Revue des données par défaut en cours

# OSCAR DOCKER

## Démo/Préprod

## Etape 1 : Récupération des sources

```bash

# Récupération du dépôt

git clone https://git.unicaen.fr/open-source/oscar.git

cd oscar

# Copie de la configuration par défaut

cp docker/.env.prod.dist .env

# Copie du composer.yml

cp docker/compose.prod.yml ./compose.yml

```

## Etape 2 : Proxy

Si vous n'êtes pas derrière un proxy, passez cette étape

```bash

# MAJ du Proxy

sed -i 's%^HTTP_PROXY=.*%HTTP_PROXY=http://votre-proxy:3128%' .env

```

## Etape 3 : Volumes

Toutes les volumes (Dossiers/Fichiers) sont référencés dans le fichier **.env**

Un script permet de vous simplifier la création de ces emplacements en se basant sur le fichier **.env** :

```bash

. docker/compose-init.sh

```

cela va créer les dossiers / copier les fichiers de configuration.

```text

demo/test/

├── config

│   ├── apache

│   ├── elasticsearch

│   │   ├── elasticsearch.yml

│   │   └── log4j2.properties

│   ├── local.php

│   ├── oscar-editable.yml

│   ├── oscar.yml

│   ├── php

│   │   ├── 90-app.ini

│   │   ├── 95-cli.ini

│   │   └── 99-debug.ini

│   ├── postgresql

│   ├── unicaen-app.local.php

│   ├── unicaen-auth.local.php

│   └── unicaen-signature.local.php

├── DoctrineORMModule

│   └── Proxy

├── documents

│   ├── activity

│   ├── pcru

│   ├── public

│   ├── request

│   └── signature

├── log

├── postgresql

│   ├── database

│   └── init

│       ├── init-database.sh

│       └── sql

│           └── 001-structure.sql

├── templates

│   ├── logo.png

│   ├── mail.phtml

│   ├── timesheet_period.default.html.php

│   └── timesheet_person_month.default.html.php

└── tmp

```

Si vous êtes en démo, tout est prêt.

## Etape 4 : Proxypass de l'hôte > container oscar

Si vous êtes en local, passez cette étape

```bash

# Activation du mod Proxy

sudo  a2enmod proxy proxy_http

# Un exemple de Vhost

sudo cp docker/host.apache.proxy.conf /etc/apache2/sites-available/000-default.conf

# Renseigner votre domaine (ou avec votre éditeur préféré)

sed -i 's%^oscar-host-name%VOTRE-NOM-DE-DOMAINE.EXT%' /etc/apache2/sites-available/000-default.conf

# Reboot apache 

sudo systemctl restart apache2

```

## Etape 5 : Lancement

```bash

sudo docker compose up

```

Vous avez un oscar fonctionnel à cette étape

- En local : http://localhost:8888

- Avec Proxypass : http://VOTRE-NOM-DE-DOMAINE.EXT

> L'application est fonctionnelle, MAIS VIDE

## Etape 6 : Données

### Données minimales (requis)

```bash

# Données de base obligatoires

docker compose exec app-worker php bin/oscar.php fixtures:import install/init-data-core.json

# Activation des 2 rôles de base obligatoires et attribution de TOUS les privilèges au compte "Administrateur"

docker compose exec app-worker php bin/oscar.php initdata:roles

```

### Accès et authentification

#### Premiers comptes

Pour accéder à l'application, vous devez vous connecter avec un compte (authentification). Pour créer un compte, 2 solutions : 

 - Se connecter via LDAP/CAS (Cela va automatiquement créer un compte)

 - Créer un compte local (Ligne de commande)

> Vous pouvez voir la liste des comptes avec la commande : 

> ```bash

> docker compose exec app-worker php bin/oscar.php auth:list 

> ```

> A cette étape, naturellement, cette liste est vide

#### Créer un compte local

```bash

docker compose exec app-worker php bin/oscar.php auth:add

```

Répondez aux différentes questions de base

#### Nommer un administrateur

```bash

docker compose exec app-worker php bin/oscar.php auth:promote

```

Dans le cadre d'une version démo, vous pouvez charger des données complémentaires qui incluent des comptes d'accès locaux, quelques comptes/personnes/structures/contracts fictifs.

```bash

. docker/docker-sync-demos-datas.sh

```

Accès : administrateur/administrateur

### Installation/build

