public async Task ReBuildSalesReports(int asycuda_id)
        {
            AsycudaDocument doc = null;

            using (var ctx = new AllocationDSContext())
            {
                doc = ctx.AsycudaDocument.FirstOrDefault(x => x.ASYCUDA_Id == asycuda_id);
            }
            await WaterNut.DataSpace.BuildSalesReportClass.Instance.ReBuildSalesReports(doc).ConfigureAwait(false);
        }
 private void ClearXbondAllocations()
 {
     using (var ctx = new AllocationDSContext()
     {
         StartTracking = true
     })
     {
         ctx.Configuration.LazyLoadingEnabled       = false;
         ctx.Configuration.AutoDetectChangesEnabled = false;
         ctx.Database.ExecuteSqlCommand("DELETE FROM xBondAllocations FROM xBondAllocations INNER JOIN xcuda_Item ON xBondAllocations.xEntryItem_Id = xcuda_Item.Item_Id WHERE(xcuda_Item.IsAssessed = 1)");
     }
 }
        public async Task ClearAllocations(IEnumerable <int> alst)
        {
            var allst = new List <AsycudaSalesAllocations>();

            using (var ctx = new AllocationDSContext())
            {
                allst.AddRange(alst.Select(aid => ctx.AsycudaSalesAllocations
                                           .Include(x => x.EntryDataDetails)
                                           .Include(x => x.PreviousDocumentItem)
                                           .FirstOrDefault(x => x.AllocationId == aid)));
            }
            await WaterNut.DataSpace.AllocationsModel.Instance.ClearAllocations(allst).ConfigureAwait(false);
        }
        public async Task ManuallyAllocate(int AllocationId, int PreviousItem_Id)
        {
            xcuda_Item pitm;
            AsycudaSalesAllocations allo;

            using (var ctx = new AllocationDSContext())
            {
                pitm = ctx.xcuda_Item.FirstOrDefault(x => x.Item_Id == PreviousItem_Id);
                allo = ctx.AsycudaSalesAllocations.FirstOrDefault(x => x.AllocationId == AllocationId);
            }

            await WaterNut.DataSpace.AllocationsModel.Instance.ManuallyAllocate(allo, pitm).ConfigureAwait(false);
        }
        public async Task ClearAllAllocations()
        {
            StatusModel.Timer("Clear All Existing Allocations");

            using (var ctx = new AllocationDSContext())
            {
                await ctx.Database.ExecuteSqlCommandAsync(TransactionalBehavior.EnsureTransaction,
                                                          "delete from AsycudaSalesAllocations" +
                                                          "\r\n\r\n" +
                                                          "update xcuda_Item" + "\r\n" +
                                                          "set DFQtyAllocated = 0, DPQtyAllocated = 0\r\n\r\n\r\n" +
                                                          "update EntryDataDetails\r\n" + "set QtyAllocated = 0\r\n\r\n" +
                                                          "update xcuda_PreviousItem\r\nset QtyAllocated = 0\r\n\r\n" +
                                                          "update SubItems \r\nset QtyAllocated = 0").ConfigureAwait(false);
            }
        }
        //System.Windows.Forms.MessageBox.


        public async Task ManuallyAllocate(AsycudaSalesAllocations currentAsycudaSalesAllocation, xcuda_Item PreviousItemEx)
        {
            double aqty;

            using (var ctx = new AllocationDSContext()
            {
                StartTracking = true
            })
            {
                var entryDataDetails =
                    ctx.EntryDataDetails.Include(x => x.Sales).First(
                        x => x.EntryDataDetailsId == currentAsycudaSalesAllocation.EntryDataDetailsId.Value);

                var asycudaItem = ctx.xcuda_Item.Include(x => x.xcuda_Tarification.xcuda_Supplementary_unit).First(x => x.Item_Id == PreviousItemEx.Item_Id);
                ctx.AsycudaSalesAllocations.Attach(currentAsycudaSalesAllocation);

                if (entryDataDetails.Quantity >=
                    (asycudaItem.ItemQuantity - asycudaItem.QtyAllocated))
                {
                    aqty = asycudaItem.ItemQuantity - asycudaItem.QtyAllocated;
                }
                else
                {
                    aqty = entryDataDetails.Quantity;
                }
                currentAsycudaSalesAllocation.PreviousItem_Id = asycudaItem.Item_Id;

                currentAsycudaSalesAllocation.QtyAllocated = aqty;
                entryDataDetails.QtyAllocated += aqty;
                if ((entryDataDetails.Sales as Sales).DutyFreePaid == "Duty Free")
                {
                    asycudaItem.DFQtyAllocated += aqty;
                }
                else
                {
                    asycudaItem.DPQtyAllocated += aqty;
                }

                currentAsycudaSalesAllocation.Status = "Manual Allocation";

                ctx.SaveChanges();
                currentAsycudaSalesAllocation.AcceptChanges();
            }
            // SaveAsycudaSalesAllocation(currentAsycudaSalesAllocation);
        }
