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)})