Documentation de GeoNature-citizen

Installation de GeoNature-citizen

Prérequis

Cette documentation suppose que vous avez les bases de l’utilisation de la ligne de commande sur un serveur linux.

Dépendances

La présente documentation présente l’installation de GeoNature-citizen dans un environnement Linux Debian (version 9 et supérieures) et Ubuntu (version 18.04 et supérieures).

La procédure d’installation dépend de TaxHub, et de certains paquets, qu’il faut installer.

Commencez par installer les paquets suivants :

su # vous aurez besoin du mot de passe de l'utilisateur root
apt install sudo git python3 python3-pip python3-venv curl unzip -y

Créer un utilisateur pour l’installation

Il faut un utilisateur qui soit capable d’utiliser la commande sudo.

Créer un utilisateur appartenant au groupe sudo. Dans cette documentation, nous allons le nommer geonatadmin, mais vous pouvez remplacer cette par une autre si vous le souhaitez. Soyez juste consistant tout au long de l’installation.

su # vous aurez besoin du mot de passe de l'utilisateur root
# Création de l'utilisateur (ceci vous demandera un mot de passe)
adduser --gecos "" geonatadmin
# Ajout dans le groupe sudo
adduser geonatadmin sudo
# Connexion avec cet utilisateur
su - geonatadmin

Mettre la localisation en français

Générer les locales en_US.UTF8 et fr_FR.UTF-8 puis choisir fr_FR.UTF-8 comme locale par default:

sudo dpkg-reconfigure locales

Si le message d’erreur suivant apparait sudo: pas de tty présent et pas de programme askpass spécifié, ajoutez remplacez sudo par sudo -S.

Cette commande va afficher une liste de codes internationaux, vous pouvez naviguer avec les flèches du clavier et sélectionner une valeur avec la touche espace. Les valeurs sélectionnées ont une étoile (*) devant.

Choisissez deux valeurs: en_US.UTF8 et fr_FR.UTF-8, puis validez.

Pour valider, utilisez la touche de tabulation jusqu’à atteindre <ok> et appuyez sur la touche entrée.

Une nouvelle liste apparait, cette fois, déplacez-vous sur fr_FR.UTF-8, et sans avoir besoin de valider avec espace, tabulez jusqu’à <ok> et appuyez sur la touche entrée.

Installation de GeoNature-citizen

Récupération du code source

Téléchargez et décompressez la dernière version de l’application, disponible ici: https://github.com/PnX-SI/GeoNature-citizen/releases

# Se positionner dans le dossier par défaut de l'utilisateur (ici /home/geonatadmin)
cd ~
# Téléchargement de l'application (en remplaçant X.Y.Z par le numéro de version souhaité)
curl -OJL https://github.com/PnX-SI/GeoNature-citizen/archive/X.Y.Z.zip
# Décompression de l'application
unzip GeoNature-citizen-X.Y.Z.zip
# Renommage du dossier contenant l'application
mv GeoNature-citizen-X.Y.Z gncitizen

Installation automatique

Le script install/install_app.sh va se charger d’installer automatiquement l’environnement, PostgreSQL, TaxHub et GeoNature-citizen, ainsi que leur base de données et leur configuration Apache.

Astuce

  • Bien vérifier de ne pas être en root :
su - nom_utilisateur (geonatadmin)
  • S’assurer d’avoir le projet GeoNature-citizen dans ce dossier ainsi que d’être propriétaire du dossier et de ses dépendances
  • Se rendre dans le répertoire home de votre utilisateur
cd

Lancer le script d’installation :

cd ~/gncitizen/
./install/install_app.sh
  • Au premier lancement, le script créera un fichier de config settings.ini, il faut alors le compléter avec les informations de votre installation.
editor ./config/settings.ini
  • Relancer le script :
./install/install_app.sh

Le script crééra la base de données, configurera TaxHub si l’installation est demandée, configurera le serveur web Apache et installera toutes les dépendances du projet GeoNature-citizen.

Installation manuelle

Si vous souhaitez à une installation manuelle, suivez les instructions suivantes.

Pré-requis

Notez bien les identifiants de connexion à la base de données de Taxhub, car ils seront réutilisés ici.

Installer les dépendances python

cd ~/gncitizen/backend
# Création et activation d'un environnement virtuel
python3 -m venv venv
source venv/bin/activate
# Installation des dépendances
python3 -m pip install wheel
python3 -m pip install -r requirements.txt

Les warnings avec le message « Failed building wheel » peuvent être ignorés.

Éditer le fichier de configuration

Créer le fichier de configuration avec des valeurs par défaut :

cd ~/gncitizen/config
cp default_config.toml.template default_config.toml

Vous devez maintenant l’éditer :

nano default_config.toml

Et changer les valeurs pour correspondre à la réalité de votre installation. Faites attention à bien respecter les guillemets.

Quelques valeurs importantes :

SQLALCHEMY_DATABASE_URI

GeoNature-citizen a pour le moment des références au schéma taxonomie de TaxHub (pour l’utilisation du référentiel taxonomique TaxRef). Ce schéma doit donc être installé dans cette même base de données. L’instance de TaxHub définissant les listes d’espèces et les médias associés peut toutefois être une autre instance indépendante.

La valeur de SQLALCHEMY_DATABASE_URI doit donc être changée pour correspondre aux valeurs utilisées pour se connecter à la BDD de TaxHub.

Exemple, si on se connecte à la BDD referentielsdb, avec l’utilisateur geonatuser et le mot de passe admin123:

SQLALCHEMY_DATABASE_URI = "postgresql+psycopg2://geonatuser:admin123@127.0.0.1:5432/referentielsdb"

Référez-vous donc à la configuration de TaxHub pour saisir ce paramètre.

Les clés secrètes

Il y a 3 clés secrètes à changer : JWT_SECRET_KEY, SECRET_KEY et CONFIRM_MAIL_SALT.

Elles doivent être changées pour contenir chacune une valeur secrète différente, connue de vous seul. Vous n’aurez jamais à saisir ces valeurs plus tard, donc faites les très longues.

Pour se simplifier la vie, on peut utiliser http://nux.net/secret pour générer une valeur pour chaque clé, et simplement la copier/coller. Il suffit de recharger la page pour obtenir une nouvelle valeur.

DEBUG

À mettre sur false si on est en production.

URL_APPLICATION

L’URL que l’utilisateur final va taper dans son navigateur pour aller visiter votre instance de GeoNature-citizen. Elle doit contenir votre nom de domaine ou l’adresse IP de votre serveur.

Exemple :

http://votredomaine.com/citizen

