public ODataShipment GetAPIShipment(SOShipment shipment, SOPackageDetail package, PXResultset <SOLine> lines)
        {
            var wrapper     = new ODataShipment();
            var apiShipment = new KCAPIShipment()
            {
                ShippedDateUtc  = shipment.ShipDate,
                TrackingNumber  = package?.TrackNumber,
                ShippingCarrier = shipment.ShipVia,
                ShippingClass   = shipment.ShipVia,
                DeliveryStatus  = "Complete"
            };
            var apiItems = new List <KCAPIShipmentItem>();

            foreach (PXResult <SOLine> line in lines)
            {
                SOLine     soLine   = line.GetItem <SOLine>();
                SOShipLine shipLine = line.GetItem <SOShipLine>();
                DAC.KNSIKCInventoryItem kcInventoryItem    = line.GetItem <DAC.KNSIKCInventoryItem>();
                InventoryItem           inventoryItem      = line.GetItem <InventoryItem>();
                InventoryItemPCExt      inventoryItemPcExt = inventoryItem.GetExtension <InventoryItemPCExt>();
                SOLinePCExt             soLinePcExt        = soLine.GetExtension <SOLinePCExt>();

                int quantity = Convert.ToInt32(shipLine.ShippedQty.GetValueOrDefault());

                if ((soLine.LineNbr != soLinePcExt?.UsrKNMasterLineNbr && ParentIsGrouped(lines, soLinePcExt)) ||
                    (inventoryItemPcExt?.UsrKNCompositeType == KCConstants.ConfigurableProduct && soLine.LineNbr == soLinePcExt?.UsrKNMasterLineNbr))
                {
                    continue;
                }

                if (inventoryItemPcExt?.UsrKNCompositeType == KCConstants.GroupedProduct && quantity == 0)
                {
                    SOShipLine childItem = lines.Where(x => x.GetItem <SOLine>().GetExtension <SOLinePCExt>().UsrKNMasterLineNbr == soLine.LineNbr &&
                                                       x.GetItem <SOLine>().LineNbr != soLine.LineNbr).RowCast <SOShipLine>().FirstOrDefault();

                    if (childItem != null)
                    {
                        KCDataExchangeMaint     graph          = PXGraph.CreateInstance <KCDataExchangeMaint>();
                        List <KNSIGroupedItems> origChildItems = graph.GroupedChildItems.Select(inventoryItem.InventoryID).RowCast <KNSIGroupedItems>().ToList();
                        quantity = Convert.ToInt32(childItem.ShippedQty / origChildItems.Where(x => x.MappedInventoryID == childItem.InventoryID).FirstOrDefault().Quantity);
                    }
                    else
                    {
                        throw new KCCorruptedShipmentException();
                    }
                }

                apiItems.Add(new KCAPIShipmentItem
                {
                    ProductID   = kcInventoryItem?.UsrKCCAID.ToString(),
                    OrderItemID = soLine?.GetExtension <KCSOLineExt>()?.UsrKCOrderItemID.ToString(),
                    Quantity    = shipLine == null ? 0 : Convert.ToInt32(quantity)
                });
            }

            apiShipment.Items = apiItems;
            wrapper.Value     = apiShipment;

            return(wrapper);
        }
Пример #2
0
        public KCAPIInventoryItem GetAPIInventoryItem(InventoryItem product)
        {
            DAC.KNSIKCInventoryItem kcProduct = BulkGraph.KCInventoryItem.SelectSingle(product.InventoryID);

            InventoryItemPCExt productPcExt       = product.GetExtension <InventoryItemPCExt>();
            string             classificationName = KCGeneralDataHelper.GetClassificationByInventoryId(ClassificationsGraph, product);

            KCAPIInventoryItem apiProduct = new KCAPIInventoryItem()
            {
                Classification = classificationName
            };

            if (IsConfigurableParentOrChild(product, productPcExt))
            {
                PropagateConfigurable(product, apiProduct, productPcExt.UsrKNCompositeType == null);
            }
            if (productPcExt.UsrKNCompositeType == KCConstants.GroupedProduct)
            {
                PropagateBundle(product, apiProduct);
            }
            if (product.KitItem.GetValueOrDefault())
            {
                PropagateKit(product, apiProduct);
            }

            KCDynamicProductMapper mapper = new KCDynamicProductMapper(KCMappingEntitiesConstants.Product);

            mapper.Mapping.MappingValues = ConversionGraph.GetEntity(product.InventoryCD);
            apiProduct = mapper.MapApiInventoryItem(apiProduct, product, kcProduct);
            apiProduct = KCGeneralDataHelper.FillReservedAttributes(product, apiProduct);

            return(apiProduct);
        }
