1037 lines
39 KiB
Python
1037 lines
39 KiB
Python
# Cette fonction permet de gerer la creation des compte utilisateur
|
|
|
|
'''
|
|
# Etape 1 : cette permet de créer un compte basique
|
|
# la class prend en argument :
|
|
- nom,
|
|
- prenom,
|
|
- login
|
|
- adresse email
|
|
|
|
La fonction effectue les operations suivantes :
|
|
- enregistrement en base
|
|
- declenchement d'un email de confirmation
|
|
'''
|
|
|
|
from pymongo import MongoClient
|
|
import json
|
|
from bson import ObjectId
|
|
import email_mgt as mail
|
|
from datetime import datetime
|
|
import prj_common as mycommon
|
|
from pymongo import ReturnDocument
|
|
import inspect
|
|
|
|
|
|
class JSONEncoder(json.JSONEncoder):
|
|
def default(self, o):
|
|
if isinstance(o, ObjectId):
|
|
return str(o)
|
|
return json.JSONEncoder.default(self, o)
|
|
|
|
|
|
|
|
CONNECTION_STRING = "mongodb://localhost/cherifdb"
|
|
client = MongoClient(CONNECTION_STRING)
|
|
dbname = client['cherifdb']
|
|
|
|
|
|
'''
|
|
Recuperation des objectifs d'un utilisateur
|
|
'''
|
|
|
|
def get_user_objectif(diction):
|
|
try:
|
|
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['name', 'token']
|
|
incom_keys = diction.keys()
|
|
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
for val in incom_keys:
|
|
if str(val).lower() not in str(field_list).lower():
|
|
mycommon.myprint(str(inspect.stack()[0][3])+ " Le champ '" + val + "' n'existe pas, MAJ annulée")
|
|
return False, " Impossible de recuperer les objectifs de l'utilisateur"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['token']
|
|
for val in field_list_obligatoire:
|
|
if str(val).lower() not in diction:
|
|
mycommon.myprint(str(inspect.stack()[0][3])+ " La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de recuperer les objectifs de l'utilisateur"
|
|
|
|
query = {}
|
|
my_token = ""
|
|
# recuperation des paramettre
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
my_token = diction['token']
|
|
query['active'] = '1'
|
|
|
|
|
|
if ("name" in diction.keys()):
|
|
if diction['name']:
|
|
name = diction['name']
|
|
query['name'] = diction['name']
|
|
|
|
user_recid = "None"
|
|
# Verification de la validité du token/mail dans le cas des user en mode connecté
|
|
if (len(str(my_token)) > 0):
|
|
retval = mycommon.check_token_validity("", my_token)
|
|
|
|
if retval is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Le token n'est pas valide")
|
|
return False, " Impossible de recuperer les objectifs de l'utilisateur"
|
|
|
|
# Recuperation du recid de l'utilisateur
|
|
user_recid = mycommon.get_user_recid_from_token(my_token)
|
|
if user_recid is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer le token de l'utilisateur")
|
|
return False, " Impossible de recuperer les objectifs de l'utilisateur"
|
|
|
|
query['user_recid'] = user_recid
|
|
coll_name = dbname['user_objectif']
|
|
|
|
# Verification si ce user a deja une formation du meme nom
|
|
tmp = coll_name.find(query).count()
|
|
if( tmp <= 0 ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Aucun resultat trouvé pour "+str(query))
|
|
return False, " Impossible de recuperer les objectifs de l'utilisateur"
|
|
|
|
RetObject = []
|
|
for retVal in coll_name.find(query):
|
|
mycommon.myprint(retVal)
|
|
user = retVal
|
|
RetObject.append(JSONEncoder().encode(user))
|
|
|
|
return True, RetObject
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + str(e))
|
|
return False, " Impossible de recuperer les objectifs de l'utilisateur"
|
|
|
|
|
|
'''
|
|
Desactivation d'un objectif.
|
|
ca revient à mettre le champ "active" à -1
|
|
'''
|
|
def desable_user_objectif(diction):
|
|
try:
|
|
client = MongoClient(CONNECTION_STRING)
|
|
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['name', 'token']
|
|
incom_keys = diction.keys()
|
|
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
for val in incom_keys:
|
|
if str(val).lower() not in str(field_list).lower():
|
|
mycommon.myprint(" Le champ '" + val + "' n'existe pas, MAJ annulée")
|
|
return False, " Impossible de desactiver l'objectif"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['name', 'token']
|
|
for val in field_list_obligatoire:
|
|
if str(val).lower() not in diction:
|
|
mycommon.myprint(" La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de desactiver l'objectif"
|
|
|
|
# recuperation des paramettre
|
|
user_token = ""
|
|
user_recid = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
user_token = diction['token']
|
|
|
|
# Recuperation du recid de l'utilisateur
|
|
user_recid = mycommon.get_user_recid_from_token(user_token)
|
|
if user_recid is False:
|
|
mycommon.myprint(" Impossible de recuperer le token de l'utilisateur")
|
|
return False, " Impossible de desactiver l'objectif utilisateur"
|
|
|
|
if ("name" in diction.keys()):
|
|
if diction['name']:
|
|
name = diction['name']
|
|
|
|
|
|
myobjectif = {}
|
|
myobjectif['user_recid'] = user_recid
|
|
myobjectif['name'] = name
|
|
myobjectif['active'] = '-1'
|
|
myobjectif['date_update'] = str(datetime.now())
|
|
|
|
dbname = client['cherifdb']
|
|
coll_name = dbname['user_objectif']
|
|
|
|
mycommon.myprint(" on recherche " + user_recid)
|
|
|
|
# Verification si ce user a deja une formation du meme nom
|
|
tmp = coll_name.find({'user_recid': user_recid, 'name': name, 'active': '1'}).count()
|
|
|
|
if (tmp > 0):
|
|
# mycommon.myprint(" MIS A J "+str(myobjectif))
|
|
# Il s'agit d'une mise à jour
|
|
ret_val = coll_name.find_and_modify(query={'user_recid': user_recid, 'name': name, 'active': '1'},
|
|
update={"$set": myobjectif}
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint("La formation a bien ete desactivée =" + str(ret_val['_id']))
|
|
return True, "La formation a bien ete desactivée"
|
|
else:
|
|
mycommon.myprint("impossible de desactivier cette formation")
|
|
return False, "impossible de desactivier cette formation"
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, "Impossible de desactivier cette formation"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def add_update_user_objectif(diction):
|
|
try:
|
|
client = MongoClient(CONNECTION_STRING)
|
|
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['name', 'email_user', 'description','date_souhaite', 'domaine', 'niveau', 'token']
|
|
incom_keys = diction.keys()
|
|
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
for val in incom_keys:
|
|
if str(val).lower() not in str(field_list).lower():
|
|
mycommon.myprint(" Le champ '" + val + "' n'existe pas, MAJ annulée")
|
|
return False, " Impossible de mettre à jour l'objectif utilisateur"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['name', 'description','date_souhaite', 'token']
|
|
for val in field_list_obligatoire :
|
|
if str(val).lower() not in diction:
|
|
mycommon.myprint(" La valeur '"+val+"' n'est pas presente dans liste ")
|
|
return False, " Impossible de mettre à jour l'objectif utilisateur"
|
|
|
|
# recuperation des paramettre
|
|
user_token = ""
|
|
user_recid = ""
|
|
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
user_token = diction['token']
|
|
|
|
# Recuperation du recid de l'utilisateur
|
|
user_recid = mycommon.get_user_recid_from_token(user_token)
|
|
if user_token is False :
|
|
mycommon.myprint(" Impossible de recuperer le token de l'utilisateur")
|
|
return False, " Impossible de mettre à jour l'objectif utilisateur"
|
|
|
|
|
|
if ("description" in diction.keys()):
|
|
if diction['description']:
|
|
description = diction['description']
|
|
|
|
if ("name" in diction.keys()):
|
|
if diction['name']:
|
|
name = diction['name']
|
|
|
|
if ("date_souhaite" in diction.keys()):
|
|
if diction['date_souhaite']:
|
|
date_souhaite = diction['date_souhaite']
|
|
|
|
if ("domaine" in diction.keys()):
|
|
if diction['domaine']:
|
|
domaine = diction['domaine']
|
|
|
|
if ("niveau" in diction.keys()):
|
|
if diction['niveau']:
|
|
niveau = diction['niveau']
|
|
|
|
now = datetime.now()
|
|
myobjectif = {}
|
|
myobjectif['user_recid'] = user_recid
|
|
myobjectif['name'] = name
|
|
myobjectif['description'] = description
|
|
myobjectif['date_souhaite'] = date_souhaite
|
|
myobjectif['domaine'] = domaine
|
|
myobjectif['niveau'] = domaine
|
|
myobjectif['domaine'] = domaine
|
|
myobjectif['active'] = '1'
|
|
myobjectif['date_update'] = str(now)
|
|
|
|
dbname = client['cherifdb']
|
|
coll_name = dbname['user_objectif']
|
|
|
|
mycommon.myprint(" on recherche recid "+user_recid)
|
|
|
|
# Verification si cette personne a deja plus de 3 objectifs actifs
|
|
tmp = coll_name.find({'user_recid': user_recid, 'active':'1'}).count()
|
|
mycommon.myprint(" TMP = "+str(tmp))
|
|
if( tmp > 3 ):
|
|
mycommon.myprint(" L'utilisateur '"+user_recid+"' a deja plus de 3 objectifs actifs ")
|
|
return False, " L'utilisateur a deja plus de 3 objectifs actifs "
|
|
|
|
# Verification si ce user a deja une formation du meme nom
|
|
tmp = coll_name.find({'user_recid': user_recid, 'name':name, 'active': '1'}).count()
|
|
#mycommon.myprint(" recherche update "+str(tmp))
|
|
#mycommon.myprint(" filetr"+str(email_user)+" name "+name)
|
|
if( tmp > 0 ):
|
|
#mycommon.myprint(" MIS A J "+str(myobjectif))
|
|
# Il s'agit d'une mise à jour
|
|
ret_val = coll_name.find_and_modify(query={'user_recid': user_recid, 'name':name, 'active': '1'},
|
|
update={"$set":myobjectif }
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint("La modif a bien ete faite =" + str(ret_val['_id']))
|
|
return True, " L'objectif a bien été mis à jour"
|
|
else:
|
|
ret_val = coll_name.insert_one(myobjectif)
|
|
|
|
return True, " L'objectif a bien été créé"
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, " Impossible de mettre à jour les objectifs utilisateur"
|
|
|
|
|
|
|
|
def add_user_account(diction):
|
|
try:
|
|
client = MongoClient(CONNECTION_STRING)
|
|
|
|
# Dictionnaire des champs utilisables
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
field_list = ['name','email','pwd']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '" + val + "' n'existe pas, MAJ annulée")
|
|
return False, "Impossible d'ajouter le compte utilisateur"
|
|
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['email','pwd']
|
|
for val in field_list_obligatoire :
|
|
if val not in diction:
|
|
mycommon.myprint(" La valeur '"+val+"' n'est pas presente dans liste ")
|
|
return False, "Impossible d'ajouter le compte utilisateur"
|
|
|
|
# recuperation des paramettre
|
|
myuser = {}
|
|
if ("name" in diction.keys()):
|
|
if diction['name']:
|
|
myuser['name'] = diction['name']
|
|
|
|
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
myuser['email'] = diction['email']
|
|
|
|
if ("pwd" in diction.keys()):
|
|
if diction['pwd']:
|
|
myuser['pwd'] = diction['pwd']
|
|
|
|
# Creation du RecId du user
|
|
myuser['recid'] = mycommon.create_user_recid()
|
|
|
|
myuser['active'] = '0'
|
|
myuser['locked'] = '0'
|
|
|
|
mycommon.myprint(" webservice : diction = "+str(myuser))
|
|
|
|
dbname = client['cherifdb']
|
|
coll_name = dbname['user_account']
|
|
|
|
|
|
|
|
# Verification que cette adresse email n'existe pas
|
|
tmp = coll_name.find({'email': str(myuser['email'])}).count()
|
|
mycommon.myprint(" TMP = "+str(tmp))
|
|
if( tmp > 0 ):
|
|
mycommon.myprint("l'adresse email '"+str(myuser['email'])+"' existe deja, impossible de créer le compte ")
|
|
return False, " Ce compte existe deja"
|
|
|
|
|
|
ret_val = coll_name.insert_one(myuser)
|
|
mail.send_user_account_mail(ret_val.inserted_id, str(myuser['email']))
|
|
return True, "Le compte a été bien ajouté, merci de l'activer depuis votre boite email"
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, "Impossible de créer le compte utilisateur"
|
|
|
|
|
|
|
|
'''
|
|
cette fonction valide un compte utilisateur
|
|
La modification ne s'effectue que si le compte n'est pas verrouillé.
|
|
'locked'=0
|
|
|
|
'''
|
|
def valide_user_account(value):
|
|
try:
|
|
client = MongoClient(CONNECTION_STRING)
|
|
dbname = client['cherifdb']
|
|
coll_name = dbname['user_account']
|
|
|
|
tmp = coll_name.find({'_id':ObjectId(str(value))})
|
|
|
|
now = datetime.now()
|
|
ret_val = coll_name.find_one_and_update({'_id':ObjectId(str(value)), 'locked':'0'},
|
|
{"$set":
|
|
{'active': "1","date_update":str(now)}
|
|
},
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if( ret_val and ret_val['_id']):
|
|
mycommon.myprint("La modif a bien ete faite ="+str(ret_val['_id']))
|
|
return True," Le compte a bien été validé >"
|
|
else:
|
|
mycommon.myprint(" Impossible de valider le compte")
|
|
return False, " Impossible de valider le compte utilisateur"
|
|
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, " Impossible de valider le compte utilisateur"
|
|
|
|
|
|
'''
|
|
Mise à jour d'un compte utilisateur
|
|
Ici l'approche est la suivante : Le front office peut envoyer autant de champs
|
|
qu'il souhaite.
|
|
Le backoffice va parser l'input et recuperer les champs qui l'interesse.
|
|
S'il trouve des champs inconnu dans la liste, il s'arrete et bloque l'update
|
|
car cela voudrait dire que le programme qui l'appel l'API n'est ne sais pas ce qu'il fait.
|
|
|
|
'''
|
|
|
|
def update_user_account(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
field_list = ['adr_street', 'adr_city', 'adr_zip', 'adr_country', 'mob_phone','link_facebook', 'link_twitter', 'token']
|
|
incom_keys=diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '"+val+"' n'existe pas, MAJ annulée")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['token']
|
|
for val in field_list_obligatoire :
|
|
if val not in diction:
|
|
mycommon.myprint(" La valeur '"+val+"' n'est pas presente dans liste ")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
mycommon.myprint(" MAJ de diction "+str(diction))
|
|
|
|
coll_name = dbname['user_account']
|
|
|
|
now = datetime.now()
|
|
dictionnary = {}
|
|
dictionnary['active'] = "1"
|
|
dictionnary['date_update'] = str(now)
|
|
mytoken =""
|
|
myemail = ""
|
|
|
|
if ("adr_street" in diction.keys()):
|
|
if( str(diction['adr_street']) ):
|
|
dictionnary['adr_street'] = str(diction['adr_street'])
|
|
|
|
if ("adr_city" in diction.keys()):
|
|
if (str(diction['adr_city'])):
|
|
dictionnary['adr_city'] = str(diction['adr_city'])
|
|
|
|
|
|
if( "adr_zip" in diction.keys() ):
|
|
if (str(diction['adr_zip'])):
|
|
dictionnary['adr_zip'] = str(diction['adr_zip'])
|
|
|
|
if ("adr_country" in diction.keys()):
|
|
if (str(diction['adr_country'])):
|
|
dictionnary['adr_country'] = str(diction['adr_country'])
|
|
|
|
if ("mob_phone" in diction.keys()):
|
|
if (str(diction['mob_phone'])):
|
|
dictionnary['mob_phone'] = str(diction['mob_phone'])
|
|
|
|
if ("link_facebook" in diction.keys()):
|
|
if (str(diction['link_facebook'])):
|
|
dictionnary['link_facebook'] = str(diction['link_facebook'])
|
|
|
|
if ("link_twitter" in diction.keys()):
|
|
if (str(diction['link_twitter'])):
|
|
dictionnary['link_twitter'] = str(diction['link_twitter'])
|
|
|
|
if ("token" in diction.keys()):
|
|
if (str(diction['token'])):
|
|
mytoken = str(diction['token'])
|
|
|
|
if ("email" in diction.keys()):
|
|
if (str(diction['email'])):
|
|
myemail = str(diction['email'])
|
|
|
|
|
|
|
|
# Verification de la validité du token/mail dans le cas des user en mode connecté
|
|
if ( len(str(mytoken)) <= 0):
|
|
mycommon.myprint("Le token est vide")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
retval = mycommon.check_token_validity(myemail, mytoken)
|
|
|
|
if retval is False:
|
|
mycommon.myprint("L'email ou le token ne sont pas valident")
|
|
return False, "L'email ou le token ne sont pas valident"
|
|
|
|
|
|
mycommon.myprint(" dictionnary = "+str(dictionnary))
|
|
|
|
'''
|
|
ret_val = coll_name.find_and_modify(query={'email': str(diction['email']), 'locked': '0'},
|
|
update={"$set":
|
|
{'active': "1",
|
|
"date_update": str(now),
|
|
"adr_street":str(diction['adr_street']),
|
|
"adr_city": str(diction['adr_city']),
|
|
"adr_zip": str(diction['adr_zip']),
|
|
"adr_country": str(diction['adr_country']),
|
|
}
|
|
}
|
|
)
|
|
'''
|
|
# Recuperer le recid en partant du token.
|
|
user_recid = mycommon.get_user_recid_from_token(str(mytoken))
|
|
|
|
if user_recid is False :
|
|
mycommon.myprint("Impossible de recuperer le user_recid")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
|
|
ret_val = coll_name.find_one_and_update({'recid': str(user_recid), 'locked': '0'},
|
|
{"$set": dictionnary },
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint("La modif a bien ete faite =" + str(ret_val['_id']))
|
|
return True, " Le compte utilisateur a bien ete mis à jour"
|
|
else:
|
|
mycommon.myprint(" Aucune modif n'a été faite")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
'''
|
|
Recuperation d'un compte utilisateur
|
|
'''
|
|
def get_user_account(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '" + val + "' n'existe pas, requete annulée")
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['token']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(" La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
|
|
|
|
# recuperation des paramettre
|
|
email_value = ""
|
|
token_value = ""
|
|
|
|
|
|
if diction['token']:
|
|
token_value = diction['token']
|
|
|
|
# Verification de la validité du token/mail dans le cas des user en mode connecté
|
|
if ( len(str(token_value)) <= 0):
|
|
mycommon.myprint(" Le token est vide")
|
|
return False, "Le token est vide "
|
|
|
|
retval = mycommon.check_token_validity("", token_value)
|
|
|
|
if retval is False:
|
|
mycommon.myprint("L'email ou le token ne sont pas valident")
|
|
return False, "L'email ou le token ne sont pas valident"
|
|
|
|
|
|
# Recuperer le recid du user
|
|
user_recid = mycommon.get_user_recid_from_token(token_value)
|
|
if user_recid is False :
|
|
mycommon.myprint("Impossible de recuperer le recid du user")
|
|
return False, "Impossible de recuperer les données de l'utilisateur"
|
|
|
|
|
|
client = MongoClient(CONNECTION_STRING)
|
|
dbname = client['cherifdb']
|
|
coll_name = dbname['user_account']
|
|
|
|
RetObject = []
|
|
for retVal in coll_name.find({'recid': user_recid, 'active':'1', 'locked':'0'}):
|
|
mycommon.myprint(retVal)
|
|
|
|
user = retVal
|
|
RetObject.append(JSONEncoder().encode(user))
|
|
|
|
return True, RetObject
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(str(e))
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
|
|
|
|
'''
|
|
changement du mot de passe d'un user
|
|
'''
|
|
def change_uer_pwd(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token','new_pwd']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '" + val + "' n'existe pas, requete annulée")
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['token','new_pwd']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(" La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
|
|
|
|
# recuperation des paramettre
|
|
email_value = ""
|
|
token_value = ""
|
|
new_pwd = ""
|
|
mydata ={}
|
|
|
|
if diction['token']:
|
|
token_value = diction['token']
|
|
|
|
if diction['new_pwd']:
|
|
new_pwd = diction['new_pwd']
|
|
mydata['pwd'] = diction['new_pwd']
|
|
|
|
|
|
# Verification de la validité du token/mail dans le cas des user en mode connecté
|
|
if ( len(str(token_value)) <= 0):
|
|
mycommon.myprint("Le token est vide")
|
|
return False, "Le token est vide"
|
|
|
|
retval = mycommon.check_token_validity("", token_value)
|
|
|
|
if retval is False:
|
|
mycommon.myprint("L'email ou le token ne sont pas valident")
|
|
return False, "L'email ou le token ne sont pas valident"
|
|
|
|
|
|
# Recuperation du recid du user
|
|
user_recid = mycommon.get_user_recid_from_token(token_value)
|
|
if user_recid is False :
|
|
mycommon.myprint(" Impossible de recuperer le recid du user")
|
|
return False, " Impossible de mettre à jour le mot de passe"
|
|
|
|
|
|
|
|
mydata['date_update'] = str(datetime.now())
|
|
|
|
client = MongoClient(CONNECTION_STRING)
|
|
dbname = client['cherifdb']
|
|
coll_name = dbname['user_account']
|
|
|
|
print(" le recid = "+user_recid+" mydata = "+str(mydata))
|
|
ret_val = coll_name.find_one_and_update({'recid': user_recid, 'locked': '0'},
|
|
{"$set": mydata},
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint("La modif a bien ete faite =" + str(ret_val['_id']))
|
|
return True, "Le mot de passe a bien été mise à jour "
|
|
else:
|
|
mycommon.myprint(" Le mot de passe n'a pas été mis à jour")
|
|
return False, "Impossible de mettre à jour le password"
|
|
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, "Impossible de mettre à jour le password"
|
|
|
|
|
|
|
|
|
|
|
|
'''
|
|
changement de l'adresse email d'un user
|
|
'''
|
|
def change_uer_email(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token','new_email']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '" + val + "' n'existe pas, requete annulée")
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['token','new_email']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(" La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
|
|
|
|
# recuperation des paramettre
|
|
email_value = ""
|
|
token_value = ""
|
|
new_email = ""
|
|
mydata ={}
|
|
|
|
if diction['token']:
|
|
token_value = diction['token']
|
|
|
|
if diction['new_pwd']:
|
|
new_email = diction['new_pwd']
|
|
mydata['email'] = diction['new_email']
|
|
|
|
|
|
# Verification de la validité du token/mail dans le cas des user en mode connecté
|
|
if ( len(str(token_value)) <= 0):
|
|
mycommon.myprint("Le token est vide")
|
|
return False, "Le token est vide"
|
|
|
|
retval = mycommon.check_token_validity("", token_value)
|
|
|
|
if retval is False:
|
|
mycommon.myprint("Le token n'est pas valide")
|
|
return False, "Le token n'est pas valide"
|
|
|
|
|
|
# Recuperation du recid du user
|
|
user_recid = mycommon.get_user_recid_from_token(token_value)
|
|
if user_recid is False :
|
|
mycommon.myprint(" Impossible de recuperer le recid du user")
|
|
return False, " Impossible de mettre à jour le mot de passe"
|
|
|
|
|
|
|
|
mydata['date_update'] = str(datetime.now())
|
|
|
|
|
|
coll_name = dbname['user_account']
|
|
|
|
print(" le recid = "+user_recid+" mydata = "+str(mydata))
|
|
ret_val = coll_name.find_one_and_update({'recid': user_recid, 'locked': '0'},
|
|
{"$set": mydata},
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint("La modif du mail principale a bien ete faite =" + str(ret_val['_id']))
|
|
return True, "L'email principale a bien été mise à jour "
|
|
else:
|
|
mycommon.myprint(" L'email principal n'a pas été mis à jour")
|
|
return False, "Impossible de mettre à jour l'email principal"
|
|
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, "Impossible de mettre à jour l'email principal"
|
|
|
|
|
|
|
|
|
|
'''
|
|
Cette fonction supprime le compte de utilisateur.
|
|
Pour garder la coherence du systeme, cela revient à :
|
|
1 - Anonyser le compte tous les champ identifiants une personne
|
|
(['adr_street', 'adr_city', 'adr_zip', 'adr_country', 'mob_phone','link_facebook', 'link_twitter', 'token'])
|
|
2 - Bloquer le compte
|
|
3 - Desactiver le compte
|
|
'''
|
|
def delete_user_account(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '" + val + "' n'existe pas, requete annulée")
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['token']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(" La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
# recuperation des paramettre
|
|
token_value = ""
|
|
user_recid = ""
|
|
mydata = {}
|
|
|
|
if diction['token']:
|
|
token_value = diction['token']
|
|
|
|
|
|
# Verification de la validité du token/mail dans le cas des user en mode connecté
|
|
if (len(str(token_value)) <= 0):
|
|
mycommon.myprint("Le token est vide")
|
|
return False, "Le token est vide"
|
|
|
|
retval = mycommon.check_token_validity("", token_value)
|
|
|
|
if retval is False:
|
|
mycommon.myprint("Le token n'est pas valide")
|
|
return False, "Le token n'est pas valide"
|
|
|
|
# Recuperation du recid du user
|
|
user_recid = mycommon.get_user_recid_from_token(token_value)
|
|
if user_recid is False:
|
|
mycommon.myprint(" Impossible de recuperer le recid du user")
|
|
return False, " Impossible de mettre à jour le mot de passe"
|
|
|
|
mydata['date_update'] = str(datetime.now())
|
|
mydata['pwd'] = user_recid
|
|
mydata['email'] = "Anonyme"
|
|
mydata['active'] = '0'
|
|
mydata['locked'] = '1'
|
|
mydata['adr_street'] = "Anonyme_"+user_recid[:5]
|
|
mydata['mob_phone'] = '0000000'
|
|
mydata['link_facebook'] = 'Anonyme_facebook'
|
|
mydata['link_twitter'] = 'Anonyme_twitter'
|
|
|
|
coll_name = dbname['user_account']
|
|
ret_val = coll_name.find_one_and_update({'recid': str(user_recid), 'locked': '0'},
|
|
{"$set": mydata},
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint("Le compte utilisateur =" + str(ret_val['_id'])+" a été supprimé")
|
|
return True, " Le compte utilisateur a bien été supprimé"
|
|
else:
|
|
mycommon.myprint(" Impossible de supprimer le compte utilisateur")
|
|
return False, "Impossible de supprimer le compte utilisateur"
|
|
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, "Impossible de supprimer le compte utilisateur"
|
|
|
|
|
|
'''
|
|
Cette fonction verrouille le compte d'un utilisateur
|
|
'''
|
|
|
|
def lock_user_account(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
field_list = ['user_email']
|
|
incom_keys=diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '"+val+"' n'existe pas, MAJ annulée")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['user_email']
|
|
for val in field_list_obligatoire :
|
|
if val not in diction:
|
|
mycommon.myprint(" La valeur '"+val+"' n'est pas presente dans liste ")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
|
|
coll_name = dbname['user_account']
|
|
|
|
now = datetime.now()
|
|
dictionnary = {}
|
|
dictionnary['locked'] = "1"
|
|
dictionnary['date_update'] = str(now)
|
|
|
|
myemail = ""
|
|
|
|
if ("user_email" in diction.keys()):
|
|
if (str(diction['user_email'])):
|
|
myemail = str(diction['user_email'])
|
|
|
|
|
|
# Recuperer le recid en partant du token.
|
|
user_recid = mycommon.get_user_recid_from_email(str(myemail))
|
|
|
|
if user_recid is False :
|
|
mycommon.myprint("Impossible de recuperer le user_recid")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
ret_val = coll_name.find_one_and_update({'recid': str(user_recid)},
|
|
{"$set": dictionnary },
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint("Le compte utilisateur =" + str(ret_val['_id'])+" a été bien verrouillé")
|
|
return True, " Le compte utilisateur a bien ete verrouillé"
|
|
else:
|
|
mycommon.myprint(" Impossible de verrouiller le compte utilisateur")
|
|
return False, "Impossible de verrouiller le compte utilisateur"
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
|
|
'''
|
|
Cette fonction desactive le compte d'un utilisateur. la fonction met
|
|
"active" à 0 et "locked" a 1
|
|
'''
|
|
|
|
def desable_user_account(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
|
|
'''
|
|
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
|
|
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
|
|
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
|
|
# field_list.
|
|
'''
|
|
field_list = ['user_email']
|
|
incom_keys=diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '"+val+"' n'existe pas, MAJ annulée")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
'''
|
|
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
|
|
On controle que les champs obligatoires sont presents dans la liste
|
|
'''
|
|
field_list_obligatoire = ['user_email']
|
|
for val in field_list_obligatoire :
|
|
if val not in diction:
|
|
mycommon.myprint(" La valeur '"+val+"' n'est pas presente dans liste ")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
|
|
coll_name = dbname['user_account']
|
|
|
|
now = datetime.now()
|
|
dictionnary = {}
|
|
dictionnary['active'] = "0"
|
|
dictionnary['locked'] = "1"
|
|
dictionnary['date_update'] = str(now)
|
|
|
|
myemail = ""
|
|
|
|
if ("user_email" in diction.keys()):
|
|
if (str(diction['user_email'])):
|
|
myemail = str(diction['user_email'])
|
|
|
|
# Recuperer le recid en partant du token.
|
|
user_recid = mycommon.get_user_recid_from_email(str(myemail))
|
|
|
|
if user_recid is False :
|
|
mycommon.myprint("Impossible de recuperer le user_recid")
|
|
return False, "Impossible de desactiver le compte utilisateur"
|
|
|
|
|
|
ret_val = coll_name.find_one_and_update({'recid': str(user_recid)},
|
|
{"$set": dictionnary },
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint("Le compte utilisateur =" + str(ret_val['_id'])+" a été bien desactivé")
|
|
return True, " Le compte utilisateur a bien ete desactivé"
|
|
else:
|
|
mycommon.myprint(" Impossible de desactiver le compte utilisateur")
|
|
return False, "Impossible de desactiver le compte utilisateur"
|
|
|
|
except Exception as e:
|
|
mycommon.myprint(e)
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|