private string BuildActivitySchedules(IList <IResourceSchedule <int> > resourceSchedules)
{
lock (m_Lock)
{
if (resourceSchedules == null)
{
return(string.Empty);
}
var output = new StringBuilder();
int spareResourceCount = 1;
for (int resourceIndex = 0; resourceIndex < resourceSchedules.Count; resourceIndex++)
{
IResourceSchedule <int> resourceSchedule = resourceSchedules[resourceIndex];
IList <IScheduledActivity <int> > scheduledActivities = resourceSchedule?.ScheduledActivities;
if (scheduledActivities == null)
{
continue;
}
var stringBuilder = new StringBuilder(@">Resource");
if (resourceSchedule.Resource != null)
{
stringBuilder.Append($@" {resourceSchedule.Resource.Id}");
if (!string.IsNullOrWhiteSpace(resourceSchedule.Resource.Name))
{
stringBuilder.Append($@" ({resourceSchedule.Resource.Name})");
}
}
else
{
stringBuilder.Append($@" {spareResourceCount}");
spareResourceCount++;
}
output.AppendLine(stringBuilder.ToString());
int previousFinishTime = 0;
foreach (IScheduledActivity <int> scheduledActivity in scheduledActivities)
{
int startTime = scheduledActivity.StartTime;
int finishTime = scheduledActivity.FinishTime;
if (startTime > previousFinishTime)
{
string from = ChartHelper.FormatScheduleOutput(previousFinishTime, ShowDates, ProjectStart, m_DateTimeCalculator);
string to = ChartHelper.FormatScheduleOutput(startTime, ShowDates, ProjectStart, m_DateTimeCalculator);
output.AppendLine($@"*** {from} -> {to} ***");
}
string start = ChartHelper.FormatScheduleOutput(startTime, ShowDates, ProjectStart, m_DateTimeCalculator);
string finish = ChartHelper.FormatScheduleOutput(finishTime, ShowDates, ProjectStart, m_DateTimeCalculator);
output.AppendLine($@"Activity {scheduledActivity.Id}: {start} -> {finish}");
previousFinishTime = finishTime;
}
output.AppendLine();
}
return(output.ToString());
}
}
public static ResourceScheduleDto ToDto(IResourceSchedule <int> resourceSchedule)
{
if (resourceSchedule == null)
{
throw new ArgumentNullException(nameof(resourceSchedule));
}
return(new ResourceScheduleDto
{
Resource = resourceSchedule.Resource != null?ToDto(resourceSchedule.Resource) : null,
ScheduledActivities = resourceSchedule.ScheduledActivities.Select(x => ToDto(x)).ToList(),
FinishTime = resourceSchedule.FinishTime
});
}
public void UpdateActivitiesAllocatedToResources()
{
lock (m_Lock)
{
IList <IResourceSchedule <int> > resourceSchedules = GraphCompilation?.ResourceSchedules;
IList <ResourceDto> resources = ResourceSettingsDto.Resources;
if (resourceSchedules == null || resources == null)
{
return;
}
var activityAllocatedToResourcesLookup = new Dictionary <int, HashSet <int> >();
for (int resourceIndex = 0; resourceIndex < resourceSchedules.Count; resourceIndex++)
{
IResourceSchedule <int> resourceSchedule = resourceSchedules[resourceIndex];
IList <IScheduledActivity <int> > scheduledActivities = resourceSchedule?.ScheduledActivities;
if (resourceSchedule.Resource == null || scheduledActivities == null)
{
continue;
}
foreach (IScheduledActivity <int> scheduledActivity in scheduledActivities)
{
if (!activityAllocatedToResourcesLookup.TryGetValue(scheduledActivity.Id, out HashSet <int> allocatedToResources))
{
allocatedToResources = new HashSet <int>();
activityAllocatedToResourcesLookup.Add(scheduledActivity.Id, allocatedToResources);
}
allocatedToResources.Add(resourceSchedule.Resource.Id);
}
}
foreach (ManagedActivityViewModel activity in Activities)
{
if (!activityAllocatedToResourcesLookup.TryGetValue(activity.Id, out HashSet <int> allocatedToResources))
{
allocatedToResources = new HashSet <int>();
}
activity.SetAllocatedToResources(
resources.Select(x => x.Copy()),
allocatedToResources);
}
}
}
public IList <ResourceSeriesDto> CalculateResourceSeriesSet(
IList <IResourceSchedule <int> > resourceSchedules,
IList <ResourceDto> resources,
double defaultUnitCost)
{
if (resourceSchedules == null)
{
throw new ArgumentNullException(nameof(resourceSchedules));
}
if (resources == null)
{
throw new ArgumentNullException(nameof(resources));
}
var resourceSeriesSet = new List <ResourceSeriesDto>();
if (resourceSchedules.Any())
{
IDictionary <int, ColorFormatDto> colorFormatLookup = resources.ToDictionary(x => x.Id, x => x.ColorFormat);
var indirectResourceIdsToIgnore = new HashSet <int>();
int finishTime = resourceSchedules.Max(x => x.FinishTime);
int spareResourceCount = 1;
var scheduledSeriesSet = new List <ResourceSeriesDto>();
for (int resourceIndex = 0; resourceIndex < resourceSchedules.Count; resourceIndex++)
{
IResourceSchedule <int> resourceSchedule = resourceSchedules[resourceIndex];
var series = new ResourceSeriesDto()
{
Values = resourceSchedule.ActivityAllocation.Select(x => x ? 1 : 0).ToList()
};
series.InterActivityAllocationType = InterActivityAllocationType.None;
var stringBuilder = new StringBuilder();
IResource <int> resource = resourceSchedule.Resource;
if (resource != null)
{
series.InterActivityAllocationType = resource.InterActivityAllocationType;
indirectResourceIdsToIgnore.Add(resource.Id);
if (string.IsNullOrWhiteSpace(resource.Name))
{
stringBuilder.Append($@"Resource {resource.Id}");
}
else
{
stringBuilder.Append($@"{resource.Name}");
}
}
else
{
stringBuilder.Append($@"Resource {spareResourceCount}");
spareResourceCount++;
}
series.Title = stringBuilder.ToString();
series.ColorFormatDto = resource != null && colorFormatLookup.ContainsKey(resource.Id) ? colorFormatLookup[resource.Id].Copy() : new ColorFormatDto().Randomize();
series.UnitCost = resource?.UnitCost ?? defaultUnitCost;
series.DisplayOrder = resource?.DisplayOrder ?? 0;
scheduledSeriesSet.Add(series);
}
// Now add the remaining resources that are indirect costs, but
// sort them separately and add them to the front of the list.
var unscheduledSeriesSet = new List <ResourceSeriesDto>();
IEnumerable <ResourceDto> indirectResources =
resources.Where(x => !indirectResourceIdsToIgnore.Contains(x.Id) && x.InterActivityAllocationType == InterActivityAllocationType.Indirect);
foreach (ResourceDto resourceDto in indirectResources)
{
var series = new ResourceSeriesDto()
{
InterActivityAllocationType = resourceDto.InterActivityAllocationType,
Values = new List <int>(Enumerable.Repeat(1, finishTime))
};
var stringBuilder = new StringBuilder();
if (string.IsNullOrWhiteSpace(resourceDto.Name))
{
stringBuilder.Append($@"Resource {resourceDto.Id}");
}
else
{
stringBuilder.Append($@"{resourceDto.Name}");
}
series.Title = stringBuilder.ToString();
series.ColorFormatDto = resourceDto.ColorFormat != null?resourceDto.ColorFormat.Copy() : new ColorFormatDto().Randomize();
series.UnitCost = resourceDto.UnitCost;
series.DisplayOrder = resourceDto.DisplayOrder;
unscheduledSeriesSet.Add(series);
}
resourceSeriesSet.AddRange(unscheduledSeriesSet.OrderBy(x => x.DisplayOrder));
resourceSeriesSet.AddRange(scheduledSeriesSet.OrderBy(x => x.DisplayOrder));
}
return(resourceSeriesSet);
}
private void BuildGanttChart(
IList <IDependentActivity <int> > dependentActivities,
IList <ResourceSeriesDto> resourceSeriesSet,
IList <IResourceSchedule <int> > resourceSchedules,
DateTime projectStart,
SlackColorFormatLookup colorFormatLookup)
{
if (dependentActivities == null || resourceSeriesSet == null || resourceSchedules == null)
{
return;
}
IDictionary <int, IDependentActivity <int> > activityLookup = dependentActivities.ToDictionary(x => x.Id);
int spareResourceCount = 1;
for (int resourceIndex = 0; resourceIndex < resourceSchedules.Count; resourceIndex++)
{
IResourceSchedule <int> resourceSchedule = resourceSchedules[resourceIndex];
IList <IScheduledActivity <int> > scheduledActivities = resourceSchedule?.ScheduledActivities;
if (scheduledActivities == null)
{
continue;
}
var stringBuilder = new StringBuilder();
if (resourceSchedule.Resource != null)
{
if (string.IsNullOrWhiteSpace(resourceSchedule.Resource.Name))
{
stringBuilder.Append($@"Resource {resourceSchedule.Resource.Id}");
}
else
{
stringBuilder.Append(resourceSchedule.Resource.Name);
}
}
else
{
stringBuilder.Append($@"Resource {spareResourceCount}");
spareResourceCount++;
}
string resourceName = stringBuilder.ToString();
GanttRowGroup rowGroup = GanttChartAreaCtrl.CreateGanttRowGroup(resourceName);
foreach (IScheduledActivity <int> scheduledctivity in resourceSchedule.ScheduledActivities)
{
if (activityLookup.TryGetValue(scheduledctivity.Id, out IDependentActivity <int> activity))
{
GanttRow row = GanttChartAreaCtrl.CreateGanttRow(rowGroup, activity.Name);
if (activity.EarliestStartTime.HasValue &&
activity.EarliestFinishTime.HasValue)
{
GanttChartAreaCtrl.AddGanttTask(
row,
CreateGanttTask(projectStart, activity, colorFormatLookup));
}
}
}
}
}
