private void button2_Click(object sender, EventArgs e)
{
const string jobName = "JobsLibraryTest.JobWorker";
var jobData = new JobWorkerParameters
{
FileName = "testJMService.txt"
};
var context = new InstanceContext(new JobManagerServiceCallback());
var client = new JobManagerServiceClient(context);
var jobDto = new JobDto
{
ClassName = jobName,
Data = new TransferData(jobData),
Triggers = new List <TriggerDto>
{
new TriggerDto
{
Cron = "0 0/1 * * * ?"
}
}
};
var jobId = client.ScheduleJob(jobDto);
}
private void button1_Click(object sender, EventArgs e)
{
const string jobName = "JobsLibraryTest.JobWorker";
var jobData = new JobWorkerParameters
{
FileName = "testJMService.txt"
};
var context = new InstanceContext(new JobManagerServiceCallback());
var client = new JobManagerServiceClient(context);
var jobDto = new JobDto
{
ClassName = jobName,
Data = new TransferData(jobData)
};
var t = new Task(() => client.SubscribeClientContext());
t.ContinueWith(s => { var workerDto = client.RunJob(jobDto); });
t.Start();
//var workerDto = client.RunJob(jobDto);
//WorkersKeeper.Worker1 = workerDto.Id;
//Thread.Sleep(2000);
//client.Signal(workerDto.Id, new TransferData("stop"));
}
public void SetParameter_UpdatesValue_WhenParameterWithTheGivenName_AlreadyExists()
{
var jobDto = new JobDto
{
Id = ObjectId.GenerateNewId(),
InvocationData = "",
Arguments = "",
CreatedAt = DateTime.UtcNow
};
_dbContext.JobGraph.InsertOne(jobDto);
var jobId = jobDto.Id;
_connection.SetJobParameter(jobId.ToString(), "Name", "Value");
_connection.SetJobParameter(jobId.ToString(), "Name", "AnotherValue");
var parameters = _dbContext
.JobGraph.OfType <JobDto>()
.Find(j => j.Id == jobId)
.Project(j => j.Parameters)
.FirstOrDefault();
Assert.NotNull(parameters);
Assert.Equal("AnotherValue", parameters["Name"]);
}
public async Task <IActionResult> UpdateEmployeeJobAsync(
[FromRoute, SwaggerParameter("Id of the employee to find job by", Required = true)] Guid employeeId,
[FromBody, SwaggerParameter("Id of the job to assign", Required = true)] JobDto jobToChange) // change to just guid?
{
if (!await _jobRepository.EntityExists <Employee>(e => e.Id == employeeId))
{
return(NotFound());
}
if (!await _jobRepository.EntityExists <Job>(j => j.Id == jobToChange.Id))
{
return(NotFound());
}
var foundEmployee = _jobRepository.GetFirstByConditionAsync(e => e.Id == employeeId);
var mappedEmployee = Mapper.Map <Employee>(foundEmployee);
mappedEmployee.JobId = jobToChange.Id;
_employeeRepository.Update(mappedEmployee);
if (!await _employeeRepository.SaveChangesAsync())
{
throw new Exception("Failed to update employee job");
}
return(NoContent());
}
/// <summary>
/// Выполнить команду Обновить данные о работе сотрудника
/// </summary>
/// <param name="employeeId">Идентификатор сотрудника</param>
/// <param name="jobDto">Данные о работе сотрудника</param>
public async Task UpdateEmployeeJobAsync(Guid employeeId, JobDto jobDto)
{
// TODO: проверить идентификатор, что не Guid.Empty
await _employeeRepository.UpdateJobAsync(employeeId, jobDto);
await _domainContext.SaveChangesAsync();
}
private static JobQueueDto CreateJobQueueDto(HangfireDbContext connection, string queue, bool isFetched)
{
var job = new JobDto
{
CreatedAt = DateTime.UtcNow,
StateHistory = new[] { new StateDto() }
};
connection.Job.InsertOne(job);
var jobQueue = new JobQueueDto
{
Queue = queue,
JobId = job.Id
};
if (isFetched)
{
jobQueue.FetchedAt = DateTime.UtcNow.AddDays(-1);
}
connection.JobQueue.InsertOne(jobQueue);
return(jobQueue);
}
public override string CreateExpiredJob(Job job, IDictionary <string, string> parameters, DateTime createdAt,
TimeSpan expireIn)
{
Guard.ArgumentNotNull(job, "job");
Guard.ArgumentNotNull(parameters, "parameters");
var invocationData = InvocationData.Serialize(job);
var jobData = new JobDto
{
Id = Guid.NewGuid().ToString(),
InvocationData = JobHelper.ToJson(invocationData),
Arguments = invocationData.Arguments,
CreatedAt = createdAt,
ExpireAt = createdAt.Add(expireIn)
};
_data.Create(jobData);
if (parameters.Count > 0)
{
var list = parameters.Select(kvp => new JobParameterDto
{
Id = AutoIncrementIdGenerator.GenerateId(typeof(JobParameterDto)),
JobId = jobData.Id,
Name = kvp.Key,
Value = kvp.Value
}).ToList();
jobData.Parameters = list;
}
return(jobData.Id);
}
public async Task UpdateJob()
{
// Initialize the database
await _jobRepository.CreateOrUpdateAsync(_job);
await _jobRepository.SaveChangesAsync();
var databaseSizeBeforeUpdate = await _jobRepository.CountAsync();
// Update the job
var updatedJob = await _jobRepository.QueryHelper().GetOneAsync(it => it.Id == _job.Id);
// Disconnect from session so that the updates on updatedJob are not directly saved in db
//TODO detach
updatedJob.JobTitle = UpdatedJobTitle;
updatedJob.MinSalary = UpdatedMinSalary;
updatedJob.MaxSalary = UpdatedMaxSalary;
JobDto updatedJobDto = _mapper.Map <JobDto>(_job);
var response = await _client.PutAsync("/api/jobs", TestUtil.ToJsonContent(updatedJobDto));
response.StatusCode.Should().Be(HttpStatusCode.OK);
// Validate the Job in the database
var jobList = await _jobRepository.GetAllAsync();
jobList.Count().Should().Be(databaseSizeBeforeUpdate);
var testJob = jobList.Last();
testJob.JobTitle.Should().Be(UpdatedJobTitle);
testJob.MinSalary.Should().Be(UpdatedMinSalary);
testJob.MaxSalary.Should().Be(UpdatedMaxSalary);
}
public void GetJobData_ReturnsResult_WhenJobExists()
{
var job = Job.FromExpression(() => HangfireTestJobs.SampleMethod("wrong"));
var jobDto = new JobDto
{
Id = ObjectId.GenerateNewId(),
InvocationData = JobHelper.ToJson(InvocationData.Serialize(job)),
Arguments = "[\"\\\"Arguments\\\"\"]",
StateName = SucceededState.StateName,
CreatedAt = DateTime.UtcNow
};
_dbContext.JobGraph.InsertOne(jobDto);
var result = _connection.GetJobData(jobDto.Id.ToString());
Assert.NotNull(result);
Assert.NotNull(result.Job);
Assert.Equal(SucceededState.StateName, result.State);
Assert.Equal("Arguments", result.Job.Args[0]);
Assert.Null(result.LoadException);
Assert.True(DateTime.UtcNow.AddMinutes(-1) < result.CreatedAt);
Assert.True(result.CreatedAt < DateTime.UtcNow.AddMinutes(1));
}
/// <summary>
/// Обновить данные по сотруднику
/// </summary>
/// <param name="employeeId">Идентификатор иностранца</param>
/// <param name="jobDto">Данные по сотруднику</param>
public async Task UpdateJobAsync(Guid employeeId, JobDto jobDto)
{
var updatedEmployee = await GetAsync(employeeId);
updatedEmployee.SetWorkPlace(jobDto.WorkPlace);
updatedEmployee.SetPosition(jobDto.Position);
}
private void JobFinished(JobDto obj)
{
Task.Run(async() =>
{
await DownloadNewJobs();
});
}
// GET: Job/Details/5
/// Reference:Varsity Project by Christine Bittle - Team Data Controllers
public ActionResult Details(int id)
{
//ShowJob, model view used
ShowJob ModelView = new ShowJob();
string url = "JobData/FindJob/" + id;
HttpResponseMessage response = client.GetAsync(url).Result;
//Response 200 code if it is ok
if (response.IsSuccessStatusCode)
{
JobDto SelectedJob = response.Content.ReadAsAsync <JobDto>().Result;
ModelView.Job = SelectedJob;
// Get Applications by Job Id
url = "JobData/GetApplicationsForJob/" + id;
response = client.GetAsync(url).Result;
IEnumerable <ApplicationDto> SelectedApplications = response.Content.ReadAsAsync <IEnumerable <ApplicationDto> >().Result;
ModelView.Applications = SelectedApplications;
return(View(ModelView));
}
else
{
return(RedirectToAction("Error"));
}
}
public void GetJobData_ReturnsResult_WhenJobExists()
{
var job = Job.FromExpression(() => HangfireTestJobs.SampleMethod("wrong"));
var jobDto = new JobDto
{
Id = Guid.NewGuid().ToString(),
InvocationData = SerializationHelper.Serialize(InvocationData.SerializeJob(job)),
Arguments = "[\"\\\"Arguments\\\"\"]",
StateName = SucceededState.StateName,
Created = DateTime.UtcNow
};
var realm = _storage.GetRealm();
realm.Write(() => { realm.Add(jobDto); });
var result = _connection.GetJobData(jobDto.Id.ToString());
Assert.NotNull(result);
Assert.NotNull(result.Job);
Assert.AreEqual(SucceededState.StateName, result.State);
Assert.AreEqual("Arguments", result.Job.Args[0]);
Assert.Null(result.LoadException);
Assert.True(DateTime.UtcNow.AddMinutes(-1) < result.CreatedAt);
Assert.True(result.CreatedAt < DateTime.UtcNow.AddMinutes(1));
}
public void ExpireJob_SetsJobExpirationData()
{
UseConnection(database =>
{
JobDto job = new JobDto
{
Id = ObjectId.GenerateNewId(1),
InvocationData = "",
Arguments = "",
CreatedAt = DateTime.UtcNow
};
database.Job.InsertOne(job);
JobDto anotherJob = new JobDto
{
Id = ObjectId.GenerateNewId(2),
InvocationData = "",
Arguments = "",
CreatedAt = DateTime.UtcNow
};
database.Job.InsertOne(anotherJob);
var jobId = job.Id.ToString();
var anotherJobId = anotherJob.Id.ToString();
Commit(database, x => x.ExpireJob(jobId.ToString(), TimeSpan.FromDays(1)));
var testJob = GetTestJob(database, jobId);
Assert.True(DateTime.UtcNow.AddMinutes(-1) < testJob.ExpireAt && testJob.ExpireAt <= DateTime.UtcNow.AddDays(1));
var anotherTestJob = GetTestJob(database, anotherJobId);
Assert.Null(anotherTestJob.ExpireAt);
});
}
public IHttpActionResult GetAllApplications()
{
//List of the Application from the database
List <Application> Applications = db.Applications.ToList();
//Using the ShowApplication View Model
List <ShowApplication> ApplicationDtos = new List <ShowApplication> {
};
foreach (var Application in Applications)
{
ShowApplication application = new ShowApplication();
//Get the user from the OurUsers Database and link them with the application
ApplicationUser ApplicationUser = db.Users
.Where(c => c.Applications
.Any(a => a.ApplicationId == Application.ApplicationId))
.FirstOrDefault();
ApplicationUserDto firstUser = new ApplicationUserDto
{
Id = ApplicationUser.Id,
FirstName = ApplicationUser.FirstName,
LastName = ApplicationUser.LastName,
Email = ApplicationUser.Email,
PhoneNumber = ApplicationUser.PhoneNumber,
Address = ApplicationUser.Address,
};
//Get the Job from Jobs Table and associate them with the application
Job Job = db.Jobs
.Where(j => j.Applications
.Any(a => a.ApplicationId == Application.ApplicationId))
.FirstOrDefault();
JobDto job = new JobDto
{
Position = Job.Position,
Category = Job.Category,
Type = Job.Type,
Requirement = Job.Requirement,
Deadline = Job.Deadline
};
ApplicationDto NewApplication = new ApplicationDto
{
ApplicationId = Application.ApplicationId,
Comment = Application.Comment,
JobId = Application.JobId,
Id = Application.Id
};
application.Application = NewApplication;
application.Job = job;
application.ApplicationUser = firstUser;
ApplicationDtos.Add(application);
}
return(Ok(ApplicationDtos));
}
public void AddJobState_JustAddsANewRecordInATable()
{
UseConnection(database =>
{
JobDto job = new JobDto
{
Id = ObjectId.GenerateNewId(1),
InvocationData = "",
Arguments = "",
CreatedAt = DateTime.UtcNow
};
database.Job.InsertOne(job);
var jobId = job.Id.ToString();
var serializedData = new Dictionary <string, string> {
{ "Name", "Value" }
};
var state = new Mock <IState>();
state.Setup(x => x.Name).Returns("State");
state.Setup(x => x.Reason).Returns("Reason");
state.Setup(x => x.SerializeData()).Returns(serializedData);
Commit(database, x => x.AddJobState(jobId, state.Object));
var testJob = GetTestJob(database, jobId);
Assert.Null(testJob.StateName);
var jobWithStates = database.Job.Find(new BsonDocument()).ToList().Single();
var jobState = jobWithStates.StateHistory.Last();
Assert.Equal("State", jobState.Name);
Assert.Equal("Reason", jobState.Reason);
Assert.Equal(serializedData, jobState.Data);
});
}
public void Can_add_load_enable_disable_job()
{
var client = new RestJobApi(new AutoResolveScyllaRestClientSettings());
var job = new JobDto()
{
Name = "TestFileJob",
Description = "blalba",
ConcurrentLimit = 12,
Enabled = false,
TriggerCronSyntax = "* */2 * * * ?",
Configuration = @"<FileConnectorJobConfiguration><RootDirectory>D:\\Documents</RootDirectory><CrawlRecursively>true</CrawlRecursively><BatchSizeLimit>100</BatchSizeLimit></FileConnectorJobConfiguration>"
};
client.EditJob(job);
var fetchedJob = client.GetJobs(job.Name).FirstOrDefault();
//fetchedJob.ShouldBeEquivalentTo(job, o => o.Excluding(x => x.LastUpdated).Excluding(x => x.Configuration));
client.EnableJob(job.Name);
fetchedJob = client.GetJobs(job.Name).FirstOrDefault();
fetchedJob.Enabled.Should().BeTrue();
client.DisableJob(job.Name);
fetchedJob = client.GetJobs(job.Name).FirstOrDefault();
fetchedJob.Enabled.Should().BeFalse();
}
public void Execute(JobDto request)
{
_validator.ValidateAndThrow(request); //ValidationException
var job = new Jobs
{
CustomerId = request.CustomerId,
Deposit = request.Deposit,
JobStatusId = 1,
JobTypeId = request.JobTypeId,
MinimumHours = request.MinimumHours,
MoveDate = request.MoveDate,
NumberOfMovers = request.NumberOfMovers,
NumberOfTrucks = request.NumberOfTrucks,
CreatedByUserId = request.CreatedByUserId,
PricePerHour = request.PricePerHour,
Pickup = false,
Delivery = false,
Id = request.Id
};
_context.Entry(job).State = job.Id > 0 ? EntityState.Modified : EntityState.Added;
_context.SaveChanges();
}
public override string CreateExpiredJob(Job job, IDictionary <string, string> parameters, DateTime createdAt, TimeSpan expireIn)
{
if (job == null)
{
throw new ArgumentNullException(nameof(job));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
var invocationData = InvocationData.Serialize(job);
var jobDto = new JobDto
{
InvocationData = JobHelper.ToJson(invocationData),
Arguments = invocationData.Arguments,
Parameters = parameters.ToDictionary(kv => kv.Key, kv => kv.Value),
CreatedAt = createdAt,
ExpireAt = createdAt.Add(expireIn)
};
Database.Job.InsertOne(jobDto);
var jobId = jobDto.Id.ToString();
return(jobId);
}
public override StateData GetStateData(string jobId)
{
if (jobId == null)
{
throw new ArgumentNullException("jobId");
}
JobDto job = AsyncHelper.RunSync(() => _database.Job.Find(Builders <JobDto> .Filter.Eq(_ => _.Id, int.Parse(jobId))).FirstOrDefaultAsync());
if (job == null)
{
return(null);
}
StateDto state = AsyncHelper.RunSync(() => _database.State.Find(Builders <StateDto> .Filter.Eq(_ => _.Id, job.StateId)).FirstOrDefaultAsync());
if (state == null)
{
return(null);
}
return(new StateData
{
Name = state.Name,
Reason = state.Reason,
Data = JobHelper.FromJson <Dictionary <string, string> >(state.Data)
});
}
public Boolean addSkillToJob(String JobId, String SkillId)
{
JobManager mgr = new JobManager();
JobDto obj = new JobDto();
obj.JobId = new Guid(JobId);
return mgr.addSkillToJob(obj, SkillId);
}
public void Dequeue_ShouldFetchATimedOutJobs_FromTheSpecifiedQueue()
{
// Arrange
UseConnection(connection =>
{
var job = new JobDto
{
InvocationData = "",
Arguments = "",
CreatedAt = connection.GetServerTimeUtc()
};
connection.Job.InsertOne(job);
var jobQueue = new JobQueueDto
{
JobId = job.Id,
Queue = "default",
FetchedAt = connection.GetServerTimeUtc().AddDays(-1)
};
connection.JobQueue.InsertOne(jobQueue);
var queue = CreateJobQueue(connection);
// Act
var payload = queue.Dequeue(DefaultQueues, CreateTimingOutCancellationToken());
// Assert
Assert.NotEmpty(payload.JobId);
});
}
public async Task <string> ValidateUpdateJobPatchAsync(int jobId, JsonPatchDocument patch)
{
_logger.LogInformation($"Validating incoming patch for JobID: {jobId} :: patchJson = {patch}");
var job = await _dbContext.Job.FindAsync(jobId);
var validationMessage = string.Empty;
var jobdto = new JobDto();
if (job.AccrualStatus == AccrualStatus.POSTED)
{
if (patch.Operations.Any(x => x.path.ToLower().Contains(nameof(jobdto.BranchName).ToLower())))
{
validationMessage = "Job has accrued a service, Branch Name cannot be updated";
}
if (patch.Operations.Any(x => x.path.ToLower().Contains(nameof(jobdto.RevenueType).ToLower())))
{
validationMessage = "Job has accrued a service, RevenueType cannot be updated";
}
var jobStatusOperation = patch.Operations.FirstOrDefault(x => x.path.ToLower().Contains(nameof(jobdto.Status).ToLower()));
if (jobStatusOperation != null && ((string)jobStatusOperation.value).ToUpper() == JobStatusIdentifier.CANCELLED)
{
validationMessage = "Job has accrued a service, Job cannot be cancelled";
}
}
return(validationMessage);
}
public void Dequeue_ShouldLeaveJobInTheQueue_ButSetItsFetchedAtValue()
{
// Arrange
UseConnection(connection =>
{
var job = new JobDto
{
InvocationData = "",
Arguments = "",
CreatedAt = connection.GetServerTimeUtc()
};
connection.Job.InsertOne(job);
var jobQueue = new JobQueueDto
{
JobId = job.Id,
Queue = "default"
};
connection.JobQueue.InsertOne(jobQueue);
var queue = CreateJobQueue(connection);
// Act
var payload = queue.Dequeue(DefaultQueues, CreateTimingOutCancellationToken());
// Assert
Assert.NotNull(payload);
var fetchedAt = connection.JobQueue.Find(Builders <JobQueueDto> .Filter.Eq(_ => _.JobId, int.Parse(payload.JobId))).FirstOrDefault().FetchedAt;
Assert.NotNull(fetchedAt);
Assert.True(fetchedAt > DateTime.UtcNow.AddMinutes(-1));
});
}
public void Dequeue_ShouldFetchATimedOutJobs_FromTheSpecifiedQueue()
{
// Arrange
var job = new JobDto
{
InvocationData = "",
Arguments = "",
CreatedAt = DateTime.UtcNow
};
_hangfireDbContext.JobGraph.InsertOne(job);
var jobQueue = new JobQueueDto
{
JobId = job.Id,
Queue = "default",
FetchedAt = DateTime.UtcNow.AddDays(-1)
};
var options = new MongoStorageOptions
{
InvisibilityTimeout = TimeSpan.FromMinutes(30)
};
_hangfireDbContext.JobGraph.InsertOne(jobQueue);
_jobQueueSemaphoreMock.Setup(m => m.WaitNonBlock("default")).Returns(true);
var queue = new MongoJobFetcher(_hangfireDbContext, options, _jobQueueSemaphoreMock.Object);
// Act
var payload = queue.FetchNextJob(DefaultQueues, CreateTimingOutCancellationToken());
// Assert
Assert.NotEmpty(payload.JobId);
_jobQueueSemaphoreMock.Verify(m => m.WaitNonBlock("default"), Times.Once);
}
public void Dequeue_NoInvisibilityTimeout_WaitsForever()
{
// Arrange
var job = new JobDto
{
InvocationData = "",
Arguments = "",
CreatedAt = DateTime.UtcNow
};
_hangfireDbContext.JobGraph.InsertOne(job);
var jobQueue = new JobQueueDto
{
JobId = job.Id,
Queue = "default",
FetchedAt = DateTime.UtcNow.AddDays(-1)
};
var options = new MongoStorageOptions();
_hangfireDbContext.JobGraph.InsertOne(jobQueue);
_jobQueueSemaphoreMock.Setup(m => m.WaitNonBlock("default")).Returns(true);
var queue = new MongoJobFetcher(_hangfireDbContext, options, _jobQueueSemaphoreMock.Object);
// Act
var exception =
Assert.Throws <OperationCanceledException>(() =>
queue.FetchNextJob(DefaultQueues,
CreateTimingOutCancellationToken(TimeSpan.FromMilliseconds(200))));
// Assert
Assert.NotNull(exception);
_jobQueueSemaphoreMock.Verify(m => m.WaitNonBlock("default"), Times.Never);
}
private static JobQueueDto CreateJobQueueDto(HangfireDbContext connection, string queue, bool isFetched)
{
var state = new StateDto();
AsyncHelper.RunSync(() => connection.State.InsertOneAsync(state));
var job = new JobDto
{
CreatedAt = connection.GetServerTimeUtc(),
StateId = state.Id
};
AsyncHelper.RunSync(() => connection.Job.InsertOneAsync(job));
var jobQueue = new JobQueueDto
{
Queue = queue,
JobId = job.Id
};
if (isFetched)
{
jobQueue.FetchedAt = connection.GetServerTimeUtc().AddDays(-1);
}
AsyncHelper.RunSync(() => connection.JobQueue.InsertOneAsync(jobQueue));
return(jobQueue);
}
public string CreateExpiredJob(Job job, IDictionary <string, string> parameters, DateTime createdAt,
TimeSpan expireIn)
{
if (job == null)
{
throw new ArgumentNullException(nameof(job));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
var invocationData = InvocationData.Serialize(job);
var jobDto = new JobDto
{
Id = ObjectId.GenerateNewId(),
InvocationData = JobHelper.ToJson(invocationData),
Arguments = invocationData.Arguments,
Parameters = parameters.ToDictionary(kv => kv.Key, kv => kv.Value),
CreatedAt = createdAt,
ExpireAt = createdAt.Add(expireIn)
};
var writeModel = new InsertOneModel <BsonDocument>(jobDto.ToBsonDocument());
_writeModels.Add(writeModel);
var jobId = jobDto.Id.ToString();
return(jobId);
}
public void ExpireJob_SetsJobExpirationData()
{
UseConnection(database =>
{
JobDto job = new JobDto
{
Id = 1,
InvocationData = "",
Arguments = "",
CreatedAt = database.GetServerTimeUtc()
};
database.Job.InsertOne(job);
JobDto anotherJob = new JobDto
{
Id = 2,
InvocationData = "",
Arguments = "",
CreatedAt = database.GetServerTimeUtc()
};
database.Job.InsertOne(anotherJob);
var jobId = job.Id;
var anotherJobId = anotherJob.Id;
Commit(database, x => x.ExpireJob(jobId.ToString(), TimeSpan.FromDays(1)));
var testJob = GetTestJob(database, jobId);
Assert.True(database.GetServerTimeUtc().AddMinutes(-1) < testJob.ExpireAt && testJob.ExpireAt <= database.GetServerTimeUtc().AddDays(1));
var anotherTestJob = GetTestJob(database, anotherJobId);
Assert.Null(anotherTestJob.ExpireAt);
});
}
public virtual JobDetailsDto JobDetails(string jobId)
{
JobDto job = _dbContext
.JobGraph
.OfType <JobDto>()
.Find(Builders <JobDto> .Filter.Eq(_ => _.Id, ObjectId.Parse(jobId)))
.FirstOrDefault();
if (job == null)
{
return(null);
}
var history = job.StateHistory.Select(x => new StateHistoryDto
{
StateName = x.Name,
CreatedAt = x.CreatedAt,
Reason = x.Reason,
Data = x.Data
})
.Reverse()
.ToList();
return(new JobDetailsDto
{
CreatedAt = job.CreatedAt,
Job = DeserializeJob(job.InvocationData, job.Arguments),
History = history,
Properties = job.Parameters
});
}
public override string Execute()
{
Console.WriteLine($"Trying to get queue \"{Number}\" in project {Project}...");
var message = "";
var code = "";
if (!int.TryParse(Number, out var id))
{
code = Number;
}
JobDto queue = null;
var project = _projectService.GetProjectByName(Project).Result;
if (project != null)
{
queue = !string.IsNullOrEmpty(code) ? _jobQueueService.GetJobQueue(project.Id, code).Result : _jobQueueService.GetJobQueue(project.Id, id).Result;
if (queue != null)
{
message = queue.ToCliString($"Job Queue {Number}", excludedFields: new string[]
{
"ProjectId",
"JobDefinitionId",
"JobTasksStatus"
});
if (queue.JobTasksStatus?.Count > 0)
{
var sb = new System.Text.StringBuilder();
sb.AppendLine();
sb.AppendLine(" ------------------------------------------------------------------");
sb.AppendLine(" Job Task Status:");
foreach (var taskStatus in queue.JobTasksStatus.OrderBy(t => t.Sequence))
{
sb.AppendLine();
sb.AppendLine($" {taskStatus.Sequence}. Task Name: {taskStatus.TaskName}");
sb.AppendLine($" Status: {taskStatus.Status}");
sb.AppendLine($" Remarks: {taskStatus.Remarks}");
}
sb.AppendLine();
sb.AppendLine(" ------------------------------------------------------------------");
message += sb.ToString();
}
}
}
if (queue == null)
{
message = $"Failed getting queue {Number}. Make sure the project name and queue number are correct.";
}
return(message);
}
public Boolean deleteJob(JobDto obj)
{
try
{
IJobSvc svc = (IJobSvc)this.getService(typeof(IJobSvc).Name);
return svc.deleteJob(obj);
}
catch (ServiceLoadException ex)
{
return false;
}
}
public Boolean removeSkillFromJob(JobDto obj, String SkillId)
{
try
{
IJobSvc svc = (IJobSvc)this.getService(typeof(IJobSvc).Name);
return svc.removeSkillFromJob(obj, SkillId);
}
catch (ServiceLoadException ex)
{
return false;
}
}
public static TestJob BuildTestJobFromDataBase(string idPerson)
{
using (SqlConnection connection = Global.GetSqlConnection())
{
string findPatient = "SELECT TOP(1) * FROM Job WHERE IdJob = (SELECT MAX(IdJob) FROM Job WHERE IdPerson = '" + idPerson + "')";
SqlCommand person = new SqlCommand(findPatient, connection);
using (SqlDataReader jobReader = person.ExecuteReader())
{
while (jobReader.Read())
{
JobDto job = new JobDto();
job.CompanyName = Convert.ToString(jobReader["CompanyName"]);
if (jobReader["DateStart"].ToString() != "")
job.DateStart = Convert.ToDateTime(jobReader["DateStart"]);
else
job.DateStart = null;
if (jobReader["DateEnd"].ToString() != "")
job.DateEnd = Convert.ToDateTime(jobReader["DateEnd"]);
else
job.DateEnd = null;
if (jobReader["Sphere"].ToString() != "")
job.Sphere = Convert.ToString(jobReader["Sphere"]);
else
job.Sphere = null;
if (jobReader["OgrnCode"].ToString() != "")
job.OgrnCode = Convert.ToString(jobReader["OgrnCode"]);
else
job.OgrnCode = null;
if (jobReader["Position"].ToString() != "")
job.Position = Convert.ToString(jobReader["Position"]);
else
job.Position = null;
TestJob j = new TestJob(job);
return j;
}
}
}
return null;
}
public Boolean removeSkillFromJob(String JobId, String SkillId)
{
JobManager mgr = new JobManager();
JobDto obj = new JobDto();
obj.JobId = new Guid(JobId);
return mgr.removeSkillFromJob(obj, SkillId);
}
public TestJob(JobDto j)
{
job = j;
}
public JobDto selectJobById(Guid JobId)
{
JobManager mgr = new JobManager();
JobDto obj = new JobDto();
obj.JobId = JobId;
return mgr.selectJobById(obj);
}
public JobDto selectJobById(JobDto obj)
{
try
{
IJobSvc svc = (IJobSvc)this.getService(typeof(IJobSvc).Name);
return svc.selectJobById(obj);
}
catch (ServiceLoadException ex)
{
return null;
}
}
