def post(self):
data = LoginUser.parser.parse_args()
if (UserModel.find_by_username(data['email'], data['password'])):
user = UserModel.find_by_username(data['email'], data['password'])
return user.json()
return {'message': 'Invalid login credential'}
def test_crud(self):
with self.app_context():
user = UserModel('test-user', '12345')
self.assertIsNone(
UserModel.find_by_username('test-user'),
"Found a user with username {}, but expected not to.".format(
user.username))
self.assertIsNone(UserModel.find_by_id(1))
user.save_to_db()
self.assertIsNotNone(UserModel.find_by_username('test-user'))
self.assertIsNotNone(UserModel.find_by_id(1))
def post(self):
data = parser.parse_args()
username = data['username']
# Searching user by username
current_user = UserModel.find_by_username(username)
# user does not exists
if not current_user:
return jsonify({'message': f'User {username} doesn\'t exist'})
# user exists, comparing password and hash
if UserModel.verify_hash(data['password'], current_user.password):
# generating access token and refresh token
access_token = create_access_token(
identity=username, expires_delta=timedelta(hours=2))
refresh_token = create_refresh_token(identity=username)
return jsonify({
'message': f'Logged in as {username}',
'access_token': access_token,
'refresh_token': refresh_token
})
else:
return jsonify({'message': "Wrong credentials"})
def post():
user = UserRegisterResource.parser.parse_args()
if UserModel.find_by_username(user.username):
abort(409, message="User Already Exists")
new_user = UserModel(**user)
new_user.add_user()
return {'message': f"added {new_user.username}"}, 201
def put(self, id_profile):
data = parser.parse_args()
fullName = data['fullName']
username = get_jwt_identity()
current_user = UserModel.find_by_username(username)
if not current_user:
return make_response(jsonify({'message': f'no user has that jwt'}),
500)
user_id = current_user.id
profile_model = ProfileModel.query.filter_by(id=id_profile,
user_id=user_id).first()
if not profile_model:
return make_response(
jsonify({
'message':
f'user does not own profile with id {id_profile}'
}), 500)
valid_data = ProfileModel.put(self, id_profile, fullName)
if not valid_data:
return make_response(jsonify({'message': f'Invalid data entered'}),
500)
def post(self):
# get params from the request
data = parser.parse_args()
name = data['name']
start_date = data['start_date']
end_date = data['end_date']
username = get_jwt_identity()
current_user = UserModel.find_by_username(username)
user_id = current_user.id
program_model = ProgramModel.query.filter_by(user_id=user_id).first()
# create model instance with the params
new_program = ProgramModel(name=name,
start_date=start_date,
end_date=end_date,
user_id=user_id)
try:
# save model instance to db
new_program.save_to_db()
return make_response(jsonify({'message': 'new program created'}),
200)
except:
return make_response(jsonify({'message': 'something went wrong'}),
500)
def post(self):
# get params from the request
data = parser.parse_args()
fullName = data['fullName']
username = get_jwt_identity()
current_user = UserModel.find_by_username(username)
user_id = current_user.id
profile_model = ProfileModel.query.filter_by(user_id=user_id).first()
if profile_model:
return make_response(
jsonify(
{'message':
f'profile for user {username} already exists'}), 500)
# create model instance with the params
new_profile = ProfileModel(full_name=fullName, user_id=user_id)
try:
# save model instance to db
new_profile.save_to_db()
return make_response(jsonify({'message': 'new profile created'}),
200)
except:
return make_response(jsonify({'message': 'something went wrong'}),
500)
def post(self):
data = UserRegister.parser.parse_args()
# Check if user name is already present
if UserModel.find_by_username(data['username']):
return {
"message": "A user with the given username already exists"
}, 403
# Check if list name is already present
if TitlesModel.find_by_listname(listname=data['listname']):
return {
"message":
"A list already exists with this name, please select a different list name."
}, 403
# Check if correct admin key is supplied for admin role
if data["role"] == "admin":
if data["adminkey"] == None:
return {"Message": "No admin code supplied for the admin"}, 401
if UserModel.check_admin_code(data["adminkey"]) == False:
return {"Message": "Invalid admin code"}, 401
# Hash password before saving to DB
o_hash = hashlib.new('ripemd160')
o_hash.update(data["password"].encode("utf-8"))
data["password"] = o_hash.hexdigest()
# Save new user to DB
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def put(self, id_program):
data = parser.parse_args()
name = data['name']
start_date = data['start_date']
end_date = data['end_date']
username = get_jwt_identity()
current_user = UserModel.find_by_username(username)
if not current_user:
return make_response(jsonify({'message': f'no user has that jwt'}),
500)
user_id = current_user.id
program_model = ProgramModel.query.filter_by(id=id_program,
user_id=user_id).first()
if not program_model:
return make_response(
jsonify({
'message':
f'user does not own program with id {id_program}'
}), 500)
ProgramModel.put(self, id_program, name, start_date, end_date)
return {'message': f'Program updated'}
def post(cls):
try:
user = user_schema.load(request.get_json())
except ValidationError as err:
return err.messages, 400
if UserModel.find_by_username(user['username']):
return {"msg": "User Already Exists"}, 400
if UserModel.find_by_email(user['email']):
return {"msg": "This email already has a registered account."}, 400
new_user = UserModel(**request.get_json())
try:
new_user.register()
print("User Registered...")
token = generate_link_token(user['email'])
UserModel.send_confirmation_email(token, user['email'],
user['username'])
except:
return {'msg': "Error Performing Request!!"}, 500
return {
'msg':
"Confirmation Link has been sent to you Email. Please Activate."
}, 201
def post(cls):
data = user_schema.load(request.get_json())
user = UserModel.find_by_username(data["username"])
# !!! below is the same with the authentication used in JWT(app,authentication,identity)
# !!! Only the active user can log in.
if user and Hash_Password.check_pwd(data["password"], user.password):
if not user.status == 'Active':
return {'msg': "Please Activate your account."}, 300
# !!! identity= is the same with the identity used in JWT(app,authentication,identity)
access_token = create_access_token(
identity=user.id, fresh=True,
expires_delta=False) # !!! Create Token for authentication
refresh_token = create_refresh_token(
user.id) # !!! Refreshing token to extend authenticated period
return {
'id': user.id,
'access_token': access_token,
'refresh_token': refresh_token,
'role': user.role,
'username': user.username,
'uuid': user.user_id,
'email': user.email
}, 200
return {'msg': "Invalid Credentials!!!"}, 401
def get(self, name):
user = UserModel.find_by_username(name)
if user:
return user.json()
return {'message': "User '{}' does not exist".format(name)}, 400
def post(self):
data = parser.parse_args()
username = data['username']
email = data['email']
# Checking if user already exist/created
if UserModel.find_by_username(username):
return {'message': f'User {username} already exists'}
# create new user
new_user = UserModel(username=username,
password=UserModel.generate_hash(
data['password']),
email=email)
# try:
# Saving user in DB and Generating Access and Refresh token
new_user.save_to_db()
access_token = create_access_token(identity=username)
refresh_token = create_refresh_token(identity=username)
return make_response(
jsonify({
'message': f'User {username} was created',
'access_token': access_token,
'refresh_token': refresh_token
}), 200)
def post(self):
user = UserRegisterResource.parser.parse_args()
if UserModel.find_by_username(user.username):
return {'message': 'user already exists'}, 409
user = UserModel(**user)
user.add_user()
return {'message': 'user added'}, 201
def post(self):
data = self.parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user and safe_str_cmp(user.password, data['password']):
access_token = create_access_token(identity=user.id, fresh=True)
return {'access_token': access_token}, 200
return {'message': 'Invalid credentials'}, 401
def register():
newUser = request.get_json()
if UserModel.find_by_username(newUser['username']):
return {'message':'Username already exists'}, 400
user = UserModel(newUser['username'],hash_password(newUser['password']))
user.save_to_db()
return jsonify({'message':'User created successfully'})
def post(self):
newUser = UserRegister.parser.parse_args()
if UserModel.find_by_username(newUser['username']):
return {'message': 'Username already exists'}, 400
user = UserModel(newUser['username'],
hash_password(newUser['password']), newUser['email'])
user.save_to_db()
return {'message': 'User created successfully'}
def delete(self):
user = UserRegisterResource.parser.parse_args()
if UserModel.find_by_username(user.username):
user = UserModel.query.filter_by(username=user.username)
user.delete_user()
return {'message': f"user removed"}, 204
return {'message': f"user not found"}, 404
def get(self, username):
friends = FriendModel.find_by_username(username)
if friends:
you = [{
"contact_name": UserModel.find_by_username(username).email
}]
return {'friends': you + [friend.json() for friend in friends]}
else:
return {'message': 'User not found'}, 404
def post(cls):
data = _global_parser.parse_args()
user = UserModel.find_by_username(data['username'])
if user and UserModel.verify_hash(data['password'], user.password):
access_token = create_access_token(identity=user.id)
return {
'access_token': access_token
}, 200
return {"message": "Invalid credentials."}, 401
def username(self): # Return True only when passed field validate
if UserModel.find_by_username(self.value):
return jsonify({
"message": False,
"error": "User already exist in the database."
})
else:
return jsonify({"message": True})
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'The username entered is already taken.'}, 400
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 post(self):
data = self.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return jsonify({"message": "User already exist in the database."})
user = UserModel(**data)
user.save_to_db()
return jsonify({"message": "User created successfully."})
def post(self):
data = _parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'That username is already registered'}, 400
new_user = UserModel(**data)
new_user.save_to_db()
return {'message': 'User created successfully'}, 201
def post(self):
data = RegisterUsers.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "username already taken"}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User registered successfully"}, 201 # created
def post(self):
data = UserRegister.parser.parse_args()
# model find by name
if UserModel.find_by_username(data['username']):
return {'message': 'User already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def authenticate(username, password):
"""
Functions that gets called when user hits the /auth endpoint
with their username and password
:param username:
:param password:
:return: A userModel object if authentication was successfull None otherwise
"""
user = UserModel.find_by_username(username)
if user and safe_str_cmp(user.password, password):
return user
def put(self, name):
data = UserRegister.parser.parse_args()
user = UserModel.find_by_username(name)
if user:
user.username = data['username']
else:
user = UserModel(**data)
user.save_to_db()
return user.json()
def post(self):
params = self.parser.parse_args()
username = params["username"]
if UserModel.find_by_username(username):
return {"message": f"მომხმარებელი {username} უკვე არსებობს"}, 400
password = params["password"]
user = UserModel(username, password)
try:
user.save_to_db()
except:
return {"message": "ინფორმაციის შენახვისას დაფიქსირდა შეცდომა"}, 500
return {"message": f"მომხმარებელი {username} დარეგისტრირებულია"}, 201