Ou:

http://ADRESSE_IP/citizen

Notez que nous suffixons avec « citizen », ce qui n’est pas obligatoire, mais nous utiliserons cette configuration pour Apache plus loin. Quelle que soit la valeur choisie, gardez-la sous la main pour cette dernière.

EMAILS

L’inscription à GeoNature-citizen n’est pas obligatoire pour les contributeurs.

Toutefois, si un contributeur souhaite créer un compte, un email de vérification de son adresse mail lui est transmis. Cet email contient un lien permettant l’activation du compte.

Pour cela, il est nécessaire de configurer un serveur SMTP permettant l’envoi de ces emails de vérification.

La partie EMAILS est donc indispensable et il faut la remplir sans erreur.

Les entrées RESET_PASSWD et CONFIRM_EMAIL seront utilisées pour formater les emails envoyés par GeoNature-citizen. Changez au moins les deux valeurs FROM pour correspondre à votre propre email.

Pour que l’envoi fonctionne, il faut ensuite configurer la partie MAIL avec les paramètres d’envoi via SMTP de votre fournisseur d’email. Ce dernier est le seul à pouvoir vous fournir les informations nécessaires à cette configuration. Chaque valeur de cette section est importante et conditionne si l’email de confirmation va partir ou non. Vérifiez bien les fautes de frappe, et faites-vous aider par quelqu’un qui a l’habitude de configurer l’envoi d’email (via thunderbird, outlook, etc.) si vous le pouvez.

Il faut également bien renseigner la variable URL_APPLICATION qui est utilisée pour générer l’adresse du lien d’activation du compte.

Attention, Gmail peut être _particulièrement_ difficile à configurer, car il faut aller sur son compte Google pour changer les paramètres de sécurité. Utilisez un autre service si vous le pouvez.

Pour activer un compte manuellement, il est possible de lancer une inscription via le site, et, même sans recevoir l’email, de changer la valeur de la colonne active du compte utilisateur dans la table t_users. Cela peut permettre de tester le reste de l’installation même si la partie email n’est pas encore prête.

Pour essayer de comprendre pourquoi un email n’est pas envoyé, on peut regarder les erreurs présentes dans Geonature-Citizen/var/log/gn_errors.log intitulées « send confirm_email failled. »

Voici un exemple de configuration avec office365 :

[RESET_PASSWD]
  SUBJECT = "Changement de votre mot de passe"
  FROM = 'monnom@mondomaine.fr'
  TEXT_TEMPLATE = '''
  Bonjour,\r\nVoici votre nouveau mot de passe :\r\n{passwd}\r\n"{app_url}
  '''
  HTML_TEMPLATE = '''
  Bonjour,<br /><br />Voici votre nouveau mot de passe :<br />
  {passwd}
  <br /><br />"
  <a href="{app_url}">Connexion</a>'
  '''


[CONFIRM_EMAIL]
  SUBJECT = "Activez votre compte"
  FROM = 'monnom@mondomaine.fr'
  HTML_TEMPLATE = '''<p> Bonjour,</p><br /><p>Nous vous confirmons que votre compte a bien été créé.</p>
   <p> Afin d'activer votre compte veuillez <a href="{activate_url}">cliquer ici.</a>
   <p>Nous vous souhaitons la bienvenue sur notre site.</p><br />
   <p>Bien à vous.</p>
  '''


[MAIL]
  MAIL_USE_SSL = false
  MAIL_HOST = 'smtp.office365.com'
  MAIL_PORT = 587   # mandatory SSL port
  MAIL_AUTH_LOGIN = 'monnom@mondomaine.fr'
  MAIL_AUTH_PASSWD = 'monmotdepasse'
  MAIL_STARTTLS = true
API_ENDPOINT

L’URL que va utiliser GeoNature-citizen pour exposer ses données. Cette valeur doit commencer comme URL_APPLICATION, mais finir par /api et utiliser le même port que définit par API_PORT (5002 par défaut, vous n’avez probablement pas besoin de le changer).

Exemple :

http://votredomaine.com:5002/citizen/api

Gardez cette valeur sous la main, nous l’utiliserons dans la configuration Apache plus loin.

Authentification Mapbox

Si vous avez des identifiants Mapbox, inscrivez-les dans MAPBOX_MAP_ID et MAPBOX_ACCESS_TOKEN. Ils sont utilisés pour afficher des fonds de carte dans la partie administration des programmes.

Installation du backend et de la base des données

Création du référentiel des géométries communales

On continue d’utiliser les identifiants de la BDD de TaxHub, ici avec les exemples referentielsdb et geonatuser.

Téléchargez les données SQL depuis le dépôt de GeoNature:

wget https://github.com/PnX-SI/GeoNature/raw/master/data/core/public.sql -P /tmp
wget https://github.com/PnX-SI/GeoNature/raw/master/data/core/ref_geo.sql -P /tmp
wget https://github.com/PnX-SI/GeoNature/raw/master/data/core/ref_geo_municipalities.sql -P /tmp

Pour importer les données dans la BDD, munissez-vous du mot de passe que vous avez choisi lors de la création de celle-ci, puis (dans cet exemple, on utilise le système de coordonnées avec le SRID 2154) :

sudo su postgres # les extensions doivent être ajoutées par un admin
psql -d referentielsdb -c "CREATE EXTENSION postgis;"
exit
psql -d referentielsdb -h localhost -p 5432 -U geonatuser -f /tmp/public.sql
# Choix du SRID ici
sed 's/MYLOCALSRID/2154/g' /tmp/ref_geo.sql > /tmp/ref_geo_2154.sql
psql -d referentielsdb -h localhost -p 5432 -U geonatuser -f /tmp/ref_geo_2154.sql

Si les communes françaises ne sont pas déjà dans la base, les importer :

wget  --cache=off http://geonature.fr/data/ign/communes_fr_admin_express_2019-01.zip -P /tmp
unzip /tmp/communes_fr_admin_express_2019-01.zip -d /tmp/
psql -d referentielsdb -h localhost -p 5432 -U geonatuser -f /tmp/fr_municipalities.sql
psql -d referentielsdb -h localhost -p 5432 -U geonatuser -c "ALTER TABLE ref_geo.temp_fr_municipalities OWNER TO geonatuser;"
sed -i "s/, geojson\w*//g" /tmp/ref_geo_municipalities.sql
psql -d referentielsdb -h localhost -p 5432 -U geonatuser -f /tmp/ref_geo_municipalities.sql
psql -d referentielsdb -h localhost -p 5432 -U geonatuser -c "DROP TABLE ref_geo.temp_fr_municipalities;"
Générer les schémas de GeoNature-citizen

