public static IQueryable <PROJECT_Dashboard> SummarizePROJECTDashboard(IQueryable <PROJECT> PROJECTS, Func <IQueryable <PROGRESS> > getLivePROGRESSESFunc, Func <IQueryable <BASELINE> > getLiveBASELINESFunc, Func <IQueryable <RATE> > getRATESFunc, Func <IQueryable <VARIATION> > getApprovedVARIATIONFunc = null)
{
IEnumerable <BASELINE> LiveBASELINES = getLiveBASELINESFunc().ToArray().AsEnumerable();
IEnumerable <PROGRESS> LivePROGRESSES = getLivePROGRESSESFunc().ToArray().AsEnumerable();
IEnumerable <VARIATION> ApprovedVARIATIONS;
if (getApprovedVARIATIONFunc != null)
{
ApprovedVARIATIONS = getApprovedVARIATIONFunc().ToArray().AsEnumerable();
}
else
{
ApprovedVARIATIONS = new List <VARIATION>();
}
IEnumerable <RATE> AllRATES = getRATESFunc();
IEnumerable <PROJECT> localPROJECTS = PROJECTS.Where(x => x.STATUS == ProjectStatus.Active).ToArray().AsEnumerable(); //process only active PROJECTS
List <PROJECT_Dashboard> returnPROJECT_Dashboard = new List <PROJECT_Dashboard>();
IBluePrintsEntitiesUnitOfWork bluePrintsUnitOfWork = BluePrintsEntitiesUnitOfWorkSource.GetUnitOfWorkFactory().CreateUnitOfWork();
IP6EntitiesUnitOfWork p6UnitOfWork = P6EntitiesUnitOfWorkSource.GetUnitOfWorkFactory().CreateUnitOfWork();
foreach (PROJECT localPROJECT in localPROJECTS)
{
BASELINE currentPROJECTLiveBASELINE = LiveBASELINES.FirstOrDefault(x => x.GUID_PROJECT == localPROJECT.GUID);
if (currentPROJECTLiveBASELINE == null)
{
continue;
}
PROGRESS currentPROJECTLivePROGRESS = LivePROGRESSES.FirstOrDefault(x => x.GUID_PROJECT == localPROJECT.GUID);
if (currentPROJECTLivePROGRESS == null)
{
continue;
}
IQueryable <PROGRESS_ITEM> LivePROGRESS_ITEMS = currentPROJECTLivePROGRESS.PROGRESS_ITEM.AsQueryable();
IQueryable <BASELINE_ITEM> LiveBASELINE_ITEMS = currentPROJECTLiveBASELINE.BASELINE_ITEM.AsQueryable();
IQueryable <RATE> RATESByProject = AllRATES.Where(x => x.GUID_PROJECT == localPROJECT.GUID).AsQueryable();
IEnumerable <VARIATION> ApprovedVARIATIONSByProject = ApprovedVARIATIONS.Where(x => x.GUID_PROJECT == localPROJECT.GUID).AsEnumerable();
IEnumerable <ReportableObject> PROJECTInfos = PROGRESS_ITEMProjectionQueries.JoinRATESAndPROGRESS_ITEMSOnBASELINE_ITEMS(
LiveBASELINE_ITEMS, () => currentPROJECTLivePROGRESS, () => currentPROJECTLiveBASELINE, () => LivePROGRESS_ITEMS, () => RATESByProject).ToArray().AsEnumerable();
PROJECT_Dashboard currentPROJECT_Dashboard = new PROJECT_Dashboard()
{
GUID = localPROJECT.GUID, PROJECT = localPROJECT, VARIATIONS = ApprovedVARIATIONSByProject
};
currentPROJECT_Dashboard.InitializeBuilder(PROJECTInfos, currentPROJECTLivePROGRESS, currentPROJECTLiveBASELINE, bluePrintsUnitOfWork, p6UnitOfWork);
returnPROJECT_Dashboard.Add(currentPROJECT_Dashboard);
}
foreach (PROJECT_Dashboard project in returnPROJECT_Dashboard)
{
BuildProjectStats summaryManufacturer = new BuildProjectStats();
summaryManufacturer.Manufacture(project.SummaryBuilder);
}
return(returnPROJECT_Dashboard.AsQueryable());
}
public void AssignProperties(PROJECT PROJECT, BASELINE BASELINE, IEnumerable <BASELINE_ITEMProjection> BASELINE_ITEMS)
{
objectDataSource1.DataSource = BASELINE_ITEMS;
title1.Value = BASELINE.NAME;
projectName.Value = PROJECT.NAME;
date1.Value = DateTime.Now;
}
public static IQueryable <BASELINE_ITEMProjection> JoinRATESOnBASELINE_ITEMS(IQueryable <BASELINE_ITEM> BASELINE_ITEMS, Func <BASELINE> getBASELINEFunc, Func <IQueryable <RATE> > getRATES_ByProjectFunc = null, bool isBASELINEQueryProcessed = false)
{
BASELINE BASELINE = getBASELINEFunc();
IQueryable <BASELINE_ITEM> contextBASELINE_ITEMS;
if (BASELINE == null)
{
contextBASELINE_ITEMS = BASELINE_ITEMS.Where(x => x.GUID == Guid.Empty);
}
else
{
if (isBASELINEQueryProcessed)
{
contextBASELINE_ITEMS = BASELINE_ITEMS;
}
else
{
contextBASELINE_ITEMS = BASELINE_ITEMS.Where(x => x.GUID_BASELINE == BASELINE.GUID);
}
}
IQueryable <RATE> RATES = getRATES_ByProjectFunc();
return(contextBASELINE_ITEMS.ToArray().AsQueryable().Select(x => new BASELINE_ITEMProjection()
{
GUID = x.GUID, BASELINE_ITEM = x, RATE = RATES.FirstOrDefault(y => y.GUID_DEPARTMENT == x.GUID_DEPARTMENT && y.GUID_DISCIPLINE == x.GUID_DISCIPLINE)
}));
}
public static IQueryable <VARIATION_ITEMProjection> JoinRATESAndPROGRESS_ITEMSAndVARIATION_ITEMSOnBASELINE_ITEMS(IQueryable <BASELINE_ITEM> BASELINE_ITEMS, Func <PROGRESS> getPROGRESSFunc, Func <BASELINE> getBASELINEFunc, Func <VARIATION> getVARIATIONFunc, Func <IQueryable <PROGRESS_ITEM> > getPROGRESS_ITEMSFunc, Func <IQueryable <VARIATION_ITEM> > getVARIATION_ITEMSFunc, Func <IQueryable <RATE> > getRATESFunc, bool IsLocked)
{
BASELINE BASELINE = getBASELINEFunc();
PROGRESS PROGRESS = getPROGRESSFunc();
VARIATION VARIATION = getVARIATIONFunc();
IQueryable <RATE> RATES = getRATESFunc();
IQueryable <VARIATION_ITEM> LoadVARIATION_ITEMS;
if (VARIATION == null)
{
LoadVARIATION_ITEMS = getVARIATION_ITEMSFunc().Where(x => x.GUID_VARIATION == Guid.Empty).ToArray().AsQueryable();
}
else
{
LoadVARIATION_ITEMS = getVARIATION_ITEMSFunc().ToArray().AsQueryable();
}
IQueryable <PROGRESS_ITEM> LoadPROGRESS_ITEMS;
if (PROGRESS == null)
{
LoadPROGRESS_ITEMS = getPROGRESS_ITEMSFunc().Where(x => x.GUID_PROGRESS == Guid.Empty).ToArray().AsQueryable();
}
else
{
LoadPROGRESS_ITEMS = getPROGRESS_ITEMSFunc().ToArray().AsQueryable();
}
IQueryable <PROGRESS_ITEMProjection> BASELINE_ITEMJoinRATESJoinPROGRESS_ITEMS;
if (PROGRESS == null || VARIATION == null)
{
BASELINE_ITEMJoinRATESJoinPROGRESS_ITEMS = PROGRESS_ITEMProjectionQueries.JoinRATESAndPROGRESS_ITEMSOnBASELINE_ITEMS(BASELINE_ITEMS.Where(x => x.GUID == Guid.Empty), getPROGRESSFunc, getBASELINEFunc, getPROGRESS_ITEMSFunc, getRATESFunc, true);
}
else
{
if (VARIATION.SUBMITTED != null)
{
BASELINE_ITEMJoinRATESJoinPROGRESS_ITEMS = PROGRESS_ITEMProjectionQueries.JoinRATESAndPROGRESS_ITEMSOnBASELINE_ITEMS(BASELINE_ITEMS.Where(x => x.GUID_VARIATION == VARIATION.GUID && x.GUID_BASELINE != null), getPROGRESSFunc, getBASELINEFunc, getPROGRESS_ITEMSFunc, getRATESFunc, true);
}
else
{
BASELINE_ITEMJoinRATESJoinPROGRESS_ITEMS = PROGRESS_ITEMProjectionQueries.JoinRATESAndPROGRESS_ITEMSOnBASELINE_ITEMS(BASELINE_ITEMS.Where(x => x.GUID_BASELINE == BASELINE.GUID || (x.GUID_VARIATION == VARIATION.GUID && x.GUID_BASELINE == null)), getPROGRESSFunc, getBASELINEFunc, getPROGRESS_ITEMSFunc, getRATESFunc, true);
}
}
return(BASELINE_ITEMJoinRATESJoinPROGRESS_ITEMS.ToArray().AsQueryable().Select(x => new VARIATION_ITEMProjection()
{
GUID = x.GUID,
VARIATION_ITEM = LoadVARIATION_ITEMS.Where(y => y.GUID_ORIBASEITEM == x.BASELINE_ITEMJoinRATE.BASELINE_ITEM.GUID_ORIGINAL).FirstOrDefault(),
BASELINE_ITEMJoinRATE = x.BASELINE_ITEMJoinRATE,
ISLOCKED = IsLocked
}));
}
bool isContinueLoadingAfterBASELINE(IEnumerable <BASELINE> entities)
{
if (entities.Count() == 0)
{
mainThreadDispatcher.BeginInvoke(new Action(() => MessageBoxService.ShowMessage(string.Format(CommonResources.Notify_View_Removed, "BASELINE"))));
return(false);
}
this.loadBASELINE = entities.First();
return(true);
}
protected override void InitializeParameters(object parameter)
{
OptionalEntitiesParameter <PROJECT, BASELINE> receiveParameter = (OptionalEntitiesParameter <PROJECT, BASELINE>)parameter;
this.loadPROJECT = receiveParameter.GetFirstEntity();
this.loadBASELINE = receiveParameter.GetSecondEntity();
if (this.loadPROJECT != null)
{
isQueryForLiveStatus = true;
}
}
protected override void InitializeParameters(object parameter)
{
object[] obj = (object[])parameter;
if (isFromPROGRESS)
{
loadPROGRESS = (PROGRESS)obj[0];
}
else
{
loadBASELINE = (BASELINE)obj[0];
}
mappingType = (BaselineMappingSelectionType)obj[1];
}
public static IQueryable <PROGRESS_ITEMProjection> JoinRATESAndPROGRESS_ITEMSOnBASELINE_ITEMS(IQueryable <BASELINE_ITEM> BASELINE_ITEMS, Func <PROGRESS> getPROGRESSFunc, Func <BASELINE> getBASELINEFunc, Func <IQueryable <PROGRESS_ITEM> > getPROGRESS_ITEMSFunc, Func <IQueryable <RATE> > getRATESFunc, bool isBASELINEQueryProcessed = false)
{
BASELINE BASELINE = getBASELINEFunc();
PROGRESS PROGRESS = getPROGRESSFunc();
IQueryable <RATE> RATES = getRATESFunc();
IQueryable <PROGRESS_ITEM> LoadPROGRESS_ITEMS;
if (PROGRESS == null)
{
LoadPROGRESS_ITEMS = getPROGRESS_ITEMSFunc().Where(x => x.GUID_PROGRESS == Guid.Empty).ToArray().AsQueryable();
}
else
{
LoadPROGRESS_ITEMS = getPROGRESS_ITEMSFunc().ToArray().AsQueryable();
}
IQueryable <BASELINE_ITEMProjection> BASELINE_ITEMJoinRATES;
if (PROGRESS == null)
{
BASELINE_ITEMJoinRATES = BASELINE_ITEMProjectionQueries.JoinRATESOnBASELINE_ITEMS(BASELINE_ITEMS.Where(x => x.GUID == Guid.Empty), getBASELINEFunc, getRATESFunc, true);
}
else
{
BASELINE_ITEMJoinRATES = BASELINE_ITEMProjectionQueries.JoinRATESOnBASELINE_ITEMS(BASELINE_ITEMS, getBASELINEFunc, getRATESFunc, isBASELINEQueryProcessed);
}
DateTime reportingDate = PROGRESS == null ? new DateTime() : PROGRESS.DATA_DATE;
return(BASELINE_ITEMJoinRATES.ToArray().AsQueryable().Select(x => new PROGRESS_ITEMProjection()
{
GUID = x.GUID, BASELINE_ITEMJoinRATE = x, ReportingDataDate = reportingDate, PROGRESS_ITEMS = LoadPROGRESS_ITEMS.Where(y => y.GUID_ORIBASEITEM == x.BASELINE_ITEM.GUID_ORIGINAL).ToArray().AsEnumerable()
}));
}
public void InitializeBuilder(IEnumerable <ReportableObject> reportableObjects, PROGRESS livePROGRESS, BASELINE liveBASELINE, IBluePrintsEntitiesUnitOfWork bluePrintsUnitOfWork, IP6EntitiesUnitOfWork p6UnitOfWork)
{
this.ReportableObjects = reportableObjects;
this.LiveBASELINE = liveBASELINE;
this.LivePROGRESS = livePROGRESS;
SummaryBuilder = new PROJECTSummaryBuilder(this, bluePrintsUnitOfWork, p6UnitOfWork);
}
/// <summary>
/// Approves an entity.
/// Since CollectionViewModelBase is a POCO view model, an the instance of this class will also expose the ApproveCommand property that can be used as a binding source in views.
/// </summary>
/// <param name="projectionEntity">An entity to approve.</param>
public void Approve(VARIATION entity)
{
string errorMessage = string.Empty;
if (entity == null)
{
errorMessage = "Nothing within variation to approve";
}
else if (loadPROJECT == null)
{
errorMessage = "Project doesn't exists";
}
else if (loadBASELINE == null)
{
errorMessage = "Live baseline doesn't exists";
}
else if (loadPROGRESS == null)
{
errorMessage = "Live progress doesn't exists";
}
if (errorMessage != string.Empty)
{
MessageBoxService.ShowMessage(errorMessage);
return;
}
IBluePrintsEntitiesUnitOfWork unitOfWork = bluePrintsUnitOfWorkFactory.CreateUnitOfWork();
BASELINE LiveBASELINE = loadBASELINE;
IEnumerable <VARIATION_ITEM> editVARIATION_ITEMS = unitOfWork.VARIATION_ITEMS.Where(x => x.GUID_VARIATION == entity.GUID).ToArray().AsEnumerable();
IEnumerable <BASELINE_ITEM> addBASELINE_ITEMS = unitOfWork.BASELINE_ITEMS.Where(x => x.GUID_VARIATION == entity.GUID && x.GUID_BASELINE == null).ToArray().AsEnumerable();
IQueryable <BASELINE_ITEM> editBASELINE_ITEMS = loaderCollection.GetCollection <BASELINE_ITEM>();
IEnumerable <PROGRESS_ITEM> livePROGRESS_ITEMS = loaderCollection.GetCollection <PROGRESS_ITEM>();
BASELINE newBASELINE = new BASELINE();
DataUtils.ShallowCopy(newBASELINE, LiveBASELINE);
newBASELINE.GUID = Guid.Empty;
newBASELINE.REVISION = ((char)(LiveBASELINE.REVISION.Last() + 1)).ToString();
//not saving new baseline as live yet because editBASELINE_ITEMS still depends on the current live baseline for copying BASELINE_ITEMS
newBASELINE.STATUS = BaselineStatus.Superseded;
CollectionViewModel <BASELINE, BASELINE, Guid, IBluePrintsEntitiesUnitOfWork> BASELINECollectionViewModel = (CollectionViewModel <BASELINE, BASELINE, Guid, IBluePrintsEntitiesUnitOfWork>)loaderCollection.GetViewModel <BASELINE>();
CollectionViewModel <BASELINE_ITEM, BASELINE_ITEM, Guid, IBluePrintsEntitiesUnitOfWork> BASELINE_ITEMCollectionViewModel = (CollectionViewModel <BASELINE_ITEM, BASELINE_ITEM, Guid, IBluePrintsEntitiesUnitOfWork>)loaderCollection.GetViewModel <BASELINE_ITEM>();
BASELINECollectionViewModel.Save(newBASELINE);
entity.APPROVED = DateTime.Now;
entity.GUID_ORIBASELINE = LiveBASELINE.GUID;
entity.GUID_BASELINE = newBASELINE.GUID;
MainViewModel.Save(entity);
ObservableCollection <BASELINE_ITEM> newBASELINE_ITEMS = new ObservableCollection <BASELINE_ITEM>();
foreach (BASELINE_ITEM editBASELINE_ITEM in editBASELINE_ITEMS)
{
BASELINE_ITEM copyBASELINE_ITEM = new BASELINE_ITEM();
DataUtils.ShallowCopy(copyBASELINE_ITEM, editBASELINE_ITEM);
VARIATION_ITEM editVARIATION_ITEM = editVARIATION_ITEMS.FirstOrDefault(x => x.GUID_ORIBASEITEM == editBASELINE_ITEM.GUID_ORIGINAL);
if (editVARIATION_ITEM != null)
{
if (editVARIATION_ITEM.ACTION == VariationAction.Cancel)
{
decimal progressItemEARNED_UNITS = livePROGRESS_ITEMS.Where(x => x.GUID_ORIBASEITEM == editBASELINE_ITEM.GUID_ORIGINAL).Sum(y => y.EARNED_UNITS);
if (progressItemEARNED_UNITS == 0)
{
copyBASELINE_ITEM.DC_HOURS = -1 * copyBASELINE_ITEM.ESTIMATED_HOURS;
}
else
{
copyBASELINE_ITEM.DC_HOURS = -1 * (copyBASELINE_ITEM.TOTAL_HOURS - progressItemEARNED_UNITS);
}
}
else if (editVARIATION_ITEM.ACTION == VariationAction.Append)
{
copyBASELINE_ITEM.DC_HOURS += editVARIATION_ITEM.VARIATION_UNITS;
}
if (editVARIATION_ITEM.ACTION != VariationAction.NoAction)
{
copyBASELINE_ITEM.GUID_VARIATION = entity.GUID;
}
}
copyBASELINE_ITEM.GUID = Guid.Empty;
copyBASELINE_ITEM.GUID_BASELINE = newBASELINE.GUID;
newBASELINE_ITEMS.Add(copyBASELINE_ITEM);
}
foreach (BASELINE_ITEM addBASELINE_ITEM in addBASELINE_ITEMS)
{
BASELINE_ITEM newBASELINE_ITEM = new BASELINE_ITEM();
DataUtils.ShallowCopy(newBASELINE_ITEM, addBASELINE_ITEM);
newBASELINE_ITEM.GUID = Guid.Empty;
newBASELINE_ITEM.GUID_BASELINE = newBASELINE.GUID;
newBASELINE_ITEM.INTERNAL_NUM = BluePrintDataUtils.BASELINEITEM_Generate_InternalNumber(this.loadPROJECT, newBASELINE_ITEM, newBASELINE_ITEMS, addBASELINE_ITEM.AREA, addBASELINE_ITEM.DISCIPLINE, addBASELINE_ITEM.DOCTYPE);
VARIATION_ITEM editVARIATION_ITEM = editVARIATION_ITEMS.First(x => x.GUID_ORIBASEITEM == newBASELINE_ITEM.GUID_ORIGINAL);
newBASELINE_ITEM.DC_HOURS = editVARIATION_ITEM.VARIATION_UNITS;
newBASELINE_ITEM.GUID_VARIATION = entity.GUID;
newBASELINE_ITEMS.Add(newBASELINE_ITEM);
}
foreach (BASELINE_ITEM newBASELINE_ITEM in newBASELINE_ITEMS)
{
BASELINE_ITEMCollectionViewModel.Save(newBASELINE_ITEM);
}
LiveBASELINE.STATUS = BaselineStatus.Superseded;
BASELINECollectionViewModel.Save(LiveBASELINE);
newBASELINE.STATUS = BaselineStatus.Live;
BASELINECollectionViewModel.Save(newBASELINE);
}
