private static decimal GetAmountFromPMHistory(RMDataSource ds, PMHistory hist)
{
//We always use the PTD amounts; depending on BalanceType we will expand our calculation to more periods (GetPeriodsToCalculate)
switch (ds.AmountType.Value)
{
case BalanceType.Amount:
case BalanceType.TurnoverAmount:
return(hist.FinPTDAmount.Value);
case BalanceType.Quantity:
case BalanceType.TurnoverQuantity:
return(hist.FinPTDQty.Value);
case BalanceType.BudgetAmount:
case BalanceType.BudgetPTDAmount:
return(hist.PTDBudgetAmount.Value);
case BalanceType.BudgetQuantity:
case BalanceType.BudgetPTDQuantity:
return(hist.PTDBudgetQty.Value);
case BalanceType.RevisedAmount:
case BalanceType.RevisedPTDAmount:
return(hist.PTDRevisedAmount.Value);
case BalanceType.RevisedQuantity:
case BalanceType.RevisedPTDQuantity:
return(hist.PTDRevisedQty.Value);
default:
System.Diagnostics.Debug.Assert(false, "Unknown amount type: " + ds.AmountType.Value);
return(0);
}
}
public virtual void dataSourceFieldSelecting(PXFieldSelectingEventArgs e, string field)
{
RMReport report = (RMReport)e.Row;
RMDataSource dataSource = report != null?Base.DataSourceByID.Select(report.DataSourceID) : null;
if (dataSource == null)
{
object defValue;
if (Base.DataSourceByID.Cache.RaiseFieldDefaulting(field, null, out defValue))
{
Base.DataSourceByID.Cache.RaiseFieldUpdating(field, null, ref defValue);
}
Base.DataSourceByID.Cache.RaiseFieldSelecting(field, null, ref defValue, true);
e.ReturnState = defValue;
}
else
{
e.ReturnState = Base.DataSourceByID.Cache.GetStateExt(dataSource, field);
}
//Fix AmountType Combo for PM:
if (report != null && report.Type == RMType.PM && field.Equals(typeof(RMDataSource.amountType).Name, StringComparison.InvariantCultureIgnoreCase))
{
e.ReturnState = PXIntState.CreateInstance(e.ReturnValue, field, false, 0, null, null,
new int[] { BalanceType.NotSet, BalanceType.Amount, BalanceType.Quantity, BalanceType.TurnoverAmount, BalanceType.TurnoverQuantity, BalanceType.BudgetAmount, BalanceType.BudgetQuantity, BalanceType.RevisedAmount, BalanceType.RevisedQuantity, BalanceType.OriginalCommittedAmount, BalanceType.OriginalCommittedQuantity, BalanceType.CommittedAmount, BalanceType.CommittedQuantity, BalanceType.CommittedOpenAmount, BalanceType.CommittedOpenQuantity, BalanceType.CommittedReceivedQuantity, BalanceType.CommittedInvoicedAmount, BalanceType.CommittedInvoicedQuantity },
new string[]
{
Messages.GetLocal(Messages.NotSet),
Messages.GetLocal(Messages.ActualAmount),
Messages.GetLocal(Messages.ActualQuantity),
Messages.GetLocal(Messages.AmountTurnover),
Messages.GetLocal(Messages.QuantityTurnover),
Messages.GetLocal(Messages.BudgetAmount),
Messages.GetLocal(Messages.BudgetQuantity),
Messages.GetLocal(Messages.RevisedAmount),
Messages.GetLocal(Messages.RevisedQuantity),
Messages.GetLocal(Messages.OriginalCommittedAmount),
Messages.GetLocal(Messages.OriginalCommittedQuantity),
Messages.GetLocal(Messages.CommittedAmount),
Messages.GetLocal(Messages.CommittedQuantity),
Messages.GetLocal(Messages.CommittedOpenAmount),
Messages.GetLocal(Messages.CommittedOpenQuantity),
Messages.GetLocal(Messages.CommittedReceivedQuantity),
Messages.GetLocal(Messages.CommittedInvoicedAmount),
Messages.GetLocal(Messages.CommittedInvoicedQuantity)
},
typeof(short), 0);
((PXFieldState)e.ReturnState).DisplayName = Messages.GetLocal(Messages.AmountType);
}
Base1.dataSourceFieldSelecting(e, field);
if (e.ReturnState is PXFieldState)
{
((PXFieldState)e.ReturnState).SetFieldName("DataSource" + field);
((PXFieldState)e.ReturnState).Visible = Base.IsFieldVisible(field, report);
}
}
public void FillDataSource(RMDataSource ds, ARmDataSet dst, string rmType, Action <RMDataSource, ARmDataSet, string> del)
{
del(ds, dst, rmType);
if (rmType == ARmReport.PM)
{
FillDataSourceInternal(ds, dst, rmType);
}
}
private void FillDataSourceInternal(RMDataSource ds, ARmDataSet dst, string rmType)
{
if (ds != null && ds.DataSourceID != null)
{
RMDataSourcePM dsPM = Base.Caches[typeof(RMDataSource)].GetExtension <RMDataSourcePM>(ds);
dst[Keys.StartAccountGroup] = dsPM.StartAccountGroup;
dst[Keys.EndAccountGroup] = dsPM.EndAccountGroup;
dst[Keys.StartProject] = dsPM.StartProject;
dst[Keys.EndProject] = dsPM.EndProject;
dst[Keys.StartProjectTask] = dsPM.StartProjectTask;
dst[Keys.EndProjectTask] = dsPM.EndProjectTask;
dst[Keys.StartInventory] = dsPM.StartInventory;
dst[Keys.EndInventory] = dsPM.EndInventory;
}
}
public static bool AccountClassInUse(PXGraph graph, string accountClassID, out string usedIn)
{
usedIn = null;
Account account = (Account)PXSelect <Account, Where <Account.accountClassID, Equal <Required <AccountClass.accountClassID> > > > .SelectSingleBound(graph, null, accountClassID);
if (account != null)
{
usedIn = Messages.Account + account.AccountCD;
}
else
{
RMDataSource rmds = PXSelect <RMDataSource, Where <RMDataSourceGL.accountClassID, Equal <Required <AccountClass.accountClassID> > > > .SelectSingleBound(graph, null, accountClassID);
if (rmds != null)
{
usedIn = Messages.RMDataSource;
}
}
return(usedIn != null);
}
protected virtual void AccountClass_RowDeleting(PXCache sender, PXRowDeletingEventArgs e)
{
if (e.Row == null)
{
return;
}
AccountClass row = (AccountClass)e.Row;
Account account_rec = (Account)PXSelect <Account, Where <Account.accountClassID, Equal <Required <AccountClass.accountClassID> > > > .SelectWindowed(this, 0, 1, row.AccountClassID);
if (account_rec != null)
{
throw new PXException(Messages.ThisAccountClassMayNotBeDeletedBecauseItIsUsedIn, "Account: " + account_rec.AccountCD);
}
RMDataSource rmds_rec = PXSelect <RMDataSource, Where <RMDataSourceGL.accountClassID, Equal <Required <AccountClass.accountClassID> > > > .SelectWindowed(this, 0, 1, row.AccountClassID);
if (rmds_rec != null)
{
throw new PXException(Messages.ThisAccountClassMayNotBeDeletedBecauseItIsUsedIn, "Analitycal Report Manager");
}
}
protected void Page_Init(object sender, EventArgs e)
{
RMReportMaint graph = (RMReportMaint)ds.DataGraph;
PXDataSourceViewSchema schema = ds.GetSchema("Report");
RMReport currentReport = graph.Report.Current;
RMRowSet currentRowSet = (RMRowSet)graph.Caches[typeof(RMRowSet)].Current;
RMColumnSet currentColumnSet = (RMColumnSet)graph.Caches[typeof(RMColumnSet)].Current;
RMUnitSet currentUnitSet = (RMUnitSet)graph.Caches[typeof(RMUnitSet)].Current;
string currentTypeReport = currentReport != null ? currentReport.Type : null;
RMDataSource currentDataSource = graph.DataSourceByID.Current;
if (currentTypeReport == null)
{
graph.Report.Current = currentReport = new RMReport();
}
if (currentRowSet == null)
{
graph.Caches[typeof(RMRowSet)].Current = new RMRowSet();
}
graph.Caches[typeof(RMColumnSet)].Current = null;
graph.Caches[typeof(RMUnitSet)].Current = null;
Dictionary <string, List <PXFieldSchema> > controls = new Dictionary <string, List <PXFieldSchema> >();
string[] arrTypes = ((PXStringState)graph.Report.Cache.GetStateExt <RMReport.type>(null)).AllowedValues;
foreach (string type in arrTypes)
{
graph.Report.Current.Type = type;
((RMRowSet)graph.Caches[typeof(RMRowSet)].Current).Type = type;
graph.Report.Current = currentReport;
graph.DataSourceByID.Current = null;
List <PXFieldSchema> lControls = new List <PXFieldSchema>();
List <PXFieldSchema> list = RefreshFieldsList(schema, graph);
foreach (PXFieldSchema f in list)
{
if (f.DataType == TypeCode.Object)
{
continue;
}
if (!ContainsControlDictionary(f, controls))
{
lControls.Add(f);
}
}
controls.Add(type, lControls);
}
if (currentTypeReport == null)
{
graph.Report.Cache.Clear();
}
else
{
graph.Report.Current.Type = currentTypeReport;
}
graph.DataSourceByID.Current = currentDataSource;
graph.Caches[typeof(RMRowSet)].Current = currentRowSet;
graph.Caches[typeof(RMColumnSet)].Current = currentColumnSet;
graph.Caches[typeof(RMUnitSet)].Current = currentUnitSet;
_insertIndex = 0;
foreach (Control control in this.form.TemplateContainer.Controls)
{
if (!string.IsNullOrEmpty(control.ID))
{
if (!control.ID.Equals("edStartUnitCode", StringComparison.OrdinalIgnoreCase))
{
_insertIndex++;
}
else
{
break;
}
}
else
{
_insertIndex++;
}
}
_insertIndex++;
PXLayoutRule rule1 = new PXLayoutRule()
{
ID = "rule1", StartGroup = true, GroupCaption = "Default Data Source Settings"
};
(rule1).ApplyStyleSheetSkin(this.Page);
this.form.TemplateContainer.Controls.AddAt(_insertIndex, rule1);
_insertIndex++;
for (int c = arrTypes.Length - 1; c >= 0; c--)
{
string type = arrTypes[c];
List <PXFieldSchema> lDsControls = new List <PXFieldSchema>();
for (int i = 0; i < controls[type].Count; i++)
{
if (controls[type][i].DataField.StartsWith("DataSource", StringComparison.OrdinalIgnoreCase) &&
!controls[type][i].DataField.Equals("datasourceexpand", StringComparison.OrdinalIgnoreCase) &&
!controls[type][i].DataField.Equals("datasourceamounttype", StringComparison.OrdinalIgnoreCase) &&
!controls[type][i].DataField.Equals("datasourcestartPeriodOffset", StringComparison.OrdinalIgnoreCase) &&
!controls[type][i].DataField.Equals("datasourceEndPeriodOffset", StringComparison.OrdinalIgnoreCase)
//ContainsControl("Request" + controls[type][i].DataField.Replace("DataSource", string.Empty), controls[type])
)
{
lDsControls.Add(controls[type][i]);
}
}
int cntFirstColumn = lDsControls.Count / 2;
if ((lDsControls.Count % 2) > 0)
{
cntFirstColumn++;
}
for (int i = 0; i < cntFirstColumn; i++)
{
AddControl(lDsControls[i], controls[type]);
if ((lDsControls.Count - 1) >= (i + cntFirstColumn))
{
AddControl(lDsControls[i + cntFirstColumn], controls[type]);
}
}
}
PXDropDown edDataSourceAmountType = new PXDropDown()
{
ID = "edDataSourceAmountType", AllowNull = false, DataField = "DataSourceAmountType"
};
form.TemplateContainer.Controls.AddAt(_insertIndex, edDataSourceAmountType);
(edDataSourceAmountType).ApplyStyleSheetSkin(this.Page);
_insertIndex++;
PXCheckBox chkApplyRestrictionGroups = new PXCheckBox()
{
ID = "chkApplyRestrictionGroups", DataField = "ApplyRestrictionGroups"
};
form.TemplateContainer.Controls.AddAt(_insertIndex, chkApplyRestrictionGroups);
(chkApplyRestrictionGroups).ApplyStyleSheetSkin(this.Page);
}
public static List <ARmUnit> ExpandUnit(RMReportReader report, RMDataSource ds, ARmUnit unit, object startKey, object endKey, Func <ARmDataSet, List <T> > fetchRangePredicate, Func <T, string> unitCodePredicate, Func <T, string> unitDescriptionPredicate, Action <T, string> applyWildcardToItemAction)
{
string nonExpandingWildcard = null;
PreProcessNonExpandingWildcardChar(unit.DataSet, startKey, out nonExpandingWildcard);
//This will validate Start/End range and merge the pair into a single range-like value that FillSubsList expects.
ARmDataSet rangeToFetch = new ARmDataSet();
RMReportWildcard.ConcatenateRangeWithDataSet(rangeToFetch, unit.DataSet, startKey, endKey, MergingMode.Intersection);
List <T> unitItems = fetchRangePredicate(rangeToFetch);
if (nonExpandingWildcard != null)
{
//TODO: Build a better auto-description based on segment values instead of copying code to description?
unitItems = ReduceListByNonExpandingWildcard(nonExpandingWildcard, unitItems,
(u) => unitCodePredicate(u),
(u, mv) => applyWildcardToItemAction(u, mv));
}
switch (ds.RowDescription.Trim().ToUpper())
{
case RowDescriptionType.CodeDescription:
unitItems.Sort((x, y) => (unitCodePredicate(x) + unitDescriptionPredicate(x)).CompareTo(unitCodePredicate(y) + unitDescriptionPredicate(y)));
break;
case RowDescriptionType.DescriptionCode:
unitItems.Sort((x, y) => (unitDescriptionPredicate(x) + unitCodePredicate(x)).CompareTo(unitDescriptionPredicate(y) + unitCodePredicate(y)));
break;
case RowDescriptionType.Description:
unitItems.Sort((x, y) => unitDescriptionPredicate(x).CompareTo(unitDescriptionPredicate(y)));
break;
default:
unitItems.Sort((x, y) => unitCodePredicate(x).CompareTo(unitCodePredicate(y)));
break;
}
List <ARmUnit> units = new List <ARmUnit>();
int n = 0;
foreach (T unitItem in unitItems)
{
n++;
var u = new ARmUnit();
report.FillDataSource(ds, u.DataSet, report.Report.Current.Type);
u.DataSet[startKey] = unitCodePredicate(unitItem);
u.DataSet[endKey] = null;
u.Code = unit.Code + n.ToString("D5");
switch (ds.RowDescription.Trim())
{
case RowDescriptionType.CodeDescription:
u.Description = string.Format("{0}{1}{2}", unitCodePredicate(unitItem).Trim(), "-", unitDescriptionPredicate(unitItem));
break;
case RowDescriptionType.DescriptionCode:
u.Description = string.Format("{0}{1}{2}", unitDescriptionPredicate(unitItem), "-", unitCodePredicate(unitItem).Trim());
break;
case RowDescriptionType.Description:
u.Description = unitDescriptionPredicate(unitItem);
break;
default:
u.Description = unitCodePredicate(unitItem).Trim();
break;
}
u.Formula = unit.Formula;
u.PrintingGroup = unit.PrintingGroup;
units.Add(u);
}
return(units);
}
public virtual List <ARmUnit> ExpandUnit(RMDataSource ds, ARmUnit unit, Func <RMDataSource, ARmUnit, List <ARmUnit> > del)
{
string rmType = Base.Report.Current.Type;
if (rmType == ARmReport.PM)
{
if (unit.DataSet.Expand != ExpandType.Nothing)
{
PMEnsureInitialized();
if (ds.Expand == ExpandType.AccountGroup)
{
return(RMReportUnitExpansion <PMAccountGroup> .ExpandUnit(Base, ds, unit, Keys.StartAccountGroup, Keys.EndAccountGroup,
rangeToFetch => _accountGroupsRangeCache.GetItemsInRange(rangeToFetch[Keys.StartAccountGroup] as string,
accountGroup => accountGroup.GroupCD,
(accountGroup, code) => accountGroup.GroupCD = code),
accountGroup => accountGroup.GroupCD, accountGroup => accountGroup.Description,
(accountGroup, wildcard) => { accountGroup.GroupCD = wildcard; accountGroup.Description = wildcard; }));
}
else if (ds.Expand == ExpandType.Project)
{
return(RMReportUnitExpansion <PMProject> .ExpandUnit(Base, ds, unit, Keys.StartProject, Keys.EndProject,
rangeToFetch => _projectsRangeCache.GetItemsInRange(rangeToFetch[Keys.StartProject] as string,
project => project.ContractCD,
(project, code) => project.ContractCD = code),
project => project.ContractCD, project => project.Description,
(project, wildcard) => { project.ContractCD = wildcard; project.Description = wildcard; }));
}
else if (ds.Expand == ExpandType.ProjectTask)
{
return(RMReportUnitExpansion <PMTask> .ExpandUnit(Base, ds, unit, Keys.StartProjectTask, Keys.EndProjectTask,
rangeToFetch => {
List <PMTask> tasks = _tasksRangeCache.GetItemsInRange(rangeToFetch[Keys.StartProjectTask] as string,
task => task.TaskCD,
(task, code) => task.TaskCD = code);
ARmDataSet projectRange = new ARmDataSet();
RMReportWildcard.ConcatenateRangeWithDataSet(projectRange, unit.DataSet, Keys.StartProject, Keys.EndProject, MergingMode.Intersection);
if (!String.IsNullOrEmpty(projectRange[Keys.StartProject] as string))
{
//A project range is specified in the unit; restrict tasks to tasks of this project range.
List <PMProject> projects = _projectsRangeCache.GetItemsInRange(projectRange[Keys.StartProject] as string,
project => project.ContractCD,
(project, code) => project.ContractCD = code);
tasks = tasks.Where(t => projects.Any(p => t.ProjectID == p.ContractID)).ToList <PMTask>();
}
//Same project TaskCD can be reused in multiple projects; it only makes sense to get distinct values for the purpose of filling the unit tree
List <PMTask> groupedTasks = tasks.GroupBy(t => t.TaskCD).Select(g => new PMTask()
{
TaskCD = g.Key, Description = g.Min(t => t.Description)
}).ToList <PMTask>();
return groupedTasks;
},
task => task.TaskCD, project => project.Description,
(task, wildcard) => { task.TaskCD = wildcard; task.Description = wildcard; }));
}
else if (ds.Expand == ExpandType.Inventory)
{
return(RMReportUnitExpansion <InventoryItem> .ExpandUnit(Base, ds, unit, Keys.StartInventory, Keys.EndInventory,
rangeToFetch => _itemRangeCache.GetItemsInRange(rangeToFetch[Keys.StartInventory] as string,
item => item.InventoryCD,
(item, code) => item.InventoryCD = code),
item => item.InventoryCD, item => item.Descr,
(item, wildcard) => { item.InventoryCD = wildcard; item.Descr = wildcard; }));
}
}
}
else
{
return(del(ds, unit));
}
return(null);
}
public ARmReport GetReport(Func <ARmReport> del)
{
ARmReport ar = del();
int?id = Base.Report.Current.StyleID;
if (id != null)
{
RMStyle st = Base.StyleByID.SelectSingle(id);
Base.fillStyle(st, ar.Style);
}
id = Base.Report.Current.DataSourceID;
if (id != null)
{
RMDataSource ds = Base.DataSourceByID.SelectSingle(id);
FillDataSourceInternal(ds, ar.DataSet, ar.Type);
}
List <ARmReport.ARmReportParameter> aRp = ar.ARmParams;
PXFieldState state;
RMReportPM rPM = Base.Report.Cache.GetExtension <RMReportPM>(Base.Report.Current);
if (ar.Type == ARmReport.PM)
{
string sViewName = string.Empty;
string sInputMask = string.Empty;
// StartAccountGroup, EndAccountGroup
bool RequestEndAccountGroup = rPM.RequestEndAccountGroup ?? false;
//int colSpan = RequestEndAccountGroup ? 1 : 2;
int colSpan = 2;
sViewName = sInputMask = string.Empty;
state = Base.DataSourceByID.Cache.GetStateExt <RMDataSourcePM.startAccountGroup>(null) as PXFieldState;
if (state != null && !String.IsNullOrEmpty(state.ViewName))
{
sViewName = state.ViewName;
if (state is PXStringState)
{
sInputMask = ((PXStringState)state).InputMask;
}
}
Base.CreateParameter(Keys.StartAccountGroup, "StartAccountGroup", Messages.GetLocal(Messages.StartAccTitle), ar.DataSet[Keys.StartAccountGroup] as string, rPM.RequestStartAccountGroup ?? false, colSpan, sViewName, sInputMask, aRp);
sViewName = sInputMask = string.Empty;
state = Base.DataSourceByID.Cache.GetStateExt <RMDataSourcePM.endAccountGroup>(null) as PXFieldState;
if (state != null && !String.IsNullOrEmpty(state.ViewName))
{
sViewName = state.ViewName;
if (state is PXStringState)
{
sInputMask = ((PXStringState)state).InputMask;
}
}
Base.CreateParameter(Keys.EndAccountGroup, "EndAccountGroup", Messages.GetLocal(Messages.EndAccTitle), ar.DataSet[Keys.EndAccountGroup] as string, RequestEndAccountGroup, colSpan, sViewName, sInputMask, aRp);
// StartProject, EndProject
bool bRequestEndProject = rPM.RequestEndProject ?? false;
//colSpan = bRequestEndProject ? 1 : 2;
colSpan = 2;
sViewName = sInputMask = string.Empty;
state = Base.DataSourceByID.Cache.GetStateExt <RMDataSourcePM.startProject>(null) as PXFieldState;
if (state != null && !String.IsNullOrEmpty(state.ViewName))
{
sViewName = state.ViewName;
if (state is PXStringState)
{
sInputMask = ((PXStringState)state).InputMask;
}
}
Base.CreateParameter(Keys.StartProject, "StartProject", Messages.GetLocal(Messages.StartProjectTitle), ar.DataSet[Keys.StartProject] as string, rPM.RequestStartProject ?? false, colSpan, sViewName, sInputMask, aRp);
sViewName = sInputMask = string.Empty;
state = Base.DataSourceByID.Cache.GetStateExt <RMDataSourcePM.endProject>(null) as PXFieldState;
if (state != null && !String.IsNullOrEmpty(state.ViewName))
{
sViewName = state.ViewName;
if (state is PXStringState)
{
sInputMask = ((PXStringState)state).InputMask;
}
}
Base.CreateParameter(Keys.EndProject, "EndProject", Messages.GetLocal(Messages.EndProjectTitle), ar.DataSet[Keys.EndProject] as string, bRequestEndProject, colSpan, sViewName, sInputMask, aRp);
// StartTask, EndTask
bool RequestEndProjectTask = rPM.RequestEndProjectTask ?? false;
//colSpan = RequestEndProjectTask ? 1 : 2;
colSpan = 2;
sViewName = sInputMask = string.Empty;
state = Base.DataSourceByID.Cache.GetStateExt <RMDataSourcePM.startProjectTask>(null) as PXFieldState;
if (state != null && !String.IsNullOrEmpty(state.ViewName))
{
sViewName = state.ViewName;
if (state is PXStringState)
{
sInputMask = ((PXStringState)state).InputMask;
}
}
Base.CreateParameter(Keys.StartProjectTask, "StartTask", Messages.GetLocal(Messages.StartTaskTitle), ar.DataSet[Keys.StartProjectTask] as string, rPM.RequestStartProjectTask ?? false, colSpan, sViewName, sInputMask, aRp);
sViewName = sInputMask = string.Empty;
state = Base.DataSourceByID.Cache.GetStateExt <RMDataSourcePM.endProjectTask>(null) as PXFieldState;
if (state != null && !String.IsNullOrEmpty(state.ViewName))
{
sViewName = state.ViewName;
if (state is PXStringState)
{
sInputMask = ((PXStringState)state).InputMask;
}
}
Base.CreateParameter(Keys.EndProjectTask, "EndTask", Messages.GetLocal(Messages.EndTaskTitle), ar.DataSet[Keys.EndProjectTask] as string, RequestEndProjectTask, colSpan, sViewName, sInputMask, aRp);
// StartInventory, EndInventory
bool bRequestEndInventory = rPM.RequestEndInventory ?? false;
//colSpan = bRequestEndInventory ? 1 : 2;
colSpan = 2;
sViewName = sInputMask = string.Empty;
state = Base.DataSourceByID.Cache.GetStateExt <RMDataSourcePM.startInventory>(null) as PXFieldState;
if (state != null && !String.IsNullOrEmpty(state.ViewName))
{
sViewName = state.ViewName;
if (state is PXStringState)
{
sInputMask = ((PXStringState)state).InputMask;
}
}
Base.CreateParameter(Keys.StartInventory, "StartInventory", Messages.GetLocal(Messages.StartInventoryTitle), ar.DataSet[Keys.StartInventory] as string, rPM.RequestStartInventory ?? false, colSpan, sViewName, sInputMask, aRp);
sViewName = sInputMask = string.Empty;
state = Base.DataSourceByID.Cache.GetStateExt <RMDataSourcePM.endInventory>(null) as PXFieldState;
if (state != null && !String.IsNullOrEmpty(state.ViewName))
{
sViewName = state.ViewName;
if (state is PXStringState)
{
sInputMask = ((PXStringState)state).InputMask;
}
}
Base.CreateParameter(Keys.EndInventory, "EndInventory", Messages.GetLocal(Messages.EndInventoryTitle), ar.DataSet[Keys.EndInventory] as string, bRequestEndInventory, colSpan, sViewName, sInputMask, aRp);
}
return(ar);
}
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);
}
}
public virtual object GetHistoryValue(ARmDataSet dataSet, bool drilldown, Func <ARmDataSet, bool, object> del)
{
string rmType = Base.Report.Current.Type;
if (rmType == ARmReport.PM)
{
RMDataSource ds = Base.DataSourceByID.Current;
RMDataSourcePM dsPM = Base.Caches[typeof(RMDataSource)].GetExtension <RMDataSourcePM>(ds);
ds.AmountType = (short?)dataSet[RMReportReaderGL.Keys.AmountType];
dsPM.StartAccountGroup = dataSet[Keys.StartAccountGroup] as string ?? "";
dsPM.EndAccountGroup = dataSet[Keys.EndAccountGroup] as string ?? "";
dsPM.StartProject = dataSet[Keys.StartProject] as string ?? "";
dsPM.EndProject = dataSet[Keys.EndProject] as string ?? "";
dsPM.StartProjectTask = dataSet[Keys.StartProjectTask] as string ?? "";
dsPM.EndProjectTask = dataSet[Keys.EndProjectTask] as string ?? "";
dsPM.StartInventory = dataSet[Keys.StartInventory] as string ?? "";
dsPM.EndInventory = dataSet[Keys.EndInventory] as string ?? "";
RMDataSourceGL dsGL = Base.Caches[typeof(RMDataSource)].GetExtension <RMDataSourceGL>(ds);
dsGL.StartBranch = dataSet[RMReportReaderGL.Keys.StartBranch] as string ?? "";
dsGL.EndBranch = dataSet[RMReportReaderGL.Keys.EndBranch] as string ?? "";
dsGL.EndPeriod = ((dataSet[RMReportReaderGL.Keys.EndPeriod] as string ?? "").Length > 2 ? ((dataSet[RMReportReaderGL.Keys.EndPeriod] as string ?? "").Substring(2) + " ").Substring(0, 4) : " ") + ((dataSet[RMReportReaderGL.Keys.EndPeriod] as string ?? "").Length > 2 ? (dataSet[RMReportReaderGL.Keys.EndPeriod] as string ?? "").Substring(0, 2) : dataSet[RMReportReaderGL.Keys.EndPeriod] as string ?? "");
dsGL.EndPeriodOffset = (short?)(int?)dataSet[RMReportReaderGL.Keys.EndOffset];
dsGL.EndPeriodYearOffset = (short?)(int?)dataSet[RMReportReaderGL.Keys.EndYearOffset];
dsGL.StartPeriod = ((dataSet[RMReportReaderGL.Keys.StartPeriod] as string ?? "").Length > 2 ? ((dataSet[RMReportReaderGL.Keys.StartPeriod] as string ?? "").Substring(2) + " ").Substring(0, 4) : " ") + ((dataSet[RMReportReaderGL.Keys.StartPeriod] as string ?? "").Length > 2 ? (dataSet[RMReportReaderGL.Keys.StartPeriod] as string ?? "").Substring(0, 2) : dataSet[RMReportReaderGL.Keys.StartPeriod] as string ?? "");
dsGL.StartPeriodOffset = (short?)(int?)dataSet[RMReportReaderGL.Keys.StartOffset];
dsGL.StartPeriodYearOffset = (short?)(int?)dataSet[RMReportReaderGL.Keys.StartYearOffset];
List <object[]> splitret = null;
if (ds.Expand != ExpandType.Nothing)
{
splitret = new List <object[]>();
}
if (ds.AmountType == null || ds.AmountType == 0)
{
return(0m);
}
PMEnsureInitialized();
EnsureHistoryLoaded(dsPM);
NormalizeDataSource(dsPM);
List <PMAccountGroup> accountGroups = _accountGroupsRangeCache.GetItemsInRange(dataSet[Keys.StartAccountGroup] as string,
group => group.GroupCD,
(group, code) => group.GroupCD = code);
List <PMProject> projects = _projectsRangeCache.GetItemsInRange(dataSet[Keys.StartProject] as string,
project => project.ContractCD,
(project, code) => project.ContractCD = code);
List <PMTask> tasks = _tasksRangeCache.GetItemsInRange(dataSet[Keys.StartProjectTask] as string,
task => task.TaskCD,
(task, code) => task.TaskCD = code);
List <InventoryItem> items = _itemRangeCache.GetItemsInRange(dataSet[Keys.StartInventory] as string,
item => item.InventoryCD,
(item, code) => item.InventoryCD = code);
if (ds.Expand == ExpandType.AccountGroup)
{
accountGroups.ForEach(a => splitret.Add(new object[] { a.GroupCD, a.Description, 0m, null, string.Empty }));
}
else if (ds.Expand == ExpandType.Project)
{
projects.ForEach(p => splitret.Add(new object[] { p.ContractCD, p.Description, 0m, null, string.Empty }));
}
else if (ds.Expand == ExpandType.ProjectTask)
{
//To avoid useless expansion, first restrict list of tasks to those tasks which point to current projects
tasks = tasks.Where(t => projects.Any(p => t.ProjectID == p.ContractID)).ToList <PMTask>();
tasks = tasks.GroupBy(t => t.TaskCD).Select(g => new PMTask()
{
TaskCD = g.Key, TaskID = g.Min(t => t.TaskID), Description = g.Min(t => t.Description)
}).ToList <PMTask>();
tasks.ForEach(pt => splitret.Add(new object[] { pt.TaskCD, pt.Description, 0m, null, string.Empty }));
}
else if (ds.Expand == ExpandType.Inventory)
{
items.ForEach(i => splitret.Add(new object[] { i.InventoryCD, i.Descr, 0m, null, string.Empty }));
}
return(CalculateAndExpandValue(drilldown, ds, dsGL, dsPM, dataSet, accountGroups, projects, tasks, items, splitret));
}
else
{
return(del(dataSet, drilldown));
}
}