Il faut maintenant faire au moins une requête au serveur pour le forcer à créer les tables dont il a besoin.

Lancement du backend pour générer les schémas :

# assurez vous de bien être toujours connecté en tant que geonatadmin
# avec le venv activé avant de lancer cette étape
sudo chown geonatadmin:geonatadmin /home/geonatadmin/gncitizen/ -R
cd ~/gncitizen/backend
export FLASK_ENV=development; export FLASK_DEBUG=1; export FLASK_RUN_PORT=5002; export FLASK_APP=wsgi;
nohup python -m flask run --host=0.0.0.0 > /dev/null 2>&1 &
serverPID=$!
sleep 1 && wget http://127.0.0.1:5002/ # ceci devrait renvoyer 404: NOT FOUND.
kill $serverPID

Enregistrement du module principal :

psql -d referentielsdb -h localhost -p 5432 -U geonatuser -c "insert into gnc_core.t_modules values (1, 'observations', 'observations', 'observations', NULL, false, now(), now());"

Vous pouvez créer un programme test avec la ligne de commande suivante :

psql -d referentielsdb -h localhost -p 5432 -U geonatuser -c "INSERT INTO gnc_core.t_programs VALUES (1, 'Au 68', 'inventaire  du 68', 'desc', NULL,  NULL, 1,  100,  't', '0106000020E6100000010000000103000000010000000500000001000070947C154042CA401665A5454001000070EE7C15402235D7E667A54540010000D81C7D1540AFBA27365AA5454000000040C47C1540DD9BD74A58A5454001000070947C154042CA401665A54540',  now(), now());"

Celui-ci suppose l’existence d’une liste de taxons dont l’ID est 100, qui normalement existe sur TaxHub par défaut. Remplacez la valeur 100 par une liste existante si ce n’est pas le cas, ou créez une liste avec cet ID sur TaxHub.

Mettre en place le système de badge

mkdir ~/gncitizen/media
cp -v ~/gncitizen/frontend/src/assets/badges_* ~/gncitizen/media/

Vous pouvez aussi optionnellement modifier le fichier ~/gncitizen/config/badges_config.py pour changer les noms, images et nombre d’observations minimum pour obtenir les badges, par programme.

Lancement du service

D’abord, créez un fichier de configuration supervisor (sudo nano /etc/supervisor/conf.d/geonature-citizen-service.conf) qui va contenir ceci :

[program:citizen]
command=/home/geonatadmin/gncitizen/backend/start_gunicorn.sh
user=geonatadmin
autostart=true
autorestart=true
stdout_logfile=/var/log/supervisor/citizen.log
redirect_stderr=true

Puis lancez le chargement du service :

sudo chown geonatadmin:geonatadmin ~/gncitizen/ -R
sudo supervisorctl reload

Installation du frontend

Installer l’environnement javascript
cd ~/gncitizen/frontend/
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash
source ~/.bashrc
nvm install
npm install
Éditer la conf et les fichiers de personnalisation

De nombreux fichiers peuvent être configurés ou personnalisés côté frontend. Ils sont nommés avec l’extension .template, et il est nécessaire de les copier une fois sans cette extension pour avoir des fichiers de base sur lesquels travailler :

cd ~/gncitizen/frontend/
find . -iname "*.template" -exec bash -c 'for x; do cp -n "$x" "${x/.template/}"; done' _ {} +

Ces commandes vont créer les fichiers de configuration comme :

src/conf/app.config.ts # configuration du front ends: URL, ports, messages, etc
src/conf/map.config.ts # tiles de carte

Une modification courante est de changer details_espece_url dans app.config.ts pour faire pointer l’adresse vers un autre service. Attention à garder cd_nom à la fin.

Il y a aussi des feuilles de style qui permettent de personnaliser la mise en page de certaines pages :

src/custom/custom.css # tout le site
src/custom/footer/footer.css # pied de page
src/custom/home/home.css # acceuil
src/custom/about/about.css # à propos

Et des patrons HTML qui permettent de changer le contenu de certaines pages :

src/custom/about/about.html # a propos
src/custom/footer/footer.html # pied de page
src/custom/home/home.html # accueil

Vous pouvez modifier ces fichiers, leur contenu apparaitra sur le site.

Servir l’application en mode monopage
Faire le build du code du frontend

Après chaque modification sur un des éléments qui concerne le frontend, il faut relancer le processus de build :

cd ~/gncitizen/frontend/
npm run ng build -- --prod

Si vous souhaitez que l’application soit disponible depuis un chemin spécifique (ex: mondomaine.org/citizen), remplacez la dernière commande par

npm run ng build -- --prod --base-href=/citizen/
Configuration d’Apache

Voici un exemple de fichier de configuration Apache, qu’il faudra adapter à votre cas d’usage. Si vous souhaitez que l’application soit disponible depuis un chemin spécifique (ex: mondomaine.org/citizen), pensez à décommenter la ligne Alias

<VirtualHost *:80>

  ServerName mondomaine.org
  # Les logs sont sockés dans /var/log/apache2
  ErrorLog ${APACHE_LOG_DIR}/error.log
  CustomLog ${APACHE_LOG_DIR}/access.log combined

  # Les fichiers statiques tels que les images, le js et le css sont servis
  # via 4 routes:
  # - / -> ./frontend/dist/browser/, Ex: /index.html
  # - /assets/ -> ./frontend/dist/browser/assets, Ex: /assets/default_program.jpg
  # - /citizen/api/media/ (apache) -> ./frontend/dist/browser/assets, Ex: /citizen/api/media/logo.png
  # - /citizen/api/media/ (served by python) -> ./media/, Ex: /api/media/obstax_60612_1_20200822_125238.png
  # Le fichier essaye donc d'accomoder ces routes

  # Tout ce qui arrive sur / va dans DocumentRoot, et donc tous les fichiers
  # statiques sont par défaut pris dans ce dossier
  DocumentRoot /home/geonatadmin/gncitizen/frontend/dist/browser/
  # Si vous souhaitez que l'application soit disponible depuis un chemin spécifique (ex: `mondomaine.org/citizen`), décommentez la ligne suivante
  #Alias /citizen "/home/geonatadmin/gncitizen/frontend/dist/browser/"

  <Directory /home/geonatadmin/gncitizen/frontend/dist/browser/>
      Require all granted
  </Directory>

  # si aucun fichier n'est demandé, servir index.html
  FallbackResource /index.html
  ErrorDocument 404 /index.html

  # Les demandes qui arrivent sur /citizen/api/media/ peuvent correspondre soit
  # à un fichier dans le dossier assets, soit à un une demande de fichier à l'API.
  # Dans un premier temps, on vérifie que le fichier existe dans assets, et si
  # oui, on réécrit l'URL pour le servir.
  RewriteEngine on
  RewriteCond "%{DOCUMENT_ROOT}/assets/$1" -f
  RewriteRule "^/citizen/api/media/(.*)" "/assets/$1"

  # Si on arrive ici, c'est qu'il n'existe pas de fichier dans assets portant
  # ce nom, dans ce cas on redirige tout vers l'API

  # Les ports utilisés pour ces 3 Locations doivent correspondre aux ports
  # utilisés par ces services.

  <Location /citizen/api>
    ProxyPass http://127.0.0.1:5002/api retry=0
    ProxyPassReverse  http://127.0.0.1:5002/api
  </Location>

  # La suite de la configuration ne concerne plus les fichiers statiques
  # mais passe simplement les requêtes à un des 3 services

  # Chemin de taxhub
  <Location /taxhub>
  ProxyPass  http://127.0.0.1:5000/ retry=0
  ProxyPassReverse  http://127.0.0.1:5000/
  </Location>


