Beispiel #1
0
        public async Task <IActionResult> OnGetAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }
            var buyMatDoc = await _context.RecurringTransDocs
                            .Include(b => b.Company)
                            .Include(b => b.Transactor)
                            .Include(b => b.DocLines)
                            .ThenInclude(m => m.WarehouseItem)
                            .FirstOrDefaultAsync(m => m.Id == id);

            ItemVm = _mapper.Map <RecurringDocModifyDto>(buyMatDoc);

            if (ItemVm == null)
            {
                return(NotFound());
            }

            LoadCombos();
            return(Page());
        }
Beispiel #2
0
        public async Task <IActionResult> OnGetAsync(int?companyFilter, int?section, int?copyFromId, int?createFromId, int?createFromType)
        {
            RoutedCompanyId = companyFilter ?? 0;
            RoutedSectionId = section ?? 0;
            CopyFromId      = copyFromId ?? 0;
            CreateFromId    = createFromId ?? 0;
            if (createFromType > 0)
            {
                CreateFromType = (RecurringDocTypeEnum)createFromType;
            }


            //if (CopyFromId > 0)
            //{
            //    var buyMatDoc = await _context.BuyDocuments
            //        .Include(b => b.Company)
            //        .Include(b => b.FiscalPeriod)
            //        .Include(b => b.BuyDocSeries)
            //        .Include(b => b.BuyDocType)
            //        .Include(b => b.Section)

            //        .Include(b => b.Transactor)
            //        .Include(b => b.BuyDocLines)
            //        .ThenInclude(m => m.WarehouseItem)
            //        .FirstOrDefaultAsync(m => m.Id == CopyFromId);
            //    if (buyMatDoc == null)
            //    {
            //        return NotFound();
            //    }
            //    //ItemVm = _mapper.Map<BuyDocCreateAjaxDto>(buyMatDoc);
            //    CopyFromItemVm = _mapper.Map<BuyDocModifyDto>(buyMatDoc);
            //    ItemVm = new BuyDocCreateAjaxDto
            //    {
            //        AmountDiscount = CopyFromItemVm.AmountDiscount,
            //        AmountFpa = CopyFromItemVm.AmountFpa,
            //        AmountNet = CopyFromItemVm.AmountNet,
            //        BuyDocSeriesId = CopyFromItemVm.BuyDocSeriesId,
            //        CompanyId = CopyFromItemVm.CompanyId,
            //        Etiology = CopyFromItemVm.Etiology,
            //        PaymentMethodId = CopyFromItemVm.PaymentMethodId,
            //        TransactorId = CopyFromItemVm.TransactorId
            //    };
            //}
            if (CreateFromId > 0)
            {
                //RecurringTransDocCreateAjaxDto vm;
                switch (CreateFromType)
                {
                case RecurringDocTypeEnum.BuyType:

                    var buyMatDoc = await _context.BuyDocuments
                                    .Include(b => b.Company)
                                    .Include(b => b.FiscalPeriod)
                                    .Include(b => b.BuyDocSeries)
                                    .Include(b => b.BuyDocType)
                                    .Include(b => b.Section)

                                    .Include(b => b.Transactor)
                                    .Include(b => b.BuyDocLines)
                                    .ThenInclude(m => m.WarehouseItem)
                                    .FirstOrDefaultAsync(m => m.Id == CreateFromId);

                    if (buyMatDoc == null)
                    {
                        return(NotFound());
                    }
                    //ItemVm = _mapper.Map<BuyDocCreateAjaxDto>(buyMatDoc);
                    CopyFromItemVm = _mapper.Map <RecurringDocModifyDto>(buyMatDoc);
                    ItemVm         = new RecurringTransDocCreateAjaxDto
                    {
                        NextTransDate      = buyMatDoc.TransDate.AddMonths(1),
                        RecurringFrequency = "1M",
                        RecurringDocType   = RecurringDocTypeEnum.BuyType,
                        SectionId          = CopyFromItemVm.SectionId,
                        AmountDiscount     = CopyFromItemVm.AmountDiscount,
                        AmountFpa          = CopyFromItemVm.AmountFpa,
                        AmountNet          = CopyFromItemVm.AmountNet,
                        DocSeriesId        = CopyFromItemVm.DocSeriesId,
                        CompanyId          = CopyFromItemVm.CompanyId,
                        Etiology           = CopyFromItemVm.Etiology,
                        PaymentMethodId    = CopyFromItemVm.PaymentMethodId,
                        TransactorId       = CopyFromItemVm.TransactorId
                    };
                    //Check if there is another recurring transaction with similar data
                    var r = await _context.RecurringTransDocs.SingleOrDefaultAsync(p =>
                                                                                   p.TransactorId == CopyFromItemVm.TransactorId &&
                                                                                   p.CompanyId == CopyFromItemVm.CompanyId &&
                                                                                   p.RecurringDocType == RecurringDocTypeEnum.BuyType &&
                                                                                   p.DocSeriesId == CopyFromItemVm.DocSeriesId);

                    if (r != null)
                    {
                        //There is another similar recurring transaction doc
                        ThereIsAnotherDoc   = true;
                        ExistingRecTransDoc = new RecurringDocModifyDto
                        {
                            Id = r.Id,
                            RecurringFrequency = r.RecurringFrequency,
                            RecurringDocType   = r.RecurringDocType,
                            NextTransDate      = r.NextTransDate,

                            TransactorId    = r.TransactorId,
                            TransactorName  = r.Transactor.Name,
                            DocSeriesId     = r.DocSeriesId,
                            DocSeriesCode   = buyMatDoc.BuyDocSeries.Code,
                            DocSeriesName   = buyMatDoc.BuyDocSeries.Name,
                            AmountFpa       = r.AmountFpa,
                            AmountNet       = r.AmountNet,
                            AmountDiscount  = r.AmountDiscount,
                            CompanyId       = r.CompanyId,
                            CompanyCode     = r.Company.Code,
                            PaymentMethodId = r.PaymentMethodId
                        };
                    }
                    else
                    {
                        ThereIsAnotherDoc   = false;
                        ExistingRecTransDoc = null;
                    }

                    break;

                case RecurringDocTypeEnum.SellType:
                    var sellMatDoc = await _context.SellDocuments
                                     .Include(b => b.Company)
                                     .Include(b => b.FiscalPeriod)
                                     .Include(b => b.SellDocSeries)
                                     .Include(b => b.SellDocType)
                                     .Include(b => b.Section)

                                     .Include(b => b.Transactor)
                                     .Include(b => b.SellDocLines)
                                     .ThenInclude(m => m.WarehouseItem)
                                     .FirstOrDefaultAsync(m => m.Id == CreateFromId);

                    if (sellMatDoc == null)
                    {
                        return(NotFound());
                    }
                    //ItemVm = _mapper.Map<BuyDocCreateAjaxDto>(buyMatDoc);
                    // _mapper.ConfigurationProvider.AssertConfigurationIsValid();
                    CopyFromItemVm = _mapper.Map <RecurringDocModifyDto>(sellMatDoc);
                    ItemVm         = new RecurringTransDocCreateAjaxDto
                    {
                        NextTransDate      = sellMatDoc.TransDate.AddMonths(1),
                        RecurringFrequency = "1M",
                        RecurringDocType   = RecurringDocTypeEnum.SellType,
                        SectionId          = CopyFromItemVm.SectionId,
                        AmountDiscount     = CopyFromItemVm.AmountDiscount,
                        AmountFpa          = CopyFromItemVm.AmountFpa,
                        AmountNet          = CopyFromItemVm.AmountNet,
                        DocSeriesId        = CopyFromItemVm.DocSeriesId,
                        CompanyId          = CopyFromItemVm.CompanyId,
                        Etiology           = CopyFromItemVm.Etiology,
                        PaymentMethodId    = CopyFromItemVm.PaymentMethodId,
                        TransactorId       = CopyFromItemVm.TransactorId
                    };
                    //Check if there is another recurring transaction with similar data
                    var rSell = await _context.RecurringTransDocs.SingleOrDefaultAsync(p =>
                                                                                       p.TransactorId == CopyFromItemVm.TransactorId &&
                                                                                       p.CompanyId == CopyFromItemVm.CompanyId &&
                                                                                       p.RecurringDocType == RecurringDocTypeEnum.SellType &&
                                                                                       p.DocSeriesId == CopyFromItemVm.DocSeriesId);

                    if (rSell != null)
                    {
                        //There is another similar recurring transaction doc
                        ThereIsAnotherDoc   = true;
                        ExistingRecTransDoc = new RecurringDocModifyDto
                        {
                            Id = rSell.Id,
                            RecurringFrequency = rSell.RecurringFrequency,
                            RecurringDocType   = rSell.RecurringDocType,
                            NextTransDate      = rSell.NextTransDate,

                            TransactorId    = rSell.TransactorId,
                            TransactorName  = rSell.Transactor.Name,
                            DocSeriesId     = rSell.DocSeriesId,
                            DocSeriesCode   = sellMatDoc.SellDocSeries.Code,
                            DocSeriesName   = sellMatDoc.SellDocSeries.Name,
                            AmountFpa       = rSell.AmountFpa,
                            AmountNet       = rSell.AmountNet,
                            AmountDiscount  = rSell.AmountDiscount,
                            CompanyId       = rSell.CompanyId,
                            CompanyCode     = rSell.Company.Code,
                            PaymentMethodId = rSell.PaymentMethodId
                        };
                    }
                    else
                    {
                        ThereIsAnotherDoc   = false;
                        ExistingRecTransDoc = null;
                    }
                    break;

                default:
                    break;
                }
            }
            LoadCombos();
            return(Page());
        }