private async Task <List <AsycudaSalesAllocations> > GetSalesData(string dfp)
        {
            StatusModel.Timer("Loading Data...");
            List <AsycudaSalesAllocations> alst = null;

            using (var ctx = new AsycudaSalesAllocationsService())
            {
                alst = (await ctx.GetAsycudaSalesAllocations().ConfigureAwait(false))
                       .Where(x => x.EntryDataDetails.Sales != null &&
                              x.PreviousDocumentItem != null
                              // && x.EntryDataDetails.ItemDescription.Contains("POLLEN-BR-B") // && x.PreviousItemEx.xcuda_Tarification.xcuda_HScode.Precision_4.Contains("DKR")// //
                              && x.PreviousDocumentItem.AsycudaDocument.CNumber != null)
                       .AsEnumerable()
                       .Where(x => (x.EntryDataDetails.Sales as Sales).DutyFreePaid == dfp)
                       .OrderBy(x => x.EntryDataDetails.Sales.EntryDataDate).ThenBy(x => x.EntryDataDetails.EntryDataDetailsId).ToList();
            }
            StatusModel.Timer("Cleaning Data...");

            using (var ctx = new global::AllocationDS.Business.Services.xcuda_ItemService())
            {
                alst.ForEach(x => x.PreviousDocumentItem.xcuda_PreviousItems.ToList().ForEach(z => z.QtyAllocated = 0));
                alst.ForEach(x => x.xbondEntry.Clear());
            }
            return(alst);
        }