</VirtualHost>

Ce fichier se met dans sites-available, par exemple /etc/apache2/sites-available/citizen.conf. Il faut ensuite faire un lien symbolique vers sites-enabled :

sudo a2ensite citizen.conf

On vérifie la configuration d’Apache :

sudo apachectl -t

Si tout est OK, alors on redémarre le service Apache :

sudo service apache2 restart
Servir l’application en mode rendu côté serveur (SSR = Server side rendering)
Installer l’application pm2 pour créer un service permanent

PM2 permet de lancer une application Javascript en tâche de fond.

cd ~/gncitizen/frontend
nvm use
npm install -g pm2
Faire le build du code du frontend en mode SSR et créer un service pour le frontend

Après chaque modification sur un des éléments qui concerne le frontend, il faut relancer le processus de build :

npm run build:i18n-ssr && npm run serve:ssr

Puis lancer le service pour le mode SSR

pm2 start dist/server.js --name gncitizen
pm2 save
Configuration d’Apache

Voici un exemple de fichier de configuration Apache, qu’il faudra adapter à votre cas d’usage.

<VirtualHost *:80>

  ServerName mondomaine.org
  # Les logs sont sockés dans /var/log/apache2
  ErrorLog ${APACHE_LOG_DIR}/error.log
  CustomLog ${APACHE_LOG_DIR}/access.log combined

  # Les fichiers statiques tels que les images, le js et le css sont servis
  # via 4 routes:
  # - / -> ./frontend/dist/browser/, Ex: /index.html
  # - /assets/ -> ./frontend/dist/browser/assets, Ex: /assets/default_program.jpg
  # - /citizen/api/media/ (apache) -> ./frontend/dist/browser/assets, Ex: /citizen/api/media/logo.png
  # - /citizen/api/media/ (served by python) -> ./media/, Ex: /api/media/obstax_60612_1_20200822_125238.png
  # Le fichier essaye donc d'accomoder ces routes

  # Tout ce qui arrive sur / va dans DocumentRoot, et donc tous les fichiers
  # statiques sont par défaut pris dans ce dossier

  # Les demandes qui arrivent sur /citizen/api/media/ peuvent correspondre soit
  # à un fichier dans le dossier assets, soit à un une demande de fichier à l'API.
  # Dans un premier temps, on vérifie que le fichier existe dans assets, et si
  # oui, on réécrit l'URL pour le servir.
  RewriteEngine on
  RewriteCond "%{DOCUMENT_ROOT}/assets/$1" -f
  RewriteRule "^/citizen/api/media/(.*)" "/assets/$1"

  # Si on arrive ici, c'est qu'il n'existe pas de fichier dans assets portant
  # ce nom, dans ce cas on redirige tout vers l'API

  # Les ports utilisés pour ces 3 Locations doivent correspondre aux ports
  # utilisés par ces services.

  # Chemin de GeoNature-citizen (frontend)
  <Location />
    ProxyPass http://127.0.0.1:4000/ retry=0
    ProxyPassReverse  http://127.0.0.1:4000/
  </Location>


  # Chemin de GeoNature-citizen (API)
  <Location /citizen/api>
    ProxyPass http://127.0.0.1:5002/api retry=0
    ProxyPassReverse  http://127.0.0.1:5002/api
  </Location>


  # La suite de la configuration ne concerne plus les fichiers statiques
  # mais passe simplement les requêtes à un des 3 services


  # Chemin de l'interface web de taxhub
  <Location /taxhub>
  ProxyPass  http://127.0.0.1:5000/ retry=0
  ProxyPassReverse  http://127.0.0.1:5000/
  </Location>

</VirtualHost>

Ce fichier se met dans sites-available, par exemple /etc/apache2/sites-available/citizen.conf. Il faut ensuite faire un lien symbolique vers sites-enabled :

sudo a2ensite citizen.conf

On vérifie la configuration d’Apache :

sudo apachectl -t

Si tout est OK, alors on redémarre le service Apache :

sudo service apache2 restart
Sécuriser l’interface d’administration

L’interface d’administration de GeoNature-citizen n’est par défaut pas sécurisée. Sa sécurisation passe par une configuration spécifique du serveur Apache2.

mkdir -p /etc/apache2/passwd
htpasswd -c /etc/apache2/passwd/gncitizen admin

Puis ajouter les lignes suivantes dans la configuration Apache2 du site (nano /etc/apache2/sites-available/citizen.conf), après le bloc <Location /citizen/api>...</Location>.

# Sécurisation du chemin du backoffice
<Location /citizen/api/admin>
AuthType Basic
AuthName "Restricted Area"
AuthBasicProvider file
AuthUserFile "/etc/apache2/passwd/gncitizen"
Require user admin
</Location>

Renseigner les fichiers de configuration

Modifier le fichier de configuration

Côté backend

Les fichiers de configuration sont dans le dossier config. Le fichier à modifier est default_config.toml. Le fichier utilisé par GeoNature-citizen est default_config.toml. Il peut-être créé en copiant le fichier default_config.toml.example vers default_config.toml:

$ cp default_config.toml.example default_config.toml

Editez alors les différents paramètres de ce fichier.

# Database
SQLALCHEMY_DATABASE_URI = "postgresql+psycopg2://geonatuser:monpassachanger@127.0.0.1:5432/geonaturedb"
SQLALCHEMY_TRACK_MODIFICATIONS = false

