public async Task AddITemToCatalogAsync(CatalogItemDto catalogItemDto)
{
try
{
var request = _daprClient.CreateInvokeMethodRequest(
HttpMethod.Post,
_configuration["DaprConfiguration:AppId_Catalog"],
_catalogApiDefaultMethod,
catalogItemDto
);
var response = await _daprClient.InvokeMethodWithResponseAsync(request);
if (!response.IsSuccessStatusCode)
{
_logger.LogCritical("Failed to add items to the catalog.", response);
throw new Exception($"Failed to add items to the catalog. Please try again.");
}
}
catch (Exception ex)
{
throw;
}
_logger.LogInformation("An item was added to the basket.", catalogItemDto);
}
public override async Task <ActionResult <UpdateCatalogItemResponse> > HandleAsync(UpdateCatalogItemRequest request, CancellationToken cancellationToken)
{
var response = new UpdateCatalogItemResponse(request.CorrelationId());
var existingItem = await _itemRepository.GetByIdAsync(request.Id, cancellationToken);
existingItem.UpdateDetails(request.Name, request.Description, request.Price);
existingItem.UpdateBrand(request.CatalogBrandId);
existingItem.UpdateType(request.CatalogTypeId);
await _itemRepository.UpdateAsync(existingItem, cancellationToken);
var dto = new CatalogItemDto
{
Id = existingItem.Id,
CatalogBrandId = existingItem.CatalogBrandId,
CatalogTypeId = existingItem.CatalogTypeId,
Description = existingItem.Description,
Name = existingItem.Name,
PictureUri = _uriComposer.ComposePicUri(existingItem.PictureUri),
Price = existingItem.Price
};
response.CatalogItem = dto;
return(response);
}
public async Task <ActionResult> Post([FromBody] CatalogItemDto catalogItemDto)
{
if (catalogItemDto == null)
{
return(BadRequest());
}
try
{
CatalogItem catalogItem = _mapper.Map <CatalogItem>(catalogItemDto);
if (catalogItem == null)
{
return(BadRequest());
}
catalogItem.CatalogItemId = Guid.NewGuid();
await _catalogItemUnit.CatalogItemABCRepository.Insert(catalogItem);
await _catalogItemUnit.SaveChangesAsync();
return(Ok(catalogItem));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> UpdateCatalogItem([FromBody] CatalogItemDto ctgItem, int Id, int itemId)
{
if (ctgItem is null)
{
return(BadRequest());
}
var data = await _catalogDataRepository.GetCatalogItem(Id, itemId);
if (data is null)
{
_logger.LogInformation($"With id {itemId} data wasn't found in Db");
return(NotFound());
}
var resultDto = Mapper.Map <CatalogItem>(ctgItem);
var result = _catalogDataRepository.UpdateCatalogItem(Id, itemId, resultDto);
if (!_catalogDataRepository.Save())
{
return(StatusCode(500, "A problem happened while handeling your request"));
}
return(Ok(data));
}
public async Task <IActionResult> CreateCatalogItem([FromBody] CatalogItemDto ctgItem, int Id)
{
if (ctgItem is null)
{
return(BadRequest());
}
var data = await _catalogDataRepository.GetCatalogItemsByIdAsync(Id);
if (data is null)
{
_logger.LogInformation($"With id {Id} data wasn't found in Db");
return(NotFound());
}
var result = Mapper.Map <CatalogItem>(ctgItem);
await _catalogDataRepository.CreateCatalogItem(Id, result);
if (!_catalogDataRepository.Save())
{
return(StatusCode(500, "A problem happened while handeling your request"));
}
var resultDto = Mapper.Map <CatalogItemDto>(result);
return(CreatedAtRoute(routeName: "GetCatalogItem",
routeValues: new { id = resultDto.CatalogTypeId, itemId = resultDto.Id },
value: resultDto));
}
public async Task AddITemToCatalogAsync(CatalogItemDto catalogItem)
{
var itemToAdd = _mapper.Map <CatalogItem>(catalogItem);
var result = _catalogContext.CatalogItems.Add(itemToAdd);
await _catalogContext.SaveChangesAsync(new CancellationToken());
return;
}
protected override Task OnInitializedAsync()
{
CatalogItemDto catalogItem = CatalogItemState.CatalogItems[EntityId];
UpdateCatalogItemRequest = new UpdateCatalogItemRequest();
MapToRequest(catalogItem);
return(base.OnInitializedAsync());
}
public async Task <IActionResult> CreateItem([FromBody] CatalogItemDto catalogItemDto)
{
var catalogItem = mapper.Map <CatalogItem>(catalogItemDto);
var result = await dbContext.CatalogItems.AddAsync(catalogItem);
await dbContext.SaveChangesAsync();
return(Ok(result.Entity.Id));
}
private void MapToRequest(CatalogItemDto catalogItem)
{
// TODO: consider Automapper here
UpdateCatalogItemRequest.CatalogItemId = catalogItem.Id;
UpdateCatalogItemRequest.CatalogBrandId = catalogItem.CatalogBrandId;
UpdateCatalogItemRequest.CatalogTypeId = catalogItem.CatalogTypeId;
UpdateCatalogItemRequest.Description = catalogItem.Description;
UpdateCatalogItemRequest.Name = catalogItem.Name;
UpdateCatalogItemRequest.PictureUri = catalogItem.PictureUri;
UpdateCatalogItemRequest.Price = catalogItem.Price;
}
public async Task <ActionResult> AddCatalogItemAsync([FromBody] CatalogItemDto catalogItem)
{
try
{
await _catalogService.AddITemToCatalogAsync(catalogItem);
return(Created("Item added to catalog.", catalogItem));
}
catch (Exception ex)
{
return(BadRequest($"{ex.Message} \n {ex.InnerException.Message}"));
}
}
public ActionResult <CatalogItemDto> GetById(Guid catalogItemId)
{
var item = _catalogRepository.GetById(catalogItemId);
if (item == null)
{
return(NotFound(value: "Catalog item not found."));
}
var itemDto = new CatalogItemDto(item);
return(Ok(itemDto));
}
public async Task <IActionResult> UpdateItem(int id, [FromBody] CatalogItemDto catalogItemDto)
{
var item = await dbContext.CatalogItems.FindAsync(id);
if (item == null)
{
return(BadRequest($"Элемента с id:{id} не существует"));
}
var updatedItem = mapper.Map(catalogItemDto, item);
dbContext.CatalogItems.Update(updatedItem);
await dbContext.SaveChangesAsync();
return(Ok());
}
public async Task <IResult> HandleAsync(CreateCatalogItemRequest request)
{
var response = new CreateCatalogItemResponse(request.CorrelationId());
var catalogItemNameSpecification = new CatalogItemNameSpecification(request.Name);
var existingCataloogItem = await _itemRepository.CountAsync(catalogItemNameSpecification);
if (existingCataloogItem > 0)
{
throw new DuplicateException($"A catalogItem with name {request.Name} already exists");
}
var newItem = new CatalogItem(request.CatalogTypeId, request.CatalogBrandId, request.Description, request.Name, request.Price, request.PictureUri);
newItem = await _itemRepository.AddAsync(newItem);
if (newItem.Id != 0)
{
//We disabled the upload functionality and added a default/placeholder image to this sample due to a potential security risk
// pointed out by the community. More info in this issue: https://github.com/dotnet-architecture/eShopOnWeb/issues/537
// In production, we recommend uploading to a blob storage and deliver the image via CDN after a verification process.
newItem.UpdatePictureUri("eCatalog-item-default.png");
await _itemRepository.UpdateAsync(newItem);
}
var dto = new CatalogItemDto
{
Id = newItem.Id,
CatalogBrandId = newItem.CatalogBrandId,
CatalogTypeId = newItem.CatalogTypeId,
Description = newItem.Description,
Name = newItem.Name,
PictureUri = _uriComposer.ComposePicUri(newItem.PictureUri),
Price = newItem.Price
};
response.CatalogItem = dto;
return(Results.Created($"api/catalog-items/{dto.Id}", response));
}
public async Task <ActionResult> Get(string id)
{
try
{
Guid _id = Guid.Empty;
if (!Guid.TryParse(id, out _id))
{
return(BadRequest());
}
CatalogItem catalogItem = await _catalogItemUnit.CatalogItemABCRepository.GetByID(_id);
if (catalogItem == null)
{
return(Ok());
}
CatalogItemDto catalogItemDto = _mapper.Map <CatalogItemDto>(catalogItem);
return(Ok(catalogItemDto));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public CatalogItemDtoBuilder()
{
_catalogItemDto = WithDefaults();
}
public void Insert(CatalogItemDto catalogItem)
{
_dbContext.Items.Add(catalogItem);
_dbContext.SaveChanges();
}
public void Insert(CatalogItemDto catalogItem)
{
_logger.LogTrace("Inserting new catalog item");
_dbContext.Items.Add(catalogItem);
_dbContext.SaveChanges();
}
