1617 lines
64 KiB
Python
1617 lines
64 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
|
|
import email_mgt as mail
|
|
from datetime import datetime
|
|
import prj_common as mycommon
|
|
from pymongo import ReturnDocument
|
|
import inspect
|
|
import sys, os
|
|
|
|
|
|
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()
|
|
tmp = coll_name.count_documents(query)
|
|
|
|
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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
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.count_documents({'email': str(myuser['email'])})
|
|
|
|
if( tmp > 0 ):
|
|
mycommon.myprint("l'adresse email '"+str(myuser['email'])+"' existe deja, impossible de créer le compte ")
|
|
return False, " Ce compte utilisateur 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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
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', 'surname', 'last_name', 'birthday','link_linkedin']
|
|
incom_keys=diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le champ '"+val+"' n'est pas autorisé ")
|
|
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'])
|
|
|
|
if ("surname" in diction.keys()):
|
|
if (str(diction['surname'])):
|
|
dictionnary['surname'] = str(diction['surname'])
|
|
|
|
if ("last_name" in diction.keys()):
|
|
if (str(diction['last_name'])):
|
|
dictionnary['last_name'] = str(diction['last_name'])
|
|
|
|
if ("birthday" in diction.keys()):
|
|
if (str(diction['birthday'])):
|
|
dictionnary['birthday'] = str(diction['birthday'])
|
|
|
|
if ("link_linkedin" in diction.keys()):
|
|
if (str(diction['link_linkedin'])):
|
|
dictionnary['link_linkedin'] = str(diction['link_linkedin'])
|
|
|
|
|
|
|
|
# Verification de la validité du token/mail dans le cas des user en mode connecté
|
|
if ( len(str(mytoken)) <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - 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(str(inspect.stack()[0][3]) + " -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(str(inspect.stack()[0][3]) + " - 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(str(inspect.stack()[0][3]) + " -La modif a bien ete faite =" + str(ret_val['_id']))
|
|
return True, " Le compte utilisateur a bien ete mis à jour"
|
|
else:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Aucune modif n'a été faite")
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
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"
|
|
|
|
'''
|
|
# Verification si compte utilisateur à ete activé
|
|
retval2, message = mycommon.check_user_validity("", token_value)
|
|
if retval2 is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " le user account n'est valide ou est verrouillé")
|
|
return False, message
|
|
'''
|
|
|
|
# Recuperer le recid du user
|
|
user_recid = mycommon.get_user_recid_from_token(token_value)
|
|
if user_recid is False :
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - 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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de recuperer le user account"
|
|
|
|
|
|
|
|
'''
|
|
changement du mot de passe d'un user
|
|
'''
|
|
def change_user_pwd(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token', 'pwd', 'new_pwd', 'conf_new_pwd']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '" + val + "' n'est pas autorisé, 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', 'pwd', 'new_pwd', 'conf_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 mettre à jour le mot de passe"
|
|
|
|
|
|
# recuperation des paramettre
|
|
email_value = ""
|
|
token_value = ""
|
|
pwd = ""
|
|
new_pwd = ""
|
|
conf_new_pwd = ""
|
|
|
|
mydata ={}
|
|
|
|
if ("pwd" in diction.keys()):
|
|
if diction['pwd']:
|
|
pwd = diction['pwd']
|
|
|
|
if ("conf_new_pwd" in diction.keys()):
|
|
if diction['conf_new_pwd']:
|
|
conf_new_pwd = diction['conf_new_pwd']
|
|
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
token_value = diction['token']
|
|
|
|
if ("new_pwd" in diction.keys()):
|
|
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(str(inspect.stack()[0][3]) + " Le token est vide")
|
|
return False, "Le token est vide"
|
|
|
|
if ( len(str(pwd)) <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le mot de passe est vide")
|
|
return False, "Le mot de passe est vide"
|
|
|
|
|
|
if ( len(str(new_pwd)) <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le nouveau mot de passe est vide")
|
|
return False, "Le nouveau mot de passe est vide"
|
|
|
|
if (str(new_pwd) != str(conf_new_pwd)):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Les mots de passe ne sont pas identiques. nouveau pass :'"+str(new_pwd) +"', la oonfirmation envoyées est "''+str(conf_new_pwd)+"' ")
|
|
return False, " Les mots de passe ne sont pas identiques "
|
|
|
|
retval = mycommon.check_token_validity("", token_value)
|
|
|
|
if retval is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le token est invalide")
|
|
return False, "Le token est invalide"
|
|
|
|
|
|
# Recuperation du recid du user
|
|
user_recid = mycommon.get_user_recid_from_token(token_value)
|
|
if user_recid is False :
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de recuperer le recid du user. Le token envoyé est :"+str(token_value))
|
|
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', 'active':'1', 'pwd':pwd},
|
|
{"$set": mydata},
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le mot de passe de l'utilisateur (recid) =" + str(user_recid)+" a été modifié")
|
|
return True, "Le mot de passe a bien été mise à jour "
|
|
else:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de mettre à jour le password du user : recid = "+str(user_recid))
|
|
return False, "Impossible de mettre à jour le password"
|
|
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de mettre à jour le mot de passe de l'utilisateur"
|
|
|
|
|
|
'''
|
|
Changement du mot de passe d'un user
|
|
avec un token de reinitialisation '''
|
|
def Reset_user_pwd_by_token(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token', 'new_pwd', 'conf_new_pwd']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(" Le champ '" + val + "' n'est pas autorisé, 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', 'conf_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 mettre à jour le mot de passe"
|
|
|
|
|
|
# recuperation des paramettre
|
|
email_value = ""
|
|
token_value = ""
|
|
pwd = ""
|
|
new_pwd = ""
|
|
conf_new_pwd = ""
|
|
|
|
mydata ={}
|
|
|
|
if ("conf_new_pwd" in diction.keys()):
|
|
if diction['conf_new_pwd']:
|
|
conf_new_pwd = diction['conf_new_pwd']
|
|
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
token_value = diction['token']
|
|
|
|
if ("new_pwd" in diction.keys()):
|
|
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(str(inspect.stack()[0][3]) + " Le token est vide")
|
|
return False, "Le token est vide"
|
|
|
|
if ( len(str(new_pwd)) <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le mot de passe est vide")
|
|
return False, "Le mot de passe est vide"
|
|
|
|
|
|
if (str(new_pwd) != str(conf_new_pwd)):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Les mots de passe ne sont pas identiques. nouveau pass :'"+str(new_pwd) +"', la oonfirmation envoyées est "''+str(conf_new_pwd)+"' ")
|
|
return False, " Les mots de passe ne sont pas identiques "
|
|
|
|
retval = mycommon.check_token_validity("", token_value)
|
|
|
|
if retval is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le token est invalide")
|
|
return False, "Le token est invalide"
|
|
|
|
|
|
# Recuperation du recid du user
|
|
user_recid = mycommon.get_user_recid_from_token(token_value)
|
|
if user_recid is False :
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de recuperer le recid du user. Le token envoyé est :"+str(token_value))
|
|
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', 'active':'1'},
|
|
{"$set": mydata},
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val and ret_val['_id']):
|
|
# Apres avoir changer le mot passe, desactivation tu token
|
|
|
|
coll_name = dbname['user_token']
|
|
ret_val = coll_name.update_many({'recid': user_recid, 'valide': '1'},
|
|
{"$set": {'valide': '0', 'date_update': str(datetime.now())}},
|
|
)
|
|
|
|
if( ret_val.matched_count <= 0 ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " WARNING : Attention à la mise à jour du mot de passe de"
|
|
" du user avec le recid = "+user_recid)
|
|
else:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le mot de passe de l'utilisateur (recid) =" + str(user_recid)+" a été modifié")
|
|
return True, "Le mot de passe a bien été mise à jour "
|
|
else:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de mettre à jour le password du user : recid = "+str(user_recid))
|
|
return False, "Impossible de mettre à jour le password"
|
|
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de mettre à jour le mot de passe de l'utilisateur"
|
|
|
|
|
|
|
|
|
|
|
|
'''
|
|
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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de mettre à jour l'email principal"
|
|
|
|
|
|
|
|
|
|
|
|
'''
|
|
Pour des questions de securité, la suppression d'un compte se fait en 2 etapes :
|
|
|
|
etape 1 :
|
|
Le frontoffice qui declenche l'envoie d'un email avec un token sur l'adresse mail
|
|
du user. puis blocage du compte.
|
|
|
|
etape 2 :
|
|
Lorsque le user se connecte à son mail et clique sur le lien, là les données
|
|
sont supprimées.
|
|
|
|
'''
|
|
def send_mail_delete_user(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token','user_ip', 'user_country_code', 'user_country_name',
|
|
'user_city', 'user_postal', 'user_latitude', 'user_longitude', 'user_state']
|
|
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
|
|
return False, " Impossible de supprimer 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(
|
|
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de supprimer le compte utilisateur"
|
|
|
|
# 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(
|
|
str(inspect.stack()[0][3]) + " - Le token est vide ")
|
|
return False, " Impossible de supprimer le compte utilisateur"
|
|
|
|
retval = mycommon.check_token_validity("", token_value)
|
|
|
|
|
|
if retval is False:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - 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(
|
|
str(inspect.stack()[0][3]) + " - Impossible de recuperer le recid du user ")
|
|
return False, " Impossible de supprimer le compte utilisateur"
|
|
|
|
# Recuperation du mail du user
|
|
user_email_from_token = mycommon.get_user_email_from_token(token_value)
|
|
if user_email_from_token is False:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Impossible de recuperer l'adresse mail du user ")
|
|
return False, " Impossible de supprimer le compte utilisateur"
|
|
|
|
# Blocage du compte.
|
|
mydata = {}
|
|
mydata['delete_process'] = "1"
|
|
mydata['locked'] = "1"
|
|
mydata['active'] = "0"
|
|
if ("user_ip" in diction.keys()):
|
|
if diction['user_ip']:
|
|
mydata['delete_ip_1'] = diction['user_ip']
|
|
|
|
mydata['date_update'] = str(datetime.now())
|
|
|
|
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(
|
|
str(inspect.stack()[0][3]) + " - Le compte utilisateur =" + str(
|
|
ret_val['_id']) + " email de suppression envoyé ")
|
|
|
|
else:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Impossible de supprimer le compte utilisateur - table : user_account")
|
|
return False, "Impossible de supprimer le compte utilisateur"
|
|
|
|
|
|
# Envoie de l'email de notification
|
|
email_mgt.send_user_delete_account(user_recid, user_email_from_token)
|
|
|
|
return True, "Un email vous été envoyé. connectez vous à votre adresse mail finaliser la suppression du compte."
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de supprimer le compte utilisateur"
|
|
|
|
|
|
|
|
'''
|
|
Cette fonction supprime le compte de utilisateur.
|
|
Pour garder la coherence du systeme, cela revient à :
|
|
1 - Anonyser le compte tous les champs 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
|
|
4 - Anomyser les tables annexe :
|
|
a) articles_avis
|
|
b) user_token
|
|
'''
|
|
def delete_user_account(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['user_recid', 'user_ip', 'user_country_code', 'user_country_name',
|
|
'user_city','user_postal', 'user_latitude', 'user_longitude', 'user_state']
|
|
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
|
|
return False, " Impossible de supprimer 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_recid']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de supprimer le compte utilisateur"
|
|
|
|
# recuperation des paramettre
|
|
token_value = ""
|
|
user_recid = ""
|
|
mydata = {}
|
|
|
|
if diction['user_recid']:
|
|
user_recid = diction['user_recid']
|
|
|
|
|
|
# Verification de la validité du token/mail dans le cas des user en mode connecté
|
|
if (len(str(user_recid)) <= 0):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Le recid est vide ")
|
|
return False, " Impossible de supprimer le compte utilisateur"
|
|
|
|
|
|
# Recuperation du mail du user
|
|
print(" user recid ~~~~~~~~ "+user_recid)
|
|
user_email_from_recid = mycommon.get_user_email_from_recid(user_recid)
|
|
if user_email_from_recid is False:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Impossible de recuperer l'adresse mail du user ")
|
|
return False, " Impossible de supprimer le compte utilisateur"
|
|
|
|
|
|
mydata['date_update'] = str(datetime.now())
|
|
mydata['pwd'] = user_recid
|
|
mydata['email'] = "Anonyme@"+user_recid[:5]
|
|
mydata['last_name'] = "name_"+user_recid[:5]
|
|
mydata['surname'] = "surname"+user_recid[:5]
|
|
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'
|
|
mydata['link_linkedin'] = 'Anonyme_linkedin'
|
|
mydata['delete_process'] = "2"
|
|
if ("user_ip" in diction.keys()):
|
|
if diction['user_ip']:
|
|
mydata['delete_ip_1'] = diction['user_ip']
|
|
|
|
|
|
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(
|
|
str(inspect.stack()[0][3]) + " - Le compte utilisateur =" + str(ret_val['_id'])+" a été supprimé de la table : user_account ")
|
|
|
|
else:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de supprimer le compte utilisateur - table : user_account")
|
|
return False, "Impossible de supprimer le compte utilisateur"
|
|
|
|
# Anonymisation de la table user_token ou se trouve aussi l'adresse email.
|
|
# table : user_token
|
|
user_token_coll_name = dbname['user_token']
|
|
ret_val = user_token_coll_name.update_many({'recid': str(user_recid), },
|
|
{"$set": {'email':'Anonyme',
|
|
'valide':'0',
|
|
'date_update':str(datetime.now()) } },
|
|
)
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Table : user_token : "+str(ret_val.matched_count)+" ont été trouvées "
|
|
" "+str(ret_val.acknowledged)+" ont été modifiées")
|
|
|
|
# table : articles_avis
|
|
articles_avis_coll_name = dbname['articles_avis']
|
|
ret_val = articles_avis_coll_name.update_many({'postedby': str(user_email_from_recid), },
|
|
{"$set": {'email': 'Anonyme',
|
|
'date_update':str(datetime.now()) }},
|
|
)
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Table : user_token : " + str(ret_val.matched_count) + " ont été trouvées "
|
|
" "+str(ret_val.acknowledged) + " ont été modifiées")
|
|
|
|
|
|
return True, "Le compte utilisateur a bien ete supprimé"
|
|
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
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:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de mettre à jour le compte utilisateur"
|
|
|
|
|
|
'''
|
|
Cette fonction retourne l'historique de recherche
|
|
d'un utilisateur
|
|
'''
|
|
|
|
def get_user_recherche_history(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 = ['token']
|
|
incom_keys=diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le champ '"+val+"' n'est pas autorisé, opération annulée")
|
|
return False, "Impossible de recuperer l'historique de recherche"
|
|
|
|
'''
|
|
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(str(inspect.stack()[0][3]) + " La valeur '"+val+"' n'est pas presente dans liste ")
|
|
return False, "Impossible de recuperer l'historique de recherche"
|
|
|
|
# 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(str(inspect.stack()[0][3]) + " Le token est vide")
|
|
return False, "Le token est vide"
|
|
|
|
retval = mycommon.check_token_validity("", token_value)
|
|
|
|
if retval is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " 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(str(inspect.stack()[0][3]) + " Impossible de recuperer le recid du user")
|
|
return False, " Impossible de mettre à jour le mot de passe"
|
|
|
|
query = {}
|
|
query['user_recid'] = user_recid
|
|
query['valide'] = '1'
|
|
|
|
coll_name = dbname['user_recherche']
|
|
|
|
# Verification si ce user a deja une formation du meme nom
|
|
#tmp = coll_name.find(query, {"_id": 0}).count()
|
|
tmp = coll_name.count_documents(query)
|
|
if (tmp <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Aucun resultat trouvé pour " + str(query))
|
|
return False, " Impossible de recuperer l'historique de recherche de l'utilisateur"
|
|
|
|
RetObject = []
|
|
local_id = 0
|
|
for retVal in coll_name.find(query, {"_id": 0, "valide":0, "user_recid":0}):
|
|
mycommon.myprint(retVal)
|
|
user = retVal
|
|
user['id'] = str(local_id)
|
|
local_id = local_id + 1
|
|
RetObject.append(JSONEncoder().encode(user))
|
|
|
|
return True, RetObject
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de recuperer l'historique de recherche"
|
|
|
|
|
|
'''
|
|
Cette Function permet de gerer la reunitialisation du passwd
|
|
à la demande de l'utilisateur : exemple : mot de passe oublié.
|
|
|
|
que fait elle exactement :
|
|
|
|
0 - Desactivation de toutes les entrée dans la table : user_token pour le mail, s'il est valide
|
|
1 - elle crée une entrée dans la table : user_token
|
|
- recid
|
|
- email
|
|
3 - envoyer un mail au user (si valide) avec le token : /ResetUserPwd/:tokenx
|
|
'''
|
|
def InitUserPasswd(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 = ['email']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé, opération annulée")
|
|
return False, "Impossible de reinitialiser le mot de passe de l'utiilisateur"
|
|
|
|
'''
|
|
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']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, "Impossible de reinitialiser le mot de passe de l'utiilisateur"
|
|
|
|
|
|
'''
|
|
Verification de la valider de l'email
|
|
'''
|
|
myemail = ""
|
|
myquery = {}
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
myemail = diction['email']
|
|
myquery['email'] = diction['email']
|
|
|
|
|
|
myquery['active'] = '1'
|
|
myquery['locked'] = '0'
|
|
|
|
|
|
coll_name = dbname['user_account']
|
|
|
|
#print(" myquery ="+str(myquery))
|
|
|
|
tmp = coll_name.count_documents(myquery)
|
|
if (tmp <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Aucun resultat trouvé pour " + str(myquery))
|
|
return True, "La demande de reinitiation à été prise en compte"
|
|
|
|
|
|
retVal = coll_name.find(myquery, {"_id": 0, "valide": 0, "user_recid": 0})
|
|
|
|
#print(" le recid = "+str(retVal[0]['recid']))
|
|
|
|
'''
|
|
Desactivation des tocken actifs
|
|
'''
|
|
update_field = {'valide': '0', 'date_update':str(datetime.now())}
|
|
|
|
|
|
coll_name_token = dbname['user_token']
|
|
ret_val_user_rech = coll_name_token.update_many(
|
|
{'recid': retVal[0]['recid']},
|
|
{"$set": update_field}
|
|
)
|
|
|
|
if (ret_val_user_rech.matched_count <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de desactivier les token actifs dans table 'user_token' ")
|
|
return True, "La demande de reinitiation à été prise en compte"
|
|
|
|
|
|
'''
|
|
Insertion du nouveau token
|
|
'''
|
|
new_token = {}
|
|
new_token['email'] = retVal[0]['email']
|
|
new_token['recid'] = retVal[0]['recid']
|
|
new_token['date_update'] = str(datetime.now())
|
|
new_token['valide'] = '1'
|
|
# Creation du token
|
|
mynewtoken = mycommon.create_token_urlsafe()
|
|
new_token['token'] = mynewtoken
|
|
|
|
|
|
#print(" new token to insert = "+str(new_token))
|
|
ret_val_tmp = coll_name_token.insert_one(new_token)
|
|
if (ret_val_tmp is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de créer le nouveau toek")
|
|
return True, "La demande de reinitiation à été prise en compte"
|
|
|
|
# envoi de l'email
|
|
email_mgt.send_user_init_pwd_mail(mynewtoken, retVal[0]['email'])
|
|
|
|
return True, "La demande de reinitiation à été prise en compte"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de reinitialiser le mot de passe de l'utiilisateur"
|
|
|
|
|
|
'''
|
|
Cette fonction verifie si le token d'un utilisateur est valide
|
|
'''
|
|
def IsUserTokenValide(diction):
|
|
try:
|
|
'''
|
|
# 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 = ['token']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé, opération annulée")
|
|
return False, "Impossible de reinitialiser le mot de passe de l'utiilisateur"
|
|
|
|
'''
|
|
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(str(inspect.stack()[0][3]) + " La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, "Impossible de reinitialiser le mot de passe de l'utiilisateur"
|
|
|
|
myquery = {}
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
myquery['token'] = diction['token']
|
|
|
|
myquery['valide'] = '1'
|
|
coll_name_token = dbname['user_token']
|
|
|
|
|
|
tmp = coll_name_token.count_documents(myquery)
|
|
if (tmp <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Aucun resultat trouvé pour " + str(myquery))
|
|
return False, "Le token n'est pas valide"
|
|
|
|
return True, "Le token est valdie"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de verifier la validité du token"
|
|
|