public async Task <ActionResult> Edit(int id, BrandViewModel brand) { /*if (brand.Id != id) // ako neshto gyrmi iztrij ili promeni if * { * return NotFound(); * } */ brand.Id = id; try { BrandsClient brandsClient = new BrandsClient(); var brandDto = new BrandDto { Id = brand.Id, BrandName = brand.BrandName, ManufacturerCountry = brand.ManufacturerCountry, ProductClass = brand.ProductClass, Rating = brand.Rating }; await brandsClient.UpdateAsync(brandDto); await brandsClient.CloseAsync(); return(RedirectToAction(nameof(Index))); } catch { return(View()); } }
public async Task <ActionResult> Create(BrandViewModel brand) { try { BrandsClient brandsClient = new BrandsClient(); var brandDto = new BrandDto { Id = brand.Id, BrandName = brand.BrandName, ManufacturerCountry = brand.ManufacturerCountry, ProductClass = brand.ProductClass, Rating = brand.Rating }; await brandsClient.CreateAsync(brandDto); await brandsClient.CloseAsync(); return(RedirectToAction(nameof(Index))); } catch { return(View()); } }
public bool DeleteBrand(BrandDto brandDto, out string message) { try { using (PosRiContext dbContext = new PosRiContext()) { var brand = dbContext.Brands.Find(brandDto.Id); if (brand == null) { message = "Marca no encontrada."; return(false); } brand.IsActive = false; dbContext.Entry(brand).State = EntityState.Modified; if (dbContext.SaveChanges() > 0) { message = ""; return(true); } message = "No se pudo eliminar la marca."; return(false); } } catch (Exception e) { message = e.Message; return(false); } }
public BrandDto AddBrand(BrandDto brandDto, out string message) { try { using (PosRiContext dbContext = new PosRiContext()) { message = ""; Brand brand = new Brand { Name = brandDto.Name, IsActive = true }; dbContext.Entry(brand).State = EntityState.Added; dbContext.Brands.Add(brand); if (dbContext.SaveChanges() > 0) { brandDto.Id = brand.Id; return(brandDto); } message = "No se pudo agregar la marca."; return(null); } } catch (Exception e) { message = e.Message; return(null); } }
public async Task <IActionResult> Post([FromBody] BrandCategoryCreateModel brandCategoryCreateModel) { CategoryDto categoryDto = await _brandCategoryService.GetCategory(brandCategoryCreateModel.Category); if (categoryDto == null) { return(NotFound("No such category")); } BrandDto brandDto = await _brandCategoryService.GetBrand(brandCategoryCreateModel.Brand); if (brandDto == null) { return(NotFound("No such brand")); } if (await _brandCategoryService.BrandCategoryExists(brandDto.BrandId, categoryDto.CategoryId)) { return(Conflict($"This relation already exists")); } BrandCategoryDto newBrandCategoryDto = await _brandCategoryService.CreateRelation(brandDto.BrandId, categoryDto.CategoryId); BrandCategoryWebModel newBrandCategoryModel = _mapper.Map <BrandCategoryWebModel>(newBrandCategoryDto); return(CreatedAtAction(nameof(Get), new { id = newBrandCategoryModel.BrandCategoryId }, newBrandCategoryModel)); }
public BrandDto UpdateBrand(BrandDto brandDto, out string message) { try { using (PosRiContext dbContext = new PosRiContext()) { message = ""; var brand = dbContext.Brands.Find(brandDto.Id); if (brand == null) { message = "Marca no encontrada."; return(null); } brand.Name = brandDto.Name; dbContext.Entry(brand).State = EntityState.Modified; if (dbContext.SaveChanges() > 0) { return(brandDto); } message = "No se pudo actualizar la marca."; return(null); } } catch (Exception e) { message = e.Message; return(null); } }
public List <BrandDto> GetBrands() { var brands = brandRepository.GetAll(); var brandDtos = new List <BrandDto>(); foreach (var brand in brands) { var brandDto = new BrandDto { Id = brand.Id, Name = brand.Name, LogoUrl = brand.LogoUrl }; brandDtos.Add(brandDto); } return(brandDtos); //return brands.Select(x => new BrandDto //{ // Id = x.Id, // Name = x.Name, // LogoUrl = x.LogoUrl //}).ToList(); }
public IActionResult UpdateBrand(int id, BrandDto brand) { if (id != brand.Id) { return(BadRequest()); } try { _brandService.Modify(new Brand { Id = brand.Id, Name = brand.Name }); } catch (DbUpdateConcurrencyException) { return(NotFound()); } catch (DbUpdateException ex) { if (ex?.InnerException?.Message != null) { return(BadRequest(ex?.InnerException?.Message)); } else { return(BadRequest(ex?.Message)); } } return(NoContent()); }
public async Task <BrandDto> CreateBrand(BrandDto brandDto) { var brandToCreate = _mapper.Map <Brand>(brandDto); var createdBrand = await CreateAndReturn(brandToCreate); return(_mapper.Map <BrandDto>(createdBrand)); }
public async Task <BrandDto> UpdateBrandProperties(BrandDto brandDto) { var brandForUpdate = _mapper.Map <Brand>(brandDto); var updatedBrand = await UpdateAndReturn(brandForUpdate); return(_mapper.Map <BrandDto>(updatedBrand)); }
public async Task <IActionResult> PutBrand(int id, BrandDto brand) { if (id != brand.Id) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var brandDbModel = _brandMapper.ToDbModel(brand); _context.Entry(brandDbModel).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BrandExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public IActionResult UpdateBrand(BrandDto brandDto) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _brandsService.Update(brandDto); var integrationEventData = JsonConvert.SerializeObject(new { id = brandDto.Id, brandName = brandDto.BrandName }); PublishToMessageQueue("brands.update", integrationEventData); _logger.LogInformation($"Brand updated, id {brandDto.Id}"); return(NoContent()); } catch (DbQueryResultNullException e) { return(NotFound(e.Message)); } }
public async Task <IActionResult> CreateBrand(BrandDto brandDto) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (brandDto.Id != 0) { return(BadRequest("The Id should be empty")); } var createdBrand = await _brandsService.CreateAsync(brandDto); var integrationEventData = JsonConvert.SerializeObject(new { id = createdBrand.Id, brandName = createdBrand.BrandName }); PublishToMessageQueue("brands.add", integrationEventData); _logger.LogInformation($"Brand added, id {createdBrand.Id}"); //Fetch the brand from data source return(CreatedAtRoute("GetBrandById", new { id = createdBrand.Id }, createdBrand)); } catch (DbQueryResultNullException e) { return(NotFound(e.Message)); } }
public async Task <IActionResult> PutBrandDto(int id, BrandDto brandDto) { if (id != brandDto.BrandId) { return(BadRequest()); } var brand = _context.Brand.FirstOrDefault(x => x.BrandId == brandDto.BrandId); brand.BrandName = brandDto.BrandName; _context.Entry(brand).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BrandDtoExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public void AddBrand(BrandDto brand) { _repo.Insert(new Brand() { Name = brand.Name, Id = brand.Id }); }
public async Task <IActionResult> Put([FromBody] BrandDto model) { if (!await _permissionService.Authorize(PermissionSystemName.Brands)) { return(Forbid()); } var brand = await _mediator.Send(new GetQuery <BrandDto>() { Id = model.Id }); if (!brand.Any()) { return(NotFound()); } if (ModelState.IsValid) { model = await _mediator.Send(new UpdateBrandCommand() { Model = model }); return(Ok(model)); } return(BadRequest(ModelState)); }
public async Task <IActionResult> EditBrand(int id, BrandDto model) { if (!ModelState.IsValid) { return(BadRequest("Something want wrong while updating brand")); } var brandToEdit = await _brandService.GetBrandByIdAsync(id); if (brandToEdit == null) { return(BadRequest("Brand not found")); } brandToEdit.Name = model.Name; await _brandService.UpdateBrandAsync(brandToEdit); await _genericRepository.SaveChangesAsync(); return(Ok(new { status = 200, message = "Brand edited successfully" })); }
public async Task <ApiRequestResult> AddAsync(BrandDto dto) { var command = dto.EntityMap <BrandDto, Brand>(); await _brandRepository.AddAsync(command); return(ApiRequestResult.Success("添加成功")); }
public void DtoToModelEntityTest() { var componentTypeDto = new ComponentTypeDto { Id = 1, Name = "CPU" }; var brandDto = new BrandDto { Id = 1, Name = "Intel" }; var componentDto = new ComponentDto { Id = 1, Name = "Intel 6600k", ComponentType = componentTypeDto, Brand = brandDto, Price = 100 }; var model = _componentMapper.ToEntityModel(componentDto); Assert.Equal(componentDto.Id, model.Id); Assert.Equal(componentDto.Name, model.Name); Assert.Equal(componentDto.Price, model.Price); Assert.Equal(componentDto.Brand.Id, model.Brand.Id); Assert.Equal(componentDto.Brand.Name, model.Brand.Name); Assert.Equal(componentDto.ComponentType.Id, model.ComponentType.Id); Assert.Equal(componentDto.ComponentType.Name, model.ComponentType.Name); }
public IEnumerable <BrandDto> GetAllBrands(string searchString) { List <BrandDto> result = new List <BrandDto>(); var query = from b in MContext.Brands select new { BrandID = b.ID, BrandName = b.Name }; if (!String.IsNullOrEmpty(searchString)) { query = query.Where(s => s.BrandName.Contains(searchString)); } foreach (var item in query) { BrandDto brand = new BrandDto() { ID = item.BrandID, Name = item.BrandName }; result.Add(brand); } return(result.ToList()); }
public static void MappingBrand(this BrandDto brandDto, Brand brand) { brand.Id = brandDto.Id; brand.Name = brandDto.Name; brand.Address = brandDto.Address; brand.Phone = brandDto.Phone; }
private void gridViewBrand_RowUpdated(object sender, DevExpress.XtraGrid.Views.Base.RowObjectEventArgs e) { try { var currentBrand = e.Row as BrandViewForUIDto; if (currentBrand != null) { var toSave = new BrandDto { Id = currentBrand.BrandId, Name = currentBrand.Brand, Models = new System.Collections.Generic.List <ModelDto>(), ProductType = new System.Collections.Generic.List <ProductTypeDto>() }; var models = currentBrand.Models.Split(','); foreach (var model in models) { toSave.Models.Add(new ModelDto { Name = model }); } toSave.ProductType.Add(new ProductTypeDto { Name = currentBrand.ProductType }); var update = this.ServiceClient.SaveBrand(toSave); } this.Refresh(); } catch (Exception ex) { MessageBox.Show(ex.Message, Properties.Resources.Error_Title, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
//[ActionName("details")] api/brand/1 public IHttpActionResult Put(int id, [FromBody] BrandDto dto, [UserId] int userId) { if (!ModelState.IsValid) { return(BadRequest()); } var item = _brandRepository.GetItem(id); if (item == null) { return(NotFound()); } var createDate = item.CreatedDate; var createUser = item.CreatedUser; dto.Id = id; item = Mapper.Map <BrandDto, Brand>(dto, item); item.UpdatedDate = DateTime.Now; item.UpdatedUser = userId; item.CreatedDate = createDate; item.CreatedUser = createUser; item = CheckModel(item); ((IOPCRepository <int, Brand>)_brandRepository).Update(item); return(Get(id)); }
public async Task <IActionResult> UpdateBrand([FromBody] BrandDto brand) { if (brand != null) { var _brand = await _repository.Brand.GetBrandById(brand.BrandId, brand.CompanyId); if (_brand != null) { var __brand = _mapper.Map <CompanyBrandModel>(brand); _brand.BrandName = __brand.BrandName; _repository.Brand.UpdateBrand(_brand); await _repository.Save(); var updatedBrand = _mapper.Map <BrandDto>(__brand); var company = await _repository.Company.GetCompanyById(new Guid(updatedBrand.CompanyId)); if (company != null) { updatedBrand.CompanyName = company.CompanyName; } return(Ok(updatedBrand)); } else { return(StatusCode(500, "Something went wrong")); } } else { return(StatusCode(500, "Something went wrong")); } }
public async Task Delete(BrandDto dto) { var brand = await _brandRepository.GetById(dto.Id); if (brand != null) { var delete = await _brandRepository.GetById(brand.Id); if (delete.ErasedState) { delete.ErasedState = false; await _brandRepository.Update(delete); } else { delete.ErasedState = true; await _brandRepository.Update(delete); } } else { throw new Exception("This Brand not exist"); } }
public bool Save(BrandDto brandDto) { Brand brand = new Brand { Id = brandDto.Id, Name = brandDto.Name, Country = brandDto.Country, Description = brandDto.Description }; try { using (UnitOfWork unitOfWork = new UnitOfWork()) { if (brandDto.Id == 0) { unitOfWork.BrandRepository.Insert(brand); } else { unitOfWork.BrandRepository.Update(brand); } unitOfWork.Save(); } return(true); } catch { return(false); } }
//Thêm Brand mới vào bảng MES_Audit_Brand public async Task <bool> Add(BrandDto model) { var brand = _mapper.Map <MES_Audit_Brand>(model); _repoBrand.Add(brand); return(await _repoBrand.SaveAll()); }
public IActionResult AddOrEdit(int id, BrandDto brand) { if (ModelState.IsValid) { if (id == 0) { brandService.CreateBrand(brand); } else { try { brandService.UpdateBrand(brand); } catch (DbUpdateConcurrencyException) { if (!brandService.BrandExists(brand.Id)) { return(NotFound()); } else { throw; } } } var brands = brandService.GetAll(); return(Json(new { isValid = true, html = Helper.RenderRazorViewToString(this, "_ViewAll", brands) })); } return(Json(new { isValid = false, html = Helper.RenderRazorViewToString(this, "AddOrEdit", brand) })); }
public async Task <BrandDto> GetBrand(string title) { var lowerTitle = title.ToLower(); BrandDto brand = await _brandRepo.FindBrand(lowerTitle); return(brand); }
public void Execute(BrandDto request) { request.Id = 0; _validator.ValidateAndThrow(request); _context.Brands.Add(_mapper.Map <Brand>(request)); _context.SaveChanges(); }
public ActionResult AddNewBrandName(BrandDto dto) { return this.Direct(new { success = !String.IsNullOrWhiteSpace(dto.Name), data = dto }); }
public object Get(BrandDto request) { var brand = new BrandDto { Name = "hmm" }; return brand; }