Elyos_FI_Back_Office/ela_user_account.py

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"