def validate(*args, **kwargs):
try:
data = schema().load(request.get_json())
except ValidationError as e:
raise BadRequestError("Invalid request data.",
e.normalized_messages())
return func(data=data, *args, **kwargs)
def signin(data):
try:
existing_user = UserModel.query.filter_by(
username=data["username"]).one_or_none()
except SQLAlchemyError as error:
raise SQLAlchemyError(error)
if not existing_user or not validate_hashed_password(
data["password"], existing_user.password):
raise BadRequestError("Invalid credentials.")
return jsonify({"access_token": generate_token(existing_user.id)}), 200
def create_user(*,
username: str,
password_hash: str,
name: Optional[str] = None) -> User:
"""Create and save an user into database, then return the user"""
user = get_user_by_username(username)
if user:
raise BadRequestError("Username already exists")
user = User(username=username, password_hash=password_hash, name=name)
user.save()
return user
def wrapper(*args, **kwargs):
try:
access_token = request.headers["Authorization"].split()[1]
data = jwt.decode(access_token,
app.config["SECRET"],
algorithms="HS256")
user_id = data["user_id"]
except KeyError:
raise BadRequestError(
"Missing token. Please sign in first to perform this action.")
except jwt.InvalidTokenError:
raise UnauthorizedError("Invalid token. Please sign in again.")
return func(user_id=user_id, *args, **kwargs)
def create_log(*,
habit_id: int,
date: datetime.date,
count: Optional[int] = None) -> Log:
"""Create and save a log into database, then return the log"""
# Verify 'count' field
habit = get_habit(habit_id)
if habit.countable and count is None:
raise BadRequestError("Log for countable habit should include a count")
if not habit.countable and count is not None:
raise BadRequestError(
"Log for uncountable habit should not include a count")
# If log for given date and habit already exists, set status of that log to 'active'
log = get_log_by_habit_and_date(habit_id, date)
if log:
log.status = LogStatus.ACTIVE
log.save()
else:
log = Log(habit_id=habit_id, date=date, count=count)
log.save()
return log
def wrapper(*args, **kwargs):
if request.method == "GET":
req_data = request.args
error_message = "Invalid query parameter(s)"
elif request.method == "PUT" or request.method == "POST":
req_data = request.get_json(force=True)
error_message = "Invalid field(s)"
else:
return func(*args, **kwargs)
errors = schema.validate(req_data)
if errors:
raise BadRequestError(error_message, errors)
data = schema.load(req_data)
return func(*args, **kwargs, data=data)
def create_item(user_id, category, data):
item_name = data["name"]
try:
existing_item = ItemModel.query.filter_by(name=item_name).one_or_none()
except SQLAlchemyError as error:
raise SQLAlchemyError(error)
if existing_item:
raise BadRequestError(f"Item {item_name} already existed.")
new_item = ItemModel(user_id=user_id, **data)
try:
db.session.add(new_item)
db.session.commit()
except SQLAlchemyError as error:
raise SQLAlchemyError(error)
return jsonify(ItemSchema().dump(new_item)), 201
def create_category(user_id, data):
category_name = data["name"]
try:
existing_category = CategoryModel.query.filter_by(
name=category_name).one_or_none()
except SQLAlchemyError as error:
raise SQLAlchemyError(error)
if existing_category:
raise BadRequestError(f"Category {category_name} already existed.")
# create new category
new_category = CategoryModel(name=category_name)
try:
db.session.add(new_category)
db.session.commit()
except SQLAlchemyError as error:
raise SQLAlchemyError(error)
return jsonify(CategorySchema().dump(new_category)), 201
def signup(data):
try:
existing_user = UserModel.query.filter_by(
username=data["username"]).one_or_none()
except SQLAlchemyError as error:
raise SQLAlchemyError(error)
if existing_user:
raise BadRequestError("Username already existed.")
data["password"] = generate_hashed_password(data["password"])
user = UserModel(**data)
try:
db.session.add(user)
db.session.commit()
except SQLAlchemyError as error:
raise SQLAlchemyError(error)
return jsonify({"access_token": generate_token(user.id)}), 201
def wrapper(*args, **kwargs):
limit = 10
offset = 0
if request.args.get("limit"):
limit = request.args.get("limit")
if request.args.get("offset"):
offset = request.args.get("offset")
try:
pagination = PaginationSchema().load({
"limit": limit,
"offset": offset
})
except ValidationError as e:
raise BadRequestError("Invalid request data.",
e.normalized_messages())
return func(pagination=pagination, *args, **kwargs)