void UpdateEngineerUI(EngineerModel engineer)
{
GameObject engineerGameObject = engineerGameObjectMap[engineer.Id];
Text nameText = engineerGameObject.GetComponentInChildren <Text>();
nameText.text = engineer.Name + " Price: " + engineer.CurrentPrice + " Earning: " + engineer.CurrentEarning;
}
public void Add(EngineerModel engineer)
{
var entity = _mapper.Map <Engineer>(engineer);
_context.Engineer.Add(entity);
_context.SaveChanges();
}
public EngineerViewModel()
{
Model = new EngineerModel();
Engineer = Storage.GetInstance().SelectedEngineer;
IsEditing = false;
IsViewing = true;
}
public IActionResult Post([FromBody] string name)
{
var engineer = new EngineerModel {
Name = name
};
_engineerRepository.Add(engineer);
return(new ObjectResult(engineer.Id)
{
StatusCode = StatusCodes.Status201Created
});
}
GameObject GetEngineerGameObjectByEngineer(EngineerModel engineer)
{
int Id = engineer.Id;
if (engineerGameObjectMap.ContainsKey(Id))
{
return(engineerGameObjectMap[Id]);
}
else
{
return(null);
}
}
public void UpgradeEngineerButtonOnClick(EngineerModel engineer)
{
if (money >= engineer.CurrentPrice)
{
money -= engineer.CurrentPrice;
engineer.UpgradeEngineer();
UpdateEngineerUI(engineer);
}
else
{
Debug.LogError("Not enough money to upgrade the engineer!");
}
}
/// <summary>
/// Get Qualified engineer which meet criteria
///
/// </summary>
/// <param name="selectedDate">Current date which will be used for matching engineer</param>
/// <param name="engineerModel">Engineer which will be compared</param>
/// <returns>EngineerModel</returns>
public EngineerModel GetQualifiedEngineerFromRandom(DateTime selectedDate, EngineerModel engineerModel)
{
try
{
ScheduleService scheduleService = new ScheduleService();
if (!scheduleService.IsEngineerAssignedScheduleForConsecativeDays(selectedDate, engineerModel.EngineerId) && scheduleService.GetEngineerAssignedScheduleForTwoWeeks(selectedDate, engineerModel.EngineerId) < 2)
{
return(engineerModel);
}
else
{
return(null);
}
}
catch (Exception ex)
{
}
return(null);
}
public void CreateEngineers()
{
this.engineers = new List <EngineerModel>();
for (int i = 1; i < 16; i++)
{
EngineerModel engineer = new EngineerModel();
engineer.Id = i;
engineer.Name = "Developer " + i;
engineer.CurrentPrice = i;
engineer.CurrentEarning = i;
engineer.Level = i;
engineer.OrderNumber = i - 1;
engineer.RegisterCurrentEarningDidUpdateAction(EngineerEarningDidUpdate);
this.engineers.Add(engineer);
}
//EngineerModel engineer = new EngineerModel();
//engineer.Id = 1;
//engineer.Name = "Developer";
//engineer.CurrentPrice = 1;
//engineer.CurrentEarning = 1;
//engineer.Level = 1;
//engineer.OrderNumber = 0;
//engineer.RegisterCurrentEarningDidUpdateAction(EngineerEarningDidUpdate);
//this.engineers.Add(engineer);
//EngineerModel engineer2 = new EngineerModel();
//engineer2.Id = 2;
//engineer2.Name = "Developer2";
//engineer2.CurrentPrice = 2;
//engineer2.CurrentEarning = 2;
//engineer2.Level = 1;
//engineer2.OrderNumber = 1;
//engineer2.RegisterCurrentEarningDidUpdateAction(EngineerEarningDidUpdate);
//this.engineers.Add(engineer2);
}
public static EngineerModel ConvertfromEntity(Engineer inengineer)
{
EngineerModel engineer = null;
try
{
engineer = new EngineerModel();
engineer.engineerid = inengineer.engineerid;
engineer.firstname = inengineer.firstname;
engineer.lastname = inengineer.lastname;
engineer.username = inengineer.username;
engineer.password = inengineer.password;
engineer.email = inengineer.email;
log.Info("Engineer wurde konvertiert.");
}
catch (Exception exp)
{
log.Error("Engineer konnte nicht konvertiert werden.");
throw new DalException("Engineer konnte nicht konvertiert werden.", exp);
}
return(engineer);
}
/// <summary>
/// Assign Engineer
///
/// </summary>
/// <param name="selectedDate">Date on which engineer selected</param>
/// <returns>int value</returns>
public int AssignEngineer(DateTime selectedDate)
{
try
{
EngineerService engineerService = new EngineerService();
EngineerModel engineerModel = engineerService.GetQualifiedEngineer(selectedDate);
if (engineerModel != null)
{
using (var ctx = new DB_121539_alkeshpatelfEntities())
{
var scheduleItems = ctx.Schedules.Where(s => s.ScheduleDate == selectedDate);
if (scheduleItems.Count() < 2)
{
var period = scheduleItems.Select(s => s.SchedulePeriod).FirstOrDefault();
int engineerPeriod = 1;
if (period == 1)
{
engineerPeriod = 2;
}
Schedule schedule = new Schedule();
schedule.SchedulePeriod = engineerPeriod;
schedule.ScheduleEngineer = engineerModel.EngineerId;
schedule.CreateDate = DateTime.Now;
schedule.UpdateDate = DateTime.Now;
schedule.ScheduleDate = selectedDate;
ctx.Schedules.Add(schedule);
ctx.SaveChanges();
return(schedule.ScheduleId);
}
}
}
}
catch (Exception ex)
{
}
return(0);
}
public static Engineer ConverttoEntity(EngineerModel inengineer)
{
Engineer engineer = null;
try
{
EngineerRepository erepo = new EngineerRepository();
engineer = new Engineer();
engineer.firstname = inengineer.firstname;
engineer.lastname = inengineer.lastname;
engineer.username = inengineer.username;
engineer.password = inengineer.password;
engineer.engineerid = inengineer.engineerid;
engineer.email = inengineer.email;
log.Info("EngineerModel wurde konvertiert.");
}
catch (Exception exp)
{
log.Error("EngineerModel konnte nicht konvertiert werden.");
throw new DalException("EngineerModel konnte nicht konvertiert werden.", exp);
}
return(engineer);
}
/// <summary>
/// Remove the engineer if it is already has enough slots based on total days
/// </summary>
/// <param name="engineers"></param>
/// <param name="totalShifts"></param>
/// <param name="totalDays"></param>
/// <param name="engineer"></param>
private void RemoveEngineerIfExceedsLimit(List <EngineerModel> engineers, List <Shift> totalShifts, double totalDays, EngineerModel engineer)
{
var count = totalShifts.Count(shft => shft.Engineer.Id == engineer.Id);
if (count == AllowMaxShiftPerEngineer(totalDays))
{
engineers.Remove(engineer);
}
}
/// <summary>
/// Generate shifts based on startDate and endDate
/// </summary>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <returns>list of schedules with shifts</returns>
public List <Schedule> GenerateShifts(DateTime startDate, DateTime endDate)
{
//to have only dates and ignore time
startDate = startDate.Date;
endDate = endDate.Date;
//gets the list of engineers
var engineers = this.engineersRepository.GetAll();
//calculate total working days exlcuding weekends
var totalDays = GetWorkingDays(startDate, endDate);
var totalShifts = new List <Shift>();
var totalSchedulers = new List <Schedule>();
var schedule = this.schedulerRepository.GetSchedule(startDate, endDate);
if (schedule != null)
{
totalSchedulers = GetExistingSchedules(schedule);
return(totalSchedulers);
}
//to find out if the engineer has same allocated previous day noon shift
var previousNoonEngineer = new EngineerModel {
Id = 0
};
//allow one shift for a week and calculate based on the week you move on
var maxAllowedCount = 1;
//create schedule for the given dates
var scheduleId = this.schedulerRepository.CreateSchedule(new ScheduleModel {
StartDateTimePeriod = startDate, EndDateTimePeriod = endDate
});
for (DateTime i = startDate; i <= endDate; i = i.AddDays(1))
{
//exclude weekends
if (i.DayOfWeek == DayOfWeek.Sunday || i.DayOfWeek == DayOfWeek.Saturday)
{
continue;
}
//remove if engineers have more than 2 shifts already
if (i != startDate && i.DayOfWeek == DayOfWeek.Monday)
{
maxAllowedCount++;
}
var randNum = new Random();
//choose random EngineerOne
EngineerModel engineerOne = null;
//choose random EngineerOne after checking if he has enough slots for a period
do
{
engineerOne = engineers[randNum.Next(engineers.Count)];
} while (totalShifts.Count(shft => engineerOne != null && shft.Engineer.Id == engineerOne.Id) >= maxAllowedCount);
//choose random EngineerTwo
EngineerModel engineerTwo = null;
//to avoid overflow in case if the random same engineer fall in last two days
var overflowCnt = 0;
//choose random EngineerTwo after checking if he has enough slots for a period and also if EngineerTwo is not previous day noon shifter
do
{
engineerTwo = engineers[randNum.Next(engineers.Count)];
overflowCnt++;
if (overflowCnt > 100)
{
break;
}
} while (engineerTwo != null && (engineerTwo.Id == engineerOne.Id || engineerTwo.Id == previousNoonEngineer.Id || totalShifts.Count(shft => shft.Engineer.Id == engineerTwo.Id) >= maxAllowedCount));
//store the noon shift engineer to compare next day
previousNoonEngineer = engineerTwo;
var morningShift = new Shift {
Date = i, ShiftPeriod = ShiftPeriod.Morning, Engineer = engineerOne
};
var afternoonShift = new Shift {
Date = i, ShiftPeriod = ShiftPeriod.Afternoon, Engineer = engineerTwo
};
totalShifts.Add(morningShift);
totalShifts.Add(afternoonShift);
RemoveEngineerIfExceedsLimit(engineers, totalShifts, totalDays, engineerOne);
RemoveEngineerIfExceedsLimit(engineers, totalShifts, totalDays, engineerTwo);
totalSchedulers.Add(new Schedule {
Date = i, Shifts = new List <Shift> {
morningShift, afternoonShift
}
});
}
//store the shifts for the schedule created above
var allShifts = totalShifts.Select(shift => new ShiftModel {
ScheduleId = scheduleId, EngineerId = shift.Engineer.Id, ShiftPeriod = (int)shift.ShiftPeriod, DateTimePeriod = shift.Date
}).ToList();
this.shiftRepository.CreateShift(allShifts);
//return the schedulers
return(totalSchedulers);
}
/// <summary>
/// Get single qualified engineer which meets all requirement
///
/// </summary>
/// <param name="selectedDate">selected date on which engineer will be added</param>
/// <returns>EngineerModel</returns>
public EngineerModel GetQualifiedEngineer(DateTime selectedDate)
{
try
{
using (var ctx = new DB_121539_alkeshpatelfEntities())
{
ScheduleService scheduleService = new ScheduleService();
List <EngineerModel> items = GetAllEngineers();
var engineerIds = items.Select(s => s.EngineerId).ToList();
//Check for engineer which has not been assigned to schedule twice in last 13 days or future 13 days
DateTime pastMinTwo = FindWorkDay(selectedDate, -9, true);
DateTime futureMinTwo = FindWorkDay(selectedDate, 9, false);
int pastMinTwoTotalRows = ctx.Schedules.Where(c => c.ScheduleDate >= pastMinTwo).Count();
if (pastMinTwoTotalRows >= 14)
{
var lastThirteenDaysCheck = ctx.Schedules.Where(c => c.ScheduleDate >= pastMinTwo).GroupBy(i => i.ScheduleEngineer)
.Where(x => x.Count() > 1)
.Select(val => val.Key);
List <int> notHitIds = new List <int>();
for (var i = 0; i < engineerIds.Count(); i++)
{
bool itemHit = false;
foreach (var item in lastThirteenDaysCheck)
{
if (item.Value == engineerIds[i])
{
itemHit = true;
break;
}
}
if (!itemHit)
{
if (!scheduleService.IsEngineerAssignedScheduleForConsecativeDays(selectedDate, engineerIds[i]))
{
notHitIds.Add(engineerIds[i]);
}
}
}
if (notHitIds.Count > 0)
{
Random rand = new Random();
int r = rand.Next(0, notHitIds.Count - 1);
EngineerModel missingEngineerModel = new EngineerModel();
missingEngineerModel.EngineerId = notHitIds[r];
return(missingEngineerModel);
}
}
int futureMinTwoTotalRows = ctx.Schedules.Where(c => c.ScheduleDate <= futureMinTwo).Count();
if (futureMinTwoTotalRows >= 14)
{
var futureThirteenDaysCheck = ctx.Schedules.Where(c => c.ScheduleDate <= futureMinTwo).GroupBy(i => i.ScheduleEngineer)
.Where(x => x.Count() > 1)
.Select(val => val.Key);
List <int> notHitIds = new List <int>();
for (var i = 0; i < engineerIds.Count(); i++)
{
bool itemHit = false;
foreach (var item in futureThirteenDaysCheck)
{
if (item.Value == engineerIds[i])
{
itemHit = true;
break;
}
}
if (!itemHit)
{
if (!scheduleService.IsEngineerAssignedScheduleForConsecativeDays(selectedDate, engineerIds[i]))
{
notHitIds.Add(engineerIds[i]);
}
}
}
if (notHitIds.Count > 0)
{
Random rand = new Random();
int r = rand.Next(0, notHitIds.Count - 1);
EngineerModel missingEngineerModel = new EngineerModel();
missingEngineerModel.EngineerId = notHitIds[r];
return(missingEngineerModel);
}
}
//Check for engineer which has not been assigned to schedule atleast once in last 11 days or future 11 days
DateTime pastMinOne = FindWorkDay(selectedDate, -7, true);
DateTime futureMinOne = FindWorkDay(selectedDate, 7, false);
int pastMinOneTotalRows = ctx.Schedules.Where(c => c.ScheduleDate >= pastMinOne).Count();
if (pastMinOneTotalRows > 8 && pastMinOneTotalRows < 14)
{
var lastElevenDaysCheck = ctx.Schedules.Where(c => c.ScheduleDate >= pastMinOne).GroupBy(i => i.ScheduleEngineer)
.Where(x => x.Count() > 0)
.Select(val => val.Key);
List <int> notHitIds = new List <int>();
for (var i = 0; i < engineerIds.Count(); i++)
{
bool itemHit = false;
foreach (var item in lastElevenDaysCheck)
{
if (item.Value == engineerIds[i])
{
itemHit = true;
break;
}
}
if (!itemHit)
{
if (!scheduleService.IsEngineerAssignedScheduleForConsecativeDays(selectedDate, engineerIds[i]))
{
notHitIds.Add(engineerIds[i]);
}
}
}
if (notHitIds.Count > 0)
{
Random rand = new Random();
int r = rand.Next(0, notHitIds.Count - 1);
EngineerModel missingEngineerModel = new EngineerModel();
missingEngineerModel.EngineerId = notHitIds[r];
return(missingEngineerModel);
}
}
int futureMinOneTotalRows = ctx.Schedules.Where(c => c.ScheduleDate <= futureMinOne).Count();
if (futureMinOneTotalRows > 8 && futureMinOneTotalRows < 14)
{
var futureElevenDaysCheck = ctx.Schedules.Where(c => c.ScheduleDate <= futureMinOne).GroupBy(i => i.ScheduleEngineer)
.Where(x => x.Count() > 0)
.Select(val => val.Key);
List <int> notHitIds = new List <int>();
for (var i = 0; i < engineerIds.Count(); i++)
{
bool itemHit = false;
foreach (var item in futureElevenDaysCheck)
{
if (item.Value == engineerIds[i])
{
itemHit = true;
break;
}
}
if (!itemHit)
{
if (!scheduleService.IsEngineerAssignedScheduleForConsecativeDays(selectedDate, engineerIds[i]))
{
notHitIds.Add(engineerIds[i]);
}
}
}
if (notHitIds.Count > 0)
{
Random rand = new Random();
int r = rand.Next(0, notHitIds.Count - 1);
EngineerModel missingEngineerModel = new EngineerModel();
missingEngineerModel.EngineerId = notHitIds[r];
return(missingEngineerModel);
}
}
EngineerModel selectedEngineer = null;
Random rnd = new Random();
while (selectedEngineer == null)
{
int r = rnd.Next(0, items.Count - 1);
if (!scheduleService.IsEngineerAssignedScheduleForConsecativeDays(selectedDate, items[r].EngineerId))
{
selectedEngineer = items[r];
}
}
return(selectedEngineer);
}
}
catch (Exception ex)
{
}
return(null);
}
public void Remove(EngineerModel engineer)
{
_engineersAvailable.Remove(engineer);
}
