コード例 #1
0
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L5CO_CBH_1606 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();

            ORM_BIL_BillHeader billHeader = null;
            ORM_BIL_BillHeader_2_BillStatus billHeader2BillStatus  = null;
            ORM_CMN_UniversalContactDetail  universalContactDetail = null;

            var BillParam = Parameter.Bill_Parameter.BillHeaderData;

            #region Preloading data

            ORM_USR_Account account = new ORM_USR_Account();
            account.Load(Connection, Transaction, securityTicket.AccountID);
            var customer = ORM_CMN_BPT_CTM_Customer.Query.Search(Connection, Transaction,
                                                                 new ORM_CMN_BPT_CTM_Customer.Query()
            {
                CMN_BPT_CTM_CustomerID = BillParam.BillingReceiverCustomer.CMN_BPT_CTM_CustomerID
            }).SingleOrDefault();

            List <L3ACAAD_GCAfT_1612> customerAddresses = cls_Get_CustomerAddresses_for_CustomerID.Invoke(Connection, Transaction, new P_L3ACAAD_GCAfCID_1612 {
                CustomerID = BillParam.BillingReceiverCustomer.CMN_BPT_CTM_CustomerID
            }, securityTicket).Result.ToList();
            L3ACAAD_GCAfT_1612 customerAddress = customerAddresses.Where(x => x.AddressID == BillParam.BillingAddressID).SingleOrDefault();

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

            #endregion

            #region Universal Contact Detail

            universalContactDetail = new ORM_CMN_UniversalContactDetail()
            {
                CMN_UniversalContactDetailID = Guid.NewGuid(),
                Country_639_1_ISOCode        = customerAddress.Country_639_1_ISOCode,
                Country_Name      = customerAddress.Country_Name,
                Street_Name       = customerAddress.Street_Name,
                Street_Number     = customerAddress.Street_Number,
                Town              = customerAddress.Town,
                ZIP               = customerAddress.ZIP,
                Tenant_RefID      = account.Tenant_RefID,
                CompanyName_Line1 = BillParam.BillingReceiverCustomer.DisplayName,
                First_Name        = BillParam.BillingReceiverCustomer.FirstName,
                Last_Name         = BillParam.BillingReceiverCustomer.LastName,
                IsCompany         = BillParam.BillingReceiverCustomer.IsCompany
            };
            universalContactDetail.Save(Connection, Transaction);
            #endregion

            #region Bill Header

            billHeader = new ORM_BIL_BillHeader
            {
                BIL_BillHeaderID = Guid.NewGuid(),
                BillNumber       = billNumber,
                CreatedBy_BusinessParticipant_RefID     = account.BusinessParticipant_RefID,
                BillRecipient_BuisnessParticipant_RefID = customer.Ext_BusinessParticipant_RefID,
                TotalValue_BeforeTax     = 0,
                TotalValue_IncludingTax  = 0,
                BillingAddress_UCD_RefID = universalContactDetail.CMN_UniversalContactDetailID,
                DateOnBill     = BillParam.BillingDate,
                BillComment    = BillParam.Comment,
                Currency_RefID = cls_Get_DefaultCurrency_for_Tenant.Invoke(Connection, Transaction, securityTicket).Result.CMN_CurrencyID,
                BillHeader_PaymentCondition_RefID = Parameter.Bill_Parameter.BillHeaderData.PaymentTargetID,
                Tenant_RefID = securityTicket.TenantID
            };

            billHeader.Save(Connection, Transaction);

            #endregion

            #region Method of Payment

            var methodOfPayment = new CL1_BIL.ORM_BIL_BillHeader_MethodOfPayment
            {
                BIL_BillHeader_MethodOfPaymentID = Guid.NewGuid(),
                ACC_PAY_Type_RefID         = Parameter.Bill_Parameter.BillHeaderData.PaymentTypeID,
                BIL_BillHeader_RefID       = billHeader.BIL_BillHeaderID,
                IsPreferredMethodOfPayment = true,
                SequenceNumber             = 0,
                Tenant_RefID = securityTicket.TenantID
            };
            methodOfPayment.Save(Connection, Transaction);

            #endregion

            #region Bill Status - Created

            var statusCreated = ORM_BIL_BillStatus.Query.Search(Connection, Transaction,
                                                                new ORM_BIL_BillStatus.Query()
            {
                GlobalPropertyMatchingID = EnumUtils.GetEnumDescription(EBillStatus.Created),
                Tenant_RefID             = account.Tenant_RefID,
                IsDeleted = false
            }).Single();

            billHeader2BillStatus = new ORM_BIL_BillHeader_2_BillStatus
            {
                AssignmentID         = Guid.NewGuid(),
                BIL_BillHeader_RefID = billHeader.BIL_BillHeaderID,
                BIL_BillStatus_RefID = statusCreated.BIL_BillStatusID,
                Tenant_RefID         = account.Tenant_RefID,
                IsCurrentStatus      = true
            };
            billHeader2BillStatus.Save(Connection, Transaction);

            #endregion

            returnValue.Result = billHeader.BIL_BillHeaderID;
            return(returnValue);

            #endregion UserCode
        }
