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 get_user(id):
if current_user().id != id:
abort(403)
one_user = User.query.get_or_404(id)
user_schema = UserSchema()
output = user_schema.dump(one_user).data
return jsonify({'user' : output})
def get(self, _id: str):
user = UserModel.get_user_by_id(_id)
if user:
user_schema = UserSchema()
result: dict = user_schema.dump(user)
return result, 200
return {"msg": "User Not found"}, 404
def get(self):
users = User.query.all()
result = []
schema = UserSchema()
for user in users:
result.append(schema.dump(user))
return {"data": result}
def get(self):
schema = UserSchema(many=True)
args = parser.parse_args()
search = args["search"]
data = self.user.search_user(search=search)
return schema.dump(data)
def post(self):
candidate = request.get_json()
schema = UserSchema()
errors = schema.validate(candidate)
if errors:
return {'massage': errors}, 400
data = schema.dump(candidate)
if UserModel.find_by_email(data['email']):
return {'massage': 'this mail already exist'}, 400
user = UserModel(**data)
user.save_to_db()
return {'massage': 'User has been created'}, 201
def update_user(id):
if current_user().id != id:
abort(403)
user = User.query.get_or_404(id)
data = request.get_json() or {}
if 'username' in data and data['username'] != user.username and User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if 'email' in data and data['email'] != user.email and User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
user.from_dict(data, new_user=False)
db.session.commit()
user_schema = UserSchema()
output = user_schema.dump(user).data
return jsonify({'user': output})
def get(self, token):
"""
"""
user_schema = UserSchema()
secret = current_app.config["SECRET_KEY"]
salt = current_app.config["VERIFICATION_SALT"]
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 user.verified:
return dict(status='fail',
message='Email is already verified'), 400
user.verified = True
user_saved = user.save()
user_dict, _ = user_schema.dump(user)
if user_saved:
# generate access token
access_token = user.generate_token(user_dict)
if not access_token:
return dict(status='fail',
message='Internal Server Error'), 500
return dict(status='success',
message='Email verified successfully',
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='Internal Server Error'), 500
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 get_users():
all_users = User.query.all()
user_schema = UserSchema(many=True)
output = user_schema.dump(all_users).data
return jsonify({'users': output})
def get(self, user_id):
schema = UserSchema()
user = User.query.get_or_404(user_id)
return {"user": schema.dump(user).data}
def get(self, id):
schema = UserSchema()
data = self.user.get_user_profile(id_user=id)
return schema.dump(data)
def get(self):
user = User.query.filter_by(id=current_user_id()).first()
user_schema = UserSchema(exclude=['password', 'avatar', 'roles'])
return user_schema.dump(user)
def get(self):
users = UserModel.query.all()
schema = UserSchema()
return schema.dump(users, many=True), 200
def users():
users = User.query.all()
users_schema = UserSchema(many=True)
result = users_schema.dump(users)
return jsonify(result)
def create(payload):
user_schema = UserSchema()
user_dict = user_schema.load(payload)
user = UserRepository.create(user_dict)
return user_schema.dump(user)