# JWT Auth
JWT_SECRET_KEY = 'jwt-secret-string'
JWT_BLACKLIST_ENABLED = true
JWT_BLACKLIST_TOKEN_CHECKS = ['access', 'refresh']

# Application
appName = 'GeoNature-citizen'                               # Application name in the home page
DEFAULT_LANGUAGE = 'fr'

# Debug
DEBUG = true
SQLALCHEMY_DEBUG_LEVEL = 'WARNING'

URL_APPLICATION = 'http://url.com/gncitizen'         # Replace my_url.com by your domain or IP
API_ENDPOINT = 'http://url.com:API_PORT/gncitizen/api'        # Replace my_url.com by your domain or IP
API_PORT = 5002 # 5000 déjà utilisé par taxhub
API_TAXHUB ='http://127.0.0.1:5000/api/'

# FlaskAdmin
# credentials for loading map tiles from mapbox
MAPBOX_MAP_ID = '...'
MAPBOX_ACCESS_TOKEN = '...'
DEFAULT_CENTER_LAT = 45
DEFAULT_CENTER_LONG = 5


SECRET_KEY = 'MyS3cr3tK3y'
CONFIRM_MAIL_SALT = 'your-secret-salt' # secret salt for corfirm mail token

MEDIA_FOLDER = 'media'


[RESET_PASSWD]
    SUBJECT = "Link"
    FROM = 'contact@geonature-citizen.fr'
    TEXT_TEMPLATE = '''
    Bonjour,\r\nVoici votre nouveau mot de passe :\r\n{passwd}\r\n"{app_url}
    '''
    HTML_TEMPLATE = '''
    Bonjour,<br /><br />Voici votre nouveau mot de passe :<br />
    {passwd}
    <br /><br />"
    <a href="{app_url}">Connexion</a>'
    '''

[CONFIRM_EMAIL]
    SUBJECT = "Activez votre compte"
    FROM = 'contact@geonature-citizen.fr'
    HTML_TEMPLATE = '''<p> Bonjour,</p><br /><p>Nous vous confirmons que votre compte a bien été créé.</p>
    <p> Afin d'activer votre compte veuillez <a href="{activate_url}">cliquer ici.</a>
    <p>Nous vous souhaitons la bienvenue sur notre site.</p><br />
    <p>Bien à vous.</p>
    '''

[MAIL]
    MAIL_USE_SSL = false
    MAIL_STARTTLS = true
    MAIL_HOST = 'smtpd host'
    MAIL_PORT = 493   # mandatory SSL port
    MAIL_AUTH_LOGIN = 'smtpd/relay host username'
    MAIL_AUTH_PASSWD = 'smtpd/relay host password'


# API flasgger main config
[SWAGGER]
    title = 'GeoNature-Citizen API'
    version = 'x.x.x'
    produces = ["application/json"]
    consumes = ["application/json"]

Côté frontend

Les fichiers de configuration du frontend se trouvent dans le dossier ./frontend/src/conf

Les fichiers à créer sont app.config.ts et map.config.ts. Il sont créés lors de l »installation ou en copiant les fichiers app.config.ts.sample vers app.config.ts et map.config.ts :

$ cp app.config.ts.template app.config.ts
$ cp map.config.ts.template map.config.ts

Editez alors les différents paramètres de ce fichier.

export const AppConfig = {
    appName: "GeoNature-citizen",
    API_ENDPOINT:"http://localhost:5002/api",
    API_TAXHUB:"http://localhost:5000/api",
    FRONTEND:{
        PROD_MOD:true,
        MULTILINGUAL:false,
        DISPLAY_FOOTER: true,
        DISPLAY_TOPBAR: false,
        DISPLAY_SIDEBAR: true,
        DISPLAY_STATS: true,
    },
    about: true,
    URL_APPLICATION:"http://127.0.0.1:4200",
    REWARDS: true,
    termsOfUse: {
    fr: "assets/cgu.pdf",
    en: "assets/termsOfUse.pdf"
    },
    signup:true,
    email_contact:false,
    platform_intro: {
    fr: "Bienvenue<br /> sur GeoNature Citizen",
    en: "Welcome<br /> on GeoNature Citizen"
    },
    platform_teaser: {
    fr: "Hae duae provinciae bello quondam piratico catervis mixtae praedonum a Servilio pro consule missae sub iugum factae sunt vectigales. et hae quidem regiones velut in prominenti terrarum lingua positae ob orbe eoo monte Amano disparantur.",
    en: "Hae duae provinciae bello quondam piratico catervis mixtae praedonum a Servilio pro consule missae sub iugum factae sunt vectigales. et hae quidem regiones velut in prominenti terrarum lingua positae ob orbe eoo monte Amano disparantur."
    },
    platform_participate: {
    fr: "PARTICIPER AU PROGRAMME",
    en: "PARTICIPATE"
    },
    program_share_an_observation: {
    fr: "PARTAGER UNE OBSERVATION",
    en: "SHARE AN OBSERVATION"
    },
    program_add_an_observation: {
    fr: "AJOUTER UNE OBSERVATION",
    en: "CONTRIBUTE AN OBSERVATION"
    },
    program_allow_email_contact: {
    fr: "J'accepte que mon adresse e-mail puisse être utilisée pour recontacter à propos de mon observation",
    en : "I agree that my e-mail address can be used to recontact about my observation"
    },
    taxonSelectInputThreshold: 7,
    taxonAutocompleteInputThreshold: 12,
    taxonAutocompleteFields: [
    "nom_complet",
    "nom_vern",
    "nom_vern_eng",
    "cd_nom"
    ],
    program_list_observers_names: true,
    program_list_sort: "-timestamp_create",
    details_espece_url: "<url_inpn_or_atlas>/cd_nom/" // !! gardez bien le cd_nom/ dans l'url
}

