public async Task Delete(int id) { var remove = await _brandRepository.GetById(id); _brandRepository.Delete(remove); await _brandRepository.Commit(); }
public void Delete(int id) { var entity = _brandRepository.GetById(id); _brandRepository.Delete(entity); _unitofwork.Commit(); }
public async Task <IActionResult> Delete(int id) { var location = GetControllerActionName(); try { logger.LogInfo($"{location}: Delete Brand with id {id}"); if (id < 1) { logger.LogWarn($"{location}: Delete Brand with id {id} failed with bad data"); return(BadRequest()); } var isExists = await brandRepository.IsExists(id); if (!isExists) { logger.LogWarn($"{location}: Brand with id {id} not found"); return(NotFound()); } var brand = await brandRepository.GetById(id); var isSuccess = await brandRepository.Delete(brand); if (!isSuccess) { return(InternalError($"{location}: Delete Brand with id {id} failed")); } logger.LogInfo($"{location}: Delete Brand with id {id} successful"); return(NoContent()); } catch (Exception e) { return(InternalError($"{location}: {e.Message} - {e.InnerException}")); } }
public async Task <Response> Delete(int idBrand) { Response response = new Response(); if (idBrand < 0) { response.Errors.Add("ID Inválido!"); } if (response.HasErrors()) { return(response); } else { response = await _iBrandRepository.Delete(idBrand); if (!response.Success) { return(response); } else { //Logger } } }
public async Task <MediatR.Unit> Handle(DeleteBrandCommand request, CancellationToken cancellationToken) { // get brand by id var brandFromRepo = await _brandRepository.FindByIdAsync(request.BrandId); if (brandFromRepo == null) { throw new BrandNotFoundException(request.BrandId); } if (brandFromRepo.Products.Count > 0) { throw new BrandContainsProductsException(request.BrandId); } // we call delete brand to rase delete brand event to sync with algolia brandFromRepo.Delete(); // update brand with the new unit deleted _brandRepository.Delete(brandFromRepo); // save changes in the database and rase BrandUpdated event await _brandRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken); return(MediatR.Unit.Value); }
public async Task <Response> Delete(int idBrand) { Response response = new Response(); if (idBrand < 0) { response.Errors.Add("ID Inválido!"); } if (response.HasErrors()) { return(response); } else { try { return(response = await _iBrandRepository.Delete(idBrand)); } catch (Exception ex) { //_log.Info(response.Errors); _log.Error(ex + "\nStackTrace: " + ex.StackTrace); response.Errors.Add("DataBase error, contact the system owner"); return(response); } } }
public void Delete(Guid id) { var entity = brandRepository.GetById(id); brandRepository.Delete(entity); brandRepository.SaveChanges(); }
/// <summary> /// Only deletes the brand if there are no references that depend on it. /// </summary> /// <param name="brandId"></param> /// <returns></returns> public bool DeleteBrand(int brandId) { try { var brandToDelete = _brandRepository.FindOne(x => x.Id == brandId); _brandRepository.Delete(brandToDelete); _brandRepository.Persist(); Log.Debug("Brand '{0}' with Id '{1}' deleted.", brandToDelete.BrandName, brandToDelete.Id); return(true); } catch (Exception e) { Log.Error(string.Format("Failed to delete brand with Id '{0}'", brandId), e); return(false); } }
public async Task <ActionResult> Delete(int id) { try { var exist = await this._brandRepository.GetOneAsyn(id); if (exist == null) { return(NotFound($"No Brand found with this id {id}.")); } var data = await _brandRepository.Delete(id); if (data == false) { return(BadRequest("This brand could not be removed.")); } return(Ok("Brand removed.")); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public void Delete(int brandId) { Brands brand = GetById(brandId); _brandRepository.Delete(brand); _unitOfWork.Complete(); }
protected void gvBrandDetails_RowDeleting(object sender, GridViewDeleteEventArgs e) { try { Label lblBrandID = (Label)gvBrandDetails.Rows[e.RowIndex].FindControl("lblBrandID"); int brandid = int.Parse(lblBrandID.Text); var CategoryBrandMappings = mappingRepo.Find(m => m.BrandId == brandid); if (CategoryBrandMappings != null) { foreach (var item in CategoryBrandMappings) { mappingRepo.Delete(item.CategoryBrandMappingId); } brandRepo.Delete(brandid); } brandRepo.Save(); BindData(); ScriptManager.RegisterStartupScript(this, GetType(), "showalert", "alert('Brand Sucessfully DELETED');", true); } catch (Exception) { lblmsgs.Visible = true; lblmsgs.Text = "This Brand be use in system"; } //conn.Open(); }
public IActionResult Delete(int id) { if (brandRepository.Delete(id)) { return(RedirectToAction("Index")); } return(View()); }
public IActionResult Delete(int id) { var brand = _brandRepository.GetById(id); _brandRepository.Delete(brand); return(RedirectToAction(nameof(List))); }
public async Task <Unit> Handle(DeleteBrandCommand request, CancellationToken cancellationToken) { var brand = await _brandRepository.GetById(request.Id); await _brandRepository.Delete(brand); return(Unit.Value); }
public void Delete(int id) { if (id == 0) { throw new ArgumentException("The id can't be zero."); } _brandRepository.Delete(id); }
public async Task <bool> Handle(RemoveBrandCommand request, CancellationToken cancellationToken) { Domain.AggregatesModel.BrandAggregate.Brand brand = await _brandRepository.GetAsync(request.Id); _brandRepository.Delete(brand); var result = await _brandRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken); return(result); }
public IActionResult Delete(int id) { var result = brandRepository.Delete(id); if (result > 0) { return(RedirectToAction("Index", "Brand")); } return(View()); }
public DeleteBrandResponse DeleteBrand(DeleteBandRequest deleteBandRequest) { var brand = brandRepository.FindBrandById(deleteBandRequest.Id); brandRepository.Delete(brand); var deletebrandresponse = new DeleteBrandResponse { Brand = messageMapper.MapToBrandDto(brand) }; return(deletebrandresponse); }
public bool Delete(int id) { _proSer.DeleteByBrandId(id); _storeSer.DeleteByBrandId(id); var entity = _repo.GetById(id); if (entity == null) { return(false); } return(_repo.Delete(entity)); }
public async Task <IActionResult> DeleteBrand(BrandCreationDto dto) { try { await _brandRepository.Delete(dto); return(Ok()); } catch (Exception e) { return(NotFound("This Brand cannot be delete")); } }
public IActionResult Delete([FromRoute] int id, [FromRoute] int page = 1, [FromRoute] int pagesize = 10) { var brand = _brandRepo.GetBrand(id); if (brand == null) { return(NotFound()); } _brandRepo.Delete(id); _brandRepo.Save(); return(BrandsList(page, pagesize)); }
public async Task <ActionResultResponse> Delete(string tenantId, string id) { var brandInfo = await _brandRepository.GetInfo(tenantId, id); if (brandInfo == null) { return(new ActionResultResponse(-1, _resourceService.GetString("Brand does not exists."))); } var result = await _brandRepository.Delete(tenantId, id); return(new ActionResultResponse(result, result <= 0 ? _resourceService.GetString("Something went wrong. Please contact with administrator.") : _resourceService.GetString("Delete brand successful."))); }
public ActionResult Delete(BrandDTO entity) { try { Brand brand = brandRepository.GetById(entity.BrandID); brandRepository.Delete(brand); brandRepository.Save(); return(Json(entity, JsonRequestBehavior.DenyGet)); } catch (Exception e) { return(Json(false, JsonRequestBehavior.DenyGet)); } }
public async Task <IActionResult> Delete(int id) { var _brandDelete = await _brandRepository.GetById(id); if (_brandDelete != null) { await _brandRepository.Delete(_brandDelete); return(Ok(_brandDelete)); } else { return(Ok("La marca no existe")); } }
public DeleteBrandResponse DeleteBrand(DeleteBrandRequest request) { DeleteBrandResponse response = new DeleteBrandResponse(); try { brandRepository.Delete(request.BrandId); response.Success = true; } catch (Exception ex) { response.Success = false; response.Message = ex.Message; } return(response); }
public async Task <IActionResult> RemoveBrand(int id) { var brand = await _repo.GetBrand(id); if (brand == null) { return(NotFound("This brand doesn't exist.")); } _repo.Delete(brand); if (await _repo.SaveAll()) { return(NoContent()); } return(BadRequest("It was not possible to remove the item.")); }
protected override async void Delete(object sender, RoutedEventArgs e) { try { // Gets the brand to delete Brand ToBeDeleted = ((FrameworkElement)sender).DataContext as Brand; string messageboxTitle = String.Format(LangResource.MBTitleDeleteObj, ToBeDeleted.Name); string messageboxContent = String.Format(LangResource.MBContentDeleteObj, LangResource.TheBrand.ToLower(), ToBeDeleted.Name); MessageBoxManager.Yes = LangResource.Yes; MessageBoxManager.No = LangResource.No; MessageBoxManager.Register(); if (MessageBox.Show(messageboxContent, messageboxTitle, MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes) { MessageBoxManager.Unregister(); // Deletes the brand _brandRepo.Delete(ToBeDeleted); BrandsList.Remove(ToBeDeleted); await _brandRepo.SaveChangesAsync(); // Refreshes the datagrid BindData(); } else { MessageBoxManager.Unregister(); } } catch (Exception) { MessageBox.Show(LangResource.ErrUpdateOverviewFailed); MessageBoxManager.Unregister(); } }
/// <summary> /// Implementación de <see cref="IRequestHandler{TRequest, TResponse}.Handle(TRequest, CancellationToken)"/> /// </summary> public async Task <Unit> Handle(Request request, CancellationToken cancellationToken) { try { if (request != null) { BrandInfo brand = new BrandInfo { Id = request.Id, Name = request.Name }; await BrandRepository.Delete(brand); } } catch (Exception ex) { CommandExceptionHandler.Handle(ex, request); } return(Unit.Value); }
public async Task <IActionResult> Delete(int id) { try { var response = await _repository.Delete(id); if (response != 0) { return(Ok("Deleted successfully")); } else { return(BadRequest("An error ocurred, contact IT Staff")); } } catch (Exception e) { //Log error Log.Error(e.Message); Log.Error(e.StackTrace); return(BadRequest("An error ocurred, contact IT Staff")); } }
public ActionResult DeleteConfirmed(int id) { CarBrand brand = _brandRepository.GetBrandById(id); if (brand == null) { return(HttpNotFound()); } if (!brand.Models.Any()) { var opStatus = new OperationStatus { Status = true, Message = "Brand deleted" }; try { _brandRepository.Delete(brand); } catch (Exception exp) { opStatus = OperationStatus.CreateFromExeption("Error deleting brand car.", exp); } TempData["OperationStatus"] = opStatus; } else { TempData["OperationStatus"] = new OperationStatus() { Status = true, Message = "You must delete all models for this brand first" } }; return(RedirectToAction("Index")); } }