コード例 #2
0
        protected static FR_L5CO_COH_1326 Execute(DbConnection Connection, DbTransaction Transaction, P_L5CO_COH_1326 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_L5CO_COH_1326();
            returnValue.Result = new L5CO_COH_1326();

            var header = new CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_Header();
            ORM_CMN_POS_CustomerInteraction customerInteraction = null;

            if (Parameter.CustomerOrderHeaderID == Guid.Empty)
            {
                #region Preload data

                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;

                var account = CL1_USR.ORM_USR_Account.Query.Search(Connection, Transaction, new CL1_USR.ORM_USR_Account.Query
                {
                    USR_AccountID = securityTicket.AccountID,
                    IsDeleted     = false,
                    Tenant_RefID  = securityTicket.TenantID
                }).Single();

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

                #endregion

                #region Customer Order Header Creation
                header = new CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_Header
                {
                    ORD_CUO_CustomerOrder_HeaderID = Guid.NewGuid(),
                    Tenant_RefID       = securityTicket.TenantID,
                    Creation_Timestamp = DateTime.Now,
                    CreatedBy_BusinessParticipant_RefID = account.BusinessParticipant_RefID,
                    Current_CustomerOrderStatus_RefID   = orderedStatusID,
                    CustomerOrder_Number         = customerOrderNumber,
                    CustomerOrder_Currency_RefID = cls_Get_DefaultCurrency_for_Tenant.Invoke(Connection, Transaction, securityTicket).Result.CMN_CurrencyID
                };
                header.ProcurementOrderITL  = Guid.Empty.ToString();
                header.TotalValue_BeforeTax = 0.0M;
                #endregion

                #region CustomerOrderStatusHistory
                var statusHistory = new CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_StatusHistory
                {
                    ORD_CUO_CustomerOrder_StatusHistoryID = Guid.NewGuid(),
                    Creation_Timestamp                    = DateTime.Now,
                    Tenant_RefID                          = securityTicket.TenantID,
                    CustomerOrder_Header_RefID            = header.ORD_CUO_CustomerOrder_HeaderID,
                    CustomerOrder_Status_RefID            = orderedStatusID,
                    StatusHistoryComment                  = null,
                    PerformedBy_BusinessParticipant_RefID = account.BusinessParticipant_RefID,
                };
                statusHistory.Save(Connection, Transaction);
                #endregion

                #region Create and Save CustomerInteraction

                var incrCustIntrNumberParam = new P_L2NR_GaIINfUA_1454()
                {
                    GlobalStaticMatchingID = EnumUtils.GetEnumDescription(ENumberRangeUsageAreaType.CustomerInteractionNumber)
                };
                var customerInteractionNumber = cls_Get_and_Increase_IncreasingNumber_for_UsageArea.Invoke(Connection, Transaction, incrCustIntrNumberParam, securityTicket).Result.Current_IncreasingNumber;

                customerInteraction = new ORM_CMN_POS_CustomerInteraction()
                {
                    CMN_POS_CustomerInteractionID = Guid.NewGuid(),
                    Creation_Timestamp            = DateTime.Now,
                    IsCustomerOrderInteraction    = true,
                    CustomerOrderHeader_RefID     = header.ORD_CUO_CustomerOrder_HeaderID,
                    CustomerInteractionNumber     = customerInteractionNumber,
                    DateOfCustomerInteraction     = DateTime.Now,
                    Tenant_RefID = securityTicket.TenantID
                };
                customerInteraction.Save(Connection, Transaction);

                #endregion
            }
            else
            {
                var fetched = header.Load(Connection, Transaction, Parameter.CustomerOrderHeaderID);
                if (fetched.Status != FR_Status.Success || header.ORD_CUO_CustomerOrder_HeaderID != Parameter.CustomerOrderHeaderID)
                {
                    returnValue.ErrorMessage = fetched.ErrorMessage;
                    returnValue.Status       = FR_Status.Error_Internal;
                    returnValue.Result       = null;
                    return(returnValue);
                }

                #region Update Customer Order Total Value
                var positions = CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_Position.Query.Search(Connection, Transaction,
                                                                                            new CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_Position.Query
                {
                    CustomerOrder_Header_RefID = Parameter.CustomerOrderHeaderID,
                    IsDeleted    = false,
                    Tenant_RefID = securityTicket.TenantID
                });
                header.TotalValue_BeforeTax = positions.Sum(x => x.Position_ValueTotal);
                #endregion

                #region Load CustomerInteraction
                customerInteraction = ORM_CMN_POS_CustomerInteraction.Query.Search(
                    Connection,
                    Transaction,
                    new ORM_CMN_POS_CustomerInteraction.Query()
                {
                    CustomerOrderHeader_RefID = header.ORD_CUO_CustomerOrder_HeaderID,
                    Tenant_RefID = securityTicket.TenantID
                }).FirstOrDefault();
                #endregion
            }

            if (Parameter.OrganizationalUnitID != null)
            {
                Guid ucdID = Guid.Empty;

                //var ucd = CL1_CMN.ORM_CMN_UniversalContactDetail.Query.Search(Connection, Transaction,
                //    new CL1_CMN.ORM_CMN_UniversalContactDetail.Query
                //    {
                //        CMN_UniversalContactDetailID = ucdID,
                //        IsDeleted = false,
                //        Tenant_RefID = securityTicket.TenantID
                //    });
                // header.ShippingAddressUCD_RefID =
            }

            header.CustomerOrder_Date = Parameter.CustomerOrderDate;
            header.DeliveryDeadline   = Parameter.DeliveryDeadline;
            header.OrderingCustomer_BusinessParticipant_RefID = Parameter.Customer_BusinessParticipantID;
            header.Save(Connection, Transaction);

            returnValue.Result = new L5CO_COH_1326()
            {
                CustomerOrderHeaderId  = header.ORD_CUO_CustomerOrder_HeaderID,
                CustomerInteractionsId = customerInteraction == null ? Guid.Empty : customerInteraction.CMN_POS_CustomerInteractionID
            };
            return(returnValue);

            #endregion UserCode
        }
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            //Leave UserCode region to enable user code saving
            #region UserCode
            var returnValue = new FR_Guid();

            // Get shopping cart status - Ordered
            var statusOrdered = CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status.Query.Search(Connection, Transaction,
                                                                                         new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status.Query()
            {
                GlobalPropertyMatchingID = DLCore_DBCommons.Utils.EnumUtils.GetEnumDescription(DLCore_DBCommons.APODemand.EShoppingCartStatus.Ordered),
                Tenant_RefID             = securityTicket.TenantID,
                IsDeleted = false
            }).Single();

            var tenant = securityTicket.TenantID;

            #region Find All Shopping Carts in Approved state for TenantID

            var statusApproved = CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status.Query.Search(Connection, Transaction,
                                                                                          new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status.Query
            {
                Tenant_RefID             = securityTicket.TenantID,
                GlobalPropertyMatchingID = DLCore_DBCommons.Utils.EnumUtils.GetEnumDescription(DLCore_DBCommons.APODemand.EShoppingCartStatus.Approved),
                IsDeleted = false
            }).Single();

            var approvedShoppingCarts = CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart.Query.Search(Connection, Transaction,
                                                                                          new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart.Query
            {
                ShoppingCart_CurrentStatus_RefID = statusApproved.ORD_PRC_ShoppingCart_StatusID,
                Tenant_RefID = securityTicket.TenantID,
                IsDeleted    = false
            });

            if (approvedShoppingCarts == null || approvedShoppingCarts.Count() == 0)
            {
                returnValue.Result = Guid.Empty;
                return(returnValue);
            }
            #endregion

            #region Procurement Order
            // Get procurement order status
            var procurementOrderStatus = CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Status.Query.Search(Connection, Transaction,
                                                                                                      new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Status.Query()
            {
                GlobalPropertyMatchingID = DLCore_DBCommons.Utils.EnumUtils.GetEnumDescription(DLCore_DBCommons.APODemand.EProcurementStatus.Active),
                Tenant_RefID             = securityTicket.TenantID,
                IsDeleted = false
            }).Single();

            var account = new CL1_USR.ORM_USR_Account();
            account.Load(Connection, Transaction, securityTicket.AccountID);

            #region

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

            #endregion

            // Create procurement order header
            var procurementOrderHeader = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Header();
            procurementOrderHeader.Tenant_RefID = securityTicket.TenantID;
            procurementOrderHeader.CreatedBy_BusinessParticipant_RefID  = account.BusinessParticipant_RefID;
            procurementOrderHeader.Current_ProcurementOrderStatus_RefID = procurementOrderStatus.ORD_PRC_ProcurementOrder_StatusID;
            procurementOrderHeader.ProcurementOrder_Supplier_RefID      = Guid.Empty;
            procurementOrderHeader.ProcurementOrder_Date   = DateTime.Now;
            procurementOrderHeader.TotalValue_BeforeTax    = 0;
            procurementOrderHeader.ProcurementOrder_Number = procurementNumber;
            procurementOrderHeader.Save(Connection, Transaction);

            // Create procurement order status history
            var procurementOrderStatusHistory = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_StatusHistory();
            procurementOrderStatusHistory.Tenant_RefID = securityTicket.TenantID;
            procurementOrderStatusHistory.ProcurementOrder_Header_RefID = procurementOrderHeader.ORD_PRC_ProcurementOrder_HeaderID;
            procurementOrderStatusHistory.ProcurementOrder_Status_RefID = procurementOrderStatus.ORD_PRC_ProcurementOrder_StatusID;
            procurementOrderStatusHistory.Save(Connection, Transaction);

            // Set return value
            returnValue.Result = procurementOrderHeader.ORD_PRC_ProcurementOrder_HeaderID;
            #endregion

            foreach (var item in approvedShoppingCarts)
            {
                #region Procurement Order Shopping Products

                var param = new P_L5AWSSC_GSPfSC_1650();
                param.ShoppingCartID = item.ORD_PRC_ShoppingCartID;
                var shoppingProducts = cls_Get_ShoppingProducts_for_ShoppingCartID.Invoke(Connection, Transaction, param, securityTicket).Result;

                //when office is deleted but there is ordered items for it
                if (shoppingProducts == null)
                {
                    continue;
                }

                // Create and save procurement order for shopping products
                foreach (var shoppingProduct in shoppingProducts.Products)
                {
                    #region Skip if Product is not good

                    if (shoppingProduct.IsProductCanceled || shoppingProduct.IsProductDeleted)
                    {
                        continue;
                    }

                    #endregion

                    var procurementOrderPosition = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Position();
                    procurementOrderPosition.ORD_PRC_ProcurementOrder_PositionID = Guid.NewGuid();
                    procurementOrderPosition.ProcurementOrder_Header_RefID       = procurementOrderHeader.ORD_PRC_ProcurementOrder_HeaderID;
                    procurementOrderPosition.Position_Quantity                = shoppingProduct.Quantity;
                    procurementOrderPosition.Position_ValuePerUnit            = shoppingProduct.Price;
                    procurementOrderPosition.Position_ValueTotal              = shoppingProduct.Price * (Decimal)shoppingProduct.Quantity;
                    procurementOrderPosition.Position_Unit_RefID              = Guid.Empty;
                    procurementOrderPosition.Position_RequestedDateOfDelivery = new DateTime();
                    procurementOrderPosition.CMN_PRO_Product_RefID            = shoppingProduct.CMN_PRO_Product_RefID;
                    procurementOrderPosition.CMN_PRO_Product_Release_RefID    = shoppingProduct.CMN_PRO_Product_Release_RefID;
                    procurementOrderPosition.CMN_PRO_Product_Variant_RefID    = shoppingProduct.CMN_PRO_Product_Variant_RefID;
                    procurementOrderPosition.Creation_Timestamp               = DateTime.Now;
                    procurementOrderPosition.Tenant_RefID = securityTicket.TenantID;
                    procurementOrderPosition.IsProductReplacementAllowed = shoppingProduct.IsProductReplacementAllowed;
                    procurementOrderPosition.Save(Connection, Transaction);

                    var shoppingCart2ProcurementOrder = new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_2_ProcurementOrderPosition();
                    shoppingCart2ProcurementOrder.AssignmentID = Guid.NewGuid();
                    shoppingCart2ProcurementOrder.ORD_PRC_ShoppingCart_Product_RefID      = shoppingProduct.ORD_PRC_ShoppingCart_ProductID;
                    shoppingCart2ProcurementOrder.ORD_PRC_ProcurementOrder_Position_RefID = procurementOrderPosition.ORD_PRC_ProcurementOrder_PositionID;
                    shoppingCart2ProcurementOrder.Tenant_RefID = securityTicket.TenantID;
                    shoppingCart2ProcurementOrder.Save(Connection, Transaction);

                    procurementOrderHeader.TotalValue_BeforeTax += procurementOrderPosition.Position_ValueTotal;
                }
                #endregion

                #region ShoppingCartNotes

                var notesParam = new P_L5AWSAR_GSCNfSC_1454()
                {
                    ShoppingCartID = item.ORD_PRC_ShoppingCartID
                };
                var scNotes = cls_Get_ShoppingCart_Notes_for_ShoppingCartID.Invoke(Connection, Transaction, notesParam, securityTicket).Result;

                var count = 1;
                foreach (var scNote in scNotes)
                {
                    if (!scNote.IsNoteForProcurementOrder)
                    {
                        continue;
                    }

                    var officeInfo = ORM_ORD_PRC_Office_ShoppingCart.Query.Search(Connection, Transaction, new ORM_ORD_PRC_Office_ShoppingCart.Query()
                    {
                        ORD_PRC_ShoppingCart_RefID = item.ORD_PRC_ShoppingCartID,
                        IsDeleted = false
                    }).Single();

                    var note = new ORM_ORD_PRC_ProcurementOrder_Note();
                    note.ORD_PRC_ProcurementOrder_NoteID         = Guid.NewGuid();
                    note.ORD_PRC_ProcurementOrder_Header_RefID   = procurementOrderHeader.ORD_PRC_ProcurementOrder_HeaderID;
                    note.ORD_PRC_ProcurementOrder_Position_RefID = Guid.Empty;
                    note.CMN_STR_Office_RefID = officeInfo.CMN_STR_Office_RefID;
                    note.Comment             = scNote.Memo_Text;
                    note.Title               = "";
                    note.NotePublishDate     = scNote.UpdatedOn;
                    note.SequenceOrderNumber = count;
                    note.Tenant_RefID        = securityTicket.TenantID;

                    note.Save(Connection, Transaction);

                    count++;
                }

                #endregion

                #region Shopping Cart

                // Change shopping cart status
                item.ShoppingCart_CurrentStatus_RefID = statusOrdered.ORD_PRC_ShoppingCart_StatusID;
                item.IsProcurementOrderCreated        = true;
                item.Save(Connection, Transaction);

                // Create and save new shopping cart history
                var shoppingHistory = new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCartStatus_History();
                shoppingHistory.ORD_PRC_ShoppingCart_RefID        = item.ORD_PRC_ShoppingCartID;
                shoppingHistory.ORD_PRC_ShoppingCart_Status_RefID = statusOrdered.ORD_PRC_ShoppingCart_StatusID;
                shoppingHistory.PerformedBy_Account_RefID         = securityTicket.AccountID;
                shoppingHistory.Tenant_RefID = securityTicket.TenantID;
                shoppingHistory.Save(Connection, Transaction);

                #endregion
            }

            //Save TotalValue_BeforeTax after updates
            procurementOrderHeader.Save(Connection, Transaction);

            return(returnValue);

            #endregion UserCode
        }
