Example #1
0
        public virtual Batch ReverseBatchProc(Batch b, ReverseBatchProcDelegate baseMethod)
        {
            GLVoucher glVoucher =
                PXSelect <GLVoucher, Where <GLVoucher.refNoteID, Equal <Required <Batch.noteID> > > > .Select(Base, b.NoteID);

            if (glVoucher == null)
            {
                return(baseMethod(b));
            }

            Batch batch;

            using (PXTransactionScope transactionScope = new PXTransactionScope())
            {
                GLVoucherBatch glVoucherBatch = PXSelect <GLVoucherBatch, Where <GLVoucherBatch.voucherBatchNbr,
                                                                                 Equal <Required <GLVoucher.voucherBatchNbr> > > > .Select(Base, glVoucher.VoucherBatchNbr);

                var contextValues = new Dictionary <string, string>();
                contextValues.Add(typeof(GLVoucherBatch.workBookID).FullName, glVoucherBatch.WorkBookID);
                contextValues.Add(typeof(GLVoucherBatch.voucherBatchNbr).FullName, glVoucherBatch.VoucherBatchNbr);
                Base.contextValues = contextValues;

                batch = baseMethod(b);

                if (batch.AutoReverseCopy == true)
                {
                    VoucherBatch.Current = glVoucherBatch;

                    var copy = (GLVoucher)Voucher.Cache.CreateCopy(glVoucher);
                    copy.DocType   = batch.BatchType;
                    copy.RefNbr    = batch.BatchNbr;
                    copy.RefNoteID = batch.NoteID;
                    copy.LineNbr   = null;
                    copy           = this.Voucher.Insert(copy);
                    this.Voucher.Cache.Persist(PXDBOperation.Insert);
                    this.VoucherBatch.Cache.Persist(PXDBOperation.Update);

                    Guid?noteID = PXNoteAttribute.GetNoteID <Batch.noteID>(Base.BatchModule.Cache, batch);
                    Base.Caches[typeof(Note)].Persist(PXDBOperation.Insert);
                }

                transactionScope.Complete(Base);
            }

            return(batch);
        }
Example #2
0
        protected virtual bool HasUnreleasedDetails(GLVoucherBatch batch)
        {
            foreach (PXResult <GLVoucher, AP.APRegister, AR.ARRegister, CAAdj, Batch> it in this.Details.Select(batch.WorkBookID, batch.VoucherBatchNbr))
            {
                GLVoucher     iVoucher = it;
                AP.APRegister iAPR     = it;
                AR.ARRegister iARR     = it;
                CAAdj         iCAR     = it;
                Batch         iGL      = it;
                switch (iVoucher.Module)
                {
                case GL.BatchModule.AP:
                    if (iAPR == null || string.IsNullOrEmpty(iAPR.RefNbr))
                    {
                        throw new PXException(GL.Messages.DocumentIsInvalidForVoucher, iVoucher.RefNbr, iVoucher.VoucherBatchNbr);
                    }
                    return(iAPR.Released != true);

                case GL.BatchModule.AR:
                    if (iARR == null || string.IsNullOrEmpty(iARR.RefNbr))
                    {
                        throw new PXException(GL.Messages.DocumentIsInvalidForVoucher, iVoucher.RefNbr, iVoucher.VoucherBatchNbr);
                    }
                    return(iARR.Released != true);

                case GL.BatchModule.CA:
                    if (iCAR == null || string.IsNullOrEmpty(iCAR.AdjRefNbr))
                    {
                        throw new PXException(GL.Messages.DocumentIsInvalidForVoucher, iVoucher.RefNbr, iVoucher.VoucherBatchNbr);
                    }
                    return(iCAR.Released != true);

                case GL.BatchModule.GL:
                    if (iGL == null || string.IsNullOrEmpty(iGL.BatchNbr))
                    {
                        throw new PXException(GL.Messages.DocumentIsInvalidForVoucher, iVoucher.RefNbr, iVoucher.VoucherBatchNbr);
                    }
                    return(iGL.Released != true);

                default:
                    throw new PXException(GL.Messages.ModuleIsNotSupported, iVoucher.Module);
                }
            }
            return(false);
        }
