def post(self):
try:
user_data = UserSchema().load(request.get_json())
except ValidationError as e:
app.logger.error(e)
abort(
400,
message="Error validating signup data",
status=400,
errors=e.messages,
)
existing_user = (
db.session.query(User).filter(User.email == user_data["email"]).first()
)
if existing_user is not None:
error_message = "User account with this email already exists"
app.logger.error(error_message)
abort(400, message=error_message, status=400)
new_user = User(**user_data)
new_user.hash_password()
db.session.add(new_user)
try:
db.session.commit()
except SQLAlchemyError as e:
app.logger.error(e)
abort(500, message="Error creating new user", status=500)
response = UserSchema().dump(new_user)
return response
def get(self):
"""Method to handle user profile retrieval"""
exact_user = UserModel.query.filter_by(
id=get_jwt_identity().get('id')).first()
if not exact_user:
return error_response(message="No associated account " +
"with this email. 😩", status=404)
user_data = UserSchema(exclude=['password']).dump(exact_user)
return success_response(data=user_data)
def login():
logged_in_user_handle = get_jwt_identity()
if logged_in_user_handle:
app.logger.info(
"Got logged in user handle: {}".format(logged_in_user_handle))
return jsonify(login=True), 200
try:
login_data = UserSchema().load(request.get_json(), partial=True)
except ValidationError as e:
abort(
400,
message="Missing login fields",
status=400,
errors=e.messages,
)
app.logger.info("Validated login payload")
try:
user = db.session.query(User).filter(
User.email == login_data["email"]).one()
app.logger.info("Found user for login {}".format(user))
authorized = user.check_password(login_data["password"])
if not authorized:
raise Unauthorized("Invalid password")
except (NoResultFound, Unauthorized) as e:
abort(
401,
message="Error authorizing user with email '{}': {}".format(
login_data.email, e),
status=401,
)
except Exception:
raise InternalServerError
app.logger.info("Generating JWT token for user")
token_identity = str(user.handle)
access_token_exp = datetime.timedelta(
days=app.config["JWT_ACCESS_TOKEN_EXP_DAYS"])
refresh_token_exp = datetime.timedelta(
days=app.config["JWT_REFRESH_TOKEN_EXP_DAYS"])
# Create the tokens we will be sending back to the user
app.logger.info("Generating access and refresh tokens")
access_token = create_access_token(identity=token_identity,
expires_delta=access_token_exp)
refresh_token = create_refresh_token(identity=token_identity,
expires_delta=refresh_token_exp)
# Set the JWTs and the CSRF double submit protection cookies
# in this response
response = jsonify(login=True)
set_access_cookies(response, access_token)
set_refresh_cookies(response, refresh_token)
return response, 200
def post(self):
user_info = request.get_json(force=True)
exact_user = UserModel.query.filter_by(
email=user_info['email']).first()
if not exact_user:
return error_response(message="No associated account " +
"with this email. 😩",
status=404)
is_valid_password = BCrypt.check_password_hash(exact_user.password,
user_info['password'])
if not is_valid_password:
return error_response(message="Email or Password " +
"is not correct 😕",
status=401)
user_schema = UserSchema(exclude=['password', 'push_sub'])
user_info = user_schema.dump(exact_user)
token = create_access_token(identity={"id": exact_user.id})
return success_response(message='Logged in successfuly',
data=dict(token=token, user=user_info),
status=200)
async def register_user(background_tasks: BackgroundTasks,
payload: UserSchema) -> JSONResponse:
try:
user = User(full_name=payload.full_name, email=payload.email)
user.save()
registeredUser = UserSchema(full_name=user.full_name, email=user.email)
except NotUniqueError:
return JSONResponse(status_code=400,
content={"error": "Email already used"})
message = MessageSchema(
subject="Registered",
recipients=[
payload.email,
],
body=
f"thanks {payload.full_name} for registering in our datascience event")
fm = FastMail(conf)
background_tasks.add_task(fm.send_message, message)
return JSONResponse(content={**registeredUser.dict()}, status_code=201)
def post(self):
user_info = request.get_json(force=True)
existing_user = UserModel.query.filter_by(
email=user_info['email']).first()
if existing_user:
return error_response(message="This email address" +
" has been taken",
status=409)
new_user = UserModel(**user_info)
new_user.save()
return success_response(
message="Your account has been created successfully",
data=UserSchema(exclude=['password']).dump(new_user),
status=201)
def put(self):
"""Method to handle user data update"""
user_update_data = request.get_json(force=True)
user_data = UserSchema(
dump_only=['id']).load_object_into_schema(user_update_data)
if user_data.get('password'):
hashed_password = BCrypt.generate_password_hash(
user_data.get('password')).decode('utf-8')
user_data.update(password=hashed_password)
exact_user = UserModel.query.filter_by(
id=get_jwt_identity().get('id')).first()
updated_user_object = exact_user.update(**user_data)
return success_response(
data=UserSchema(exclude=['password']).dump(
updated_user_object),
message='Profile Updated Successfully')
def get(self, user, user_handle):
user = get_user_or_404(user_handle)
response = UserSchema().dump(user)
return response
def get(self):
users = db.session.query(User).all()
response = UserSchema(many=True).dump(users)
return response
app.config['PROPAGATE_EXCEPTIONS'] = True
app.config['JWT_SECRET_KEY'] = 'azbycxdwevfugthsirjqkplomn'
jwt.init_app(app)
app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = '******'
app.config['MYSQL_PASSWORD'] = ''
app.config['MYSQL_DB'] = 'db'
mysql = MySQL(app)
bcrypt = Bcrypt(app)
jwt = JWTManager(app)
CORS(app)
user_schema = UserSchema(many=False)
class login(Resource):
result = user_schema.load(request.form)
name = result['username']
email = result['email']
password = result['password']
@app.route('/register', methods=['POST'])
def register(self):
cur = mysql.connection.cursor()
username = request.get_json()['username']
email = request.get_json()['email']
password = bcrypt.generate_password_hash(
def get(self, user):
return UserSchema().dump(user)