public static IEnumerable<Employee> FindEmployees(IEnumerable<Employee> employees, EmployeeQuery query)
{
var foundEmployees = new List<Employee>();
foreach (Employee employee in employees)
{
// skills
if (query.RequestedSkills != null && query.RequestedSkills.Length > 0 &&
!query.RequestedSkills.Any(employee.HasSkill))
{
continue;
}
// career level
if (query.RequestedCareerLevels != null && query.RequestedCareerLevels.Length > 0 &&
!query.RequestedCareerLevels.Any(requestedCareerLevel => employee.CareerLevel == requestedCareerLevel))
{
continue;
}
// free time
if (!employee.HasAnyAvailableTime(query.BeginOfWorkPeriod, query.EndOfWorkPeriod))
{
continue;
}
foundEmployees.Add(employee);
}
return foundEmployees;
}
public EmployeeSearchResult[] FindPotentialEmployeesForCustomer(EmployeeQuery query)
{
if (query == null) throw new ArgumentNullException("query");
IEnumerable<Employee> foundEmployees = this.FindEmployees(query);
return foundEmployees
.Select(e => new EmployeeSearchResult
{
Id = e.Id,
Distance = 10.1F,
EmployeeName = String.Format("{0} {1}", e.FirstName, e.LastName),
Skills = e.Skills.ToArray(),
Level = e.CareerLevel
})
.ToArray();
}
public void FindEmployees_NoRequestedSkillsAndCareerlevels_ReturnsAllEmployees()
{
// arrange
IEnumerable<Employee> employees = CreateEmployees();
var query = new EmployeeQuery
{
BeginOfWorkPeriod = new DateTime(2013, 1, 1),
EndOfWorkPeriod = new DateTime(2015, 1, 4),
};
// act
IEnumerable<Employee> result = EmployeeReservationServiceHelper.FindEmployees(employees, query);
// assert
Assert.AreEqual(2, result.Count());
}
public void FindPotentialEmployeesForCustomer_NoRequestedSkillsAndCareerlevels_ReturnsAllEmployees()
{
// arrange
Mock<IRepository> mockedRepository = CreateMockedRepository();
var service = new EmployeeReservationService(mockedRepository.Object);
var query = new EmployeeQuery
{
BeginOfWorkPeriod = new DateTime(2013, 1, 1),
EndOfWorkPeriod = new DateTime(2015, 1, 4),
};
// act
EmployeeSearchResult[] result = service.FindPotentialEmployeesForCustomer(query);
// assert
Assert.AreEqual(2, result.Count());
}
public void FindEmployees_RequestASkillFromOneEmployee_ReturnsOnlyMatchingEmployees()
{
// arrange
IEnumerable<Employee> employees = CreateEmployees();
var query = new EmployeeQuery
{
BeginOfWorkPeriod = new DateTime(2013, 1, 1),
EndOfWorkPeriod = new DateTime(2015, 1, 4),
RequestedSkills = new[] { Skill.SqlServer }
};
// act
IEnumerable<Employee> result = EmployeeReservationServiceHelper.FindEmployees(employees, query);
// assert
Assert.AreEqual(1, result.Count());
}
public EmployeeSearchResult[] FindPotentialEmployeesForCustomer(EmployeeQuery query)
{
var e = new EmployeeSearchResult()
{
Distance = 10.3f,
EmployeeName = "Hans Wurst",
Id = 1,
Level = CareerLevel.SoftwareEngineer,
Skills = new[] { Skill.WCF, Skill.AspDotNet, }
};
var f = new EmployeeSearchResult()
{
Distance = 5.1f,
EmployeeName = "Super Dev",
Id = 1,
Level = CareerLevel.JuniorSoftwareEngineer,
Skills = new[] { Skill.WCF, Skill.CSharp, }
};
return new[] { e, f };
}
private IEnumerable<EmployeeSearchResult> SearchEmployees(SearchParamViewModel searchParamViewModel)
{
var query = new EmployeeQuery
{
BeginOfWorkPeriod = searchParamViewModel.StartDate,
EndOfWorkPeriod = searchParamViewModel.EndDate,
CustomerId = searchParamViewModel.SelectedCustomer,
RequestedCareerLevels = searchParamViewModel.SelectedCareerLevels.Select(i => (CareerLevel)i).ToArray(),
RequestedSkills = searchParamViewModel.SelectedSkills.Select(i => (Skill)i).ToArray()
};
return this.reservationService.FindPotentialEmployeesForCustomer(query);
}
public void FindEmployees_RequestOneCareerlevels_ReturnsOnlyMatchingEmployees()
{
// arrange
IEnumerable<Employee> employees = CreateEmployees();
var query = new EmployeeQuery
{
BeginOfWorkPeriod = new DateTime(2013, 1, 1),
EndOfWorkPeriod = new DateTime(2015, 1, 4),
RequestedCareerLevels = new[] { CareerLevel.JuniorSoftwareEngineer },
};
// act
IEnumerable<Employee> result = EmployeeReservationServiceHelper.FindEmployees(employees, query);
// assert
Assert.AreEqual(1, result.Count());
}
public void FindEmployees_RequestedPeriodContainsOnlyOneEmployee_ReturnsOnlyMatchingEmployees()
{
// arrange
IEnumerable<Employee> employees = CreateEmployees();
var query = new EmployeeQuery
{
BeginOfWorkPeriod = new DateTime(2013, 5, 1),
EndOfWorkPeriod = new DateTime(2013, 6, 1),
};
// act
IEnumerable<Employee> result = EmployeeReservationServiceHelper.FindEmployees(employees, query);
// assert
Assert.AreEqual(1, result.Count());
}
private void RefreshValues()
{
var x = this.CareerLevels.SelectedItems.Count;
var employeeQuery = new EmployeeQuery()
{
CustomerId = this.selectedCustomer.Id,
BeginOfWorkPeriod = this.BeginOfWorkPeriod,
EndOfWorkPeriod = this.EndOfWorkPeriod,
RequestedCareerLevels = this.CareerLevels.SelectedItems.ToArray(),
RequestedSkills = this.Skills.SelectedItems.ToArray()
};
EmployeeSearchResult[] result = this.service.FindPotentialEmployeesForCustomer(employeeQuery);
var filtered = result.Where(empl => this.CareerLevels.SelectedItems.Contains(empl.Level));
this.availableEmployees.ReplaceAllItemsWith(filtered);
}
private IEnumerable<Employee> FindEmployees(EmployeeQuery query)
{
return EmployeeReservationServiceHelper.FindEmployees(this.repository.GetEmployees(), query);
}
