public override async void OnCreate()
{
if (!Jobs.Any())
{
await GetMostRecentJobs();
}
}
public Scheduler(string fileName, ITwitterContextList contextList, ITwitterConfiguration twitterConfig)
{
FileName = fileName;
JobProcessors.Add(SchedulerJobType.DeleteStatus, new DeleteStatusProcessor(contextList));
JobProcessors.Add(SchedulerJobType.CreateStatus, new CreateStatusProcessor(contextList, twitterConfig));
if (File.Exists(FileName))
{
var json = File.ReadAllText(FileName);
try
{
Jobs.AddRange(JsonConvert.DeserializeObject <List <SchedulerJob> >(json));
}
catch (Exception ex)
{
LogTo.WarnException("Failed to load joblist from file", ex);
}
}
JobIdCounter = Jobs.Any()
? Jobs.Max(j => j.JobId) + 1
: 0;
SleepTime = 1000;
}
public IEnumerable <Event> PlanMaintenanceJob(PlanMaintenanceJob command)
{
// check business rules
// maintenance jobs may not span multiple days
if (command.StartTime.Date != command.EndTime.Date)
{
throw new BusinessRuleViolationException("Start-time and end-time of a Maintenance Job must be within a 1 day.");
}
// no more than 3 jobs can be planned at the same time (limited resources)
if (Jobs.Count(j => (j.StartTime >= command.StartTime && j.StartTime <= command.EndTime) ||
(j.EndTime >= command.StartTime && j.EndTime <= command.EndTime)) >= MAX_PARALLEL_JOBS)
{
throw new BusinessRuleViolationException($"Maintenancejob overlaps with more than {MAX_PARALLEL_JOBS} other jobs.");
}
// only 1 maintenance job can be executed on a vehicle during a certain time-slot
if (Jobs.Any(j => j.Vehicle.Matricula == command.VehicleInfo.Matricula &&
(j.StartTime >= command.StartTime && j.StartTime <= command.EndTime ||
j.EndTime >= command.StartTime && j.EndTime <= command.EndTime)))
{
throw new BusinessRuleViolationException($"Only 1 maintenance job can be executed on a vehicle during a certain time-slot.");
}
// handle event
MaintenanceJobPlanned e = Mapper.Map <MaintenanceJobPlanned>(command);
return(HandleEvent(e));
}
public void Save(IJob obj)
{
var job = (Job)obj;
if (!Jobs.Any(j => job.JobId == j.JobId))
{
Jobs.Add(job);
}
}
/// <summary>
///
/// </summary>
/// <param name="jobId"></param>
public void AddJob(int jobId)
{
// already exists
if (Jobs.Any(job => job.JobId == jobId))
{
return;
}
// will implicitly added to the list of job because it has the same reference
CharacterJobRepository.Instance.Create(m_character.Id, jobId);
}
public string SetStandartData()
{
if (!Jobs.Any())
{
try
{
Jobs.AddRange(new List <Job>()
{
new Job()
{
Jobtype = "Менеджер"
},
new Job()
{
Jobtype = "Повар"
},
new Job()
{
Jobtype = "Доставка"
},
new Job()
{
Jobtype = "Официант"
}
});
if (!EatTypes.Any())
{
EatTypes.AddRange(new List <EatType>()
{
new EatType()
{
EatTypeName = "Завтрак"
},
new EatType()
{
EatTypeName = "Обед"
},
new EatType()
{
EatTypeName = "Ужин"
},
});
}
SaveChanges();
return(0.ToString());
}
catch (Exception e)
{
return(e.ToString());
}
}
return("1");
}
/// <summary>
/// Get job name that doesn't overlap with an existing one
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private string GetJobName(string name)
{
string newName = name;
int counter = 1;
while (Jobs.Any(x => x.Name == newName))
{
newName = name + counter;
counter++;
}
return(newName);
}
public void AddNewJob(int id)
{
if (Jobs.Any(x => x.ID == id))
{
return;
}
Jobs.Add(new Jobs.Job(id, 1, 0));
SendJobs();
SendJobsXP();
SendJobOptions();
}
public void ScheduleRecurringResend(int miliseconds, Guid messageId, Action <Guid> func)
{
//return if the task exists
if (Jobs.Any(x => x.Item2 == messageId))
{
return;
}
var cts = new CancellationTokenSource();
var token = cts.Token;
Jobs.Add(new Tuple <CancellationTokenSource, Guid>(cts, messageId));
Task.Delay(miliseconds).ContinueWith(t => { CreateDelayedRecurringResend(miliseconds, messageId, func, token); }, token);
}
public void CancelTask(Guid messageId, string clientId, int seqNo)
{
if (JobsWithClientId.ContainsKey(clientId + seqNo))
{
JobsWithClientId[clientId + seqNo].Cancel();
JobsWithClientId.Remove(clientId + seqNo);
}
else if (Jobs.Any(x => x.Item2 == messageId))
{
var job = Jobs.Find(x => x.Item2 == messageId);
job.Item1.Cancel();
Jobs.Remove(job);
}
}
private async Task ExecuteSearchCommand()
{
IsBusy = true;
var jobsList = await SearchJob();
if (Jobs.Any())
{
Jobs.Clear();
}
if (jobsList != null)
{
Jobs.AddRange(jobsList);
}
IsBusy = false;
}
public void Remove(IJob obj)
{
var job = (Job)obj;
foreach (var note in job.Notes.ToList())
{
Remove(note);
}
foreach (var task in job.Tasks.ToList())
{
Remove(task);
}
if (Jobs.Any(j => job.JobId == j.JobId))
{
Jobs.Remove(job);
}
}
public void CreateJob(Job protoJob, Tile tile, float amountDone = 0)
{
if (protoJob?.CanCreate == null || tile == null || world == null || Jobs == null ||
world?.Resources < protoJob.Cost && amountDone == 0 ||
Jobs.Any(j => tile == j.Tile) || !protoJob.CanCreate(tile))
{
return;
}
if (amountDone == 0)
{
world.Resources -= protoJob.Cost;
}
var jobToCreate = new Job(protoJob)
{
Tile = tile, AmountDone = amountDone
};
AvailableJobs?.Add(jobToCreate);
world.OnChange();
}
public void Can_prepare_mock_data()
{
Assert.That(StartLocation != null);
Assert.That(Locations != null && Locations.Any(), "Mock Locations not ready");
Assert.That(Drivers != null && Drivers.Any(), "Mock Drivers not ready");
Assert.That(Jobs != null && Jobs.Any(), "Mock Jobs not ready");
var hazmatJobs = Jobs.Where(p => p.IsHazmat);
var shortHaulJobs = Jobs.Where(p => p.IsShortHaul);
var longHaulJobs = Jobs.Where(p => p.IsLongHaul);
var type1Jobs = Jobs.Where(p => p.OrderType == 1);
var type2Jobs = Jobs.Where(p => p.OrderType == 2);
var type3Jobs = Jobs.Where(p => p.OrderType == 3);
var p1Jobs = Jobs.Where(p => p.Priority == 1);
var p2Jobs = Jobs.Where(p => p.Priority == 2);
var p3Jobs = Jobs.Where(p => p.Priority == 3);
Assert.That(hazmatJobs != null && hazmatJobs.Any());
Assert.That(shortHaulJobs != null && shortHaulJobs.Any());
Assert.That(longHaulJobs != null && longHaulJobs.Any());
Assert.That(type1Jobs != null && type1Jobs.Any());
Assert.That(type2Jobs != null && type2Jobs.Any());
Assert.That(type3Jobs != null && type3Jobs.Any());
Assert.That(p1Jobs != null && p1Jobs.Any());
Assert.That(p2Jobs != null && p2Jobs.Any());
Assert.That(p3Jobs != null && p3Jobs.Any());
var hazmatDrivers = Drivers.Where(p => p.IsHazmatEligible);
var shortHaulDrivers = Drivers.Where(p => p.IsShortHaulEligible);
var longHaulDrivers = Drivers.Where(p => p.IsLongHaulEligible);
var type1Drivers = Drivers.Where(p => p.OrderType == 1);
var type2Drivers = Drivers.Where(p => p.OrderType == 2);
var type3Drivers = Drivers.Where(p => p.OrderType == 3);
Assert.That(hazmatDrivers != null && hazmatDrivers.Any());
Assert.That(shortHaulDrivers != null && shortHaulDrivers.Any());
Assert.That(longHaulDrivers != null && longHaulDrivers.Any());
Assert.That(type1Drivers != null && type1Drivers.Any());
Assert.That(type2Drivers != null && type2Drivers.Any());
Assert.That(type3Drivers != null && type3Drivers.Any());
}
private void JobStopping(ThenExecute thenExecute)
{
if (this.waitJobStopped == null || this.waitJobStopped.Status != TaskStatus.Running)
{
this.waitJobStopped = new Task(() =>
{
while (Jobs.Any((job) => job.IsExecuting))
{
Thread.Sleep(1000);
}
});
this.waitJobStopped.ContinueWith((wAitjobStopped) =>
{
this.InvokeIfNecessary(() =>
{
switch (thenExecute)
{
case ThenExecute.Stop:
{
Log.Info("作業停止");
this.SwitchStoppedState();
}
break;
case ThenExecute.Exit:
{
Application.Exit();
}
break;
}
});
});
this.waitJobStopped.Start();
}
}
public bool HasJob(int id)
{
return(Jobs.Any(x => x.ID == id));
}
/// <summary>
///
/// </summary>
/// <param name="jobId"></param>
/// <returns></returns>
public bool HasJob(int jobId)
{
return(Jobs.Any(job => job.JobId == jobId));
}
/// <summary>
///
/// </summary>
/// <param name="skillId"></param>
/// <returns></returns>
public bool HasSkill(int skillId)
{
return(Jobs.Any(job => job.HasSkill(m_character, skillId)));
}