コード例 #4
0
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L5CO_CSHfCO_1528 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();

            #region Get CustomerOrderHeader

            var customerOrderHeader = new CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_Header();
            customerOrderHeader.Load(Connection, Transaction, Parameter.CustomerOrderHeaderID);

            #endregion

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

            var shipmentHeader = new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Header();
            shipmentHeader.LOG_SHP_Shipment_HeaderID = Guid.NewGuid();
            shipmentHeader.ShipmentHeader_Number     = shipmentHeaderNumber;
            shipmentHeader.Tenant_RefID = securityTicket.TenantID;
            shipmentHeader.IsPartiallyReadyForPicking = false;
            shipmentHeader.IsReadyForPicking          = false;
            shipmentHeader.HasPickingFinished         = false;
            shipmentHeader.HasPickingStarted          = false;
            shipmentHeader.IsShipped = false;
            shipmentHeader.IsBilled  = false;
            shipmentHeader.IsPartialShippingAllowed           = true;
            shipmentHeader.ShipmentHeader_Currency_RefID      = customerOrderHeader.CustomerOrder_Currency_RefID;
            shipmentHeader.RecipientBusinessParticipant_RefID = customerOrderHeader.OrderingCustomer_BusinessParticipant_RefID;
            shipmentHeader.Shippipng_AddressUCD_RefID         = customerOrderHeader.ShippingAddressUCD_RefID;
            shipmentHeader.Save(Connection, Transaction);

            if (shipmentHeader.Shippipng_AddressUCD_RefID == Guid.Empty)
            {
                var AllAddressForShipmentHeader =
                    cls_Get_AllAddresses_for_ShipmentHeaderID.Invoke(Connection, Transaction,
                                                                     new P_L3SO_GAAfSHI_1612 {
                    ShipmentHeaderID = shipmentHeader.LOG_SHP_Shipment_HeaderID
                },
                                                                     securityTicket).Result.ToList();

                var defaultAddressForOU = AllAddressForShipmentHeader.Where(x => x.hasOrganizationUnit).SingleOrDefault(x => x.IsDefault);
                if (defaultAddressForOU != null)
                {
                    shipmentHeader.Shippipng_AddressUCD_RefID = cls_Save_Address_for_ShipmentHeaderID.Invoke(Connection, Transaction,
                                                                                                             new P_L3SO_SA_f_SHI_1535
                    {
                        LOG_SHP_Shipment_HeaderID = shipmentHeader.LOG_SHP_Shipment_HeaderID,
                        StreetName   = defaultAddressForOU.Street_Name,
                        StreetNumber = defaultAddressForOU.Street_Number,
                        Town         = defaultAddressForOU.Town,
                        ZIP          = defaultAddressForOU.ZIP,
                        IsCompany    = defaultAddressForOU.IsCompany
                    }, securityTicket).Result;
                }
                else
                {
                    var defaultAddressForCustomer =
                        AllAddressForShipmentHeader.Where(x => !x.hasOrganizationUnit && x.IsCompany && x.IsShipping).SingleOrDefault(x => x.IsDefault);
                    if (defaultAddressForCustomer != null)
                    {
                        shipmentHeader.Shippipng_AddressUCD_RefID = cls_Save_Address_for_ShipmentHeaderID.Invoke(Connection, Transaction,
                                                                                                                 new P_L3SO_SA_f_SHI_1535
                        {
                            LOG_SHP_Shipment_HeaderID = shipmentHeader.LOG_SHP_Shipment_HeaderID,
                            StreetName   = defaultAddressForCustomer.Street_Name,
                            StreetNumber = defaultAddressForCustomer.Street_Number,
                            Town         = defaultAddressForCustomer.Town,
                            ZIP          = defaultAddressForCustomer.ZIP,
                            IsCompany    = defaultAddressForCustomer.IsCompany
                        }, securityTicket).Result;
                    }
                    else
                    {
                        var defaultPersonAddress = AllAddressForShipmentHeader.Where(x => !x.IsCompany).SingleOrDefault(x => x.IsDefault);
                        if (defaultPersonAddress != null)
                        {
                            shipmentHeader.Shippipng_AddressUCD_RefID = cls_Save_Address_for_ShipmentHeaderID.Invoke(Connection, Transaction,
                                                                                                                     new P_L3SO_SA_f_SHI_1535
                            {
                                LOG_SHP_Shipment_HeaderID = shipmentHeader.LOG_SHP_Shipment_HeaderID,
                                StreetName   = defaultPersonAddress.Street_Name,
                                StreetNumber = defaultPersonAddress.Street_Number,
                                Town         = defaultPersonAddress.Town,
                                ZIP          = defaultPersonAddress.ZIP,
                                IsCompany    = defaultPersonAddress.IsCompany
                            }, securityTicket).Result;
                        }
                    }
                }
            }



            var shipmentToCustomerOrderHeader = new CL1_LOG_SHP.ORM_LOG_SHP_ShipmentHeader_2_CustomerOrderHeader();
            shipmentToCustomerOrderHeader.ORD_CUO_CustomerOrder_Header_RefID = Parameter.CustomerOrderHeaderID;
            shipmentToCustomerOrderHeader.LOG_SHP_Shipment_Header_RefID      = shipmentHeader.LOG_SHP_Shipment_HeaderID;
            shipmentToCustomerOrderHeader.Tenant_RefID = securityTicket.TenantID;
            shipmentToCustomerOrderHeader.Save(Connection, Transaction);

            #region Status

            #region Get Current Account

            var account = new CL1_USR.ORM_USR_Account();
            account.Load(Connection, Transaction, securityTicket.AccountID);

            #endregion

            var statusCreated = CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Status.Query.Search(Connection, Transaction,
                                                                                     new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Status.Query()
            {
                GlobalPropertyMatchingID = EnumUtils.GetEnumDescription(EShipmentStatus.Created),
                Tenant_RefID             = securityTicket.TenantID,
                IsDeleted = false
            }).Single();

            var shipmentStatusHistory = new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_StatusHistory();
            shipmentStatusHistory.LOG_SHP_Shipment_Header_RefID         = shipmentHeader.LOG_SHP_Shipment_HeaderID;
            shipmentStatusHistory.LOG_SHP_Shipment_Status_RefID         = statusCreated.LOG_SHP_Shipment_StatusID;
            shipmentStatusHistory.PerformedBy_BusinessParticipant_RefID = account.BusinessParticipant_RefID;
            shipmentStatusHistory.Tenant_RefID = (account == null) ? Guid.Empty : account.Tenant_RefID;
            shipmentStatusHistory.Save(Connection, Transaction);

            #endregion

            returnValue.Result = shipmentHeader.LOG_SHP_Shipment_HeaderID;
            return(returnValue);

            #endregion UserCode
        }