export const MAP_CONFIG = {
DEFAULT_PROVIDER: "OpenStreetMapOrg",
BASEMAPS: [
    {
    name: "OpenStreetMapOrg",
    maxZoom: 19,
    layer: "//{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
    subdomains: "abc",
    attribution:
        '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, Tiles style by <a href="https://www.hotosm.org/" target="_blank">Humanitarian OpenStreetMap Team</a> hosted by <a href="https://openstreetmap.fr/" target="_blank">OpenStreetMap France</a>'
    },
    {
    name: "OpenTopoMap",
    maxZoom: 17,
    layer: "//{s}.opentopomap.org/{z}/{x}/{y}.png",
    subdomains: "abc",
    attribution: "© OpenTopoMap"
    },
    {
    name: "IGN Vue satellite",
    maxZoom: 17,
    layer: "https://wxs.ign.fr/{apiKey}/geoportail/wmts?&REQUEST=GetTile&SERVICE=WMTS&VERSION=1.0.0&STYLE=normal&TILEMATRIXSET=PM&FORMAT=image/jpeg&LAYER={layerName}&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}",
    layerName: "ORTHOIMAGERY.ORTHOPHOTOS",
    // Remplacer "pratique" par votre clé IGN
    apiKey: 'pratique',
    subdomains: "abc",
    attribution: "© IGN-F/Geoportail"
    },
    {
    name: "IGN Cartes",
    maxZoom: 17,
    layer: "https://wxs.ign.fr/{apiKey}/geoportail/wmts?&REQUEST=GetTile&SERVICE=WMTS&VERSION=1.0.0&STYLE=normal&TILEMATRIXSET=PM&FORMAT=image/jpeg&LAYER={layerName}&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}",
    layerName: "GEOGRAPHICALGRIDSYSTEMS.MAPS",
    // Remplacer "pratique" par votre clé IGN
    apiKey: 'pratique',
    subdomains: "abc",
    attribution: "© IGN-F/Geoportail"
    },
],
CENTER: [46.52863469527167, 2.43896484375],
ZOOM_LEVEL: 6,
ZOOM_LEVEL_RELEVE: 15,
NEW_OBS_POINTER: "assets/pointer-blue2.png",
OBS_POINTER: "assets/pointer-green.png"
}

Configuration des badges

Types de récompense:

  • seniority: ancienneté d’inscription sur la plateforme
  • all_attendance: nombre d’observations totales réalisées sur la plateforme
  • program_Attendance: nombre d’observations totales réalisées par programme
  • recognition: identification d’espèces

niveaux de récompense:

  • min_obs: nombre d’observations minimum pour obtenir le badge
  • min_date: date minimum pour obtenir le badge

Configuration de récompense:

  • type: type de récompense (exemple Seniority)
  • reward_label label de la récompense ( a afficher du coté forntend)
  • id_program: identifant du programme ( 0 pour les récompenses géneral)
  • badges: tableau des badges par type de récompense

Pour les récompenses de type recognition il faut renseigner soit la classe ou la famille du taxref

Le fichier à configurer est le badges_config.py situé dans le dossier config

Ex : https://github.com/PnX-SI/GeoNature-citizen/blob/dev/config/badges_config.py

notes:Pour plus d’informations voir : https://github.com/PnX-SI/GeoNature-citizen/issues/7

Installer GeoNature-citizen en mode développement

Avertissement

GeoNature-citizen nécessite l’installation préalable de TaxHub > https://taxhub.readthedocs.io/fr/latest/

Contribuer avec GitHub

Avertissement

