示例#1
0
 public virtual void _(Events.RowSelected <APAdjust> args)
 {
     if (args.Row is APAdjust adjustment && !PXLongOperation.Exists(Base.UID))
     {
         UpdateAmountPaidAvailability(adjustment);
     }
 }
        protected virtual void Schedule_RowSelected(PXCache cache, PXRowSelectedEventArgs e)
        {
            Schedule task = (Schedule)e.Row;

            if (task == null || PXLongOperation.Exists(UID))
            {
                return;
            }

            if ((task.NoRunLimit ?? false) == false && task.RunCntr == task.RunLimit)
            {
                cache.RaiseExceptionHandling <Schedule.scheduleID>(e.Row, task.ScheduleID, new PXSetPropertyException(Messages.SheduleExecutionLimitExceeded, PXErrorLevel.RowError));
            }
            else
            {
                if ((task.NoEndDate ?? false) == false && task.EndDate < Accessinfo.BusinessDate)
                {
                    cache.RaiseExceptionHandling <Schedule.scheduleID>(e.Row, task.ScheduleID, new PXSetPropertyException(Messages.SheduleHasExpired, PXErrorLevel.RowError));
                }
                else
                {
                    if (task.NextRunDate > Accessinfo.BusinessDate)
                    {
                        cache.RaiseExceptionHandling <Schedule.scheduleID>(e.Row, task.ScheduleID, new PXSetPropertyException(Messages.SheduleNextExecutionDateExceeded, PXErrorLevel.RowWarning));
                    }
                }
            }
        }
示例#3
0
 private void CheckPrevOperation()
 {
     if (PXLongOperation.Exists(UID))
     {
         throw new ApplicationException(GL.Messages.PrevOperationNotCompleteYet);
     }
 }
示例#4
0
        public virtual void _(Events.RowSelected <APAdjust> args)
        {
            var adjustment = args.Row;

            if (adjustment != null && !PXLongOperation.Exists(Base.UID))
            {
                SetAmountToPayIfEmpty(adjustment);
            }
        }