コード例 #5
0
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L5PO_CED_1410 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();
            //Put your code here

            List <Guid> positionsForCreating = new List <Guid>();
            Guid        headerID             = new Guid();

            var procurementHeader = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Header();
            procurementHeader.Load(Connection, Transaction, Parameter.ProcurementHeaderID);

            if (procurementHeader == null)
            {
                throw new Exception("wrong procurment header!");
            }

            #region Update Procurement Order

            var newProcurementOrderStatusID = CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Status.Query.Search(Connection, Transaction,
                                                                                                           new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Status.Query()
            {
                GlobalPropertyMatchingID = DLCore_DBCommons.Utils.EnumUtils.GetEnumDescription(EProcurementStatus.Ordered),
                Tenant_RefID             = securityTicket.TenantID,
                IsDeleted = false
            }).Single().ORD_PRC_ProcurementOrder_StatusID;

            procurementHeader.Current_ProcurementOrderStatus_RefID = newProcurementOrderStatusID;
            procurementHeader.Save(Connection, Transaction);

            // Create procurement order status history
            var procurementOrderStatusHistory = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_StatusHistory();
            procurementOrderStatusHistory.Tenant_RefID = securityTicket.TenantID;
            procurementOrderStatusHistory.ProcurementOrder_Header_RefID = procurementHeader.ORD_PRC_ProcurementOrder_HeaderID;
            procurementOrderStatusHistory.ProcurementOrder_Status_RefID = newProcurementOrderStatusID;
            procurementOrderStatusHistory.StatusHistoryComment          = "";
            procurementOrderStatusHistory.Save(Connection, Transaction);

            #endregion

            var procurementPositionsQuery = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Position.Query();
            procurementPositionsQuery.ProcurementOrder_Header_RefID = Parameter.ProcurementHeaderID;
            procurementPositionsQuery.Tenant_RefID = securityTicket.TenantID;
            procurementPositionsQuery.IsDeleted    = false;
            var foundProcurementPositions = CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Position.Query.Search(Connection, Transaction, procurementPositionsQuery).ToList();

            //positionIDs
            var positionIDs = foundProcurementPositions.Select(x => x.ORD_PRC_ProcurementOrder_PositionID);

            //find expected delivery data if exist
            P_L5PO_GEDfPOP_1132 expDeliveryParam = new P_L5PO_GEDfPOP_1132();
            expDeliveryParam.ProcurementOrderPositions = positionIDs.ToArray();
            var expectedDeliveries = cls_Get_ExpectedDeliveries_for_ProcurementOrderPositions.Invoke(Connection, Transaction, expDeliveryParam, securityTicket).Result;
            CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Header expectedDeliveryHeader = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Header();

            if (expectedDeliveries != null && expectedDeliveries.Length > 0)
            {
                expectedDeliveryHeader = new ORM_ORD_PRC_ExpectedDelivery_Header();
                expectedDeliveryHeader.Load(Connection, Transaction, expectedDeliveries.First().ORD_PRC_ExpectedDelivery_HeaderID);
                expectedDeliveryHeader.ExpectedDeliveryDate = Parameter.ExpectedDeliveryDate;
                expectedDeliveryHeader.Save(Connection, Transaction);

                headerID = expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID;

                foreach (var item in expectedDeliveries)
                {
                    if (!positionIDs.Contains(item.ORD_PRC_ProcurementOrder_Position_RefID))
                    {
                        positionsForCreating.Add(item.ORD_PRC_ProcurementOrder_Position_RefID);
                    }
                }
            }
            else
            {
                positionsForCreating.AddRange(positionIDs);
                //napraviti header

                expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID = Guid.NewGuid();
                expectedDeliveryHeader.ExpectedDeliveryHeaderITL         = expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID.ToString();

                //finding global property matchin id from number ranges for expected delivery
                var expectedDeliveryNumberParam = new CL2_NumberRange.Complex.Retrieval.P_L2NR_GaIINfUA_1454();
                expectedDeliveryNumberParam.GlobalStaticMatchingID = DLCore_DBCommons.Utils.EnumUtils.
                                                                     GetEnumDescription(DLCore_DBCommons.APODemand.ENumberRangeUsageAreaType.ExpectedDeliveryNumber);

                expectedDeliveryHeader.ExpectedDeliveryNumber = CL2_NumberRange.Complex.Retrieval.cls_Get_and_Increase_IncreasingNumber_for_UsageArea.
                                                                Invoke(Connection, Transaction, expectedDeliveryNumberParam, securityTicket).Result.Current_IncreasingNumber;
                expectedDeliveryHeader.ExpectedDeliveryDate    = Parameter.ExpectedDeliveryDate;
                expectedDeliveryHeader.LOG_WRH_Warehouse_RefID = Guid.Empty;
                expectedDeliveryHeader.IsDeleted                 = false;
                expectedDeliveryHeader.Tenant_RefID              = securityTicket.TenantID;
                expectedDeliveryHeader.IsDeliveryOpen            = true;
                expectedDeliveryHeader.IsDeliveryManuallyCreated = true;

                expectedDeliveryHeader.Save(Connection, Transaction);

                headerID = expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID;
            }


            #region Get receiptHeader or create it if don't exist

            var queryProcurement = new CL1_LOG_RCP.ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader.Query()
            {
                ORD_PRO_ProcurementOrder_Header_RefID = Parameter.ProcurementHeaderID,
                Tenant_RefID = securityTicket.TenantID,
                IsDeleted    = false
            };
            var receiptToProcurementHeader = CL1_LOG_RCP.ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader.Query.Search(Connection, Transaction, queryProcurement).SingleOrDefault();

            var  receiptHeader   = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Header();
            Guid receiptHeaderID = Guid.Empty;
            if (receiptToProcurementHeader == null)
            {
                var incrNumberParam = new P_L2NR_GaIINfUA_1454()
                {
                    GlobalStaticMatchingID = EnumUtils.GetEnumDescription(ENumberRangeUsageAreaType.StockReceiptNumber)
                };
                var receiptNumber = cls_Get_and_Increase_IncreasingNumber_for_UsageArea.Invoke(Connection, Transaction, incrNumberParam, securityTicket).Result.Current_IncreasingNumber;

                receiptHeader = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Header();
                receiptHeader.ReceiptNumber = receiptNumber;
                receiptHeader.ExpectedDeliveryHeader_RefID = expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID;
                receiptHeader.ProvidingSupplier_RefID      = procurementHeader.ProcurementOrder_Supplier_RefID;
                receiptHeader.LOG_RCP_Receipt_HeaderID     = Guid.NewGuid();
                receiptHeader.Creation_Timestamp           = DateTime.Now;
                receiptHeader.ReceiptHeaderITL             = receiptHeader.LOG_RCP_Receipt_HeaderID.ToString();
                receiptHeader.IsTakenIntoStock             = false;
                receiptHeader.Tenant_RefID = securityTicket.TenantID;
                receiptHeader.Save(Connection, Transaction);

                receiptHeaderID = receiptHeader.LOG_RCP_Receipt_HeaderID;

                var receipt2sProcurementHeader = new CL1_LOG_RCP.ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader();
                receipt2sProcurementHeader.LOG_RCP_Receipt_Header_RefID          = receiptHeaderID;
                receipt2sProcurementHeader.ORD_PRO_ProcurementOrder_Header_RefID = procurementHeader.ORD_PRC_ProcurementOrder_HeaderID;
                receipt2sProcurementHeader.Tenant_RefID       = securityTicket.TenantID;
                receipt2sProcurementHeader.IsDeleted          = false;
                receipt2sProcurementHeader.Creation_Timestamp = DateTime.Now;
                receipt2sProcurementHeader.Save(Connection, Transaction);
            }
            else
            {
                receiptHeaderID = receiptToProcurementHeader.LOG_RCP_Receipt_Header_RefID;
            }

            var receiptPositions = CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position.Query.Search(Connection, Transaction,
                                                                                         new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position.Query
            {
                Tenant_RefID         = securityTicket.TenantID,
                IsDeleted            = false,
                Receipt_Header_RefID = receiptHeaderID
            });


            #endregion

            foreach (var position in foundProcurementPositions)
            {
                #region Expected Delivery
                CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Position deliveryPosition = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Position();
                deliveryPosition.ORD_PRC_ExpectedDelivery_PositionID = Guid.NewGuid();
                deliveryPosition.AlreadyReceivedQuantityOfDelivery   = 0;
                deliveryPosition.ExpectedDeliveryPositionITL         = deliveryPosition.ORD_PRC_ExpectedDelivery_PositionID.ToString();
                deliveryPosition.TotalExpectedQuantity          = position.Position_Quantity;
                deliveryPosition.ORD_PRC_ExpectedDelivery_RefID = headerID;
                deliveryPosition.Tenant_RefID       = securityTicket.TenantID;
                deliveryPosition.IsDeleted          = false;
                deliveryPosition.Creation_Timestamp = DateTime.Now;
                deliveryPosition.Save(Connection, Transaction);

                CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_2_ProcurementOrderPosition assignment = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_2_ProcurementOrderPosition();
                assignment.AssignmentID = Guid.NewGuid();
                assignment.ORD_PRC_ProcurementOrder_Position_RefID      = position.ORD_PRC_ProcurementOrder_PositionID;
                assignment.ORD_PRC_ExpectedDelivery_Position_RefID      = deliveryPosition.ORD_PRC_ExpectedDelivery_PositionID;
                assignment.AssignedQuantityFromProcurementOrderPosition = position.Position_Quantity;
                assignment.Tenant_RefID       = securityTicket.TenantID;
                assignment.IsDeleted          = false;
                assignment.Creation_Timestamp = DateTime.Now;
                assignment.Save(Connection, Transaction);

                #endregion

                #region Receipt Positions
                var receiptPosition = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position();

                if (receiptPositions.Count == 0)
                {
                    // create new position
                    receiptPosition.LOG_RCP_Receipt_PositionID = Guid.NewGuid();
                    receiptPosition.Creation_Timestamp         = DateTime.Now;
                    receiptPosition.Tenant_RefID                  = securityTicket.TenantID;
                    receiptPosition.ReceiptPositionITL            = receiptPosition.LOG_RCP_Receipt_PositionID.ToString();
                    receiptPosition.Receipt_Header_RefID          = receiptHeaderID;
                    receiptPosition.ReceiptPosition_Product_RefID = position.CMN_PRO_Product_RefID;
                    receiptPosition.TotalQuantityFreeOfCharge     = 0.0;
                    receiptPosition.TotalQuantityTakenIntoStock   = 0.0;
                    receiptPosition.ExpectedPositionPrice         = position.Position_ValuePerUnit;
                    receiptPosition.Save(Connection, Transaction);


                    var receiptPosition2procurementorderposition = new CL1_LOG_RCP.ORM_LOG_RCP_ReceiptPosition_2_ProcurementOrderPosition();
                    receiptPosition2procurementorderposition.AssignmentID = Guid.NewGuid();
                    receiptPosition2procurementorderposition.LOG_RCP_Receipt_Position_RefID          = receiptPosition.LOG_RCP_Receipt_PositionID;
                    receiptPosition2procurementorderposition.ORD_PRO_ProcurementOrder_Position_RefID = position.ORD_PRC_ProcurementOrder_PositionID;
                    receiptPosition2procurementorderposition.Tenant_RefID       = securityTicket.TenantID;
                    receiptPosition2procurementorderposition.Creation_Timestamp = DateTime.Now;
                    receiptPosition2procurementorderposition.IsDeleted          = false;
                    receiptPosition2procurementorderposition.Save(Connection, Transaction);
                }



                #endregion

                #region Quality Control Items
                var qualityControlItem = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position_QualityControlItem();
                if (receiptPositions.Count == 0)
                {
                    qualityControlItem.LOG_RCP_Receipt_Position_QualityControlItem = Guid.NewGuid();
                    qualityControlItem.ReceiptPositionCountedItemITL = qualityControlItem.LOG_RCP_Receipt_Position_QualityControlItem.ToString();
                    qualityControlItem.Creation_Timestamp            = DateTime.Now;
                    qualityControlItem.Tenant_RefID           = securityTicket.TenantID;
                    qualityControlItem.Receipt_Position_RefID = receiptPosition.LOG_RCP_Receipt_PositionID;
                }
                else
                {
                    var query = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position_QualityControlItem.Query()
                    {
                        Receipt_Position_RefID = receiptPosition.LOG_RCP_Receipt_PositionID,
                        Tenant_RefID           = securityTicket.TenantID,
                        IsDeleted = false
                    };

                    qualityControlItem = CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position_QualityControlItem.Query.Search(Connection, Transaction, query).Single();
                }
                //qualityControlItem.BatchNumber = position.Position_OrdinalNumber;
                //qualityControlItem.ExpiryDate = position.date
                qualityControlItem.Quantity = position.Position_Quantity;
                qualityControlItem.Save(Connection, Transaction);

                #endregion

                #region Forwarding Instruction

                var forwardingInstruction = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Position_ForwardingInstruction();
                if (receiptPositions.Count == 0)
                {
                    #region Create new

                    var businessParticipant = CL1_CMN_BPT.ORM_CMN_BPT_BusinessParticipant.Query.Search(Connection, Transaction,
                                                                                                       new CL1_CMN_BPT.ORM_CMN_BPT_BusinessParticipant.Query()
                    {
                        IfTenant_Tenant_RefID = securityTicket.TenantID,
                        IsDeleted             = false
                    }).Single();

                    forwardingInstruction.ORD_PRC_ProcurementOrder_Position_ForwardingInstructionID = Guid.NewGuid();
                    forwardingInstruction.Creation_Timestamp = DateTime.Now;
                    forwardingInstruction.Tenant_RefID       = securityTicket.TenantID;
                    forwardingInstruction.ProcurementOrder_Position_RefID     = position.ORD_PRC_ProcurementOrder_PositionID;
                    forwardingInstruction.ForwardTo_BusinessParticipant_RefID = businessParticipant.CMN_BPT_BusinessParticipantID;

                    #endregion
                }
                else
                {
                    #region Load Existing

                    var query = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Position_ForwardingInstruction.Query()
                    {
                        ProcurementOrder_Position_RefID = position.ORD_PRC_ProcurementOrder_PositionID,
                        IsDeleted    = false,
                        Tenant_RefID = securityTicket.TenantID
                    };
                    forwardingInstruction = CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Position_ForwardingInstruction.Query.Search(Connection, Transaction, query).Single();

                    #endregion
                }

                forwardingInstruction.QuantityToForward = position.Position_Quantity;
                forwardingInstruction.Save(Connection, Transaction);

                #endregion
            }

            //returning created expected delivery header id
            returnValue.Result = headerID;

            return(returnValue);

            #endregion UserCode
        }