Aucun commit n’est réalisé directement sur le dépot principal du projet (https://github.com/PnX-SI/GeoNature-citizen). Pour contribuer, il est nécessaire de faire un fork du projet, de travailler sur ce fork et de proposer des mises à jour du dépot principal par pull request.

Faire un fork du projet

Tout est ici

Cloner le projet

Dans un terminal:

$ git clone git@github.com:YOUR_NAME/GeoNature-citizen.git

Cloning into `GeoNature-citizen`...
remote: Counting objects: 10, done.
remote: Compressing objects: 100% (8/8), done.
remove: Total 10 (delta 1), reused 10 (delta 1)
Unpacking objects: 100% (10/10), done.
Récupérer les mises à jour du dépot principal

Dans un terminal, dans le dossier cloné:

$ git remote add upstream git@github.com:PnX-SI/GeoNature-citizen.git

Pour vérifier que votre clone local puisse suivre votre dépot (origin) et le dépot principal (upstream):

$ git remove -v

origin      git@github.com:YOUR_NAME/GeoNature-citizen.git (fetch)
origin      git@github.com:YOUR_NAME/GeoNature-citizen.git (push)
upstream    git@github.com:PnX-SI/GeoNature-citizen.git (fetch)
upstream    git@github.com:PnX-SI/GeoNature-citizen.git (push)
Créer votre propre branche de développement

Pour créer votre branche de développement, dans un terminal:

$ git checkout -b dev_mabranche

Configurer et installer la base de données

GeoNature-citizen s’appuie sur le serveur de base de données spatiales PostgreSQL et son extension spatiale PostGIS.

Installer le serveur

Pour installer le serveur de base de données, suiviz les instructions du site officiel PostgreSQL Downloads:

Concrètement, sur Debian stretch:

sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ stretch-pgdg main" >> /etc/apt/sources.list.d/postgresql.list'
sudo wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
sudo apt update
sudo apt install postgresql-10 postgresql-10-postgis-2.5 postgresql-10-postgis-2.5-scripts git

Configurer la base de données

Création du role principal

Pour créer la base de données spatiale. On considèrera ici que l’utilisateur de la base de données sera dbuser, renseignez alors le mot de passe de l’utilisateur lorsqu’il vous sera demandé :

sudo -u postgres createuser -e -E -P dbuser

Créez la base de données, ici nommée geonaturedb appartenant à l’utilisateur dbuser:

Création de la base de données et des extensions
sudo -u postgres createdb -e -E UTF8 -O dbuser geonaturedb

Activez les extensions postgis pour la gestion des données spatiales et uuid-ossp pour la gestion des uuid. Seul un superutilisateur peut activer les extensions (ici, l’utilisateur postgres, installé par défaut) :

sudo -u postgres psql geonaturedb -c 'create extension postgis; create extension "uuid-ossp";'

Votre serveur de base de données est maintenant opérationel.

Configurer et lancer le backend

Installer l’environnement virtuel python

La création de l’environnement virtuel python3 nécessite virtualenv ou pyenv ou tout autre outil équivalent (ex: pyenv):

cd backend
sudo apt install python3-pip
python3 -m pip install --upgrade --user virtualenv
export PATH=/home/geonatadmin/.local/bin:$PATH
virtualenv -p /usr/bin/python3 venv

L’activation de cet environnement se fait avec la commande suivante:

source venv/bin/activate

Et l’installation des librairies nécessaires à GeoNature-citizen avec la commande suivante:

python3 -m pip install -r requirements.txt

Lancer le backend

Pour lancer l’application Backend, il suffit d’éxécuter les commandes suivantes depuis l’environnement virtuel python:

cd backend
source venv/bin/activate

cd ../config
cp default_config.toml.example default_config.toml

python -m wsgi.py
# debug mode
# export FLASK_ENV=development; export FLASK_DEBUG=1; export FLASK_RUN_PORT=5002; export FLASK_APP=wsgi; python -m flask run --host=0.0.0.0

Vous pouvez alors aller sur la page de documentation de l’API à l’adresse suivant http://VOTRE_HOTE:5002/apidocs, en local, ce sera http://localhost:5002/apidocs.

Configurer et lancer le frontend

Installer l’environnement virtuel NodeJS avec nvm

L’installation de nvm se fait en suivant les instructions du dépot principal de l’outil nvm par creationix creationix/nvm.

Une fois l’environnement installé, installer la dernière version stable de nodejs:

nvm install v10.16

Pour utiliser cette version:

nvm use v10.16

Installer angular CLI (version LTS 6) et les dépendances requises:

npm install -g @angular/cli@v8-lts
npm install

Lancer du frontend

Vous pouvez lancer le frontend dans deux modes:

En mode développement et client-side rendering:
ng serve
En mode Server Side Rendering, optimisé pour le SEO et réservé aux robots d’indexation:
npm run build:ssr && npm run serve:ssr

Gestion du Server Side Rendering

Le SSR a été intégré au projet à partir de la commande :

npm run ng add @nguniversal/express-engine --clientProject frontend

NB: L’intégration Leaflet.MarkerCluster a nécessité de déclarer une variable globale L et d’y importer Leaflet; c’est dans le script server.ts.

Les modules BrowserTransferState et ServerTransferState importés, nous avons créé un couple {clé: valeur} pour être transféré du serveur au client.

La clé est créée avec la fonction factory makeStateKey :

const PROGRAMS_KEY = makeStateKey("programs");

Le transfert d’état s’effectue avec accesseur et mutateur:

this.programs = this.state.get(PROGRAMS_KEY, null as any);
if (!this.programs) {
  /*
    code exécuté côté serveur Node, express
    qui effectue donc un appel à l'API de GN-Citizen
    et génère une capture d'état
  */

  this.state.set(PROGRAMS_KEY, programs as any);
} else {
  /*
    code exécuté côté présentation qui consomme l'état "cristallisé"
    transféré depuis le serveur.
  */
}

La redirection de port pourrait se faire au niveau du serveur web / reverse proxy, avec un filtre sur l’entête de requête User-Agent

Gestion de l’internationalisation (i18n)

La fonctionnalité i18n a été intégrée avec @ngx-i18nsupport.

L’interface est paramétrée par défaut en langue française.

Mettre à jour les traductions

La commande suivante met à jour les fichiers de traduction (ajout/suppression de traductions symbolisées par l’argument i18n dans les templates.

npm run extract-i18n

Les fichiers de traduction sont dans le répertoire frontend/src/i18n.

Mettre à jour les nouvelles traductions (texte dans les balises <target></target> des fichiers localisés messages.fr.xlf et messages.en.xlf.

Déploiement

Préparer la distribution avec:

npm run ng build -- --prod

ou:

npm run ng build -- --configuration=en --prod

pour une version en langue anglaise.

Tout est contenu dans le répertoire frontend/dist, qu’il faut copier sur la plateforme acceuillant le service.

Annexe:

Exemple de fichier de configuration serveur Apache2:

/etc/apache2/sites-enabled/citizen.conf

# Configuration GeoNature-citizen
Alias /citizen /home/utilisateur/citizen/frontend/dist/browser

<Directory /home/utilisateur/citizen/frontend/dist/browser>
  Require all granted
  AllowOverride All

  <IfModule mod_rewrite.c>
      Options -MultiViews

      RewriteEngine On
        RewriteCond %{REQUEST_FILENAME} !-d
        RewriteCond %{REQUEST_FILENAME} !-f
          RewriteRule ".*" "index.html" [QSA,L]
  </IfModule>

</Directory>
<Location /citizen/api>
  ProxyPass http://127.0.0.1:5002/api
  ProxyPassReverse  http://127.0.0.1:5002/api
</Location>
Suivi des journaux d’évenements et d’erreurs:
Backend:
tail -f /var/log/supervisor/citizen.log
Gunicorn (option de gestion de processus pour lancer le backend):
tail -f ~/citizen/var/log/gn_errors.log
Apache:
sudo tail -f /var/log/apache2/{error,access,other_vhosts_access}.log
Utiliser PgAdmin pour la gestion de la BDD distante (production):

~/.ssh/config

Se logguer en SSH (ssh nom_du_raccourci) sur l’hôte distant va opérer une redirection de port et rendre la BDD distante accessible sur le port local 5433 pour un client PostgreSQL.

Il suffit alors d’ajuster les paramètres de psql en CLI ou ceux de l’assistant de configuration de PgAdmin pour son interface graphique.

Installation de GeoNature-citizen

Prérequis

Application développée et installée sur un serveur Debian 9.

Ce serveur doit aussi disposer de :

  • sudo (apt-get install sudo)
  • un utilisateur (monuser dans cette documentation) appartenant au groupe sudo (pour pouvoir bénéficier des droits d’administrateur)

1. Créer un utilisateur Debian :

adduser nom_utilisateur (geonatadmin) entrez un mot de passe (****)
usermod -aG sudo nom_utilisateur (geonatadmin)
su - nom_utilisateur (geonatadmin)

2. Vérifier que l’utilisateur est correctement créé :

sudo -l (entrez un mot de passe) : vérifier que ALL
sudo whoami : ok si on peut faire un sudo

3. Changer la locale en fr (il faut être root) :

sudo dpkg-reconfigure locales

INSTALLATION Automatique

notes:
  • Bien vérifier de ne pas être en root :
su - nom_utilisateur (geonatadmin)
  • S’assurer d’avoir le projet Geonature-citizen dans ce dossier ainsi que d’etre propriétaire du dossier et de ses dépendances
  • Se rendre sur la Home de votre utilisateur
cd

Lancer le script d’installation :

./install/install_app.sh
  • Le script créera un fichier de config settings.ini, il faut alors le compléter avec les informations de votre installation.
editor ./config/settings.ini
  • Complétez également les fichiers de config Apache situés dans config/apache
  • Relancer le script :
./install/install_app.sh

Le script crééra la base de données, configurera taxhub si l’installation est demandée, configurera apache et installera toutes les dépendances du projet Geonature-Citizen.

INSTALLATION DE TAXHUB

Pour plus de détails, lien officiel pour l’installation de TaxHub : https://taxhub.readthedocs.io/fr/latest/

Configurer le serveur : https://taxhub.readthedocs.io/fr/latest/serveur.html#installation-et-configuration-du-serveur

Configurer PostgreSQL : https://taxhub.readthedocs.io/fr/latest/serveur.html#installation-et-configuration-de-posgresql

Configuration et installation de l’application : https://taxhub.readthedocs.io/fr/latest/installation.html

notes:
  • Bien vérifier de ne pas être en root :
su - nom_utilisateur (geonatadmin)
  • Pour avoir les caractéristiques de votre instance :
lsb_release -a
uname -a

INSTALLATION DE GEONATURE-CITIZEN

Etape 1 : Configurer PostgreSQL :

notes: 
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ stretch-pgdg main" >>/etc/apt/sources.list.d/postgresql.list'
sudo wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add
sudo apt update
sudo apt install postgresql-10 postgresql-10-postgis-2.5 postgresql-10-postgis-2.5-scripts git
sudo -u postgres createuser -e -E -P dbuser (geonatadmin) (Entrez le password)
sudo -u postgres createdb -e -E UTF8 -O dbuser (geonatadmin) dbname (geonature2db)
notes:
  • ls /etc/init.d/ : pour lister les services
  • sudo service restart postgresql : vérification

Etape 2 : Installer python3, pip et virtualenv :

python3 -m pip install --upgrade --user virtualenv
sudo apt install python3-pip

installer virtualenv :

export PATH=/home/username/.local/bin:$PATH (username = geonatadmin)
echo $PATH
virtualenv -p /usr/bin/python3 venv
source venv/bin/activate

Etape 3 : Installation du backend et de la base des données :

notes:

Cloner le dépôt Github de GeoNature-citizen

sudo apt install git
git clone name (citizen)
git checkout branch_name
cd citizen/backend

Création du référentiel des géométries communales :

wget https://github.com/PnX-SI/GeoNature/raw/master/data/core/public.sql -P /tmp
wget https://github.com/PnX-SI/GeoNature/raw/master/data/core/ref_geo.sql -P /tmp
wget https://github.com/PnX-SI/GeoNature/raw/master/data/core/ref_geo_municipalities.sql -P /tmp

psql -d geonature2db -h localhost -p 5432 -U geonatadmin -f /tmp/public.sql
sed 's/MYLOCALSRID/2154/g' /tmp/ref_geo.sql > /tmp/ref_geo_2154.sql
psql -d geonature2db -h localhost -p 5432 -U geonatadmin -f /tmp/ref_geo_2154.sql

Pour restaurer en cas de besoin :

psql -d geonature2db -h localhost -U geonatadmin -f ~/citizen_taxhub_l_areas_dump.sql
if [ ! -f '/tmp/communes_fr_admin_express_2019-01.zip' ]
then
   wget  --cache=off http://geonature.fr/data/ign/communes_fr_admin_express_2019-01.zip -P /tmp
else
   echo "/tmp/communes_fr_admin_express_2019-01.zip already exist"
fi
unzip /tmp/communes_fr_admin_express_2019-01.zip -d /tmp/
psql -d geonature2db -h localhost -p 5432 -U geonatadmin -f /tmp/fr_municipalities.sql
psql -d geonature2db -h localhost -p 5432 -U geonatadmin -c "ALTER TABLE ref_geo.temp_fr_municipalities
OWNER TO geonatadmin;"
psql -d geonature2db -h localhost -p 5432 -U geonatadmin -f /tmp/ref_geo_municipalities.sql
psql -d geonature2db -h localhost -p 5432 -U geonatadmin -c "DROP TABLE ref_geo.temp_fr_municipalities;"

Lancement du backend pour générer les schémas :

En mode debug :

export FLASK_ENV=development; export FLASK_DEBUG=1; export FLASK_RUN_PORT=5002; export FLASK_APP=wsgi;
python -m flask run --host=0.0.0.0

Enregistrement du module principal :

insert into gnc_core.t_modules values (1, 'main', 'main', 'main', NULL, false, '2019-05-26 09:38:39.389933', '2019-05-26 09:38:39.389933');

Enregistrement d’un programme exemple

psql -d geonature2db -h localhost -p 5432 -U geonatadmin -c "INSERT INTO gnc_core.t_programs VALUES (1, 'Au 68', 'inventaire  du 68', 'desc', NULL,    NULL,   1,      1,      't', '0106000020E6100000010000000103000000010000000500000001000070947C154042CA401665A5454001000070EE7C15402235D7E667A54540010000D81C7D1540AFBA27365AA5454000000040C47C1540DD9BD74A58A5454001000070947C154042CA401665A54540',    '2019-05-26 09:38:39.389933', '2019-05-26 09:38:39.389933');"

Etape 4 : éditer le fichier de config :

notes: 
cd ../config
editer les paramètres dans default_config.toml

-SQLALCHEMY_DATABASE_URI :"postgresql+psycopg2://dbuser(geonatadmin):password(***)@127.0.0.1:5432/dbname(geonature2db)"
-URL_APPLICATION : 'https://ipserveur:4200/'
-API_ENDPOINT : 'https://ipserveur:5002/api'
-API_TAXHUB : 'http://ipserveur/taxhub/api/'

- Pour configurer du serveur Smtp renseigner les différents paramètres de votre serveur
dans la partie [MAIL] ( MAIL_HOST,MAIL_PORT ..)
 # La partie [RESET_PASSWD] correspond à la configuration du texte du mail a envoyé pour la restauration
  du mot de passe oublié
 # La partie [CONFIRM_EMAIL] correspond à la configuration du texte du mail a envoyé pour l’activation
 du compte et la confirmation de l’adresse mail de l’utilisateur

Etape 5 : configuration des badges :

Etape 6 : configuration du supervisor :

/etc/supervisor/conf.d/geonature-citizen-service.conf
[program:citizen]
command = /home/geonatadmin/citizen/backend/start_gunicorn.sh
autostart=true
autorestart=true
stdout_logfile = /var/log/supervisor/citizen.log
redirect_stderr = true

Etape 7 : Installation du frontend :

notes: 
cd citizen/frontend/
nvm use --lts  # Now using node v10.16.0 (npm v6.9.0)
si pas installé : nvm install --lts (remplacer lts par la dernière version)
cp -v src/assets/badges_* ../media/

Editer la conf :

cp src/conf*.ts.sample src/conf/  # ajuster la conf
# copier le template css alternatif
cp src/custom/custom.css.template src/custom/custom.css
# Pour configurer le lien externe de la fiche détaillée de l'espèce, éditer l'entrée suivante:
details_espece_url: "<url_inpn_or_atlas>/cd_nom/" // !! garder bien le cd_nom/ dans l'url

Lancer le front :

npm run build:i18n-ssr && npm run serve:ssr