Example #2
0
 private async Task SaveAllocation(AsycudaSalesAllocations ssa)
 {
     using (var ctx = new AsycudaSalesAllocationsService())
     {
         await ctx.UpdateAsycudaSalesAllocations(ssa).ConfigureAwait(false);
     }
 }
 //Search Entities
 public async Task <IEnumerable <AsycudaSalesAllocations> > SearchAsycudaSalesAllocations(List <string> lst, List <string> includeLst = null)
 {
     using (var ctx = new AsycudaSalesAllocationsService())
     {
         return(await ctx.GetAsycudaSalesAllocationsByExpressionLst(lst, includeLst).ConfigureAwait(false));
     }
 }
 private async void SaveAsycudaSalesAllocation(AsycudaSalesAllocations allo)
 {
     using (var ctx = new AsycudaSalesAllocationsService())
     {
         await ctx.UpdateAsycudaSalesAllocations(allo).ConfigureAwait(false);
     }
 }
        public async Task <IEnumerable <AsycudaSalesAllocations> > GetAsycudaSalesAllocations(string FilterExpression)
        {
            try
            {
                // create dictionary map and run replace
                var map = new Dictionary <string, string>()
                {
                    { "InvoiceDate", "EntryDataDetails.Sales.EntryDataDate" },
                    { "InvoiceNo", "EntryDataDetails.EntryDataId" },
                    { "TaxAmount", "EntryDataDetails.Sales.TaxAmount" },
                    { "ItemNumber", "EntryDataDetails.ItemNumber" },
                    { "ItemDescription", "EntryDataDetails.ItemDescription" },
                    { "TariffCode", "EntryDataDetails.InventoryItem.TariffCode" },
                    { "pCNumber", "PreviousDocumentItem.AsycudaDocument.CNumber" },
                    { "pLineNumber", "PreviousDocumentItem.LineNumber" }
                };


                var exp = map.Aggregate(FilterExpression, (current, m) => current.Replace(m.Key, m.Value));


                using (var ctx = new AsycudaSalesAllocationsService())
                {
                    var res = await ctx.GetAsycudaSalesAllocationsByExpression(exp,
                                                                               new List <string>()
                    {
                        "xbondEntry",
                        // "EntryDataDetails",
                        // "EntryDataDetails.EntryDataDetailsEx",
                        // "EntryDataDetails.InventoryItem",
                        "EntryDataDetails.InventoryItem.TariffCodes.TariffCategory.TariffSupUnitLkps",
                        "EntryDataDetails.Sales",
                        // "PreviousDocumentItem",
                        //"PreviousDocumentItem.EX",
                        "PreviousDocumentItem.xcuda_Goods_description",
                        "PreviousDocumentItem.xcuda_Tarification.xcuda_HScode",
                        "PreviousDocumentItem.xcuda_Tarification.xcuda_Supplementary_unit",
                        "PreviousDocumentItem.xcuda_Taxation.xcuda_Taxation_line",
                        "PreviousDocumentItem.xcuda_Valuation_item.xcuda_Item_Invoice",
                        "PreviousDocumentItem.xcuda_Valuation_item.xcuda_Weight_itm",
                        "PreviousDocumentItem.AsycudaDocument",
                        //"PreviousDocumentItem.xcuda_PreviousItems",
                        "PreviousDocumentItem.xcuda_PreviousItems.xcuda_Item.AsycudaDocument"
                        // "PreviousDocumentItem.xcuda_PreviousItems.xcuda_Item"
                    }).ConfigureAwait(false);

                    return(res);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
Example #6
0
 public async Task SaveAsycudaSalesAllocations(AsycudaSalesAllocations i)
 {
     if (i == null)
     {
         return;
     }
     using (var ctx = new AsycudaSalesAllocationsService())
     {
         await ctx.UpdateAsycudaSalesAllocations(i).ConfigureAwait(false);
     }
 }
Example #7
0
        public async Task ClearAllocations(IEnumerable <int> alst)
        {
            var allos = new List <AsycudaSalesAllocations>();

            using (var ctx = new AsycudaSalesAllocationsService())
            {
                foreach (var aid in alst)
                {
                    allos.Add(await ctx.GetAsycudaSalesAllocationsByKey(aid.ToString(), new List <string>()
                    {
                        "EntryDataDetails",
                        "PreviousDocumentItem"
                    }).ConfigureAwait(false));
                }
            }

            await DataSpace.AllocationsModel.Instance.ClearAllocations(allos).ConfigureAwait(false);
        }
        public async Task <IEnumerable <AsycudaSalesAllocations> > GetAsycudaSalesAllocations(string FilterExpression)
        {
            try
            {
                // create dictionary map and run replace
                var exp = TranslateAllocationWhereExpression(FilterExpression);


                using (var ctx = new AsycudaSalesAllocationsService())
                {
                    var res = await ctx.GetAsycudaSalesAllocationsByExpression(exp,
                                                                               new List <string>()
                    {
                        "xBondAllocations",
                        // "EntryDataDetails",
                        // "EntryDataDetails.EntryDataDetailsEx",
                        // "EntryDataDetails.InventoryItem",
                        "EntryDataDetails.InventoryItem.TariffCodes.TariffCategory.TariffSupUnitLkps",
                        "EntryDataDetails.Sales",
                        // "PreviousDocumentItem",
                        //"PreviousDocumentItem.EX",
                        "PreviousDocumentItem.xcuda_Goods_description",
                        "PreviousDocumentItem.xcuda_Tarification.xcuda_HScode",
                        "PreviousDocumentItem.xcuda_Tarification.xcuda_Supplementary_unit",
                        "PreviousDocumentItem.xcuda_Taxation.xcuda_Taxation_line",
                        "PreviousDocumentItem.xcuda_Valuation_item.xcuda_Item_Invoice",
                        "PreviousDocumentItem.xcuda_Valuation_item.xcuda_Weight_itm",
                        "PreviousDocumentItem.AsycudaDocument",
                        //"PreviousDocumentItem.xcuda_PreviousItems",
                        "PreviousDocumentItem.EntryPreviousItems.xcuda_PreviousItem.xcuda_Item.AsycudaDocument"
                        // "PreviousDocumentItem.xcuda_PreviousItems.xcuda_Item"
                    }).ConfigureAwait(false);

                    return(res);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        //public CreateErrOPS CreateErrOps
        //{
        //    get { return CreateErrOPS.Instance; }
        //}

        //public CreateIncompOPSClass CreateIncompOpsClass
        //{
        //    get { return _createIncompOpsClass; }
        //}

        public async Task ClearAllocation(AsycudaSalesAllocations allo)
        {
            /////////// took out entrydatadetails update

            if (allo.EntryDataDetails != null && (allo.EntryDataDetails.TrackingState != TrackingState.Deleted))
            {
                allo.EntryDataDetails.QtyAllocated = 0;
                allo.EntryDataDetails = null;
            }

            if (allo.PreviousDocumentItem != null)
            {
                using (var ctx = new xcuda_ItemService())
                {
                    var res = await ctx.Getxcuda_ItemByKey(allo.PreviousItem_Id.ToString()).ConfigureAwait(false);

                    res.DFQtyAllocated = 0;
                    res.DPQtyAllocated = 0;

                    foreach (var sitm in res.SubItems)
                    {
                        sitm.QtyAllocated = 0;
                    }

                    foreach (var ed in res.xcuda_PreviousItems.Select(x => x.xcuda_PreviousItem))
                    {
                        ed.QtyAllocated = 0;
                    }
                    await ctx.Updatexcuda_Item(res).ConfigureAwait(false);
                }

                allo.PreviousDocumentItem = null;
            }


            using (var ctx = new AsycudaSalesAllocationsService())
            {
                await ctx.DeleteAsycudaSalesAllocations(allo.AllocationId.ToString()).ConfigureAwait(false);
            }
        }