Example #3
0
        protected virtual void GLVoucherBatch_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
        {
            GLVoucherBatch row = (GLVoucherBatch)e.Row;

            if (row.Released == true)
            {
                throw new PXException(Messages.BatchDeleteReleased);
            }

            GLVoucher detail = PXSelect <GLVoucher,
                                         Where <GLVoucher.workBookID, Equal <Required <GLVoucherBatch.workBookID> >,
                                                And <GLVoucher.voucherBatchNbr, Equal <Required <GLVoucherBatch.voucherBatchNbr> > > > > .Select(this, row.WorkBookID, row.VoucherBatchNbr);

            if (detail != null)
            {
                throw new PXException(Messages.BatchDeleteWithDocuments);
            }
        }
        protected virtual void Batch_RowSelected(PXCache sender, PXRowSelectedEventArgs e, PXRowSelected bs)
        {
            if (bs != null)
            {
                bs(sender, e);
            }
            Batch row = e.Row as Batch;

            if (row == null)
            {
                return;
            }
            bool           isWithinContext = Base.IsWithinContext;
            GLVoucher      voucher         = this.Voucher.Select();
            GLVoucherBatch voucherBatch    = this.VoucherBatch.Select();
            PXCache        voucherCache    = this.Voucher.Cache;
            bool           isDetached      = (voucher == null);

            PXUIFieldAttribute.SetEnabled <GLVoucher.refNbr>(voucherCache, voucher, false);
            PXUIFieldAttribute.SetVisible <GLVoucher.refNbr>(voucherCache, voucher, !isDetached);
            PXUIFieldAttribute.SetEnabled <Batch.batchNbr>(sender, e.Row, !isWithinContext);
            this.SaveAndAdd.SetVisible(!isDetached && isWithinContext);
            this.SaveAndAdd.SetEnabled(!isDetached && isWithinContext);
            if (isWithinContext)
            {
                Base.release.SetVisible(false);
                Base.release.SetEnabled(false);
                Base.reverseBatch.SetVisible(false);
                Base.reverseBatch.SetEnabled(false);
                PXUIFieldAttribute.SetVisible <Batch.autoReverse>(sender, row, false);
                PXUIFieldAttribute.SetEnabled <Batch.autoReverse>(sender, row, false);
            }
            if (!isDetached)
            {
                Base.createSchedule.SetVisible(false);
                Base.createSchedule.SetEnabled(false);
            }
            PXUIFieldAttribute.SetVisible <GLVoucher.voucherBatchNbr>(Voucher.Cache, null, !isDetached && !isWithinContext);
            PXUIFieldAttribute.SetVisible <GLVoucher.workBookID>(Voucher.Cache, null, !isDetached && !isWithinContext);
            if (isWithinContext && !isDetached)
            {
                sender.AllowInsert = !(voucherBatch != null && voucherBatch.Released == true);
            }
        }
