public void Add(ManufacturerDto manufacturerDto)
{
var manufacturer = Mapper.Map <Manufacturer>(manufacturerDto);
Database.Manufacturers.Add(manufacturer);
Database.Save();
}
public ManufacturersViewModel Get(int?id)
{
using (var db = new SmartAutosContext())
{
return(ManufacturerDto.ManufacturersViewModelDTO(db.Manufacturer.FirstOrDefault(x => x.Id == id)));
}
}
public async Task <IActionResult> Put([FromBody] ManufacturerDto model)
{
if (!await _permissionService.Authorize(PermissionSystemName.Manufacturers))
{
return(Forbid());
}
var manufacturer = await _mediator.Send(new GetQuery <ManufacturerDto>() { Id = model.Id });
if (!manufacturer.Any())
{
return(NotFound());
}
if (ModelState.IsValid)
{
model = await _mediator.Send(new UpdateManufacturerCommand()
{
Model = model
});
return(Ok(model));
}
return(BadRequest(ModelState));
}
public CreateProductCommand(string title, double price, int countInStock, ManufacturerDto manufacturer)
{
Title = title;
Price = price;
CountInStock = countInStock;
Manufacturer = manufacturer;
}
public ManufacturerViewModel(ManufacturerDto manufacturerDto)
{
Id = manufacturerDto.Id;
Name = manufacturerDto.Name;
Description = manufacturerDto.Description;
Country = manufacturerDto.Country;
}
public async Task <IActionResult> UpdateManufacturer([FromRoute] int id, [FromBody] ManufacturerDto entityDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != entityDto.Id)
{
return(BadRequest());
}
var entity = await _repository.GetByIdAsync(entityDto.Id);
if (entity == null)
{
return(NotFound("Manufacturer does not exist"));
}
_mapper.Map(entityDto, entity);
try
{
_repository.Update(entity);
await _unitOfWork.SaveAsync();
}
catch (Exception)
{
throw new Exception("An unexpected error occured. Could not update.");
}
return(Ok(_mapper.Map <ManufacturerDto>(entity)));
}
public IActionResult GetManufacturerById(int manufacturerId)
{
var manufacturer = _manufacturerRepository.GetManufacturerById(manufacturerId);
if (manufacturer == null)
{
ModelState.AddModelError("", "Ошибка при получении производителя");
ViewBag.Message = $"Проблема с извлечением производителя с Id {manufacturerId} " +
$"из базы данных (возможно такой производитель не существует)";
manufacturer = new ManufacturerDto();
}
var items = _manufacturerRepository.GetItemsForManufacturer(manufacturerId);
if (items.Count() <= 0)
{
ViewBag.ItemMessage = $"У { manufacturer.Name} производителя нету товаров";
}
var itemManufacturerViewModel = new ManufacturerItemsViewModel()
{
Manufacturer = manufacturer,
Items = items
};
ViewBag.SuccessMessage = TempData["SuccessMessage"];
return(View(itemManufacturerViewModel));
}
public void Edit(ManufacturerDto manufacturerDto)
{
var manufacturer = Mapper.Map <Manufacturer>(manufacturerDto);
Database.Manufacturers.Update(manufacturer);
Database.Save();
}
public ManufacturerDto Create(ManufacturerDto dto)
{
var manufacturer = Mapper.Map <ManufacturerDto, Manufacturer>(dto);
_manufacturerRepository.Create(manufacturer);
return(Mapper.Map <Manufacturer, ManufacturerDto>(_manufacturerRepository.FindById(manufacturer.Id)));
}
public ManufacturerDto CreateManufacturer(ManufacturerDto manufacturerDto)
{
manufacturerDto.Slug = _slugService.CreateSlug(manufacturerDto.Name);
var manufacturerToInsert = _mapper.Map <ManufacturerEntity>(manufacturerDto);
var manufacturer = _manufacturerRepository.Insert(manufacturerToInsert);
return(_mapper.Map <ManufacturerDto>(manufacturer));
}
public void UpdateManufacturer(ManufacturerDto manufacturerDto)
{
var manufactuer = _manufacturerRepository.GetById(manufacturerDto.Id);
manufactuer.ImageUrl = manufacturerDto.ImageUrl;
manufactuer.Name = manufacturerDto.Name;
_manufacturerRepository.Update(manufactuer);
}
public PutProductCommand(string id, string title, double price, int countInStock, ManufacturerDto manufacturer)
{
Id = new ObjectId(id);
Title = title;
Price = price;
CountInStock = countInStock;
Manufacturer = manufacturer;
}
public IActionResult Update(ManufacturerDto manufacturerDto)
{
if (ModelState.IsValid)
{
_manufacturerService.UpdateManufacturer(manufacturerDto);
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Create(ManufacturerDto manufacturerDto)
{
if (ModelState.IsValid)
{
var reulst = _manufacturerService.Create(manufacturerDto);
return(RedirectToAction("Index"));
}
return(View());
}
public void UpdateManufacturer_Calls_Update_In_Repository()
{
var manufacturer = new ManufacturerEntity();
var dto = new ManufacturerDto();
mockRepo.Setup(r => r.GetById(It.IsAny <int>())).Returns(manufacturer);
manufacturerService.UpdateManufacturer(dto);
mockRepo.Verify(r => r.Update(It.IsAny <ManufacturerEntity>()), Times.Once);
}
public void GetManufacturerById_Returns_Manufacturer()
{
var manufacturer = new ManufacturerEntity();
var dto = new ManufacturerDto();
mockRepo.Setup(r => r.GetById(It.IsAny <int>())).Returns(manufacturer);
mockMapper.Setup(m => m.Map <ManufacturerDto>(manufacturer)).Returns(dto);
var actual = manufacturerService.GetManufacturer(1);
Assert.AreEqual(dto, actual);
}
public ManufacturerDto Update(ManufacturerDto manufacturerDto)
{
manufacturerDto.Name = manufacturerDto.Name.ToUpper();
var savedManufacturer = GetExistingManufacturer(manufacturerDto.Name);
savedManufacturer.UpdateFields(_mapper.Map <ManufacturerDto, Manufacturer>(manufacturerDto));
return(_mapper
.Map <Manufacturer, ManufacturerDto>(
_repository.Update(savedManufacturer)
));
}
public void CreateManufacturer_Returns_Manufacturer()
{
var manufacturer = new ManufacturerEntity();
var dto = new ManufacturerDto();
mockRepo.Setup(r => r.Insert(It.IsAny <ManufacturerEntity>()))
.Returns(manufacturer);
mockMapper.Setup(m => m.Map <ManufacturerDto>(manufacturer)).Returns(dto);
var actual = manufacturerService.CreateManufacturer(dto);
Assert.AreEqual(dto, actual);
}
public void GetManufacturerBySlug_Returns_Manufacturer()
{
var slug = "test";
var manufacturer = new ManufacturerEntity();
var dto = new ManufacturerDto();
mockRepo.Setup(r => r.GetBySlug(It.IsAny <string>())).Returns(manufacturer);
mockMapper.Setup(m => m.Map <ManufacturerDto>(manufacturer)).Returns(dto);
var actual = manufacturerService.GetManufacturerBySlug(slug);
Assert.AreEqual(dto, actual);
}
public static ManufacturerModel ToModel(this ManufacturerDto dto)
{
if (dto == null)
{
return(null);
}
return(new ManufacturerModel()
{
Name = dto.Name,
VinPrefix = dto.VinPrefix
});
}
public virtual async Task DeleteManufacturer(ManufacturerDto model)
{
var manufacturer = await _manufacturerService.GetManufacturerById(model.Id);
if (manufacturer != null)
{
await _manufacturerService.DeleteManufacturer(manufacturer);
//activity log
await _customerActivityService.InsertActivity("DeleteManufacturer", manufacturer.Id, _localizationService.GetResource("ActivityLog.DeleteManufacturer"), manufacturer.Name);
}
}
public void CreateManufacturer_Returns_ManufacturerResource()
{
var expected = new ManufacturerDto();
var request = new CreateManufacturerRequest();
mockMapper.Setup(m => m.Map <ManufacturerDto>(It.IsAny <CreateManufacturerRequest>())).Returns(new ManufacturerDto());
mockService.Setup(r => r.CreateManufacturer(It.IsAny <ManufacturerDto>())).Returns(expected);
mockService.Setup(r => r.GetManufacturer(It.IsAny <int>())).Returns(expected);
var result = manufacturerController.CreateManufacturer(request) as CreatedAtActionResult;
var actual = result.Value as ManufacturerDto;
Assert.AreEqual(expected, actual);
}
public void CreateManufacturer_Returns_Ok_Result()
{
var expected = new ManufacturerDto();
var request = new CreateManufacturerRequest();
mockMapper.Setup(m => m.Map <ManufacturerDto>(It.IsAny <CreateManufacturerRequest>())).Returns(new ManufacturerDto());
mockService.Setup(r => r.CreateManufacturer(It.IsAny <ManufacturerDto>())).Returns(expected);
mockService.Setup(r => r.GetManufacturer(It.IsAny <int>())).Returns(expected);
var result = manufacturerController.CreateManufacturer(request) as CreatedAtActionResult;
Assert.NotNull(result);
Assert.AreEqual(201, result.StatusCode);
}
public virtual ManufacturerDto InsertOrUpdateManufacturer(ManufacturerDto model)
{
if (string.IsNullOrEmpty(model.Id))
{
model = InsertManufacturer(model);
}
else
{
model = UpdateManufacturer(model);
}
return(model);
}
public IActionResult Save(ManufacturerDto manufacturerDto)
{
ManufacturerDto savedManufacturerDto = _manufacturerService.Save(manufacturerDto);
return(new CreatedResult(
_servicesUtils
.CreateUri(
Request,
Url.RouteUrl(
"GetByNameManufacturerRoute",
new { name = savedManufacturerDto.Name })),
savedManufacturerDto));
}
public virtual async Task <ManufacturerDto> InsertOrUpdateManufacturer(ManufacturerDto model)
{
if (string.IsNullOrEmpty(model.Id))
{
model = await InsertManufacturer(model);
}
else
{
model = await UpdateManufacturer(model);
}
return(model);
}
public IActionResult GetByName([FromRoute] string name)
{
ManufacturerDto savedManufacturerDto = _manufacturerService.GetByName(name);
if (savedManufacturerDto == null)
{
return(new NotFoundResult());
}
else
{
return(new OkObjectResult(savedManufacturerDto));
}
}
/// <inheritdoc />
public async Task <Result> AddManufacturer(ManufacturerDto manufacturerDto)
{
var manufacturer = new Manufacturer
{
Name = manufacturerDto.Name,
Sort = manufacturerDto.Sort,
Status = manufacturerDto.Status
};
await _context.AddAsync(manufacturer);
await _context.SaveChangesAsync();
return(Result.Ok());
}
public List <ManufacturersViewModel> GetAll()
{
List <ManufacturersViewModel> manufacturers = new List <ManufacturersViewModel>();
using (var db = new SmartAutosContext())
{
foreach (var item in db.Manufacturer.Select(x => x).ToList())
{
manufacturers.Add(ManufacturerDto.ManufacturersViewModelDTO(item));
}
}
return(manufacturers);
}
public IActionResult Post([FromBody] ManufacturerDto model)
{
if (!_permissionService.Authorize(PermissionSystemName.Manufacturers))
{
return(Forbid());
}
if (ModelState.IsValid)
{
model = _manufacturerApiService.InsertOrUpdateManufacturer(model);
return(Created(model));
}
return(BadRequest(ModelState));
}
