Exemplo n.º 1
0
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L6TR_SOHaS1434 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();
            //* Array TreatmentID and ArticleID are the sam lenght; Treatment with position i has article with the position i

            var           count         = 0;
            List <Orders> orderList     = new List <Orders>();
            int           ordinalNumber = 0;
            Guid          headerID      = Guid.Empty;

            for (int g = 0; g < Parameter.HEC_Patient_TreatmentID.Length; g++)
            {
                #region Save Order

                var status_query = new ORM_ORD_CUO_CustomerOrder_Status.Query();
                status_query.IsDeleted                = false;
                status_query.Tenant_RefID             = securityTicket.TenantID;
                status_query.GlobalPropertyMatchingID = STLD_ORD_CUO_CustomerOrder_Status.Ordered.ToString();
                var notOrderedstatus = ORM_ORD_CUO_CustomerOrder_Status.Query.Search(Connection, Transaction, status_query).First();


                // za ispraviti sto pre
                #region
                var prod_param = new P_L6PD_GPaCOSfT_1120();
                prod_param.TreatmentID = Parameter.HEC_Patient_TreatmentID[g];
                var products = cls_Get_Products_and_CustomerOrderStatuses_for_TreatmentID.Invoke(Connection, Transaction, prod_param, securityTicket).Result;


                var notOrdered_Products = products.Where(i => i.CMN_PRO_ProductID == Guid.Empty);
                #endregion

                if (notOrdered_Products.Count() == 0)
                {
                    return(returnValue);
                }

                #region Save Header and Status

                var header_query = new ORM_ORD_CUO_CustomerOrder_Header.Query();
                header_query.IsDeleted    = false;
                header_query.Tenant_RefID = securityTicket.TenantID;
                var headers = ORM_ORD_CUO_CustomerOrder_Header.Query.Search(Connection, Transaction, header_query);



                if (headers != null)
                {
                    count = headers.Count();
                }

                String ordernumber = String.Empty;
                var    orderFound  = orderList.Where(c => c.TreatmentID == Parameter.HEC_Patient_TreatmentID[g]).FirstOrDefault();

                if (orderFound == null)
                {
                    ordernumber = "000000000000" + (count + 1).ToString();
                    ordernumber = ordernumber.Substring(ordernumber.Length - 12);



                    var header = new ORM_ORD_CUO_CustomerOrder_Header();
                    headerID = Guid.NewGuid();
                    header.ORD_CUO_CustomerOrder_HeaderID    = headerID;
                    header.Current_CustomerOrderStatus_RefID = notOrderedstatus.ORD_CUO_CustomerOrder_StatusID;
                    header.CustomerOrder_Number = ordernumber;
                    header.CustomerOrder_Date   = DateTime.Now;
                    header.Creation_Timestamp   = DateTime.Now;
                    header.Tenant_RefID         = securityTicket.TenantID;
                    header.Save(Connection, Transaction);

                    var history = new ORM_ORD_CUO_CustomerOrder_StatusHistory();
                    history.ORD_CUO_CustomerOrder_StatusHistoryID = Guid.NewGuid();
                    history.CustomerOrder_Header_RefID            = header.ORD_CUO_CustomerOrder_HeaderID;
                    history.CustomerOrder_Status_RefID            = notOrderedstatus.ORD_CUO_CustomerOrder_StatusID;
                    history.StatusHistoryComment = "";
                    history.Creation_Timestamp   = DateTime.Now;
                    history.Tenant_RefID         = securityTicket.TenantID;
                    history.Save(Connection, Transaction);


                    Orders ord = new Orders();
                    ord.TreatmentID   = Parameter.HEC_Patient_TreatmentID[g];
                    ord.Ordernumber   = ordernumber;
                    ord.OrdinalNumber = 0;
                    ord.headerID      = headerID;
                    orderList.Add(ord);
                    ordinalNumber = 0;
                }
                else
                {
                    ordernumber   = orderFound.Ordernumber;
                    ordinalNumber = orderFound.OrdinalNumber + 1;
                    headerID      = orderFound.headerID;
                }
                #endregion



                var product = notOrdered_Products.Where(t => t.CMN_PRO_ProductID == Parameter.AtricleID[g]).FirstOrDefault();


                var position = new ORM_ORD_CUO_CustomerOrder_Position();
                position.ORD_CUO_CustomerOrder_PositionID = Guid.NewGuid();
                position.CustomerOrder_Header_RefID       = headerID;
                position.Position_OrdinalNumber           = ordinalNumber;
                position.Position_Quantity                = product.Quantity;
                position.Position_ValuePerUnit            = 1;
                position.Position_ValueTotal              = (decimal)product.Quantity;
                position.CMN_PRO_Product_Variant_RefID    = Guid.Empty;
                position.CMN_PRO_Product_RefID            = product.CMN_PRO_ProductID;
                position.CMN_PRO_Product_Release_RefID    = Guid.Empty;
                position.Position_RequestedDateOfDelivery = product.ExpectedDateOfDelivery;
                position.Creation_Timestamp               = DateTime.Now;
                position.Tenant_RefID = securityTicket.TenantID;
                position.Save(Connection, Transaction);


                var item = new ORM_HEC_Patient_Treatment_RequiredProduct();
                item.Load(Connection, Transaction, product.HEC_Patient_Treatment_RequiredProductID);
                item.BoundTo_CustomerOrderPosition_RefID = position.ORD_CUO_CustomerOrder_PositionID;
                item.Save(Connection, Transaction);



                #endregion
            }

            return(returnValue);

            #endregion UserCode
        }
        protected static FR_L5SO_GSPwPaSfSH_1141_Array Execute(DbConnection Connection, DbTransaction Transaction, P_L5SO_GSPwPaSfSH_1141 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_L5SO_GSPwPaSfSH_1141_Array();

            #region Get Shipment Positions

            P_L2SH_GSPfToSH_1334 positionsGetParam = new P_L2SH_GSPfToSH_1334();
            positionsGetParam.ShipmentHeaderID = Parameter.ShippmentHeaderID;
            var shipmentPositions = cls_Get_ShipmentPositions_for_Tenant_or_ShipmentHeaderID.Invoke(Connection, Transaction, positionsGetParam, securityTicket).Result.ToList();

            #endregion

            if (shipmentPositions.Count() == 0)
            {
                returnValue.Result = new L5SO_GSPwPaSfSH_1141[0];
                return(returnValue);
            }

            #region Get Articles For ShipmentPositions

            P_L3AR_GAfAL_0942 articlesGetParam = new P_L3AR_GAfAL_0942();
            articlesGetParam.ProductID_List = shipmentPositions.Select(i => i.CMN_PRO_Product_RefID).Distinct().ToArray();

            var articles = cls_Get_Articles_for_ArticleList.Invoke(Connection, Transaction, articlesGetParam, securityTicket).Result;

            #endregion

            #region Get Quantities on Shelf contents per product

            var articleIDs     = shipmentPositions.Select(x => x.CMN_PRO_Product_RefID).Distinct();
            var qntsPerProduct = new L3WH_GASCQfPL_1239[] { };
            if (articleIDs.Count() > 0)
            {
                var qntParam = new P_L3WH_GASCQfPL_1239 {
                    ProductIDList = articleIDs.ToArray()
                };
                qntsPerProduct = cls_Get_All_ShelfContent_Quantities_for_ProductListID.Invoke(Connection, Transaction, qntParam, securityTicket).Result;
            }

            #endregion

            #region Get ABDAPrices

            var abdaPricesParam = new P_L2PR_GPVfSC_1424()
            {
                SubscribedCatalogITL = EnumUtils.GetEnumDescription(EPublicCatalogs.ABDA)
            };

            var abdaPrices = cls_Get_PriceValues_for_SubscribedCatalogITL.Invoke(Connection, Transaction, abdaPricesParam, securityTicket).Result;

            #endregion

            #region cls_Get_AllGeneralAverageProcurementPrices_for_TenantID

            var avgProcPrice = cls_Get_AllGeneralAverageProcurementPrices_for_TenantID.Invoke(Connection, Transaction, securityTicket).Result;

            #endregion

            List <L5SO_GSPwPaSfSH_1141> listOfPositionsWithPrices = new List <L5SO_GSPwPaSfSH_1141>();

            foreach (var position in shipmentPositions)
            {
                var quantity = qntsPerProduct.Where(i => i.Product_RefID == position.CMN_PRO_Product_RefID).SingleOrDefault();
                if (quantity == null)
                {
                    quantity = new L3WH_GASCQfPL_1239()
                    {
                        Product_RefID          = position.CMN_PRO_Product_RefID,
                        Sum_Quantity_Current   = 0,
                        Sum_R_ReservedQuantity = 0,
                        Sum_R_FreeQuantity     = 0
                    };
                }

                var tempPositionWithPrice = new L5SO_GSPwPaSfSH_1141();
                tempPositionWithPrice.ShipmentPositionID = position.LOG_SHP_Shipment_PositionID;

                var reservationSum = ORM_LOG_RSV_Reservation.Query.Search(Connection, Transaction, new ORM_LOG_RSV_Reservation.Query()
                {
                    LOG_SHP_Shipment_Position_RefID = position.LOG_SHP_Shipment_PositionID,
                    IsDeleted             = false,
                    IsReservationExecuted = false
                }).Sum(x => x.ReservedQuantity);

                var correspodingCustomerOrderPosition = new ORM_ORD_CUO_CustomerOrder_Position();

                var positionArticle = articles.Where(ar => ar.CMN_PRO_ProductID == position.CMN_PRO_Product_RefID).Single();
                tempPositionWithPrice.Product_Number    = positionArticle.Product_Number;
                tempPositionWithPrice.Product_Name      = positionArticle.Product_Name;
                tempPositionWithPrice.UnitAmount        = positionArticle.UnitAmount;
                tempPositionWithPrice.UnitIsoCode       = positionArticle.UnitIsoCode;
                tempPositionWithPrice.DossageFormName   = positionArticle.DossageFormName;
                tempPositionWithPrice.Producer          = positionArticle.ProducerName;
                tempPositionWithPrice.CMN_PRO_ProductID = positionArticle.CMN_PRO_ProductID;

                tempPositionWithPrice.ReservedQuantity  = reservationSum;
                tempPositionWithPrice.QuantityToShip    = position.QuantityToShip;
                tempPositionWithPrice.QuantityInStock   = quantity.Sum_Quantity_Current;
                tempPositionWithPrice.QuantityAvailable = quantity.Sum_R_FreeQuantity;

                tempPositionWithPrice.ABDAPrice  = abdaPrices.Where(i => i.CMN_PRO_Product_RefID == position.CMN_PRO_Product_RefID).Select(j => j.PriceAmount).SingleOrDefault();
                tempPositionWithPrice.SalesPrice = position.ShipmentPosition_ValueWithoutTax;
                tempPositionWithPrice.AverageProcurementPrice = avgProcPrice.Where(i => i.Product_RefID == position.CMN_PRO_Product_RefID).Select(j => j.PriceValue_Amount).SingleOrDefault();
                tempPositionWithPrice.ShipmentPosition_PricePerUnitValueWithoutTax = position.ShipmentPosition_PricePerUnitValueWithoutTax;

                #region Product Replacement Allowed

                var assignmentToCustomerOrderPositionQuery = new ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition.Query();
                assignmentToCustomerOrderPositionQuery.LOG_SHP_Shipment_Position_RefID = position.LOG_SHP_Shipment_PositionID;
                assignmentToCustomerOrderPositionQuery.Tenant_RefID = securityTicket.TenantID;
                assignmentToCustomerOrderPositionQuery.IsDeleted    = false;
                var foundAssignment = ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition.Query.
                                      Search(Connection, Transaction, assignmentToCustomerOrderPositionQuery).SingleOrDefault();

                if (foundAssignment != null)
                {
                    correspodingCustomerOrderPosition.Load(Connection, Transaction, foundAssignment.ORD_CUO_CustomerOrder_Position_RefID);
                    tempPositionWithPrice.IsProductReplacementAllowed = correspodingCustomerOrderPosition.IsProductReplacementAllowed;
                }
                else
                {
                    tempPositionWithPrice.IsProductReplacementAllowed = true;
                }

                #endregion

                listOfPositionsWithPrices.Add(tempPositionWithPrice);
            }

            returnValue.Result = listOfPositionsWithPrices.ToArray();

            return(returnValue);

            #endregion UserCode
        }
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L6TR_SPTaO_1014 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();

            #region Save Treatment

            var param = new P_L6TR_SPT_1533();
            param.Aticles   = Parameter.Aticles;
            param.Diagnosis = Parameter.Diagnosis;
            param.Treatment = Parameter.Treatment;
            param.Followups = Parameter.Followups;
            var TreatmentID = cls_Save_Patient_Treatment.Invoke(Connection, Transaction, param, securityTicket).Result;

            returnValue.Result = TreatmentID;
            #endregion

            #region Save Order

            var status_query = new ORM_ORD_CUO_CustomerOrder_Status.Query();
            status_query.IsDeleted                = false;
            status_query.Tenant_RefID             = securityTicket.TenantID;
            status_query.GlobalPropertyMatchingID = STLD_ORD_CUO_CustomerOrder_Status.Ordered.ToString();
            var notOrderedstatus = ORM_ORD_CUO_CustomerOrder_Status.Query.Search(Connection, Transaction, status_query).First();

            var prod_param = new P_L6PD_GPaCOSfT_1120();
            prod_param.TreatmentID = TreatmentID;
            var products = cls_Get_Products_and_CustomerOrderStatuses_for_TreatmentID.Invoke(Connection, Transaction, prod_param, securityTicket).Result;

            var notOrdered_Products = products.Where(i => i.ORD_CUO_CustomerOrder_PositionID == Guid.Empty);

            if (notOrdered_Products.Count() == 0)
            {
                return(returnValue);
            }

            #region Save Header and Status

            var header_query = new ORM_ORD_CUO_CustomerOrder_Header.Query();
            header_query.IsDeleted    = false;
            header_query.Tenant_RefID = securityTicket.TenantID;
            var headers = ORM_ORD_CUO_CustomerOrder_Header.Query.Search(Connection, Transaction, header_query);

            var count = 0;
            if (headers != null)
            {
                count = headers.Count();
            }

            String ordernumber = "000000000000" + (count + 1).ToString();
            ordernumber = ordernumber.Substring(ordernumber.Length - 12);

            var header = new ORM_ORD_CUO_CustomerOrder_Header();
            header.ORD_CUO_CustomerOrder_HeaderID    = Guid.NewGuid();
            header.Current_CustomerOrderStatus_RefID = notOrderedstatus.ORD_CUO_CustomerOrder_StatusID;
            header.CustomerOrder_Number = ordernumber;
            header.CustomerOrder_Date   = DateTime.Now;
            header.Creation_Timestamp   = DateTime.Now;
            header.Tenant_RefID         = securityTicket.TenantID;
            header.Save(Connection, Transaction);

            var history = new ORM_ORD_CUO_CustomerOrder_StatusHistory();
            history.ORD_CUO_CustomerOrder_StatusHistoryID = Guid.NewGuid();
            history.CustomerOrder_Header_RefID            = header.ORD_CUO_CustomerOrder_HeaderID;
            history.CustomerOrder_Status_RefID            = notOrderedstatus.ORD_CUO_CustomerOrder_StatusID;
            history.StatusHistoryComment = "";
            history.Creation_Timestamp   = DateTime.Now;
            history.Tenant_RefID         = securityTicket.TenantID;
            history.Save(Connection, Transaction);

            #endregion

            int cnt = 0;
            foreach (var product in notOrdered_Products)
            {
                cnt++;

                var position = new ORM_ORD_CUO_CustomerOrder_Position();
                position.ORD_CUO_CustomerOrder_PositionID = Guid.NewGuid();
                position.CustomerOrder_Header_RefID       = header.ORD_CUO_CustomerOrder_HeaderID;
                position.Position_OrdinalNumber           = cnt;
                position.Position_Quantity                = product.Quantity;
                position.Position_ValuePerUnit            = 1;
                position.Position_ValueTotal              = (decimal)product.Quantity;
                position.CMN_PRO_Product_Variant_RefID    = Guid.Empty;
                position.CMN_PRO_Product_RefID            = product.CMN_PRO_ProductID;
                position.CMN_PRO_Product_Release_RefID    = Guid.Empty;
                position.Position_RequestedDateOfDelivery = product.ExpectedDateOfDelivery;
                position.Creation_Timestamp               = DateTime.Now;
                position.Tenant_RefID = securityTicket.TenantID;
                position.Save(Connection, Transaction);


                var item = new ORM_HEC_Patient_Treatment_RequiredProduct();
                item.Load(Connection, Transaction, product.HEC_Patient_Treatment_RequiredProductID);
                item.BoundTo_CustomerOrderPosition_RefID = position.ORD_CUO_CustomerOrder_PositionID;
                item.Save(Connection, Transaction);
            }

            #endregion

            return(returnValue);

            #endregion UserCode
        }
