Elyos_FI_Back_Office/ela_user_account.py

1986 lines
81 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 re
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
import GlobalVariable as MYSY_GV
class JSONEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, ObjectId):
return str(o)
return json.JSONEncoder.default(self, o)
'''
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 récupérer 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 la liste des arguments ")
return False, " Impossible de récupérer 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'
name_defined = 0
if ("name" in diction.keys()):
if diction['name']:
name = diction['name']
query['name'] = diction['name']
name_defined = 1
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]) + " - La session de connexion n'est pas valide")
return False, " Impossible de récupérer 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 récupérer le token de l'utilisateur")
return False, " Impossible de récupérer les objectifs de l'utilisateur"
query['user_recid'] = user_recid
coll_name = MYSY_GV.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 récupérer les objectifs de l'utilisateur"
val_tmp = 1
RetObject = []
print(" ### my query = "+str(query))
if( name_defined == 1 ):
for retVal in coll_name.find(query).limit(1):
#mycommon.myprint(retVal)
user = retVal
user['id'] = str(val_tmp)
val_tmp = val_tmp+1
#print(" #### user 1= "+str(user))
RetObject.append(JSONEncoder().encode(user))
else :
for retVal in coll_name.find(query):
#mycommon.myprint(retVal)
CLEANR = re.compile('<.*?>')
val = re.sub(CLEANR, '', str(retVal['description']))
val = str(val).replace("&nbsp;", " ").replace('\n', '')
user = retVal
user['id'] = str(val_tmp)
user['description'] = val
val_tmp = val_tmp+1
#print(" #### user 2 = "+str(user))
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 récupérer les objectifs de l'utilisateur"
'''
Desactivation d'un objectif.
ca revient à mettre le champ "active" à -1
'''
def desable_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(" 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 la liste des arguments ")
return False, " Impossible de desactiver l'objectif"
# recuperation des paramettre
partner_token = ""
user_recid = ""
if ("token" in diction.keys()):
if diction['token']:
partner_token = diction['token']
# Recuperation du recid de l'utilisateur
user_recid = mycommon.get_user_recid_from_token(partner_token)
if user_recid is False:
mycommon.myprint(" Impossible de récupérer 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())
coll_name = MYSY_GV.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()
tmp = coll_name.count_documents({'user_recid': user_recid, 'name': name, 'active': '1'})
if (tmp > 0):
# mycommon.myprint(" MIS A J "+str(myobjectif))
# Il s'agit d'une mise à jour
ret_val = coll_name.find_one_and_update({'user_recid': user_recid, 'name': name, 'active': '1'},
{"$set": myobjectif},
return_document=ReturnDocument.AFTER
)
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:
# 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 la liste des arguments ")
return False, " Impossible de mettre à jour l'objectif utilisateur"
# recuperation des paramettre
partner_token = ""
user_recid = ""
if ("token" in diction.keys()):
if diction['token']:
partner_token = diction['token']
# Recuperation du recid de l'utilisateur
user_recid = mycommon.get_user_recid_from_token(partner_token)
if partner_token is False :
mycommon.myprint(" Impossible de récupérer 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'] = niveau
myobjectif['active'] = '1'
myobjectif['date_update'] = str(now)
coll_name = MYSY_GV.dbname['user_objectif']
mycommon.myprint(" on recherche recid "+user_recid)
# Verification si cette personne a deja plus de 3 objectifs actifs
tmp = coll_name.count_documents({'user_recid': user_recid, 'active':'1'})
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.count_documents({'user_recid': user_recid, 'name':name, 'active': '1'})
#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_one_and_update({'user_recid': user_recid, 'name':name, 'active': '1'},
{"$set":myobjectif },
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, " 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"
"""
Cette fonction modifie le profil d'un user
Un profil est definit (par defaut) par :
- name :
- nb_langue : le nombre de langue
- niveau_etude :
- etc
"""
def add_update_user_profile(diction):
try:
# Dictionnaire des champs utilisables
field_list = ['name', 'nb_lang','etude_level', '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 le profil 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', 'token']
for val in field_list_obligatoire :
if str(val).lower() not in diction:
mycommon.myprint(" La valeur '"+val+"' n'est pas presente dans la liste des arguments ")
return False, " Impossible de mettre à jour l'objectif utilisateur"
# recuperation des paramettre
partner_token = ""
user_recid = ""
if ("token" in diction.keys()):
if diction['token']:
partner_token = diction['token']
# Recuperation du recid de l'utilisateur
user_recid = mycommon.get_user_recid_from_token(partner_token)
if partner_token is False :
mycommon.myprint(" Impossible de récupérer le token de l'utilisateur")
return False, " Impossible de mettre à jour l'objectif utilisateur"
my_data = {}
if ("nb_lang" in diction.keys()):
if diction['nb_lang']:
my_data['nb_lang'] = diction['nb_lang']
if ("name" in diction.keys()):
if diction['name']:
my_data['name'] = diction['name']
if ("etude_level" in diction.keys()):
if diction['etude_level']:
my_data['etude_level'] = diction['etude_level']
now = datetime.now()
my_data['user_recid'] = user_recid
my_data['active'] = '1'
my_data['date_update'] = str(now)
coll_name = MYSY_GV.dbname['user_profil']
#mycommon.myprint(" on recherche recid "+user_recid)
ret_val = coll_name.find_one_and_update(
{'user_recid': user_recid, 'active': '1'},
{"$set": my_data},
upsert=True,
return_document=ReturnDocument.AFTER
)
if (ret_val['_id'] is False):
mycommon.myprint(
str(inspect.stack()[0][3]) + " : Impossible d'ajouter le mode de payement")
return False, "Impossible d'ajouter le mode de payement"
else:
mycommon.myprint( str(inspect.stack()[0][3]) + " La modif du profile a bien ete faite =" + str(ret_val['_id']))
return True, " Le profile a bien été mis à jour"
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"
"""
Recuperation du profil d'un utilisateur
"""
def Get_user_profile(diction):
try:
# Dictionnaire des champs utilisables
field_list = [ '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 récupérer le profil 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(" La valeur '"+val+"' n'est pas presente dans la liste des arguments ")
return False, " Impossible de récupérer le profil de l'utilisateur"
# recuperation des paramettre
partner_token = ""
user_recid = ""
if ("token" in diction.keys()):
if diction['token']:
partner_token = diction['token']
# Recuperation du recid de l'utilisateur
user_recid = mycommon.get_user_recid_from_token(partner_token)
if partner_token is False :
mycommon.myprint(" Impossible de récupérer le profil de l'utilisateur")
return False, " Impossible de récupérer le profil de l'utilisateur"
coll_name = MYSY_GV.dbname['user_profil']
insertObject = []
for val in coll_name.find( {'user_recid': str(user_recid), 'active': '1'}, {'_id':0, 'user_recid':0}):
insertObject.append(mycommon.JSONEncoder().encode(val))
return True, insertObject
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 récupérer le profil de l'utilisateur"
def add_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 = ['name','email','pwd']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(" Le champ '" + val + "' n'existe pas, MAJ annulée")
return False, "Impossible d'ajouter le compte utilisateur. Toutes les informations fournies ne sont pas valables"
'''
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 la liste des arguments ")
return False, "Impossible d'ajouter le compte utilisateur. Toutes les informations necessaires n'ont pas été fournies"
# 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))
coll_name = MYSY_GV.dbname['user_account']
coll_name_partnair_account = MYSY_GV.dbname['partnair_account']
# Verification que cette adresse email n'existe pas. On doit aussi verifier que cette adresse
# n'est pas utiliser comme compte partner.
print(" QRY check partner exist = ", {'email': str(myuser['email']), 'active':'1'})
tmp = coll_name.count_documents({'email': str(myuser['email']), 'active':'1'})
if( tmp > 0 ):
mycommon.myprint("l'adresse email '"+str(myuser['email'])+"' existe deja, impossible de créer le compte ")
return False, "Cette adresse email est deja utilisée, impossible de créer le compte utilisateur"
tmp = coll_name_partnair_account.count_documents({'email': str(myuser['email']), 'active':'1'})
if (tmp > 0):
mycommon.myprint(
"l'adresse email '" + str(myuser['email']) + "' existe deja (compte utiliser comme partner), impossible de créer le compte ")
return False, "Cette adresse email est deja utilisée, impossible de créer le compte utilisateur "
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:
coll_name = MYSY_GV.dbname['user_account']
tmp = coll_name.find({'_id':ObjectId(str(value))})
now = datetime.now()
update = coll_name.find_one_and_update({'_id': ObjectId(str(value)), 'locked': '0'},
{"$set": {'active': "1", "date_update": str(now)}},
return_document=ReturnDocument.AFTER)
ret_val = update
if( ret_val and ret_val['_id']):
mycommon.myprint("La modif a bien ete faite ="+str(ret_val['_id']))
remerciement_ = """
Declenchement de l'envoie du mail de remerciement
"""
status = mail.send_user_thks_mail("", ret_val['email'])
if( status is False ):
mycommon.myprint(" Impossible d'envoyer le mail de remerciement de validation le compte")
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 récupérer 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 and val.startswith('my_') is False:
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 la liste des arguments ")
return False, "Impossible de mettre à jour le compte utilisateur"
mycommon.myprint(" MAJ de diction "+str(diction))
coll_name = MYSY_GV.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"
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
mycommon.myprint(" dictionnary = "+str(dictionnary))
"""
23/12/2024 : Après avoir verifier la validité du token,
on va aller chercher l'_id dans la collection 'user_account'
"""
is_token_valide_for_one_user = MYSY_GV.dbname['user_account'].count_documents({'token':str(diction['token']),
'active':'1', 'locked':'0',
'partner_owner_recid':my_partner['recid']})
if( is_token_valide_for_one_user != 1 ):
mycommon.myprint(str(inspect.stack()[0][3]) + " Le token correspond a plusieurs au aucun utilisateur de la collection 'user_account' ")
return False, "La session est invalide "
ret_val = coll_name.find_one_and_update({'token':str(diction['token']),
'active':'1', 'locked':'0',
'partner_owner_recid':my_partner['recid']},
{"$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 and val.startswith('my_') is False:
mycommon.myprint(" Le champ '" + val + "' n'existe pas, requete annulée")
return False, " Impossible de récupérer 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(str(inspect.stack()[0][3]) + " La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, " Impossible de récupérer 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(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]) +" L'email ou le token ne sont pas valides")
return False, "L'email ou le token ne sont pas valides (1)"
coll_name = MYSY_GV.dbname['user_account']
"""
Si plusieurs personnes ont ce token, alors rejette la connexion, car pas normal.
Un token valide ne doit appartenir qu'a un et seul user
"""
cout_user_with_same_token = coll_name.count_documents({'token': str(token_value), 'locked': '0', 'active':'1'})
if( cout_user_with_same_token > 1 ):
mycommon.myprint(str(inspect.stack()[0][3]) + " Violation des règles du token ")
return False, "L'email ou le token ne sont pas valides (2) "
RetObject = []
for retVal in coll_name.find({'token': str(token_value), 'locked': '0', 'active':'1'}):
#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, " L'email ou le token ne sont pas valides "
'''
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 and val.startswith('my_') is False:
mycommon.myprint(" Le champ '" + val + "' n'est pas autorisé, requete annulée")
return False, " Impossible de récupérer 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 la liste des arguments ")
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 récupérer 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())
coll_name = MYSY_GV.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', 'accounttype']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(" Le champ '" + val + "' n'est pas autorisé, requete annulée")
return False, " Impossible de récupérer 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', 'accounttype']
for val in field_list_obligatoire:
if val not in diction:
mycommon.myprint(" La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, " Impossible de mettre à jour le mot de passe"
# recuperation des paramettre
email_value = ""
token_value = ""
pwd = ""
new_pwd = ""
conf_new_pwd = ""
accounttype = ""
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']
if ("accounttype" in diction.keys()):
if diction['accounttype']:
accounttype = diction['accounttype']
if( accounttype == "1"):
#Traitement d'un user classique
# 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 récupérer 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())
coll_name = MYSY_GV.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},
upsert=False,
return_document=ReturnDocument.AFTER
)
if (ret_val and ret_val['_id']):
# Apres avoir changer le mot passe, desactivation tu token
coll_name = MYSY_GV.dbname['partner_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"
elif( accounttype == "2"):
# Traitement d'un compte pro
# 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 "
"""
/!\ ATTENTION : Pour les pro, on verifie le champ : "tmp_token_pwd" qui est token temporaire generé
pour le lien de reinitialisation.
"""
tmp_retval = MYSY_GV.dbname['partnair_account'].find({'tmp_token_pwd':token_value, 'active':'1'})
if tmp_retval is False or tmp_retval[0] 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_email = tmp_retval[0]['email']
mydata = {}
mydata['date_update'] = str(datetime.now())
mydata['pwd'] = new_pwd
mydata['tmp_token_pwd'] = ""
coll_name = MYSY_GV.dbname['partnair_account']
#print(" le recid PARTENAIRE = " + user_recid + " mydata = " + str(mydata))
ret_val = coll_name.find_one_and_update({'email': user_email, 'locked': '0', 'active': '1'},
{"$set": mydata},
upsert=False,
return_document=ReturnDocument.AFTER
)
if (ret_val and ret_val['_id']):
# Deactivation du token temporaire de mise à jour
retval = MYSY_GV.dbname['partnair_account'].update_many(
{'tmp_token_pwd':str(token_value), 'active':'1'},
{"$unset": {'active': '', 'tmp_token_pwd': '', 'email':''}}
)
mycommon.myprint(str(inspect.stack()[0][3]) + " Le mot de passe a bien été mise à jour")
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 ")
return False, "Impossible de mettre à jour le mot de passe"
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 and val.startswith('my_') is False:
mycommon.myprint(" Le champ '" + val + "' n'existe pas, requete annulée")
return False, " Impossible de récupérer 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 la liste des arguments ")
return False, " Impossible de récupérer 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("La session de connexion n'est pas valide")
return "Err_Connexion", "La session de connexion 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 récupérer le recid du user")
return False, " Impossible de mettre à jour le mot de passe"
mydata['date_update'] = str(datetime.now())
coll_name = MYSY_GV.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 and val.startswith('my_') is False:
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 la liste des arguments ")
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]) + " - La session de connexion n'est pas valide ")
return "Err_Connexion", "La session de connexion 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 récupérer 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 récupérer 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 = MYSY_GV.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) partner_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 and val.startswith('my_') is False:
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 la liste des arguments ")
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 récupérer 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 = MYSY_GV.dbname['user_account']
ret_val = coll_name.find_one_and_update({'recid': str(user_recid)},
{"$set": mydata},
upsert=False,
return_document=ReturnDocument.AFTER
)
print("mydata ="+str(mydata))
print( "user_recid = "+user_recid)
print(str(ret_val))
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 partner_token ou se trouve aussi l'adresse email.
# table : partner_token
partner_token_coll_name = MYSY_GV.dbname['partner_token']
ret_val = partner_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 : partner_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 = MYSY_GV.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 : partner_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 and val.startswith('my_') is False:
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 la liste des arguments ")
return False, "Impossible de mettre à jour le compte utilisateur"
coll_name = MYSY_GV.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'])
# récupérer 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 récupérer 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 and val.startswith('my_') is False:
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 la liste des arguments ")
return False, "Impossible de mettre à jour le compte utilisateur"
coll_name = MYSY_GV.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'])
# récupérer 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 récupérer 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 and val.startswith('my_') is False:
mycommon.myprint(str(inspect.stack()[0][3]) + " Le champ '"+val+"' n'est pas autorisé, opération annulée")
return False, "Impossible de récupérer 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 la liste des arguments ")
return False, "Impossible de récupérer 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]) + " La session de connexion n'est pas valide")
return "Err_Connexion", "La session de connexion 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 récupérer 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 = MYSY_GV.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 récupérer 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 récupérer 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 : partner_token pour le mail, s'il est valide
1 - elle crée une entrée dans la table : partner_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', 'account_type']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
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', 'account_type']
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 la liste des arguments ")
return False, "Impossible de reinitialiser le mot de passe de l'utiilisateur"
'''
Verification de la valider de l'email
'''
myemail = ""
account_type = ""
myquery = {}
if ("email" in diction.keys()):
if diction['email']:
myemail = diction['email']
myquery['email'] = diction['email']
if ("account_type" in diction.keys()):
if diction['account_type']:
account_type = diction['account_type']
if( account_type not in ['partner', 'user']):
mycommon.myprint(str(inspect.stack()[0][3]) + "Le type de compte "+str(account_type)+" est inconnu ")
return False, "Impossible de reinitialiser le mot de passe de l'utiilisateur. Le type de compte est inconnu"
myquery['active'] = '1'
myquery['locked'] = '0'
'''
Si Le champ "secrete" est vide, alors il s'agit d'un compte utilisateur classique
'''
if( account_type == "user"):
'''
Le champ "account_type" est un user
'''
coll_name = MYSY_GV.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 = MYSY_GV.dbname['partner_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 'partner_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"
# Account type 1 is for normal customers
account_type = 1
# envoi de l'email
email_mgt.send_user_init_pwd_mail(mynewtoken, retVal[0]['email'], account_type)
return True, "La demande de reinitiation à été prise en compte"
elif( account_type == "partner"):
'''
Le champ "account_type" est un partenaire
'''
coll_name = MYSY_GV.dbname['partnair_account']
#print(" #### myquery partenaire ="+str(myquery))
tmp = coll_name.count_documents(myquery)
if (tmp <= 0):
mycommon.myprint(str(inspect.stack()[0][3]) + " Aucun resultat trouvé pour le compte pro " + str(myquery))
return True, "La demande de reinitiation à été prise en compte"
retVal = coll_name.find(myquery, {"_id": 0, "valide": 0,})
#print(" ### retVal 001 = ", str(retVal[0]))
"""
Dans le cas exclusif du compte pro,
nous allons créer une token temporaire de reinitialisation, ceci sans perdre de vue que le
token de base ne change pas.
"""
new_token = {}
new_token['date_update'] = str(datetime.now())
# Creation du token
mynewtoken = mycommon.create_token_urlsafe()
new_token['tmp_token_pwd'] = mynewtoken
new_token['active'] = "1"
new_token['email'] = str(myemail)
#print(" ### str(retVal[0]['recid']) = ", str(retVal[0]['recid']))
ret_val = coll_name.find_one_and_update(
{'recid': str(retVal[0]['recid']), },
{"$set": new_token},
upsert=False,
return_document=ReturnDocument.AFTER
)
if ("_id" not in ret_val.keys()):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " : Impossible de reinitialiser le mot de passe")
return False, "Impossible de reinitialiser le mot de passe"
"""
Apres la mise à jour du partner, on insert l'objet qui signifie qu'il y a une
attente de mise à jour de mot de passe
"""
ret_val_tmp = coll_name.find_one_and_update(
{'recid': "tmp_"+str(retVal[0]['recid']), },
{"$set": new_token},
upsert=True,
return_document=ReturnDocument.AFTER
)
if ("_id" not in ret_val_tmp.keys()):
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de créer le nouveau token")
return True, "La demande de réinitialisation à été prise en compte"
# Account type 2 is for PRO customers
account_type = 2
email_mgt.send_user_init_pwd_mail(mynewtoken, retVal[0]['email'],account_type )
return True, "La demande de réinitialisation à é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 réinitialiser le mot de passe"
'''
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', 'accounttype']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
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', 'accounttype']
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 la liste des arguments ")
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']
myaccounttype = ""
if ("accounttype" in diction.keys()):
if diction['accounttype']:
myaccounttype = diction['accounttype']
if( myaccounttype == "1"):
myquery['valide'] = '1'
# il s'agit d'un compte utilisateur
coll_name_token = MYSY_GV.dbname['partner_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 "Err_Connexion", "La session de connexion n'est pas valide"
elif( myaccounttype == "2"):
# Il s'agit d'un compte pro (partenaire)
myquery = {}
myquery['tmp_token_pwd'] = diction['token']
myquery['active'] = '1'
coll_name_token = MYSY_GV.dbname['partnair_account']
tmp = coll_name_token.count_documents(myquery)
if (tmp <= 0):
mycommon.myprint(str(inspect.stack()[0][3]) + " Aucun resultat trouvé pour la" + str(myquery))
return "Err_Connexion", "La session de connexion n'est pas valide"
""" # Deactivation du token temporaire de mise à jour
retval = MYSY_GV.dbname['partnair_account'].update_many(
myquery,
{"$unset": {'active':'', 'tmp_token_pwd':''}}
)
print(" #### IsUserTokenValide = ", retval)
"""
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"