def create_current_user_command(): cart = cartDao.get_cart_of(current_identity.id) commandModel = CommandModel(id_Cart=cart.id, creationDate=datetime.now()) result = commandDao.save(commandModel) return response.success(result)
def modify_current_user_cart_item(request_body: CartItemEditionRequest, ingredient_id): cart = cartDao.get_cart_of(current_identity.id) result = cartItemDao.modifyQuantity( request_body.multiplier, cart.id, ingredient_id) return response.success(result)
def like_recipe(recipe_id): likeRecipeModel = LikeRecipeModel( id_User=current_identity.id, id_Recipe=recipe_id ) result = like_recipe_dao.save(likeRecipeModel) return response.success(result)
def get_current_user_commands(): commands = commandDao.getUserCommands(current_identity.id) data = [] for command in commands: cart = cartDao.getById(command.id_Cart) data.append({**asdict(command), 'totalCost': cart.totalCost}) return response.success(data)
def modify_recipe_ingredient_quantity(request_body: RecipeIngredientQuantityEditionRequest, recipe_id): recipe = recipe_finding_usecase.find_by_id(recipe_id) authentication_use_case.ensure_same_user(recipe.id_User, current_identity.id) result = recipe_ingredient_dao.modifyQuantity( recipe_id, request_body.id_Ingredient, request_body.totalQuantity) return response.success(result)
def edit_recipe_rating(request_body: RatingCreationRequest, recipe_id): ratingModel = RatingModel( id_User=current_identity.id, id_Recipe=recipe_id, value=request_body.value ) result = recipe_rating_dao.replace(ratingModel) return response.success(result)
def add_recipe_comment(request_body: CommentCreationRequest, recipe_id): commentModel = CommentModel( id_User=current_identity.id, id_Recipe=recipe_id, text=request_body.text ) result = comment_dao.save(commentModel) return response.success(result)
def modify_recipe(request_body: RecipeEditionRequest, recipe_id): edition_dto = RecipeEditionDto( id=recipe_id, name=request_body.name, directives=request_body.directives) modified_recipe = recipe_editing_usecase.edit_recipe(current_identity.id, edition_dto) return response.success(modified_recipe)
def add_current_user_cart_item(request_body: CartItemCreationRequest): cart = cartDao.get_cart_of(current_identity.id) cartItemModel = CartItemModel( id_Cart=cart.id, id_Ingredient=request_body.id_Ingredient ) result = cartItemDao.save(cartItemModel) return response.success(result)
def create_recipe(request_body: RecipeCreationRequest): recipe_creation_dto = RecipeCreationDto(recipe=RecipeCreationInfo( id_User=current_identity.id, name=request_body.name, description=request_body.description, directives=request_body.directives ), ingredients=request_body.ingredients) recipe = recipe_creation_usecase.create_recipe(recipe_creation_dto) return response.success(asdict(recipe))
def get_recipe(recipe_id): recipe = recipe_finding_usecase.find_by_id(recipe_id) user = user_finding_usecase.find_by_id(recipe.id_User) data = { **asdict(recipe), 'user': { **asdict(user) } } return response.success(data)
def get_recipe_comments(recipe_id): comments = comment_dao.getRecipeComments(recipe_id) data = [] for comment in comments: user = user_finding_usecase.find_by_id(comment.id_User) data.append({ **asdict(comment), 'user': asdict(user) }) return response.success(data)
def get_current_user_account(): account = user_finding_usecase.find_account_of(current_identity.id) address = user_finding_usecase.find_adress_for_account(account.id) response_data = AccountResponse( id=account.id, id_User=account.id_User, id_Address=account.id_Address, firstName=account.firstName, lastName=account.lastName, email=account.email, address=AddressResponse(**asdict(address)) ) return response.success(response_data)
def modify_current_user_address(request_body: AddressEditionRequest): try: address_edition_dto = AddressInfoEditionDto( country=request_body.country, city=request_body.city, street=request_body.street, apartment=request_body.apartment, number=request_body.number ) address = user_editing_usecase.update_address(current_identity.id, address_edition_dto) return response.success(address) except Exception as e: return response.error(e)
def get_recipe_ingredients(recipe_id): data = [] recipeIngredients = recipe_ingredient_dao.getIngredientsByRecipe(recipe_id) for recipeIngredient in recipeIngredients: ingredient = ingredient_dao.getById(recipeIngredient.id_Ingredient) quantityUnit = quantity_unit_dao.getById( recipeIngredient.id_QuantityUnit) data.append({ 'id': ingredient.id, 'name': ingredient.name, 'quantityUnit': asdict(quantityUnit), 'totalQuantity': recipeIngredient.totalQuantity }) return response.success(data)
def get_current_user_cart_items(): cart = cartDao.get_cart_of(current_identity.id) cartItems = cartItemDao.getItemsByCart(cart.id) data = [] for cartItem in cartItems: ingredient = ingredientDao.getById(cartItem.id_Ingredient) quantity_unit = quantityUnitDao.getById(ingredient.id_QuantityUnit) quantity = f'{int(ingredient.baseQuantity)} {quantity_unit.abbreviation}' data.append({ **asdict(cartItem), 'name': ingredient.name, 'baseCost': ingredient.baseCost, 'quantity': quantity }) return response.success(data)
def modify_current_user_account(request_body: AccountEditionRequest): try: account_edition_dto = AccountInfoEditionDto( email=request_body.email, password=request_body.password ) account = user_editing_usecase.update_account(current_identity.id, account_edition_dto) address = user_finding_usecase.find_adress_for_account(account.id) response_data = AccountResponse( id=account.id, id_User=account.id_User, id_Address=account.id_Address, firstName=account.firstName, lastName=account.lastName, email=account.email, address=AddressResponse(**asdict(address)) ) return response.success(response_data) except Exception as e: return response.error(e)
def get_ingredients(): populated_ingredients = [] ingredients = [] search_name = request.args.get('name') if search_name: ingredients = ingredientDao.getIngredientsByName(search_name) else: ingredients = ingredientDao.getAll() for ingredient in ingredients: quantity_unit = quantityUnitDao.getById(ingredient.id_QuantityUnit) quantity = str.format('{} {}', int( ingredient.baseQuantity), quantity_unit.abbreviation) populated_ingredients.append({ 'id': ingredient.id, 'name': ingredient.name, 'quantity': quantity, 'price': ingredient.baseCost }) return response.success(populated_ingredients)
def create_account(request_body: AccountCreationRequest): if not request_body.user: return response.error('user field cannot be empty', status=400) if not request_body.account: return response.error('account field cannot be empty', status=400) if not request_body.address: return response.error('address field cannot be empty', status=400) try: dto = SignupDto( user=UserInfo(**asdict(request_body.user)), account=AccountInfo(**asdict(request_body.account)), address=AddressInfo(**asdict(request_body.address)) ) result = signup_usecase.register_new_user(dto) return response.success(result) except ValueError as e: print(e) return response.error(e, status=400) except Exception as e: raise e
def get_user(user_id): data = user_finding_usecase.find_by_id(user_id) return response.success(data)
def get_current_user_cart(): cart = cartDao.get_cart_of(current_identity.id) return response.success(cart)
def remove_current_user_cart_item(ingredient_id): cart = cartDao.get_cart_of(current_identity.id) cartItemDao.deleteIngredient(cart.id, ingredient_id) return response.success("", status=204)
def index(): recipes = recipe_finding_usecase.find_all( name=request.args.get('name') ) return response.success(list(map(asdict, recipes)))
def get_current_user_address(): account = user_finding_usecase.find_account_of(current_identity.id) address = user_finding_usecase.find_adress_for_account(account.id) return response.success(address)
def get_ingredient_mesures(ingredient_id): quantityUnits = quantityUnitDao.getAllQuantityUnitsByIngredientId(ingredient_id) return response.success(quantityUnits)
def get_user_ratings(user_id): authentication_use_case.ensure_same_user(user_id, current_identity.id) data = recipeRatingDao.getRatingsByUser(user_id) return response.success(data)
def get_current_user(): user = UserModel(username=current_identity.username, id=current_identity.id) return response.success(user)
def index(): return response.success("App is running correctly")
def jwt_response_handler(access_token, identity): return response.success({ 'token': access_token.decode('utf-8'), 'id': identity.id, 'username': identity.username })
def get_user_liked_recipes(user_id): recipes = recipe_finding_usecase.find_all_liked_by(user_id) return response.success(list(map(asdict, recipes)))