コード例 #6
0
        protected static FR_L5SO_SSHwP_1030 Execute(DbConnection Connection, DbTransaction Transaction, P_L5SO_SSHwP_1030 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_L5SO_SSHwP_1030();
            returnValue.Result = new L5SO_SSHwP_1030();

            var oldShipmentHeader = new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Header();
            oldShipmentHeader.Load(Connection, Transaction, Parameter.HeaderID);

            var oldPositions = CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Position.Query.Search(Connection, Transaction,
                                                                                      new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Position.Query
            {
                LOG_SHP_Shipment_Header_RefID = Parameter.HeaderID,
                IsDeleted    = false,
                Tenant_RefID = securityTicket.TenantID
            });

            bool isThereAnyDifference = false;
            foreach (var item in Parameter.Positions)
            {
                var oldPosition = oldPositions.Single(x => x.LOG_SHP_Shipment_PositionID == item.PositionID);

                if (oldPosition.QuantityToShip > item.PickingQuantity)
                {
                    isThereAnyDifference = true;
                    break;
                }
            }

            if (!isThereAnyDifference)
            {
                throw new ShipmentHeaderException(ResultMessage.SplitShipment_ThereIsNoDifferenceBetweenNewAndOldOne);
            }

            #region Create New ShippmentHeader

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


            var newShipmentHeader = new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Header();
            newShipmentHeader.LOG_SHP_Shipment_HeaderID = Guid.NewGuid();
            newShipmentHeader.ShipmentHeader_Number     = shipmentOrderNumber;
            newShipmentHeader.Tenant_RefID               = securityTicket.TenantID;
            newShipmentHeader.Creation_Timestamp         = DateTime.Now;
            newShipmentHeader.IsPartialShippingAllowed   = oldShipmentHeader.IsPartialShippingAllowed;
            newShipmentHeader.Shippipng_AddressUCD_RefID = oldShipmentHeader.Shippipng_AddressUCD_RefID;
            newShipmentHeader.Source_Warehouse_RefID     = oldShipmentHeader.Source_Warehouse_RefID;
            newShipmentHeader.ShipmentPriority           = oldShipmentHeader.ShipmentPriority;
            newShipmentHeader.ShipmentType_RefID         = oldShipmentHeader.ShipmentType_RefID;

            newShipmentHeader.RecipientBusinessParticipant_RefID = oldShipmentHeader.RecipientBusinessParticipant_RefID;

            newShipmentHeader.Save(Connection, Transaction);

            var assignmentQuery = new CL1_LOG_SHP.ORM_LOG_SHP_ShipmentHeader_2_CustomerOrderHeader.Query();
            assignmentQuery.LOG_SHP_Shipment_Header_RefID = oldShipmentHeader.LOG_SHP_Shipment_HeaderID;
            assignmentQuery.IsDeleted    = false;
            assignmentQuery.Tenant_RefID = securityTicket.TenantID;

            var oldAssignment = CL1_LOG_SHP.ORM_LOG_SHP_ShipmentHeader_2_CustomerOrderHeader.Query.Search(Connection, Transaction, assignmentQuery).Single();

            var shipmentToCustomerOrderHeader = new CL1_LOG_SHP.ORM_LOG_SHP_ShipmentHeader_2_CustomerOrderHeader();
            shipmentToCustomerOrderHeader.ORD_CUO_CustomerOrder_Header_RefID = oldAssignment.ORD_CUO_CustomerOrder_Header_RefID;
            shipmentToCustomerOrderHeader.LOG_SHP_Shipment_Header_RefID      = newShipmentHeader.LOG_SHP_Shipment_HeaderID;
            shipmentToCustomerOrderHeader.Tenant_RefID       = securityTicket.TenantID;
            shipmentToCustomerOrderHeader.Creation_Timestamp = DateTime.Now;
            shipmentToCustomerOrderHeader.Save(Connection, Transaction);

            #region Status

            var statusCreated = CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Status.Query.Search(Connection, Transaction,
                                                                                     new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Status.Query()
            {
                GlobalPropertyMatchingID = EnumUtils.GetEnumDescription(EShipmentStatus.Created),
                Tenant_RefID             = securityTicket.TenantID,
                IsDeleted = false
            }).Single();

            var account = new CL1_USR.ORM_USR_Account();
            account.Load(Connection, Transaction, securityTicket.AccountID);

            var shipmentStatusHistory = new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_StatusHistory();
            shipmentStatusHistory.LOG_SHP_Shipment_Header_RefID         = newShipmentHeader.LOG_SHP_Shipment_HeaderID;
            shipmentStatusHistory.LOG_SHP_Shipment_Status_RefID         = statusCreated.LOG_SHP_Shipment_StatusID;
            shipmentStatusHistory.PerformedBy_BusinessParticipant_RefID = account.BusinessParticipant_RefID;
            shipmentStatusHistory.Tenant_RefID = account.Tenant_RefID;
            shipmentStatusHistory.Save(Connection, Transaction);

            #endregion

            #endregion

            var param = new P_L5SO_GSPwPaSfSH_1141()
            {
                ShippmentHeaderID = Parameter.HeaderID,
                LanguageID        = Parameter.LanguageID
            };
            var splittingPositions = cls_Get_ShipmentPositions_with_Prices_and_Stock_for_ShipmentHeaderID.Invoke(Connection, Transaction, param, securityTicket).Result;

            decimal totalAmountForOldHeader = 0;
            decimal totalAmountForNewHeader = 0;
            foreach (var item in Parameter.Positions)
            {
                var oldPosition = oldPositions.Single(x => x.LOG_SHP_Shipment_PositionID == item.PositionID);

                var newQuantity       = oldPosition.QuantityToShip - item.PickingQuantity;
                var positionToSplit   = splittingPositions.Single(x => x.ShipmentPositionID == item.PositionID);
                var availableQuantity = positionToSplit.QuantityAvailable;

                decimal unitPrice = oldPosition.ShipmentPosition_PricePerUnitValueWithoutTax;

                if (item.PickingQuantity > availableQuantity + positionToSplit.ReservedQuantity)
                {
                    throw new ShipmentHeaderException(ResultMessage.SplitShipment_FreeQuantityNotAvailable);
                }

                if (newQuantity > 0)
                {
                    var newPosition = new CL1_LOG_SHP.ORM_LOG_SHP_Shipment_Position
                    {
                        LOG_SHP_Shipment_PositionID   = Guid.NewGuid(),
                        LOG_SHP_Shipment_Header_RefID = newShipmentHeader.LOG_SHP_Shipment_HeaderID,
                        Tenant_RefID          = securityTicket.TenantID,
                        CMN_PRO_Product_RefID = oldPosition.CMN_PRO_Product_RefID,
                        QuantityToShip        = newQuantity,
                        ShipmentPosition_PricePerUnitValueWithoutTax = unitPrice,
                        ShipmentPosition_ValueWithoutTax             = unitPrice * (decimal)newQuantity
                    };
                    newPosition.Save(Connection, Transaction);

                    totalAmountForNewHeader += newPosition.ShipmentPosition_ValueWithoutTax;

                    var oldAssignmentCustomerOrderToShipmentPosition = CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition.Query.Search(Connection, Transaction,
                                                                                                                                                      new CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition.Query
                    {
                        LOG_SHP_Shipment_Position_RefID = oldPosition.LOG_SHP_Shipment_PositionID,
                        IsDeleted    = false,
                        Tenant_RefID = securityTicket.TenantID
                    }).Single();

                    var customerOrder2ShipmentPosition = new CL1_ORD_CUO.ORM_ORD_CUO_CustomerOrder_Position_2_ShipmentPosition
                    {
                        AssignmentID       = Guid.NewGuid(),
                        Creation_Timestamp = DateTime.Now,
                        Tenant_RefID       = securityTicket.TenantID,
                        IsDeleted          = false,
                        LOG_SHP_Shipment_Position_RefID      = newPosition.LOG_SHP_Shipment_PositionID,
                        ORD_CUO_CustomerOrder_Position_RefID = oldAssignmentCustomerOrderToShipmentPosition.ORD_CUO_CustomerOrder_Position_RefID,
                        CMN_BPT_CTM_OrganizationalUnit_RefID = oldAssignmentCustomerOrderToShipmentPosition.CMN_BPT_CTM_OrganizationalUnit_RefID
                    };
                    customerOrder2ShipmentPosition.Save(Connection, Transaction);
                }

                oldPosition.QuantityToShip = item.PickingQuantity;
                oldPosition.ShipmentPosition_ValueWithoutTax = unitPrice * (decimal)item.PickingQuantity;
                oldPosition.IsDeleted = (oldPosition.QuantityToShip == 0);

                oldPosition.Save(Connection, Transaction);

                totalAmountForOldHeader += oldPosition.ShipmentPosition_ValueWithoutTax;
            }

            oldShipmentHeader.ShipmentHeader_ValueWithoutTax = totalAmountForOldHeader;
            oldShipmentHeader.Save(Connection, Transaction);

            newShipmentHeader.ShipmentHeader_ValueWithoutTax = totalAmountForNewHeader;
            newShipmentHeader.Save(Connection, Transaction);

            // set return value to ok and new header's id
            returnValue.Result.NewHeaderID = newShipmentHeader.LOG_SHP_Shipment_HeaderID;
            returnValue.Result.Message     = CL5_APOLogistic_ShippingOrder.Utils.ResultMessage.SplitShipment_OK;

            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
        }
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L5SR_CEDfUP_1438 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();

            #region Save Header

            #region Expected Delivery Header

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

            var expectedDeliveryHeader = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Header();
            expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID = Guid.NewGuid();
            expectedDeliveryHeader.ExpectedDeliveryNumber            = expectedDeliveryNumber;
            expectedDeliveryHeader.IsDeliveryOpen            = true;
            expectedDeliveryHeader.IsDeliveryClosed          = false;
            expectedDeliveryHeader.ExpectedDeliveryHeaderITL = expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID.ToString();
            expectedDeliveryHeader.ExpectedDeliveryDate      = Parameter.ExpectedDeliveryDate;
            expectedDeliveryHeader.Tenant_RefID       = securityTicket.TenantID;
            expectedDeliveryHeader.Creation_Timestamp = DateTime.Now;
            expectedDeliveryHeader.Save(Connection, Transaction);

            #endregion

            #region Receipt Header

            var oldReceiptHeader = new ORM_LOG_RCP_Receipt_Header();
            oldReceiptHeader.Load(Connection, Transaction, Parameter.ReceiptHeaderID);

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

            var receiptHeader = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Header();
            receiptHeader.ReceiptNumber                = receiptNumber;
            receiptHeader.LOG_RCP_Receipt_HeaderID     = Guid.NewGuid();
            receiptHeader.Creation_Timestamp           = DateTime.Now;
            receiptHeader.Tenant_RefID                 = securityTicket.TenantID;
            receiptHeader.ReceiptHeaderITL             = receiptHeader.LOG_RCP_Receipt_HeaderID.ToString();
            receiptHeader.IsTakenIntoStock             = false;
            receiptHeader.ProvidingSupplier_RefID      = oldReceiptHeader.ProvidingSupplier_RefID;
            receiptHeader.ExpectedDeliveryHeader_RefID = expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID;
            receiptHeader.Save(Connection, Transaction);

            #endregion Receipt Header

            #region Procurement Order

            var oldReceiptToProcurement = ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader.Query.Search(Connection, Transaction, new ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader.Query()
            {
                LOG_RCP_Receipt_Header_RefID = Parameter.ReceiptHeaderID,
                IsDeleted = false
            }).First();

            var receiptToProcurement = new CL1_LOG_RCP.ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader();
            receiptToProcurement.AssignmentID                          = Guid.NewGuid();
            receiptToProcurement.Creation_Timestamp                    = DateTime.Now;
            receiptToProcurement.Tenant_RefID                          = securityTicket.TenantID;
            receiptToProcurement.LOG_RCP_Receipt_Header_RefID          = receiptHeader.LOG_RCP_Receipt_HeaderID;
            receiptToProcurement.ORD_PRO_ProcurementOrder_Header_RefID = oldReceiptToProcurement.ORD_PRO_ProcurementOrder_Header_RefID;
            receiptToProcurement.Save(Connection, Transaction);

            #endregion

            #endregion

            #region Save Positions

            P_L5SR_GSRPfH_1544 param = new P_L5SR_GSRPfH_1544();
            param.ReceiptHeaderID = Parameter.ReceiptHeaderID;
            var stockReceiptsPositions = cls_Get_StockReceiptsPositions_for_ReceiptHeaderID.Invoke(Connection, Transaction, param, securityTicket).Result;

            foreach (var positionParam in Parameter.ReceiptPositions)
            {
                var item = stockReceiptsPositions.Single(i => i.OrderPosition.LOG_RCP_Receipt_PositionID == positionParam.ReceipPositionID);

                #region Receipt Position

                var receiptPosition = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position();
                receiptPosition.LOG_RCP_Receipt_PositionID    = Guid.NewGuid();
                receiptPosition.Receipt_Header_RefID          = receiptHeader.LOG_RCP_Receipt_HeaderID;
                receiptPosition.ReceiptPosition_Product_RefID = item.OrderPosition.ReceiptPosition_Product_RefID;
                receiptPosition.TotalQuantityFreeOfCharge     = 0.0;
                receiptPosition.TotalQuantityTakenIntoStock   = 0.0;
                receiptPosition.ExpectedPositionPrice         = item.OrderPosition.Receipt_ExpectedPositionPrice;
                receiptPosition.Creation_Timestamp            = DateTime.Now;
                receiptPosition.Tenant_RefID = securityTicket.TenantID;
                receiptPosition.Save(Connection, Transaction);

                #endregion

                #region ReceiptPosition to ProcurementOrderPosition

                var receiptToProcurementPosition = new CL1_LOG_RCP.ORM_LOG_RCP_ReceiptPosition_2_ProcurementOrderPosition();
                receiptToProcurementPosition.AssignmentID = Guid.NewGuid();
                receiptToProcurementPosition.ORD_PRO_ProcurementOrder_Position_RefID      = item.OrderPosition.ORD_PRC_ProcurementOrder_PositionID;
                receiptToProcurementPosition.LOG_RCP_Receipt_Position_RefID               = receiptPosition.LOG_RCP_Receipt_PositionID;
                receiptToProcurementPosition.ReceivedQuantityFromProcurementOrderPosition = positionParam.ExpectedQuantity;
                receiptToProcurementPosition.Creation_Timestamp = DateTime.Now;
                receiptToProcurementPosition.Tenant_RefID       = securityTicket.TenantID;
                receiptToProcurementPosition.Save(Connection, Transaction);

                #endregion

                #region Expected Delivery

                var expectedDeliveryPosition = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Position();
                expectedDeliveryPosition.ORD_PRC_ExpectedDelivery_PositionID = Guid.NewGuid();
                expectedDeliveryPosition.ORD_PRC_ExpectedDelivery_RefID      = receiptHeader.ExpectedDeliveryHeader_RefID;
                expectedDeliveryPosition.TotalExpectedQuantity = positionParam.ExpectedQuantity;
                expectedDeliveryPosition.Creation_Timestamp    = DateTime.Now;
                expectedDeliveryPosition.Tenant_RefID          = securityTicket.TenantID;
                expectedDeliveryPosition.Save(Connection, Transaction);

                var expectedDeliveryToProcurementOrderPosition = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_2_ProcurementOrderPosition();
                expectedDeliveryToProcurementOrderPosition.AssignmentID = Guid.NewGuid();
                expectedDeliveryToProcurementOrderPosition.ORD_PRC_ExpectedDelivery_Position_RefID      = expectedDeliveryPosition.ORD_PRC_ExpectedDelivery_PositionID;
                expectedDeliveryToProcurementOrderPosition.ORD_PRC_ProcurementOrder_Position_RefID      = item.OrderPosition.ORD_PRC_ProcurementOrder_PositionID;
                expectedDeliveryToProcurementOrderPosition.AssignedQuantityFromProcurementOrderPosition = positionParam.ExpectedQuantity;
                expectedDeliveryToProcurementOrderPosition.Creation_Timestamp = DateTime.Now;
                expectedDeliveryToProcurementOrderPosition.Tenant_RefID       = securityTicket.TenantID;
                expectedDeliveryToProcurementOrderPosition.Save(Connection, Transaction);

                #endregion

                #region Quality Control Items

                var oldQualityControlItem = ORM_LOG_RCP_Receipt_Position_QualityControlItem.Query.Search(Connection, Transaction, new ORM_LOG_RCP_Receipt_Position_QualityControlItem.Query()
                {
                    Receipt_Position_RefID = item.OrderPosition.LOG_RCP_Receipt_PositionID,
                    IsDeleted = false
                }).First();

                var qualityControlItem = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position_QualityControlItem();
                qualityControlItem.LOG_RCP_Receipt_Position_QualityControlItem = Guid.NewGuid();
                qualityControlItem.ReceiptPositionCountedItemITL = qualityControlItem.LOG_RCP_Receipt_Position_QualityControlItem.ToString();
                qualityControlItem.Receipt_Position_RefID        = receiptPosition.LOG_RCP_Receipt_PositionID;
                qualityControlItem.BatchNumber        = oldQualityControlItem.BatchNumber;
                qualityControlItem.ExpiryDate         = oldQualityControlItem.ExpiryDate;
                qualityControlItem.Quantity           = positionParam.ExpectedQuantity;
                qualityControlItem.Creation_Timestamp = DateTime.Now;
                qualityControlItem.Tenant_RefID       = securityTicket.TenantID;
                qualityControlItem.Save(Connection, Transaction);

                #endregion

                #region Forwarding Instruction

                var oldForwardingInstruction = ORM_ORD_PRC_ProcurementOrder_Position_ForwardingInstruction.Query.Search(Connection, Transaction, new ORM_ORD_PRC_ProcurementOrder_Position_ForwardingInstruction.Query()
                {
                    ProcurementOrder_Position_RefID = item.OrderPosition.ORD_PRC_ProcurementOrder_PositionID,
                    IsDeleted = false
                }).First();

                var forwardingInstruction = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Position_ForwardingInstruction();
                forwardingInstruction.ORD_PRC_ProcurementOrder_Position_ForwardingInstructionID = Guid.NewGuid();
                forwardingInstruction.ProcurementOrder_Position_RefID     = item.OrderPosition.ORD_PRC_ProcurementOrder_PositionID;
                forwardingInstruction.ForwardTo_BusinessParticipant_RefID = oldForwardingInstruction.ForwardTo_BusinessParticipant_RefID;
                forwardingInstruction.QuantityToForward  = positionParam.ExpectedQuantity;
                forwardingInstruction.Creation_Timestamp = DateTime.Now;
                forwardingInstruction.Tenant_RefID       = securityTicket.TenantID;
                forwardingInstruction.Save(Connection, Transaction);

                #endregion
            }

            #endregion

            return(returnValue);

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

            #region Preload Data
            var CurrencyID = CL2_Currency.Atomic.Retrieval.cls_Get_DefaultCurrency_for_Tenant.Invoke(Connection, Transaction, securityTicket).Result.CMN_CurrencyID;

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


            var account = CL1_USR.ORM_USR_Account.Query.Search(Connection, Transaction,
                                                               new CL1_USR.ORM_USR_Account.Query
            {
                USR_AccountID = securityTicket.AccountID,
                IsDeleted     = false,
                Tenant_RefID  = securityTicket.TenantID
            }).Single();
            #endregion

            #region Create Receipt Header
            var receiptHeader = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Header
            {
                LOG_RCP_Receipt_HeaderID            = Guid.NewGuid(),
                ReceiptNumber                       = stockReceiptNumber,
                ReceiptHeaderCurrency_RefID         = CurrencyID,
                DeliveringBusinessParticipant_RefID = Parameter.BusinessParticipantID,
                // Quality control
                IsQualityControlPerformed               = true,
                QualityControlPerformed_AtDate          = DateTime.Now,
                QualityControlPerformed_ByAccount_RefID = securityTicket.AccountID,
                // Price conditions
                IsPriceConditionsManuallyCleared               = true,
                PriceConditionsManuallyCleared_AtDate          = DateTime.Now,
                PriceConditionsManuallyCleared_ByAccount_RefID = securityTicket.AccountID,
                IsCustomerReturnReceipt = true,
                Creation_Timestamp      = DateTime.Now,
                IsDeleted    = false,
                Tenant_RefID = securityTicket.TenantID
            };
            receiptHeader.Save(Connection, Transaction);
            #endregion

            #region Create CustomerOrderReturnHeader
            var resultCustomerOrderReturnHeaderId = cls_Save_CustomerOrderReturnHeader.Invoke(
                Connection,
                Transaction,
                new P_L5CO_SCORH_1326()
            {
                CustomerOrderReturnHeaderID = Guid.Empty,
                CurencyId = CurrencyID,
                Customer_BillingAddressUCD_RefID = Guid.Empty,      // TODO:Marko - Not sure how to get this one!?
                Customer_BusinessParticipantID   = Parameter.BusinessParticipantID,
                CustomerInteractionsId           = Parameter.CustomerInteractionId,
                ReceiptHeaderId      = receiptHeader.LOG_RCP_Receipt_HeaderID,
                DateOfCustomerReturn = DateTime.Now,        // TODO:Marko !?
                TotalValueBeforeTax  = Parameter.Positions.Sum(p => p.Price)
            }, securityTicket).Result;
            #endregion

            #region Create and Load CustomerOrderReturn positions
            var returnPositionsParameter = new P_L5CO_SCORP_1459()
            {
                CustomerOrderReturnHeaderID = resultCustomerOrderReturnHeaderId,
                OrganizationalUnitID        = Parameter.OrganizationalUnitID,
                Positions = Parameter.Positions.Select(x =>
                                                       new P_L5CO_SCORP_1459a
                {
                    CustomerOrderReturnPositionId = Guid.Empty,
                    ArticleID  = x.ProductID,
                    OrderPrice = x.Price,
                    Quantity   = x.Quantity,
                    CorrespondingReceiptPosition_RefID = x.ReceiptPositionID
                }
                                                       ).ToArray()
            };
            cls_Save_CustomerOrderReturnPositions.Invoke(Connection, Transaction, returnPositionsParameter, securityTicket);
            #endregion

            #region Create Receipt Positions
            CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position receiptPosition = null;
            CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position_QualityControlItem qualityControlItem = null;

            foreach (var position in Parameter.Positions)
            {
                #region Receipt Position
                receiptPosition = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position
                {
                    LOG_RCP_Receipt_PositionID    = position.ReceiptPositionID,
                    Receipt_Header_RefID          = receiptHeader.LOG_RCP_Receipt_HeaderID,
                    ReceiptPosition_Product_RefID = position.ProductID,
                    ExpectedPositionPrice         = position.Price,
                    TotalQuantityTakenIntoStock   = position.Quantity,
                    Creation_Timestamp            = DateTime.Now,
                    Tenant_RefID = securityTicket.TenantID
                };
                receiptPosition.Save(Connection, Transaction);
                #endregion

                #region Quality Control Item
                qualityControlItem = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Position_QualityControlItem
                {
                    LOG_RCP_Receipt_Position_QualityControlItem = Guid.NewGuid(),
                    Receipt_Position_RefID        = receiptPosition.LOG_RCP_Receipt_PositionID,
                    ReceiptPositionCountedItemITL = receiptPosition.LOG_RCP_Receipt_PositionID.ToString(),
                    BatchNumber = position.BatchNumber,
                    QualityControl_PerformedAtDate = DateTime.Now,
                    QualityControl_PerformedByBusinessParticipant_RefID = account.BusinessParticipant_RefID,
                    Quantity = position.Quantity,
                    Target_WRH_Shelf_RefID = position.ShelfID,
                    Creation_Timestamp     = DateTime.Now,
                    Tenant_RefID           = securityTicket.TenantID
                };
                if (position.ExpiryDate.HasValue)
                {
                    qualityControlItem.ExpiryDate = position.ExpiryDate.Value;
                }
                qualityControlItem.Save(Connection, Transaction);
                #endregion
            }
            #endregion

            #region Place article on stock
            var intakeParam = new CL3_Warehouse.Complex.Manipulation.P_L3WH_SRIC_1421
            {
                ReceiptHeaderID    = receiptHeader.LOG_RCP_Receipt_HeaderID,
                WithoutProcurement = true
            };
            CL3_Warehouse.Complex.Manipulation.cls_StockReceipt_IntakeConfirmation.Invoke(Connection, Transaction, intakeParam, securityTicket);
            #endregion

            returnValue.Result = resultCustomerOrderReturnHeaderId;
            return(returnValue);

            #endregion UserCode
        }
