Esempio n. 1
0
        public async Task <IActionResult> UpdateAsync(Guid productId, Guid productOptionId, [FromBody] ProductOption productOption)
        {
            _logger.Information($"Executing PUT - '/products/{productId}/options/{productOptionId}'");

            if (!ModelState.IsValid)
            {
                return(WebApi.Response.Error(new Error(ErrorCode.BadRequest, AppConstants.InvalidRequest)));
            }

            try
            {
                productOption.ProductId = productId;
                productOption.Id        = productOptionId;
                var result = await _productOptionService.UpdateAsync(productOption);

                return(result.IsSuccess()
                        ? WebApi.Response.NoContent()
                        : WebApi.Response.Error(result.Error));
            }
            catch (Exception ex)
            {
                _logger.Error("An error has occurred while updating a product option. ProductId: {productId}, ProductOptionId: {productOptionId}, Details: {message}", productId, productOptionId, ex.Message);
            }

            return(WebApi.Response.Fatal());
        }
Esempio n. 2
0
        public async Task <ActionResult> Update(Guid productId, Guid productOptionId, ProductOptionDto productOptionDto)
        {
            try
            {
                await _productOptionService.UpdateAsync(productId, productOptionId, productOptionDto);

                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public async Task <IActionResult> UpdateProductOption(Guid id, ProductOptionUpdateRequestDto productOptionUpdateRequest)
        {
            try
            {
                _logger.LogDebug($"Received {nameof(UpdateProductOption)} request with {{@ProductOptionUpdateRequest}}", productOptionUpdateRequest);
                if (id != productOptionUpdateRequest.Id)
                {
                    return(BadRequest("Parameter mismatch between the route and the payload"));
                }
                await _service.UpdateAsync(_mapper.Map <ProductOption>(productOptionUpdateRequest));

                _logger.LogDebug($"Returned {nameof(UpdateProductOption)} response for Id {productOptionUpdateRequest.Id}");
                return(CreatedAtAction(nameof(UpdateProductOption), productOptionUpdateRequest.Id,
                                       productOptionUpdateRequest.Id));
            }
            catch (ProductOptionNotFoundException exception)
            {
                _logger.LogWarning(exception, exception.Message);
                return(NotFound(exception.Message));
            }
        }
Esempio n. 4
0
        public async Task <IActionResult> UpdateOption(Guid id, ProductOption option)
        {
            try
            {
                await _productOptionService.GetProductOptionAsync(id);

                await _productOptionService.UpdateAsync(id, option);

                return(NoContent());
            }
            catch (RecordNotFoundException e)
            {
                Log.Error(e, ExceptionTemplates.RecordNotFoundError);
                return(NotFound(e.Message));
            }
            catch (Exception e)
            {
                Log.Error(e, ExceptionTemplates.UnknownError);
                return(StatusCode(500));
            }
        }