示例#7
0
        private static async Task <IEnumerable <AsycudaDocumentItemIM9> > GetSelectedLinesIM9Data(IEnumerable <int> lst)
        {
            var alst = new ConcurrentQueue <IEnumerable <AsycudaDocumentItemIM9> >();


            //Parallel.ForEach(lst, new ParallelOptions() {MaxDegreeOfParallelism = Environment.ProcessorCount*4},//
            //    docId =>
            //    {
            var res        = new StringBuilder();
            var enumerable = lst as IList <int> ?? lst.ToList();

            foreach (var itm in enumerable)
            {
                res.Append(itm + ",");
            }
            var str = res.ToString();


            using (var ctx = new AllocationDSContext())
            {
                //alst.Enqueue(

                //    ctx.xcuda_Item(
                //        string.Format("ItemQuantity > PiQuantity && CNumber != Null && " +
                //                      (BaseDataModel.Instance.CurrentApplicationSettings.OpeningStockDate.HasValue ? string.Format("RegistrationDate <= \"{0}\" && ", BaseDataModel.Instance.CurrentApplicationSettings.OpeningStockDate) : "") +
                //                      "AsycudaDocument.DocumentType == \"IM7\" && " +
                //                    //  "AsycudaDocument.DoNotAllocate != true && " +
                //                      "AsycudaDocument.Cancelled != true && " +
                //                      "\"{0}\".Contains(Item_Id.ToString())", res),
                //        new List<string>()
                //                {
                //                    "AsycudaDocument",
                //                    "xcuda_Supplementary_unit"
                //                }).Result);

                alst.Enqueue(

                    ctx.xcuda_Item
                    .Where(x => x.xcuda_Tarification.xcuda_Supplementary_unit.Any())
                    .Where(x => x.xcuda_Tarification.xcuda_Supplementary_unit.FirstOrDefault()
                           .Suppplementary_unit_quantity > x.EntryPreviousItems.Select(y => y.xcuda_PreviousItem)
                           .Where(y => y.xcuda_Item.AsycudaDocument.CNumber != null)
                           .Select(z => z.Suplementary_Quantity).DefaultIfEmpty(0).Sum())
                    .Where(x => str.Contains(x.Item_Id.ToString()))
                    .Select(x => new AsycudaDocumentItemIM9()
                {
                    ItemNumber = x.xcuda_Tarification.xcuda_HScode.Precision_4,
                    CNumber    = x.AsycudaDocument.CNumber,
                    Customs_clearance_office_code = x.AsycudaDocument.Customs_clearance_office_code,
                    Country_of_origin_code        = x.xcuda_Goods_description.Country_of_origin_code,
                    PiQuantity = x.EntryPreviousItems.Select(y => y.xcuda_PreviousItem)
                                 .Where(y => y.xcuda_Item.AsycudaDocument.CNumber != null)
                                 .Select(z => z.Suplementary_Quantity).DefaultIfEmpty(0).Sum(),
                    PiWeight = x.EntryPreviousItems.Select(y => y.xcuda_PreviousItem)
                               .Where(y => y.xcuda_Item.AsycudaDocument.CNumber != null)
                               .Select(z => z.Net_weight).DefaultIfEmpty(0).Sum(),
                    ItemQuantity             = (double)x.xcuda_Tarification.xcuda_Supplementary_unit.FirstOrDefault().Suppplementary_unit_quantity,
                    Suppplementary_unit_code = x.xcuda_Tarification.xcuda_Supplementary_unit.FirstOrDefault().Suppplementary_unit_code,
                    LineNumber             = x.LineNumber,
                    AsycudaDocumentId      = x.ASYCUDA_Id,
                    Commercial_Description = x.xcuda_Goods_description.Commercial_Description,
                    TariffCode             = x.xcuda_Tarification.xcuda_HScode.Commodity_code,
                    Item_price             = x.xcuda_Tarification.Item_price,
                    Net_weight             = x.xcuda_Valuation_item.xcuda_Weight_itm.Net_weight_itm,
                    ItemId           = x.Item_Id,
                    RegistrationDate = x.AsycudaDocument.RegistrationDate.Value,
                    Total_CIF_itm    = x.xcuda_Valuation_item.Total_CIF_itm
                }).ToList());
            }

            var ares = alst.SelectMany(x => x).OrderBy(x => x.LineNumber).ToList();

            AttachPackageInfo(ares);

            return(ares);
        }