コード例 #10
0
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L5SR_SRH_1545 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();

            Guid HeaderID = Parameter.ReceiptHeaderID;

            var businessParticipant = CL1_CMN_BPT.ORM_CMN_BPT_BusinessParticipant.Query.Search(Connection, Transaction,
                                                                                               new CL1_CMN_BPT.ORM_CMN_BPT_BusinessParticipant.Query()
            {
                IfTenant_Tenant_RefID = securityTicket.TenantID,
                IsDeleted             = false
            }).Single();

            bool isNew = HeaderID == Guid.Empty;
            var  expectedDeliveryHeader = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Header();
            var  receiptHeader          = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Header();
            var  procurementHeader      = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Header();
            var  receiptToProcurement   = new CL1_LOG_RCP.ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader();

            #region Receipt Header
            if (isNew)
            {
                var incrNumberParam = new P_L2NR_GaIINfUA_1454()
                {
                    GlobalStaticMatchingID = EnumUtils.GetEnumDescription(ENumberRangeUsageAreaType.StockReceiptNumber)
                };
                var receiptNumber = cls_Get_and_Increase_IncreasingNumber_for_UsageArea.Invoke(Connection, Transaction, incrNumberParam, securityTicket).Result.Current_IncreasingNumber;

                receiptHeader = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Header();
                receiptHeader.ReceiptNumber            = receiptNumber;
                receiptHeader.LOG_RCP_Receipt_HeaderID = Guid.NewGuid();
                receiptHeader.Creation_Timestamp       = DateTime.Now;
                receiptHeader.Tenant_RefID             = securityTicket.TenantID;
                receiptHeader.ReceiptHeaderITL         = receiptHeader.LOG_RCP_Receipt_HeaderID.ToString();
                receiptHeader.IsTakenIntoStock         = false;
            }
            else
            {
                var query = new CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Header.Query
                {
                    LOG_RCP_Receipt_HeaderID = Parameter.ReceiptHeaderID,
                    IsDeleted    = false,
                    Tenant_RefID = securityTicket.TenantID
                };
                receiptHeader = CL1_LOG_RCP.ORM_LOG_RCP_Receipt_Header.Query.Search(Connection, Transaction, query).Single();
            }
            HeaderID = receiptHeader.LOG_RCP_Receipt_HeaderID;
            receiptHeader.ProvidingSupplier_RefID = Parameter.SupplierID;
            receiptHeader.Save(Connection, Transaction);

            #endregion Receipt Header

            #region Expected Delivery Header
            if (isNew)
            {
                var incrNumberParam = new P_L2NR_GaIINfUA_1454()
                {
                    GlobalStaticMatchingID = EnumUtils.GetEnumDescription(ENumberRangeUsageAreaType.ExpectedDeliveryNumber)
                };
                var expectedDeliveryNumber = cls_Get_and_Increase_IncreasingNumber_for_UsageArea.Invoke(Connection, Transaction, incrNumberParam, securityTicket).Result.Current_IncreasingNumber;

                expectedDeliveryHeader = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Header
                {
                    ORD_PRC_ExpectedDelivery_HeaderID = Guid.NewGuid(),
                    Tenant_RefID           = securityTicket.TenantID,
                    Creation_Timestamp     = DateTime.Now,
                    ExpectedDeliveryNumber = expectedDeliveryNumber,
                    IsDeliveryOpen         = true,
                    IsDeliveryClosed       = false,
                };
                expectedDeliveryHeader.ExpectedDeliveryHeaderITL = expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID.ToString();

                // save receipt header with new expected delivery header
                receiptHeader.ExpectedDeliveryHeader_RefID = expectedDeliveryHeader.ORD_PRC_ExpectedDelivery_HeaderID;
                receiptHeader.Save(Connection, Transaction);
            }
            else
            {
                var query = new CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Header.Query
                {
                    ORD_PRC_ExpectedDelivery_HeaderID = receiptHeader.ExpectedDeliveryHeader_RefID,
                    IsDeleted    = false,
                    Tenant_RefID = securityTicket.TenantID
                };
                expectedDeliveryHeader = CL1_ORD_PRC.ORM_ORD_PRC_ExpectedDelivery_Header.Query.Search(Connection, Transaction, query).Single();
            }
            if (Parameter.LatestDeliveryDate != null)
            {
                expectedDeliveryHeader.ExpectedDeliveryDate = Parameter.LatestDeliveryDate.Value;
            }
            expectedDeliveryHeader.Save(Connection, Transaction);

            #endregion Expected Delivery Header

            #region Procurement Order

            if (isNew)
            {
                procurementHeader = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Header();
                procurementHeader.ORD_PRC_ProcurementOrder_HeaderID = Guid.NewGuid();
                procurementHeader.Creation_Timestamp = DateTime.Now;
                procurementHeader.Tenant_RefID       = securityTicket.TenantID;
                procurementHeader.CreatedBy_BusinessParticipant_RefID = businessParticipant.CMN_BPT_BusinessParticipantID;
                procurementHeader.IsCreatedForExpectedDelivery        = true;
                procurementHeader.ProcurementOrder_Currency_RefID     = cls_Get_DefaultCurrency_for_Tenant.Invoke(Connection, Transaction, securityTicket).Result.CMN_CurrencyID;

                receiptToProcurement = new CL1_LOG_RCP.ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader();
                receiptToProcurement.AssignmentID                          = Guid.NewGuid();
                receiptToProcurement.Creation_Timestamp                    = DateTime.Now;
                receiptToProcurement.Tenant_RefID                          = securityTicket.TenantID;
                receiptToProcurement.LOG_RCP_Receipt_Header_RefID          = receiptHeader.LOG_RCP_Receipt_HeaderID;
                receiptToProcurement.ORD_PRO_ProcurementOrder_Header_RefID = procurementHeader.ORD_PRC_ProcurementOrder_HeaderID;
                receiptToProcurement.Save(Connection, Transaction);
            }
            else
            {
                var query = new CL1_LOG_RCP.ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader.Query
                {
                    LOG_RCP_Receipt_Header_RefID = HeaderID,
                    IsDeleted    = false,
                    Tenant_RefID = securityTicket.TenantID
                };
                receiptToProcurement = CL1_LOG_RCP.ORM_LOG_RCP_ReceiptHeader_2_ProcurementOrderHeader.Query.Search(Connection, Transaction, query).Single();

                var query2 = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Header.Query
                {
                    ORD_PRC_ProcurementOrder_HeaderID = receiptToProcurement.ORD_PRO_ProcurementOrder_Header_RefID,
                    IsDeleted    = false,
                    Tenant_RefID = securityTicket.TenantID
                };
                procurementHeader = CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Header.Query.Search(Connection, Transaction, query2).Single();
            }

            #region get status for procurement order

            var newProcurementOrderStatusID = CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Status.Query.Search(Connection, Transaction,
                                                                                                           new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Status.Query()
            {
                GlobalPropertyMatchingID = DLCore_DBCommons.Utils.EnumUtils.GetEnumDescription(EProcurementStatus.Ordered),
                Tenant_RefID             = securityTicket.TenantID,
                IsDeleted = false
            }).Single().ORD_PRC_ProcurementOrder_StatusID;
            #endregion

            procurementHeader.Current_ProcurementOrderStatus_RefID = newProcurementOrderStatusID;
            procurementHeader.ProcurementOrder_Supplier_RefID      = Parameter.SupplierID;
            procurementHeader.Save(Connection, Transaction);

            if (!string.IsNullOrEmpty(Parameter.ProcurementOrderStatus))
            {
                var queryStatus = new CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Status.Query()
                {
                    GlobalPropertyMatchingID = Parameter.ProcurementOrderStatus,
                    Tenant_RefID             = securityTicket.TenantID,
                    IsDeleted = false
                };
                var status = CL1_ORD_PRC.ORM_ORD_PRC_ProcurementOrder_Status.Query.Search(Connection, Transaction, queryStatus).Single();

                var statusHistory = new ORM_ORD_PRC_ProcurementOrder_StatusHistory();
                statusHistory.ORD_PRC_ProcurementOrder_StatusHistoryID = Guid.NewGuid();
                statusHistory.ProcurementOrder_Header_RefID            = procurementHeader.ORD_PRC_ProcurementOrder_HeaderID;
                statusHistory.ProcurementOrder_Status_RefID            = status.ORD_PRC_ProcurementOrder_StatusID;
                statusHistory.IsDeleted          = false;
                statusHistory.Tenant_RefID       = securityTicket.TenantID;
                statusHistory.Creation_Timestamp = DateTime.Now;

                statusHistory.Save(Connection, Transaction);
            }

            #endregion Procurement Order

            returnValue.Result = HeaderID;
            return(returnValue);

            #endregion UserCode
        }
