private global::DocumentItemDS.Business.Entities.xcuda_PreviousItem CreatePreviousItem(AllocationsModel.AlloEntryLineData pod, int itmcount, string dfp)
        {
            try
            {
                var previousItem = (pod.PreviousDocumentItem as xcuda_Item);

                var pitm = new global::DocumentItemDS.Business.Entities.xcuda_PreviousItem()
                {
                    TrackingState = TrackingState.Added
                };
                if (previousItem == null)
                {
                    return(pitm);
                }

                pitm.Hs_code              = previousItem.xcuda_Tarification.xcuda_HScode.Commodity_code;
                pitm.Commodity_code       = "00";
                pitm.Current_item_number  = (itmcount + 1).ToString(); // piggy back the previous item count
                pitm.Previous_item_number = previousItem.LineNumber.ToString();


                SetWeights(pod, pitm, dfp);


                pitm.Previous_Packages_number = "0";


                pitm.Suplementary_Quantity           = Convert.ToDouble(pod.Quantity);
                pitm.Preveious_suplementary_quantity = Convert.ToDouble(previousItem.ItemQuantity);


                pitm.Goods_origin = previousItem.xcuda_Goods_description.Country_of_origin_code;
                double pval = previousItem.xcuda_Valuation_item.xcuda_Item_Invoice.Amount_national_currency;
                pitm.Previous_value = Convert.ToDouble((pval / previousItem.ItemQuantity));
                pitm.Current_value  = Convert.ToDouble((pval) / Convert.ToDouble(previousItem.ItemQuantity));
                pitm.Prev_reg_ser   = "C";
                pitm.Prev_reg_nbr   = previousItem.AsycudaDocument.CNumber;
                pitm.Prev_reg_dat   = previousItem.AsycudaDocument.RegistrationDate.GetValueOrDefault().Year.ToString();
                pitm.Prev_reg_cuo   = previousItem.AsycudaDocument.Customs_clearance_office_code;

                return(pitm);
            }
            catch (Exception)
            {
                throw;
            }
        }
        private void SetWeights(AllocationsModel.AlloEntryLineData pod, global::DocumentItemDS.Business.Entities.xcuda_PreviousItem pitm, string dfp)
        {
            try
            {
                var previousItem = pod.PreviousDocumentItem as xcuda_Item;
                if (previousItem == null)
                {
                    return;
                }
                var pw = Convert.ToDouble(previousItem.xcuda_Valuation_item.xcuda_Weight_itm.Net_weight_itm);
                //Double iw = System.Convert.ToDouble(Math.Round((pod.PreviousDocumentItem.xcuda_Valuation_item.xcuda_Weight_itm.Net_weight_itm
                //                    / pod.PreviousDocumentItem.ItemQuantity) * Convert.ToDouble(pod.Quantity), 2));
                var iw = Convert.ToDouble((previousItem.xcuda_Valuation_item.xcuda_Weight_itm.Net_weight_itm
                                           / previousItem.ItemQuantity) * Convert.ToDouble(pod.Quantity));

                var ppdfpqty =
                    previousItem.xcuda_PreviousItems.Where(x => x.DutyFreePaid != dfp)
                    .Sum(x => x.Suplementary_Quantity);
                var pi = previousItem.ItemQuantity -
                         previousItem.xcuda_PreviousItems.Where(x => x.DutyFreePaid == dfp)
                         .Sum(x => x.Suplementary_Quantity);
                var pdfpqty = (dfp == "Duty Free"
                    ? previousItem.DPQtyAllocated
                    : previousItem.DFQtyAllocated);
                var rw = previousItem.xcuda_PreviousItems.ToList().Sum(x => x.Net_weight);
                if ((pdfpqty == ppdfpqty) &&
                    (pi == pod.Quantity) &&
                    (previousItem.ItemQuantity - previousItem.QtyAllocated == 0))
                //                //(pod.PreviousDocumentItem.AsycudaSalesAllocations.Max(x => x.EntryDataDetailsId) == pod.EntryDataDetails.Max(x => x.EntryDataDetailsId) && (pod.PreviousDocumentItem.ItemQuantity - pod.PreviousDocumentItem.QtyAllocated == 0))
                {
                    pitm.Net_weight = Convert.ToDouble(pw - rw);
                }
                else
                {
                    pitm.Net_weight = Convert.ToDouble(Math.Round(iw, 2));
                }
                //pitm.Prev_net_weight = pw;
                pitm.Prev_net_weight = Convert.ToDouble(pw - rw);
            }
            catch (Exception)
            {
                throw;
            }
        }
        public bool CreateEx9EntryAsync(dynamic mypod, DocumentCT cdoc, int itmcount, string dfp, bool applyEX9Bucket)
        {
            try
            {
                if (applyEX9Bucket == true)
                {
                    Ex9Bucket(mypod, dfp, cdoc);
                }



                mypod.EntlnData.Quantity = Math.Round(mypod.EntlnData.Quantity, 2);
                if (mypod.EntlnData.Quantity <= 0)
                {
                    return(false);
                }

                global::DocumentItemDS.Business.Entities.xcuda_PreviousItem pitm = CreatePreviousItem(mypod.EntlnData, itmcount, dfp);
                if (pitm.Net_weight < 0.01)
                {
                    foreach (AsycudaSalesAllocations item in mypod.Allocations)
                    {
                        item.Status = "Net Weight < 0.01";
                    }
                    return(false);
                }


                //cdoc.Document.xcuda_PreviousItem.Add(pitm);
                pitm.ASYCUDA_Id = cdoc.Document.ASYCUDA_Id;
                global::DocumentItemDS.Business.Entities.xcuda_Item itm = BaseDataModel.Instance.CreateItemFromEntryDataDetail(mypod.EntlnData, cdoc);

                itm.xcuda_ASYCUDA = cdoc.Document;

                //TODO:Refactor this dup code
                if (mypod.Allocations != null)
                {
                    var itmcnt = 0;
                    foreach (
                        var allo in (mypod.Allocations as List <AsycudaSalesAllocations>))//.Distinct()
                    {
                        itm.xBondAllocations.Add(new xBondAllocations()
                        {
                            AllocationId = allo.AllocationId, xcuda_Item = itm, TrackingState = TrackingState.Added
                        });

                        itmcnt = AddFreeText(itmcnt, itm, allo.EntryDataDetails.EntryDataId);
                    }
                }
                //return true;



                itm.xcuda_PreviousItem = pitm;
                pitm.xcuda_Item        = itm;

                // cdoc.Document.xcuda_PreviousItem.Add(pitm);
                //pitm.xcuda_ASYCUDA = cdoc;
                // pitm.PreviousDocumentItem = itm;

                itm.xcuda_Tarification.xcuda_HScode.Commodity_code = pitm.Hs_code;
                itm.xcuda_Goods_description.Country_of_origin_code = pitm.Goods_origin;


                itm.xcuda_Previous_doc.Summary_declaration = String.Format("{0} {1} C {2} art. {3}", pitm.Prev_reg_cuo,
                                                                           pitm.Prev_reg_dat,
                                                                           pitm.Prev_reg_nbr, pitm.Previous_item_number);
                itm.xcuda_Valuation_item.xcuda_Weight_itm = new xcuda_Weight_itm()
                {
                    TrackingState = TrackingState.Added
                };
                itm.xcuda_Valuation_item.xcuda_Weight_itm.Gross_weight_itm = pitm.Net_weight;
                itm.xcuda_Valuation_item.xcuda_Weight_itm.Net_weight_itm   = pitm.Net_weight;
                // adjusting because not using real statistical value when calculating
                itm.xcuda_Valuation_item.xcuda_Item_Invoice.Amount_foreign_currency =
                    Convert.ToDouble(Math.Round((pitm.Current_value * pitm.Suplementary_Quantity), 2));
                itm.xcuda_Valuation_item.xcuda_Item_Invoice.Amount_national_currency =
                    Convert.ToDouble(Math.Round(pitm.Current_value * pitm.Suplementary_Quantity, 2));
                itm.xcuda_Valuation_item.xcuda_Item_Invoice.Currency_code = "XCD";
                itm.xcuda_Valuation_item.xcuda_Item_Invoice.Currency_rate = 1;


                if (cdoc.DocumentItems.Select(x => x.xcuda_PreviousItem).Count() == 1 || itmcount == 0)
                {
                    pitm.Packages_number          = "1"; //(i.Packages.Number_of_packages).ToString();
                    pitm.Previous_Packages_number = pitm.Previous_item_number == "1" ? "1" : "0";
                }
                else
                {
                    pitm.Packages_number          = (0).ToString(CultureInfo.InvariantCulture);
                    pitm.Previous_Packages_number = (0).ToString(CultureInfo.InvariantCulture);
                }



                return(true);
            }
            catch (Exception Ex)
            {
                throw;
            }
        }