class User(Resource):
def __init__(self):
self.user_schema = UserSchema()
@jwt_required
def get(self, id=None):
if id:
user = UserModel.query.get(id)
if user is None:
return error_template('User not found', httpclient.NOT_FOUND)
return self.user_schema.dump(user).data, httpclient.OK
users = UserModel.query.all()
return self.user_schema.dump(users, many=True).data, httpclient.OK
def post(self):
json_data = request.get_json()
data, errors = self.user_schema.load(json_data)
if errors:
return errors, httpclient.UNPROCESSABLE_ENTITY
user = UserModel(email=data['email'], username=data['username'])
user.set_password(data['password'])
db.session.add(user)
db.session.commit()
return self.user_schema.dump(user).data, httpclient.CREATED
@jwt_required
def put(self, id):
user = UserModel.query.filter_by(id=id).first()
if user is None:
return error_template('User not found', httpclient.NOT_FOUND)
json_data = request.get_json()
data, errors = self.user_schema.load(json_data)
if errors:
return errors, httpclient.UNPROCESSABLE_ENTITY
for attr, value in data.items():
if attr is 'password':
user.set_password(value)
continue
if getattr(user, attr) != value:
setattr(user, attr, value)
db.session.commit()
return self.user_schema.dump(user).data
def delete(self, id):
return NotImplementedError
def patch(self, user_id):
"""
"""
try:
user_schema = UserSchema(only=("name", ))
user_data = request.get_json()
validate_user_data, errors = user_schema.load(user_data)
if errors:
return dict(status='fail', message=errors), 400
user = User.get_by_id(user_id)
if not user:
return dict(status='fail',
message=f'User {user_id} not found'), 404
updated = User.update(user, **validate_user_data)
if not updated:
return dict(status='fail',
message='Internal Server Error'), 500
return dict(status='success',
message=f'User {user_id} updated successfully'), 200
except Exception as e:
return dict(status='fail', message=str(e)), 500
def post(self):
"""
Create New User
"""
user_schema = UserSchema()
user_data = request.get_json()
# Validate user data
validated_user_data, errors = user_schema.load(user_data)
if errors:
return dict(status="fail", message=errors), 400
email = validated_user_data.get('email', None)
# Check if user email exists
user_existant = User.query.filter_by(email=email).first()
if user_existant:
return dict(status="fail", message=f"Email {validated_user_data['email']} already in use."), 400
# add validated data to user object
user = User(**validated_user_data)
saved_user = user.save()
if not saved_user:
return dict(status='fail', message=f'Internal Server Error'), 500
# for returning to user
new_user_data, errors = user_schema.dumps(user)
return dict(status='success', data=dict(user=json.loads(new_user_data))), 201
def patch(self, user_id):
"""
Update User
"""
user_schema = UserSchema()
update_data = request.get_json()
validated_update_data, errors = user_schema.load(update_data)
if errors:
return dict(status="fail", message=errors), 400
user = User.get_by_id(user_id)
if not user:
return dict(status="fail", message=f"User with id {user_id} not found"), 404
if 'username' in validated_update_data:
user.username = validated_update_data['username']
if 'email' in validated_update_data:
user.email = validated_update_data['email']
if 'password' in validated_update_data:
user.password = validated_update_data['password']
updated_user = user.save()
if not updated_user:
return dict(status='fail', message='Internal Server Error'), 500
return dict(status="success", message=f"User {user.username} updated successfully"), 200
def patch(self, user_id):
"""
Update a single user
"""
# To do check if user is admin
schema = UserSchema(partial=True)
update_data = request.get_json()
validated_update_data, errors = schema.load(update_data)
if errors:
return dict(status="fail", message=errors), 400
user = User.get_by_id(user_id)
if not user:
return dict(status="fail",
message=f"User with id {user_id} not found"), 404
updated_user = User.update(user, **validated_update_data)
if not updated_user:
return dict(status='fail', message='Internal Server Error'), 500
return dict(status="success", message="User updated successfully"), 200
def post(self):
"""
"""
user_schema = UserSchema()
user_data = request.get_json()
validated_user_data, errors = user_schema.load(user_data)
email = validated_user_data.get('email', None)
client_base_url = os.getenv('CLIENT_BASE_URL',
f'https://{request.host}/users')
# To do change to a frontend url
verification_url = f"{client_base_url}/verify/"
secret_key = current_app.config["SECRET_KEY"]
password_salt = current_app.config["VERIFICATION_SALT"]
sender = current_app.config["MAIL_DEFAULT_SENDER"]
template = "user/verify.html"
subject = "Please confirm your email"
if errors:
return dict(status="fail", message=errors), 400
# get the customer role
user_role = Role.find_first(name='customer')
user_existant = User.query.filter_by(email=email).first()
if user_existant:
return dict(
status="fail",
message=f"Email {validated_user_data['email']} already in use."
), 400
user = User(**validated_user_data)
if user_role:
user.roles.append(user_role)
saved_user = user.save()
if not saved_user:
return dict(status='fail', message=f'Internal Server Error'), 500
# send verification
send_verification(email, user.name, verification_url, secret_key,
password_salt, sender,
current_app._get_current_object(), template, subject)
new_user_data, errors = user_schema.dumps(user)
return dict(status='success',
data=dict(user=json.loads(new_user_data))), 201
def post(self):
try:
requested_data = request.get_json()
if UserModel.get_user_by_username(requested_data["username"]):
return {"msg": "Username already exists"}, 400
if UserModel.get_user_by_email(requested_data["email"]):
return {"msg": "Email already exists"}, 400
user_schema = UserSchema()
result: dict = user_schema.load(requested_data)
UserModel.register_user(**result)
return {"msg": "Registration successful"}, 201
except ValidationError as err:
return jsonify(err.messages, 400)
def post(self):
"""
"""
user_schema = UserSchema(only=("email", "password"))
token_schema = UserSchema()
login_data = request.get_json()
validated_user_data, errors = user_schema.load(login_data)
if errors:
return dict(status='fail', message=errors), 400
email = validated_user_data.get('email', None)
password = validated_user_data.get('password', None)
user = User.find_first(email=email)
admin_role = Role.find_first(name='administrator')
if not user or not admin_role or (admin_role not in user.roles):
return dict(status='fail', message="login failed"), 401
if not user.verified:
return dict(status='fail',
message='Email not verified',
data=dict(verified=user.verified)), 401
user_dict, errors = token_schema.dump(user)
if user and user.password_is_valid(password):
access_token = user.generate_token(user_dict)
if not access_token:
return dict(status="fail",
message="Internal Server Error"), 500
return dict(status='success',
data=dict(
access_token=access_token,
email=user.email,
username=user.username,
verified=user.verified,
id=str(user.id),
)), 200
return dict(status='fail', message="login failed"), 401
def post(self, token):
password_schema = UserSchema(only=("password", ))
secret = current_app.config["SECRET_KEY"]
salt = current_app.config["PASSWORD_SALT"]
request_data = request.get_json()
validated_data, errors = password_schema.load(request_data)
if errors:
return dict(status='fail', message=errors), 400
password = validated_data['password']
hashed_password = Bcrypt().generate_password_hash(password).decode()
email = validate_token(token, secret, salt)
if not email:
return dict(status='fail', message="invalid token"), 401
user = User.find_first(**{'email': email})
if not user:
return dict(status="fail",
message=f'user with email {email} not found'), 404
if not user.verified:
return dict(status='fail',
message=f'email {email} is not verified'), 400
user.password = hashed_password
user_saved = user.save()
if not user_saved:
return dict(status='fail', message='internal server error'), 500
return dict(status='success',
message='password reset successfully'), 200
def post(self):
"""
"""
email_schema = UserSchema(only=("email", ))
request_data = request.get_json()
validated_data, errors = email_schema.load(request_data)
if errors:
return dict(status='fail', message=errors), 400
email = validated_data.get('email', None)
client_base_url = os.getenv('CLIENT_BASE_URL',
f'https://{request.host}/users')
# To do, change to a frontend url
verification_url = f"{client_base_url}/verify/"
secret_key = current_app.config["SECRET_KEY"]
password_salt = current_app.config["VERIFICATION_SALT"]
sender = current_app.config["MAIL_DEFAULT_SENDER"]
template = "user/verify.html"
subject = "Please confirm your email"
user = User.find_first(**{'email': email})
if not user:
return dict(status='fail',
message=f'User with email {email} not found'), 404
# send verification
send_verification(email, user.name, verification_url, secret_key,
password_salt, sender,
current_app._get_current_object(), template, subject)
return dict(status='success',
message=f'Verification link sent to {email}'), 200
def post(self):
user_schema = UserSchema(only=("email", "password"))
login_data = request.get_json()
validated_user_data, errors = user_schema.load(login_data)
if errors:
return dict(status='fail', message=errors), 400
email = validated_user_data.get('email', None)
password = validated_user_data.get('password', None)
user = User.find_first(email=email)
if not user:
return dict(status='fail', message="login failed"), 401
user_data, errors = user_schema.dumps(user)
if errors:
return dict(status='fail', message=errors), 400
return dict(status='Success', message=f"User { user.username } logged in Successfully. "), 200
def post(self):
"""
Creating an User ad
"""
user_schema = UserSchema()
user_data = request.get_json()
validated_user_data, errors = user_schema.load(user_data)
if errors:
return dict(status='fail', message=errors), 400
user = User(**validated_user_data)
saved_user = user.save()
if not saved_user:
return dict(status='fail', message='Internal Server Error'), 500
new_user_data, errors = user_schema.dumps(user)
return dict(status='success',
data=dict(user=json.loads(new_user_data))), 201
def create(payload):
user_schema = UserSchema()
user_dict = user_schema.load(payload)
user = UserRepository.create(user_dict)
return user_schema.dump(user)