コード例 #11
0
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L5AWSAR_CSC_1809 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();

            var item = new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart();

            CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status statusShoppingCart;

            if (Parameter.IsWaitingForApproval)
            {
                // Get status
                statusShoppingCart = CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status.Query.Search(Connection, Transaction,
                                                                                              new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status.Query()
                {
                    GlobalPropertyMatchingID = DLCore_DBCommons.Utils.EnumUtils.GetEnumDescription
                                                   (DLCore_DBCommons.APODemand.EShoppingCartStatus.WaitingForApproval),
                    Tenant_RefID = securityTicket.TenantID,
                    IsDeleted    = false
                }).Single();
            }
            else
            {
                // Get status
                statusShoppingCart = CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status.Query.Search(Connection, Transaction,
                                                                                              new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart_Status.Query()
                {
                    GlobalPropertyMatchingID = DLCore_DBCommons.Utils.EnumUtils.GetEnumDescription
                                                   (DLCore_DBCommons.APODemand.EShoppingCartStatus.Active),
                    Tenant_RefID = securityTicket.TenantID,
                    IsDeleted    = false
                }).Single();
            }

            // Check does already exist available shopping cart for current office.
            var shoppingCartOffice = new CL1_ORD_PRC.ORM_ORD_PRC_Office_ShoppingCart();
            item.Tenant_RefID = securityTicket.TenantID;

            var lastShoppingCart = CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart.Query.Search(Connection, Transaction,
                                                                                     new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCart.Query
            {
                Tenant_RefID = securityTicket.TenantID
            }
                                                                                     ).OrderByDescending(x => x.Creation_Timestamp).FirstOrDefault();

            #region

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

            #endregion

            // Create shopping cart office
            shoppingCartOffice.ORD_PRC_ShoppingCart_RefID = item.ORD_PRC_ShoppingCartID;
            shoppingCartOffice.CMN_STR_Office_RefID       = Parameter.OfficeID;
            shoppingCartOffice.Tenant_RefID = securityTicket.TenantID;
            shoppingCartOffice.Save(Connection, Transaction);

            // Create shoppping cart
            item.ShoppingCart_CurrentStatus_RefID = statusShoppingCart.ORD_PRC_ShoppingCart_StatusID;
            item.InternalIdentifier        = shoppingCartNumber;
            item.CreatedBy_Account_RefID   = securityTicket.AccountID;
            item.IsProcurementOrderCreated = false;

            // Create and save new shopping cart history
            var shoppingHistory = new CL1_ORD_PRC.ORM_ORD_PRC_ShoppingCartStatus_History();
            shoppingHistory.ORD_PRC_ShoppingCart_RefID        = item.ORD_PRC_ShoppingCartID;
            shoppingHistory.ORD_PRC_ShoppingCart_Status_RefID = statusShoppingCart.ORD_PRC_ShoppingCart_StatusID;
            shoppingHistory.PerformedBy_Account_RefID         = securityTicket.AccountID;
            shoppingHistory.Tenant_RefID = securityTicket.TenantID;
            shoppingHistory.Save(Connection, Transaction);

            return(new FR_Guid(item.Save(Connection, Transaction), item.ORD_PRC_ShoppingCartID));

            #endregion UserCode
        }
