private void ProcessPMResultset(PXResultset <PMHistory> resultset)
{
foreach (PXResult <PMHistory, PMTask> result in resultset)
{
var hist = (PMHistory)result;
var task = (PMTask)result;
var key = new PMHistoryKeyTuple(hist.ProjectID.Value, task.TaskCD, hist.AccountGroupID.Value, hist.InventoryID.Value);
Dictionary <string, PMHistory> keyData;
if (_pmhistoryPeriodsByKey.TryGetValue(key, out keyData))
{
keyData.Add(hist.PeriodID, hist);
}
else
{
_pmhistoryPeriodsByKey.Add(key, new Dictionary <string, PMHistory> {
{ hist.PeriodID, hist }
});
}
_historySegments.Add(new PMHistoryKeyTuple(0, String.Empty, hist.AccountGroupID.Value, 0));
_historySegments.Add(new PMHistoryKeyTuple(hist.ProjectID.Value, String.Empty, hist.AccountGroupID.Value, 0));
_historySegments.Add(new PMHistoryKeyTuple(hist.ProjectID.Value, task.TaskCD, hist.AccountGroupID.Value, 0));
}
}
private List <PMHistory> GetPeriodsToCalculate(PMProject project, PMTask task, PMAccountGroup accountGroup, InventoryItem item, RMDataSource ds, RMDataSourceGL dsGL)
{
Dictionary <string, PMHistory> periodsForKey = null;
var key = new PMHistoryKeyTuple(project.ContractID.Value, task.TaskCD, accountGroup.GroupID.Value, item.InventoryID.Value);
if (!_pmhistoryPeriodsByKey.TryGetValue(key, out periodsForKey))
{
return(null);
}
if (ds.AmountType == BalanceType.Amount || ds.AmountType == BalanceType.Quantity ||
ds.AmountType == BalanceType.BudgetAmount || ds.AmountType == BalanceType.BudgetQuantity ||
ds.AmountType == BalanceType.RevisedAmount || ds.AmountType == BalanceType.RevisedQuantity)
{
//These amounts are calculated against start of project
dsGL.StartPeriod = _reportPeriods.PerWildcard;
dsGL.StartPeriodOffset = 0;
dsGL.StartPeriodYearOffset = 0;
}
return(_reportPeriods.GetPeriodsForRegularAmount(dsGL, periodsForKey));
}
private object CalculateAndExpandValue(bool drilldown, RMDataSource ds, RMDataSourceGL dsGL, RMDataSourcePM dsPM, ARmDataSet dataSet, List <PMAccountGroup> accountGroups, List <PMProject> projects, List <PMTask> tasks, List <InventoryItem> items, List <object[]> splitret)
{
decimal totalAmount = 0;
object locker = new object();
Dictionary <PMHistoryKeyTuple, PXResult <PMHistory, PMProject, PMTask, PMAccountGroup, InventoryItem> > drilldownData = null;
if (drilldown)
{
drilldownData = new Dictionary <PMHistoryKeyTuple, PXResult <PMHistory, PMProject, PMTask, PMAccountGroup, InventoryItem> >();
}
Parallel.For(0, accountGroups.Count, accountGroup =>
{
PMAccountGroup currentAccountGroup = accountGroups[accountGroup];
if (!_historySegments.Contains(new PMHistoryKeyTuple(0, String.Empty, currentAccountGroup.GroupID.Value, 0)))
{
return;
}
Parallel.For(0, projects.Count, project =>
{
PMProject currentProject = projects[project];
if (!_historySegments.Contains(new PMHistoryKeyTuple(currentProject.ContractID.Value, String.Empty, currentAccountGroup.GroupID.Value, 0)))
{
return;
}
Parallel.For(0, tasks.Count, task =>
{
PMTask currentTask = tasks[task];
if (!_historySegments.Contains(new PMHistoryKeyTuple(currentProject.ContractID.Value, currentTask.TaskCD, currentAccountGroup.GroupID.Value, 0)))
{
return;
}
if (ds.Expand != ExpandType.ProjectTask && currentTask.ProjectID != currentProject.ContractID)
{
return;
}
Parallel.For(0, items.Count, item =>
{
InventoryItem currentItem = items[item];
List <PMHistory> periods = GetPeriodsToCalculate(currentProject, currentTask, currentAccountGroup, currentItem, ds, dsGL);
if (periods == null)
{
return;
}
foreach (var hist in periods)
{
decimal amount = GetAmountFromPMHistory(ds, hist);
lock (locker)
{
totalAmount += amount;
}
if (drilldown)
{
var key = new PMHistoryKeyTuple(currentProject.ContractID.Value, currentTask.TaskCD, currentAccountGroup.GroupID.Value, currentItem.InventoryID.Value);
PXResult <PMHistory, PMProject, PMTask, PMAccountGroup, InventoryItem> drilldownRow = null;
lock (drilldownData)
{
if (!drilldownData.TryGetValue(key, out drilldownRow))
{
drilldownRow = new PXResult <PMHistory, PMProject, PMTask, PMAccountGroup, InventoryItem>(new PMHistory(), currentProject, currentTask, currentAccountGroup, currentItem);
drilldownData.Add(key, drilldownRow);
}
}
lock (drilldownRow)
{
AggregatePMHistoryForDrilldown(drilldownRow, hist);
}
}
if (ds.Expand == ExpandType.AccountGroup)
{
lock (currentAccountGroup)
{
splitret[accountGroup][2] = (decimal)splitret[accountGroup][2] + amount;
if (splitret[accountGroup][3] == null)
{
var dataSetCopy = new ARmDataSet(dataSet);
dataSetCopy[PX.Objects.CS.RMReportReaderPM.Keys.StartAccountGroup] = dataSetCopy[PX.Objects.CS.RMReportReaderPM.Keys.EndAccountGroup] = currentAccountGroup.GroupCD;
splitret[accountGroup][3] = dataSetCopy;
}
}
}
else if (ds.Expand == ExpandType.Project)
{
lock (currentProject)
{
splitret[project][2] = (decimal)splitret[project][2] + amount;
if (splitret[project][3] == null)
{
var dataSetCopy = new ARmDataSet(dataSet);
dataSetCopy[PX.Objects.CS.RMReportReaderPM.Keys.StartProject] = dataSetCopy[PX.Objects.CS.RMReportReaderPM.Keys.EndProject] = currentProject.ContractCD;
splitret[project][3] = dataSetCopy;
}
}
}
else if (ds.Expand == ExpandType.ProjectTask)
{
lock (currentItem)
{
splitret[task][2] = (decimal)splitret[task][2] + amount;
if (splitret[task][3] == null)
{
var dataSetCopy = new ARmDataSet(dataSet);
dataSetCopy[PX.Objects.CS.RMReportReaderPM.Keys.StartProjectTask] = dataSetCopy[PX.Objects.CS.RMReportReaderPM.Keys.EndProjectTask] = currentTask.TaskCD;
splitret[task][3] = dataSetCopy;
}
}
}
else if (ds.Expand == ExpandType.Inventory)
{
lock (currentItem)
{
splitret[item][2] = (decimal)splitret[item][2] + amount;
if (splitret[item][3] == null)
{
var dataSetCopy = new ARmDataSet(dataSet);
dataSetCopy[PX.Objects.CS.RMReportReaderPM.Keys.StartInventory] = dataSetCopy[PX.Objects.CS.RMReportReaderPM.Keys.EndInventory] = currentItem.InventoryCD;
splitret[item][3] = dataSetCopy;
}
}
}
}
});
});
});
});
if (drilldown)
{
var resultset = new PXResultset <PMHistory, PMProject, PMTask, PMAccountGroup, InventoryItem>();
foreach (var r in
from row in drilldownData.Values
let projectCD = ((PMProject)row[typeof(PMProject)]).With(_ => _.ContractCD)
let taskCD = ((PMTask)row[typeof(Sub)]).With(_ => _.TaskCD)
let accGroupCD = ((PMAccountGroup)row[typeof(PMAccountGroup)]).With(_ => _.GroupCD)
let inventoryCD = ((InventoryItem)row[typeof(InventoryItem)]).With(_ => _.InventoryCD)
orderby projectCD, taskCD, accGroupCD, inventoryCD
select row)
{
resultset.Add(r);
}
return(resultset);
}
else if (ds.Expand != ExpandType.Nothing)
{
return(splitret);
}
else
{
return(totalAmount);
}
}
