Ejemplo n.º 1
0
        private async Task PrepareProductExportBillInfo(
            ProductExportBill productExportBill,
            int requestedUserId,
            Order order
            )
        {
            var storageManager = await _context.StorageManagers
                                 .SingleOrDefaultAsync(x => x.UserId == requestedUserId);

            if (storageManager == null)
            {
                throw new Exception("Bạn không có quyền để xuất hoá đơn này");
            }

            var validateOrderResult = ValidateValidOrderOfProductExportBill(
                order);

            if (validateOrderResult.IsSuccess == false)
            {
                throw new Exception(validateOrderResult.Errors[0]);
            }

            productExportBill.IsDeleted        = false;
            productExportBill.CreatedAt        = DateTime.UtcNow;
            productExportBill.UpdatedAt        = DateTime.UtcNow;
            productExportBill.StorageManagerId = storageManager.Id;
        }
        public async Task <IActionResult> Create(
            [FromBody] CreateProductExportBillRequest createModel
            )
        {
            var requestedUserId = int.Parse(HttpContext.GetUserIdFromRequest());
            ProductExportBill productExportBill = new ProductExportBill
            {
                OrderId = createModel.OrderId
            };
            var productExportDetails = _mapper
                                       .Map <IEnumerable <CreateProductExportDetailRequest>, IEnumerable <ProductExportDetail> >(
                createModel.ProductExportDetails);
            var result = await _productExportBillService.CreateAsync(
                productExportBill,
                productExportDetails,
                requestedUserId
                );

            if (result.IsSuccess == false)
            {
                return(BadRequest(result.Errors));
            }

            var locationUri = _uriService.GetByIdUri(
                ApiRoutes.ProductExportBill.GetById.Replace(
                    "{productExportBillId}",
                    result.EntityReturn.Id.ToString())
                );
            var productExportBillResponse = _mapper.Map <ProductExportBillResponse>(
                result.EntityReturn);

            return(Created(locationUri,
                           new Response <ProductExportBillResponse>(productExportBillResponse)));
        }
Ejemplo n.º 3
0
        private async Task <CreateResult <IEnumerable <ProductExportDetail> > > SaveProductExportDetailsWhenCreateProductExportBill(
            IEnumerable <ProductExportDetail> productExportDetails,
            ProductExportBill productExportBill,
            IEnumerable <OrderItem> orderItems,
            IEnumerable <ProductTier> productTiers
            )
        {
            var validateProductExportDetailsResult = ValidateProductExportDetails(
                productExportDetails,
                orderItems,
                productTiers
                );

            if (validateProductExportDetailsResult.IsSuccess == false)
            {
                return(new CreateResult <IEnumerable <ProductExportDetail> >
                {
                    IsSuccess = false,
                    Errors = validateProductExportDetailsResult.Errors
                });
            }

            PrepareInfoForAllProductExportDetails(
                productExportDetails,
                productExportBill.Id,
                orderItems
                );

            /** Save to db */
            await _context.ProductExportDetails.AddRangeAsync(productExportDetails);

            var created = await _context.SaveChangesAsync();

            if (!(created > 0))
            {
                return(new CreateResult <IEnumerable <ProductExportDetail> >
                {
                    IsSuccess = false,
                    Errors = new List <string>()
                    {
                        "Tạo hoá đơn xuất kho bị lỗi, xin thử lại"
                    }
                });
            }

            return(new CreateResult <IEnumerable <ProductExportDetail> >
            {
                IsSuccess = true
            });
        }
Ejemplo n.º 4
0
        /** CREATE ASYNC */
        public async Task <CreateResult <ProductExportBill> > CreateAsync(
            ProductExportBill productExportBill,
            IEnumerable <ProductExportDetail> productExportDetails,
            int requestedUserId)
        {
            try
            {
                var order = await _context.Orders
                            .Where(x => x.Id == productExportBill.OrderId &&
                                   x.IsDeleted == false)
                            .Include(x => x.OrderItems)
                            .FirstOrDefaultAsync();

                var productTiers = await GetProductTierListFromProductExportDetails(
                    productExportDetails
                    );

                await PrepareProductExportBillInfo(
                    productExportBill,
                    requestedUserId,
                    order);

                using (var transaction = _context.Database.BeginTransaction())
                {
                    try
                    {
                        /** Save product export bill */
                        await _context.ProductExportBills.AddAsync(productExportBill);

                        var productExportBillCreated = await _context.SaveChangesAsync();

                        if (!(productExportBillCreated > 0))
                        {
                            transaction.Dispose();
                            throw new Exception("Tạo hoá đơn xuất hàng bị lỗi, xin thử lại");
                        }

                        /** Change status of order to Delivering */
                        order.OrderStatus = OrderStatus.Delivering;

                        _context.Orders.Update(order);
                        var orderUpdated = await _context.SaveChangesAsync();

                        if (!(orderUpdated > 0))
                        {
                            transaction.Dispose();
                            throw new Exception("Tạo hoá đơn xuất hàng bị lỗi, xin thử lại");
                        }

                        /** Save product export details */
                        var createProductExportDetailsResult = await SaveProductExportDetailsWhenCreateProductExportBill(
                            productExportDetails,
                            productExportBill,
                            order.OrderItems,
                            productTiers
                            );

                        if (createProductExportDetailsResult.IsSuccess == false)
                        {
                            transaction.Dispose();
                            return(new CreateResult <ProductExportBill>
                            {
                                IsSuccess = false,
                                Errors = createProductExportDetailsResult.Errors
                            });
                        }

                        /** Update product quantity */
                        bool isUpdateProductTiersQuantitySucceeded = await UpdateProductTiersQuantityAfterCreateExportBill(
                            productTiers,
                            productExportDetails
                            );

                        if (!isUpdateProductTiersQuantitySucceeded)
                        {
                            transaction.Dispose();
                            throw new Exception("Tạo hoá đơn xuất hàng bị lỗi, xin thử lại");
                        }

                        await transaction.CommitAsync();
                    }
                    catch (Exception e)
                    {
                        return(new CreateResult <ProductExportBill>
                        {
                            IsSuccess = false,
                            Errors = new List <string>()
                            {
                                e.Message.ToString()
                            }
                        });
                    }
                }
            }
            catch (Exception e)
            {
                return(new CreateResult <ProductExportBill>
                {
                    IsSuccess = false,
                    Errors = new List <string>()
                    {
                        e.Message.ToString()
                    }
                });
            }


            productExportBill.ProductExportDetails = productExportDetails.ToList();
            return(new CreateResult <ProductExportBill>
            {
                IsSuccess = true,
                EntityReturn = productExportBill
            });
        }