コード例 #12
0
        protected static FR_Guid Execute(DbConnection Connection, DbTransaction Transaction, P_L5CO_SCORH_1326 Parameter, CSV2Core.SessionSecurity.SessionSecurityTicket securityTicket = null)
        {
            #region UserCode
            var returnValue = new FR_Guid();

            var returnHeader = new ORM_ORD_CUO_CustomerOrderReturn_Header();
            ORM_CMN_POS_CustomerInteraction customerInteraction = null;

            if (Parameter.CustomerOrderReturnHeaderID == Guid.Empty)
            {
                #region Preload data

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


                var account = CL1_USR.ORM_USR_Account.Query.Search(Connection, Transaction, new CL1_USR.ORM_USR_Account.Query
                {
                    USR_AccountID = securityTicket.AccountID,
                    IsDeleted     = false,
                    Tenant_RefID  = securityTicket.TenantID
                }).Single();

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

                var customerId = ORM_CMN_BPT_CTM_Customer.Query.Search(
                    Connection,
                    Transaction,
                    new ORM_CMN_BPT_CTM_Customer.Query()
                {
                    Ext_BusinessParticipant_RefID = Parameter.Customer_BusinessParticipantID,
                    IsDeleted    = false,
                    Tenant_RefID = securityTicket.TenantID
                }).Single().CMN_BPT_CTM_CustomerID;
                #endregion

                #region Customer Order Return Header Creation
                returnHeader = new ORM_ORD_CUO_CustomerOrderReturn_Header
                {
                    ORD_CUO_CustomerOrderReturn_HeaderID = Guid.NewGuid(),
                    Tenant_RefID                     = securityTicket.TenantID,
                    Creation_Timestamp               = DateTime.Now,
                    Customer_RefID                   = customerId,
                    CustomerOrderReturnNumber        = customerReturnNumber,
                    TotalValueBeforeTax              = Parameter.TotalValueBeforeTax,
                    Currency_RefID                   = Parameter.CurencyId,
                    Customer_BillingAddressUCD_RefID = Parameter.Customer_BillingAddressUCD_RefID
                };
                #endregion

                #region Create or Update CustomerInteraction
                if (Parameter.CustomerInteractionsId == Guid.Empty)
                {
                    var incrCustIntrNumberParam = new P_L2NR_GaIINfUA_1454()
                    {
                        GlobalStaticMatchingID = EnumUtils.GetEnumDescription(ENumberRangeUsageAreaType.CustomerInteractionNumber)
                    };
                    var customerInteractionNumber = cls_Get_and_Increase_IncreasingNumber_for_UsageArea.Invoke(Connection, Transaction, incrCustIntrNumberParam, securityTicket).Result.Current_IncreasingNumber;

                    customerInteraction = new ORM_CMN_POS_CustomerInteraction()
                    {
                        CMN_POS_CustomerInteractionID    = Guid.NewGuid(),
                        Creation_Timestamp               = DateTime.Now,
                        IsCustomerOrderReturnInteraction = true,
                        CustomerOrderReturnHeader_RefID  = returnHeader.ORD_CUO_CustomerOrderReturn_HeaderID,
                        CustomerInteractionNumber        = customerInteractionNumber,
                        DateOfCustomerInteraction        = DateTime.Now,
                        Tenant_RefID = securityTicket.TenantID
                    };
                    customerInteraction.Save(Connection, Transaction);
                }
                else
                {
                    customerInteraction = ORM_CMN_POS_CustomerInteraction.Query.Search(
                        Connection,
                        Transaction,
                        new ORM_CMN_POS_CustomerInteraction.Query()
                    {
                        CMN_POS_CustomerInteractionID = Parameter.CustomerInteractionsId,
                        IsDeleted    = false,
                        Tenant_RefID = securityTicket.TenantID
                    }).FirstOrDefault();
                    customerInteraction.CustomerOrderReturnHeader_RefID  = returnHeader.ORD_CUO_CustomerOrderReturn_HeaderID;
                    customerInteraction.IsCustomerOrderReturnInteraction = true;
                    customerInteraction.Save(Connection, Transaction);
                }
                #endregion
            }
            else
            {
                var fetched = returnHeader.Load(Connection, Transaction, Parameter.CustomerOrderReturnHeaderID);
                if (fetched.Status != FR_Status.Success || returnHeader.ORD_CUO_CustomerOrderReturn_HeaderID != Parameter.CustomerOrderReturnHeaderID)
                {
                    returnValue.ErrorMessage = fetched.ErrorMessage;
                    returnValue.Status       = FR_Status.Error_Internal;
                    returnValue.Result       = Guid.Empty;
                    return(returnValue);
                }

                #region Update Customer Order Total Value
                var returnPositions = ORM_ORD_CUO_CustomerOrderReturn_Position.Query.Search(
                    Connection,
                    Transaction,
                    new ORM_ORD_CUO_CustomerOrderReturn_Position.Query
                {
                    CustomerOrderReturnHeader_RefID = Parameter.CustomerOrderReturnHeaderID,
                    IsDeleted    = false,
                    Tenant_RefID = securityTicket.TenantID
                });
                returnHeader.TotalValueBeforeTax = returnPositions.Sum(x => x.Position_ValueTotal);
                #endregion
            }

            returnHeader.DateOfCustomerReturn = Parameter.DateOfCustomerReturn;
            returnHeader.Save(Connection, Transaction);

            returnValue.Result = returnHeader.ORD_CUO_CustomerOrderReturn_HeaderID;
            return(returnValue);

            #endregion UserCode
        }