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)