Suivez la [procédure d'installation en production](./PROD.md)

--

-- Name: activity_num_auto(integer); Type: FUNCTION; Schema: public; Owner: -

--

CREATE FUNCTION public.activity_num_auto(activity_id integer) RETURNS text

    LANGUAGE plpgsql

    AS $$

DECLARE

activity_record activity;

year int;

	last_num text;

	num text;

	separator text := 'DRI';

	counter_val int;

BEGIN

    ------------------------------------------------------------------------------------

    -- On récupère l'activité qui va bien

SELECT * INTO activity_record FROM activity WHERE id = activity_id;

-- Err : Pas d'activité

IF activity_record IS NULL THEN

        RAISE EXCEPTION 'Activité % non trouve', activity_id;

END IF;

    -- Err : Activité déjà numérotée

    IF activity_record.oscarnum IS NOT NULL THEN

        RAISE EXCEPTION 'Cette activité (%) est déjà numérotée', activity_id;

END IF;

    -------------------------------------------------------------------------------------

    -------------------------------------------------------------------------------------

    -- Récupération du plus grand numéro précédent :

    -- On récupère l'année de l'activité (Si elle est null, on utilise l'année courante)

year := EXTRACT(YEAR FROM activity_record.dateSigned);

    IF year IS NULL THEN

        year = EXTRACT(YEAR FROM activity_record.dateCreated);

END IF;

    IF year IS NULL THEN

        year = EXTRACT(YEAR FROM CURRENT_TIMESTAMP);

END IF;

    -- On récupère le dernier numéro pour cette année

SELECT MAX(oscarNum) INTO last_num FROM activity WHERE oscarnum LIKE year || (separator ||'%');

IF last_num IS NULL THEN

        counter_val := 0;

ELSE

        counter_val := substring(last_num FROM (5 + char_length(separator)) FOR 5)::int;

END IF;

    counter_val := counter_val + 1;

    num := CONCAT(year, separator, to_char(counter_val, 'fm00000'));

UPDATE activity SET oscarNum = num WHERE id = activity_id;

RETURN num;

END;

$$;

--

-- Name: oscar_activity_numauto(); Type: FUNCTION; Schema: public; Owner: -

--

CREATE FUNCTION public.oscar_activity_numauto() RETURNS trigger

    LANGUAGE plpgsql

    AS $$DECLARE

	-- Résultat de la numérotation

	result text;

BEGIN

	IF (TG_OP = 'INSERT') THEN

SELECT * INTO result FROM activity_num_auto(NEW.id);

RETURN NEW;

END IF;

	-- Autre, osef

RETURN NULL;

END$$;

CREATE TRIGGER activity_numauto AFTER INSERT ON public.activity FOR EACH ROW EXECUTE FUNCTION public.oscar_activity_numauto();

 No newline at end of file

use Oscar\Service\Fixture\io\ActivityTypeIO;

use Oscar\Service\Fixture\io\CategoryPrivilegeIO;

use Oscar\Service\Fixture\io\CurrencyIO;

use Oscar\Service\Fixture\io\OrganizationIO;

use Oscar\Service\Fixture\io\OrganizationRoleIO;

use Oscar\Service\Fixture\io\OrganizationTypeIO;

use Oscar\Service\Fixture\io\PersonIO;

use Oscar\Service\Fixture\io\PrivilegeIO;

use Oscar\Service\Fixture\io\TvaIO;

use Oscar\Service\Fixture\io\UserRoleIO;

    const ALL = 'all';

    const CURRENCY = 'currency';

    const ORGANIZATIONS = 'organizations';

    const ORGANIZATION_TYPE = 'organization_type';

    const ORGANIZATION_ROLE = 'organization_role';

    const PERSONS = 'persons';

    const TVA = 'tva';

    const USER_ROLE = 'user_role';

    const PRIVILEGE = 'privilege';

    const CATEGORY_PRIVILEGE = 'category_privilege';

    const ACTIVITY_TYPE = 'activity_type';

    private array $keys;

            self::USER_ROLE => UserRoleIO::class,

            self::ORGANIZATION_TYPE => OrganizationTypeIO::class,

            self::ORGANIZATION_ROLE => OrganizationRoleIO::class,

//            self::CATEGORY_PRIVILEGE => CategoryPrivilegeIO::class,

//            self::PRIVILEGE => PrivilegeIO::class,

            self::ORGANIZATIONS => OrganizationIO::class,

            self::PERSONS => PersonIO::class,

        ];

    }

        $allowedKeys = self::getAllKeys();

        foreach ($fixtures as $key => $data) {

            if (!array_key_exists($key, $allowedKeys)) {

                $this->getLoggerService()->warning(

                    "La source de données inclue une clef $key qui n'est pas prise en charge, elle sera ignorée"

                );

            }

        }

        foreach ($allowedKeys as $key => $class) {

            if (array_key_exists($key, $fixtures) && in_array($key, $keys)) {

                $fixture = $fixtures[$key];

<?php

namespace Oscar\Service\Fixture\io;

use Doctrine\ORM\Exception\ORMException;

use Doctrine\ORM\OptimisticLockException;

use Doctrine\Persistence\Mapping\MappingException;

use Oscar\Entity\ActivityType;

use Oscar\Entity\Organization;

use Oscar\Entity\Person;

use Oscar\Entity\TVA;

use Oscar\Entity\Role;

class OrganizationIO extends AbstractFixtureIO

{

    /**

     * @param Organization $object

     * @param IOParameters $datas

     * @return void

     * @throws IOParametersMissingException

     */

    protected function hydrate($object, IOParameters $datas): void

    {

        $object->setCode($datas->getRequired('code'));

        $object->setShortName($datas->getRequired('shortname'));

        $object->setFullName($datas->getRequired('fullname'));

        $object->setDescription($datas->getOptional('description', ''));

        $object->setEmail($datas->getOptional('email', ''));

        $object->setCity($datas->getOptional('city', ''));

        $object->setCountry($datas->getOptional('country', ''));

    }

    protected function getIdField(): string

    {

        return "code";

    }

    protected function getClass(): string

    {

        return Organization::class;

    }

    /**

     * @param Organization $object

     * @return array

     */

    protected function extract($object): array

    {

        return [

            "code" => $object->getCode(),

            "shortname" => $object->getShortName(),

            "fullname" => $object->getFullName(),

            "description" => $object->getDescription(),

            "email" => $object->getEmail(),

            "city" => $object->getCity(),

            "country" => $object->getCountry(),

        ];

    }

}