public async Task <ActionResult> Delete([FromRoute] int id)
        {
            try
            {
                var food = await _foodService.GetById(id);

                if (food is null)
                {
                    _logger.LogDebug($"Food with ID {id} is not found");
                    return(NotFound());
                }

                await _foodService.Delete(food);

                return(Ok());
            }
            catch (LaprTrackrException ex)
            {
                _logger.LogDebug(ex.Message);
                return(ex.GetActionResult());
            }
            catch (Exception ex)
            {
                const string message = "Failed to delete food";
                _logger.LogError(ex, message);
                return(new LaprTrackrException(LaprTrackrStatusCodes.ServiceUnavailable, message).GetActionResult());
            }
        }
Esempio n. 2
0
        public ActionResult DeleteFood(int id)
        {
            foodService.Delete(id);


            return(RedirectToAction("Index", "Food"));
        }
 public IActionResult Delete(int id)
 {
     _foodService.Delete(new Food {
         Id = id
     });
     return(Ok());
 }
Esempio n. 4
0
        public IActionResult Delete(Food food)
        {
            var result = _foodService.Delete(food);

            if (result.Success)
            {
                return(Ok(result));
            }
            return(BadRequest(result));
        }
Esempio n. 5
0
        public IActionResult DeleteFood(int id)
        {
            var food = _foodOperation.Get(id);

            if (food != default)
            {
                _foodOperation.Delete(id);
                _foodOperation.Save();
                return(Ok());
            }
            return(NotFound());
        }
Esempio n. 6
0
 public HttpResponseMessage Delete(int id)
 {
     try
     {
         _foodService.Delete(id);
         SuccessResponse resp = new SuccessResponse();
         return(Request.CreateResponse(HttpStatusCode.OK, resp));
     }
     catch (System.Exception ex)
     {
         return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
     }
 }
        public async Task <ActionResult <FoodItem> > Delete([FromRoute] long id)
        {
            var model = await _service.GetById(id);

            if (model == null)
            {
                return(NotFound());
            }

            await _service.Delete(id);

            return(model);
        }
Esempio n. 8
0
        public async Task <ActionResult <Food_FoodDTO> > Delete([FromBody] Food_FoodDTO Food_FoodDTO)
        {
            if (!ModelState.IsValid)
            {
                throw new BindException(ModelState);
            }

            Food Food = ConvertDTOToEntity(Food_FoodDTO);

            Food = await FoodService.Delete(Food);

            Food_FoodDTO = new Food_FoodDTO(Food);
            if (Food.IsValidated)
            {
                return(Food_FoodDTO);
            }
            else
            {
                return(BadRequest(Food_FoodDTO));
            }
        }
Esempio n. 9
0
 public ActionResult Delete(int id)
 {
     _foodService.Delete(id);
     _foodService.Save();
     return(RedirectToAction(nameof(Index)));
 }
        public async Task <IActionResult> Delete([FromBody] Food food)
        {
            await _foodService.Delete(food);

            return(Ok());
        }
Esempio n. 11
0
        public async Task <IActionResult> Delete(int id)
        {
            await _foodService.Delete(id);

            return(Ok());
        }
Esempio n. 12
0
 public bool Delete(long id)
 {
     foodService = FoodService.Instance;
     return(foodService.Delete(id));
 }