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)