public void Is_Whole_Order_Returned_Should_Return_True_If_There_Is_A_Order_Response_Line_For_Each_Ordered_Line_With_Same_Qty()
        {
            var line1 = ConstructOrderLine(123, vendorItemNumberLine1, 2);
            var line2 = ConstructOrderLine(124, vendorItemNumberLine2, 2);

            #region test case setup
            var order = new Order()
            {
                OrderLines = new List <OrderLine>()
                {
                    line1, line2
                },
                OrderResponses = new List <OrderResponse>()
                {
                    new OrderResponse()
                    {
                        OrderResponseLines = new List <OrderResponseLine>()
                        {
                            new OrderResponseLine()
                            {
                                Remark    = "Returned",
                                OrderLine = line1,
                                Delivered = 2
                            },
                            new OrderResponseLine()
                            {
                                Remark    = "Returned",
                                OrderLine = line2,
                                Delivered = 2
                            }
                        }
                    }
                }
            };
            #endregion

            Assert.IsTrue(TNTOrderHelper.IsTotalOrderReturned(order));
        }
        protected override bool Process(String file, Vendor vendor)
        {
            var document = Documents[file];

            var elementGroups =
                from element in document.XPathSelectElements("return_notifications/return_notification")
                let websiteOrderNumber = (String)element.XPathEvaluate("string(website_order_number/text())")
                                         group element by websiteOrderNumber;

            foreach (var elementGroup in elementGroups)
            {
                var websiteOrderNumber = elementGroup.Key;

                if (String.IsNullOrWhiteSpace(websiteOrderNumber))
                {
                    var message = "Website_order_number is missing.";

                    Log.AuditError(message);

                    throw new Exception(message);
                }

                int connectorID = vendor.VendorSettings.FirstOrDefault(c => c.SettingKey == "RelatedConnectorID").Try(c => int.Parse(c.Value));

                var order = Unit.Scope.Repository <Order>().GetSingle(o => o.WebSiteOrderNumber == websiteOrderNumber && o.ConnectorID == connectorID);

                if (order == null) //no order for this connector. Leave message for next
                {
                    return(false);
                }

                var orderResponse = new OrderResponse
                {
                    Order = order,
                    OrderResponseLines      = new List <OrderResponseLine>(),
                    ReceiveDate             = DateTime.Now.ToUniversalTime(),
                    ResponseType            = OrderResponseTypes.Return.ToString(),
                    Vendor                  = Vendor,
                    VendorDocument          = document.ToString(),
                    VendorDocumentDate      = DateTime.Now.ToUniversalTime(),
                    VendorDocumentReference = websiteOrderNumber,
                    VendorDocumentNumber    = websiteOrderNumber,
                };

                var isCompleteOrderReturnedInOne = IsTotalOrderReturnedAtOnce(elementGroup, order, vendor.Name);
                int currentComplaintCount        = 0;
                foreach (var element in elementGroup)
                {
                    var sku     = GetSku(element, true).Replace(" ", "");
                    var product = Unit.Scope.Repository <Product>().GetSingle(p => p.VendorItemNumber.Replace(" ", "") == sku);

                    if (product == null)
                    {
                        var message = String.Format("No product found with vendor item number '{0}'.", sku);

                        Log.AuditError(message);

                        throw new Exception(message);
                    }

                    var returned = Convert.ToInt32(element.XPathEvaluate("number(returned/text())"));

                    var         vendorID         = vendor.VendorID;
                    int         vendorOverrideID = vendor.VendorSettings.GetValueByKey <int>("VendorStockOverrideID", 0);
                    VendorStock vendorStock      = null;

                    //Not good, rework
                    if (vendorOverrideID != 0)
                    {
                        vendorStock = product.VendorStocks.Single(vs => vs.VendorID == vendorOverrideID && vs.VendorStockType.StockType == "Webshop");
                    }
                    else
                    {
                        vendorStock = product.VendorStocks.Single(vs => vs.Vendor == Vendor && vs.VendorStockType.StockType == "Webshop");
                    }

                    vendorStock.QuantityOnHand += returned;

                    var complaint = Convert.ToBoolean(element.XPathEvaluate("string(complaint/text())"));
                    if (complaint)
                    {
                        currentComplaintCount++;
                    }

                    var orderLine = order.OrderLines.FirstOrDefault(row => row.Product == product);

                    if (orderLine == null)
                    {
                        var message = String.Format("No order line found with product '{0}'.", sku);

                        Log.AuditError(message);

                        throw new Exception(message);
                    }

                    orderResponse.OrderResponseLines.Add(new OrderResponseLine
                    {
                        OrderLine   = orderLine,
                        Ordered     = orderLine.GetDispatchQuantity(),
                        Delivered   = returned,
                        Remark      = "Returned",
                        Description = complaint ? "complaint" : null
                    });
                }
                order.OrderResponses.Add(orderResponse);

                //check if total order is returned
                var isWholeOrderReturned = TNTOrderHelper.IsTotalOrderReturned(order);
                var complaintCount       = GetOrderComplaintCount(order);

                if (currentComplaintCount == 0)
                {
                    //add a new line for the return costs
                    orderResponse.OrderResponseLines.Add(AddReturnCosts(order));
                }

                if (isWholeOrderReturned)
                {
                    bool useKialaShipmentCosts = !string.IsNullOrEmpty(order.ShippedToCustomer.ServicePointID);

                    var line = order.OrderLines.FirstOrDefault(c => c.Product.VendorItemNumber == GetShipmentCostsProduct(order.ConnectorID, Unit, useKialaShipmentCosts));
                    if (line != null)
                    {
                        //add shipment costs to returned collection
                        orderResponse.OrderResponseLines.Add(new OrderResponseLine()
                        {
                            OrderLine = line,
                            Delivered = 1,
                            Remark    = "Returned",
                            Ordered   = 1
                        });
                    }
                }


                Unit.Save();
            }
            return(true);
        }