Intégration travail sur l'API

README.md

@@ -41,6 +41,77 @@ Pour protéger une route :
   def insertUpdate_bibtaxons(id_taxon=None):
     ...
 ```
+## Utilisation de l'API
+
+### Routes définies dans UsersHub
+
+* create_tmp_user : 
+  * in : {données sur l'utilisateur}
+  * return : {token}
+  * Création d'un utilisateur temporaire en base
+* valid_temp_user :
+  * in : {token, application_id}
+  * return : {role}
+  * Création utilisateur en base dans la table t_role et ajout d'un profil avec code 1 pour une l’application donnée
+* create_cor_role_token:
+  * in : {email}
+  * return : {role}
+  * Génère un token pour utilisateur ayant l’email indiqué et stoque le token dans cor_role_token
+* change_password
+  * in: {token, password, password_confirmation}
+  * return : {role}
+  * Mise à jour du mot de passe de l’utilisateur et suppression du token en base
+* change_application_right
+  * in : {id_application, id_profil, id_role}
+  * return : {id_role, id_profil, id_application, role}
+  * Modifie le profil de l’utilisateur pour l’application 
+* update_user
+  * in : {id_role, données utilisateur}
+  * return : {role}
+  * Mise à jour d'un rôle
+
+### Méthodes définies dans le module
+ * connect_admin : décorateur pour la connexion d’un utilisateur type admin a une appli ici usershub. Paramètres à renseigner dans config.py
+ * post_usershub :
+  * route générique pour appeler les route usershub en tant qu'administrateur de l'appli en cours
+  * lance l’action spécifié
+  * si une post request est définie pour l’action exécute la fonction
+
+
+### Configuration
+Paramètres à rajouter dans le fichier de configuration (`config.py`)
+
+```
+URL_USERSHUB="http://usershub-url.ext"
+
+# Administrateur de mon application
+ADMIN_APPLICATION_LOGIN="admin-monapplication"
+ADMIN_APPLICATION_PASSWORD="monpassword"
+ADMIN_APPLICATION_MAIL="[email protected]"
+```
+
+### Appel des routes
+Pour disposer des routes dans votre application Flask, ajoutez dans votre fichier de lancement de l'application (`server.py` par exemple) :
+
+```
+from pypnusershub import routes_register
+app.register_blueprint(routes_register.bp, url_prefix='/pypn/register')
+```
+
+### Configuration des actions post request
+
+Rajouter le paramètre `after_USERSHUB_request` à la configuration. Ce paramètre est un tableau qui défini pour chaque action un ensemble d'opération à réaliser ensuite. Comme par exemple envoyer un mail.
+
+```
+function_dict = {
+    'create_cor_role_token': create_cor_role_token,
+    'create_temp_user': create_temp_user,
+    'valid_temp_user': valid_temp_user,
+    'change_application_right': change_application_right
+}
+```
+
+Chaque fonction prend un paramètre en argument qui correspond aux données retournée par la route de UsersHub
 
 ## Installation
 

requirements.txt

@@ -2,4 +2,7 @@ flask==1.0.2
 sqlalchemy==1.3.3
 flask-sqlalchemy==2.3.2
 psycopg2==2.7.5
-bcrypt
+bcrypt
+requests==2.20.1
+pycrypto==2.6.1
+

routes.py

@@ -23,4 +23,5 @@
 
 sys.path.append(SRCDIR)
 
-from pypnusershub.routes import *  # noqa
+from pypnusershub.routes import *  # noqa
+from pypnusershub.routes_register import *  # noqa

src/pypnusershub/db/models.py

@@ -15,7 +15,7 @@
 from flask import current_app
 
 from sqlalchemy.orm import relationship
-from sqlalchemy import Sequence, func
+from sqlalchemy import Sequence, func, ForeignKey
 db = current_app.config['DB']
 
 def fn_check_password(self, pwd):
@@ -111,10 +111,40 @@ def as_dict(self, recursif=False, columns=()):
             'nom_role': self.nom_role,
             'prenom_role': self.prenom_role,
             'id_organisme': self.id_organisme,
+            'email': self.email,
             'groupe': self.groupe,
+            'remarques': self.remarques,
             'nom_complet': nom_role+' '+prenom_role
         }
 
+class Profils(db.Model):
+    """
+    Model de la classe t_profils
+    """
+
+    __tablename__ = 't_profils'
+    __table_args__ = {'schema':'utilisateurs', 'extend_existing': True}
+    id_profil = db.Column(db.Integer,primary_key = True)
+    code_profil = db.Column(db.Unicode)
+    nom_profil = db.Column(db.Unicode)
+    desc_profil = db.Column(db.Unicode)
+
+class ProfilsForApp(db.Model):
+    """
+    Model de la classe t_profils
+    """
+
+    __tablename__ = 'cor_profil_for_app'
+    __table_args__ = {'schema':'utilisateurs', 'extend_existing': True}
+    id_profil = db.Column(
+        db.Integer,
+        ForeignKey('utilisateurs.t_profils.id_profil'),
+        primary_key = True
+    )
+    id_application = db.Column(db.Integer,primary_key = True)
+
+    profil = relationship("Profils")
+
 
 class Application(db.Model):
     '''
@@ -123,6 +153,7 @@ class Application(db.Model):
     __tablename__ = 't_applications'
     __table_args__ = {'schema': 'utilisateurs'}
     id_application = db.Column(db.Integer, primary_key=True)
+    code_application = db.Column(db.Unicode)
     nom_application = db.Column(db.Unicode)
     desc_application = db.Column(db.Unicode)
     id_parent = db.Column(db.Integer)
@@ -161,15 +192,17 @@ class UserApplicationRight(db.Model):
     '''
     Droit d'acces d'un user particulier a une application particuliere
     '''
-    __tablename__ = 'cor_role_droit_application'
-    __table_args__ = {'schema': 'utilisateurs'}
+    __tablename__ = 'cor_role_app_profil'
+    __table_args__ = {'schema': 'utilisateurs', 'extend_existing': True}
     id_role = db.Column(db.Integer, primary_key=True)
-    id_droit = db.Column(db.Integer, primary_key=True)
+    id_profil = db.Column(db.Integer, ForeignKey('utilisateurs.t_profils.id_profil'), primary_key = True)
     id_application = db.Column(db.Integer, primary_key=True)
 
+    profil = relationship("Profils")
+
     def __repr__(self):
-        return "<UserApplicationRight role='{}' droit='{}' app='{}'>".format(
-            self.id_role, self.id_droit, self.id_application
+        return "<UserApplicationRight role='{}' profil='{}' app='{}'>".format(
+            self.id_role, self.id_profil, self.id_application
         )
 
 

src/pypnusershub/db/models_register.py

@@ -0,0 +1,118 @@
+from flask import current_app
+
+
+from .models import User
+
+from Crypto.Cipher import XOR
+
+import base64
+
+import re
+
+config = current_app.config
+
+DB = current_app.config['DB']
+
+
+def encrypt_str(s, secret_key):
+
+    return s
+
+
+def decrypt_str(s, secret_key):
+
+    return s
+
+
+class TempUser(DB.Model):
+    __tablename__ = 'temp_users'
+    __table_args__ = {'schema': 'utilisateurs', 'extend_existing': True}
+
+    id_temp_user = DB.Column(DB.Integer, primary_key=True)
+    token_role = DB.Column(DB.Unicode)
+    password = DB.Column(DB.Unicode)
+    password_confirmation = DB.Column(DB.Unicode)
+    identifiant = DB.Column(DB.String(250))
+    nom_role = DB.Column(DB.String(250))
+    prenom_role = DB.Column(DB.String(250))
+    desc_role = DB.Column(DB.String(250))
+    remarques = DB.Column(DB.String(250))
+    groupe = DB.Column(DB.Boolean)
+    pn = DB.Column(DB.Boolean)
+    id_organisme = DB.Column(DB.Integer)
+    organisme = DB.Column(DB.String(250))
+    email = DB.Column(DB.Unicode)
+    date_insert = DB.Column(DB.DateTime)
+    date_update = DB.Column(DB.DateTime)
+
+    def encrypt_password(self, secret_key):
+
+        self.password = encrypt_str(self.password, secret_key)
+        self.password_confirmation = encrypt_str(self.password_confirmation, secret_key)
+
+    def decrypt_password(self, secret_key):
+
+        self.password = decrypt_str(self.password, secret_key)
+        self.password_confirmation = decrypt_str(self.password_confirmation, secret_key)
+
+    def is_valid(self):
+
+        is_valid = True
+        msg = ""
+
+        if not self.password:
+
+            is_valid = False
+            msg += "Password is required. "
+
+        if self.password != self.password_confirmation:
+
+            is_valid = False
+            msg += "Password and password_confirmation are differents. "
+
+        re.compile(r"[^@\s]+@[^@\s]+\.[a-zA-Z0-9]+$")
+
+        if not re.match(r"[^@\s]+@[^@\s]+\.[a-zA-Z0-9]+$", self.email):
+
+            is_valid = False
+            msg += "E-mail is not valid. "
+
+        role = DB.session.query(User).filter(User.email == self.email).first()
+
+        if role:
+
+            is_valid = False
+            msg += "User with mail " + self.email + " exists. "
+
+        return (is_valid, msg)
+
+    def as_dict(self, recursif=False, columns=()):
+        return {
+            'id_temp_user': self.id_temp_user,
+            'token_role': self.token_role,
+            'identifiant': self.identifiant,
+            'nom_role': self.nom_role,
+            'prenom_role': self.prenom_role,
+            'desc_role': self.prenom_role,
+            'remarques': self.prenom_role,
+            'id_organisme': str(self.id_organisme),
+            'organisme': self.organisme,
+            'email': self.email,
+            'groupe': self.groupe,
+            'password': self.password,
+            'password_confirmation': self.password_confirmation
+        }
+
+class CorRoleToken(DB.Model):
+
+    __tablename__ = 'cor_role_token'
+    __table_args__ = {'schema': 'utilisateurs', 'extend_existing': True}
+
+    id_role = DB.Column(DB.Integer, primary_key=True)
+    token = DB.Column(DB.Unicode)
+
+    def as_dict(self, recursif=False, columns=()):
+        return {
+            'id_role': self.id_role,
+            'token': self.token
+        }

src/pypnusershub/routes.py

@@ -169,7 +169,6 @@ def __check_auth(*args, **kwargs):
 
 @routes.route('/login', methods=['POST'])
 def login():
-
     try:
         user_data = request.json
         try:
@@ -181,6 +180,7 @@ def login():
                     .filter(models.AppUser.identifiant == login)
                     .filter(models.AppUser.id_application == id_app)
                     .one())
+
             # Return child application
             sub_app = models.AppUser.query.join(
                 models.Application, models.Application.id_application == models.AppUser.id_application