public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount)
{
var personService = services.Resolve<IPersonService>();
var expectedCompensation = personService.CalculateCompensationValue(person);
if(amount >= expectedCompensation)
{
return null;
}
return OfferResponseReason.OfferValue;
}
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount)
{
var perkService = services.Resolve<IPerkService>();
var applicablePerkCount = company.Perks.Count(cp => cp.Count > 0 && perkService.DoesPerkApplyTo(cp.Perk, person));
var personService = services.Resolve<IPersonService>();
var minimumPerkCount = person.GetPersonalityValue(PersonalityAttributeId.MinimumPerkCount);
if(minimumPerkCount <= applicablePerkCount)
{
return null;
}
return OfferResponseReason.Perks;
}
public PersonDto(Person person)
{
Id = person.Id;
Birthday = person.Birthday;
FirstName = person.FirstName;
Gender = person.Gender;
LastName = person.LastName;
PersonalityId = person.Personality.Id;
RetirementDate = person.RetirementDate;
Skills = person.Skills.Select(s => new SkillDto(s));
WorkHistory = person.WorkHistory.Select(wh => new WorkHistoryDto(wh));
}
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount)
{
var workload = 0m;
if (company.Employees.Any())
{
workload = (decimal)company.Projects.Count / (decimal)company.Employees.Count;
}
var personService = services.Resolve<IPersonService>();
var minWorkload = person.GetPersonalityValue(PersonalityAttributeId.MinimumDesiredEmployeeWorkload);
var maxWorkload = person.GetPersonalityValue(PersonalityAttributeId.MaximumDesiredEmployeeWorkload);
if (workload >= minWorkload &&
workload <= maxWorkload)
{
return null;
}
return OfferResponseReason.EmployeeWorkload;
}
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount)
{
var configurationService = services.Resolve<IConfigurationService>();
var fastCompanyGrowth = configurationService.GetIntValue(ConfigurationKey.FastCompanyGrowthValue, ConfigurationFallbackValue.FastCompanyGrowthValue);
var weight = Math.Min((decimal)company.Prospects.Count / (decimal)fastCompanyGrowth, 1m);
var desiredGrowth = person.GetPersonalityValue(PersonalityAttributeId.DesiredCompanyGrowth);
var importance = person.GetPersonalityValue(PersonalityAttributeId.CompanyGrowthImportance);
var differential = Math.Abs(desiredGrowth - weight) * importance;
var maxDifferential = configurationService.GetDecimalValue(ConfigurationKey.CompanyGrowthMaxDifferential, ConfigurationFallbackValue.CompanyGrowthMaxDifferential);
if (differential <= maxDifferential)
{
return null;
}
return OfferResponseReason.CompanyGrowth;
}
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount)
{
var configurationService = services.Resolve<IConfigurationService>();
var largeCompanySize = configurationService.GetIntValue(ConfigurationKey.LargeCompanySize, ConfigurationFallbackValue.LargeCompanySize);
var weight = Math.Min((decimal)company.Employees.Count / (decimal)largeCompanySize, 1m);
var desiredSize = person.GetPersonalityValue(PersonalityAttributeId.DesiredCompanySize);
var importance = person.GetPersonalityValue(PersonalityAttributeId.CompanySizeImportance);
var differential = Math.Abs(desiredSize - weight) * importance;
var maxDifferential = configurationService.GetDecimalValue(ConfigurationKey.CompanySizeMaxDifferential, ConfigurationFallbackValue.CompanySizeMaxDifferential);
if (differential <= maxDifferential)
{
return null;
}
return OfferResponseReason.CompanySize;
}
public OfferResponseReason? Evaluate(IHub services, Company company, Person person, decimal amount)
{
// Create a flag table of the optional skills this person has
var skills = person.Skills.Where(s => !s.SkillDefinition.IsMandatory)
.ToDictionary(s => s.SkillDefinition, s => false);
foreach(var project in company.Projects)
{
foreach(var requirement in project.Requirements)
{
if(skills.ContainsKey(requirement.SkillDefinition))
{
skills[requirement.SkillDefinition] = true;
}
}
}
var relevance = 1m;
if (skills.Count > 0)
{
relevance = (decimal)skills.Count(s => s.Value) / (decimal)skills.Count;
}
var minRelevance = person.GetPersonalityValue(PersonalityAttributeId.MinimumDesiredRelevance);
var maxRelevance = person.GetPersonalityValue(PersonalityAttributeId.MaximumDesiredRelevance);
if(minRelevance <= relevance &&
relevance <= maxRelevance)
{
return null;
}
return OfferResponseReason.Relevance;
}
public bool IsUnemployed(Person person)
{
throw new NotImplementedException();
}
public bool IsRetired(Person person)
{
return false;
}
public decimal GetPersonalityValue(Person person, PersonalityAttributeId attribute)
{
throw new NotImplementedException();
}
public OfferResponse EvaluateOffer(Company company, Person person, decimal amount)
{
return new OfferResponse(new List<OfferResponseReason>(), 0);
}
public decimal CalculateCompensationValue(Person person)
{
return 100000.0m;
}
public void RecruitPerson(Company company, Person person)
{
throw new NotImplementedException();
}
public OfferResponse MakeOffer(Company company, Person person, decimal value)
{
throw new NotImplementedException();
}
public static Prospect CreateRandomProspect(Person person)
{
var prospectSkills = new List<ProspectSkill>();
foreach (var skill in person.Skills)
{
var prospectSkill = new ProspectSkill
{
SkillDefinition = skill.SkillDefinition
};
prospectSkill.Value.Minimum = 0;
prospectSkill.Value.Maximum = 100000;
prospectSkills.Add(prospectSkill);
}
var output = new Prospect(prospectSkills)
{
Person = person,
Accuracy = 0,
Salary = new Range<decimal>(0, 100000)
};
return output;
}
public static PersonServiceData GeneratePersonServiceData(int numberOfPeople, IEnumerable<Personality> validPersonalities, IEnumerable<SkillDefinition> validSkills = null, IEnumerable<Company> validCompanies = null)
{
var people = new List<Person>();
for (var personIndex = 0; personIndex < numberOfPeople; personIndex++)
{
List<Skill> skills = null;
if (validSkills != null)
{
var remainingSkills = new List<SkillDefinition>(validSkills);
var skillCount = Utilities.GetRandomInt(1, remainingSkills.Count);
skills = new List<Skill>(skillCount);
for (var skillIndex = 0; skillIndex < skillCount; skillIndex++)
{
var skill = new Skill
{
ForgetRate = Utilities.GetRandomDecimal(0, 1),
LearnRate = Utilities.GetRandomDecimal(0, 1),
Value = Utilities.GetRandomDecimal(0, 255),
SkillDefinition = remainingSkills.Random()
};
remainingSkills.Remove(skill.SkillDefinition);
skills.Add(skill);
}
}
else
{
skills = new List<Skill>();
}
var person = new Person(skills)
{
Id = Utilities.InvalidId,
FirstName = Utilities.GetRandomString(16),
LastName = Utilities.GetRandomString(16),
Birthday = Utilities.GetRandomDate().Date,
Gender = Utilities.GetRandomValue(Gender.None),
Personality = validPersonalities.Random()
};
person.RetirementDate = person.Birthday.AddYears(Utilities.GetRandomInt(60, 100)).AddDays(Utilities.GetRandomInt(1, 360));
if (validCompanies != null)
{
var remainingCompanies = new List<Company>(validCompanies);
var rollingDate = new DateTime(Utilities.GetRandomInt(person.Birthday.Year + 10, person.Birthday.Year + 20), Utilities.GetRandomInt(1, 12), Utilities.GetRandomInt(1, 28));
while (remainingCompanies.Any())
{
var workHistory = new WorkHistory
{
Company = remainingCompanies.Random(),
StartDate = rollingDate,
EndDate = rollingDate = rollingDate.AddMonths(Utilities.GetRandomInt(1, 6)),
StartingSalary = Utilities.GetRandomDecimal(10, 100),
EndingSalary = Utilities.GetRandomDecimal(100, 250)
};
remainingCompanies.Remove(workHistory.Company);
person.WorkHistory.Add(workHistory);
}
}
people.Add(person);
}
return new PersonServiceData
{
People = people
};
}
