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)))