Example #5
0
 protected static void SetVoucherAsCurrent2(PXGraph target, GLVoucher voucher)
 {
     if (voucher != null)
     {
         if (voucher.Module == GL.BatchModule.AP)
         {
             if (voucher.DocType == AP.APDocType.Check || voucher.DocType == AP.APDocType.Prepayment)
             {
                 (target as AP.APPaymentEntry).Document.Current = (target as AP.APPaymentEntry).Document.Search <AP.APPayment.refNbr, AP.APPayment.docType>(voucher.RefNbr, voucher.DocType);
             }
             else if (voucher.DocType == AP.APDocType.Invoice || voucher.DocType == AP.APDocType.CreditAdj || voucher.DocType == AP.APDocType.DebitAdj)
             {
                 (target as AP.APInvoiceEntry).Document.Current = (target as AP.APInvoiceEntry).Document.Search <AP.APInvoice.refNbr, AP.APInvoice.docType>(voucher.RefNbr, voucher.DocType);
             }
             else if (voucher.DocType == AP.APDocType.QuickCheck)
             {
                 (target as AP.APQuickCheckEntry).Document.Current = (target as AP.APQuickCheckEntry).Document.Search <AP.Standalone.APQuickCheck.refNbr>(voucher.RefNbr, voucher.DocType);
             }
         }
         else if (voucher.Module == GL.BatchModule.AR)
         {
             if (voucher.DocType == AR.ARDocType.Payment || voucher.DocType == AR.ARDocType.Prepayment)
             {
                 (target as AR.ARPaymentEntry).Document.Current = (target as AR.ARPaymentEntry).Document.Search <AR.ARPayment.refNbr, AR.ARPayment.docType>(voucher.RefNbr, voucher.DocType);
             }
             else if (voucher.DocType == AR.ARDocType.Invoice || voucher.DocType == AR.ARDocType.CreditMemo || voucher.DocType == AR.ARDocType.DebitMemo)
             {
                 (target as AR.ARInvoiceEntry).Document.Current = (target as AR.ARInvoiceEntry).Document.Search <AR.ARInvoice.refNbr, AR.ARInvoice.docType>(voucher.RefNbr, voucher.DocType);
             }
             else if (voucher.DocType == AR.ARDocType.CashSale)
             {
                 (target as AR.ARCashSaleEntry).Document.Current = (target as AR.ARCashSaleEntry).Document.Search <AR.Standalone.ARCashSale.refNbr, AR.Standalone.ARCashSale.docType>(voucher.RefNbr, voucher.DocType);
             }
         }
         else if (voucher.Module == GL.BatchModule.CA && voucher.DocType == CA.CATranType.CAAdjustment)
         {
             (target as CA.CATranEntry).CAAdjRecords.Current = (target as CA.CATranEntry).CAAdjRecords.Search <CA.CAAdj.adjRefNbr, CA.CAAdj.adjTranType>(voucher.RefNbr, voucher.DocType);
         }
         else if (voucher.Module == GL.BatchModule.GL && voucher.DocType == GLTranType.GLEntry)
         {
             (target as GL.JournalEntry).BatchModule.Current = (target as GL.JournalEntry).BatchModule.Search <GL.Batch.refNbr, GL.Batch.batchType>(voucher.RefNbr, voucher.DocType);
         }
     }
 }
Example #6
0
        private void RedirectToBatch(GLVoucherBatch batch, GLVoucher voucher = null)
        {
            if (batch != null)
            {
                GLWorkBook wb = PXSelect <GLWorkBook, Where <GLWorkBook.workBookID, Equal <Required <GLWorkBook.workBookID> > > > .Select(this, batch.WorkBookID);

                if (wb == null || wb.VoucherEditScreen == null)
                {
                    throw new PXException(Messages.GLWorkBookIsInvalidOrVoucherEditScreenIsNotConfiguredForIt, batch.WorkBookID);
                }

                PXGraph       target = null;
                PXSiteMapNode sm     = PXSiteMap.Provider.FindSiteMapNodeFromKey((Guid)wb.VoucherEditScreen);
                if (sm == null)
                {
                    throw new PXException(Messages.CannotFindSitemapNode);
                }
                Type graphType       = System.Web.Compilation.BuildManager.GetType(sm.GraphType, true);
                Type parentGraphType = GLWorkBookMaint.GetGraphByDocType(batch.Module, wb.DocType);
                if (parentGraphType != null && parentGraphType.IsAssignableFrom(graphType))
                {
                    target = PXGraph.CreateInstance(graphType);
                }
                else
                {
                    throw new PXException(Messages.GLVoucherEditGraphMayNotBeAssignedToTheBasedDocumentGraph, graphType, parentGraphType);
                }
                if (voucher == null)
                {
                    voucher = PXSelect <GLVoucher, Where <GLVoucher.workBookID, Equal <Required <GLVoucher.workBookID> >,
                                                          And <GLVoucher.voucherBatchNbr, Equal <Required <GLVoucher.voucherBatchNbr> > > >, OrderBy <Desc <GLVoucher.refNbr> > > .Select(this, batch.WorkBookID, batch.VoucherBatchNbr);
                }
                else
                {
                    voucher = PXSelect <GLVoucher, Where <GLVoucher.workBookID, Equal <Required <GLVoucher.workBookID> >,
                                                          And <GLVoucher.voucherBatchNbr, Equal <Required <GLVoucher.voucherBatchNbr> >, And <GLVoucher.refNbr, Equal <Required <GLVoucher.refNbr> > > > >, OrderBy <Desc <GLVoucher.refNbr> > > .Select(this, batch.WorkBookID, batch.VoucherBatchNbr, voucher.RefNbr);
                }
                SetVoucherAsCurrent(target, voucher);
                throw new PXRedirectWithinContextException(this, target, Messages.VoucherEdit, typeof(GLVoucherBatch.workBookID), typeof(GLVoucherBatch.voucherBatchNbr));
            }
        }
