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)