protected virtual void CATransfer_OutAccountID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { CATransfer transfer = e.Row as CATransfer; CashAccount cashaccountOut = (CashAccount)PXSelectorAttribute.Select <CATransfer.outAccountID>(sender, e.Row); CurrencyInfo currinfo = CurInfoOUT.Select(); if (cashaccountOut?.CuryRateTypeID != null) { currinfo.CuryRateTypeID = cashaccountOut.CuryRateTypeID; } else { CMSetup cmsetup = PXSelect <CMSetup> .Select(this); if (!string.IsNullOrEmpty(cmsetup?.CARateTypeDflt)) { currinfo.CuryRateTypeID = cmsetup.CARateTypeDflt; } } sender.SetDefaultExt <CATransfer.outCuryID>(transfer); CurInfoOUT.Update(currinfo); if (cashaccountOut?.Reconcile != true) { transfer.ClearedOut = true; transfer.ClearDateOut = transfer.OutDate; } else { transfer.ClearedOut = false; transfer.ClearDateOut = null; } CurrencyInfoAttribute.SetEffectiveDate <CATransfer.outDate, CATransfer.outCuryInfoID>(sender, e); }
protected virtual void CATransfer_InAccountID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { CATransfer transfer = e.Row as CATransfer; CashAccount cashaccountIn = (CashAccount)PXSelectorAttribute.Select <CATransfer.inAccountID>(sender, transfer); CurrencyInfo currinfo = CurInfoIN.Select(); if (cashaccountIn?.CuryRateTypeID != null) { currinfo.CuryRateTypeID = cashaccountIn.CuryRateTypeID; } else { CMSetup cmsetup = PXSelect <CMSetup> .Select(this); if (!string.IsNullOrEmpty(cmsetup?.CARateTypeDflt)) { currinfo.CuryRateTypeID = cmsetup.CARateTypeDflt; } } sender.SetDefaultExt <CATransfer.inCuryID>(transfer); CurInfoIN.Cache.RaiseFieldUpdated <CurrencyInfo.curyRateTypeID>(currinfo, null); if (cashaccountIn?.Reconcile != true) { transfer.ClearedIn = true; transfer.ClearDateIn = transfer.InDate; } else { transfer.ClearedIn = false; transfer.ClearDateIn = null; } CurrencyInfoAttribute.SetEffectiveDate <CATransfer.inDate, CATransfer.inCuryInfoID>(sender, e); }
public virtual void VerifyCashAccountLinkOrMethodCanBeDeleted(CashAccount cashAccount) { if (cashAccount.UseForCorpCard == true) { throw new PXException(Messages.CashAccountLinkOrMethodCannotBeDeleted); } }
protected virtual void CABatch_RowSelected(PXCache sender, PXRowSelectedEventArgs e) { CABatch row = e.Row as CABatch; if (row == null) { return; } bool isReleased = (row.Released == true); PXUIFieldAttribute.SetEnabled(sender, row, false); PXUIFieldAttribute.SetEnabled <CABatch.batchNbr>(sender, row, true); bool isProcessing = row.Processing ?? false; PXUIFieldAttribute.SetEnabled <CABatch.processing>(sender, row, true); bool allowDelete = !isReleased; if (allowDelete) { allowDelete = !(this.ReleasedPayments.Select(row.BatchNbr).Count > 0); } sender.AllowDelete = allowDelete; CashAccount cashaccount = (CashAccount)PXSelectorAttribute.Select <CABatch.cashAccountID>(sender, row); bool clearEnabled = (row.Released != true) && (cashaccount != null) && (cashaccount.Reconcile == true); if (!isReleased) { PXUIFieldAttribute.SetEnabled <CABatch.hold>(sender, row, !isReleased); PXUIFieldAttribute.SetEnabled <CABatch.tranDesc>(sender, row, !isReleased); PXUIFieldAttribute.SetEnabled <CABatch.tranDate>(sender, row, !isReleased); PXUIFieldAttribute.SetEnabled <CABatch.batchSeqNbr>(sender, row, !isReleased); PXUIFieldAttribute.SetEnabled <CABatch.extRefNbr>(sender, row, !isReleased); PXUIFieldAttribute.SetEnabled <CABatch.released>(sender, row, true); bool hasDetails = this.BatchPayments.Select().Count > 0; PXUIFieldAttribute.SetEnabled <CABatch.paymentMethodID>(sender, row, !hasDetails && !isReleased); PXUIFieldAttribute.SetEnabled <CABatch.cashAccountID>(sender, row, !hasDetails && !isReleased); if (hasDetails) { decimal?curyTotal = Decimal.Zero, total = Decimal.Zero; this.CalcDetailsTotal(ref curyTotal, ref total); row.DetailTotal = total; row.CuryTotal = curyTotal; } } PXUIFieldAttribute.SetVisible <CABatch.curyDetailTotal>(sender, row, isReleased); PXUIFieldAttribute.SetVisible <CABatch.curyTotal>(sender, row, !isReleased); PXUIFieldAttribute.SetEnabled <CABatch.exportFileName>(sender, row, isProcessing); PXUIFieldAttribute.SetEnabled <CABatch.exportTime>(sender, row, isProcessing); PXUIFieldAttribute.SetVisible <CABatch.dateSeqNbr>(sender, row, isReleased); this.Release.SetEnabled(!isReleased && (row.Hold == false)); this.Export.SetEnabled(isReleased); //this.addExtPayment.SetEnabled(!isReleased); }
protected virtual void CAExpense_CashAccountID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { CAExpense expense = e.Row as CAExpense; CashAccount cashaccount = (CashAccount)PXSelectorAttribute.Select <CAExpense.cashAccountID>(sender, e.Row); UpdateCuryInfoExpense(sender, expense); if (cashaccount?.Reconcile != true) { expense.Cleared = true; expense.ClearDate = expense.TranDate; } else { expense.Cleared = false; expense.ClearDate = null; } CurrencyInfo currinfo = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CAExpense.curyInfoID> >, And <CurrencyInfo.curyID, Equal <Required <CAExpense.curyID> > > > > .Select(this, expense.CuryInfoID, expense.CuryID); if (currinfo != null) { CurrencyInfoAttribute.SetEffectiveDate <CAExpense.tranDate, CAExpense.curyInfoID>(sender, e); } }
protected virtual void CATransfer_InAccountID_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { CATransfer transfer = e.Row as CATransfer; CashAccount cashaccountIn = (CashAccount)PXSelectorAttribute.Select <CATransfer.inAccountID>(sender, transfer); sender.SetDefaultExt <CATransfer.inCuryID>(transfer); CurrencyInfo currinfo = CurInfoIN.Select(); if ((cashaccountIn != null) && (cashaccountIn.CuryRateTypeID != null)) { currinfo.CuryRateTypeID = cashaccountIn.CuryRateTypeID; CurInfoIN.Cache.RaiseFieldUpdated <CurrencyInfo.curyRateTypeID>(currinfo, null); } //CalculateCuryTranIn(transfer); transfer.ClearedIn = false; transfer.ClearDateIn = null; if ((cashaccountIn != null) && (cashaccountIn.Reconcile != true)) { transfer.ClearedIn = true; transfer.ClearDateIn = transfer.InDate; } }
private static void ValidateCADailySummary(CATranEntryLight graph, CashAccount cashAccount, IFinPeriod period) { using (new PXConnectionScope()) { using (PXTransactionScope ts = new PXTransactionScope()) { graph.dailycache.Clear(); ts.Complete(graph); } } PXDatabase.Delete <CADailySummary>( new PXDataFieldRestrict(nameof(CADailySummary.CashAccountID), PXDbType.Int, 4, cashAccount.CashAccountID, PXComp.EQ), new PXDataFieldRestrict(nameof(CADailySummary.TranDate), PXDbType.DateTime, 8, period.StartDate, PXComp.GE)); foreach (CATran tran in PXSelect <CATran, Where <CATran.cashAccountID, Equal <Required <CATran.cashAccountID> >, And <CATran.tranDate, GreaterEqual <Required <CATran.tranDate> > > > > .Select(graph, cashAccount.CashAccountID, period.StartDate)) { CADailyAccumulatorAttribute.RowInserted <CATran.tranDate>(graph.catrancache, tran); } graph.dailycache.Persist(PXDBOperation.Insert); graph.dailycache.Persist(PXDBOperation.Update); graph.dailycache.Persisted(false); }
protected virtual void CASetup_RowUpdating(PXCache sender, PXRowUpdatingEventArgs e) { CASetup row = (CASetup)e.NewRow; if (e.NewRow == null || row == null || row.TransitAcctId == null) { return; } CashAccount cashAccount = PXSelect <CashAccount, Where <CashAccount.accountID, Equal <Required <CASetup.transitAcctId> > > > .Select( this, row.TransitAcctId); if (cashAccount == null) { return; } if (cashAccount.SubID != (int)row.TransitSubID) { Sub subAccount = PXSelect <Sub, Where <Sub.subID, Equal <Required <CASetup.transitSubID> > > > .Select( this, row.TransitSubID); sender.RaiseExceptionHandling <CASetup.transitSubID>(row, subAccount.SubCD, new PXSetPropertyException(Messages.WrongSubIdForCashAccount)); } }
protected virtual void CAEntryType_RowUpdating(PXCache sender, PXRowUpdatingEventArgs e) { CAEntryType row = e.NewRow as CAEntryType; if (row.AccountID != null) { Account currentAcc = PXSelect <Account, Where <Account.accountID, Equal <Required <Account.accountID> > > > .Select(this, row.AccountID); if (currentAcc.IsCashAccount == true) { CashAccount cashAccount = PXSelect <CashAccount, Where <CashAccount.accountID, Equal <Required <CashAccount.accountID> >, And <CashAccount.subID, Equal <Required <CashAccount.subID> >, And <CashAccount.branchID, Equal <Required <CashAccount.branchID> > > > > > .Select(this, row.AccountID, row.SubID, row.BranchID); if (cashAccount == null) { string branchCD = (string)PXSelectorAttribute.GetField(sender, row, typeof(CAEntryType.branchID).Name, row.BranchID, typeof(Branch.branchCD).Name); sender.RaiseExceptionHandling <CAEntryType.branchID>(row, branchCD, new PXSetPropertyException(Messages.NoCashAccountForBranchAndSub, PXErrorLevel.Error)); string subCD = (string)PXSelectorAttribute.GetField(sender, row, typeof(CAEntryType.subID).Name, row.SubID, typeof(Sub.subCD).Name); sender.RaiseExceptionHandling <CAEntryType.subID>(row, subCD, new PXSetPropertyException(Messages.NoCashAccountForBranchAndSub, PXErrorLevel.Error)); e.Cancel = true; return; } } } }
protected virtual void PaymentMethodAccount_RowPersisting(PXCache sender, PXRowPersistingEventArgs e) { PaymentMethodAccount row = (PaymentMethodAccount)e.Row; PXDefaultAttribute.SetPersistingCheck <PaymentMethodAccount.aPLastRefNbr>(sender, e.Row, row.APAutoNextNbr == true ? PXPersistingCheck.NullOrBlank : PXPersistingCheck.Nothing); if (row.APAutoNextNbr == true && row.APLastRefNbr == null) { sender.RaiseExceptionHandling <PaymentMethodAccount.aPAutoNextNbr>(row, row.APAutoNextNbr, new PXSetPropertyException(Messages.SpecifyLastRefNbr, GL.Messages.ModuleAP)); } if (row.ARAutoNextNbr == true && row.ARLastRefNbr == null) { sender.RaiseExceptionHandling <PaymentMethodAccount.aRAutoNextNbr>(row, row.ARAutoNextNbr, new PXSetPropertyException(Messages.SpecifyLastRefNbr, GL.Messages.ModuleAR)); } CashAccount cashAccount = PXSelectReadonly <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > > .Select(this, row.CashAccountID); if (cashAccount != null && cashAccount.Active != true) { string errorMsg = string.Format(CA.Messages.CashAccountInactive, cashAccount.CashAccountCD.Trim()); sender.RaiseExceptionHandling <PaymentMethodAccount.cashAccountID>(e.Row, cashAccount.CashAccountCD, new PXSetPropertyException(errorMsg, PXErrorLevel.Error)); } }
/// <summary> /// Handles the CA transaction detail <see cref="ICATranDetail.AccountID"/> field updated event. /// </summary> /// <param name="tranDetailsCache">The transaction details cache.</param> /// <param name="e">Field updated event arguments.</param> public static void OnAccountIdFieldUpdatedEvent(PXCache tranDetailsCache, PXFieldUpdatedEventArgs e) { ICATranDetail tranDetail = e.Row as ICATranDetail; if (tranDetail == null) { return; } Account glAccount = PXSelect <Account, Where <Account.accountID, Equal <Required <Account.accountID> > > > .Select(tranDetailsCache.Graph, tranDetail.AccountID); if (glAccount?.IsCashAccount != true) { return; } CashAccount cashAccount = GetCashAccount(tranDetailsCache.Graph, glAccount.AccountID, tranDetail.SubID, tranDetail.BranchID, doSearchWithSubsetsOfArgs: true); if (cashAccount != null) { tranDetailsCache.SetValueExt(tranDetail, nameof(ICATranDetail.BranchID), cashAccount.BranchID); tranDetailsCache.SetValueExt(tranDetail, nameof(ICATranDetail.SubID), cashAccount.SubID); } }
protected virtual void PaymentMethodAccount_RowSelected(PXCache cache, PXRowSelectedEventArgs e) { PaymentMethodAccount row = (PaymentMethodAccount)e.Row; if (row == null) { return; } if (string.IsNullOrEmpty(row.PaymentMethodID) == false) { PaymentMethod pt = PXSelect <PaymentMethod, Where <PaymentMethod.paymentMethodID, Equal <Required <PaymentMethod.paymentMethodID> > > > .Select(this, row.PaymentMethodID); bool enabled = (pt != null) && pt.APCreateBatchPayment == true; PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.aPBatchLastRefNbr>(cache, row, enabled); } if (row.CashAccountID.HasValue) { CashAccount c = PXSelectReadonly <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > > .Select(this, row.CashAccountID); PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.useForAP>(cache, row, (c != null)); } bool enableAP = row.UseForAP ?? false; bool enableAR = row.UseForAR ?? false; PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.aPIsDefault>(cache, e.Row, enableAP); PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.aPAutoNextNbr>(cache, e.Row, enableAP); PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.aPLastRefNbr>(cache, e.Row, enableAP); PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.aRIsDefault>(cache, e.Row, enableAR); PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.aRIsDefaultForRefund>(cache, e.Row, enableAR); PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.aRAutoNextNbr>(cache, e.Row, enableAR); PXUIFieldAttribute.SetEnabled <PaymentMethodAccount.aRLastRefNbr>(cache, e.Row, enableAR); }
protected static CashAccount GetCashAccount(CATran catran, PXGraph graph) { PXSelectBase <CashAccount> selectStatement = new PXSelectReadonly <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > >(graph); CashAccount cashacc = (CashAccount)selectStatement.View.SelectSingle(catran.CashAccountID); return(cashacc); }
public virtual void GetRange(DateTime date, string Range, int?cashAccountID, out DateTime?RangeStart, out DateTime?RangeEnd) { switch (Range) { case "W": RangeStart = date.AddDays(-1 * (PXDateTime.DayOfWeekOrdinal(date.DayOfWeek) - 1)); RangeEnd = date.AddDays(7 - PXDateTime.DayOfWeekOrdinal(date.DayOfWeek)); return; case "M": RangeStart = new DateTime(date.Year, date.Month, 1); RangeEnd = new DateTime(date.Year, date.Month, 1).AddMonths(1).AddDays(-1); return; case "P": CashAccount cashAccount = PXSelect <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > > .Select(this, cashAccountID); int?organizationID = PXAccess.GetParentOrganizationID(cashAccount?.BranchID); var period = FinPeriodRepository.FindFinPeriodByDate(date, organizationID); RangeStart = period?.StartDate; RangeEnd = period?.EndDate; return; case "D": default: RangeStart = date; RangeEnd = date; return; } }
public override int Persist(Type cacheType, PXDBOperation operation) { try { return(base.Persist(cacheType, operation)); } catch (PXDatabaseException e) { if (cacheType == typeof(PaymentMethodAccount) && (operation == PXDBOperation.Delete || operation == PXDBOperation.Command) && (e.ErrorCode == PXDbExceptions.DeleteForeignKeyConstraintViolation || e.ErrorCode == PXDbExceptions.DeleteReferenceConstraintViolation)) { CashAccount ca = PXSelect <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > > . Select(this, e.Keys[1]); string CashAccountCD = ca.CashAccountCD; throw new PXException(Messages.CannotDeletePaymentMethodAccount, e.Keys[0], CashAccountCD); } else { throw; } } }
private static void ValidateCleared(CATranEntryLight graph, CashAccount cashAccount, IFinPeriod period) { if (cashAccount.Reconcile != true) { graph.Clear(); using (new PXConnectionScope()) { using (PXTransactionScope ts = new PXTransactionScope()) { foreach (CATran catran in PXSelect <CATran, Where <CATran.cashAccountID, Equal <Required <CATran.cashAccountID> >, And <CATran.finPeriodID, GreaterEqual <Required <CATran.finPeriodID> > > > > .Select(graph, cashAccount.CashAccountID, period.FinPeriodID)) { if (cashAccount.Reconcile != true && (catran.Cleared != true || catran.TranDate == null)) { catran.Cleared = true; catran.ClearDate = catran.TranDate; } graph.catrancache.Update(catran); } graph.catrancache.Persist(PXDBOperation.Update); ts.Complete(graph); } graph.catrancache.Persisted(false); } } }
private static void Validate(CATranEntryLight graph, CashAccount cashAccount, CABalanceValidationPeriodFilter filter) { if (string.IsNullOrEmpty(filter.FinPeriodID)) { throw new PXException(GL.Messages.Prefix + ": " + GL.Messages.ProcessingRequireFinPeriodID); } MasterFinPeriod period = PXSelect <MasterFinPeriod, Where <MasterFinPeriod.finPeriodID, Equal <Required <MasterFinPeriod.finPeriodID> > > > .Select(graph, filter.FinPeriodID); if (period == null) { throw new PXException(GL.Messages.ProcessingRequireFinPeriodID); } ValidateAccount(graph, cashAccount); graph.Clear(); ValidateCleared(graph, cashAccount, period); graph.Clear(); ValidateCAAdjustments(graph, cashAccount, period); graph.Clear(); ValidateCATransfers(graph, cashAccount, period); graph.Clear(); ValidateCATrans(graph, cashAccount, period); graph.Clear(); ValidateCADailySummary(graph, cashAccount, period); }
protected virtual void CAEntryType_BranchID_FieldDefaulting(PXCache cache, PXFieldDefaultingEventArgs e) { CAEntryType row = (CAEntryType)e.Row; if (row == null) { return; } if (row.CashAccountID != null) { CashAccount acct = PXSelect <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > > .SelectWindowed(this, 0, 1, row.CashAccountID); if (acct != null) { e.NewValue = acct.BranchID; e.Cancel = true; } } else { e.NewValue = null; e.Cancel = true; } }
protected virtual IStatementReader CreateReader() { IStatementReader processor = null; bool importToSingleAccount = this.CASetup.Current.ImportToSingleAccount ?? false; string typeName = this.CASetup.Current.StatementImportTypeName; if (importToSingleAccount) { CashAccount acct = PXSelect <CashAccount, Where <CashAccount.cashAccountID, Equal <Optional <CABankTranHeader.cashAccountID> > > > .Select(this); if (acct != null) { typeName = acct.StatementImportTypeName; } } if (string.IsNullOrEmpty(typeName)) { return(processor); } try { Type processorType = System.Web.Compilation.PXBuildManager.GetType(typeName, true); processor = (IStatementReader)Activator.CreateInstance(processorType); } catch (Exception e) { throw new PXException(e, Messages.StatementServiceReaderCreationError, typeName); } return(processor); }
protected void CAExpense_RowSelected(PXCache sender, PXRowSelectedEventArgs e) { var expense = (CAExpense)e.Row; if (expense == null) { return; } CashAccount cashAccount = PXSelect <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CAExpense.cashAccountID> > > > .Select(this, expense.CashAccountID); CurrencyInfo curyInfo = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CAExpense.curyInfoID> >, And <CurrencyInfo.curyID, Equal <Required <CAExpense.curyID> > > > > .Select(this, expense.CuryInfoID, expense.CuryID); if (curyInfo == null) { return; } bool clearEnabled = expense.Released != true && cashAccount?.Reconcile == true; bool cureRateEnable = expense.CuryID != curyInfo.BaseCuryID; PXUIFieldAttribute.SetEnabled <CAExpense.cleared>(sender, expense, clearEnabled); PXUIFieldAttribute.SetEnabled <CAExpense.adjCuryRate>(sender, expense, cureRateEnable); if (Transfer.Current.Released != true && Transfer.Current.OutDate > expense.TranDate) { sender.RaiseExceptionHandling <CAExpense.tranDate>(expense, expense.TranDate, new PXSetPropertyException(Messages.EarlyExpenseDate, PXErrorLevel.Warning)); } else { sender.RaiseExceptionHandling <CAExpense.tranDate>(expense, expense.TranDate, null); } }
protected static void SetCleared(CATran catran, CashAccount cashAccount) { if (cashAccount != null && cashAccount.Reconcile == false && (catran.Cleared != true || catran.TranDate == null)) { catran.Cleared = true; catran.ClearDate = catran.TranDate; } }
protected virtual void CAEntryType_RowPersisting(PXCache sender, PXRowPersistingEventArgs e) { CAEntryType row = e.Row as CAEntryType; PXDefaultAttribute.SetPersistingCheck <CAEntryType.referenceID>(sender, e.Row, PXPersistingCheck.Nothing); if ((e.Operation & PXDBOperation.Command) == PXDBOperation.Update) { CAAdj foundCAAdj = PXSelectReadonly <CAAdj, Where <CAAdj.entryTypeID, Equal <Required <CAAdj.entryTypeID> > > > . Select(this, row.EntryTypeId); if (foundCAAdj != null) { CAEntryType foundCAEntryType = PXSelectReadonly <CAEntryType, Where <CAEntryType.entryTypeId, Equal <Required <CAEntryType.entryTypeId> > > > . Select(this, row.EntryTypeId); if (foundCAEntryType != null) { if (row.DrCr != foundCAEntryType.DrCr) { if (sender.RaiseExceptionHandling <CAEntryType.drCr>(e.Row, row.DrCr, new PXSetPropertyException(Messages.CantEditDisbReceipt, PXErrorLevel.RowError, typeof(CAEntryType.drCr).Name))) { throw new PXRowPersistingException(typeof(CAEntryType.drCr).Name, row.DrCr, Messages.CantEditDisbReceipt, typeof(CAEntryType.drCr).Name); } } if (row.Module != foundCAEntryType.Module) { if (sender.RaiseExceptionHandling <CAEntryType.module>(e.Row, row.Module, new PXSetPropertyException(Messages.CantEditModule, PXErrorLevel.RowError, typeof(CAEntryType.module).Name))) { throw new PXRowPersistingException(typeof(CAEntryType.module).Name, row.Module, Messages.CantEditModule, typeof(CAEntryType.module).Name); } } } } } if ((e.Operation & PXDBOperation.Command) != PXDBOperation.Delete) { if (row.UseToReclassifyPayments == true && row.AccountID.HasValue) { CashAccount cashAcct = PXSelectReadonly <CashAccount, Where <CashAccount.accountID, Equal <Required <CashAccount.accountID> >, And <CashAccount.subID, Equal <Required <CashAccount.subID> > > > > .Select(this, row.AccountID, row.SubID); GL.Account acct = PXSelectReadonly <Account, Where <Account.accountID, Equal <Required <Account.accountID> > > > .Select(this, row.AccountID); if (cashAcct == null || !cashAcct.AccountID.HasValue) { if (sender.RaiseExceptionHandling <CAEntryType.accountID>(e.Row, acct.AccountCD, new PXSetPropertyException(Messages.CAEntryTypeUsedForPaymentReclassificationMustHaveCashAccount, PXErrorLevel.Error))) { throw new PXRowPersistingException(typeof(CAEntryType.accountID).Name, acct.AccountCD, Messages.CAEntryTypeUsedForPaymentReclassificationMustHaveCashAccount); } } } } }
protected virtual void CATransfer_RowSelected(PXCache sender, PXRowSelectedEventArgs e) { CATransfer transfer = (CATransfer)e.Row; if (transfer == null) { return; } transfer.RGOLAmt = transfer.TranIn - transfer.TranOut; bool transferOnHold = (transfer.Hold == true); bool transferNotReleased = (transfer.Released != true); bool transferReleased = (transfer.Released == true); PXUIFieldAttribute.SetVisible <CATransfer.inGLBalance>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetVisible <CATransfer.outGLBalance>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetVisible <CATransfer.cashBalanceIn>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetVisible <CATransfer.cashBalanceOut>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetVisible <CATransfer.tranIDIn_CATran_batchNbr>(sender, transfer, transferReleased); PXUIFieldAttribute.SetVisible <CATransfer.tranIDOut_CATran_batchNbr>(sender, transfer, transferReleased); PXUIFieldAttribute.SetEnabled(sender, transfer, false); sender.AllowDelete = transferNotReleased; sender.AllowUpdate = transferNotReleased; Expenses.Cache.SetAllEditPermissions(transferNotReleased); CashAccount cashaccountOut = (CashAccount)PXSelectorAttribute.Select <CATransfer.outAccountID>(sender, e.Row); CashAccount cashaccountIn = (CashAccount)PXSelectorAttribute.Select <CATransfer.inAccountID>(sender, e.Row); bool clearEnabledIn = transferNotReleased && (cashaccountIn != null) && (cashaccountIn.Reconcile == true); bool clearEnabledOut = transferNotReleased && (cashaccountOut != null) && (cashaccountOut.Reconcile == true); PXUIFieldAttribute.SetEnabled <CATransfer.hold>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.transferNbr>(sender, transfer, true); PXUIFieldAttribute.SetEnabled <CATransfer.descr>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.curyTranIn>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.inAccountID>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.inDate>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.inExtRefNbr>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.curyTranOut>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.outAccountID>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.outDate>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.outExtRefNbr>(sender, transfer, transferNotReleased); PXUIFieldAttribute.SetEnabled <CATransfer.clearedOut>(sender, transfer, clearEnabledOut); PXUIFieldAttribute.SetEnabled <CATransfer.clearDateOut>(sender, transfer, clearEnabledOut && transfer.ClearedOut == true); PXUIFieldAttribute.SetEnabled <CATransfer.clearedIn>(sender, transfer, clearEnabledIn); PXUIFieldAttribute.SetEnabled <CATransfer.clearDateIn>(sender, transfer, clearEnabledIn && transfer.ClearedIn == true); Release.SetEnabled(transferNotReleased && !transferOnHold); Reverse.SetEnabled(transferReleased); UIState.RaiseOrHideErrorByErrorLevelPriority <CATransfer.inDate>(sender, transfer, transfer.Released != true && transfer.OutDate > transfer.InDate, Messages.EarlyInDate, PXErrorLevel.Warning); SetAdjRefNbrVisibility(); }
private void ValidateCuryID(PXCache sender, CashForecastTran row, string CuryID) { CashAccount acct = PXSelect <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > > .Select(this, filter.Current.CashAccountID); if (acct.CuryID != CuryID) { cashForecastTrans.Cache.RaiseExceptionHandling <CashForecastTran.curyID>(row, CuryID, new PXRowPersistingException(typeof(CashForecastTran.curyID).Name, CuryID, Messages.TranCuryNotMatchAcctCury)); } }
protected virtual void CurrencyInfo_CuryRateTypeID_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e) { if (PXAccess.FeatureInstalled <FeaturesSet.multicurrency>() != true) { CashAccount cashAcc = cashaccount.Current; if (cashAcc != null && !string.IsNullOrEmpty(cashAcc.CuryRateTypeID)) { e.NewValue = cashAcc.CuryRateTypeID; e.Cancel = true; } } }
/// <summary> /// Duplicates <see cref="UpdateCuryInfoExpense(PXCache, CAExpense)"/>. Should be refactored. /// </summary> public virtual void CATransfer_RowInserted(PXCache sender, PXRowInsertedEventArgs e) { var row = (CATransfer)e.Row; CashAccount cashaccountOut = (CashAccount)PXSelectorAttribute.Select <CATransfer.outAccountID>(sender, row); CurrencyInfo currinfoOut = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CATransfer.outCuryInfoID> >, And <CurrencyInfo.curyID, Equal <Required <CATransfer.outCuryID> > > > > .Select(this, row.OutCuryInfoID, row.OutCuryID); if (currinfoOut == null) { return; } if (cashaccountOut?.CuryRateTypeID != null) { currinfoOut.CuryRateTypeID = cashaccountOut.CuryRateTypeID; } else { CMSetup cmsetup = PXSelect <CMSetup> .Select(this); if (!string.IsNullOrEmpty(cmsetup?.CARateTypeDflt)) { currinfoOut.CuryRateTypeID = cmsetup.CARateTypeDflt; } } CuryInfo.Update(currinfoOut); CashAccount cashaccountIn = (CashAccount)PXSelectorAttribute.Select <CATransfer.outAccountID>(sender, row); CurrencyInfo currinfoIn = PXSelect <CurrencyInfo, Where <CurrencyInfo.curyInfoID, Equal <Required <CATransfer.inCuryInfoID> >, And <CurrencyInfo.curyID, Equal <Required <CATransfer.inCuryID> > > > > .Select(this, row.InCuryInfoID, row.InCuryID); if (cashaccountIn == null) { return; } if (cashaccountIn?.CuryRateTypeID != null) { currinfoIn.CuryRateTypeID = cashaccountIn.CuryRateTypeID; } else { CMSetup cmsetup = PXSelect <CMSetup> .Select(this); if (!string.IsNullOrEmpty(cmsetup?.CARateTypeDflt)) { currinfoIn.CuryRateTypeID = cmsetup.CARateTypeDflt; } } CuryInfo.Update(currinfoIn); }
protected virtual void CurrencyInfo_CuryRateTypeID_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e) { CashAccount acct = this.cashAccount.Current; if (acct != null) { if (acct != null && !string.IsNullOrEmpty(acct.CuryRateTypeID)) { e.NewValue = acct.CuryRateTypeID; e.Cancel = true; } } }
public virtual string GenerateFileName(CABatch aBatch) { if (aBatch.CashAccountID != null && !string.IsNullOrEmpty(aBatch.PaymentMethodID)) { CashAccount acct = PXSelect <CashAccount, Where <CashAccount.cashAccountID, Equal <Required <CashAccount.cashAccountID> > > > .Select(this, aBatch.CashAccountID); if (acct != null) { return(string.Format(Messages.CABatchDefaultExportFilenameTemplate, aBatch.PaymentMethodID, acct.CashAccountCD, aBatch.TranDate.Value, aBatch.DateSeqNbr)); } } return(string.Empty); }
protected virtual void CATransfer_InDate_FieldUpdated(PXCache sender, PXFieldUpdatedEventArgs e) { CATransfer transfer = e.Row as CATransfer; if (transfer.ClearedIn == true) { CashAccount cashaccountIn = (CashAccount)PXSelectorAttribute.Select <CATransfer.inAccountID>(sender, e.Row); if ((cashaccountIn != null) && (cashaccountIn.Reconcile != true)) { transfer.ClearDateIn = transfer.InDate; } } }
/// <summary> /// Handles the CA transaction detail row updating event. /// </summary> /// <param name="tranDetailsCache">The transaction details cache.</param> /// <param name="e">Row updating event arguments.</param> public static void OnCATranDetailRowUpdatingEvent(PXCache tranDetailsCache, PXRowUpdatingEventArgs e) { ICATranDetail oldTranDetail = e.Row as ICATranDetail; ICATranDetail newTranDetail = e.NewRow as ICATranDetail; if (newTranDetail == null || tranDetailsCache == null) { return; } UpdateNewTranDetailCuryTranAmtOrCuryUnitPrice(tranDetailsCache, oldTranDetail, newTranDetail); if (newTranDetail.AccountID == null) { return; } Account currentAcc = PXSelect <Account, Where <Account.accountID, Equal <Required <Account.accountID> > > > . Select(tranDetailsCache.Graph, newTranDetail.AccountID); if (currentAcc?.IsCashAccount != true) { return; } CashAccount cashAccount = GetCashAccount(tranDetailsCache.Graph, newTranDetail.AccountID, newTranDetail.SubID, newTranDetail.BranchID, doSearchWithSubsetsOfArgs: false); if (cashAccount == null) { PXSetPropertyException exception = new PXSetPropertyException(Messages.NoCashAccountForBranchAndSub, PXErrorLevel.Error); string branchCD = (string)PXSelectorAttribute.GetField(tranDetailsCache, newTranDetail, nameof(ICATranDetail.BranchID), newTranDetail.BranchID, typeof(Branch.branchCD).Name); string subCD = (string)PXSelectorAttribute.GetField(tranDetailsCache, newTranDetail, nameof(ICATranDetail.SubID), newTranDetail.SubID, typeof(Sub.subCD).Name); tranDetailsCache.RaiseExceptionHandling(nameof(ICATranDetail.BranchID), newTranDetail, branchCD, exception); tranDetailsCache.RaiseExceptionHandling(nameof(ICATranDetail.SubID), newTranDetail, subCD, exception); e.Cancel = true; } }