Beispiel #1
0
        public static async Task <Response <Payroll> > MakePayment(Guid orderId, Guid clientId)
        {
            using (var unitOfWork = new DataLayerUnitOfWork())
            {
                var orderRepository   = unitOfWork.TrackingRepository <OrderRepository>();
                var payrollRepository = unitOfWork.TrackingRepository <PayrollRepository>();

                var order = await orderRepository.GetAsync(orderId, new[]
                {
                    nameof(Order.OrderItems)
                }).ConfigureAwait(false);

                if (order == null)
                {
                    return(ResponseFactory <Payroll> .CreateResponse(false, ResponseCode.ErrorInvalidInput));
                }

                var payroll = new DataLayer.Payroll
                {
                    ClientId = clientId,
                    OrderId  = orderId,
                    Date     = DateTime.Now,
                    Value    = order.OrderItems.Sum(orderItem => orderItem.Price * orderItem.Quantity)
                };
                payroll = await payrollRepository.CreateAsync(payroll, true).ConfigureAwait(false);

                if (payroll == null)
                {
                    return(ResponseFactory <Payroll> .CreateResponse(false, ResponseCode.Error));
                }

                order.Status = OrderStatus.Finalized.ToInt();
                var updatedOrder = await orderRepository.UpdateAsync(order, true).ConfigureAwait(false);

                if (updatedOrder == null)
                {
                    return(ResponseFactory <Payroll> .CreateResponse(false, ResponseCode.Error));
                }

                return(ResponseFactory <Payroll> .CreateResponse(true, ResponseCode.Success, payroll.CopyTo <Payroll>()));
            }
        }
Beispiel #2
0
        public static async Task <Response <OrderItem> > UpdateAsync(OrderItem orderItem)
        {
            using (var unitOfWork = new DataLayerUnitOfWork())
            {
                var order = await unitOfWork.TrackingRepository <OrderRepository>().GetAsync(orderItem.OrderId).ConfigureAwait(false);

                if (!SalesValidator.ValidateOrderItem(orderItem, (SaleType)order.SaleType))
                {
                    return(ResponseFactory <OrderItem> .CreateResponse(false, ResponseCode.ErrorInvalidInput));
                }

                var dbModel = orderItem.CopyTo <DataLayer.OrderItem>();
                var result  = await unitOfWork.TrackingRepository <OrderItemRepository>().UpdateAsync(dbModel).ConfigureAwait(false);

                if (result == null)
                {
                    return(ResponseFactory <OrderItem> .CreateResponse(false, ResponseCode.Error));
                }

                return(ResponseFactory <OrderItem> .CreateResponse(true, ResponseCode.Success, result.CopyTo <OrderItem>()));
            }
        }
Beispiel #3
0
        private static async Task <Response <Order> > CreatePayroll(Order order, DataLayerUnitOfWork unitOfWork, OrderRepository orderRepository)
        {
            var orderWithItems = await orderRepository.GetAsync(order.Id, new[]
            {
                nameof(Order.OrderItems)
            }).ConfigureAwait(false);

            var payroll = new Payroll
            {
                ClientId = order.ClientId,
                Date     = DateTime.Now,
                OrderId  = order.Id,
                Value    = orderWithItems.OrderItems.Sum(orderItem => orderItem.Price * orderItem.Quantity)
            };

            payroll = await unitOfWork.TrackingRepository <PayrollRepository>().CreateAsync(payroll).ConfigureAwait(false);

            if (payroll == null)
            {
                return(ResponseFactory <Order> .CreateResponse(false, ResponseCode.Error));
            }

            return(ResponseFactory <Order> .CreateResponse(true, ResponseCode.Success, order));
        }
Beispiel #4
0
        public static async Task <Response <Order> > Finalize(Order order)
        {
            if (!SalesValidator.ValidateOrder(order, false))
            {
                return(ResponseFactory <Order> .CreateResponse(false, ResponseCode.ErrorInvalidInput));
            }

            order.Status = OrderStatus.Finalized.ToInt();

            using (var unitOfWork = new DataLayerUnitOfWork())
            {
                var orderRepository = unitOfWork.TrackingRepository <OrderRepository>();

                var dbModel      = order.CopyTo <DataLayer.Order>();
                var updatedOrder = await orderRepository.UpdateAsync(dbModel, true).ConfigureAwait(false);

                if (updatedOrder == null)
                {
                    return(ResponseFactory <Order> .CreateResponse(false, ResponseCode.Error));
                }

                return(await CreatePayroll(order, unitOfWork, orderRepository));
            }
        }