public string GetValidationWarning(int costCodeID)
{
PMTask task = SelectFrom <PMTask>
.Where <PMTask.taskID.IsEqual <@P.AsInt> >
.View
.Select(_Graph, GetTaskID());
int?accountGroupID = GetAccountGroupID();
if (accountGroupID == null)
{
Account account = SelectFrom <Account>
.Where <Account.accountID.IsEqual <@P.AsInt> >
.View
.Select(_Graph, GetAccountID());
if (account != null)
{
accountGroupID = account.AccountGroupID;
}
}
PMAccountGroup accountGroup = SelectFrom <PMAccountGroup>
.Where <PMAccountGroup.groupID.IsEqual <@P.AsInt> >
.View
.Select(_Graph, accountGroupID);
PMCostCode costCode = SelectFrom <PMCostCode>
.Where <PMCostCode.costCodeID.IsEqual <@P.AsInt> >
.View
.Select(_Graph, costCodeID);
return(string.Format(Messages.CostCodeNotInBudget, costCode.CostCodeCD, task.TaskCD, accountGroup?.GroupCD));
}
protected virtual PMBudgetAccum GetTargetBudget(int?accountGroupID, ARTran line)
{
PMAccountGroup ag = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(Base, accountGroupID);
PMProject project = PXSelect <PMProject, Where <PMProject.contractID, Equal <Required <PMProject.contractID> > > > .Select(Base, line.ProjectID);
bool isExisting;
BudgetService budgetService = new BudgetService(Base);
PX.Objects.PM.Lite.PMBudget budget = budgetService.SelectProjectBalance(ag, project, line.TaskID, line.InventoryID, line.CostCodeID, out isExisting);
PMBudgetAccum target = new PMBudgetAccum();
target.Type = budget.Type;
target.ProjectID = budget.ProjectID;
target.ProjectTaskID = budget.TaskID;
target.AccountGroupID = budget.AccountGroupID;
target.InventoryID = budget.InventoryID;
target.CostCodeID = budget.CostCodeID;
target.UOM = budget.UOM;
target.Description = budget.Description;
target.CuryInfoID = project.CuryInfoID;
return(target);
}
public virtual PMBudgetLite SelectProjectBalance(PMAccountGroup ag, PMProject project, int?taskID, int?inventoryID, int?costCodeID, out bool isExisting)
{
BudgetKeyTuple key = new BudgetKeyTuple(project.ContractID.Value, taskID.Value, ag.GroupID.Value, inventoryID.GetValueOrDefault(PMInventorySelectorAttribute.EmptyInventoryID), costCodeID.GetValueOrDefault(CostCodeAttribute.GetDefaultCostCode()));
string budgetLevel = BudgetLevels.Task;
string updateMode = CostBudgetUpdateModes.Summary;
if (ag.Type == GL.AccountType.Income)
{
budgetLevel = project.BudgetLevel;
updateMode = settings.RevenueBudgetUpdateMode;
}
else if (ag.IsExpense == true)
{
budgetLevel = project.CostBudgetLevel;
updateMode = settings.CostBudgetUpdateMode;
}
PMBudgetLite target = SelectExistingBalance(key, budgetLevel, updateMode);
if (target != null)
{
isExisting = true;
}
else
{
isExisting = false;
target = BuildTarget(key, ag, budgetLevel, updateMode);
}
return(target);
}
protected virtual void PMBillingRule_CapsAccountGroupID_FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e)
{
PMBillingRule row = e.Row as PMBillingRule;
if (row != null && row.CapsAccountGroupID == null && (row.LimitAmt == true || row.LimitQty == true))
{
PMAccountGroup ag = PXSelect <PMAccountGroup> .Search <PMAccountGroup.groupID>(this, row.AccountGroupID);
e.NewValue = ag.GroupCD;
}
}
public virtual string GetAccountGroupType(int?accountGroup)
{
PMAccountGroup ag = AccountGroups[accountGroup.Value];
if (ag.Type == PMAccountType.OffBalance)
{
return(ag.IsExpense == true ? GL.AccountType.Expense : ag.Type);
}
else
{
return(ag.Type);
}
}
public virtual void RecalculateChangeOrders(PMProject project, ProjectBalance projectBalance, Dictionary <BudgetKeyTuple, PMBudgetEx> existingBudgetRecords)
{
var select = new PXSelect <PMChangeOrderBudget,
Where <PMChangeOrderBudget.projectID, Equal <Required <PMChangeOrderBudget.projectID> >,
And <PMChangeOrderBudget.released, Equal <True> > > >(this);
foreach (PMChangeOrderBudget change in select.Select(project.ContractID))
{
BudgetKeyTuple key = GetKey(change);
PMBudgetEx existing = null;
if (existingBudgetRecords.TryGetValue(key, out existing))
{
PMBudgetAccum budget = new PMBudgetAccum();
budget.ProjectID = key.ProjectID;
budget.ProjectTaskID = key.ProjectTaskID;
budget.AccountGroupID = key.AccountGroupID;
budget.InventoryID = key.InventoryID;
budget.CostCodeID = key.CostCodeID;
budget = Budget.Insert(budget);
budget.ChangeOrderAmount += change.Amount.GetValueOrDefault();
budget.RevisedAmount += change.Amount.GetValueOrDefault();
var rollup = projectBalance.CalculateRollupQty <PMChangeOrderBudget>(change, existing);
if (rollup.Qty.GetValueOrDefault() != 0)
{
budget.ChangeOrderQty += change.Qty.GetValueOrDefault();
budget.RevisedQty += change.Qty.GetValueOrDefault();
}
}
else
{
PMAccountGroup accountGroup = null;
if (AccountGroups.TryGetValue(key.AccountGroupID, out accountGroup))
{
PMBudgetAccum budget = new PMBudgetAccum();
budget.ProjectID = key.ProjectID;
budget.ProjectTaskID = key.ProjectTaskID;
budget.AccountGroupID = key.AccountGroupID;
budget.InventoryID = key.InventoryID;
budget.CostCodeID = key.CostCodeID;
budget.Type = accountGroup.IsExpense == true ? GL.AccountType.Expense : accountGroup.Type;
budget = Budget.Insert(budget);
budget.ChangeOrderAmount += change.Amount.GetValueOrDefault();
budget.RevisedAmount += change.Amount.GetValueOrDefault();
}
}
}
}
protected virtual void _(Events.FieldDefaulting <PMBudget, PMBudget.type> e)
{
PMAccountGroup ag = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(this, e.Row.AccountGroupID);
if (ag != null)
{
if (ag.Type == PMAccountType.OffBalance)
{
e.NewValue = ag.IsExpense == true ? GL.AccountType.Expense : ag.Type;
}
else
{
e.NewValue = ag.Type;
}
}
}
protected virtual void _(Events.FieldUpdated <PMBudget, PMBudget.accountGroupID> e)
{
PMAccountGroup ag = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(this, e.Row.AccountGroupID);
if (ag != null)
{
if (ag.IsExpense == true)
{
e.Row.Type = GL.AccountType.Expense;
}
else
{
e.Row.Type = ag.Type;
}
}
}
protected virtual void PMTran_AccountID_FieldVerifying(PXCache sender, PXFieldVerifyingEventArgs e)
{
PMTran row = e.Row as PMTran;
if (row != null && e.NewValue != null)
{
Account item = PXSelect <Account, Where2 <Match <Current <AccessInfo.userName> >, And <Account.accountID, Equal <Required <Account.accountID> > > > > .Select(sender.Graph, e.NewValue);
if (row != null && item != null && (item.AccountGroupID == null || item.AccountGroupID != row.AccountGroupID))
{
PMAccountGroup accountGroup = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(sender.Graph, row.AccountGroupID);
throw new PXException(PM.Messages.AccountIsNotAssociatedWithAccountGroup, item.AccountCD, accountGroup.GroupCD);
}
}
}
public string GetTrace()
{
//Add transaction properties:
PMAccountGroup ag = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(graph, tran.AccountGroupID);
if (ag != null)
{
trace.AppendFormat(" PMTran.AccountGroup={0} ", ag.GroupCD);
}
IN.InventoryItem inventoryItem = PXSelect <IN.InventoryItem, Where <IN.InventoryItem.inventoryID, Equal <Required <IN.InventoryItem.inventoryID> > > > .Select(graph, tran.InventoryID);
if (inventoryItem != null)
{
trace.AppendFormat(" PMTran.InventoryID={0} ", inventoryItem.InventoryCD);
}
return(trace.ToString());
}
protected virtual void _(Events.FieldDefaulting <PMBudget, PMBudget.rate> e)
{
PMAccountGroup ag = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(this, e.Row.AccountGroupID);
if (ag != null)
{
if (ag.IsExpense == true)
{
if (e.Row.InventoryID != null && e.Row.InventoryID != PMInventorySelectorAttribute.EmptyInventoryID)
{
InventoryItem item = (InventoryItem)PXSelectorAttribute.Select <PMCostBudget.inventoryID>(e.Cache, e.Row);
e.NewValue = item?.StdCost;
}
}
else
{
if (e.Row.InventoryID != null && e.Row.InventoryID != PMInventorySelectorAttribute.EmptyInventoryID)
{
string customerPriceClass = ARPriceClass.EmptyPriceClass;
PMTask projectTask = (PMTask)PXSelectorAttribute.Select <PMRevenueBudget.projectTaskID>(e.Cache, e.Row);
CR.Location c = (CR.Location)PXSelectorAttribute.Select <PMTask.locationID>(e.Cache, projectTask);
if (c != null && !string.IsNullOrEmpty(c.CPriceClassID))
{
customerPriceClass = c.CPriceClassID;
}
CM.CurrencyInfo dummy = new CM.CurrencyInfo();
dummy.CuryID = Accessinfo.BaseCuryID;
dummy.BaseCuryID = Accessinfo.BaseCuryID;
dummy.CuryRate = 1;
e.NewValue = ARSalesPriceMaint.CalculateSalesPrice(Caches[typeof(PMTran)], customerPriceClass, projectTask.CustomerID, e.Row.InventoryID, dummy, e.Row.Qty, e.Row.UOM, Accessinfo.BusinessDate.Value, true);
}
}
}
}
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));
}
public virtual PMBudgetLite SelectProjectBalance(IProjectFilter filter, PMAccountGroup ag, PMProject project, out bool isExisting)
{
return(SelectProjectBalance(ag, project, filter.TaskID, filter.InventoryID, filter.CostCodeID, out isExisting));
}
protected virtual PMBudgetLite BuildTarget(BudgetKeyTuple key, PMAccountGroup accountGroup, string budgetLevel, string budgetUpdateMode)
{
if (accountGroup == null)
{
throw new ArgumentNullException(nameof(accountGroup));
}
if (accountGroup.GroupID != key.AccountGroupID)
{
throw new ArgumentException("AccountGroup doesnot match key.AccountGroupID");
}
PMBudgetLite target = new PMBudgetLite();
target.ProjectID = key.ProjectID;
target.ProjectTaskID = key.ProjectTaskID;
target.AccountGroupID = key.AccountGroupID;
target.InventoryID = PMInventorySelectorAttribute.EmptyInventoryID;
target.CostCodeID = CostCodeAttribute.GetDefaultCostCode();
target.IsProduction = false;
target.Type = accountGroup.IsExpense == true ? GL.AccountType.Expense : accountGroup.Type;
if (budgetLevel == BudgetLevels.Task)
{
//default
}
else if (budgetLevel == BudgetLevels.Item)
{
target.InventoryID = budgetUpdateMode == CostBudgetUpdateModes.Summary ? PMInventorySelectorAttribute.EmptyInventoryID : key.InventoryID;
if (target.InventoryID != PMInventorySelectorAttribute.EmptyInventoryID)
{
InventoryItem item = PXSelect <InventoryItem, Where <InventoryItem.inventoryID, Equal <Required <InventoryItem.inventoryID> > > > .Select(graph, target.InventoryID);
if (item != null)
{
target.Description = item.Descr;
target.UOM = item.BaseUnit;
}
}
}
else if (budgetLevel == BudgetLevels.CostCode)
{
target.CostCodeID = budgetUpdateMode == CostBudgetUpdateModes.Summary ? CostCodeAttribute.GetDefaultCostCode() : key.CostCodeID;
PMCostCode costCode = PXSelect <PMCostCode, Where <PMCostCode.costCodeID, Equal <Required <PMCostCode.costCodeID> > > > .Select(graph, target.CostCodeID);
if (costCode != null)
{
target.Description = costCode.Description;
}
}
else if (budgetLevel == BudgetLevels.Detail)
{
target.InventoryID = budgetUpdateMode == CostBudgetUpdateModes.Summary ? PMInventorySelectorAttribute.EmptyInventoryID : key.InventoryID;
target.CostCodeID = budgetUpdateMode == CostBudgetUpdateModes.Summary ? CostCodeAttribute.GetDefaultCostCode() : key.CostCodeID;
PMCostCode costCode = PXSelect <PMCostCode, Where <PMCostCode.costCodeID, Equal <Required <PMCostCode.costCodeID> > > > .Select(graph, target.CostCodeID);
if (costCode != null)
{
target.Description = costCode.Description;
}
}
else
{
throw new ArgumentException(string.Format("Unknown budget level = {0}", budgetLevel), nameof(budgetLevel));
}
return(target);
}
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));
}
public virtual void RunProjectBalanceVerification(PMProject project)
{
PXDatabase.Delete <PMTaskTotal>(new PXDataFieldRestrict(typeof(PMTaskTotal.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ));
PXDatabase.Delete <PMTaskAllocTotal>(new PXDataFieldRestrict(typeof(PMTaskAllocTotal.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ));
PXDatabase.Delete <PMHistory>(new PXDataFieldRestrict(typeof(PMHistory.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ));
foreach (PMProjectStatusEx status in PXSelect <PMProjectStatusEx, Where <PMProjectStatusEx.projectID, Equal <Required <PMProjectStatusEx.projectID> > > > .Select(this, project.ContractID))
{
PXDatabase.Update <PMProjectStatus>(new PXDataFieldRestrict(typeof(PMProjectStatus.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ),
new PXDataFieldAssign(typeof(PMProjectStatus.actualAmount).Name, PXDbType.Decimal, 0m),
new PXDataFieldAssign(typeof(PMProjectStatus.actualQty).Name, PXDbType.Decimal, 0m));
PMHistory2Accum hist2 = new PMHistory2Accum();
hist2.ProjectID = status.ProjectID;
hist2.ProjectTaskID = status.ProjectTaskID;
hist2.AccountGroupID = status.AccountGroupID;
hist2.InventoryID = status.InventoryID ?? PMProjectStatus.EmptyInventoryID;
hist2.PeriodID = status.PeriodID;
hist2 = History2.Insert(hist2);
hist2.PTDBudgetAmount += status.Amount;
hist2.PTDBudgetQty += status.Qty;
hist2.BudgetAmount += status.Amount;
hist2.BudgetQty += status.Qty;
hist2.PTDRevisedAmount += status.RevisedAmount;
hist2.PTDRevisedQty += status.RevisedQty;
hist2.RevisedAmount += status.RevisedAmount;
hist2.RevisedQty += status.RevisedQty;
}
PXSelectBase <PMTran> select = new PXSelectJoin <PMTran,
LeftJoin <Account, On <PMTran.accountID, Equal <Account.accountID> >,
InnerJoin <PMProject, On <PMProject.contractID, Equal <PMTran.projectID> >,
LeftJoin <PMTask, On <PMTask.projectID, Equal <PMTran.projectID>, And <PMTask.taskID, Equal <PMTran.taskID> > >,
LeftJoin <OffsetAccount, On <PMTran.offsetAccountID, Equal <OffsetAccount.accountID> >,
LeftJoin <PMAccountGroup, On <PMAccountGroup.groupID, Equal <Account.accountGroupID> >,
LeftJoin <OffsetPMAccountGroup, On <OffsetPMAccountGroup.groupID, Equal <OffsetAccount.accountGroupID> > > > > > > >,
Where <PMTran.projectID, Equal <Required <PMTran.projectID> >,
And <PMTran.released, Equal <True> > > >(this);
foreach (PXResult <PMTran, Account, PMProject, PMTask, OffsetAccount, PMAccountGroup, OffsetPMAccountGroup> res in select.Select(project.ContractID))
{
PMTran tran = (PMTran)res;
Account acc = (Account)res;
PMAccountGroup ag = (PMAccountGroup)res;
OffsetAccount offsetAcc = (OffsetAccount)res;
OffsetPMAccountGroup offsetAg = (OffsetPMAccountGroup)res;
PMTask task = (PMTask)res;
IList <PMHistory> list = RegisterReleaseProcess.UpdateProjectBalance(this, task, tran, acc, ag, offsetAcc, offsetAg);
#region History Update
foreach (PMHistory item in list)
{
PMHistoryAccum hist = new PMHistoryAccum();
hist.ProjectID = item.ProjectID;
hist.ProjectTaskID = item.ProjectTaskID;
hist.AccountGroupID = item.AccountGroupID;
hist.InventoryID = item.InventoryID;
hist.PeriodID = item.PeriodID;
hist = History.Insert(hist);
hist.FinPTDAmount += item.FinPTDAmount.GetValueOrDefault();
hist.FinYTDAmount += item.FinYTDAmount.GetValueOrDefault();
hist.FinPTDQty += item.FinPTDQty.GetValueOrDefault();
hist.FinYTDQty += item.FinYTDQty.GetValueOrDefault();
hist.TranPTDAmount += item.TranPTDAmount.GetValueOrDefault();
hist.TranYTDAmount += item.TranYTDAmount.GetValueOrDefault();
hist.TranPTDQty += item.TranPTDQty.GetValueOrDefault();
hist.TranYTDQty += item.TranYTDQty.GetValueOrDefault();
}
#endregion
}
PXSelectBase <PMTran> select2 = new PXSelect <PMTran,
Where <PMTran.origProjectID, Equal <Required <PMTran.origProjectID> >,
And <PMTran.origTaskID, IsNotNull,
And <PMTran.origAccountGroupID, IsNotNull> > > >(this);
foreach (PMTran tran in select2.Select(project.ContractID))
{
PMTaskAllocTotalAccum tat = new PMTaskAllocTotalAccum();
tat.ProjectID = tran.OrigProjectID;
tat.TaskID = tran.OrigTaskID;
tat.AccountGroupID = tran.OrigAccountGroupID;
tat.InventoryID = tran.InventoryID;
tat = AllocationTotals.Insert(tat);
tat.Amount += tran.Amount;
tat.Quantity += tran.Qty;
}
foreach (PMProjectStatusAccum item in this.Caches[typeof(PMProjectStatusAccum)].Inserted)
{
Debug.Print("Task={0} AG={1} Qty={2} Amt={3}", item.ProjectTaskID, item.AccountGroupID, item.ActualQty, item.ActualAmount);
}
}
public virtual void RunProjectBalanceVerification(PMProject project, bool recalculateUnbilledSummary)
{
PXDatabase.Delete <PMTaskTotal>(new PXDataFieldRestrict(typeof(PMTaskTotal.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ));
PXDatabase.Delete <PMTaskAllocTotal>(new PXDataFieldRestrict(typeof(PMTaskAllocTotal.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ));
PXDatabase.Delete <PMHistory>(new PXDataFieldRestrict(typeof(PMHistory.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ));
if (recalculateUnbilledSummary)
{
PXDatabase.Delete <PMUnbilledDailySummary>(new PXDataFieldRestrict(typeof(PMUnbilledDailySummary.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ));
}
foreach (PMProjectStatusEx status in PXSelect <PMProjectStatusEx, Where <PMProjectStatusEx.projectID, Equal <Required <PMProjectStatusEx.projectID> > > > .Select(this, project.ContractID))
{
PXDatabase.Update <PMProjectStatus>(new PXDataFieldRestrict(typeof(PMProjectStatus.projectID).Name, PXDbType.Int, 4, project.ContractID, PXComp.EQ),
new PXDataFieldAssign(typeof(PMProjectStatus.actualAmount).Name, PXDbType.Decimal, 0m),
new PXDataFieldAssign(typeof(PMProjectStatus.actualQty).Name, PXDbType.Decimal, 0m));
PMHistory2Accum hist2 = new PMHistory2Accum();
hist2.ProjectID = status.ProjectID;
hist2.ProjectTaskID = status.ProjectTaskID;
hist2.AccountGroupID = status.AccountGroupID;
hist2.InventoryID = status.InventoryID ?? PMProjectStatus.EmptyInventoryID;
hist2.PeriodID = status.PeriodID;
hist2 = History2.Insert(hist2);
hist2.PTDBudgetAmount += status.Amount;
hist2.PTDBudgetQty += status.Qty;
hist2.BudgetAmount += status.Amount;
hist2.BudgetQty += status.Qty;
hist2.PTDRevisedAmount += status.RevisedAmount;
hist2.PTDRevisedQty += status.RevisedQty;
hist2.RevisedAmount += status.RevisedAmount;
hist2.RevisedQty += status.RevisedQty;
}
PXSelectBase <PMTran> select = new PXSelectJoinGroupBy <PMTran,
LeftJoin <Account, On <PMTran.accountID, Equal <Account.accountID> >,
LeftJoin <OffsetAccount, On <PMTran.offsetAccountID, Equal <OffsetAccount.accountID> >,
LeftJoin <PMAccountGroup, On <PMAccountGroup.groupID, Equal <Account.accountGroupID> >,
LeftJoin <OffsetPMAccountGroup, On <OffsetPMAccountGroup.groupID, Equal <OffsetAccount.accountGroupID> > > > > >,
Where <PMTran.projectID, Equal <Required <PMTran.projectID> >,
And <PMTran.released, Equal <True> > >,
Aggregate <GroupBy <PMTran.tranType,
GroupBy <PMTran.finPeriodID,
GroupBy <PMTran.tranPeriodID,
GroupBy <PMTran.projectID,
GroupBy <PMTran.taskID,
GroupBy <PMTran.inventoryID,
GroupBy <PMTran.accountID,
GroupBy <PMTran.accountGroupID,
GroupBy <PMTran.offsetAccountID,
GroupBy <PMTran.offsetAccountGroupID,
GroupBy <PMTran.uOM,
GroupBy <PMTran.released,
Sum <PMTran.qty,
Sum <PMTran.amount> > > > > > > > > > > > > > > >(this);
if (recalculateUnbilledSummary)
{
select = new PXSelectJoinGroupBy <PMTran,
LeftJoin <Account, On <PMTran.accountID, Equal <Account.accountID> >,
LeftJoin <OffsetAccount, On <PMTran.offsetAccountID, Equal <OffsetAccount.accountID> >,
LeftJoin <PMAccountGroup, On <PMAccountGroup.groupID, Equal <Account.accountGroupID> >,
LeftJoin <OffsetPMAccountGroup, On <OffsetPMAccountGroup.groupID, Equal <OffsetAccount.accountGroupID> > > > > >,
Where <PMTran.projectID, Equal <Required <PMTran.projectID> >,
And <PMTran.released, Equal <True> > >,
Aggregate <GroupBy <PMTran.tranType,
GroupBy <PMTran.finPeriodID,
GroupBy <PMTran.tranPeriodID,
GroupBy <PMTran.projectID,
GroupBy <PMTran.taskID,
GroupBy <PMTran.inventoryID,
GroupBy <PMTran.date,
GroupBy <PMTran.accountID,
GroupBy <PMTran.accountGroupID,
GroupBy <PMTran.offsetAccountID,
GroupBy <PMTran.offsetAccountGroupID,
GroupBy <PMTran.uOM,
GroupBy <PMTran.released,
Sum <PMTran.qty,
Sum <PMTran.amount,
Max <PMTran.billable,
Max <PMTran.billed,
Max <PMTran.reversed> > > > > > > > > > > > > > > > > > > >(this);
}
else
{
select = new PXSelectJoinGroupBy <PMTran,
LeftJoin <Account, On <PMTran.accountID, Equal <Account.accountID> >,
LeftJoin <OffsetAccount, On <PMTran.offsetAccountID, Equal <OffsetAccount.accountID> >,
LeftJoin <PMAccountGroup, On <PMAccountGroup.groupID, Equal <Account.accountGroupID> >,
LeftJoin <OffsetPMAccountGroup, On <OffsetPMAccountGroup.groupID, Equal <OffsetAccount.accountGroupID> > > > > >,
Where <PMTran.projectID, Equal <Required <PMTran.projectID> >,
And <PMTran.released, Equal <True> > >,
Aggregate <GroupBy <PMTran.tranType,
GroupBy <PMTran.finPeriodID,
GroupBy <PMTran.tranPeriodID,
GroupBy <PMTran.projectID,
GroupBy <PMTran.taskID,
GroupBy <PMTran.inventoryID,
GroupBy <PMTran.accountID,
GroupBy <PMTran.accountGroupID,
GroupBy <PMTran.offsetAccountID,
GroupBy <PMTran.offsetAccountGroupID,
GroupBy <PMTran.uOM,
GroupBy <PMTran.released,
Sum <PMTran.qty,
Sum <PMTran.amount> > > > > > > > > > > > > > > >(this);
}
foreach (PXResult <PMTran, Account, OffsetAccount, PMAccountGroup, OffsetPMAccountGroup> res in select.Select(project.ContractID))
{
PMTran tran = (PMTran)res;
Account acc = (Account)res;
PMAccountGroup ag = (PMAccountGroup)res;
OffsetAccount offsetAcc = (OffsetAccount)res;
OffsetPMAccountGroup offsetAg = (OffsetPMAccountGroup)res;
//suppose we have allocated unbilled 100 - unearned 100
//during billing we reduced the amount to 80.
//as a result of this. only 80 will be reversed. leaving 20 on the unbilled.
//plus a remainder transaction will be generated. (if we allow this remainder to update balance it will add additional 20 to the unbilled.)
if (tran.RemainderOfTranID != null)
{
continue; //skip remainder transactions.
}
IList <PMHistory> list = RegisterReleaseProcess.UpdateProjectBalance(this, tran, acc, ag, offsetAcc, offsetAg);
RegisterReleaseProcess.AddToUnbilledSummary(this, tran);
#region History Update
foreach (PMHistory item in list)
{
PMHistoryAccum hist = new PMHistoryAccum();
hist.ProjectID = item.ProjectID;
hist.ProjectTaskID = item.ProjectTaskID;
hist.AccountGroupID = item.AccountGroupID;
hist.InventoryID = item.InventoryID;
hist.PeriodID = item.PeriodID;
hist = History.Insert(hist);
hist.FinPTDAmount += item.FinPTDAmount.GetValueOrDefault();
hist.FinYTDAmount += item.FinYTDAmount.GetValueOrDefault();
hist.FinPTDQty += item.FinPTDQty.GetValueOrDefault();
hist.FinYTDQty += item.FinYTDQty.GetValueOrDefault();
hist.TranPTDAmount += item.TranPTDAmount.GetValueOrDefault();
hist.TranYTDAmount += item.TranYTDAmount.GetValueOrDefault();
hist.TranPTDQty += item.TranPTDQty.GetValueOrDefault();
hist.TranYTDQty += item.TranYTDQty.GetValueOrDefault();
}
#endregion
}
PXSelectBase <PMTran> select2 = new PXSelect <PMTran,
Where <PMTran.origProjectID, Equal <Required <PMTran.origProjectID> >,
And <PMTran.origTaskID, IsNotNull,
And <PMTran.origAccountGroupID, IsNotNull> > > >(this);
foreach (PMTran tran in select2.Select(project.ContractID))
{
PMTaskAllocTotalAccum tat = new PMTaskAllocTotalAccum();
tat.ProjectID = tran.OrigProjectID;
tat.TaskID = tran.OrigTaskID;
tat.AccountGroupID = tran.OrigAccountGroupID;
tat.InventoryID = tran.InventoryID;
tat = AllocationTotals.Insert(tat);
tat.Amount += tran.Amount;
tat.Quantity += tran.Qty;
}
//foreach (PMProjectStatusAccum item in this.Caches[typeof(PMProjectStatusAccum)].Inserted)
//{
// Debug.Print("Task={0} AG={1} Qty={2} Amt={3}", item.ProjectTaskID, item.AccountGroupID, item.ActualQty, item.ActualAmount);
//}
}
public virtual List <Result> Calculate(PMProject project, PMTran tran, Account acc, PMAccountGroup ag, Account offsetAcc, PMAccountGroup offsetAg)
{
List <Result> list = new List <Result>();
if (tran.TaskID != null)
{
int invert = 1;
if (tran.TranType == BatchModule.PM && IsFlipRequired(acc.Type, ag.Type))
{
//Invert transactions that originated in PM. All other transactions were already inverted when they were transformed from GLTran to PMTran.
invert = -1;
}
bool debitcreditcancelout = false;
if (offsetAcc != null && acc.AccountID == offsetAcc.AccountID)
{
debitcreditcancelout = true;
}
if (offsetAg != null && ag.GroupID == offsetAg.GroupID)
{
debitcreditcancelout = true;
}
if (offsetAcc != null && string.IsNullOrEmpty(acc.Type) && offsetAcc.AccountGroupID == tran.AccountGroupID)
{
return(list);
}
if (string.IsNullOrEmpty(ag.Type))
{
//offbalance tran.
PMAccountGroup tranAG = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(graph, tran.AccountGroupID);
if (tranAG != null)
{
//DEBIT ONLY
if (tranAG.Type == AccountType.Income || tranAG.Type == AccountType.Liability)
{
list.Add(Calculate(project, tran, tranAG, null, -1 * invert));
}
else
{
list.Add(Calculate(project, tran, tranAG, null, 1 * invert));
}
}
}
else
{
if (!debitcreditcancelout)
{
//DEBIT
if (acc.Type == AccountType.Income || acc.Type == AccountType.Liability)
{
list.Add(Calculate(project, tran, ag, acc, -1 * invert));
}
else
{
list.Add(Calculate(project, tran, ag, acc, 1 * invert));
}
}
}
//CREDIT
if (offsetAcc != null && offsetAg != null && offsetAcc.AccountID != null && offsetAg.GroupID != null && !debitcreditcancelout)
{
int offsetInvert = 1;
if (IsFlipRequired(offsetAcc.Type, offsetAg.Type))
{
offsetInvert = -1;
}
if (offsetAcc.Type == AccountType.Income || offsetAcc.Type == AccountType.Liability)
{
list.Add(Calculate(project, tran, offsetAg, offsetAcc, 1 * offsetInvert));
}
else
{
list.Add(Calculate(project, tran, offsetAg, offsetAcc, -1 * offsetInvert));
}
}
}
return(list);
}
public virtual void ProcessTransaction(PMProject project, PXResult <PMTran, Account, OffsetAccount, PMAccountGroup, OffsetPMAccountGroup> res, ProjectBalance pb)
{
PMTran tran = (PMTran)res;
Account acc = (Account)res;
PMAccountGroup ag = (PMAccountGroup)res;
OffsetAccount offsetAcc = (OffsetAccount)res;
OffsetPMAccountGroup offsetAg = (OffsetPMAccountGroup)res;
IList <ProjectBalance.Result> balances = pb.Calculate(project, tran, acc, ag, offsetAcc, offsetAg);
foreach (ProjectBalance.Result balance in balances)
{
if (balance.Status != null)
{
PMBudgetAccum ps = new PMBudgetAccum();
ps.ProjectID = balance.Status.ProjectID;
ps.ProjectTaskID = balance.Status.ProjectTaskID;
ps.AccountGroupID = balance.Status.AccountGroupID;
ps.InventoryID = balance.Status.InventoryID;
ps.CostCodeID = balance.Status.CostCodeID;
ps.UOM = balance.Status.UOM;
ps.IsProduction = balance.Status.IsProduction;
ps.Type = balance.Status.Type;
ps.Description = balance.Status.Description;
ps = Budget.Insert(ps);
ps.ActualQty += balance.Status.ActualQty.GetValueOrDefault();
ps.ActualAmount += balance.Status.ActualAmount.GetValueOrDefault();
}
if (balance.TaskTotal != null)
{
PMTaskTotal ta = new PMTaskTotal();
ta.ProjectID = balance.TaskTotal.ProjectID;
ta.TaskID = balance.TaskTotal.TaskID;
ta = TaskTotals.Insert(ta);
ta.Asset += balance.TaskTotal.Asset.GetValueOrDefault();
ta.Liability += balance.TaskTotal.Liability.GetValueOrDefault();
ta.Income += balance.TaskTotal.Income.GetValueOrDefault();
ta.Expense += balance.TaskTotal.Expense.GetValueOrDefault();
}
foreach (PMHistory item in balance.History)
{
PMHistoryAccum hist = new PMHistoryAccum();
hist.ProjectID = item.ProjectID;
hist.ProjectTaskID = item.ProjectTaskID;
hist.AccountGroupID = item.AccountGroupID;
hist.InventoryID = item.InventoryID;
hist.CostCodeID = item.CostCodeID;
hist.PeriodID = item.PeriodID;
hist = History.Insert(hist);
hist.FinPTDAmount += item.FinPTDAmount.GetValueOrDefault();
hist.FinYTDAmount += item.FinYTDAmount.GetValueOrDefault();
hist.FinPTDQty += item.FinPTDQty.GetValueOrDefault();
hist.FinYTDQty += item.FinYTDQty.GetValueOrDefault();
hist.TranPTDAmount += item.TranPTDAmount.GetValueOrDefault();
hist.TranYTDAmount += item.TranYTDAmount.GetValueOrDefault();
hist.TranPTDQty += item.TranPTDQty.GetValueOrDefault();
hist.TranYTDQty += item.TranYTDQty.GetValueOrDefault();
}
}
}
public string AccountGroupFromID(int?accountGroupID)
{
PMAccountGroup ag = PXSelect <PMAccountGroup, Where <PMAccountGroup.groupID, Equal <Required <PMAccountGroup.groupID> > > > .Select(this, accountGroupID);
return(ag.GroupCD);
}
public virtual PMTran ExpenseTransactionFromBudget(PMBudget budget, PMProject project, PMTask task, PMAccountGroup accountGroup, InventoryItem item, PMCostCode costcode)
{
PMTran tran = new PMTran();
tran.AccountGroupID = budget.AccountGroupID;
tran.ProjectID = budget.ProjectID;
tran.TaskID = budget.ProjectTaskID;
tran.InventoryID = budget.InventoryID;
tran.AccountID = item.InventoryID != null ? item.COGSAcctID : accountGroup.AccountID;
tran.SubID = item.InventoryID != null ? item.COGSSubID : accountGroup.AccountID;
tran.Amount = budget.RevisedAmount;
tran.Qty = budget.RevisedQty;
tran.UOM = budget.UOM;
tran.BAccountID = task.CustomerID;
tran.LocationID = task.LocationID;
tran.Billable = true;
tran.UseBillableQty = true;
tran.BillableQty = budget.RevisedQty;
tran.Released = true;
return(tran);
}