示例#5
0
        protected virtual void CAEnqFilter_RowSelected(PXCache cache, PXRowSelectedEventArgs e)
        {
            CAEnqFilter filter = (CAEnqFilter)e.Row;

            if (filter == null)
            {
                return;
            }

            bool ShowSummaryNotChecked = filter.ShowSummary != true;

            bool CashAccountNeedReconcilation = (cashaccount.Current != null) && (bool)cashaccount.Current.Reconcile;

            if (cashaccount.Current != null && AddFilter.Current != null && AddFilter.Current.CashAccountID != filter.AccountID)
            {
                AddFilter.Cache.SetValueExt <AddTrxFilter.cashAccountID>(AddFilter.Current, cashaccount.Current.CashAccountCD);
            }
            AddDet.SetEnabled(filter.AccountID != null);
            PXCache tranCache = CATranListRecords.Cache;

            tranCache.AllowInsert = false;
            tranCache.AllowUpdate = (ShowSummaryNotChecked);
            tranCache.AllowDelete = (ShowSummaryNotChecked);

            PXUIFieldAttribute.SetVisible <CATran.selected>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.hold>(tranCache, null, false);
            PXUIFieldAttribute.SetVisible <CATran.status>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.origModule>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.origRefNbr>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.origTranType>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.extRefNbr>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.batchNbr>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.finPeriodID>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.tranDesc>(tranCache, null, ShowSummaryNotChecked);

            PXUIFieldAttribute.SetVisible <CATran.referenceName>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.reconciled>(tranCache, null, ShowSummaryNotChecked && CashAccountNeedReconcilation);
            PXUIFieldAttribute.SetVisible <CATran.clearDate>(tranCache, null, ShowSummaryNotChecked && CashAccountNeedReconcilation);
            PXUIFieldAttribute.SetVisible <CATran.cleared>(tranCache, null, ShowSummaryNotChecked && CashAccountNeedReconcilation);
            PXUIFieldAttribute.SetVisible <CATran.dayDesc>(tranCache, null, !ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATranExt.dayDesc>(tranCache, null, !ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATranExt.depositNbr>(tranCache, null, ShowSummaryNotChecked);
            PXUIFieldAttribute.SetVisible <CATran.referenceID>(tranCache, null, ShowSummaryNotChecked);
            PXCache bAcctCache = this.Caches[typeof(BAccountR)];

            PXUIFieldAttribute.SetVisible <BAccountR.acctName>(bAcctCache, null, ShowSummaryNotChecked);

            Clearence.SetEnabled(CashAccountNeedReconcilation);
            AddFilter.Cache.RaiseRowSelected(AddFilter.Current);

            bool operationExists = PXLongOperation.Exists(UID);

            Save.SetEnabled(!operationExists);
            Release.SetEnabled(!operationExists);
            Clearence.SetEnabled(!operationExists);
        }
 protected override IEnumerable ProcessAll(PXAdapter adapter)
 {
     if (ConfirmationMessage != null && adapter.ExternalCall)
     {
         if (!PXLongOperation.Exists(_Graph.UID) && this.Ask(ConfirmationTitle, ConfirmationMessage, MessageButtons.YesNo) != WebDialogResult.Yes)
         {
             return(adapter.Get());
         }
     }
     return(base.ProcessAll(adapter));
 }
		protected virtual void GLConsolSetup_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
		{
			if (e.Row == null)
				return;

			if (!PXLongOperation.Exists(UID))
			{
				var glConsolSetup = (GLConsolSetup)e.Row;

				CheckUnpostedBatchesNotExist(glConsolSetup);
			}
		}
示例#8
0
        public virtual IEnumerable release(PXAdapter adapter)
        {
            PXCache    cache    = Caches[typeof(CATransfer)];
            CATransfer transfer = Transfer.Current;

            if (PXLongOperation.Exists(UID))
            {
                throw new ApplicationException(GL.Messages.PrevOperationNotCompleteYet);
            }
            bool holdExpenses = false;

            foreach (PXResult <CATran, CAAdj> expense in TransferTran.Select())
            {
                CAAdj  expenseAdj  = (CAAdj)expense;
                CATran expenseTran = (CATran)expense;
                if (expenseAdj != null && (expenseAdj.Hold == true || expenseAdj.Approved == false))
                {
                    holdExpenses = true;
                    TransferTran.Cache.RaiseExceptionHandling <CATran.extRefNbr>(expenseTran, expenseTran.ExtRefNbr, new PXSetPropertyException(Messages.HoldExpense, PXErrorLevel.RowError));
                }
            }
            if (holdExpenses)
            {
                throw new PXException(Messages.HoldExpenses, transfer.RefNbr);
            }
            Save.Press();
            List <CARegister> list = new List <CARegister>();
            CATran            tran = PXSelect <CATran, Where <CATran.tranID, Equal <Required <CATransfer.tranIDIn> > > > .Select(this, transfer.TranIDIn);

            if (tran != null)
            {
                list.Add(CATrxRelease.CARegister(transfer, tran));
            }
            else
            {
                throw new PXException(Messages.TransactionNotFound);
            }

            tran = PXSelect <CATran, Where <CATran.tranID, Equal <Required <CATransfer.tranIDOut> > > > .Select(this, transfer.TranIDOut);

            if (tran == null)
            {
                throw new PXException(Messages.TransactionNotFound);
            }

            PXLongOperation.StartOperation(this, delegate() { CATrxRelease.GroupRelease(list, false); });

            List <CATransfer> ret = new List <CATransfer>();

            ret.Add(transfer);
            return(ret);
        }
        public virtual IEnumerable release(PXAdapter adapter)
        {
            if (PXLongOperation.Exists(UID))
            {
                throw new ApplicationException(GL.Messages.PrevOperationNotCompleteYet);
            }
            Save.Press();
            CABatch document = this.Document.Current;

            PXLongOperation.StartOperation(this, delegate() { CABatchEntry.ReleaseDoc(document); });

            return(adapter.Get());
        }
        protected override IEnumerable Handler(PXAdapter adapter)
        {
            if (PXLongOperation.Exists(_Graph.UID))
            {
                throw new ApplicationException(PX.Objects.GL.Messages.PrevOperationNotCompleteYet);
            }

            _Graph.Actions.PressSave();
            CABatch    doc    = (CABatch)_Graph.Views[_Graph.PrimaryView].Cache.Current;
            CABatchExt docExt = PXCache <CABatch> .GetExtension <CABatchExt>(doc);

            if (doc.Released == true && doc.ExportTime.HasValue && !String.IsNullOrEmpty(docExt.ProcessingCenterID) && !docExt.FileTransferTime.HasValue)
            {
                PXLongOperation.StartOperation(_Graph, delegate() { TransferDocProcessingCenter(_Graph, doc, docExt); });
            }
            return(adapter.Get());
        }
示例#11
0
        protected virtual void FABookBalance_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
        {
            FABookBalance bal = (FABookBalance)e.Row;

            if (bal == null || PXLongOperation.Exists(UID))
            {
                return;
            }

            try
            {
                AssetProcess.CheckUnreleasedTransactions(this, bal);
            }
            catch (PXException exc)
            {
                PXUIFieldAttribute.SetEnabled <FABookBalance.selected>(sender, bal, false);
                sender.RaiseExceptionHandling <FABookBalance.selected>(bal, null, new PXSetPropertyException(exc.MessageNoNumber, PXErrorLevel.RowWarning));
            }
        }
        public virtual IEnumerable export(PXAdapter adapter)
        {
            if (PXLongOperation.Exists(UID))
            {
                throw new ApplicationException(GL.Messages.PrevOperationNotCompleteYet);
            }
            CABatch doc = this.Document.Current;

            if (doc != null && doc.Released == true && doc.Hold == false)
            {
                PXResult <PaymentMethod, SYMapping> res = (PXResult <PaymentMethod, SYMapping>) PXSelectJoin <PaymentMethod,
                                                                                                              LeftJoin <SYMapping, On <SYMapping.mappingID, Equal <PaymentMethodExt.aRBatchExportSYMappingID> > >,
                                                                                                              Where <PaymentMethod.paymentMethodID, Equal <Optional <CABatch.paymentMethodID> > > > .Select(this, doc.PaymentMethodID);

                PaymentMethod    pt  = res;
                PaymentMethodExt ptx = PXCache <PaymentMethod> .GetExtension <PaymentMethodExt>(pt);

                SYMapping map = res;
                if (ptx != null && ptx.ARCreateBatchPayment == true && ptx.ARBatchExportSYMappingID != null && map != null)
                {
                    string defaultFileName = this.GenerateFileName(doc);
                    PXLongOperation.StartOperation(this, delegate()
                    {
                        PX.Api.SYExportProcess.RunScenario(map.Name, SYMapping.RepeatingOption.All, true, true,
                                                           new PX.Api.PXSYParameter(CABatchEntry.ExportProviderParams.FileName, defaultFileName),
                                                           new PX.Api.PXSYParameter(CABatchEntry.ExportProviderParams.BatchNbr, doc.BatchNbr)

                                                           //,
                                                           //new PX.Api.PXSYParameter(ExportProviderParams.BatchSequenceStartingNbr, "0000")
                                                           );
                    });
                }
                else
                {
                    throw new PXException(CA.Messages.CABatchExportProviderIsNotConfigured);
                }
            }

            return(adapter.Get());
        }
        public virtual IEnumerable release(PXAdapter adapter)
        {
            PXCache    cache    = Caches[typeof(CATransfer)];
            CATransfer transfer = Transfer.Current;

            if (PXLongOperation.Exists(UID))
            {
                throw new ApplicationException(GL.Messages.PrevOperationNotCompleteYet);
            }

            Save.Press();
            CheckExpensesOnHold();

            List <CARegister> list = new List <CARegister>();
            CATran            tran = PXSelect <CATran, Where <CATran.tranID, Equal <Required <CATransfer.tranIDIn> > > > .Select(this, transfer.TranIDIn);

            if (tran != null)
            {
                list.Add(CATrxRelease.CARegister(transfer, tran));
            }
            else
            {
                throw new PXException(Messages.TransactionNotFound);
            }

            tran = PXSelect <CATran, Where <CATran.tranID, Equal <Required <CATransfer.tranIDOut> > > > .Select(this, transfer.TranIDOut);

            if (tran == null)
            {
                throw new PXException(Messages.TransactionNotFound);
            }

            PXLongOperation.StartOperation(this, delegate() { CATrxRelease.GroupRelease(list, false); });

            List <CATransfer> ret = new List <CATransfer>();

            ret.Add(transfer);
            return(ret);
        }
        public GLConsolSetupMaint()
        {
            GLSetup setup = glsetup.Current;

            ConsolSetupRecords.SetProcessCaption(Messages.ProcSynchronize);
            ConsolSetupRecords.SetProcessAllCaption(Messages.ProcSynchronizeAll);
            ConsolSetupRecords.SetProcessDelegate <GLConsolSetupMaint>(Synchronize);
            PXUIFieldAttribute.SetEnabled(ConsolSetupRecords.Cache, null, true);
            PXUIFieldAttribute.SetEnabled <GLConsolSetup.lastPostPeriod>(ConsolSetupRecords.Cache, null, false);
            PXUIFieldAttribute.SetEnabled <GLConsolSetup.lastConsDate>(ConsolSetupRecords.Cache, null, false);
            ConsolSetupRecords.SetAutoPersist(true);
            ConsolSetupRecords.Cache.AllowDelete = true;
            ConsolSetupRecords.Cache.AllowInsert = true;

            PXUIFieldAttribute.SetRequired <GLConsolSetup.segmentValue>(ConsolSetupRecords.Cache, true);
            PXUIFieldAttribute.SetRequired <GLConsolSetup.sourceLedgerCD>(ConsolSetupRecords.Cache, true);

            Save.StateSelectingEvents += new PXFieldSelecting(delegate(PXCache sender, PXFieldSelectingEventArgs e)
            {
                e.ReturnState = PXButtonState.CreateInstance(e.ReturnState, null, null, null, null, null, false,
                                                             PXConfirmationType.Unspecified, null, null, null, null, null, null, null, null, null, null, null, null);
                ((PXButtonState)e.ReturnState).Enabled = !PXLongOperation.Exists(this.UID);
            });
        }
示例#15
0
 private bool IsLongOperationProcessing(PXGraph graph) => PXLongOperation.Exists(graph);