public ManufacturerViewModel saveManufacturer(ManufacturerViewModel manufacturerViewModel)
{
//throw new NotImplementedException();
ManufacturerDTO manufacturerDTO = new ManufacturerDTO();
var manufacturerMapper = new ecvMapper <ManufacturerModel, ManufacturerDTO>();
manufacturerDTO = manufacturerMapper.CreateMappedObject(manufacturerViewModel.manufacturerModel);
var _manufacturerServiceStatus = _mnfService.SaveEntity(manufacturerDTO);
if (_manufacturerServiceStatus.operationStatus == OperationStatus.Error)
{
manufacturerViewModel.operationStatus = OperationStatus.Error;
if (!string.IsNullOrEmpty(_manufacturerServiceStatus.OperationMessage))
{
manufacturerViewModel.OperationMessage = _manufacturerServiceStatus.OperationMessage;
}
manufacturerViewModel.ecvRuleViolation = _manufacturerServiceStatus.ecvRuleViolation;
}
else
{
manufacturerViewModel.operationStatus = OperationStatus.Success;
if (!string.IsNullOrEmpty(_manufacturerServiceStatus.OperationMessage))
{
manufacturerViewModel.OperationMessage = _manufacturerServiceStatus.OperationMessage;
}
manufacturerViewModel.ecvRuleViolation = _manufacturerServiceStatus.ecvRuleViolation;
}
return(manufacturerViewModel);
}
public async Task <IActionResult> PutManufacturer([FromRoute] int id, [FromBody] ManufacturerDTO manufacturerDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != manufacturerDTO.Id)
{
return(BadRequest());
}
var manufacturer = await _context.Manufacturer.FindAsync(id);
manufacturer.Name = manufacturerDTO.Name;
_context.Entry(manufacturer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ManufacturerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task ManufacturerService_Should_Update_Manufacturer()
{
// Arrange
SetUpUnitOfWork();
var service = new ManufacturerService(_unitOfWork.Object, _mapper);
var entity = new ManufacturerDTO()
{
Name = "TestName",
};
var newEntity = new ManufacturerDTO()
{
Name = "NewTestName",
};
await service.CreateAsync(entity);
await _unitOfWork.Object.SaveAsync();
// Act
entity.Name = newEntity.Name;
await service.UpdateAsync(entity);
await _unitOfWork.Object.SaveAsync();
// Assert
Assert.NotNull(entity);
Assert.Equal(newEntity.Name, entity.Name);
}
private void InitCommands()
{
RemoveGoodCommand = new RelayCommand(x =>
{
goodService.Remove(SelectedGood);
Goods.Remove(SelectedGood);
});
RemoveCategoryCommand = new RelayCommand(x =>
{
categoryService.Remove(SelectedCategory);
Categories.Remove(SelectedCategory);
});
RemoveManufacturerCommand = new RelayCommand(x =>
{
manufacturerService.Remove(SelectedManufactirer);
Manufacturers.Remove(SelectedManufactirer);
});
AddUpdateGoodCommand = new RelayCommand(x =>
{
AddUpdateGood dlg = new AddUpdateGood();
dlg.ShowDialog();
var good = new GoodDTO
{
GoodName = GoodViewModelProxy.Proxy.GoodName,
GoodCount = GoodViewModelProxy.Proxy.GoodCount,
Price = GoodViewModelProxy.Proxy.GoodPrice,
CategoryId = categoryService.GetAll().FirstOrDefault(y => y.CategoryName == GoodViewModelProxy.Proxy.GoodCategory).CategoryId,
ManufacturerId = manufacturerService.GetAll().FirstOrDefault(y => y.ManufacturerName == GoodViewModelProxy.Proxy.GoodManufacturer).ManufacturerId
};
var result = goodService.CreateOrUpdate(good);
Goods.Add(result);
});
AddUpdateCategoryCommand = new RelayCommand(x =>
{
AddUpdateCategoryView dlg = new AddUpdateCategoryView();
dlg.ShowDialog();
var category = new CategoryDTO
{
CategoryName = CategoryViewModelProxy.Proxy.CategoryName
};
var result = categoryService.CreateOrUpdate(category);
Categories.Add(result);
});
AddUpdateManufacturerCommand = new RelayCommand(x =>
{
AddUpdateManufactorerView dlg = new AddUpdateManufactorerView();
dlg.ShowDialog();
var manufactorer = new ManufacturerDTO
{
ManufacturerName = ManufacturerModelProxy.Proxy.ManufacturerName
};
var result = manufacturerService.CreateOrUpdate(manufactorer);
Manufacturers.Add(result);
});
}
public void CreateManufacturer(ManufacturerDTO item)
{
var mapper = new MapperConfiguration(cg => cg.CreateMap <ManufacturerDTO, Manufacturer>()).CreateMapper();
var mr = mapper.Map <ManufacturerDTO, Manufacturer>(item);
Db.Manufacturers.Create(mr);
Db.Save();
}
public ActionResult ManufacturerEdit(ManufacturerDTO manufacturer)
{
if (ModelState.IsValid)
{
service.CreateOrUpdate(manufacturer);
service.SaveAll(); return(RedirectToAction("ManufacturerView"));
}
return(RedirectToAction("ManufacturerEdit"));
}
public async Task <ManufacturerDTO> UpdateAsync(ManufacturerDTO dto)
{
var model = _mapper.Map <Manufacturer>(dto);
_unitOfWork.ManufacturerRepository.Update(model);
await _unitOfWork.SaveAsync();
return(_mapper.Map <ManufacturerDTO>(model));
}
public ActionResult CreateManufacturer(ManufacturerDTO manufacturerViewModel)
{
if (ModelState.IsValid)
{
manufacturerService.CreateOrUpdate(manufacturerViewModel);
return(RedirectToAction("Index"));
}
return(View(manufacturerViewModel));
}
public ActionResult Edit(ManufacturerDTO manufacturer)
{
if (ModelState.IsValid)
{
manufacturerService.AddOrUpdate(manufacturer);
return(RedirectToAction("IndexHtmlAction"));
}
return(View("Edit"));
}
public Manufacturer Post(ManufacturerDTO value)
{
Manufacturer manufacturer = new Manufacturer()
{
Name = value.Name,
Location = value.Location
};
return(IManufacturerRepo.Create(manufacturer));
}
public async Task <IHttpActionResult> GetById(int id)
{
ManufacturerDTO Manufacturer = await ManufacturerService.GetAll().Where(x => x.Id == id && !x.Deleted).ProjectTo <ManufacturerDTO>().FirstOrDefaultAsync();
if (Manufacturer == null)
{
return(NotFound());
}
return(Ok(Manufacturer));
}
public async Task <IActionResult> UpdateManufacturer(int id)
{
var manufacturer = await manufacturerService.GetByIdAsync(id);
var config = new MapperConfiguration(cfg => cfg.CreateMap <Manufacturer, ManufacturerDTO>());
var mapper = new Mapper(config);
ManufacturerDTO manDTO = mapper.Map <Manufacturer, ManufacturerDTO>(manufacturer);
return(View(manDTO));
}
public async Task <ManufacturerDTO> CreateManufacturer(ManufacturerDTO ManufacturerDTO)
{
Manufacturer manufacturer = new Manufacturer {
CountryId = ManufacturerDTO.CountryId, Name = ManufacturerDTO.Name
};
await db.Manufacturers.AddAsync(manufacturer);
await db.SaveChangesAsync();
return(ManufacturerDTO);
}
public void CreateManufacturer(ManufacturerDTO viewmodel)
{
try
{
var manufacturer = Mapper.Map <ManufacturerDTO, Manufacturer>(viewmodel);
_manufacturerRepository.AddNewManufacturer(manufacturer);
}
catch (Exception ex)
{
throw;
}
}
public ActionResult <ManufacturerDTO> GetManufacturer(int ManufacturerId)
{
try
{
ManufacturerDTO manufacturer = serv.GetManufacturer(ManufacturerId);
return(Ok(manufacturer));
}
catch (ValidationException ex)
{
return(Content(ex.Message));
}
}
public PartialViewResult ManufacturerEdit(int id = 1)
{
if (id < 0)
{
ManufacturerDTO createDTO = new ManufacturerDTO();
service.CreateOrUpdate(createDTO);
return(PartialView(createDTO));
}
ManufacturerDTO manufacturer = service.Get(id);
return(PartialView(manufacturer));
}
public async Task <IActionResult> UpdateManufacturer(ManufacturerDTO manuf, string country)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <ManufacturerDTO, Manufacturer>());
var mapper = new Mapper(config);
Manufacturer manufacturer = mapper.Map <ManufacturerDTO, Manufacturer>(manuf);
country = "USA";
await manufacturerService.UpdateManufacturer(manufacturer.Id, manufacturer.Name, country);
return(RedirectToAction("Index"));
}
public ActionResult Delete(int id)
{
try
{
ManufacturerDTO manufacturer = manufacturerService.Get(id);
manufacturerService.Delete(manufacturer);
return(Json("OK"));
}
catch
{
return(Json("Error"));
}
}
public async Task <ActionResult <ManufacturerDTO> > CreateManufacturer(ManufacturerDTO ManufacturerDTO)
{
try
{
await serv.CreateManufacturer(ManufacturerDTO);
}
catch (Exception ex)
{
var err = new { error = ex.Message };
return(Ok(err));
}
return(Ok(ManufacturerDTO));
}
public async Task <IHttpActionResult> Create([FromBody] ManufacturerDTO ManufacturerDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var entity = ManufacturerDto.ToEntity();
entity.CreateUserId = User.Identity.GetUserId();
entity.CreateTime = DateTime.Now;
await ManufacturerService.InsertAsync(entity);
return(Ok(entity.ToModel()));
}
public void Put(int id, ManufacturerDTO value)
{
Manufacturer manufacturer = IManufacturerRepo.Get(id);
if (value.Name != null)
{
manufacturer.Name = value.Name;
}
if (value.Location != null)
{
manufacturer.Location = value.Location;
}
IManufacturerRepo.Update(manufacturer);
}
public ActionResult UploadPhoto(HttpPostedFileBase fileUpload)
{
string Id = Request.Params["id"];
if (fileUpload != null)
{
ManufacturerDTO manufacturer = manufacturerService.Get(Convert.ToInt32(Id));
manufacturer.ManufacturerPhotoPath = "/Images/" + fileUpload.FileName;
manufacturerService.AddOrUpdate(manufacturer);
}
string path = Path.Combine(Server.MapPath("~/Images/"), fileUpload.FileName);
fileUpload.SaveAs(path);
return(RedirectToAction("Edit", "Manufacturer", new { id = Convert.ToInt32(Id) }));
}
public async Task <IActionResult> AddManufacturer(ManufacturerDTO manDTO, string country)
{
if (!ModelState.IsValid)
{
return(await Task.Run(() => View(manDTO)));
}
var config = new MapperConfiguration(cfg => cfg.CreateMap <ManufacturerDTO, Manufacturer>());
var mapper = new Mapper(config);
Manufacturer manufacturer = mapper.Map <ManufacturerDTO, Manufacturer>(manDTO);
country = "USA";
await manufacturerService.CreateManufacturerAsync(manDTO.Name, country);
return(RedirectToAction("Index"));
}
public List <ManufacturerDTO> CreateManufacturerDTOs()
{
List <ManufacturerDTO> manufacturerDTOList = new List <ManufacturerDTO>();
var manufacturers = GetManufacturers();
foreach (Manufacturer manufacturer in manufacturers)
{
ManufacturerDTO manufacturerDTO = new ManufacturerDTO
{
ManufacturerKey = manufacturer.ManufacturerKey,
ManufacturerName = manufacturer.ManufacturerName
};
manufacturerDTOList.Add(manufacturerDTO);
}
return(manufacturerDTOList);
}
public async Task <IActionResult> PostManufacturer([FromBody] ManufacturerDTO manufacturerDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var manufacturer = new Manufacturer
{
Name = manufacturerDTO.Name
};
_context.Manufacturer.Add(manufacturer);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetManufacturer), new { id = manufacturer.Id }, ManufacturerDTO.FromManufacturer(manufacturer)));
}
public async Task ManufacturerService_Should_Create_Manufacturer_Async()
{
// Arrange
SetUpUnitOfWork();
var service = new ManufacturerService(_unitOfWork.Object, _mapper);
var expectedEntity = new ManufacturerDTO()
{
Name = "TestName",
};
// Act
var actualEntity = await service.CreateAsync(expectedEntity);
await _unitOfWork.Object.SaveAsync();
// Assert
Assert.NotNull(actualEntity);
Assert.Equal(expectedEntity.Name, actualEntity.Name);
}
public async Task <IActionResult> DeleteManufacturer([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var manufacturer = await _context.Manufacturer.FindAsync(id);
if (manufacturer == null)
{
return(NotFound());
}
_context.Manufacturer.Remove(manufacturer);
await _context.SaveChangesAsync();
return(Ok(ManufacturerDTO.FromManufacturer(manufacturer)));
}
public ManufacturerDTO GetManufacturerById(int manufacturerId)
{
var _manufacturer = _unitOfWork.manufacturerRepository.Get(manufacturerId);
ManufacturerDTO _manufacturerDTO;
if (_manufacturer == null)
{
_manufacturerDTO = null;
}
else
{
_manufacturerDTO = new ManufacturerDTO();
var manufacturerMapper = new ecvMapper <Manufacturer, ManufacturerDTO>();
_manufacturerDTO = manufacturerMapper.CreateMappedObject(_manufacturer);
}
return(_manufacturerDTO);
}
public async Task ManufacturerService_Should_Delete_Manufacturer_Async()
{
// Arrange
SetUpUnitOfWork();
var service = new ManufacturerService(_unitOfWork.Object, _mapper);
var entity = new ManufacturerDTO()
{
Name = "TestName",
};
entity = await service.CreateAsync(entity);
await _unitOfWork.Object.SaveAsync();
// Act
await service.DeleteAsync(entity.Id);
await _unitOfWork.Object.SaveAsync();
// Assert
Assert.Null(await service.GetAsync(entity.Id));
}
public void Update(ManufacturerDTO item)
{
item.TimeStamps = DateTime.Now;
_unitOfWork.EFRepository <Manufacturer>().Update(_mapper.Map <Manufacturer>(item));
}
public static ManufacturerDTO CreateManufacturerDTO(global::System.Guid ID, int type)
{
ManufacturerDTO manufacturerDTO = new ManufacturerDTO();
manufacturerDTO.Id = ID;
manufacturerDTO.Type = type;
return manufacturerDTO;
}
public void AddToManufacturers(ManufacturerDTO manufacturerDTO)
{
base.AddObject("Manufacturers", manufacturerDTO);
}