Пример #3
0
        public bool CheckBranches(KCSiteMasterMaint sitemaster, List <KCAPIOrderItem> orderItems, KCAPIOrder order)
        {
            BAccount customer = KCGeneralDataHelper.GetCustomerByCAOrder(sitemaster, order);

            if (customer == null)
            {
                logger.SetNonChildEntityId(order.ID.ToString());
                logger.Information(KCMessages.CustomerNotFound(order.ID, order.BuyerEmailAddress));
                return(false);
            }

            bool workflowPublished = new KCNamespaceReview().Test(KCConstants.NamespaceTesterPackage);

            if (workflowPublished)
            {
                bool validItem;
                foreach (KCAPIOrderItem item in orderItems)
                {
                    DAC.KNSIKCInventoryItem stockItem    = sitemaster.ExistingProducts.SelectSingle(item.ProductID);
                    InventoryItem           product      = sitemaster.ProductByInvId.SelectSingle(stockItem.InventoryID);
                    KCInventoryItemExt      productKCExt = product.GetExtension <KCInventoryItemExt>();
                    validItem = false;

                    if (product.GetExtension <InventoryItemPCExt>().UsrKNCompositeType == null)
                    {
                        if (productKCExt.UsrKNCPBranch != null && customer.GetExtension <KCCustomerExt>()?.UsrKNCPBranchID != null)
                        {
                            List <string> productBranches = productKCExt.UsrKNCPBranch.Split(',').ToList();

                            foreach (string branch in productBranches)
                            {
                                if (customer.GetExtension <KCCustomerExt>()?.UsrKNCPBranchID?.Split(',').Select(x => x.Trim()).ToList().Contains(branch) == true)
                                {
                                    validItem = true;
                                }
                            }
                        }
                        else
                        {
                            validItem = true;
                        }
                    }
                    else
                    {
                        validItem = true;
                    }

                    if (!validItem)
                    {
                        logger.SetNonChildEntityId(order.ID.ToString());
                        logger.Information(KCMessages.WebsitesAreNotAssociated(order.ID, product.InventoryCD, customer.AcctName));
                        return(false);
                    }
                }
            }
            return(true);
        }
Пример #4
0
        public bool CheckFulfillmentItems(KCSOShipmentEntryExt graph, List <KCAPIFulfillmentItem> productsFromAllFulfillments, Dictionary <int?, List <int?> > compositeItems,
                                          KCAPIFulfillment currentFulfillment, List <KCAPIOrderItem> orderItems)
        {
            foreach (KCAPIFulfillmentItem item in currentFulfillment.Items)
            {
                double?orderedCountOfBundles = 0;

                KCAPIOrderItem orderItem = orderItems.Where(x => x.ID == item.OrderItemID).FirstOrDefault();
                if (orderItem.ProductID == item.ProductID)
                {
                    continue;
                }

                foreach (int productID in compositeItems[item.OrderItemID])
                {
                    int?itemQuantity = 0;
                    productsFromAllFulfillments.Where(x => x.ProductID == productID && x.OrderItemID == item.OrderItemID).ToList().ForEach(x => itemQuantity += x.Quantity);
                    double?qtyPerBundle = itemQuantity / orderItem.Quantity;

                    DAC.KNSIKCInventoryItem KCItem = graph.KCInventoryItem.SelectSingle(productID);
                    if (KCItem != null)
                    {
                        if (orderedCountOfBundles == 0)
                        {
                            orderedCountOfBundles = itemQuantity / qtyPerBundle;
                        }
                        if (currentFulfillment.Items.Any(x => x.ProductID == productID && x.OrderItemID == item.OrderItemID && x.Quantity / qtyPerBundle == orderedCountOfBundles) &&
                            (!productsFromAllFulfillments.Any(x => x.ProductID == productID && x.OrderItemID == item.OrderItemID && x.FulfillmentID != item.FulfillmentID) ||
                             (orderedCountOfBundles % 1 == 0 && itemQuantity / qtyPerBundle == orderedCountOfBundles)))
                        {
                            continue;
                        }
                        else
                        {
                            return(false);
                        }
                    }
                }
            }

            return(true);
        }
Пример #5
0
        public bool CheckOrderItems(List <KCAPIOrderItem> orderItems, KCSiteMasterMaint exchangeMaint)
        {
            bool result = false;

            if (orderItems != null)
            {
                foreach (KCAPIOrderItem orderItem in orderItems)
                {
                    DAC.KNSIKCInventoryItem stockItem = exchangeMaint.ExistingProducts.SelectSingle(orderItem.ProductID);
                    if (stockItem == null)
                    {
                        logger.SetNonChildEntityId(orderItem.OrderID.ToString());
                        logger.Information(KCMessages.ProductDoesntExist(orderItem.OrderID, orderItem.ProductID));
                        return(false);
                    }
                    result = true;
                }
            }
            return(result);
        }