Example #7
0
        protected virtual void ReleaseBatchDetailsProc(GLVoucherBatch aBatch, List <Batch> toPost, Dictionary <Guid, CAMessage> errors)
        {
            int         toProcessCount = 0;
            List <Guid> failed         = new List <Guid>();
            Dictionary <string, IList> processQueue = new Dictionary <string, IList>();

            foreach (PXResult <GLVoucher, AP.APRegister, AR.ARRegister, CAAdj, Batch> it in this.Details.Select(aBatch.WorkBookID, aBatch.VoucherBatchNbr))
            {
                GLVoucher iVoucher = it;
                Guid      key      = iVoucher.RefNoteID.Value;
                try
                {
                    switch (iVoucher.Module)
                    {
                    case GL.BatchModule.AP:
                        AP.APRegister iAPR = it;
                        if (iAPR == null || String.IsNullOrEmpty(iAPR.RefNbr))
                        {
                            throw new PXException(GL.Messages.DocumentIsInvalidForVoucher, iVoucher.RefNbr, iVoucher.VoucherBatchNbr);
                        }
                        if (iAPR.Released != true)
                        {
                            toProcessCount++;
                            List <AP.APRegister> list = new List <AP.APRegister>(1);
                            list.Add(iAPR);
                            if (iAPR.Scheduled == true)
                            {
                                throw new PXException(Messages.CannotReleaseScheduled);
                            }
                            AP.APDocumentRelease.ReleaseDoc(list, false, false, toPost);
                        }
                        break;

                    case GL.BatchModule.AR:
                        AR.ARRegister iARR = it;
                        if (iARR == null || String.IsNullOrEmpty(iARR.RefNbr))
                        {
                            throw new PXException(GL.Messages.DocumentIsInvalidForVoucher, iVoucher.RefNbr, iVoucher.VoucherBatchNbr);
                        }
                        if (iARR.Released != true)
                        {
                            toProcessCount++;
                            List <AR.ARRegister> list = new List <AR.ARRegister>(1);
                            list.Add(iARR);
                            if (iARR.Scheduled == true)
                            {
                                throw new PXException(Messages.CannotReleaseScheduled);
                            }
                            AR.ARDocumentRelease.ReleaseDoc(list, false, toPost, null);
                        }
                        break;

                    case GL.BatchModule.CA:
                        CAAdj iCAR = it;
                        if (iCAR == null || String.IsNullOrEmpty(iCAR.AdjRefNbr))
                        {
                            throw new PXException(GL.Messages.DocumentIsInvalidForVoucher, iVoucher.RefNbr, iVoucher.VoucherBatchNbr);
                        }
                        if (iCAR.Released != true)
                        {
                            toProcessCount++;
                            CATrxRelease.ReleaseDoc <CAAdj>(iCAR, 0, toPost);
                        }
                        break;

                    case GL.BatchModule.GL:
                        Batch iGL = it;
                        if (iGL == null || String.IsNullOrEmpty(iGL.BatchNbr))
                        {
                            throw new PXException(GL.Messages.DocumentIsInvalidForVoucher, iVoucher.RefNbr, iVoucher.VoucherBatchNbr);
                        }
                        if (iGL.Released != true)
                        {
                            toProcessCount++;
                            List <Batch> list = new List <Batch>(1);
                            list.Add(iGL);
                            if (iGL.Scheduled == true)
                            {
                                throw new PXException(Messages.CannotReleaseScheduled);
                            }
                            JournalEntry.ReleaseBatch(list, toPost);
                        }
                        break;

                    default:
                        throw new PXException(GL.Messages.ModuleIsNotSupported, iVoucher.Module);
                    }
                }
                catch (Exception ex)
                {
                    failed.Add(key);                     //prevent process from stoping on first error
                    errors.Add(key, FormatError(ex));
                }
            }
            if (failed.Count > 0)
            {
                throw new PXException(Messages.ReleasingOfSomeOfTheIncludedDocumentsFailed, failed.Count, toProcessCount);
            }
        }
Example #8
0
 protected virtual void SetVoucherAsCurrent(PXGraph target, GLVoucher voucher)
 {
     SetVoucherAsCurrent(this, target, voucher);
 }