def login(): data = request.get_json(silent=True) email = data["email"] password = data["password"] user = UsersModel().authenticate(email=email, password=password) if not user: return jsonify({ 'message': 'Invalid Credentials', 'authenticated': False }) # set the session of the user login_session["user_id"] = str(user["_id"]) print(f"user id: {login_session}") response = jsonify({ "token": jwt.encode( { 'sub': user['email'], 'iat': datetime.utcnow(), 'exp': datetime.utcnow() + timedelta(minutes=30) }, app.config['SECRET_KEY']).decode('UTF-8'), "user": { "id": str(user['_id']), "username": user['username'], "email": user['email'] }, 'authenticated': 'true' }) response.headers.add('Access-Control-Allow-Origin', '*') return response
def test_create_user(self): users_model = UsersModel() user_model = UserModel() user = '******' passwd = 'fakepass' group = 'unit_test_fake_group' profile = 'unit_test_fake_profile' common_users = users_model.get_list() params = { 'name': user, 'password': passwd, 'group': group, 'profile': profile } with RollbackContext() as rollback: users_model.create(params) rollback.prependDefer(user_model.delete, user) new_users = users_model.get_list() self.assertEqual(len(new_users), len(common_users) + 1) enc_passwd = spwd.getspnam(user)[1] invalid_passwd = [None, "NP", "!", "!!", "", "LK", "*"] self.assertNotIn(enc_passwd, invalid_passwd) self.assertEqual(crypt.crypt(passwd, enc_passwd), enc_passwd)
def test(self): users_model = UsersModel(PostgresConnection().get_connection()) users_amount = users_model.amount()[0] username = random_string() password = random_string() returned_data = users_model.create({ "name": "name", "role": 1, "date_registration": date.today(), "username": username, "pwd_hash": password, "pwd_salt": uuid.uuid4().hex, "date_last_update": date.today(), "status": True }) assert (users_amount + 1 == users_model.amount()[0]) user = users_model.read({'username': username}) assert (user['role'] == 1) new_username = random_string() users_model.update({"username": new_username}, {"id": returned_data['id']}) user = users_model.read({"username": new_username}) assert (user is not None) users_model.delete({"id": returned_data['id']}) assert (users_model.read({"username": new_username}) is None)
def create(): content = request.json username = content['username'] user_exists = UsersModel.find_user_by_username(username) if user_exists: return jsonify(success=False, msg='Username already exists'), 409 email = content['email'] email_exists = UsersModel.find_user_by_email(email) if email_exists: return jsonify(success=False, msg='Email already used'), 409 password = content['password'] display_name = content['displayName'] new_user = UsersModel(username, hashlib.sha256(password.encode("utf-8")).hexdigest(), email) new_user.save_to_db() new_location = LocationsModel(new_user, 0.0, 0.0) new_location.save_to_db() premade = '[{"key":"InitialGreeting","title":"Greetings","text":"Hi, this is ' + display_name + '"}]' new_pass = PassesModel(new_user, display_name, premade) new_pass.save_to_db() return jsonify(success=True), 200
def post(self): data = Users.parser.parse_args() if UsersModel.find_by_email(data['email']): return { 'data': { 'status': False, 'message': "Email Already Regsitered" } }, 201 if UsersModel.find_by_phone(data['phone_number']): return { 'data': { 'status': False, 'message': "Phone Number Already Registered" } }, 201 # return {'error': "Phone Number Already Registered"}, 400 user = UsersModel(data['fname'], data['lname'], data['email'], data['phone_number'], data['password']) user.save_to_db() return { 'data': { 'status': True, 'message': "Registration Successful" } }, 201
def generate(): if roles_required(["admin", "registrar"]) == 400: return jsonify({"msg": "no access"}), 400 if not request.is_json: return jsonify({"msg": "Missing JSON in request"}), 400 try: num = request.json['number'] users_model = UsersModel(PostgresConnection().get_connection()) notarius_model = NotariusModel(PostgresConnection().get_connection()) blank_model = BlankModel(PostgresConnection().get_connection()) usages_register_model = UsagesRegisterModel( PostgresConnection().get_connection()) journal_actions_model = JournalActionsModel( PostgresConnection().get_connection()) verifications_register_model = VerificationsRegisterModel( PostgresConnection().get_connection()) code_usages_blank_model = CodeUsagesBlankModel( PostgresConnection().get_connection()) users_model.generate_data(num) notarius_model.generate_data(num) blank_model.generate_data(num) usages_register_model.generate_data(num) journal_actions_model.generate_data(num) verifications_register_model.generate_data(num) code_usages_blank_model.generate_data(num) except Exception as e: return jsonify({"msg": str(e)}), 400 return jsonify({"msg": "data generated"}), 200
def init_users(self): user1 = UsersModel(mail='*****@*****.**', google_token='juy65rfty76Hg65FVytfGGDD63ccxeDFg', role=0) user1.country = 'España' user1.id_bank_data = 1234567890123456 user1.name = 'Joan' user1.surname = 'Martin' user1.national_id_document = '23432123P' user1.save_to_db() user2 = UsersModel(mail='*****@*****.**', google_token='jug65FVytfGGDD63ccxeDFg', role=0) user2.country = 'España' user2.id_bank_data = 6543217890123456 user2.name = 'Juan' user2.surname = 'Martínez' user2.national_id_document = '23845467M' user2.save_to_db()
def put(self, Email): data = self.parser.parse_args() user = UsersModel.find_by_Email(Email) if user: user = UsersModel(Email, **data) user.save_to_db() return user.json() else: return {'message': 'User not found.'}, 404
def post(self): data = request.get_json(force=True) if UsersModel.find_by_username(data['username']): return { 'message': 'Username is existed, please use another name.' }, 400 data['_id'] = 0 user = UsersModel(data) user.insert_to_db() return {'message': 'user has been created successfully.'}, 201
def post(self): # register interface req_data = request.get_json() user_name = req_data.get('username', None) user_pass = req_data.get('password', None) if not user_name or not user_pass: return StandardResponse(403, 1, 'Forbidden') user = UsersModel(user_name, user_pass) try: user.add(user) except Exception, e: return StandardResponse(500, 1, e.message)
def post(self): """ 用户注册 :return: json """ self.parser.add_argument( "email", type=inputs.regex( r'(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)'), required=True, location="json", help='email format is incorrect') self.parser.add_argument("username", type=str, required=True, location="json", help='username is required') # self.parser.add_argument("permission", type=str, choices=['test', 'guest', 'user', 'admin', 'superAdmin'], required=True, location="json", # help='permission is required and only (test,user,admin,superAdmin)') self.parser.add_argument("permission", type=str, required=True, location="json", help='permission is required') self.parser.add_argument("password", type=password_len, required=True, location="json", trim=True) args = self.parser.parse_args() userEmailInfo = UsersModel.query.filter_by(email=args.email).all() for item in userEmailInfo: if item.id != args.id: return pretty_result(code.ERROR, msg='该邮箱已经被注册!') user = UsersModel(email=args.email, username=args.username, password=UsersModel.set_password( UsersModel, args.password), permission=args.permission) result = UsersModel.add(UsersModel, user) if user.id: returnUser = { 'id': user.id, 'username': user.username, 'email': user.email, 'login_time': user.login_time } return pretty_result(code.OK, data=returnUser, msg='用户注册成功') else: return pretty_result(code.ERROR, data='', msg='用户注册失败(用户名或邮箱已存在)')
def post(self, Email): if UsersModel.find_by_Email(Email): return {'message': "An user with Email '{}' already exists.".format(Email)}, 400 data = self.parser.parse_args() user = UsersModel(Email, **data) try: user.CreatedOn = datetime.utcnow() user.save_to_db() except: return {"message": "An error occurred while inserting the user."}, 500 return user.json(), 201
def post(self): """ POST method Adds a new account Return: dict (account created / message) """ data = parser.parse_args() if not data['mail']: return {'message': {"mail": "Mail cant be empty"}}, 400 if not data['google_token']: return { 'message': { "google_token": "Google token cant be empty" } }, 400 if not data['role']: return {'message': {"role": "Role cant be empty"}}, 400 if UsersModel.find_by_mail(data['mail']): return { 'message': "Account with mail [{}] already exists".format(data['mail']) }, 409 user = UsersModel(google_token=data['google_token'], mail=data['mail'], role=data['role']) if data['role'] != '0': try: user.save_to_db() return {'user': UsersModel.find_by_mail(user.mail).json()}, 201 except: return {"message": "Error Description"}, 500 else: try: user.save_to_db() return {'user': UsersModel.find_by_mail(user.mail).json()}, 201 except: return {"message": "Error Description"}, 500
def post(self): """ Insert multi-instances """ jsondata = request.get_json() if not jsondata or jsondata['username'] is None: return pretty_response(40001) if UsersModel.query.filter_by(username=jsondata['username']).first(): return pretty_response(40002) try: users_instance = UsersSchema().load(jsondata) users_instance = UsersModel( jsondata['username'], jsondata['password']) users_instance.add(users_instance) users_dump = UsersSchema().dump(users_instance) return pretty_response(200, users_dump) except ValidationError as e: current_app.logger.error(e.messages) return pretty_response(40003) except SQLAlchemyError as e: current_app.logger.error(e) return pretty_response(50001)
def __init__(self): self._connection = PostgresConnection().get_connection() self._cursor = self._connection.cursor(cursor_factory=DictCursor) self._create_tables() self._code_usages_blank_model = CodeUsagesBlankModel(self._connection) self._notarius_model = NotariusModel(self._connection) self._blank_model = BlankModel(self._connection) self._usages_register_model = UsagesRegisterModel(self._connection) self._users_model = UsersModel(self._connection) self._journal_actions_model = JournalActionsModel(self._connection) self._verifications_register_model = VerificationsRegisterModel( self._connection) self._users_model.generate_data(5000) self._notarius_model.generate_data(5000) self._blank_model.generate_data(5000) self._usages_register_model.generate_data(5000) self._journal_actions_model.generate_data(5000) self._verifications_register_model.generate_data(5000) self._code_usages_blank_model.generate_data(5000)
def test_creating_existing_user_fails(self): users_model = UsersModel() user_model = UserModel() user = '******' passwd = 'fakepass' group = 'unit_test_fake_group' profile = 'unit_test_fake_profile' params = { 'name': user, 'password': passwd, 'group': group, 'profile': profile } with RollbackContext() as rollback: users_model.create(params) rollback.prependDefer(user_model.delete, user) with self.assertRaises(OperationFailed): users_model.create(params)
def generate_data(self, num: int): try: auxiliary_model = UsersModel(self._connection) auxiliary_list = auxiliary_model.read_all() length = len(auxiliary_list) for i in range(0, num): self.create({ "user_id": auxiliary_list[random_int_from_zero_to_num(length)]['id'], "action_date": date.today(), "action_type": random_int_from_zero_to_num(), "row_affected": random_string(), "old_value": random_string(), "new_value": random_string() }) except Exception as e: return str(e)
def post(self): data = self.parser.parse_args() user = UsersModel(**data) user.created_by = 1 user.created_on = datetime.now() user.modified_by = 0 user.deleted_by = 0 user.modified_on = None user.deleted_on = None try: validateObj = UsersModel.validateData(data, request) if type(validateObj) is dict: return {"success": False, "errors": validateObj}, 400 if UsersModel.find_by_name(data['email']): return { "success": False, "message": "A user with that Record Name already exists" }, 400 name = data['email'] if name.strip(): user.save_to_db() user.token = encodeID(user.user_id) user.save_to_db() else: return { "success": False, "message": "String Should not be empty" } except Exception as e: return { "message": "An error occurred creating the Record.'{}'".format(e) }, 500 return user.json(), 201
def post(self): data = Users.parser.parse_args() if UsersModel.find_by_email(data['email']): return {'data':{'status': False, 'message': "Email Already Regsitered"}}, 201 if UsersModel.find_by_phone(data['phone_number']): return {'data':{'status': False, 'message': "Phone Number Already Registered"}}, 201 # return {'error': "Phone Number Already Registered"}, 400 if data['register_ref'] == "0": refcode = UsersModel.getRefCode(data['fname']) user = UsersModel(data['fname'], data['lname'], data['email'], data['phone_number'], data['password'],refcode, data['register_ref'],0,"fcm") try: user.save_to_db() except: return {'message': "An Error Occured"}, 500 return {'data':{'status': True, 'message': "Registration Successful"}}, 201 else: user_ref = UsersModel.find_by_refcode(data['register_ref']) if user_ref is not None: no = user_ref.register_ref_no if no == 2: return {'data': {'status': False, 'message': "User Crossed his/her Limit"}} #refernece code cannot be added. User crosseds the limit elif no < 2: no = no + 1 user_ref.register_ref_no = no try: db.session.commit() except: return {'message': "An Error Occured"}, 500 userpromo = UserPromoModel(user_ref.id, "REF020", "2018-12-12", False) try: userpromo.save_to_db() except: return {'message': "User promo table Error"}, 500 refcode = UsersModel.getRefCode(data['fname']) user = UsersModel(data['fname'], data['lname'], data['email'], data['phone_number'], data['password'],refcode, data['register_ref'],0,"fcm") try: user.save_to_db() user_id_for_promo = user.id userpromo_u = UserPromoModel(user_id_for_promo, "REF010", "2018-12-12", False) userpromo_u.save_to_db() except: return {'message': "An Error Occured"}, 500 return {'data':{'status': True, 'message': "Registration Successful"}}, 201 else: return {'data': {'status': False, 'message': "Reference Code Invalid"}}
import unittest import uuid from datetime import date from connection import PostgresConnection from models.journal_actions import JournalActionsModel from models.users import UsersModel from random_data_generators import (random_int, random_string) users_model = UsersModel(PostgresConnection().get_connection()) users_returned_data = {'id': 0} class TestJournalActions(unittest.TestCase): def setUp(self): returned_data = users_model.create({ "name": "name", "role": 1, "date_registration": date.today(), "username": random_string(), "pwd_hash": random_string(), "pwd_salt": uuid.uuid4().hex, "date_last_update": date.today(), "status": True }) users_returned_data['id'] = returned_data['id'] def test(self): journal_actions_model = JournalActionsModel( PostgresConnection().get_connection()) journal_actions_amount = journal_actions_model.amount()[0]
def test_get_users_list(self): model = UsersModel() users = model.get_list() self.assertGreaterEqual(len(users), 0)