示例#8
0
        private static async Task <List <AsycudaDocumentItemIM9> > GetAllIM9Data()
        {
            var alst = new List <AsycudaDocumentItemIM9>();

            using (var ctx = new AllocationDSContext())
            {
                //alst.AddRange(
                //   await
                //       ctx.xcuda_Item.Where(
                //       (BaseDataModel.Instance.CurrentApplicationSettings.OpeningStockDate.HasValue ? string.Format("RegistrationDate <= \"{0}\" && ", BaseDataModel.Instance.CurrentApplicationSettings.OpeningStockDate) : "") +
                //           "ItemQuantity > PiQuantity && CNumber != Null " +
                //           "&& AsycudaDocument.DocumentType == \"IM7\" " +
                //           // " && AsycudaDocument.DoNotAllocate != true" +
                //           " && AsycudaDocument.Cancelled != true" +
                //           " && WarehouseError == NULL" +
                //           " && InvalidHSCode != true" +
                //           " && Item_price != 0 && ItemQuantity != 0"
                //          // + " && (LineNumber != 5 && LineNumber != 7)"
                //          ,
                //           new List<string>()
                //           {
                //                "AsycudaDocument",
                //                "xcuda_Supplementary_unit"
                //           }).ConfigureAwait(false));
                alst.AddRange(
                    ctx.xcuda_Item

                    .Where(x => x.AsycudaDocument.RegistrationDate <= (BaseDataModel.Instance.CurrentApplicationSettings.OpeningStockDate ?? DateTime.Now))
                    .Where(x => x.AsycudaDocument.DocumentType == "IM7")
                    .Where(x => x.WarehouseError == null)
                    .Where(x => x.xcuda_Tarification.Item_price > 0)
                    .Where(x => x.xcuda_Tarification.xcuda_Supplementary_unit.Any())
                    .Where(x => x.xcuda_Tarification.xcuda_Supplementary_unit.FirstOrDefault()
                           .Suppplementary_unit_quantity > x.EntryPreviousItems.Select(y => y.xcuda_PreviousItem)
                           .Where(y => y.xcuda_Item.AsycudaDocument.CNumber != null)
                           .Select(z => z.Suplementary_Quantity).DefaultIfEmpty(0).Sum())

                    .Select(x => new AsycudaDocumentItemIM9()
                {
                    ItemNumber = x.xcuda_Tarification.xcuda_HScode.Precision_4,
                    CNumber    = x.AsycudaDocument.CNumber,
                    Customs_clearance_office_code = x.AsycudaDocument.Customs_clearance_office_code,
                    Country_of_origin_code        = x.xcuda_Goods_description.Country_of_origin_code,
                    PiQuantity = x.EntryPreviousItems.Select(y => y.xcuda_PreviousItem)
                                 .Where(y => y.xcuda_Item.AsycudaDocument.CNumber != null)
                                 .Select(z => z.Suplementary_Quantity).DefaultIfEmpty(0).Sum(),
                    PiWeight = x.EntryPreviousItems.Select(y => y.xcuda_PreviousItem)
                               .Where(y => y.xcuda_Item.AsycudaDocument.CNumber != null)
                               .Select(z => z.Net_weight).DefaultIfEmpty(0).Sum(),
                    ItemQuantity             = (double)x.xcuda_Tarification.xcuda_Supplementary_unit.FirstOrDefault().Suppplementary_unit_quantity,
                    Suppplementary_unit_code = x.xcuda_Tarification.xcuda_Supplementary_unit.FirstOrDefault().Suppplementary_unit_code,
                    LineNumber             = x.LineNumber,
                    AsycudaDocumentId      = x.ASYCUDA_Id,
                    Commercial_Description = x.xcuda_Goods_description.Commercial_Description,
                    TariffCode             = x.xcuda_Tarification.xcuda_HScode.Commodity_code,
                    Item_price             = x.xcuda_Tarification.Item_price,
                    Net_weight             = x.xcuda_Valuation_item.xcuda_Weight_itm.Net_weight_itm,
                    ItemId           = x.Item_Id,
                    RegistrationDate = x.AsycudaDocument.RegistrationDate.Value,
                    Total_CIF_itm    = x.xcuda_Valuation_item.Total_CIF_itm
                }).ToList()
                    );
            }
            var ares = alst.OrderBy(x => x.CNumber).ToList();

            AttachPackageInfo(ares);

            return(ares);
        }
        public IEnumerable <AllocationPi> GetAllocations()
        {
            using (var ctx = new AllocationDSContext()
            {
                StartTracking = true
            })
            {
                try
                {
                    ctx.Configuration.LazyLoadingEnabled       = false;
                    ctx.Configuration.AutoDetectChangesEnabled = false;


                    var res = ctx.AsycudaSalesAllocations
                              .Where(x => x.EntryDataDetails.Sales != null

                                     //   && "17997453".Contains(x.EntryDataDetails.ItemNumber) && x.EntryDataDetails.Sales.EntryDataDate.Month == 11 && x.EntryDataDetails.Sales.EntryDataDate.Year == 2016


                                     && x.PreviousDocumentItem != null &&
                                     x.PreviousDocumentItem.EntryPreviousItems.Any(
                                         z =>
                                         x.EntryDataDetails.Sales.EntryDataDate >= z.xcuda_Item.AsycudaDocument.AssessmentDate &&
                                         z.xcuda_Item.AsycudaDocument.Cancelled != true &&
                                         z.xcuda_Item.AsycudaDocument.DoNotAllocate != true &&
                                         z.xcuda_Item.AsycudaDocument != null &&
                                         z.xcuda_Item.AsycudaDocument.CNumber != null &&
                                         z.xcuda_PreviousItem.xcuda_Item.AsycudaDocument.Extended_customs_procedure == (x.EntryDataDetails.Sales.TaxAmount == 0 ? "9070" : "4070")) &&
                                     x.PreviousDocumentItem.AsycudaDocument != null &&
                                     x.PreviousDocumentItem.AsycudaDocument.Cancelled != true)
                              .OrderBy(x => x.EntryDataDetails.Sales.EntryDataDate)
                              .ThenBy(x => x.EntryDataDetails.EntryDataDetailsId)
                              .Select(x => new AllocationPi
                    {
                        Allocation   = x,
                        SalesDate    = x.EntryDataDetails.Sales.EntryDataDate,
                        Item_Id      = x.PreviousDocumentItem.Item_Id,
                        DutyFreePaid = (x.EntryDataDetails.Sales.TaxAmount == 0 ? "9070" : "4070"),
                        Pi           = x.PreviousDocumentItem.EntryPreviousItems // already filtered out
                                                                                 //       .Where(p => p.xcuda_PreviousItem.xcuda_Item.AsycudaDocument.Cancelled != true
                                                                                 //&&   x.EntryDataDetails.Sales.EntryDataDate >= p.xcuda_Item.AsycudaDocument.AssessmentDate
                                                                                 //                                                            && p.xcuda_PreviousItem.xcuda_Item.AsycudaDocument.Extended_customs_procedure == (x.EntryDataDetails.Sales.TaxAmount == 0?"9070": "4070"))

                                       .Select(p => new DatedPi
                        {
                            Pi              = p.xcuda_PreviousItem,
                            SalesFactor     = p.xcuda_Item.SalesFactor,
                            CNumber         = p.xcuda_PreviousItem.xcuda_Item.AsycudaDocument.CNumber,
                            pAssessmentDate = p.xcuda_PreviousItem.xcuda_Item.AsycudaDocument.AssessmentDate ?? DateTime.MinValue,
                            pRegDate        =
                                (p.xcuda_PreviousItem.xcuda_Item.AsycudaDocument.RegistrationDate ?? DateTime.MinValue)
                        }).OrderBy(q => q.pAssessmentDate).ThenBy(q => q.pRegDate),
                    })
                              .Where(x => x.Pi.Any())
                              .ToList()
                              .OrderBy(x => x.Pi.First().pAssessmentDate)
                              .ThenBy(x => x.Pi.First().pRegDate);
                    return(res);
                }
                catch (Exception)
                {
                    throw;
                }
            }
        }