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);
}
}
