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)