def get(self, id):
try:
result = User.query.filter(
User.services.any(id=id)).filter_by(role='Worker').all()
return jsonify(UserSchema(many=True).dump(result).data)
except NoResultFound:
return jsonify(UserSchema(many=True).dump([]).data), 404
def post(self):
value = req.get_json()
value.update({'userId': uuid4().hex})
user = UserSchema().load(value, session=db.session)
isEmail = bool(UserModel.findByEmail(user.email))
isName = bool(UserModel.findByName(user.name))
if isEmail or isName:
return gettex('EXIST'), 422
try:
user.insert()
except:
return gettex('SOMETHING_WRONG'), 500
return UserSchema().dump(user)
def newToken(self, user):
access_token = create_access_token(identity=user.userId,
user_claims=UserSchema().dump(user),
fresh=True)
refresh_token = create_refresh_token(user.userId)
return {
'access_token': f'{access_token}',
'refresh_token': refresh_token
}, 201
def delete(self, userid):
user = UserModel.findById(userid)
if user is None:
return gettex('NOT_FOUND'), 400
try:
user.delete()
except:
return gettex('SOMETHING_WRONG'), 500
return UserSchema().dump(user)
def user_register():
try:
payload = NewUserInputSchema().load(request.json)
new_user = UserHandler.create_new_user(**payload)
except ValidationError as error:
return error.messages, 422
except RepeatEmailException:
return jsonify(message="Email is already being used"), 422
out = UserSchema().dump(new_user)
return jsonify(out), 201
def put(self):
userid = get_jwt_claims()['userId']
value = req.get_json()
user = UserModel.findById(userid)
if not bool(user):
return gettex('NOT_FOUND'), 400
try:
user.name = value['name']
user.insert()
except:
return gettex('SOMETHING_WRONG'), 500
return UserSchema().dump(user)
def signup(
user_schema: UserSchema = Body(..., embed=True, alias="user"),
session: Session = Depends(get_session),
) -> ObjectCreate:
user_service = UserService(session)
if user_service.get_by_email(user_schema.email):
raise HTTPException(
status_code=HTTP_401_UNAUTHORIZED,
detail='Usuário já criado'
)
user = user_service.insert(user_schema.dict())
return ObjectCreate(
message='Usuário criado com sucesso',
object_id=user.id
)
def test_authenticate_with_success(self):
# arrange
user = UserSchema(
email='test@test',
password='******'
)
session_mock = mock.MagicMock()
session_mock\
.query.return_value\
.filter.return_value\
.filter.return_value\
.all.return_value = user
# act
result = AuthenticationService(session_mock)._authenticate(
email='test@test',
password='******'
)
# assert
self.assertTrue(result)
def reset_password():
"""Change the current password
---
put:
tags:
- auth
requestBody:
content:
application/json:
schema:
type: object
properties:
username:
type: string
required: true
password:
type: string
required: true
responses:
200:
content:
application/json:
schema:
type: object
properties:
status:
type: int
example: 200
success:
type: dict
example: {message: password changes successfully}
error:
type: dict
example: {message: error occurred}
400:
description: bad request
"""
if not request.is_json:
response_body = {"message": "Missing JSON in request"}
return (
Response(400).wrap(response_body=response_body),
HTTPStatus.BAD_REQUEST,
)
# return jsonify({"msg": "Missing JSON in request"}), HTTPStatus.BAD_REQUEST
_mandatory_fields = ["username", "password"]
req_data = request.json
try:
validation_data_check(_mandatory_fields, req_data)
authorized_user = validation_authority(
get_jwt_identity().get("username"))
if authorized_user == "authorized":
username = req_data["username"]
password = req_data["password"]
current_time = datetime.datetime.now().isoformat()
current_user = get_jwt_identity().get("username")
user = User.query.filter_by(username=username).first()
if user is None:
response_body = {"message": "user is not present"}
return (
Response(401).wrap(response_body),
HTTPStatus.UNAUTHORIZED,
)
update_data = {
"password": pwd_context.hash(password),
# "updated_by": current_user,
# "updated_on": current_time,
}
obj = UserSchema().load(update_data, instance=user, partial=True)
db.session.add(obj)
db.session.commit()
response_body = {"message": "password reset successfully"}
return Response(200).wrap(response_body), HTTPStatus.OK
elif authorized_user == "unauthorized":
response_body = {"message": "unauthorized"}
return (
Response(401).wrap(response_body=response_body),
HTTPStatus.UNAUTHORIZED,
)
else:
response_body = {"message": authorized_user}
return (
Response(500).wrap(response_body=response_body),
HTTPStatus.INTERNAL_SERVER_ERROR,
)
except ValueError as e:
response_body = {"message": e.args[0]}
return Response(400).wrap(response_body), HTTPStatus.BAD_REQUEST
except SQLAlchemyError as e:
app.logger.error(f"error occured while returned {str(e)}")
response_body = {"message": f"{str(e)}"}
return (
Response(500).wrap(response_body),
HTTPStatus.INTERNAL_SERVER_ERROR,
)
def change_password():
"""Change the current password
---
put:
tags:
- auth
requestBody:
content:
application/json:
schema:
type: object
properties:
user_id:
type: integer
required: true
current_password:
type: string
required: true
new_password:
type: string
required: true
confirm_password:
type: string
required: true
responses:
200:
content:
application/json:
schema:
type: object
properties:
status:
type: int
example: 200
success:
type: dict
example: {message: password changes successfully}
error:
type: dict
example: {message: error occurred}
400:
description: bad request
"""
app.logger.info("change password")
if not request.is_json:
response_body = {"message": "Missing JSON in request"}
return Response(400).wrap(response_body), HTTPStatus.BAD_REQUEST
_mandatory_fields = [
"user_id",
"current_password",
"new_password",
"confirm_password",
]
req_data = request.json
try:
validation_data_check(_mandatory_fields, req_data)
user_id, current_password, new_password, confirm_password = fetch_change_pass_req_body(
req_data=request.json)
user = User.query.filter_by(id=user_id).first()
app.logger.info(
f"password mismatch {pwd_context.verify(current_password, user.password)}"
)
if user is None or not pwd_context.verify(current_password,
user.password):
response_body = {"message": "unauthorized"}
return Response(401).wrap(response_body), HTTPStatus.UNAUTHORIZED
check_new_password_confirm_password(new_password, confirm_password)
app.logger.info(get_jwt_identity())
update_data = {
"password": pwd_context.hash(new_password)
# "updated_by": get_jwt_identity().get("username"),
# "updated_on": datetime.datetime.now().isoformat(),
}
obj = UserSchema().load(update_data, instance=user, partial=True)
db.session.add(obj)
db.session.commit()
response_body = {"message": "password changed successfully"}
return Response(200).wrap(response_body), HTTPStatus.OK
except ValueError as e:
response_body = {"message": e.args[0]}
return Response(400).wrap(response_body), HTTPStatus.BAD_REQUEST
except SQLAlchemyError as e:
app.logger.error(f"error occured while returned {str(e)}")
response_body = {"message": f"{str(e)}"}
return (
Response(500).wrap(response_body),
HTTPStatus.INTERNAL_SERVER_ERROR,
)
from flask_restful import Resource
from flask import request
from models.user import UserModel
from schema.user import UserSchema
from flask_jwt_extended import create_access_token, create_refresh_token
user_schema = UserSchema()
class User(Resource):
def get(self, name):
find = UserModel.search_by_name(name)
if find:
return {"id": find.id, "name": find.name}
else:
return {"message": "User doesnt exist in the databse"}
def post(self, name):
data_json = request.get_json()
data_json['name'] = name
data = user_schema.load(data_json)
try:
user = UserModel(**data)
user.save_to_db()
return {
"message": "user has been added to the database Sucessfully"
}
except Exception as e:
def get(self, id):
try:
result = User.query.filter_by(id=id).one()
return jsonify(UserSchema(many=False).dump(result).data)
except NoResultFound:
return jsonify(UserSchema(many=False).dump(None).data), 404
def get(self):
try:
result = User.query.all()
return jsonify(UserSchema(many=True).dump(result).data)
except NoResultFound:
return jsonify(UserSchema(many=True).dump([]).data), 404
if 'registration_id' in request.form else None
is_verified = request.form['is_verified'] \
if 'is_verified' in request.form else None
except Exception, ex:
return "Could not validate user information: {}". \
format(repr(ex)), 400
try:
update_customer(id, first_name, last_name, username, password,
email, address, barangay, phone_no,
registration_id, is_verified)
except Exception, ex:
return "Error updating user: {}". \
format(repr(ex)), 400
return jsonify(UserSchema(many=True).dump(None).data), 200
class UserForgotApi(MethodView):
def post(self):
try:
email = request.form['email']
except Exception, ex:
return "Email parameter not found: {}". \
format(repr(ex)), 400
try:
item = User.query.filter_by(
email=email,
role='Customer',
is_verified=True,
def get(cls):
user = UserModel.fetchAll()
alluser = UserSchema(many=True).dump(user)
return {'data': alluser[0]}
def get(self, userid):
user = UserModel.findById(userid)
if user is None:
return gettex('NOT_FOUND'), 400
return UserSchema().dump(user)
