Introduction
Cette application permet de gérer le cycle de vie des cartes NFC de votre établissement, de la demande à sa désactivation en passant par son impression, encodage et activation dans votre système d'information.
Cette application fonctionne via une authentification/identification Shibboleth et en lien avec une instance esup-nfc-tag-server
Une Machine Virtuelle est à votre disposition pour pouvoir manipuler ESUP-SGC et ainsi avoir à diposition un exemple complet d'installation : VM ESUP-SGC.
Plan du document
Concepts
Afin de mettre en œuvre le système de gestion de carte ESUP-SGC, vous devez installer ESUP-SGC mais également ESUP-NFC-TAG.
ESUP-SGC
Gère le cycle de vie de vos cartes (workflow allant de la demande à désactivatino de la carte)
- Authentifie les utilisateurs via une authentification Shibboleth
Récupère les informations (nom, prénom, email, date de naissance, etc.) des utilisateurs depuis l'identifiaction shibboleth ou/et un annuaire LDAP ou/et une base de données relationnelle
Synchronise les informations utilisateurs et de cartes avec l'API du CNOUS (CROUS, IZLY) en temps réel.
- Synchronise les informations utilisateurs étudiants et de cartes avec l'API ESC - European Student Card : http://europeanstudentcard.eu
Synchronisation avec différentes solutions de contrôles d’accès (P2S, TIL, Synchronic)
- Reversement des informations de cartes (csn, 'identifiant desfire', photo) dans un annuaie LDAP
- Permet l’impression des cartes (en mode PS/PCL)
esup-sgc ne sait pas encoder les cartes, la partie technique propre au NFC est propre à ESUP-NFC-TAG
ESUP-NFC-TAG
ESUP-NFC-TAG ( https://www.esup-portail.org/wiki/display/ESUPNFC ) se décompose d'une partie serveur (implémentatnt toute la logique métier, la gestion des périphériques et applications clientes ainsi que les algorithmes de chiffrement Mifare Desfire) nommé ESUP-NFC-TAG-SERVER qui :
Permet la lecture et l’écriture des cartes en NFC - technologie Mifare Desfire
Gère des applications clientes (de lecture notamment mais aussi écriture ou/et mise à jour pour ESUP-SGC)
Gère les périphériques sans contact (lecteur PC/SC, smartphone, …)
C'est esup-nfc-tag-server qui connait la structure de la carte Mifare Desfire. Il communique avec esup-sgc pour récupérer le contenu à écrire dans les fichiers (ex : code d’identification pour le contrôle d’accès)
Pour lire ou encoder une carte, un "client lourd" est nécessaire ; aussi les applications clientes suivantes sont disponibles :
esup-nfc-tag-desktop : application java qui permet d’utiliser un encodeur PC/SC USB depuis une machine linux/windows/mac disposant de Java
esup-nfc-tag-droid : application Android qui utilise le lecteur NFC du smartphone
ESUP-SGC-CLIENT
ESUP-SGC inclut également son propre client pour l’encodage des cartes (esup-sgc-client) qui est en fait également client d'esup-nfc-tag-server.
L’encodage via esup-sgc-client se passe de cette manière :
lecture du QR code présent sur la carte (identifiant l’individu à encoder)
association de la carte avec l’individu dans le SGC
encodage des différentes applications DESFIRE telles que décrites dans le fichier de configuration d'ESUP-NFC-TAG-SERVER
... et optionnellement (on recommande plutôt d'acheter des cartes préencodés IZLY) encodage de l’application IZLY (CROUS) via ESUP-NFC-TAG-SERVER en utilisant la clé SAM du CNOUS et des DLL Windows
Schéma d’architecture de la solution
Liens
https://github.com/EsupPortail/esup-sgc
https://github.com/EsupPortail/esup-sgc-client
https://github.com/EsupPortail/esup-nfc-tag-server
https://github.com/EsupPortail/esup-nfc-tag-desktop
https://github.com/EsupPortail/esup-nfc-tag-droid
Pre-requis
Logiciels
Java (JDK - JAVA SE 8): vous pouvez utiliser la librairie openjdk pour la partie serveur, pour la partie cliente, il est plus simple de prendre les versions officielles de chez Oracle (notamment pour le support facilité de JAVA WebStart et Java FX) : http://www.oracle.com/technetwork/java/javase/downloads/index.html
Maven (dernière version 3.0.x) : http://maven.apache.org/download.cgi
Postgresql : le mieux est de l'installer via le système de paquets de votre linux.
Tomcat 8 : https://tomcat.apache.org/download-80.cgi
Apache + libapache2-mod-shib2
Git
Les deux applications serveurs doivent être « shibbolethisées » - voir la documentation renater : https://services.renater.fr/federation/docs/installation/sp
Matériel
Voici le matériel minimal requis pour pouvoir mettre en place un Système de Gestion de cartes via l'environnement ESUP-SGC.
Serveur : 2 CPU, RAM > 2 Go, Disque > 20 Go
Un lecteur RFID USB Compatible PC/SC pour encodage
- Une webcam
Cartes Mifare Desfire EV1 ou EV2
- Une imprimante à carte.
A cela, un Smartphone Android > 5 avec lecteur NFC peut également s'avérer utile par exemple.
Installation des pré-requis
Note:
Les utilisateurs, chemins d'installation, ports utilisés ci-dessous ne sont qu'une suggestion.
Les exemples de configuration système sont basés sur Debian.
Les deux services seront installés sur le même serveur, l'un répondant avec le nom esup-sgc.univ-ville.fr et l'autre avec le nom esup-nfc-tag.univ-ville.fr.
Ces VirtualHosts seront configurés sous Apache.
Installer les paquets nécessaires
apt-get install wget maven apache2 libapache2-mod-shib2 git apt-get install postgresql postgresql-contrib
Il est également nécessaire d'avoir un JDK d'installé (Oracle Java ou bien OpenJDK).
Installation des instances Tomcat
Création de l'utilisateur esup:
groupadd esup useradd -g esup -m esup
Installer les deux instances de Tomcat. L'une sera utilisée pour ESUP-SGC, l'autre pour ESUP-NFC-TAG.
cd /opt/ wget http://apache.crihan.fr/dist/tomcat/tomcat-8/v8.5.24/bin/apache-tomcat-8.5.24.tar.gz tar xzvf apache-tomcat-8.5.24.tar.gz mv apache-tomcat-8.5.24 apache-tomcat-8.5.24-esup-nfc-tag tar xzvf apache-tomcat-8.5.24.tar.gz mv apache-tomcat-8.5.24 apache-tomcat-8.5.24-esup-sgc ln -s apache-tomcat-8.5.24-esup-nfc-tag tomcat-esup-nfc-tag ln -s apache-tomcat-8.5.24-esup-sgc tomcat-esup-sgc rm -Rf /opt/tomcat-esup-sgc/webapps/* mkdir /opt/tomcat-esup-sgc/webapps/ROOT/ rm -Rf /opt/tomcat-esup-nfc-tag/webapps/* mkdir /opt/tomcat-esup-nfc-tag/webapps/ROOT/ chown -R esup:esup /opt/apache-tomcat-8.5.24-esup-sgc/ chown -R esup:esup /opt/apache-tomcat-8.5.24-esup-nfc-tag/
Les options Java étant les mêmes pour les deux instances, on peut créer un fichier commun qui sera lu lors du démarrage des tomcat.
cat > /opt/esup-env <<EOF #!/bin/sh ANT_HOME=/usr/share/ant JAVA_HOME=/opt/jdk #GRADLE_HOME=/usr/local/gradle-2.14.1 #ANDROID_HOME=/usr/local/android-sdk JAVA_OPTS="-Xms256m -Xmx512m -Djavax.net.ssl.trustStore=/opt/esup.univ-ville.jks -Djavax.net.ssl.trustStorePassword=esupesup" EOF
Note: il faudra penser à créer le keystore indiqué et y intégrer les certificats utilisés par les VirtualHosts Apache.
Ces deux instances seront démarrées via Systemd. On peut donc créer et activer ces deux services:
Pour Esup-SGC:
cat > /etc/systemd/system/tomcat-esup-sgc.service <<EOF # Systemd unit file for tomcat [Unit] Description=Apache Tomcat Web Application Container After=syslog.target network.target [Service] Type=forking EnvironmentFile=/opt/esup-env Environment=CATALINA_PID=/opt/tomcat-esup-sgc/temp/tomcat.pid Environment=CATALINA_HOME=/opt/tomcat-esup-sgc ExecStart=/opt/tomcat-esup-sgc/bin/startup.sh ExecStop=/bin/kill -15 $MAINPID User=esup Group=esup [Install] WantedBy=multi-user.target EOF systemctl enable tomcat-esup-sgc.service
Pour Esup-NFC-TAG:
cat > /etc/systemd/system/tomcat-esup-nfc-tag.service <<EOF # Systemd unit file for tomcat [Unit] Description=Apache Tomcat Web Application Container After=syslog.target network.target [Service] Type=forking EnvironmentFile=/opt/esup-env Environment=CATALINA_PID=/opt/tomcat-esup-nfc-tag/temp/tomcat.pid Environment=CATALINA_HOME=/opt/tomcat-esup-nfc-tag ExecStart=/opt/tomcat-esup-nfc-tag/bin/startup.sh ExecStop=/bin/kill -15 $MAINPID User=esup Group=esup [Install] WantedBy=multi-user.target EOF systemctl enable tomcat-esup-nfc-tag.service
Configuration des Tomcat
Pour l'instance d'Esup-SGC, éditer /opt/tomcat-esup-sgc/conf/server.xml
afin de configurer le port 8205 et un connecteur AJP sur le port 8209.
Les connecteurs HTTP et HTTPS (ports 8080 et 8443 par défaut) doivent être commentés (ou être configurés sur un autre port pour éviter les conflits avec la seconde instance Tomcat)
<Server port="8205" shutdown="SHUTDOWN"> <!-- (...) --> <Connector port="8209" protocol="AJP/1.3" redirectPort="8443" tomcatAuthentication="false" />
Idem pour l'instance d'Esup-NFC-TAG qui utilisera les ports 8305 et 8309.
<Server port="8305" shutdown="SHUTDOWN"> <!-- (...) --> <Connector port="8309" protocol="AJP/1.3" redirectPort="8443" tomcatAuthentication="false" />
Configuration d'Apache
Activer les modules suivants:
a2enmod rewrite a2enmod ssl a2enmod proxy_ajp a2enmod proxy_http a2enmod shib2
Créer un fichier de configuration pour le VirtualHost esup-sgc.univ-ville.fr /etc/apache2/sites-available/esup-sgc.univ-ville.fr.conf
<VirtualHost *:80> ServerName esup-sgc.univ-ville.fr ServerAdmin webmaster@univ-ville.fr DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined RewriteEngine On RewriteCond %{REQUEST_METHOD} ^(TRACE|TRACK) RewriteRule .* - [F] RewriteRule ^/(.*)$ https://esup-sgc.univ-ville.fr/$1 [L,R] </VirtualHost> <VirtualHost *:443> ServerName esup-sgc.univ-ville.fr ServerAdmin webmaster@univ-ville.fr DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined SSLEngine on SSLCertificateFile /etc/apache2/certs/esup-sgc.crt SSLCertificateKeyFile /etc/apache2/certs/esup-sgc.key SSLCACertificateFile /etc/apache2/certs/CA.crt ProxyPass /Shibboleth.sso ! ProxyPass /secure ! ScriptAlias /secure /var/www/printenv.pl ShibCompatValidUser Off <Location /Shibboleth.sso> SetHandler shib AuthType None Require all granted </Location> <Location /shibboleth-sp> AuthType None Require all granted </Location> Alias /shibboleth-sp/main.css /usr/share/shibboleth/main.css <Location /secure> AuthType shibboleth ShibRequestSetting requireSession 1 require shib-session ShibUseHeaders On ShibRequestSetting applicationId default </Location> <Location /> AuthType shibboleth ShibRequestSetting requireSession 1 require shib-session ShibUseHeaders On ShibRequestSetting applicationId default </Location> <Location "/resources"> Require all granted ShibRequireSession Off </Location> <Location "/wsrest"> Require all granted ShibRequireSession Off </Location> <Location "/payboxcallback"> Require all granted ShibRequireSession Off </Location> ProxyPass / ajp://localhost:8209/ ttl=10 timeout=3600 retry=1 </VirtualHost>
Idem pour le VirtualHost esup-nfc-tag.univ-ville.fr dans /etc/apache2/sites-available/esup-nfc-tag.univ-ville.fr.conf
<VirtualHost *:80> ServerName esup-nfc-tag.univ-ville.fr ServerAdmin webmaster@univ-ville.fr DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error_esup-nfc-tag.log CustomLog ${APACHE_LOG_DIR}/access_esup-nfc-tag.log combined RewriteEngine On RewriteCond %{REQUEST_METHOD} ^(TRACE|TRACK) RewriteRule .* - [F] RewriteRule ^/(.*)$ https://esup-nfc-tag.univ-ville.fr/$1 [L,R] </VirtualHost> <VirtualHost *:443> ServerName esup-nfc-tag.univ-ville.fr ServerAdmin webmaster@univ-ville.fr DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error_esup-nfc-tag.log CustomLog ${APACHE_LOG_DIR}/access_esup-nfc-tag.log combined SSLEngine on SSLCertificateFile /etc/apache2/certs/esup-nfc-tag.crt SSLCertificateKeyFile /etc/apache2/certs/esup-nfc-tag.key SSLCACertificateFile /etc/apache2/certs/CA.crt ProxyPass /Shibboleth.sso ! ProxyPass /secure ! ScriptAlias /secure /var/www/printenv.pl ShibCompatValidUser Off <Location /Shibboleth.sso> SetHandler shib AuthType None Require all granted </Location> <Location /shibboleth-sp> AuthType None Require all granted </Location> Alias /shibboleth-sp/main.css /usr/share/shibboleth/main.css <Location /secure> AuthType shibboleth ShibRequestSetting requireSession 1 require shib-session ShibUseHeaders On ShibRequestSetting applicationId esup-nfc-tag </Location> <Location /manager> AuthType shibboleth ShibRequestSetting requireSession 1 require shib-session ShibUseHeaders On ShibRequestSetting applicationId esup-nfc-tag </Location> <Location /admin> AuthType shibboleth ShibRequestSetting requireSession 1 require shib-session ShibUseHeaders On ShibRequestSetting applicationId esup-nfc-tag </Location> <Location /nfc> AuthType shibboleth ShibRequestSetting requireSession 1 require shib-session ShibUseHeaders On ShibRequestSetting applicationId esup-nfc-tag </Location> ProxyPass / ajp://localhost:8309/ ttl=10 timeout=3600 retry=1 </VirtualHost>
A noter que l'applicationId
du ShibRequestSetting
diffère selon les VirtualHosts.
De plus, dans cet exemple, chaque VirtualHost dispose de son propre certificat. Il est tout à fait possible d'utiliser le même sous-réserve que les noms des deux VirtualHosts y soient indiqués (SAN).
Penser à intégrer ces certificats au keystore des tomcat. Par exemple:
keytool -genkey -alias mon_cert -keyalg RSA -keystore /opt/esup.univ-ville.jks keytool -delete -alias mon_cert -keystore /opt/esup.univ-ville.jks keytool -import -file /etc/apache2/certs/esup-sgc.crt -alias sgc -trustcacerts -keystore /opt/esup.univ-ville.jks keytool -import -file /etc/apache2/certs/esup-nfc-tag.crt -alias nfctag -trustcacerts -keystore /opt/esup.univ-ville.jks
Activer les sites:
a2dissite 000-default.conf a2ensite esup-sgc.univ-ville.fr a2ensite esup-nfc-tag.univ-ville.fr
Installation du SP Shibboleth
Générer une nouvelle clé:
shib-keygen
Cette commande permet de générer les fichiers sp-key.pem
et sp-cert.pem
dans /etc/shibboleth/
Editer /etc/shibboleth/shibboleth2.xml
Avant la balise ApplicationDefaults, ajouter un RequestMap avec le nom des deux virtualhost:
<RequestMapper type="Native"> <RequestMap applicationId="default"> <Host name="esu-nfc-tag.univ-ville.fr" applicationId="esup-nfc-tag" authType="shibboleth" requireSession="false"/> <Host name="esup-sgc.univ-ville.fr" applicationId="esup-sgc" authType="shibboleth" requireSession="false"/> </RequestMap> </RequestMapper>
Configurer la balise SSO pour un IDP par défaut:
<ApplicationDefaults ...> <Sessions ...> <SSO entityID="https://idp.univ-ville.fr/idp/shibboleth"> SAML2 SAML1 </SSO>
Penser à modifier le contact du support:
<Errors supportContact="sysadmin@univ-ville.fr"
Votre fournisseur de Metadata:
<MetadataProvider type="XML" validate="true" uri="https://idp.univ-ville.fr/idp/shibboleth" backingFilePath="idp.univ-ville.fr-metadata.xml"> </MetadataProvider>
Et enfin, avant la fermeture de la balise ApplicationDefaults, rajoutez un ApplicationOverride. Dans notre cas, le VirtualHost esup-sgc.univ-ville.fr utilisera le default, on utilisera un id spécifique pour esup-nfc-tag:
<ApplicationOverride id="esup-nfc-tag" entityID="https://esup-nfc-tag.univ-ville.fr/shibboleth"/>
Les Metadata doivent à présent être téléchargeables à ces adresses:
https://esup-sgc.univ-ville.fr/Shibboleth.sso/Metadata
https://esup-nfc-tag.univ-ville.fr/Shibboleth.sso/Metadata
Il reste donc à les intégrer à l'IDP, soit directement, soit en passant par la fédération d'identité.
Installation
Éléments requis
Pour avoir un système de gestion de cartes fonctionnel, l'installation minimale consiste à installer :
- un serveur tomcat avec l'application web esup-nfc-tag-server - documentation d'installation ici :
https://github.com/EsupPortail/esup-nfc-tag-server/blob/master/README.md - un serveur tomcat avec l'application web esup-sgc - documentation d'installation ici :
https://github.com/EsupPortail/esup-sgc/blob/master/README.md
A noter que esup-sgc embarque de fait le client esup-sgc-client sous la forme d'un jar servi via Java Web Start (JavaWS) / Java Network Launch Protocol (JNLP).
Ce client est signé par l'Université de Rouen Normandie - vous pouvez aussi le reconstruire et le resigner vous même depuis les sources : https://github.com/EsupPortail/esup-sgc-client
Installation materielle
Dans l'application esup-sgc-client, l'encodage des cartes s'effectue à l'aide de la webcam et du lecteur de carte NFC. La webcam est disposée au dessus du lecteur de cartes de manière à le filmer. Lorsque qu'une carte est placée sur le lecteur la webcam lit le qrcode puis lance l'encodage.
Pour automatiser l'encodage des cartes il est possible d'utiliser une imprimante Zebra ZXP3. voir : Tuto robot encodeur basé sur une Zebra ZXP3
Éléments optionnels
Vous pouvez également mettre en place les applications Esup-nfc-tag-desktop et Esup-nfc-tag-droid :
- Esup-nfc-tag-desktop :https://github.com/EsupPortail/esup-nfc-tag-desktop/blob/master/README.md
- Esup-nfc-tag-droid : https://github.com/EsupPortail/esup-nfc-tag-droid/blob/master/README.md
Alliées à ESUP-SGC, ces applications pourront vous permettre
- de rechercher une carte en la badgeant
- de marquer une carte comme "livrée" en la badgeant
Configurations
Esup-nfc-tag-server
La configuration se fait par les fichiers suivants :
src/main/resources/META-INF/spring/applicationContext-custom.xml
src/main/resources/META-INF/spring/applicationContext-desfire.xml (voir configuration avancée)
src/main/resources/META-INF/spring/applicationContext-security.xml
applicationContext-custom.xml
Le fichier applicationContext-custom.xml permet de configurer les différentes applications avec lesquelles esup-nfc-tag va communiquer.
Dans le cadre du SGC il faudra à minima configurer la connexion avec esup-sgc à l’aide de la configuration suivante :
<bean id="csnAuthConfig" class="org.esupportail.nfctag.service.api.impl.CsnAuthConfig"> <property name="description" value="Authentification CSN"/> </bean> <bean id="esupSgcWriteExtApi" class="org.esupportail.nfctag.service.api.impl.AppliExtRestWs"> <property name="isTagableUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/isTagable"/> <property name="validateTagUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/validateTag"/> <property name="getLocationsUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/locations"/> <property name="description" value="Web Service Write Esup SGC"/> </bean> <bean id="tagIdCheckApiEsupSgc" class="org.esupportail.nfctag.service.api.impl.TagIdCheckRestWs"> <property name="tagIdCheckUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/tagIdCheck"/> <property name="idFromEppnInitUrl" value="https://esup-sgc-test.univ-ville.fr/wsrest/nfc/idFromEppnInit"/> <property name="description" value="via Esup SGC"/> </bean>
en remplacant les liens par ceux pointant vers votre instance d’esup-sgc
applicationContext-desfire.xml
Dans le ficher applicationContext-desfire.xml on trouve la structure et les données qui seront écrites sur la carte lors de l’encodage. Par défaut la configuration de Desfire est vide, aucune application ne sera écrite sur la carte.
<bean id="tagName" class="org.esupportail.nfctag.beans.DesfireTag" p:formatBeforeWrite="false" p:key="0000000000000000" p:keyType="DES" p:keyVersion="00"> </bean> <bean id="desfireAuthConfigComueWriteEsupSgc" class="org.esupportail.nfctag.service.api.impl.DesfireWriteConfig"> <property name="desfireTag" ref="tagName" /> <property name="description" value="Ecriture ESUP SGC"/> </bean>
Voir la documentation avancée pour l'ajout d'application Desfire sur la carte.
applicationContext-security.xml
Dans le fichier applicationContext-security.xml il faut modifier le mapping des groupes pour l’attribution des rôles Admin et Supervisor en precisant le cn des groupes concernés :
<beans:bean id="authUserDetailsService" class="org.esupportail.nfctag.security.ShibAuthenticatedUserDetailsService"> <beans:property name="mappingGroupesRoles"> <beans:map> <beans:entry key="cn=for.esup-nfc-tag.admin,ou=groups,dc=univ-ville,dc=fr" value="ROLE_ADMIN" /> <beans:entry key="cn=for.esup-nfc-tag.supervisor,ou=groups,dc=univ-ville,dc=fr" value="ROLE_SUPERVISOR" /> </beans:map> </beans:property> </beans:bean>
Configuration de l'application dans l'IHM
ESUP-NFC-TAG est multi-service. Il faut donc déclarer les applications, auxquelles il peut s’adresser, au niveau de l’IHM.
Dans la section « Application » → « +Ajouter une application »
On retrouve les éléments configurés dans applicationContext-custom.xml. Pour l’encodage des cartes par le SGC, nous allons créer une application nommée "Ecriture SGC" avec les paramètres suivants:
Nom : « Ecriture SGC »
Configuration NFC : « Ecriture ESUP SGC » (spécifié dans applicationContext-desfire.xml)
Application externe : « Web Service Write Esup SGC »
Contrôle du tagId : « via Esup SGC »
Valeur par défaut pour la validation sans confirmation : true
Voir aussi la configuration des applications optionnelles : Applications ESUP-NFC-TAG optionnelles
Esup-sgc
La configuration se fait via les fichiers suivants :
src/main/resources/META-INF/spring/database.properties
- src/main/resources/META-INF/persistence.xml
- src/main/resources/META-INF/spring/applicationContext-services.xml
src/main/resources/META-INF/spring/applicationContext-crous.xml
src/main/resources/META-INF/spring/applicationContext-paybox.xml
src/main/resources/META-INF/spring/applicationContext-access-control.xml
src/main/resources/META-INF/spring/applicationContext-security.xml
Paramétrage de la base de données (database.properties et persistence.xml)
Les paramètres de connexion à la base de données sont indiqués dans le database.properties. Par exemple:
database.driverClassName=org.postgresql.Driver database.url=jdbc\:postgresql\://localhost\:5432/esupsgc database.username=esupsgc database.password=esup
Cette base de données Postgresql doit être créée auparavant et devra disposer de l'extension lo. Il doit également être possible de se connecter avec la méthode 'password' (cf pg_hba.conf).
Concrètement, cette ligne doit être présente dans le pg_hba.conf (penser à redémarrer le service postgresql une fois cette ligne ajoutée):
host all all 127.0.0.1/32 password
Pour créer la base:
create database esupsgc; create USER esupsgc with password 'esup'; grant ALL ON DATABASE esupsgc to esupsgc;
Dans le fichier persistence.xml, vérifier que la propriété hibernate.hbm2ddl.auto est à "create" (ce n'est pas le cas par défaut).
<property name="hibernate.hbm2ddl.auto" value="create" />
ATTENTION: Après le premier lancement de l'application, il faudra penser à remettre cette propriété à "update" et rajouter un trigger sur une table. Soit:
\c esupsgc CREATE EXTENSION lo; CREATE TRIGGER t_big_file BEFORE UPDATE OR DELETE ON big_file FOR EACH ROW EXECUTE PROCEDURE lo_manage(binary_file);
applicationContext-services.xml
UserInfo :
La première partie du fichier comporte les « UserInfoService » ainsi que les « SpelUserInfoService » . Ces deux entités ont pour but de peupler les informations des demandeurs de carte à l’aide des différentes sources de données présentent dans le SI. Trois methodes sont implémentées dans le SGC :
ShibUserInfoService (recupération des données via le context Shibboleth)
LdapUserInfoService
SqlUserInfoService
Les spelUserInfoService sont des règles qui s’appliquent ensuite pour calculer certains attributs de l’utilisateur.
La recherche dans les différentes sources ainsi que le calcul des règles se fait de manière séquentielle dans l’ordre défini par la propriété « p:order ». A chaque étape, quand une donnée est trouvée, elle remplace celle trouvée par l’étape précédente.
C'est via les 'userInfos' que la synchronisation des données utilisateurs depuis le Système d'Information se fait. Les champs 'userInfos' sont de tout type : nom, prénom, date de naissance, indice, numéro étudiant, numéro personnel, email, libellés à écrire sur la carte, template de la carte à utiliser, etc.
cardIdsService :
Permet de configurer la génération d'identifiants qui pourront être codés dans la carte par esup-nfc-tag :
- pour du contrôle d'accès par exemple
- ou pour générer l'identifiant de carte crous si on n'opte pas pour l'usage de carte préencodé crous et qu'on souhaite qu'esup-sgc et esup-nfc-tag se chargent de cet encodage. Aussi dans ce cadre crousEncodeEnabled à true permet de spécifier que l’application CROUS doit être écrite lors de l’encodage des cartes.
EsupNfcTagService :
Pour spécifier l’adresse du serveur esup-nfc-tag. Le SGC déclare et contrôle ses périphériques d’encodage (esup-scg-client) avec esup-nfc-tag (applicationName correspond à l'application créée dans esup-nfc-tag)
<bean id="esupNfcTagService" class="org.esupportail.sgc.services.EsupNfcTagService"> <property name="restTemplate" ref="restTemplate"/> <property name="webUrl" value="http://esup-nfc-tag.univ-ville.fr"/> <property name="applicationName" value="Ecriture SGC"/> <property name="location" value="Encodage ESUP SGC"/> </bean>
LdapValidateService
Le SGC peut transmettre des données au LDAP lorsque la carte est activée. Dans le bean ldapValidateService il est possible de paramétrer deux types de clés : Simple ou multivaluée (ldapCardIdsMappingValue, ldapCardIdsMappingMultiValues)
Les valeurs transmissibles sont : %csn%, %reverse_csn% (le csn retourné par paires), %access-control% (ex : identifiant contrôle d'accès), %photo%.
<bean id="ldapValidateService" class="org.esupportail.sgc.services.ldap.LdapValidateService"> <property name="ldapTemplate" ref="ldapTestTemplate"/> <property name="peopleSearchFilter" value="(eduPersonPrincipalName={0})"/> <property name="ldapCardIdsMappingMultiValues"> <map> <!-- Exemple clé multi-valuée --> <entry key="supannRefId"> <list> <value>{ISO15693}%csn%</value> <value>{LEOCARTE:ACCESS-CONTROL}%access-control%</value> </list> </entry> <!-- Exemple clé multi-valuée --> <entry key="autreExemple"> <list> <value>%reverse_csn%@ISO15693</value> </list> </entry> </map> </property> <property name="ldapCardIdsMappingValue"> <map> <!-- Exemple clé simple --> <entry key="jpegPhoto" value="%photo%"/> </map> </property> </bean>
applicationContext-crous.xml
ApiCrousService :
Permet d’activer l’envoi de données au CROUS via l’api
<bean id="apiCrousService" class="org.esupportail.sgc.services.crous.ApiCrousService"> <property name="enable" value="false"/> <property name="webUrl" value="https://api-pp.nuonet.fr/v1" /> <property name="login" value="truc@univ-ville.fr" /> <property name="password" value="xxxxxxxxxxxxxxx" /> <property name="restTemplate" ref="restTemplate" /> </bean>
EsistCrousService :
Fait référence au fichier XML de calcul des tarifs CROUS
ApiEscrService :
Permet de configurer l’envoi des données à l’api ESC (Eropean Student Card) voir : http://europeanstudentcard.eu/
<bean id="europeanStudentCardService" class="org.esupportail.sgc.services.esc.ApiEscrService"> <property name="enable" value="false"/> <property name="webUrl" value="http://api-sandbox.europeanstudentcard.eu/v1" /> <property name="key" value="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" /> <property name="restTemplate" ref="restTemplate" /> <property name="countryCode" value="FR"/> <property name="picInstitutionCode" value="000000000"/> <!-- Type of cards. Possibles values are : 1 - passive card, with no electronic 2 - Smartcard without European common data zone 3 - Smartcard with European common data zone 4 - Smartcard on which application may be installed by service providers --> <property name="cardType" value="3"/> </bean>
applicationContext-paybox.xml
Permet le paramétrage du module paybox dans le cas d’un renouvellement de carte payant.
applicationContext-access-control.xml
Permet de paramétrer le chemin d'export des informations pour le controle d'accès. Formats disponibles:
- P2S
- TIL
- SYNCHRONIC
applicationContext-security.xml
Comme pour la configuration esup-nfc-tag, il s’agit de mapper les groups sur les rôles proposés par le SGC :
ADMIN
Permet d'avoir la vue "Admin" de l'interface, et donc accès aux paramètres de configuration, aux imports CSV, aux logs, etc.
Le rôle Admin permet également de disposer de la fonction SU (Switch User).
SUPER_MANAGER
Permet d'avoir la vue "Manager" de l'interface. Un manager peut valider/refuser une demande, imprimer les cartes et les activer.
Le lien pour l'application java d'encodage (disponible depuis le menu Apps) est présent, cette application java étant à la fois cliente d'ESUP-SGC et ESUP-NFC-TAG.
MANAGER_XYZ
Rôle particulier et dynamique, XYZ étant à changer par un userType, comme P par exemple pour les personnels : MANAGER_P.
Si l'utilisateur a le rôle MANAGER_P il ne pourra rechercher (et éditer, etc.) que les cartes dont les utilisateurs sont de userType P.
attention
Cette limitation est en fait uniquement visuelle, techniquement il a les mêmes droits que le super_manager et il peut tout à fait affichier une fiche de carte d'un autre userType (en tapant directement l'url qui va bien ... ou en la recherchant au travers du badgeage de la 'salle recherche' par exemple - cf plus bas).
LIVREUR
La vue "Manager" est disponible en lecture seule.
Il est possible de noter une carte comme livrée :
- via l'interface web
- en utilisant une application cliente esup-nfc-tag (disponible depuis le menu Apps) pour smartphone (android) ou de bureau (java) et en badgeant la carte qu'on livre
UPDATER
ll est possible de mettre à jour électroniquement une carte en utilisant une application cliente esup-nfc-tag (disponible depuis le menu Apps) pour smartphone (android) ou de bureau (java) et en badgeant la carte.
Cette mise à jour électronique est configurée dans esup-nfc-tag (ajout d'applications, de fichiers et clefs ...)
CONSULT
La vue "Manager" est disponible en lecture seule. Il n'est pas possible d'imprimer la carte ni de l'encoder, mais les liens vers les applications permettant d'utiliser le lecteur NFC sont présents, ils permettent de rechercher une carte via badgeage de la carte sur smartphone ou ordinateur.
Après badgeage d'une carte dans la 'salle recherche' de l'application cliente, à la validation la fiche de la carte est automatiquement affichée dans le navigateur de l'utilisateur connecté (dernière session en date) avec le même identifiant que sur l'application cliente (si connecté == si session en cours).
USER
Pour pouvoir faire une demande de carte, l'utilisateur doit avoir ce rôle.
USER_NO_EDITABLE
Si un utilisateur dispose de ce rôle, alors sa carte ne peut pas être éditée (par ex: problème sur dossier), même si celui-ci a pu effectuer la demande.
USER_RENEWAL_PAYED
Si un utilisateur dispose de ce rôle, celui-ci doit payer avant de pouvoir demander un renouvellement de carte.