protected override bool PrepareInsert(PXCache sender, object row, PXAccumulatorCollection columns)
{
if (!base.PrepareInsert(sender, row, columns))
{
return(false);
}
PMHistory hist = (PMHistory)row;
columns.RestrictPast <PMHistory.periodID>(PXComp.GE, hist.PeriodID.Substring(0, 4) + "01");
columns.RestrictFuture <PMHistory.periodID>(PXComp.LE, hist.PeriodID.Substring(0, 4) + "99");
return(true);
}
public virtual Result Calculate(PMTran pmt, PMAccountGroup ag, Account acc, int mult)
{
PMBudget status = SelectProjectBalance(pmt);
int? inventoryID = status != null ? status.InventoryID : PMInventorySelectorAttribute.EmptyInventoryID;
int? costCodeID = status != null ? status.CostCodeID : CostCodeAttribute.GetDefaultCostCode();
RollupQty rollup = null;
if (settings.CostBudgetUpdateMode == CostBudgetUpdateModes.Detailed && ag.IsExpense == true && pmt.InventoryID != settings.EmptyInventoryID)
{
if (status == null || status.InventoryID == settings.EmptyInventoryID)
{
rollup = new RollupQty(pmt.UOM, pmt.Qty);
inventoryID = pmt.InventoryID;
if (pmt.CostCodeID != null)
{
costCodeID = pmt.CostCodeID;
}
}
}
if (rollup == null)
{
rollup = CalculateRollupQty(pmt, status);
}
List <PMHistory> list = new List <PMHistory>();
PMTaskTotal ta = null;
PMBudget ps = null;
if (pmt.TaskID != null && (rollup.Qty != 0 || pmt.Amount != 0)) //TaskID will be null for Contract
{
ps = new PMBudget();
ps.ProjectID = pmt.ProjectID;
ps.ProjectTaskID = pmt.TaskID;
ps.AccountGroupID = ag.GroupID;
if (ag.Type == PMAccountType.OffBalance)
{
ps.Type = ag.IsExpense == true ? GL.AccountType.Expense : ag.Type;
}
else
{
ps.Type = ag.Type;
}
ps.InventoryID = inventoryID;
ps.CostCodeID = costCodeID;
ps.UOM = rollup.UOM;
if (status != null)
{
ps.IsProduction = status.IsProduction;
}
decimal amt = mult * pmt.Amount.GetValueOrDefault();
if (!string.IsNullOrEmpty(ps.UOM))
{
ps.ActualQty = rollup.Qty; // commented out otherwise invoice produces -ve Qty. * mult;
}
ps.ActualAmount = amt;
#region PMTask Totals Update
ta = new PMTaskTotal();
ta.ProjectID = pmt.ProjectID;
ta.TaskID = pmt.TaskID;
string accType = null;
int multFix = 1; //flip back the sign if it was changed because of ag.Type<>acc.type
if (pmt.TranType == BatchModule.PM && acc != null && !string.IsNullOrEmpty(acc.Type))
{
//Only transactions that originated in PM were inverted and require to be fixed.
accType = ag.Type;
if (acc.Type != ag.Type)
{
multFix = -1;
}
}
else
{
accType = ag.Type;
}
switch (accType)
{
case AccountType.Asset:
ta.Asset = amt * multFix;
break;
case AccountType.Liability:
ta.Liability = amt * multFix;
break;
case AccountType.Income:
ta.Income = amt * multFix;
break;
case AccountType.Expense:
ta.Expense = amt * multFix;
break;
}
#endregion
#region History
PMHistory hist = new PMHistory();
hist.ProjectID = pmt.ProjectID;
hist.ProjectTaskID = pmt.TaskID;
hist.AccountGroupID = ag.GroupID;
hist.InventoryID = pmt.InventoryID ?? PMInventorySelectorAttribute.EmptyInventoryID;
hist.CostCodeID = pmt.CostCodeID ?? CostCodeAttribute.GetDefaultCostCode();
hist.PeriodID = pmt.FinPeriodID;
decimal baseQty = 0;
list.Add(hist);
if (pmt.InventoryID != null && pmt.InventoryID != PMInventorySelectorAttribute.EmptyInventoryID && pmt.Qty != 0 && !string.IsNullOrEmpty(rollup.UOM))
{
if (PXAccess.FeatureInstalled <FeaturesSet.multipleUnitMeasure>())
{
baseQty = mult * IN.INUnitAttribute.ConvertToBase(graph.Caches[typeof(PMHistory)], pmt.InventoryID, pmt.UOM, pmt.Qty.Value, PX.Objects.IN.INPrecision.QUANTITY);
}
else
{
IN.InventoryItem initem = PXSelectorAttribute.Select <PMTran.inventoryID>(graph.Caches[typeof(PMTran)], pmt) as IN.InventoryItem;
if (initem != null)
{
baseQty = mult * IN.INUnitAttribute.ConvertGlobalUnits(graph, pmt.UOM, initem.BaseUnit, pmt.Qty ?? 0, IN.INPrecision.QUANTITY);
}
}
}
hist.FinPTDAmount = amt;
hist.FinYTDAmount = amt;
hist.FinPTDQty = baseQty;
hist.FinYTDQty = baseQty;
if (pmt.FinPeriodID == pmt.TranPeriodID)
{
hist.TranPTDAmount = amt;
hist.TranYTDAmount = amt;
hist.TranPTDQty = baseQty;
hist.TranYTDQty = baseQty;
}
else
{
PMHistory tranHist = new PMHistory();
tranHist.ProjectID = pmt.ProjectID;
tranHist.ProjectTaskID = pmt.TaskID;
tranHist.AccountGroupID = ag.GroupID;
tranHist.InventoryID = pmt.InventoryID ?? PM.PMInventorySelectorAttribute.EmptyInventoryID;
tranHist.CostCodeID = pmt.CostCodeID ?? CostCodeAttribute.GetDefaultCostCode();
tranHist.PeriodID = pmt.TranPeriodID;
list.Add(tranHist);
tranHist.TranPTDAmount = amt;
tranHist.TranYTDAmount = amt;
tranHist.TranPTDQty = baseQty;
tranHist.TranYTDQty = baseQty;
}
#endregion
}
return(new Result(list, ps, ta));
}
/// <summary>
/// Updates Project Status Balance using PMProjectStatusAccum.
/// </summary>
public static IList <PMHistory> UpdateProjectBalance(PXGraph graph, PMTran pmt, PMAccountGroup ag, Account acc, int mult)
{
List <PMHistory> list = new List <PMHistory>();
PXSelectBase <PMProjectStatus> selectProjectStatus = new PXSelect <PMProjectStatus,
Where <PMProjectStatus.accountGroupID, Equal <Required <PMProjectStatus.accountGroupID> >,
And <PMProjectStatus.projectID, Equal <Required <PMProjectStatus.projectID> >,
And <PMProjectStatus.projectTaskID, Equal <Required <PMProjectStatus.projectTaskID> >,
And <PMProjectStatus.inventoryID, Equal <Required <PMProjectStatus.inventoryID> > > > > > >(graph); // select any without restricting by FinPeriod
int inventoryID = PMProjectStatus.EmptyInventoryID;
PMProjectStatus status = null;
if (pmt.InventoryID != null)
{
status = selectProjectStatus.Select(ag.GroupID, pmt.ProjectID, pmt.TaskID, pmt.InventoryID);
if (status == null)
{
status = selectProjectStatus.Select(ag.GroupID, pmt.ProjectID, pmt.TaskID, PMProjectStatus.EmptyInventoryID);
}
else
{
inventoryID = status.InventoryID ?? PMProjectStatus.EmptyInventoryID;
}
}
else
{
status = selectProjectStatus.Select(ag.GroupID, pmt.ProjectID, pmt.TaskID, PMProjectStatus.EmptyInventoryID);
}
string UOM = null;
decimal rollupQty = 0;
if (status == null)
{
//Status does not exist for given Inventory and <Other> is not present.
}
else
{
if (status.InventoryID == PMProjectStatus.EmptyInventoryID)
{
//<Other> item is present. Update only if UOMs are same.
decimal convertedQty;
if (IN.INUnitAttribute.TryConvertGlobalUnits(graph, pmt.UOM, status.UOM, pmt.Qty.GetValueOrDefault(), IN.INPrecision.QUANTITY, out convertedQty))
{
rollupQty = convertedQty;
UOM = status.UOM;
}
}
else
{
UOM = status.UOM;
//Item matches. Convert to UOM of ProjectStatus.
if (status.UOM != pmt.UOM)
{
decimal inBase = IN.INUnitAttribute.ConvertToBase(graph.Caches[pmt.GetType()], pmt.InventoryID, pmt.UOM, pmt.Qty ?? 0, IN.INPrecision.QUANTITY);
try
{
rollupQty = IN.INUnitAttribute.ConvertFromBase(graph.Caches[pmt.GetType()], pmt.InventoryID, status.UOM, inBase, IN.INPrecision.QUANTITY);
}
catch (PX.Objects.IN.PXUnitConversionException ex)
{
IN.InventoryItem item = PXSelect <IN.InventoryItem, Where <IN.InventoryItem.inventoryID, Equal <Required <IN.InventoryItem.inventoryID> > > > .Select(graph, pmt.InventoryID);
string msg = PXMessages.LocalizeFormatNoPrefixNLA(Messages.UnitConversionNotDefinedForItemOnBudgetUpdate, item.BaseUnit, status.UOM, item.InventoryCD);
throw new PXException(msg, ex);
}
}
else
{
rollupQty = pmt.Qty ?? 0;
}
}
}
if (pmt.TaskID != null && (rollupQty != 0 || pmt.Amount != 0)) //TaskID will be null for Contract
{
PMProjectStatusAccum ps = new PMProjectStatusAccum();
ps.PeriodID = pmt.FinPeriodID;
ps.ProjectID = pmt.ProjectID;
ps.ProjectTaskID = pmt.TaskID;
ps.AccountGroupID = ag.GroupID;
ps.InventoryID = inventoryID;
ps.UOM = UOM;
if (status != null)
{
ps.IsProduction = status.IsProduction;
}
ps = (PMProjectStatusAccum)graph.Caches[typeof(PMProjectStatusAccum)].Insert(ps);
decimal amt = mult * pmt.Amount.GetValueOrDefault();
ps.ActualQty += rollupQty * mult;
ps.ActualAmount += amt;
graph.Views.Caches.Add(typeof(PMProjectStatusAccum));
#region PMTask Totals Update
PMTaskTotal ta = new PMTaskTotal();
ta.ProjectID = pmt.ProjectID;
ta.TaskID = pmt.TaskID;
ta = (PMTaskTotal)graph.Caches[typeof(PMTaskTotal)].Insert(ta);
string accType = null;
int multFix = 1; //flip back the sign if it was changed because of ag.Type<>acc.type
if (pmt.TranType == BatchModule.PM && acc != null && !string.IsNullOrEmpty(acc.Type))
{
//Only transactions that originated in PM were inverted and require to be fixed.
accType = ag.Type;
if (acc.Type != ag.Type)
{
multFix = -1;
}
}
else
{
accType = ag.Type;
}
switch (accType)
{
case AccountType.Asset:
ta.Asset += amt * multFix;
break;
case AccountType.Liability:
ta.Liability += amt * multFix;
break;
case AccountType.Income:
ta.Income += amt * multFix;
break;
case AccountType.Expense:
ta.Expense += amt * multFix;
break;
}
graph.Views.Caches.Add(typeof(PMTaskTotal));
#endregion
#region History
PMHistory hist = new PMHistory();
hist.ProjectID = pmt.ProjectID;
hist.ProjectTaskID = pmt.TaskID;
hist.AccountGroupID = ag.GroupID;
hist.InventoryID = pmt.InventoryID ?? PMProjectStatus.EmptyInventoryID;
hist.PeriodID = pmt.FinPeriodID;
decimal baseQty = 0;
list.Add(hist);
if (pmt.InventoryID != null && pmt.InventoryID != PMInventorySelectorAttribute.EmptyInventoryID && rollupQty != 0)
{
baseQty = mult * PX.Objects.IN.INUnitAttribute.ConvertToBase(graph.Caches[typeof(PMHistory)], pmt.InventoryID, UOM, rollupQty, PX.Objects.IN.INPrecision.QUANTITY);
}
hist.FinPTDAmount = amt;
hist.FinYTDAmount = amt;
hist.FinPTDQty = baseQty;
hist.FinYTDQty = baseQty;
if (pmt.FinPeriodID == pmt.TranPeriodID)
{
hist.TranPTDAmount = amt;
hist.TranYTDAmount = amt;
hist.TranPTDQty = baseQty;
hist.TranYTDQty = baseQty;
}
else
{
PMHistory tranHist = new PMHistory();
tranHist.ProjectID = pmt.ProjectID;
tranHist.ProjectTaskID = pmt.TaskID;
tranHist.AccountGroupID = ag.GroupID;
tranHist.InventoryID = pmt.InventoryID ?? PM.PMProjectStatus.EmptyInventoryID;
tranHist.PeriodID = pmt.TranPeriodID;
list.Add(tranHist);
tranHist.TranPTDAmount = amt;
tranHist.TranYTDAmount = amt;
tranHist.TranPTDQty = baseQty;
tranHist.TranYTDQty = baseQty;
}
#endregion
}
return(list);
}
public virtual Result Calculate(PMProject project, PMTran pmt, PMAccountGroup ag, string accountType, int amountSign, int qtySign)
{
PMBudgetLite target = null;
bool isExisting;
target = service.SelectProjectBalance(pmt, ag, project, out isExisting);
var rollupQty = CalculateRollupQty(pmt, target);
List <PMHistory> list = new List <PMHistory>();
PMTaskTotal ta = null;
PMBudget ps = null;
PMForecastHistory forecast = null;
if (pmt.TaskID != null && (rollupQty != 0 || pmt.Amount != 0)) //TaskID will be null for Contract
{
ps = new PMBudget();
ps.ProjectID = target.ProjectID;
ps.ProjectTaskID = target.TaskID;
ps.AccountGroupID = target.AccountGroupID;
ps.Type = target.Type;
ps.InventoryID = target.InventoryID;
ps.CostCodeID = target.CostCodeID;
ps.UOM = target.UOM;
ps.IsProduction = target.IsProduction;
ps.Description = target.Description;
if (ps.CuryInfoID == null)
{
ps.CuryInfoID = project.CuryInfoID;
}
decimal amt = amountSign * pmt.Amount.GetValueOrDefault();
decimal curyAmt = amountSign * pmt.ProjectCuryAmount.GetValueOrDefault();
ps.ActualQty = rollupQty * qtySign;
ps.ActualAmount = amt;
ps.CuryActualAmount = curyAmt;
#region PMTask Totals Update
ta = new PMTaskTotal();
ta.ProjectID = ps.ProjectID;
ta.TaskID = ps.TaskID;
string accType = ag.IsExpense == true ? AccountType.Expense : ag.Type;
switch (accType)
{
case AccountType.Asset:
ta.CuryAsset = curyAmt;
ta.Asset = amt;
break;
case AccountType.Liability:
ta.CuryLiability = curyAmt;
ta.Liability = amt;
break;
case AccountType.Income:
ta.CuryIncome = curyAmt;
ta.Income = amt;
break;
case AccountType.Expense:
ta.CuryExpense = curyAmt;
ta.Expense = amt;
break;
}
#endregion
#region History
PMHistory hist = new PMHistory();
hist.ProjectID = ps.ProjectID;
hist.ProjectTaskID = ps.TaskID;
hist.AccountGroupID = ps.AccountGroupID;
hist.InventoryID = pmt.InventoryID ?? ps.InventoryID;
hist.CostCodeID = pmt.CostCodeID ?? ps.CostCodeID;
hist.PeriodID = pmt.FinPeriodID;
hist.BranchID = pmt.BranchID;
decimal baseQty = 0;
list.Add(hist);
if (pmt.InventoryID != null && pmt.InventoryID != PMInventorySelectorAttribute.EmptyInventoryID && pmt.Qty != 0)
{
if (PXAccess.FeatureInstalled <FeaturesSet.multipleUnitMeasure>())
{
baseQty = qtySign * IN.INUnitAttribute.ConvertToBase(graph.Caches[typeof(PMHistory)], pmt.InventoryID, pmt.UOM, pmt.Qty.Value, PX.Objects.IN.INPrecision.QUANTITY);
}
else
{
IN.InventoryItem initem = PXSelectorAttribute.Select <PMTran.inventoryID>(graph.Caches[typeof(PMTran)], pmt) as IN.InventoryItem;
if (initem != null && !string.IsNullOrEmpty(pmt.UOM))
{
baseQty = qtySign * IN.INUnitAttribute.ConvertGlobalUnits(graph, pmt.UOM, initem.BaseUnit, pmt.Qty ?? 0, IN.INPrecision.QUANTITY);
}
}
}
hist.FinPTDCuryAmount = curyAmt;
hist.FinPTDAmount = amt;
hist.FinYTDCuryAmount = curyAmt;
hist.FinYTDAmount = amt;
hist.FinPTDQty = baseQty;
hist.FinYTDQty = baseQty;
if (pmt.FinPeriodID == pmt.TranPeriodID)
{
hist.TranPTDCuryAmount = curyAmt;
hist.TranPTDAmount = amt;
hist.TranYTDCuryAmount = curyAmt;
hist.TranYTDAmount = amt;
hist.TranPTDQty = baseQty;
hist.TranYTDQty = baseQty;
}
else
{
PMHistory tranHist = new PMHistory();
tranHist.ProjectID = ps.ProjectID;
tranHist.ProjectTaskID = ps.TaskID;
tranHist.AccountGroupID = ps.AccountGroupID;
tranHist.InventoryID = pmt.InventoryID ?? PM.PMInventorySelectorAttribute.EmptyInventoryID;
tranHist.CostCodeID = pmt.CostCodeID ?? CostCodeAttribute.GetDefaultCostCode();
tranHist.PeriodID = pmt.TranPeriodID;
tranHist.BranchID = pmt.BranchID;
list.Add(tranHist);
tranHist.TranPTDCuryAmount = curyAmt;
tranHist.TranPTDAmount = amt;
tranHist.TranYTDCuryAmount = curyAmt;
tranHist.TranYTDAmount = amt;
tranHist.TranPTDQty = baseQty;
tranHist.TranYTDQty = baseQty;
}
#endregion
forecast = new PMForecastHistory();
forecast.ProjectID = ps.ProjectID;
forecast.ProjectTaskID = ps.ProjectTaskID;
forecast.AccountGroupID = ps.AccountGroupID;
forecast.InventoryID = ps.InventoryID;
forecast.CostCodeID = ps.CostCodeID;
forecast.PeriodID = pmt.TranPeriodID;
forecast.ActualQty = ps.ActualQty;
forecast.CuryActualAmount = ps.CuryActualAmount;
forecast.ActualAmount = ps.ActualAmount;
}
return(new Result(list, ps, ta, forecast));
}