Пример #6
0
        public bool CheckSalesAccountID(KCSiteMasterMaint sitemaster, InventoryItem product, int orderID, int CAProductId)
        {
            if (product != null && !product.StkItem.GetValueOrDefault() && (product.SalesAcctID == null || product.SalesSubID == null))
            {
                DAC.KNSIKCInventoryItem KCChild = sitemaster.KCInventoryItem.SelectSingle(product.InventoryID);
                if (KCChild != null)
                {
                    logger.SetNonChildEntityId(orderID.ToString());
                    logger.Information(KCMessages.SalesAcctIDCannotBeEmpty(orderID, KCChild.UsrKCCAID.GetValueOrDefault()));
                }
                else
                {
                    logger.SetNonChildEntityId(orderID.ToString());
                    logger.Information(KCMessages.SalesAcctIDCannotBeEmpty(orderID, CAProductId));
                }
                return(false);
            }

            return(true);
        }
Пример #7
0
        public bool CheckProductStatus(KCSiteMasterMaint sitemaster, InventoryItem product, int orderID, int CAProductId)
        {
            if (product != null && product.ItemStatus != KCConstants.Active)
            {
                DAC.KNSIKCInventoryItem KCChild = sitemaster.KCInventoryItem.SelectSingle(product.InventoryID);
                if (KCChild != null)
                {
                    logger.SetNonChildEntityId(orderID.ToString());
                    logger.Information(KCMessages.ProductDoesntActive(orderID, KCChild.UsrKCCAID.GetValueOrDefault()));
                }
                else
                {
                    logger.SetNonChildEntityId(orderID.ToString());
                    logger.Information(KCMessages.ProductDoesntActive(orderID, CAProductId));
                }
                return(false);
            }

            return(true);
        }
Пример #8
0
        public bool ValidateItems <T>(List <T> items, Validation method, KCSiteMasterMaint sitemaster)
        {
            bool result = false;
            List <KCAPIOrderItem>       orderItems;
            List <KCAPIFulfillmentItem> filfillmentItems;

            if (items as List <KCAPIOrderItem> != null)
            {
                orderItems = items as List <KCAPIOrderItem>;
            }
            if (items as List <KCAPIFulfillmentItem> != null)
            {
                filfillmentItems = items as List <KCAPIFulfillmentItem>;
            }

            if (items != null)
            {
                foreach (T item in items)
                {
                    KCAPIOrderItem       orderItem      = null;
                    KCAPIFulfillmentItem fulfillmetItem = null;

                    if (item as KCAPIOrderItem != null)
                    {
                        orderItem = item as KCAPIOrderItem;
                    }
                    if (item as KCAPIFulfillmentItem != null)
                    {
                        fulfillmetItem = item as KCAPIFulfillmentItem;
                    }

                    int productID = 0;
                    int orderID   = 0;

                    if (orderItem == null)
                    {
                        productID = fulfillmetItem.ProductID;
                        orderID   = fulfillmetItem.OrderID;
                    }
                    else
                    {
                        productID = orderItem.ProductID;
                        orderID   = orderItem.OrderID;
                    }

                    DAC.KNSIKCInventoryItem stockItem     = sitemaster.ExistingProducts.SelectSingle(productID);
                    InventoryItem           inventoryItem = sitemaster.ProductByInvId.SelectSingle(stockItem.InventoryID);

                    if (inventoryItem != null)
                    {
                        if (!method(sitemaster, inventoryItem, orderID, productID))
                        {
                            return(false);
                        }
                        else if (inventoryItem.GetExtension <InventoryItemPCExt>().UsrKNCompositeType == KCConstants.ConfigurableProduct)
                        {
                            PXResultset <InventoryItem> childItems = sitemaster.ConfigChildItems.Select(inventoryItem.InventoryID);

                            foreach (InventoryItem child in childItems)
                            {
                                if (!method(sitemaster, child, orderID, productID))
                                {
                                    return(false);
                                }
                            }
                        }
                        else if (inventoryItem.GetExtension <InventoryItemPCExt>().UsrKNCompositeType == KCConstants.GroupedProduct)
                        {
                            PXResultset <KNSIGroupedItems> childItems = sitemaster.GroupedChildItems.Select(inventoryItem.InventoryID);
                            foreach (KNSIGroupedItems child in childItems)
                            {
                                InventoryItem product = sitemaster.ProductByInvId.SelectSingle(child.MappedInventoryID);

                                if (!method(sitemaster, product, orderID, productID))
                                {
                                    return(false);
                                }
                            }
                        }
                        else if (inventoryItem.KitItem.GetValueOrDefault())
                        {
                            string revisionId = sitemaster.KitProduct.SelectSingle(inventoryItem.InventoryID)?.RevisionID;
                            IEnumerable <INKitSpecNonStkDet> nonStockKitComponents = sitemaster.NonStockKitComponents.Select(inventoryItem.InventoryID, revisionId)?.RowCast <INKitSpecNonStkDet>();

                            foreach (INKitSpecNonStkDet child in nonStockKitComponents)
                            {
                                InventoryItem product = sitemaster.ProductByInvId.SelectSingle(child.CompInventoryID);

                                if (!method(sitemaster, product, orderID, productID))
                                {
                                    return(false);
                                }
                            }
                        }
                    }

                    result = true;
                }
            }
            return(result);
        }