Exemplo n.º 4
0
        protected static FR_Bool Execute(DbConnection Connection, DbTransaction Transaction, P_L5CO_CCO_1950 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Bool();

            //Find status
            var status = ORM_ORD_CUO_CustomerOrder_Status.Query.Search(Connection, Transaction, new ORM_ORD_CUO_CustomerOrder_Status.Query()
            {
                Tenant_RefID             = securityTicket.TenantID,
                GlobalPropertyMatchingID = EnumUtils.GetEnumDescription(ECustomerOrderStatus.Ordered),
                IsDeleted = false
            }).SingleOrDefault();

            //Find currency
            var currency = ORM_CMN_Currency.Query.Search(Connection, Transaction, new ORM_CMN_Currency.Query()
            {
                Tenant_RefID = securityTicket.TenantID,
                ISO4127      = Parameter.ProcurementOrderHeader.CurrencyISOCode.Trim()
            });

            //Put your code here
            ORM_ORD_CUO_CustomerOrder_Header customerOrderHeader = new ORM_ORD_CUO_CustomerOrder_Header();
            customerOrderHeader.ORD_CUO_CustomerOrder_HeaderID             = Guid.NewGuid();
            customerOrderHeader.ProcurementOrderITL                        = Parameter.ProcurementOrderHeader.ProcurementOrderID.ToString();
            customerOrderHeader.CustomerOrder_Number                       = Parameter.ProcurementOrderHeader.OrderNumber;
            customerOrderHeader.CustomerOrder_Date                         = DateTime.Now;
            customerOrderHeader.OrderingCustomer_BusinessParticipant_RefID = Parameter.ProcurementOrderHeader.OrderingCustomerBusinessParticipantID;
            customerOrderHeader.CreatedBy_BusinessParticipant_RefID        = Parameter.ProcurementOrderHeader.CreatedByBusinessParticipantID;
            customerOrderHeader.TotalValue_BeforeTax                       = Parameter.ProcurementOrderHeader.TotalValueBeforeTax;
            customerOrderHeader.Current_CustomerOrderStatus_RefID          = status.ORD_CUO_CustomerOrder_StatusID;
            customerOrderHeader.Tenant_RefID = securityTicket.TenantID;
            //This should be changed when we figure out what to do with currencies that don't exist in s-adm database
            customerOrderHeader.CustomerOrder_Currency_RefID = (currency != null && currency.Count == 1) ? currency.First().CMN_CurrencyID : Guid.Empty;
            customerOrderHeader.Save(Connection, Transaction);

            ORM_ORD_CUO_CustomerOrder_StatusHistory statusHistory = new ORM_ORD_CUO_CustomerOrder_StatusHistory();
            statusHistory.ORD_CUO_CustomerOrder_StatusHistoryID = Guid.NewGuid();
            statusHistory.CustomerOrder_Status_RefID            = status.ORD_CUO_CustomerOrder_StatusID;
            statusHistory.CustomerOrder_Header_RefID            = customerOrderHeader.ORD_CUO_CustomerOrder_HeaderID;
            statusHistory.Tenant_RefID = securityTicket.TenantID;
            statusHistory.Save(Connection, Transaction);

            //Get products and product variants for ITL Lists
            var productIDList            = Parameter.ProcurementOrderHeader.Positions.Select(x => x.ProductRefID.ToString()).ToArray();
            L3PR_GPfPITL_1416[] products = null;
            if (productIDList != null && productIDList.Count() > 0)
            {
                products = cls_Get_Producs_for_ProductITLList.Invoke(Connection, Transaction, new P_L3PR_GPfPITL_1416()
                {
                    ProductITLList = productIDList
                }, securityTicket).Result;
            }

            var variantIDList             = Parameter.ProcurementOrderHeader.Positions.Select(x => x.ProductVariantRefID.ToString()).ToArray();
            L3PV_GPVfVITL_1421[] variants = null;
            if (variantIDList != null && variantIDList.Count() > 0)
            {
                variants = cls_Get_ProductVariants_for_VariantITLList.Invoke(Connection, new P_L3PV_GPVfVITL_1421()
                {
                    VariantITLList = variantIDList
                }, securityTicket).Result;
            }

            foreach (var position in Parameter.ProcurementOrderHeader.Positions)
            {
                var newPosition = new ORM_ORD_CUO_CustomerOrder_Position();
                newPosition.ORD_CUO_CustomerOrder_PositionID    = Guid.NewGuid();
                newPosition.CustomerProcurementOrderPositionITL = position.ProcurementOrderPositionID.ToString();
                newPosition.CustomerOrder_Header_RefID          = customerOrderHeader.ORD_CUO_CustomerOrder_HeaderID;
                newPosition.Position_OrdinalNumber        = position.OridinalNumber;
                newPosition.Position_Quantity             = position.Quantity;
                newPosition.Position_ValuePerUnit         = position.ValuePerunit;
                newPosition.Position_ValueTotal           = position.ValueTotal;
                newPosition.Position_Comment              = position.Comment;
                newPosition.Position_Description          = position.Description;
                newPosition.IsProductReplacementAllowed   = position.IsProductReplacementAllowed;
                newPosition.CMN_PRO_Product_RefID         = products.Where(x => x.ProductITL == position.ProductRefID.ToString()).First().CMN_PRO_ProductID;
                newPosition.CMN_PRO_Product_Variant_RefID = variants.Where(x => x.ProductVariantITL == position.ProductVariantRefID.ToString()).First().CMN_PRO_Product_VariantID;
                newPosition.Tenant_RefID = securityTicket.TenantID;
                newPosition.Save(Connection, Transaction);

                foreach (var custom in position.PositionCustomizations)
                {
                    ORM_ORD_CUO_CustomerOrder_Position_Customization customization = new ORM_ORD_CUO_CustomerOrder_Position_Customization();
                    customization.ORD_CUO_CustomerOrder_Position_CustomizationID = Guid.NewGuid();
                    customization.Tenant_RefID = securityTicket.TenantID;
                    customization.CustomerOrder_Position_RefID = newPosition.ORD_CUO_CustomerOrder_PositionID;
                    customization.Customization_Name           = custom.CustomizationName;
                    customization.CustomizationVariant_Name    = custom.CustomizationVariantName;
                    customization.ValuePerUnit = custom.ValuePerUnit;
                    customization.ValueTotal   = custom.ValueTotal;
                    customization.Save(Connection, Transaction);
                }
            }

            return(returnValue);

            #endregion UserCode
        }
        protected static FR_Guids Execute(DbConnection Connection, DbTransaction Transaction, P_L5CO_CCOaMR_1102 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guids();
            var result      = new List <Guid>();

            #region Current_CustomerOrderStatus

            var orderedStatusID = ORM_ORD_CUO_CustomerOrder_Status.Query.Search(Connection, Transaction,
                                                                                new ORM_ORD_CUO_CustomerOrder_Status.Query
            {
                GlobalPropertyMatchingID = EnumUtils.GetEnumDescription(ECustomerOrderStatus.Ordered),
                Tenant_RefID             = securityTicket.TenantID,
                IsDeleted = false
            }).SingleOrDefault().ORD_CUO_CustomerOrder_StatusID;

            #endregion

            #region Get All OrganizationalUnits

            var organizationalUnits = ORM_CMN_BPT_CTM_OrganizationalUnit.Query.Search(Connection, Transaction, new ORM_CMN_BPT_CTM_OrganizationalUnit.Query()
            {
                Tenant_RefID = securityTicket.TenantID,
                IsDeleted    = false
            });
            #endregion

            foreach (var procurement in Parameter.Procurements)
            {
                #region CustomerOrder_Number

                var incrNumberParam = new P_L2NR_GaIINfUA_1454()
                {
                    GlobalStaticMatchingID = EnumUtils.GetEnumDescription(ENumberRangeUsageAreaType.CustomerOrderNumber)
                };
                var customerOrderNumber = cls_Get_and_Increase_IncreasingNumber_for_UsageArea.Invoke(Connection, Transaction, incrNumberParam, securityTicket).Result.Current_IncreasingNumber;

                #endregion

                var cuoHeader = new ORM_ORD_CUO_CustomerOrder_Header();
                cuoHeader.ORD_CUO_CustomerOrder_HeaderID    = Guid.NewGuid();
                cuoHeader.ProcurementOrderITL               = procurement.ProcurementHeaderInfo.ProcurementOrderInfo.ITL;
                cuoHeader.Current_CustomerOrderStatus_RefID = orderedStatusID;
                cuoHeader.CustomerOrder_Number              = customerOrderNumber;
                cuoHeader.CustomerOrder_Date = DateTime.Now;
                cuoHeader.OrderingCustomer_BusinessParticipant_RefID = Parameter.CustomerBusinessParticipantID;
                cuoHeader.CreatedBy_BusinessParticipant_RefID        = Parameter.CustomerBusinessParticipantID;
                cuoHeader.CanceledBy_BusinessParticipant_RefID       = Guid.Empty;
                cuoHeader.CustomerOrder_Currency_RefID = Guid.Empty;
                cuoHeader.TotalValue_BeforeTax         = 0;
                cuoHeader.IsCustomerOrderFinalized     = false;
                cuoHeader.DeliveryDeadline             = new DateTime();
                cuoHeader.IsPartialShippingAllowed     = true;
                cuoHeader.Tenant_RefID       = securityTicket.TenantID;
                cuoHeader.Creation_Timestamp = DateTime.Now;
                cuoHeader.Save(Connection, Transaction);

                #region CustomerOrderStatusHistory

                var statusHistory = new ORM_ORD_CUO_CustomerOrder_StatusHistory()
                {
                    ORD_CUO_CustomerOrder_StatusHistoryID = Guid.NewGuid(),
                    CustomerOrder_Header_RefID            = cuoHeader.ORD_CUO_CustomerOrder_HeaderID,
                    CustomerOrder_Status_RefID            = orderedStatusID,
                    StatusHistoryComment = "",
                    PerformedBy_BusinessParticipant_RefID = Parameter.CustomerBusinessParticipantID,
                    Creation_Timestamp = DateTime.Now,
                    Tenant_RefID       = securityTicket.TenantID
                };

                statusHistory.Save(Connection, Transaction);

                #endregion

                var     count   = 1;
                decimal ammount = 0;

                foreach (var position in procurement.ProcurementPositions)
                {
                    #region FindArticle

                    var product = ORM_CMN_PRO_Product.Query.Search(Connection, Transaction,
                                                                   new ORM_CMN_PRO_Product.Query()
                    {
                        ProductITL   = position.Product.ProductITL,
                        IsDeleted    = false,
                        Tenant_RefID = securityTicket.TenantID,
                        IsProductAvailableForOrdering = true
                    }).Single();

                    var packageInfo = ORM_CMN_PRO_PAC_PackageInfo.Query.Search(Connection, Transaction,
                                                                               new ORM_CMN_PRO_PAC_PackageInfo.Query()
                    {
                        CMN_PRO_PAC_PackageInfoID = product.PackageInfo_RefID,
                        IsDeleted    = false,
                        Tenant_RefID = securityTicket.TenantID
                    }).SingleOrDefault();

                    #endregion

                    #region Find Price

                    decimal priceAmount = 0;

                    if (position.Product.SourceCatalogITL == EnumUtils.GetEnumDescription(EPublicCatalogs.ABDA))
                    {
                        var abdaCatalogSubscription = ORM_CMN_PRO_SubscribedCatalog.Query.Search(Connection, Transaction,
                                                                                                 new ORM_CMN_PRO_SubscribedCatalog.Query()
                        {
                            CatalogCodeITL = EnumUtils.GetEnumDescription(EPublicCatalogs.ABDA),
                            Tenant_RefID   = securityTicket.TenantID,
                            IsDeleted      = false
                        }
                                                                                                 ).SingleOrDefault();

                        var price = ORM_CMN_SLS_Price.Query.Search(Connection, Transaction, new ORM_CMN_SLS_Price.Query()
                        {
                            CMN_PRO_Product_RefID  = product.CMN_PRO_ProductID,
                            PricelistRelease_RefID = abdaCatalogSubscription.SubscribedCatalog_PricelistRelease_RefID,
                            IsDeleted = false
                        }).Single();

                        priceAmount = price.PriceAmount;
                    }
                    else
                    {
                        var catalog = ORM_CMN_PRO_Catalog.Query.Search(Connection, Transaction,
                                                                       new ORM_CMN_PRO_Catalog.Query()
                        {
                            CatalogCodeITL = position.Product.SourceCatalogITL,
                            IsDeleted      = false,
                            Tenant_RefID   = securityTicket.TenantID
                        }).Single();

                        var lastPublishedRevision = ORM_CMN_PRO_Catalog_Revision.Query.Search(Connection, Transaction,
                                                                                              new ORM_CMN_PRO_Catalog_Revision.Query()
                        {
                            CMN_PRO_Catalog_RefID = catalog.CMN_PRO_CatalogID,
                            IsDeleted             = false,
                            Tenant_RefID          = securityTicket.TenantID,
                        }).Where(j => j.PublishedOn_Date != new DateTime()).OrderBy(i => i.RevisionNumber).Last();

                        var price = ORM_CMN_SLS_Price.Query.Search(Connection, Transaction,
                                                                   new ORM_CMN_SLS_Price.Query()
                        {
                            CMN_PRO_Product_RefID  = product.CMN_PRO_ProductID,
                            PricelistRelease_RefID = lastPublishedRevision.Default_PricelistRelease_RefID,
                            CMN_Currency_RefID     = catalog.Catalog_Currency_RefID,
                            IsDeleted    = false,
                            Tenant_RefID = securityTicket.TenantID
                        }).Single();

                        priceAmount = price.PriceAmount;
                    }

                    #endregion

                    var cuoPosition = new ORM_ORD_CUO_CustomerOrder_Position();
                    cuoPosition.ORD_CUO_CustomerOrder_PositionID = Guid.NewGuid();
                    cuoPosition.CustomerOrder_Header_RefID       = cuoHeader.ORD_CUO_CustomerOrder_HeaderID;
                    cuoPosition.Position_OrdinalNumber           = count++;
                    cuoPosition.Position_Quantity                = position.TotalOrderQuantity;
                    cuoPosition.Position_ValuePerUnit            = priceAmount;
                    cuoPosition.Position_ValueTotal              = priceAmount * (decimal)position.TotalOrderQuantity;
                    cuoPosition.Position_Comment                 = String.Empty;
                    cuoPosition.Position_Unit_RefID              = packageInfo.PackageContent_MeasuredInUnit_RefID;
                    cuoPosition.Position_RequestedDateOfDelivery = new DateTime();
                    cuoPosition.CMN_PRO_Product_RefID            = product.CMN_PRO_ProductID;
                    cuoPosition.CMN_PRO_Product_Release_RefID    = Guid.Empty;
                    cuoPosition.CMN_PRO_Product_Variant_RefID    = Guid.Empty;
                    cuoPosition.IsProductReplacementAllowed      = position.Product.IsProductReplacementAllowed;

                    cuoPosition.Tenant_RefID       = securityTicket.TenantID;
                    cuoPosition.Creation_Timestamp = DateTime.Now;
                    cuoPosition.Save(Connection, Transaction);

                    #region Product 2 OrganizationalUnit

                    foreach (var item in position.TargetOrgUnitInfo)
                    {
                        var orgUnit = organizationalUnits.Where(i => i.CustomerTenant_OfficeITL == item.OfficeITL).Single();

                        var assignement = new ORM_ORD_CUO_Position_CustomerOrganizationalUnitDistribution()
                        {
                            ORD_CUO_Position_CustomerOrganizationalUnitDistributionID = Guid.NewGuid(),
                            Quantity = item.SubQuantity,
                            CMN_BPT_CTM_OrganizationalUnit_RefID = orgUnit.CMN_BPT_CTM_OrganizationalUnitID,
                            ORD_CUO_CustomerOrder_Position_RefID = cuoPosition.ORD_CUO_CustomerOrder_PositionID,
                            Creation_Timestamp = DateTime.Now,
                            Tenant_RefID       = securityTicket.TenantID
                        };

                        assignement.Save(Connection, Transaction);
                    }

                    #endregion

                    ammount += cuoPosition.Position_ValueTotal;
                }

                #region Create comments

                if (procurement.ProcurementComments != null)
                {
                    foreach (var item in procurement.ProcurementComments)
                    {
                        var orgUnit = organizationalUnits.Where(i => i.CustomerTenant_OfficeITL == item.OfficeITL).Single();

                        var assignement = new ORM_ORD_CUO_CustomerOrder_Note()
                        {
                            ORD_CUO_CustomerOrder_NoteID         = Guid.NewGuid(),
                            CustomerOrder_Header_RefID           = cuoHeader.ORD_CUO_CustomerOrder_HeaderID,
                            CustomerOrder_Position_RefID         = Guid.Empty,
                            CMN_BPT_CTM_OrganizationalUnit_RefID = orgUnit.CMN_BPT_CTM_OrganizationalUnitID,
                            Title               = item.Title,
                            Comment             = item.Content,
                            NotePublishDate     = item.PublilshDate,
                            SequenceOrderNumber = item.SequenceNumber,
                            Creation_Timestamp  = DateTime.Now,
                            Tenant_RefID        = securityTicket.TenantID
                        };

                        assignement.Save(Connection, Transaction);
                    }
                }

                #endregion

                cuoHeader.TotalValue_BeforeTax = ammount;
                cuoHeader.Save(Connection, Transaction);

                result.Add(cuoHeader.ORD_CUO_CustomerOrder_HeaderID);
            }

            returnValue.Result = result.ToArray();
            return(returnValue);

            #endregion UserCode
        }
