コード例 #1
0
        public bool TryValidateReturn(PurchaseOrder order, ReturnInfo returnInfo, out string[] messages)
        {
            bool isValid = true;
            var  errors  = new List <string>();

            if (order.ReturnOrderForms.ToArray().Any(f => f.Status == ReturnFormStatus.AwaitingStockReturn.ToString() || f.Status == ReturnFormStatus.AwaitingCompletion.ToString()))
            {
                errors.Add(string.Format("Order {0} has pending returns", order.TrackingNumber));
            }

            var returnableLineItems =
                ReturnExchangeManager.GetAvailableForReturnLineItems(order.OrderForms[0].Shipments[0]).ToList();

            foreach (ReturnItem returnItem in returnInfo.ReturnItems)
            {
                if (returnableLineItems.All(x => x.CatalogEntryId != returnItem.Sku))
                {
                    errors.Add(string.Format("Lineitem with code: {0} is not returnable", returnItem.Sku));
                }
            }

            messages = errors.ToArray();

            if (errors.Any())
            {
                isValid = false;
            }

            return(isValid);
        }
コード例 #2
0
        public HttpResponseMessage CreateReturn(ReturnInfo returnInfo)
        {
            var returFormCalculator  = ServiceLocator.Current.GetInstance <IReturnFormTotalCalculator>();
            var paymentCreator       = ServiceLocator.Current.GetInstance <ICreditPaymentCreator>();
            var paymentRetriever     = ServiceLocator.Current.GetInstance <IOrderFormPaymentRetriever>();
            var returnOrderValidator = ServiceLocator.Current.GetInstance <IReturnOrderValidator>();

            var order = Get(returnInfo.OrderNumber);

            string[] messages;
            if (!returnOrderValidator.TryValidateReturn(order, returnInfo, out messages))
            {
                return(CreateResponseMessage(HttpStatusCode.NotAcceptable, string.Join(", ", messages)));
            }

            var returnForm = ReturnExchangeManager.AddNewReturnFormToPurchaseOrder(order);

            foreach (var item in returnInfo.ReturnItems)
            {
                var returnableLineItems = ReturnExchangeManager.GetAvailableForReturnLineItems(order.OrderForms[0].Shipments[0]).Where(l => l.CatalogEntryId == item.Sku).ToList();
                ReturnExchangeManager.AddNewReturnLineItemToReturnForm(returnForm, returnableLineItems.FirstOrDefault(), item.Quantity, item.ReturnReason);
                ReturnExchangeManager.AddNewShipmetToReturnForm(returnForm, order.OrderForms[0].Shipments[0]);
            }

            ReturnFormStatusManager.AcknowledgeReceiptItems(returnForm);

            returFormCalculator.AdjustReturnTotal(returnForm);
            paymentCreator.CreateCreditPayment <OtherPayment>(returnForm, order,
                                                              paymentRetriever.GetCapturedPayment(order).PaymentMethodId);
            order.AcceptChanges();
            var respons = CreateResponseMessage(HttpStatusCode.OK, "Return Created");

            return(respons);
        }
 protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
 {
     if (base.ReturnFormStatus == ReturnFormStatus.Complete)
     {
         //Need change ExchangeOrder from AvaitingCompletition to InProgress
         var exchangeOrder = ReturnExchangeManager.GetExchangeOrderForReturnForm(base.ReturnOrderForm);
         if (exchangeOrder != null && OrderStatusManager.GetOrderGroupStatus(exchangeOrder) == OrderStatus.AwaitingExchange)
         {
             OrderStatusManager.ProcessOrder(exchangeOrder);
             exchangeOrder.AcceptChanges();
         }
     }
     // Retun the closed status indicating that this activity is complete.
     return(ActivityExecutionStatus.Closed);
 }
コード例 #4
0
        public void CreateExchangePayments()
        {
            var origPurchaseOrder = ReturnOrderForm.Parent as PurchaseOrder;
            var origOrderForm     = origPurchaseOrder.OrderForms[0];
            var exchangeOrder     = ReturnExchangeManager.GetExchangeOrderForReturnForm(ReturnOrderForm);

            if (exchangeOrder != null)
            {
                var exchangeOrderForm = exchangeOrder.OrderForms[0];
                //Exchange payments
                //Credit exchange payment to original order
                decimal         paymentTotal          = Math.Min(ReturnOrderForm.Total, exchangeOrder.Total);
                ExchangePayment creditExchangePayment = CreateExchangePayment(TransactionType.Credit, paymentTotal);
                origOrderForm.Payments.Add(creditExchangePayment);

                //Debit exchange payment to exchange order
                ExchangePayment debitExchangePayment = CreateExchangePayment(TransactionType.Capture, paymentTotal);
                exchangeOrderForm.Payments.Add(debitExchangePayment);

                OrderStatusManager.RecalculatePurchaseOrder(exchangeOrder);
                exchangeOrder.AcceptChanges();
            }
        }
コード例 #5
0
 protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
 {
     try
     {
         if (base.ReturnFormStatus == ReturnFormStatus.Complete)
         {
             //Need change ExchangeOrder from AvaitingCompletition to InProgress
             var exchangeOrder = ReturnExchangeManager.GetExchangeOrderForReturnForm(base.ReturnOrderForm);
             if (exchangeOrder != null && OrderStatusManager.GetOrderGroupStatus(exchangeOrder) == OrderStatus.AwaitingExchange)
             {
                 OrderStatusManager.ProcessOrder(exchangeOrder);
                 exchangeOrder.AcceptChanges();
             }
         }
         // Retun the closed status indicating that this activity is complete.
         return(ActivityExecutionStatus.Closed);
     }
     catch (Exception ex)
     {
         Logger.Error(GetType().Name + ": " + ex.Message, ex);
         // An unhandled exception occured.  Throw it back to the WorkflowRuntime.
         throw;
     }
 }