public async Task <ActionResult <Product> > PostProduct([FromBody] PostProductDTO product)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }
            var mappedProduct = mapper.Map <PostProductDTO, Product>(product);
            await productService.CreateProduct(mappedProduct);

            return(Ok());
        }
Beispiel #2
0
        public async Task <List <ProductGetDTO> > GetProductByPageNumber(PostProductDTO payload)
        {
            int[] filteredProductIds = arrayFilterSelector(getProductIdByCategories(payload.categoryIds), getProductIdByPropertyDetails(payload.propertyDetailIds));

            var query = _context.Products.Include("ProductImages")
                        .OrderByDescending(d => d.LastModified).Skip(payload.pageNo * payload.pageSize);

            if (filteredProductIds != null)
            {
                query = query.Where(p => filteredProductIds.Contains(p.ProductId));
            }

            query = query.Take(payload.pageSize);

            List <ProductGetDTO> result = await query.Select(pr => pr.Adapt <ProductGetDTO>()).ToListAsync();

            return(await Task.FromResult <List <ProductGetDTO> >(result));
        }
        public async Task <IActionResult> PutProduct(int id, [FromBody] PostProductDTO product)
        {
            if (id == 0)
            {
                return(BadRequest());
            }

            var productToBeUpdated = await productService.GetDeletedByIdAsync(id);

            if (productToBeUpdated == null)
            {
                return(NotFound());
            }
            var mappedProduct = mapper.Map <PostProductDTO, Product>(product);
            await productService.UpdateProduct(productToBeUpdated, mappedProduct);

            var newProduct = await productService.GetDeletedByIdAsync(id);

            return(Ok(newProduct));
        }
        public async Task <ApiResponse> Post([FromBody] PostProductDTO arg)
        {
            try
            {
                var data = await productServiceService.CreateAsync(arg);

                return(new ApiResponse(InfoMessages.ProductAdded, data, HttpStatusCode.OK.ToInt()));
            }
            catch (ValidationException ex)
            {
                throw new ApiException(ex.Errors, ex.StatusCode);
            }
            catch (CustomException ex)
            {
                throw new ApiException(ex, ex.StatusCode);
            }
            catch (Exception ex)
            {
                throw new ApiException(ex);
            }
        }
        public async Task <Response <ProductGetDTO> > GetProductByPageNumber(PostProductDTO payload)
        {
            _logger.LogDebug("GetProductByPageNumber init with", payload);
            Response <ProductGetDTO> httpResponse = new Response <ProductGetDTO>();

            try
            {
                httpResponse.RequestState = true;
                httpResponse.DataList     = await _productManager.GetProductByPageNumber(payload);

                httpResponse.EntityCount = httpResponse.DataList.Count();
            }
            catch (Exception ex)
            {
                _logger.LogError("GetProductByPageNumber Error", ex);
                httpResponse.ErrorState = true;
                httpResponse.ErrorList.Add(ex.Adapt <ApiException>());
            }
            _logger.LogDebug("GetProductByPageNumber end with", httpResponse);
            return(await Task.FromResult(httpResponse));
        }