def post(self):
# nombre, apellido_paterno, apellido_materno, email, contraseña, sexo, no_hijos, estado_civil, fecha_nacimiento, direccion?
client = json.loads(self.request.body.decode('utf-8'))
__model = UserModel()
try:
if 'facebook' in client:
# id, apellido paterno, email, nombre
registered = yield __model.check_registered_client(
client['email'])
if registered:
self.set_status(200)
self.write({'message': True})
else:
register = yield __model.register_client_by_facebook(
client)
self.set_status(200)
self.write({'message': False})
else:
registered = yield __model.check_registered_client(
client['email'])
if registered:
raise Exception('Ese email ya está registrado.')
status, message = yield __model.register_client_persona_table(
client)
if status == 400:
raise Exception(message)
self.set_status(status)
self.write({'message': message})
except Exception as err:
self.set_status(400)
print(err)
traceback.print_exc()
self.write({'message': str(err)})
self.finish()
def post(self):
token = json.loads(self.request.body.decode('utf-8'))
__model = UserModel()
status, message = yield __model.persona_update_token_fcm(
token['id_persona'], token['token'])
self.set_status(status)
self.finish({'message': message})
def get(self, id_persona):
try:
dirname = os.path.dirname(__file__)
user_model = UserModel()
id_cliente = yield user_model.get_client_id_by_person_id(
id_persona)
if not id_cliente:
raise Exception('Cliente no encontrado')
try:
filename = os.path.join(dirname,
'recoms/' + str(id_cliente) + '.json')
file = open(filename, 'r')
file = file.read()
recom = json.loads(file)
except:
product_model = ProductModel()
util = UtilProject()
recom = yield product_model.get_default_recommendations()
recom = util.cast_numeric_to_string(recom, 'precio_venta')
recom = util.cast_numeric_to_string(recom, 'score')
self.set_status(200)
self.write({'recommendations': recom})
except Exception as error:
self.set_status(400)
self.write({'message': str(error)})
def post(self):
data = json.loads(self.request.body.decode('utf-8'))
try:
if 'user' in data and 'password' in data:
__model = UserModel()
correct_credentials = yield __model.administrador_login(data['user'], data['password'])
if not correct_credentials:
raise Exception('Usuario o contraseña incorrectos')
user_data = yield __model.empleado_login_data(data['user'])
payload = {'key' : 'token_admin_super_secreto', 'id_user' : user_data['id_empleado']}
jwt_token = jwt.encode(payload,JWT_SECRET,JWT_ALGORITHM)
json_response = {
'token': jwt_token.decode('utf-8'),
'name': user_data['nombre'],
'shop_name': user_data['nombre_tienda'],
'shop_id': user_data['id_tienda'],
'department_name': user_data['nombre_departamento'],
'departament_id': user_data['id_departamento'],
'pat_surname': user_data['apellido_paterno'],
'mat_surname': user_data['apellido_materno'],
'image' : user_data['imagen'],
'email': user_data['email'],
'id_administrador': user_data['id_empleado']
}
self.set_status(200)
self.finish(json_response)
else:
raise Exception('Favor de cumplir los campos necesarios')
except Exception as err:
self.set_status(400)
self.finish(json.dumps({'message': str(err)}))
async def retrieve_user(self, request, payload, *args, **kwargs):
"""
only two client, 1 pc, 1 mobile,
so, at the time of login, generate two tokes depending on the login device. see login function
:param request:
:param payload:
:param args:
:param kwargs:
:return:
"""
collection = app.mongo["account_center"].user
user_model = UserModel(collection)
print("retrieve_user payload is ", payload)
only_user = kwargs.get("only_user", None)
if not payload:
raise AuthenticationFailed()
user_id = payload.get("user_id", None)
if user_id is None:
raise exceptions.InvalidAuthorizationHeader()
docs = await user_model.find_by_id(user_id)
if not docs:
raise InvalidAuthorizationHeader()
if only_user:
return UserLoginAfter(**docs).to_dict()
login_device = await get_login_device(request)
access_token = await app.redis.get("{}_{}".format(login_device, user_id))
if not access_token:
raise AuthenticationFailed()
# token = self._get_token(request) # 2018-09-21 18:24:00, wym.........
# if token != access_token:
# raise AuthenticationFailed()
return UserLoginAfter(**docs).to_dict()
def post(self):
try:
self.__model = UserModel()
data = json.loads(self.request.body.decode('UTF-8'))
if not 'id_persona' in data and not 'id_producto' in data and not 'favorito' in data:
raise Exception('No cumples con los datos necesarios.')
id_cliente = yield self.__model.get_client_id_by_person_id(data['id_persona'])
if not id_cliente:
raise Exception('Ha ocurrido un error al buscar el cliente.')
if data['favorito'] is 1:
registered = yield self.__model.existent_favourite(id_cliente, data['id_producto'])
if registered:
raise Exception('Este producto ya estaba agregado a tus favoritos.')
register = yield self.__model.add_client_favourite(id_cliente, data['id_producto'])
if not register:
raise Exception('Ha ocurrido un error.')
self.set_status(200)
self.write({'message': 'Producto agregado a favoritos'})
else:
errased = yield self.__model.remove_client_favourite(id_cliente, data['id_producto'])
if not errased:
raise Exception('Ha habido un problema al remover de favoritos.')
self.set_status(200)
self.write({'message' : 'Se ha removido el producto de favoritos.'})
except Exception as error:
self.set_status(400)
self.write({'message' : str(error)})
def post(self):
"""
Create a new user after verifying that all details are provided
"""
data = register_parser.parse_args()
username = data["username"]
if UserModel.find_by_username(username):
return {"message": f"User {username} already exists"}
new_user = UserModel(
username=username,
email=data["email"],
full_name=data["full_name"],
password=UserModel.generate_hash(data["password"])
)
try:
new_user.save_to_db()
access_token = create_access_token(
identity=username, expires_delta=False)
return {
"message": f"User {username} was created",
"access_token": access_token
}
except:
return {"message": "Something went wrong"}, 500
async def after_server(app, loop):
print("begin after server start...")
app.consumer = AIOKafkaConsumer(
'article',
"user",
"message",
loop=loop,
bootstrap_servers=kafka_host,
group_id="my-group-ubuntu123",
value_deserializer=lambda m: json.loads(m.decode('ascii')))
# app.article_consumer = AIOKafkaConsumer(
# 'article',
# loop=loop, bootstrap_servers=kafka_host,
# group_id="my-group123")
# self.collection = app.mongo["account_center"].user
# self.user_model = UserModel(self.collection)
init_redis = InitRedis(app.redis,
UserModel(app.mongo["account_center"].user))
await init_redis.init_user_info_to_redis()
# init redis follower and friend relationship
# init user info to redis
# async for msg in app.consumer:
# print("consumed: ", msg.topic, msg.partition, msg.offset,
# msg.key, msg.value, msg.timestamp)
# loop.run_until_complete(consume(loop))
await app.consumer.start()
await process(app.consumer, app)
# await process(app.article_consumer)
print("finish server init...")
def createUser(params):
is_valid_password = not verifyPassword(params.password)
if is_valid_password:
return {
"message": "Wrong password, please enter a valid one",
"error": True,
"data": None
}
if not userExists(params.email):
ciphered_password = __cipherData(params.password)
user_model = UserModel(
name=params.name,
password=ciphered_password,
email=params.email,
)
user_model.save()
else:
return {
"message":
"This user already exist, plis try to recover your password if you dont remember it",
"error": True
}
return {
"message": "User created successfully",
"error": False,
"data": None
}
def put(self):
vendedor = json.loads(self.request.body.decode('utf-8'))
__model = UserModel()
status, message = yield __model.vendedor_update_info(
self._user_id, vendedor)
self.set_status(status)
self.finish({'message': message})
def on_post(self, req, resp):
"""Handles POST requests"""
# Add user to the DB
email = req.get_param('email')
first_name = req.get_param('first_name')
middle_name = req.get_param('middle_name')
last_name = req.get_param('last_name')
display_name = req.get_param('display_name')
password = req.get_param('password')
today = datetime.utcnow()
user_to_add = UserModel(email=email,
first_name=first_name,
middle_name=middle_name,
last_name=last_name,
display_name=display_name,
password=password,
created=today,
modified=today)
try:
req.context['session'].add(user_to_add)
req.context['session'].commit()
except IntegrityError as e:
req.context['session'].rollback()
raise falcon.HTTPFound('/app/create_email_exists')
else:
# Send user to the login page if their account was created
raise falcon.HTTPFound('/app/login')
def post(cls):
data = _user_parser.parse_args()
user = UserModel.find_by_username(data["username"])
if user:
return {"message": USER_ALREADY_EXISTS.format(data["username"])}, 400
UserModel(**data).save_to_db()
return {"message": USER_CREATED}, 201
def post(self):
data = UserRegister.parse.parse_args()
if UserModel.find_by_username(data['user_name']):
return {'msg': 'User already exists.'}, 400
UserModel(**data).save_to_db()
return {'msg': 'User created'}, 201
def post(self):
gmail_user = '******'
gmail_password = '******'
try:
user = UserModel()
data = json.loads(self.request.body.decode('utf-8'))
password = yield user.get_password_by_email(data['email'])
if not password:
raise Exception(
'No se ha encontrado un usuario registrado con ese correo.'
)
server = smtplib.SMTP_SSL('smtp.gmail.com', 465)
server.login(gmail_user, gmail_password)
sent_from = gmail_user
to = [data['email']]
subject = 'Olvidaste tu contrasenia de Sapphire?'
body = "Hola! \n Tu contrasenia es: %s \n Esperamos volver a verte pronto!" % password
email_text = """\
From: %s
To: %s
Subject: %s
%s
""" % (sent_from, ", ".join(to), subject, body)
server.sendmail(sent_from, to, email_text)
server.close()
self.set_status(200)
self.write({
'message':
'Tu contraseña está en tu correo, esperamos verte pronto!'
})
except Exception as error:
self.set_status(400)
self.write({'message': error})
def get(self, id_usuario, id_departamento):
try:
util = UtilProject()
user_model = UserModel()
product_model = ProductModel()
products = yield product_model.get_products_by_department(
id_departamento)
id_cliente = yield user_model.get_client_id_by_person_id(
id_usuario)
if not id_cliente:
raise Exception('Cliente no encontrado')
client = yield user_model.get_client_thetas(id_cliente)
if client['thetas']:
client['theta'] = np.array([client['thetas']],
dtype=np.longdouble)
del client['thetas']
for product in products:
product['x'] = np.array([product['x']],
dtype=np.longdouble)
client = yield user_model.get_purchases_and_favs_by_client(
client)
favs = client['favs']
purchases = client['purchases']
recommendations = []
for product in products:
if not any(
d['fk_id_producto'] == product['id_producto']
for d in favs) or not any(
d['fk_id_producto'] == product['id_producto']
for d in purchases):
recommendations.append({
'id_producto':
product['id_producto'],
'score':
np.matmul(client['theta'].T, product['x'])[0][0] +
product['mu']
})
recommendations = yield product_model.get_recommendations_specific_info(
recommendations
) #obtenemos los datos de cada recomendacion
recommendations = sorted(
recommendations, key=lambda k: k['score'],
reverse=True) #ordenamos de mayor a menor
recommendations = recommendations[:15]
else:
recommendations = yield product_model.get_default_recommendations_department(
id_departamento)
recommendations = util.cast_numeric_to_string(
recommendations, 'precio_venta')
recommendations = util.cast_numeric_to_string(
recommendations, 'score')
self.set_status(200)
self.write({'recommendations': recommendations})
except Exception as error:
import traceback
traceback.print_exc()
self.set_status(400)
self.write({'message': str(error)})
"""
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_the_username(data["username"]):
return {"message": "A username {0} already exists".format(data["username"])}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(self):
args = parser.parse_args()
user = UserModel(username=args["username"])
user.get_by_username()
if user and user.verify_password(args["password"]):
user_token = create_access_token(identity=user.id)
return {"access_token": user_token}, 200
return {"message": "invalid username or password"}, 401
def post(self):
data = UserRegister.parser.parse_args()
user = UserModel(**data)
if UserModel.find_by_username(data['username']):
return {'message': 'A user with that username already exist'}, 400
user.save_user_to_database()
return {'message': 'User created succesfully'}
def get(self, id_persona):
try:
__model = UserModel()
likes = yield __model.get_client_likes(id_persona)
self.write({'likes': likes})
self.set_status(200)
except Exception as error:
self.set_status(400)
self.write({'message': str(error)})
def get(self, id_persona):
try:
__model = UserModel()
permissions = yield __model.get_client_permissions(id_persona)
self.write({'permisos': permissions['permisos']})
self.set_status(200)
except Exception as error:
self.set_status(400)
self.write({'message': str(error)})
def post(self):
data = self.parser.parse_args()
# user=UserModel(data['username'],data['password'])
user = UserModel(**data)
user.save_to_db()
return {'message': 'User created successfully'}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return {"message": "a user with that username already exists"}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "user created successfully"}, 201
def user_signup_controller(req, res, abort):
if not req.json or not 'username' in req.json:
abort(400)
UserModel(username=req.json['username'],
password=hashpw(req.json['password'].encode('UTF-8'),
gensalt(SALT_WORK_FACTOR))).save()
resp = res(json.dumps({'success': True}), 200)
resp.headers['content-type'] = 'application/json'
return resp
def create():
try:
user_data = request.get_json()
user = UserModel(user_data)
user.save()
return custom_response({'message': 'Usuário criado com sucesso!', 'id': user.id}, 200)
except Exception as e:
print(e)
return custom_response({'message': 'Houve um erro ao criar o Usuário'}, 400)
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'Username already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'User created successfully'}, 201
async def post(self, request, *args, **kwargs):
# check captcha
captcha_key = request.json.get("captcha_mark", None)
captcha_num = request.json.get("captcha", None)
assert captcha_key, "验证码未填写"
await self.check_captcha(captcha_key, captcha_num)
registered_phone = request.json.get('registered_phone', None)
password = request.json.get('password', None)
print("request ---------------------")
# # print(dir(request))
print(request.cookies)
helper = MyCustomUserAuthHelper()
user = await helper.register_new_user(
registered_phone=registered_phone, password=password)
await send_kafka_server.send_to(app=app,
topic="user",
message_type="register",
body=user)
init_redis = InitRedis(app.redis,
UserModel(app.mongo["account_center"].user))
await init_redis.init_registered_info_to_redis(user)
access_token, output = await self.responses.get_access_token_output(
request, user, self.config, self.instance)
refresh_token = await self.instance.auth.generate_refresh_token(
request, user)
output.update({self.config.refresh_token_name(): refresh_token})
user_id = user.get("user_id", None)
key = "refresh_token_{user_id}".format(user_id=user_id)
res = await app.redis.set(key, refresh_token)
login_device = await get_login_device(request)
await app.redis.set("{}_{}".format(login_device, user_id),
access_token,
expire=EXPIRATION_DELTA)
output.clear()
output.update(
response_package(
"200", {
"access_token": access_token,
"refresh_token": refresh_token,
"user_info": user
}), )
response = self.responses.get_token_reponse(
request,
access_token,
output,
refresh_token=refresh_token,
config=self.config)
# print(response.headers)
# print(response)
return response
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return { 'message': 'User with username: "******" already exists in database'.format(data['username'])}, 400
user = UserModel(**data)
user.save_to_db()
return { 'message': 'User created successfully.' }, 201
def post(self):
data = RegisterUser.parser.parse_args()
if UserModel.search_by_username(data['username']):
return {
'message': 'A user with the same username already exists '
}, 400
user = UserModel(**data)
user.save_to_db()
return {'message': 'user created'}, 201
def post(self):
'''Register a user'''
data = _user_parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "A user with that username already exists"}, 400
user = UserModel(**data)
user.save()
return {"message": "User created successfully."}, 201
def get(self, id_persona):
try:
__model = UserModel()
client_information = yield __model.get_client_information(
id_persona)
self.write({'informacion': client_information})
self.set_status(200)
except Exception as error:
self.set_status(400)
self.write({'message': str(error)})