Exemplo n.º 6
0
        protected static FR_L5PP_GSHwCOfPfT_1348_Array Execute(DbConnection Connection, DbTransaction Transaction, P_L5PP_GSHwCOfPfT_1348 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_L5PP_GSHwCOfPfT_1348_Array();

            //Put your code here
            List <L5PP_GSHwCOfPfT_1348> retVal = new List <L5PP_GSHwCOfPfT_1348>();
            returnValue.Result = retVal.ToArray();

            #region Retrieve Headers

            // get all headers
            P_L2SH_GSHfT_1527 shipmentHeadersParam = new P_L2SH_GSHfT_1527();
            shipmentHeadersParam.IsShipped                = false;
            shipmentHeadersParam.ShipmentNumber           = Parameter.ShipmentNumber;
            shipmentHeadersParam.ShipmentCreationDateFrom = Parameter.ShipmentCreationDateFrom;
            shipmentHeadersParam.ShipmentCreationDateTo   = Parameter.ShipmentCreationDateTo;
            var headersResult = cls_Get_ShippmentHeaders_for_TenantID.Invoke(Connection, Transaction, shipmentHeadersParam, securityTicket).Result;

            if (headersResult == null)
            {
                return(returnValue);
            }

            // filter headers
            List <L2SH_GSHfT_1527> headers     = new List <L2SH_GSHfT_1527>();
            List <L2SH_GSHfT_1527> tempHeaders = new List <L2SH_GSHfT_1527>();
            if (Parameter.HasPositionsPartiallyToPick)
            {
                // filtered by passed parameter option
                tempHeaders = headersResult.Where(i => i.IsPartiallyReadyForPicking && !i.IsManuallyCleared_ForPicking).ToList();
                // add not inserted shipment headers
                headers.AddRange(tempHeaders.Where(i => !headers.Any(j => j.LOG_SHP_Shipment_HeaderID == i.LOG_SHP_Shipment_HeaderID)).ToList());
            }

            if (Parameter.IsReadyForPicking)
            {
                // filtered by passed parameter option
                tempHeaders = headersResult.Where(i => i.IsReadyForPicking && !i.IsManuallyCleared_ForPicking).ToList();
                // add not inserted shipment headers
                headers.AddRange(tempHeaders.Where(i => !headers.Any(j => j.LOG_SHP_Shipment_HeaderID == i.LOG_SHP_Shipment_HeaderID)).ToList());
            }

            if (Parameter.IsInPickingProcess)
            {
                // filtered by passed parameter option
                tempHeaders = headersResult.Where(i => i.HasPickingStarted || i.HasPickingFinished || i.IsManuallyCleared_ForPicking).ToList();
                // add not inserted shipment headers
                headers.AddRange(tempHeaders.Where(i => !headers.Any(j => j.LOG_SHP_Shipment_HeaderID == i.LOG_SHP_Shipment_HeaderID)).ToList());
            }

            if (Parameter.NoPositionsFullyToPick)
            {
                // filtered by passed parameter option
                tempHeaders = headersResult.Where(i =>
                                                  !(i.IsPartiallyReadyForPicking && !i.IsManuallyCleared_ForPicking) &&
                                                  !(i.IsReadyForPicking && !i.IsManuallyCleared_ForPicking) &&
                                                  !(i.HasPickingStarted || i.HasPickingFinished || i.IsManuallyCleared_ForPicking)
                                                  ).ToList();
                // add not inserted shipment headers
                headers.AddRange(tempHeaders.Where(i => !headers.Any(j => j.LOG_SHP_Shipment_HeaderID == i.LOG_SHP_Shipment_HeaderID)).ToList());
            }

            #endregion

            L5PP_GSHwCOfPfT_1348 retValItem;
            foreach (var header in headers)
            {
                #region Getting data

                #region Shipment positions
                // get one shipment position for shipment header
                ORM_LOG_SHP_Shipment_Position.Query shipmentPositionsQuery = new ORM_LOG_SHP_Shipment_Position.Query();
                shipmentPositionsQuery.LOG_SHP_Shipment_Header_RefID = header.LOG_SHP_Shipment_HeaderID;
                shipmentPositionsQuery.Tenant_RefID = securityTicket.TenantID;
                shipmentPositionsQuery.IsDeleted    = false;
                List <ORM_LOG_SHP_Shipment_Position> shipmentPositions = ORM_LOG_SHP_Shipment_Position.Query.Search(Connection, Transaction, shipmentPositionsQuery);

                if (shipmentPositions == null || shipmentPositions.Count == 0)
                {
                    continue;
                }
                #endregion

                #region Customer order position for shipment position
                // get one customer order position for shipment position
                ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition customerOrder2ShipmentPosition = null;
                foreach (var shipmentPosition in shipmentPositions)
                {
                    ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition.Query customerOrder2ShipmentPositionQuery = new ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition.Query();
                    customerOrder2ShipmentPositionQuery.LOG_SHP_Shipment_Position_RefID = shipmentPosition.LOG_SHP_Shipment_PositionID;
                    customerOrder2ShipmentPositionQuery.Tenant_RefID = securityTicket.TenantID;
                    customerOrder2ShipmentPositionQuery.IsDeleted    = false;
                    customerOrder2ShipmentPosition =
                        ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition.Query
                        .Search(Connection, Transaction, customerOrder2ShipmentPositionQuery).FirstOrDefault();

                    if (customerOrder2ShipmentPosition != null)
                    {
                        break;
                    }
                }

                if (customerOrder2ShipmentPosition == null)
                {
                    continue;
                }
                #endregion

                #region Customer order position
                ORM_ORD_CUO_CustomerOrder_Position orm_CustomerOrderPosition = new ORM_ORD_CUO_CustomerOrder_Position();
                var distributionOrderPosition = orm_CustomerOrderPosition.Load(Connection, Transaction, customerOrder2ShipmentPosition.ORD_CUO_CustomerOrder_Position_RefID);
                if (distributionOrderPosition.Status != FR_Status.Success || orm_CustomerOrderPosition.ORD_CUO_CustomerOrder_PositionID == Guid.Empty)
                {
                    continue;
                }
                #endregion

                #region Customer order header
                // get customer order header for customer order position
                ORM_ORD_CUO_CustomerOrder_Header.Query customerOrderHeaderQuery = new ORM_ORD_CUO_CustomerOrder_Header.Query();
                customerOrderHeaderQuery.ORD_CUO_CustomerOrder_HeaderID = orm_CustomerOrderPosition.CustomerOrder_Header_RefID;
                customerOrderHeaderQuery.Tenant_RefID = securityTicket.TenantID;
                customerOrderHeaderQuery.IsDeleted    = false;
                if (!String.IsNullOrEmpty(Parameter.CustomerOrderNumber))
                {
                    customerOrderHeaderQuery.CustomerOrder_Number = Parameter.CustomerOrderNumber;
                }

                ORM_ORD_CUO_CustomerOrder_Header customerOrderHeader = ORM_ORD_CUO_CustomerOrder_Header.Query.Search(Connection, Transaction, customerOrderHeaderQuery).FirstOrDefault();
                if (customerOrderHeader == null)
                {
                    continue;
                }

                // apply filter for customer order header
                if (Parameter.OrderDateFrom != null)
                {
                    if (customerOrderHeader.CustomerOrder_Date < Parameter.OrderDateFrom)
                    {
                        continue;
                    }
                }

                if (Parameter.OrderDateTo != null)
                {
                    if (customerOrderHeader.CustomerOrder_Date > Parameter.OrderDateTo)
                    {
                        continue;
                    }
                }
                #endregion

                #region Customer
                ORM_CMN_BPT_BusinessParticipant.Query bussinerParticipantQuery = new ORM_CMN_BPT_BusinessParticipant.Query();
                bussinerParticipantQuery.CMN_BPT_BusinessParticipantID = customerOrderHeader.OrderingCustomer_BusinessParticipant_RefID;
                bussinerParticipantQuery.Tenant_RefID = securityTicket.TenantID;
                bussinerParticipantQuery.IsDeleted    = false;

                ORM_CMN_BPT_BusinessParticipant bussinerParticipant = ORM_CMN_BPT_BusinessParticipant.Query.Search(Connection, Transaction, bussinerParticipantQuery).FirstOrDefault();

                if (bussinerParticipant == null)
                {
                    continue;
                }

                if (!String.IsNullOrEmpty(Parameter.Customer))
                {
                    if (!bussinerParticipant.DisplayName.ToUpper().Contains(Parameter.Customer.ToUpper()))
                    {
                        continue;
                    }
                }
                #endregion

                #endregion

                retValItem = new L5PP_GSHwCOfPfT_1348();
                retValItem.LOG_SHP_Shipment_HeaderID = header.LOG_SHP_Shipment_HeaderID;
                retValItem.ShipmentHeader_Number     = header.ShipmentHeader_Number;
                retValItem.IsShipped                    = header.IsShipped;
                retValItem.IsBilled                     = header.IsBilled;
                retValItem.IsReadyForPicking            = header.IsReadyForPicking;
                retValItem.IsPartiallyReadyForPicking   = header.IsPartiallyReadyForPicking;
                retValItem.HasPickingStarted            = header.HasPickingStarted;
                retValItem.HasPickingFinished           = header.HasPickingFinished;
                retValItem.IsManuallyCleared_ForPicking = header.IsManuallyCleared_ForPicking;
                retValItem.ShipmentCreationDate         = header.Creation_Timestamp;

                retValItem.ORD_CUO_CustomerOrder_HeaderID = customerOrderHeader.ORD_CUO_CustomerOrder_HeaderID;
                retValItem.CustomerOrderNumber            = customerOrderHeader.CustomerOrder_Number;
                retValItem.CustomerOrderDate = customerOrderHeader.CustomerOrder_Date;

                retValItem.Customer = bussinerParticipant.DisplayName;

                retVal.Add(retValItem);
            }

            retVal = retVal.Skip(Parameter.From).Take(Parameter.Size).ToList();

            returnValue.Result = retVal.ToArray();

            return(returnValue);

            #endregion UserCode
        }