def post(self):
data = User.parser.parse_args()
first_name = data['first_name']
last_name = data['last_name']
email = data['email']
password = data['password']
if UserModel.find_by_email(email):
return {
'result': 'Email {} is already registered'.format(email)
}, 400
user = UserModel(userid=str(uuid.uuid1()),
first_name=first_name,
last_name=last_name,
email=email,
password=password)
user.set_password()
try:
user.save_to_db()
return user.json()
except Exception as err:
return {
'result':
'There was an error while registering your email {}'.format(
email)
}, 500
def post(self):
data = EmployeeController.parser.parse_args()
username = data['username']
email = data['email']
if (UserModel.find_by_username(username)
or UserModel.find_by_email(email)):
return {'message': "User already exists."}, 400
# Because only admin can create employee
admin_user = AdminModel.find_by_user_id(current_identity.id)
if not admin_user:
abort(403,
message="Please use admin or ask admin to crete company.")
# Create a new Employee user
employee = EmployeeModel(isAdmin=data['isAdmin'])
user_data = data
del user_data['isAdmin']
user = UserModel(**user_data)
user = user.hash_password()
user.employee_id = employee
employee.user_id = user
# save the database
try:
db.session.add(user)
db.session.add(employee)
db.session.commit()
except (ArgumentError, DataError):
abort(500,
message="Server internal error due to invalid argument.")
return employee.get_employee(user), 201
def custom_jwt_authenticate(email, password):
user = UserModel.find_by_email(email)
if not user:
abort(401)
if not (user and bcrypt.check_password_hash(user.password, password)):
abort(401)
return user
def post(self):
data = _user_parser.parse_args()
if UserModel.find_by_email(data['email']):
return {
'message': 'A user with that username already exists.'
}, 400
user = UserModel(data['email'], data['password'])
user.save_to_db()
return {"message": "User created successfully."}, 201
def get(self):
userid = request.args.get('userid')
email = request.args.get('email')
if userid:
user = UserModel.query.get(userid)
elif email:
user = UserModel.find_by_email(email)
else:
return {'result': 'Invalid parameter'}, 400
if user:
print(user.json())
return {'result': user.json()}
return {'result': 'User not found'}, 404
def test_crud(self):
with self.app_context():
# to test user we need to create user right
right = UserRightModel('test right')
right.save_to_db()
user = UserModel('*****@*****.**', 'abcd')
self.assertIsNone(
UserModel.find_by_email('*****@*****.**'),
"Found a user with e-mail '*****@*****.**' before save_to_db.")
self.assertIsNone(UserModel.find_by_id(1),
"Found a user with id '1' before save_to_db.")
user.save_to_db()
self.assertIsNotNone(
UserModel.find_by_email('*****@*****.**'),
"Did not find a user with e-mail '*****@*****.**' after save_to_db"
)
self.assertIsNot(
UserModel.find_by_id(1),
"Did not find a user with id '1' after save_to_db")
def post(cls):
data = _user_parser.parse_args()
user = UserModel.find_by_email(data['email'])
if user and user.right_id > 1 and safe_str_cmp(user.password,
data['password']):
access_token = create_access_token(identity=user.id, fresh=True)
refresh_token = create_refresh_token(user.id)
return {
'access_token': access_token,
'refresh_token': refresh_token
}, 200
return {"message": "Invalid credentials"}, 401
def test_register_user(self):
with self.app() as c:
with self.app_context():
r = c.post('/register',
data={
"email": "*****@*****.**",
"password": "******"
})
self.assertEqual(
r.status_code, 201,
f"Error in request, expected response 201, obtained {r.status_code}."
)
self.assertIsNotNone(UserModel.find_by_email("*****@*****.**"))
self.assertDictEqual(
d1={"message": "User created successfully."},
d2=json.loads(r.data))
def post(self):
data = request.get_json(silent=True)
try:
user = UserModel.find_by_email(data["email"])
if user:
if user.check_password(data["password"]):
token = create_access_token(identity=user.uuid, fresh=True)
return {"token": token, "uuid": user.uuid}, 200
return {"message": "Wrong password"}, 401
return {"message": "No user found"}, 401
except:
return {"message": "Cannot write Data"}, 500
def test_register_and_login(self):
with self.app() as c:
with self.app_context():
r = c.post('/register',
data={
"email": "*****@*****.**",
"password": "******"
})
user = UserModel.find_by_email("*****@*****.**")
user.right_id = 2
user.save_to_db()
login = c.post('/login',
data=json.dumps({
"email": "*****@*****.**",
"password": "******"
}),
headers={'Content-Type': 'application/json'})
self.assertIn('access_token',
json.loads(login.data).keys(),
"Access token is not found after user login")
def post(self):
data = parser.parse_args()
new_user = UserModel(
username=data.get("username"),
password=UserModel.generate_hash(data.get("password")),
email=data.get("email"),
)
try:
if UserModel.find_by_username(data.get("username")) or UserModel.find_by_email(data.get("email")):
return {"message": f"User alread exists"}
new_user.save_to_db()
access_token = create_access_token(identity=data.get("username"))
refresh_token = create_refresh_token(identity=data.get("username"))
return {
"message": f"User {data.get('username')} was created",
"access_token": access_token,
"refresh_token": refresh_token,
}
except:
return {"message": "Something went wrong"}, 500
def test_blocked_user_login(self):
with self.app() as c:
with self.app_context():
r = c.post('/register',
data={
"email": "*****@*****.**",
"password": "******"
})
user = UserModel.find_by_email("*****@*****.**")
self.assertEqual(user.right_id, 1)
login = c.post('/login',
data=json.dumps({
"email": "*****@*****.**",
"password": "******"
}),
headers={'Content-Type': 'application/json'})
self.assertNotIn('access_token',
json.loads(login.data).keys(),
"A blocked User logged in successfully.")
self.assertDictEqual({"message": "Invalid credentials"},
json.loads(login.data))
def authenticate(email, password):
user = UserModel.find_by_email(email)
if user and safe_str_cmp(user.password, password):
return user
