public virtual void InsertSOAdjustments(SOOrder order, ARPaymentEntry docgraph, ARPayment payment, InsertSOAdjustmentsDelegate baseMethod) { baseMethod(order, docgraph, payment); SOOrderRUTROT orderRR = RUTROTHelper.GetExtensionNullable <SOOrder, SOOrderRUTROT>(order); if (orderRR.IsRUTROTDeductible == true) { RUTROT rutrot = PXSelect <RUTROT, Where <RUTROT.docType, Equal <Required <SOOrder.orderType> >, And <RUTROT.refNbr, Equal <Required <SOOrder.orderNbr> > > > > .Select(Base, order.OrderType, order.OrderNbr); foreach (SOAdjust adj in docgraph.SOAdjustments.Select()) { SOAdjust other = PXSelectGroupBy <SOAdjust, Where <SOAdjust.voided, Equal <False>, And <SOAdjust.adjdOrderType, Equal <Required <SOAdjust.adjdOrderType> >, And <SOAdjust.adjdOrderNbr, Equal <Required <SOAdjust.adjdOrderNbr> >, And <Where <SOAdjust.adjgDocType, NotEqual <Required <SOAdjust.adjgDocType> >, Or <SOAdjust.adjgRefNbr, NotEqual <Required <SOAdjust.adjgRefNbr> > > > > > > >, Aggregate <GroupBy <SOAdjust.adjdOrderType, GroupBy <SOAdjust.adjdOrderNbr, Sum <SOAdjust.curyAdjdAmt, Sum <SOAdjust.adjAmt> > > > > > .Select(Base, adj.AdjdOrderType, adj.AdjdOrderNbr, adj.AdjgDocType, adj.AdjgRefNbr); if (other == null || other.AdjdOrderNbr == null) { docgraph.SOAdjustments.Cache.SetValueExt <SOAdjust.curyAdjgAmt>(adj, adj.CuryAdjgAmt - rutrot.CuryTotalAmt); docgraph.SOAdjustments.Update(adj); } } } }
protected virtual void CRCampaign_RowPersisting(PXCache cache, PXRowPersistingEventArgs e) { CRCampaign row = (CRCampaign)e.Row; if (row != null) { if (row.StartDate.HasValue == false) { if (cache.RaiseExceptionHandling <CRCampaign.startDate>(e.Row, null, new PXSetPropertyException(ErrorMessages.FieldIsEmpty, typeof(CRCampaign.startDate).Name))) { throw new PXRowPersistingException(typeof(CRCampaign.startDate).Name, null, ErrorMessages.FieldIsEmpty, typeof(CRCampaign.startDate).Name); } } if (row.ProjectID.HasValue && !row.ProjectTaskID.HasValue) { if (cache.RaiseExceptionHandling <CRCampaign.projectTaskID>(e.Row, null, new PXSetPropertyException(ErrorMessages.FieldIsEmpty, typeof(CRCampaign.projectTaskID).Name))) { throw new PXRowPersistingException(typeof(CRCampaign.projectTaskID).Name, null, ErrorMessages.FieldIsEmpty, typeof(CRCampaign.projectTaskID).Name); } } if (row.ProjectTaskID.HasValue) { if (PXSelectGroupBy <CRCampaign, Where <CRCampaign.projectID, Equal <Required <CRCampaign.projectID> >, And <CRCampaign.projectTaskID, Equal <Required <CRCampaign.projectTaskID> >, And <CRCampaign.campaignID, NotEqual <Required <CRCampaign.campaignID> > > > >, Aggregate <Count> > .Select(this, new object[] { row.ProjectID, row.ProjectTaskID, row.CampaignID }).RowCount > 0) { throw new PXRowPersistingException(typeof(CRCampaign.projectTaskID).Name, row.ProjectTaskID, Messages.TaskIsAlreadyLinkedToCampaign, typeof(CRCampaign.projectTaskID).Name); } } } }
/// <summary> /// Gets documents which has been reported in the tax period. /// </summary> public IEnumerable <DocumentID> GetReportedDocuments(int?branchID, int?taxAgency, string taxPeriodID) { var childBranchIds = PXAccess.GetChildBranchIDs(GetBranchByID(branchID).BranchCD); return(PXSelectGroupBy <TaxTran, Where <TaxTran.branchID, In <Required <TaxTran.branchID> >, And <TaxTran.vendorID, Equal <Required <TaxTran.vendorID> >, And <TaxTran.taxPeriodID, Equal <Required <TaxTran.taxPeriodID> >, And <TaxTran.voided, Equal <False>, And <TaxTran.released, Equal <True> > > > > >, Aggregate <GroupBy <TaxTran.refNbr, GroupBy <TaxTran.tranType> > > > .Select(_graph, childBranchIds, taxAgency, taxPeriodID) .Select(row => { var taxTran = (TaxTran)row; return new DocumentID() { DocType = taxTran.TranType, RefNbr = taxTran.RefNbr, Module = taxTran.Module }; })); }
protected virtual void PMTask_CompletedPct_FieldSelecting(PXCache sender, PXFieldSelectingEventArgs e) { PMTask row = e.Row as PMTask; if (row != null) { PXSelectBase <PMProjectStatus> select = new PXSelectGroupBy <PMProjectStatus, Where <PMProjectStatus.projectID, Equal <Required <PMTask.projectID> >, And <PMProjectStatus.projectTaskID, Equal <Required <PMTask.taskID> >, And <PMProjectStatus.isProduction, Equal <True> > > >, Aggregate <GroupBy <PMProjectStatus.accountGroupID, GroupBy <PMProjectStatus.projectID, GroupBy <PMProjectStatus.projectTaskID, GroupBy <PMProjectStatus.inventoryID, Sum <PMProjectStatus.amount, Sum <PMProjectStatus.qty, Sum <PMProjectStatus.revisedAmount, Sum <PMProjectStatus.revisedQty, Sum <PMProjectStatus.actualAmount, Sum <PMProjectStatus.actualQty> > > > > > > > > > > >(this); PMProjectStatus ps = select.Select(row.ProjectID, row.TaskID); if (ps != null) { if (ps.RevisedQty > 0) { e.ReturnValue = Convert.ToInt32(100 * ps.ActualQty / ps.RevisedQty); e.ReturnState = PXFieldState.CreateInstance(e.ReturnValue, typeof(decimal?), false, false, 0, 0, 0, 0, "CompletedPct", null, null, null, PXErrorLevel.Undefined, false, true, true, PXUIVisibility.Visible, null, null, null); } } } }
public static int GetBookPeriodsInYear(PXGraph graph, int?BookID) { FABook book = PXSelect <FABook, Where <FABook.bookID, Equal <Required <FABook.bookID> > > > .Select(graph, BookID); IPeriodSetup periodsInYear; if (book.UpdateGL ?? false) { periodsInYear = (FinPeriodSetup)PXSelectGroupBy <FinPeriodSetup, Where <FinPeriodSetup.endDate, Greater <FinPeriodSetup.startDate> >, Aggregate <Max <FinPeriodSetup.periodNbr> > > .Select(graph); } else { periodsInYear = (FABookPeriodSetup)PXSelectGroupBy <FABookPeriodSetup, Where <FABookPeriodSetup.endDate, Greater <FABookPeriodSetup.startDate>, And <FABookPeriodSetup.bookID, Equal <Required <FABookPeriodSetup.bookID> > > >, Aggregate <Max <FABookPeriodSetup.periodNbr> > > .Select(graph, BookID); } if (periodsInYear == null || periodsInYear.PeriodNbr == null) { throw new PXFABookCalendarException(); } return(Convert.ToInt32(periodsInYear.PeriodNbr)); }
public static int?PeriodMinusPeriod(PXGraph graph, string FiscalPeriodID1, string FiscalPeriodID2, int?BookID) { // TODO: AC-106141 // Use BranchID (OrganizationID) passed as parameter int count = PXSelect < FABookPeriod, Where <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> >, And <Where <FABookPeriod.finPeriodID, Equal <Required <FABookPeriod.finPeriodID> >, Or <FABookPeriod.finPeriodID, Equal <Required <FABookPeriod.finPeriodID> > > > > > > .Select(graph, BookID, FiscalPeriodID1, FiscalPeriodID2) .Count; if (count < 2 && string.Equals(FiscalPeriodID1, FiscalPeriodID2) == false) { throw new PXException(Messages.NoCalendarDefined); } // TODO: AC-106141 // Use BranchID (OrganizationID) passed as parameter PXResult res = PXSelectGroupBy < FABookPeriod, Where <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> >, And <FABookPeriod.finPeriodID, LessEqual <Required <FABookPeriod.finPeriodID> >, And <FABookPeriod.finPeriodID, Greater <Required <FABookPeriod.finPeriodID> >, And <FABookPeriod.endDate, Greater <FABookPeriod.startDate> > > > >, Aggregate < GroupBy <FABookPeriod.bookID, Count> > > .Select(graph, BookID, FiscalPeriodID1, FiscalPeriodID2); return(res != null ? res.RowCount : null); }
private int?GetSubcontractReceiptsCount(POOrder purchaseOrder) { return(PXSelectGroupBy <POOrderReceipt, Where <POOrderReceipt.pONbr, Equal <Required <POOrder.orderNbr> >, And <POOrderReceipt.pOType, Equal <Required <POOrder.orderType> > > >, Aggregate <Count> > .Select(this, purchaseOrder.OrderNbr, purchaseOrder.OrderType).RowCount); }
private int?GetSubcontractBillsGeneratedCount(POOrder purchaseOrder) { return(PXSelectGroupBy <APTran, Where <APTran.pONbr, Equal <Required <POOrder.orderNbr> >, And <APTran.pOOrderType, Equal <Required <POOrder.orderType> > > >, Aggregate <Count> > .Select(this, purchaseOrder.OrderNbr, purchaseOrder.OrderType).RowCount); }
internal static void CheckVehiclesLicense(PXGraph graph, int?SMEquipmentID, string status) { if (SMEquipmentID != null && status != null && status != EPEquipmentStatus.Active) { return; } if (PXAccess.FeatureInstalled <FeaturesSet.routeManagementVehiclesPackUnlimited>() == true) { return; } int vehiclesCount = (int)PXSelectGroupBy <FSEquipment, Where < FSEquipment.status, Equal <EPEquipmentStatus.EquipmentStatusActive>, And < FSEquipment.isVehicle, Equal <True>, And < Where2 < Where <Required <FSEquipment.SMequipmentID>, IsNull>, Or <FSEquipment.SMequipmentID, NotEqual <Required <FSEquipment.SMequipmentID> > > > > > >, Aggregate <Count> > .Select(graph, SMEquipmentID, SMEquipmentID).RowCount; if (SMEquipmentID != null && status != null && status == EPEquipmentStatus.Active) { vehiclesCount += 1; } CheckVehiclesLicense(vehiclesCount); }
/// <summary> /// Allows to calculate the <c>RefNbr</c> sequence when trying to insert a new register /// It's called from the Persisting event of FSServiceContract. /// </summary> protected override bool SetRefNbr(PXCache cache, object row) { FSServiceContract fsServiceContractRow = (FSServiceContract)row; FSServiceContract fsServiceContractRow_tmp = PXSelectGroupBy <FSServiceContract, Where < FSServiceContract.customerID, Equal <Current <FSServiceContract.customerID> > >, Aggregate < Max <FSServiceContract.refNbr, GroupBy < FSServiceContract.customerID> > > > .Select(cache.Graph); string refNbr = fsServiceContractRow_tmp == null ? null : fsServiceContractRow_tmp.RefNbr; if (string.IsNullOrEmpty(refNbr)) { refNbr = initialRefNbr; } else { refNbr = (int.Parse(refNbr) + 1).ToString().PadLeft(initialRefNbr.Length, '0'); } fsServiceContractRow.RefNbr = refNbr; return(true); }
public static string PeriodPlusPeriod(PXGraph graph, string FiscalPeriodID, int counter, int?BookID) { FABook book = PXSelect <FABook, Where <FABook.bookID, Equal <Required <FABook.bookID> > > > .Select(graph, BookID); IYearSetup setup; if (book.UpdateGL == true) { setup = (FinYearSetup)PXSelect <FinYearSetup> .Select(graph); } else { setup = (FABookYearSetup)PXSelect <FABookYearSetup, Where <FABookYearSetup.bookID, Equal <Required <FABookYearSetup.bookID> > > > .Select(graph, BookID); } IPeriodSetup periodsInYear; if (book.UpdateGL == true) { periodsInYear = (FinPeriodSetup)PXSelectGroupBy <FinPeriodSetup, Where <FinPeriodSetup.endDate, Greater <FinPeriodSetup.startDate> >, Aggregate <Max <FinPeriodSetup.periodNbr> > > .Select(graph); } else { periodsInYear = (FABookPeriodSetup)PXSelectGroupBy <FABookPeriodSetup, Where <FABookPeriodSetup.endDate, Greater <FABookPeriodSetup.startDate>, And <FABookPeriodSetup.bookID, Equal <Required <FABookPeriodSetup.bookID> > > >, Aggregate <Max <FABookPeriodSetup.periodNbr> > > .Select(graph, BookID); } if (setup != null && FiscalPeriodSetupCreator.IsFixedLengthPeriod(setup.FPType) && periodsInYear != null && periodsInYear.PeriodNbr != null) { return(OffsetPeriod(graph, FiscalPeriodID, counter, Convert.ToInt32(periodsInYear.PeriodNbr))); } else if (counter > 0) { PXResultset <FABookPeriod> res = PXSelect <FABookPeriod, Where <FABookPeriod.finPeriodID, Greater <Required <FABookPeriod.finPeriodID> >, And <FABookPeriod.startDate, NotEqual <FABookPeriod.endDate>, And <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> > > > >, OrderBy <Asc <FABookPeriod.finPeriodID> > > .SelectWindowed(graph, 0, counter, FiscalPeriodID, BookID); if (res.Count < counter) { throw new PXFABookPeriodException(); } return(((FABookPeriod)res[res.Count - 1]).FinPeriodID); } else if (counter < 0) { PXResultset <FABookPeriod> res = PXSelect <FABookPeriod, Where <FABookPeriod.finPeriodID, Less <Required <FABookPeriod.finPeriodID> >, And <FABookPeriod.startDate, NotEqual <FABookPeriod.endDate>, And <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> > > > >, OrderBy <Desc <FABookPeriod.finPeriodID> > > .SelectWindowed(graph, 0, -counter, FiscalPeriodID, BookID); if (res.Count < -counter) { throw new PXFABookPeriodException(); } return(((FABookPeriod)res[res.Count - 1]).FinPeriodID); } else { return(FiscalPeriodID); } }
protected virtual void Ledger_RowSelected(PXCache cache, PXRowSelectedEventArgs e) { Ledger ledger = e.Row as Ledger; if (ledger != null && ledger.LedgerID.HasValue) { //Type and Currency are forbidden for changses for the used accounts bool hasHistory = GLUtility.IsLedgerHistoryExist(this, ledger.LedgerID); PXUIFieldAttribute.SetEnabled <Ledger.balanceType>(LedgerRecords.Cache, ledger, !hasHistory); PXUIFieldAttribute.SetEnabled <Ledger.baseCuryID>(LedgerRecords.Cache, ledger, !hasHistory && PXAccess.FeatureInstalled <FeaturesSet.multicurrency>()); } if (ledger != null) { PXUIFieldAttribute.SetEnabled <Ledger.postInterCompany>(cache, e.Row, ledger.BalanceType == LedgerBalanceType.Actual && ledger.DefBranchID != null); PXUIFieldAttribute.SetEnabled <Ledger.defBranchID>(cache, e.Row, ledger.BalanceType == LedgerBalanceType.Actual); if (ledger.BalanceType == LedgerBalanceType.Actual && ledger.DefBranchID != null) { using (new PXReadBranchRestrictedScope()) { GLHistory hist = PXSelectReadonly <GLHistory, Where <GLHistory.ledgerID, Equal <Current <Ledger.ledgerID> >, And <GLHistory.branchID, Equal <Current <Ledger.defBranchID> > > > > .SelectWindowed(this, 0, 1); PXResultset <GLHistory> hist2 = PXSelectGroupBy <GLHistory, Where <GLHistory.ledgerID, Equal <Current <Ledger.ledgerID> > >, Aggregate <GroupBy <GLHistory.branchID> > > .Select(this); PXUIFieldAttribute.SetEnabled <Ledger.postInterCompany>(cache, e.Row, (hist2.Count <= 1)); PXUIFieldAttribute.SetEnabled <Ledger.defBranchID>(cache, e.Row, (hist == null)); } } } }
public virtual void EMailAccount_RowSelected(PXCache sender, PXRowSelectedEventArgs e) { var row = e.Row as EMailAccount; if (row == null) { return; } var outbox = PXSelectGroupBy <EPActivity, Where <EPActivity.mailAccountID, Equal <Required <EPActivity.mailAccountID> >, And <EPActivity.mpstatus, Equal <MailStatusListAttribute.preProcess>, And <EPActivity.isIncome, NotEqual <True> > > >, Aggregate <Count> > . Select(this, row.EmailAccountID). RowCount ?? 0; row.OutboxCount = outbox; var inbox = PXSelectGroupBy <EPActivity, Where <EPActivity.mailAccountID, Equal <Required <EPActivity.mailAccountID> >, And <EPActivity.mpstatus, Equal <MailStatusListAttribute.preProcess>, And <EPActivity.isIncome, Equal <True> > > >, Aggregate <Count> > . Select(this, row.EmailAccountID). RowCount ?? 0; row.InboxCount = inbox; }
public virtual void EnsureCanCancel(ARInvoice doc, bool isCorrection) { if (doc.DocType != ARDocType.Invoice) { throw new PXException(Messages.CantCancelDocType, doc.DocType); } if (doc.InstallmentCntr > 0) { throw new PXException(Messages.CantCancelMultipleInstallmentsInvoice); } var arAdjustGroups = PXSelectGroupBy <ARAdjust, Where <ARAdjust.adjdDocType, Equal <Current <ARInvoice.docType> >, And <ARAdjust.adjdRefNbr, Equal <Current <ARInvoice.refNbr> > > >, Aggregate < GroupBy <ARAdjust.adjgDocType, GroupBy <ARAdjust.adjgRefNbr, GroupBy <ARAdjust.released, Sum <ARAdjust.curyAdjdAmt> > > > > > .SelectMultiBound(Base, new[] { doc }) .RowCast <ARAdjust>().ToList(); if (arAdjustGroups.Any(a => a.Released == false)) { throw new PXException(Messages.CantCancelInvoiceWithUnreleasedApplications); } var nonReversedCreditMemo = arAdjustGroups.FirstOrDefault(a => a.CuryAdjdAmt != 0m && a.AdjgDocType == ARDocType.CreditMemo); if (nonReversedCreditMemo != null) { throw new PXException(Messages.CantCancelInvoiceWithCM, nonReversedCreditMemo.AdjdRefNbr, nonReversedCreditMemo.AdjgRefNbr); } var nonReversedApplication = arAdjustGroups.FirstOrDefault(a => a.CuryAdjdAmt != 0m); if (nonReversedApplication != null) { throw new PXException(Messages.CantCancelInvoiceWithPayment, nonReversedApplication.AdjdRefNbr, nonReversedApplication.AdjgRefNbr); } ARTran directSale = PXSelectReadonly <ARTran, Where <ARTran.tranType, Equal <Current <ARInvoice.docType> >, And <ARTran.refNbr, Equal <Current <ARInvoice.refNbr> >, And <ARTran.invtMult, NotEqual <short0>, And <ARTran.lineType, Equal <SOLineType.inventory> > > > > > .SelectSingleBound(Base, new[] { doc }); if (directSale != null) { throw new PXException(Messages.CantCancelInvoiceWithDirectStockSales, doc.RefNbr); } SOOrderShipment notRequireShipment = PXSelectReadonly <SOOrderShipment, Where <SOOrderShipment.invoiceType, Equal <Current <ARInvoice.docType> >, And <SOOrderShipment.invoiceNbr, Equal <Current <ARInvoice.refNbr> >, And <SOOrderShipment.shipmentNbr, Equal <Constants.noShipmentNbr> > > > > .SelectSingleBound(Base, new[] { doc }); if (notRequireShipment != null) { throw new PXException(Messages.CantCancelInvoiceWithOrdersNotRequiringShipments, doc.RefNbr); } }
public FinPeriod FindOffsetPeriod(string finPeriodID, int offset, int?organizationID) { FinYearSetup setup = PXSelect <FinYearSetup> .Select(Graph); //TODO: Need to refactor, duplicates the part of function FABookPeriodIDAttribute.GetBookPeriodsInYear FinPeriodSetup periodsInYear = PXSelectGroupBy <FinPeriodSetup, Where <FinPeriodSetup.endDate, Greater <FinPeriodSetup.startDate> >, Aggregate <Max <FinPeriodSetup.periodNbr> > > .Select(Graph); if (setup != null && FiscalPeriodSetupCreator.IsFixedLengthPeriod(setup.FPType) && periodsInYear != null && periodsInYear.PeriodNbr != null) { string offsetFinPeriodID = FinPeriodUtils.OffsetPeriod(finPeriodID, offset, Convert.ToInt32(periodsInYear.PeriodNbr)); return(FindByID(organizationID, offsetFinPeriodID)); } else if (offset > 0) { PXResultset <FinPeriod> res = PXSelect < FinPeriod, Where < FinPeriod.finPeriodID, Greater <Required <FinPeriod.finPeriodID> >, And <FinPeriod.startDate, NotEqual <FinPeriod.endDate>, And <FinPeriod.organizationID, Equal <Required <FinPeriod.organizationID> > > > >, OrderBy < Asc <FinPeriod.finPeriodID> > > .SelectWindowed(Graph, 0, offset, finPeriodID, organizationID); if (res.Count < offset) { return(null); } return((FinPeriod)res[res.Count - 1]); } else if (offset < 0) { PXResultset <FinPeriod> res = PXSelect < FinPeriod, Where < FinPeriod.finPeriodID, Less <Required <FinPeriod.finPeriodID> >, And <FinPeriod.startDate, NotEqual <FinPeriod.endDate>, And <FinPeriod.organizationID, Equal <Required <FinPeriod.organizationID> > > > >, OrderBy < Desc <FinPeriod.finPeriodID> > > .SelectWindowed(Graph, 0, -offset, finPeriodID, organizationID); if (res.Count < -offset) { return(null); } return((FinPeriod)res[res.Count - 1]); } else { return(FindByID(organizationID, finPeriodID)); } }
protected virtual void PMTask_CompletedPercent_FieldSelecting(PXCache sender, PXFieldSelectingEventArgs e) { PMTask row = e.Row as PMTask; if (row != null && row.CompletedPctMethod != PMCompletedPctMethod.Manual) { PXSelectBase <PMCostBudget> select = new PXSelectGroupBy <PMCostBudget, Where <PMCostBudget.projectID, Equal <Required <PMTask.projectID> >, And <PMCostBudget.projectTaskID, Equal <Required <PMTask.taskID> >, And <PMCostBudget.isProduction, Equal <True> > > >, Aggregate < GroupBy <PMCostBudget.accountGroupID, GroupBy <PMCostBudget.inventoryID, GroupBy <PMCostBudget.uOM, Sum <PMCostBudget.amount, Sum <PMCostBudget.qty, Sum <PMCostBudget.curyRevisedAmount, Sum <PMCostBudget.revisedQty, Sum <PMCostBudget.actualAmount, Sum <PMCostBudget.actualQty> > > > > > > > > > >(this); PXResultset <PMCostBudget> ps = select.Select(row.ProjectID, row.TaskID); if (ps != null) { double percentSum = 0; Int32 recordCount = 0; decimal actualAmount = 0; decimal revisedAmount = 0; foreach (PMCostBudget item in ps) { if (row.CompletedPctMethod == PMCompletedPctMethod.ByQuantity && item.RevisedQty > 0) { recordCount++; percentSum += Convert.ToDouble(100 * item.ActualQty / item.RevisedQty); } else if (row.CompletedPctMethod == PMCompletedPctMethod.ByAmount) { recordCount++; actualAmount += item.CuryActualAmount.GetValueOrDefault(0); revisedAmount += item.CuryRevisedAmount.GetValueOrDefault(0); } } if (row.CompletedPctMethod == PMCompletedPctMethod.ByAmount) { e.ReturnValue = revisedAmount == 0 ? 0 : Convert.ToDecimal(100 * actualAmount / revisedAmount); } else { e.ReturnValue = Convert.ToDecimal(percentSum) == 0 ? 0 : Convert.ToDecimal(percentSum / recordCount); } e.ReturnState = PXFieldState.CreateInstance(e.ReturnValue, typeof(decimal?), false, false, 0, 2, 0, 0, nameof(PMTask.completedPercent), null, null, null, PXErrorLevel.Undefined, false, true, true, PXUIVisibility.Visible, null, null, null); } } }
public int?GetMaxGAFMajorVersion(GAFPeriod gafPeriod) { var gafPeriodWithMaxMajorVersion = (GAFPeriod)PXSelectGroupBy <GAFPeriod, Where <GAFPeriod.branchID, Equal <Required <GAFPeriod.branchID> >, And <GAFPeriod.taxAgencyID, Equal <Required <GAFPeriod.taxAgencyID> > > >, Aggregate <Max <GAFPeriod.gafMajorVersion> > > .Select(_graph, gafPeriod.BranchID, gafPeriod.TaxAgencyID); return(gafPeriodWithMaxMajorVersion.GAFMajorVersion); }
private bool CanBeDeleted(CRCampaign campaign, DAC.Standalone.CRCampaign dacCampaign) { foreach (var f in new string[] { nameof(CRCampaign.mailsSent) }) { var state = CampaignCurrent.Cache.GetStateExt(campaign, f); if (((PXIntState)state).Value != null && (int)((PXIntState)state).Value > 0) { return(false); } } foreach (var f in new string[] { nameof(DAC.Standalone.CRCampaign.closedOpportunities), nameof(DAC.Standalone.CRCampaign.contacts), nameof(DAC.Standalone.CRCampaign.leadsConverted), nameof(DAC.Standalone.CRCampaign.leadsGenerated), nameof(DAC.Standalone.CRCampaign.opportunities), }) { var state = CalcCampaignCurrent.Cache.GetStateExt(dacCampaign, f); if (((PXIntState)state).Value != null && (int)((PXIntState)state).Value > 0) { return(false); } } if (PXSelectGroupBy <SOOrder, Where <SOOrder.campaignID, Equal <Current <CRCampaign.campaignID> > >, Aggregate <Count> > .Select(this).RowCount > 0) { return(false); } if (PXSelectGroupBy <ARInvoice, Where <ARInvoice.campaignID, Equal <Current <CRCampaign.campaignID> > >, Aggregate <Count> > .Select(this).RowCount > 0) { return(false); } if (PXSelectGroupBy <PMProject, Where <PMProject.campaignID, Equal <Current <CRCampaign.campaignID> > >, Aggregate <Count> > .Select(this).RowCount > 0) { return(false); } return(true); }
public virtual void FieldSelecting(PXCache sender, PXFieldSelectingEventArgs e) { CASetup caSetup = PXSelect <CASetup> .Select(sender.Graph); decimal?result = 0m; object cashAccountID = sender.GetValue(e.Row, _CashAccount); CADailySummary caBalance = PXSelectGroupBy <CADailySummary, Where <CADailySummary.cashAccountID, Equal <Required <CADailySummary.cashAccountID> > >, Aggregate <Sum <CADailySummary.amtReleasedClearedCr, Sum <CADailySummary.amtReleasedClearedDr, Sum <CADailySummary.amtReleasedUnclearedCr, Sum <CADailySummary.amtReleasedUnclearedDr, Sum <CADailySummary.amtUnreleasedClearedCr, Sum <CADailySummary.amtUnreleasedClearedDr, Sum <CADailySummary.amtUnreleasedUnclearedCr, Sum <CADailySummary.amtUnreleasedUnclearedDr> > > > > > > > > > . Select(sender.Graph, cashAccountID); if ((caBalance != null) && (caBalance.CashAccountID != null)) { result = caBalance.AmtReleasedClearedDr - caBalance.AmtReleasedClearedCr; if ((bool)caSetup.CalcBalDebitClearedUnreleased) { result += caBalance.AmtUnreleasedClearedDr; } if ((bool)caSetup.CalcBalCreditClearedUnreleased) { result -= caBalance.AmtUnreleasedClearedCr; } if ((bool)caSetup.CalcBalDebitUnclearedReleased) { result += caBalance.AmtReleasedUnclearedDr; } if ((bool)caSetup.CalcBalCreditUnclearedReleased) { result -= caBalance.AmtReleasedUnclearedCr; } if ((bool)caSetup.CalcBalDebitUnclearedUnreleased) { result += caBalance.AmtUnreleasedUnclearedDr; } if ((bool)caSetup.CalcBalCreditUnclearedUnreleased) { result -= caBalance.AmtUnreleasedUnclearedCr; } } e.ReturnValue = result; e.Cancel = true; }
private DateTime GetLowerDateBoundForRatesSelection(PXGraph graph, IEnumerable <string> fromCuryIDs, DateTime minDate) { var ratesBottomDateBounds = PXSelectGroupBy <CurrencyRate, Where <CurrencyRate.toCuryID, Equal <Required <CurrencyRate.toCuryID> >, And <CurrencyRate.fromCuryID, In <Required <CurrencyRate.fromCuryID> >, And <CurrencyRate.curyRateType, Equal <Required <CurrencyRate.curyRateType> >, And <CurrencyRate.curyEffDate, LessEqual <Required <CurrencyRate.curyEffDate> > > > > >, Aggregate < GroupBy <CurrencyRate.fromCuryID, Max <CurrencyRate.curyEffDate> > > > .Select(graph, _toCuryID, fromCuryIDs.ToArray(), _rateType, minDate); return(ratesBottomDateBounds.RowCast <CurrencyRate>().Select(cr => cr.CuryEffDate).Min() ?? minDate); }
protected virtual void ValidateSubItems() { //1.Validate that trimming segmented key will not cause duplicate values int?length = Header.Current.Length; foreach (PXResult <INSubItem> record in PXSelectGroupBy <INSubItem, Aggregate <GroupBy <Left <INSubItem.subItemCD, CurrentValue <Dimension.length> >, Count> > > .Select(this)) { if (record.RowCount > 1) { throw new PXRowPersistingException(typeof(Dimension.length).Name, length, Messages.InSubitemDuplicate); } } }
public static int CustomerProfileCountPerCustomer(PXGraph graph, int?aBAccountID, string aCCProcessingCenterID) { PXResult <CustomerProcessingCenterID> result = PXSelectGroupBy <CustomerProcessingCenterID, Where <CustomerProcessingCenterID.bAccountID, Equal <Required <CustomerPaymentMethod.bAccountID> >, And <CustomerProcessingCenterID.cCProcessingCenterID, Equal <Required <CustomerPaymentMethod.cCProcessingCenterID> > > >, Aggregate <Count <CustomerProcessingCenterID.customerCCPID> > > .Select(graph, aBAccountID, aCCProcessingCenterID); int customerProfileCount = result.RowCount ?? 0; return(customerProfileCount); }
public TWNGUITrans InitAndCheckOnAR(string gUINbr, string vATOutCode) { SequenceNo = (int)PXSelectGroupBy <TWNGUITrans, Where <TWNGUITrans.gUINbr, Equal <Required <TWNGUITrans.gUINbr> >, And <TWNGUITrans.gUIFormatcode, Equal <Required <TWNGUITrans.gUIFormatcode> > > >, Aggregate <Count> > .Select(this, gUINbr, vATOutCode).RowCount; TWNGUIValidation gUIValidation = new TWNGUIValidation(); gUIValidation.CheckCorrespondingInv(this, gUINbr, vATOutCode); return(gUIValidation.tWNGUITrans); }
public static int?LogSubmitCount(SOPartialMaint logGraph, string integrationID, int?TotalRecordsToSubmit) { SOSubmitProcessLog processcount = new SOSubmitProcessLog(); processcount.ProcessDate = PX.Common.PXTimeZoneInfo.Now; processcount.TotalRecordstoProcess = TotalRecordsToSubmit; processcount.SubmitRecordsCount = 0; processcount.SubmitFailedRecordsCount = 0; processcount.IntegrationID = integrationID; logGraph.SubmitProcesLog.Insert(processcount); logGraph.Actions.PressSave(); SOSubmitProcessLog getProcessId = PXSelectGroupBy <SOSubmitProcessLog, Aggregate <Max <SOSubmitProcessLog.processID> > > .Select(logGraph); return(getProcessId != null && getProcessId.ProcessID != null ? getProcessId.ProcessID : 1); }
public static int GetBookPeriodsInYear(PXGraph graph,FABook book, int Year) { FABookYear year = GetBookYear(graph, book.BookID, Year); if (year == null) { throw new PXException(Messages.FABookPeriodsNotDefined, book.BookCode, Year); } return PXSelectGroupBy<FABookPeriod, Where<FABookPeriod.bookID, Equal<Required<FABookPeriod.bookID>>, And<FABookPeriod.finYear, Equal<Required<FABookPeriod.finYear>>, And<FABookPeriod.startDate, NotEqual<FABookPeriod.endDate>>>>, Aggregate<Count<FABookPeriod.finPeriodID>>> .Select(graph, book.BookID, year.Year).RowCount ?? 0; }
protected void FSBillingCycle_RowPersisting(PXCache cache, PXRowPersistingEventArgs e) { if (e.Row == null) { return; } FSBillingCycle fsBillingCycleRow = (FSBillingCycle)e.Row; if (fsBillingCycleRow.BillingBy == ID.Billing_By.SERVICE_ORDER && fsBillingCycleRow.BillingCycleType == ID.Billing_Cycle_Type.APPOINTMENT) { throw new PXException(TX.Error.CANT_DEFINE_BILLING_CYCLE_BILLED_BY_SERVICE_ORDER_AND_GROUPED_BY_APPOINTMENT); } if (e.Operation == PXDBOperation.Delete) { int billingCycleCount = (int)PXSelectGroupBy <FSCustomer, Where < FSxCustomer.billingCycleID, Equal <Required <FSxCustomer.billingCycleID> >, And <FSCustomerBillingSetup.active, Equal <True> > >, Aggregate <Count> > .Select(this, fsBillingCycleRow.BillingCycleID).RowCount; if (billingCycleCount > 0) { throw new PXException(TX.Error.BILLING_CYCLE_ERROR_DELETING_CUSTOMER_USING_IT, fsBillingCycleRow); } else { billingCycleCount = (int)PXSelectGroupBy <FSCustomerBillingSetup, Where < FSCustomerBillingSetup.billingCycleID, Equal <Required <FSCustomerBillingSetup.billingCycleID> > >, Aggregate <Count> > .Select(this, fsBillingCycleRow.BillingCycleID).RowCount; if (billingCycleCount > 0) { throw new PXException(TX.Error.BILLING_CYCLE_ERROR_DELETING_CUSTOMER_USING_IT, fsBillingCycleRow); } } } if (e.Operation == PXDBOperation.Update) { VerifyPrepaidContractRelated(cache, fsBillingCycleRow); } }
public int?PeriodMinusPeriod(string finPeriodID1, string finPeriodID2, int?bookID, int?assetID) { FABookPeriodRepository.CheckNotNullOrEmptyStringContract(finPeriodID1, nameof(finPeriodID1)); FABookPeriodRepository.CheckNotNullOrEmptyStringContract(finPeriodID2, nameof(finPeriodID2)); FABookPeriodRepository.CheckNotNullIDContract(bookID, nameof(bookID)); FABookPeriodRepository.CheckNotNullIDContract(assetID, nameof(assetID)); int count = PXSelect < FABookPeriod, Where <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> >, And <FABookPeriod.organizationID, Equal <Required <FABookPeriod.organizationID> >, And <Where <FABookPeriod.finPeriodID, Equal <Required <FABookPeriod.finPeriodID> >, Or <FABookPeriod.finPeriodID, Equal <Required <FABookPeriod.finPeriodID> > > > > > > > .Select( Graph, bookID, FABookPeriodRepositoryHelper.GetFABookPeriodOrganizationID(bookID, assetID), finPeriodID1, finPeriodID2) .Count; if (count < 2 && string.Equals(finPeriodID1, finPeriodID2) == false) { throw new PXException(Messages.NoCalendarDefined); } PXResult res = PXSelectGroupBy < FABookPeriod, Where <FABookPeriod.bookID, Equal <Required <FABookPeriod.bookID> >, And <FABookPeriod.organizationID, Equal <Required <FABookPeriod.organizationID> >, And <FABookPeriod.finPeriodID, LessEqual <Required <FABookPeriod.finPeriodID> >, And <FABookPeriod.finPeriodID, Greater <Required <FABookPeriod.finPeriodID> >, And <FABookPeriod.endDate, Greater <FABookPeriod.startDate> > > > > >, Aggregate < GroupBy <FABookPeriod.bookID, GroupBy <FABookPeriod.organizationID, Count> > > > .Select( Graph, bookID, FABookPeriodRepositoryHelper.GetFABookPeriodOrganizationID(bookID, assetID), finPeriodID1, finPeriodID2); return(res != null ? res.RowCount : null); }
/// <summary> /// Allows to calculate the <c>RefNbr</c> sequence when trying to insert a new register /// It's called from the Persisting event of FSServiceContract. /// </summary> protected override bool SetRefNbr(PXCache cache, object row) { FSServiceContract fsServiceContractRow = (FSServiceContract)row; FSServiceContract fsServiceContractRowTmp = PXSelectGroupBy <FSServiceContract, Where < FSServiceContract.customerID, Equal <Current <FSServiceContract.customerID> > >, Aggregate < Max <FSServiceContract.customerContractNbr, GroupBy <FSServiceContract.customerID> > > > .Select(cache.Graph); string lastRefNbr = fsServiceContractRowTmp?.CustomerContractNbr; fsServiceContractRow.CustomerContractNbr = GetNextRefNbr(null, lastRefNbr); return(true); }
/// <summary> /// Return the last FSContractGenerationHistory. /// </summary> protected FSContractGenerationHistory getLastGenerationHistoryRow(string recordType) { FSContractGenerationHistory fsContractGenerationHistoryRow = PXSelectGroupBy <FSContractGenerationHistory, Where < FSContractGenerationHistory.recordType, Equal <Required <FSContractGenerationHistory.recordType> > >, Aggregate < Max <FSContractGenerationHistory.generationID> > > .Select(this, recordType); if (fsContractGenerationHistoryRow != null && fsContractGenerationHistoryRow.GenerationID != null) { return(fsContractGenerationHistoryRow); } else { return(null); } }
/// <summary> /// Return the last FSContractGenerationHistory by Schedule. /// </summary> public FSContractGenerationHistory GetLastGenerationHistoryRowBySchedule(int scheduleID) { FSContractGenerationHistory fsContractGenerationHistoryRow = PXSelectGroupBy <FSContractGenerationHistory, Where < FSContractGenerationHistory.scheduleID, Equal <Required <FSContractGenerationHistory.scheduleID> > >, Aggregate < Max <FSContractGenerationHistory.generationID> > > .Select(this, scheduleID); if (fsContractGenerationHistoryRow != null && fsContractGenerationHistoryRow.GenerationID != null) { return(fsContractGenerationHistoryRow); } else { return(null); } }