/// <summary> Loads a list of employees pair working on same project </summary>
public List <EmployeesWorkingPair> LoadEmployeesWorkingPairV1()
{
Dictionary <int, List <Employee> > projectToEmployeesDictionary = new Dictionary <int, List <Employee> >();
employees.ForEach((employee) =>
{
if (projectToEmployeesDictionary.ContainsKey(employee.ProjectID))
{
var value = projectToEmployeesDictionary[employee.ProjectID];
value.Add(employee);
}
else
{
List <Employee> workingDaysList = new List <Employee>()
{
employee
};
projectToEmployeesDictionary.Add(employee.ProjectID, workingDaysList);
}
});
Dictionary <EmployeeProjectWorkingDaysKey, int> projectToEmployeesWorkingPairs = new Dictionary <EmployeeProjectWorkingDaysKey, int>(new EmployeeProjectWorkingDaysKey.EqualityComparer());
foreach (var item in projectToEmployeesDictionary)
{
var employeesValue = item.Value;
// We need at least 2 employees working on one project
if (employeesValue.Count <= 0)
{
continue;
}
for (int index = 0; index < employeesValue.Count; index++)
{
var foundItems = employeesValue.FindAll((value) => { return(employeesValue[index].EmployeeID != value.EmployeeID); });
foreach (var foundItem in foundItems)
{
DateTime beginDate = Utilities.Max(employeesValue[index].DateFrom, foundItem.DateFrom),
endDate = Utilities.Min(employeesValue[index].DateTo, foundItem.DateTo);
// Check if we have matching periods
if (beginDate > endDate)
{
continue;
}
EmployeeProjectWorkingDaysKey key = new EmployeeProjectWorkingDaysKey()
{
ProjectID = employeesValue[index].ProjectID,
EmployeeID1 = Utilities.Min(employeesValue[index].EmployeeID, foundItem.EmployeeID),
EmployeeID2 = Utilities.Max(employeesValue[index].EmployeeID, foundItem.EmployeeID)
};
if (projectToEmployeesWorkingPairs.ContainsKey(key))
{
var DaysWorked = projectToEmployeesWorkingPairs[key];
projectToEmployeesWorkingPairs[key] += (int)Utilities.CountDaysBetweenDates(beginDate, endDate);
}
else
{
projectToEmployeesWorkingPairs.Add(key, (int)Utilities.CountDaysBetweenDates(beginDate, endDate));
}
}
}
}
List <EmployeesWorkingPair> employeesWorkingPairs = new List <EmployeesWorkingPair>(projectToEmployeesWorkingPairs.Count);
foreach (var item in projectToEmployeesWorkingPairs)
{
employeesWorkingPairs.Add(new EmployeesWorkingPair()
{
ProjectID = item.Key.ProjectID,
FirstEmployeeID = item.Key.EmployeeID1,
SecondEmployeeID = item.Key.EmployeeID2,
DaysWorked = item.Value
});
}
return(employeesWorkingPairs);
}
/// <summary> Loads a list of employees pair working on same project </summary>
public List <EmployeesWorkingPair> LoadEmployeesWorkingPairV2()
{
Dictionary <int, List <Employee> > projectToEmployeesDictionary = new Dictionary <int, List <Employee> >();
employees.ForEach((employee) =>
{
if (projectToEmployeesDictionary.ContainsKey(employee.ProjectID))
{
var value = projectToEmployeesDictionary[employee.ProjectID];
value.Add(employee);
}
else
{
List <Employee> workingDaysList = new List <Employee>()
{
employee
};
projectToEmployeesDictionary.Add(employee.ProjectID, workingDaysList);
}
});
Dictionary <int, Dictionary <int, Dictionary <int, int> > > projectToEmployeePairToWorkDays = new Dictionary <int, Dictionary <int, Dictionary <int, int> > >();
foreach (var projectsItem in projectToEmployeesDictionary)
{
var employeesValue = projectsItem.Value;
// We need at least 2 employees working on one project
if (employeesValue.Count < 2)
{
continue;
}
for (int index = 0; index < employeesValue.Count - 1; index++)
{
var employee = employeesValue[index];
for (int searchIndex = index + 1; searchIndex < employeesValue.Count; searchIndex++)
{
var foundEmployee = employeesValue[searchIndex];
if (foundEmployee.EmployeeID == employee.EmployeeID)
{
continue;
}
DateTime beginDate = Utilities.Max(employee.DateFrom, foundEmployee.DateFrom),
endDate = Utilities.Min(employee.DateTo, foundEmployee.DateTo);
// Check if we have matching periods
if (beginDate > endDate)
{
continue;
}
int workDays = (int)Utilities.CountDaysBetweenDates(beginDate, endDate);
AddProjectToEmployeePairDictionary(employee.ProjectID, employee.EmployeeID, foundEmployee.EmployeeID, workDays, ref projectToEmployeePairToWorkDays);
}
}
}
Dictionary <EmployeeProjectWorkingDaysKey, int> projectToEmployeesWorkingPairs = new Dictionary <EmployeeProjectWorkingDaysKey, int>(new EmployeeProjectWorkingDaysKey.EqualityComparer());
foreach (var project in projectToEmployeePairToWorkDays)
{
foreach (var firstEmployee in project.Value)
{
foreach (var secondEmployee in firstEmployee.Value)
{
EmployeeProjectWorkingDaysKey key = new EmployeeProjectWorkingDaysKey()
{
ProjectID = project.Key,
EmployeeID1 = Utilities.Min(firstEmployee.Key, secondEmployee.Key),
EmployeeID2 = Utilities.Max(firstEmployee.Key, secondEmployee.Key)
};
// Lets create the unique pairs
if (!projectToEmployeesWorkingPairs.ContainsKey(key))
{
projectToEmployeesWorkingPairs.Add(key, secondEmployee.Value);
}
}
}
}
List <EmployeesWorkingPair> employeesWorkingPairs = new List <EmployeesWorkingPair>(projectToEmployeesWorkingPairs.Count);
foreach (var item in projectToEmployeesWorkingPairs)
{
employeesWorkingPairs.Add(new EmployeesWorkingPair()
{
ProjectID = item.Key.ProjectID,
FirstEmployeeID = item.Key.EmployeeID1,
SecondEmployeeID = item.Key.EmployeeID2,
DaysWorked = item.Value
});
}
return(employeesWorkingPairs);
}
