private bool HasProperty(JobCreateModel jobCreateModel,
string key,
string value)
{
return(jobCreateModel.Properties.TryGetValue(key, out string matchValue1) &&
matchValue1 == value);
}
public override async Task Process(Message message)
{
Guard.ArgumentNotNull(message, nameof(message));
JobSummary jobSummary = message.GetPayloadAsInstanceOf <JobSummary>();
if (jobSummary.CompletionStatus == CompletionStatus.Succeeded && jobSummary.JobType == JobConstants.DefinitionNames.CreateInstructGenerateAggregationsAllocationJob)
{
JobCreateModel jobCreateModel = new JobCreateModel
{
JobDefinitionId = JobConstants.DefinitionNames.CreateInstructAllocationJob,
InvokerUserDisplayName = jobSummary.InvokerUserDisplayName,
InvokerUserId = jobSummary.InvokerUserId,
CorrelationId = message.GetCorrelationId(),
SpecificationId = jobSummary.SpecificationId,
Properties = new Dictionary <string, string>
{
{ "specification-id", jobSummary.SpecificationId }
},
Trigger = jobSummary.Trigger
};
Job newJob = await _jobManagement.QueueJob(jobCreateModel);
if (newJob == null)
{
_logger.Error($"Failed to create new job of type: '{JobConstants.DefinitionNames.CreateInstructAllocationJob}'");
throw new Exception($"Failed to create new job of type: '{JobConstants.DefinitionNames.CreateInstructAllocationJob}'");
}
_logger.Information($"Created new job of type: '{JobConstants.DefinitionNames.CreateInstructAllocationJob}' with id: '{newJob.Id}'");
}
}
private static CreateJobValidationModel CreateNewCreateJobValidationModel()
{
JobCreateModel jobCreateModel = new JobCreateModel
{
JobDefinitionId = "job-def-1",
Trigger = new Trigger
{
EntityId = "spec-1"
},
SpecificationId = "spec-1",
MessageBody = "body",
Properties = new Dictionary <string, string>
{
{ "prop-1", "property 1" },
{ "prop-2", "property 2" }
},
InvokerUserId = "authorId",
InvokerUserDisplayName = "authorname"
};
JobDefinition jobDefinition = new JobDefinition
{
Id = "job-def-1",
RequireEntityId = true,
RequireSpecificationId = true,
RequireMessageBody = true,
RequireMessageProperties = new[] { "prop-1", "prop-2" }
};
return(new CreateJobValidationModel
{
JobCreateModel = jobCreateModel,
JobDefinition = jobDefinition
});
}
private async Task <Job> CreateJob(JobCreateModel job)
{
Job newJob = new Job()
{
JobDefinitionId = job.JobDefinitionId,
InvokerUserId = job.InvokerUserId,
InvokerUserDisplayName = job.InvokerUserDisplayName,
ItemCount = job.ItemCount,
SpecificationId = job.SpecificationId,
Trigger = job.Trigger,
ParentJobId = job.ParentJobId,
CorrelationId = job.CorrelationId,
Properties = job.Properties,
MessageBody = job.MessageBody
};
Job newJobResult = null;
try
{
newJobResult = await _jobDefinitionsRepositoryPolicy.ExecuteAsync(() => _jobRepository.CreateJob(newJob));
}
catch (Exception ex)
{
_logger.Error(ex, $"Failed to save new job with definition id {job.JobDefinitionId}");
}
return(newJobResult);
}
public async Task <ActionResult> Create(JobCreateModel model)
{
Job job = new Job()
{
CreatedDate = DateTime.UtcNow,
CreatedByEmployeeId = model.CreatedByEmployeeId,
DeadLine = model.DeadLine,
DepartmentId = model.DepartmentId,
JobStatus = JobStatus.Pending,
VehicleId = model.VehicleId,
};
job.PurchasedServices = model.PurchasedServices.Select(ps => new JobService()
{
Name = ps.Name,
Price = ps.Price,
ServiceId = ps.ServiceId
}).ToList();
this.dbContext.Add(job);
await this.dbContext.SaveChangesAsync();
return(Created(nameof(Create), job.Id));
}
public async Task <ApiResponse <JobCreateResult> > TryCreateJob(JobCreateModel jobCreateModel)
{
Guard.ArgumentNotNull(jobCreateModel, nameof(jobCreateModel));
return(await PostAsync <JobCreateResult, JobCreateModel>("jobs/try-create-job",
jobCreateModel));
}
public async Task <ActionResult> Create(JobCreateModel model)
{
var services = await this.garageService.Services(model.DepartmentId);
return(Ok());
}
public void GivenTheFollowingJobIsRequestedToBeQueuedForTheCurrentSpecification(Table table)
{
JobCreateModel job = table.CreateInstance <JobCreateModel>();
job.SpecificationId = _currentSpecificationStepContext.SpecificationId;
_jobStepContext.JobToCreate = job;
}
public IActionResult Post(JobCreateModel jobCreateModel)
{
var check = _jobLogic.CreateNewJob(jobCreateModel);
if(!check)
{
return BadRequest("Create failed");
}
return Ok("Created");
}
private async Task <JobCreateResult> TryCreateNewJob(JobCreateModel job, Reference user)
{
Guard.ArgumentNotNull(job.Trigger, nameof(job.Trigger));
job.InvokerUserId ??= user?.Id;
job.InvokerUserDisplayName ??= user?.Name;
return(await CreateJob(job));
}
public async Task ThenTheFollowingJobIsRequestedIsCompletedForTheCurrentSpecificationAsync(Table table)
{
JobCreateModel job = table.CreateInstance <JobCreateModel>();
string jobId = _currentJobStepContext.JobId;
List <JobLog> status = await _jobStepContext.InMemoryRepo.GetLatestJobForSpecification(jobId);
var completeStatusLog = status.SingleOrDefault(c => c.CompletedSuccessfully == true);
completeStatusLog.Should().NotBeNull();
}
public string AddJob(JobCreateModel form)
{
var job = Mapper.Map <Job>(form);
job.UserId = GetLoggedUser();
job.Id = ObjectId.GenerateNewId();
this.db.Jobs.InsertOneAsync(job);
return(job.Id.ToString());
}
public Task <Job> CreateJob(JobCreateModel jobCreateModel)
{
Guard.ArgumentNotNull(jobCreateModel, nameof(jobCreateModel));
Job job = new Job()
{
Id = Guid.NewGuid().ToString(),
Completed = null,
CompletionStatus = null,
CorrelationId = jobCreateModel.CorrelationId,
Created = DateTime.Now,
InvokerUserDisplayName = jobCreateModel.InvokerUserDisplayName,
InvokerUserId = jobCreateModel.InvokerUserId,
ItemCount = jobCreateModel.ItemCount,
JobDefinitionId = jobCreateModel.JobDefinitionId,
LastUpdated = DateTime.Now,
MessageBody = jobCreateModel.MessageBody,
Outcome = null,
ParentJobId = jobCreateModel.ParentJobId,
Properties = jobCreateModel.Properties,
RunningStatus = RunningStatus.Queued,
SpecificationId = jobCreateModel.SpecificationId,
SupersededByJobId = null,
Trigger = null,
};
if (job.Properties == null)
{
job.Properties = new Dictionary <string, string>();
}
if (!string.IsNullOrWhiteSpace(job.InvokerUserId))
{
job.Properties["user-id"] = job.InvokerUserId;
}
if (!string.IsNullOrWhiteSpace(job.InvokerUserDisplayName))
{
job.Properties["user-name"] = job.InvokerUserDisplayName;
}
if (!string.IsNullOrWhiteSpace(job.SpecificationId))
{
job.Properties["specificationId"] = job.SpecificationId;
}
if (!string.IsNullOrWhiteSpace(job.Id))
{
job.Properties["jobId"] = job.Id;
}
_jobs.Add(job.Id, job);
return(Task.FromResult(job));
}
private void GuardAgainstNullJob(Job job, JobCreateModel createModel)
{
if (job != null)
{
return;
}
var errorMessage = $"Creating job of type {createModel.JobDefinitionId} on specification {createModel.SpecificationId} returned no result";
_logger.Error(errorMessage);
throw new Exception(errorMessage);
}
public async Task CreateJob()
{
JobCreateModel jobCreateModel = NewCreateModel();
IEnumerable <Job> jobs = NewEnumerable(NewJob());
GivenTheResponse("jobs", jobs, HttpMethod.Post);
Job apiResponse = await _client.CreateJob(jobCreateModel);
apiResponse
.Should()
.BeEquivalentTo(jobs.Single());
AndTheRequestContentsShouldHaveBeen(NewEnumerable(jobCreateModel).AsJson());
}
public ActionResult Create(JobCreateModel model, string JobPackageName, string skill1, string skill2, string skill3)
{
string UserID = jobUnitOfWork.AspNetUserRepository.Get(s => s.UserName == User.Identity.Name).FirstOrDefault().Id;
if (jobUnitOfWork.CreateJob(model, JobPackageName, skill1, skill2, skill3, UserID))
{
TempData["successmessage"] = "Tạo đăng tuyển thành công.";
}
else
{
TempData["errormessage"] = "Tạo đăng tuyển thất bại!";
}
return(RedirectToAction("OwnList"));
}
public async Task <Job> CreateJob(JobCreateModel jobCreateModel)
{
Guard.ArgumentNotNull(jobCreateModel, nameof(jobCreateModel));
string url = $"jobs";
ApiResponse <IEnumerable <Job> > jobs = await PostAsync <IEnumerable <Job>, IEnumerable <JobCreateModel> >(url, new[] { jobCreateModel });
if (jobs.Content.IsNullOrEmpty())
{
throw new Exception($"Failed to create new job of type {jobCreateModel.JobDefinitionId}");
}
return(jobs.Content.First());
}
private async Task <Job> CreateJob(string errorMessage, JobCreateModel createModel)
{
try
{
Job job = await _jobManagement.QueueJob(createModel);
return(job);
}
catch (Exception ex)
{
_logger.Error(ex, errorMessage);
throw new Exception(errorMessage);
}
}
public async Task TryCreateJob()
{
JobCreateModel jobCreateRequest = NewCreateModel();
JobCreateResult result = NewCreateResult();
GivenTheResponse("jobs/try-create-job", result, HttpMethod.Post);
ApiResponse <JobCreateResult> apiResponse = await _client.TryCreateJob(jobCreateRequest);
apiResponse?
.Content
.Should()
.BeEquivalentTo(result);
AndTheRequestContentsShouldHaveBeen(jobCreateRequest.AsJson());
}
private async Task <Job> CreateJob(JobCreateModel createModel)
{
try
{
var job = await _jobManagement.QueueJob(createModel);
GuardAgainstNullJob(job, createModel);
return(job);
}
catch (Exception ex)
{
_logger.Error($"Failed to create job of type '{createModel.JobDefinitionId}' on specification '{createModel.Trigger.EntityId}'. {ex}");
throw;
}
}
private async Task <Job> JobFromJobCreateModel(JobCreateModel job, IEnumerable <JobDefinition> jobDefinitions, Reference user)
{
Guard.ArgumentNotNull(job.Trigger, nameof(job.Trigger));
JobDefinition jobDefinition = jobDefinitions.First(m => m.Id == job.JobDefinitionId);
if (string.IsNullOrWhiteSpace(job.InvokerUserId) || string.IsNullOrWhiteSpace(job.InvokerUserDisplayName))
{
job.InvokerUserId = user?.Id;
job.InvokerUserDisplayName = user?.Name;
}
Job newJobResult = await CreateJob(job);
return(newJobResult);
}
public IActionResult Create(JobCreateModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
TempData.AddSuccessMessage("Job successfully created");
var id = this.emp.AddJob(model).ToString();
return(this.RedirectToAction(nameof(List)));
}
catch (Exception ex)
{
return(BadRequest(ex.ToString()));
}
}
public ActionResult Create()
{
JobCreateModel jobCreateModel = new JobCreateModel();
string UserID = jobUnitOfWork.AspNetUserRepository.Get(s => s.UserName == User.Identity.Name).FirstOrDefault().Id;
if (jobUnitOfWork.CompanyInfoRepository.GetByID(UserID) == null)
{
TempData["warningmessage"] = "Xin hãy cập nhật thông tin công ty trước khi đăng tuyển!";
return(RedirectToAction("Update", "CompanyInfo"));
}
if (!jobUnitOfWork.CheckIfCanPostJob(UserID))
{
TempData["jobpackagemessage"] = "Bạn cần mua gói công việc!";
return(RedirectToAction("OwnList"));
}
jobCreateModel.JobLevelList = jobUnitOfWork.JobLevelRepository.Get(filter: d => d.IsDeleted == false).OrderByDescending(s => s.LevelNum);
jobCreateModel.SchoolLevelList = jobUnitOfWork.SchoolLevelRepository.Get(filter: d => d.IsDeleted == false).OrderByDescending(s => s.LevelNum);
jobCreateModel.CityList = jobUnitOfWork.CityRepository.Get(filter: city => city.IsDeleted == false).OrderBy(s => s.Name);
jobCreateModel.CategoryList = jobUnitOfWork.CategoryRepository.Get(category => category.IsDeleted == false).OrderBy(s => s.Name);
jobCreateModel.SkillList = jobUnitOfWork.SkillRepository.Get(skill => skill.IsDeleted == false);
jobCreateModel.JobInfo.RecruiterID = UserID;
jobCreateModel.JobPackageItemSelectItemList = (from p in jobUnitOfWork.PurchaseJobPackageRepository.Get()
join j in jobUnitOfWork.JobPackageRepository.Get() on p.JobPackageID equals j.JobPackageID
where p.RecruiterID == UserID && p.IsApproved == true && p.IsDeleted == false &&
j.IsDeleted == false
select new JobPackageSelectItem()
{
JobPackageName = j.Name,
RemainJobNumber = j.JobNumber - (from jo in jobUnitOfWork.JobRepository.Get()
where jo.PurchaseJobPackageId == p.PurchaseJobPackageID
select jo).Count()
})
.GroupBy(s => s.JobPackageName)
.Select(s => new JobPackageSelectItem {
JobPackageName = s.Key, RemainJobNumber = s.Sum(g => g.RemainJobNumber)
})
.Where(s => s.RemainJobNumber > 0)
.AsEnumerable();
return(View(jobCreateModel));
}
public async Task TryQueueJobs_Called_ReturnsJobCreateResults()
{
IJobsApiClient jobsApiClient = Substitute.For <IJobsApiClient>();
JobManagementResiliencePolicies policies = new JobManagementResiliencePolicies
{
JobsApiClient = Policy.NoOpAsync()
};
IMessengerService messengerService = Substitute.For <IMessengerService>();
ILogger logger = Substitute.For <ILogger>();
JobCreateModel createModelOne = new JobCreateModel();
JobCreateModel createModelTwo = new JobCreateModel();
JobCreateResult expectedCreateResultOne = new JobCreateResult();
JobCreateResult expectedCreateResultTwo = new JobCreateResult();
IEnumerable <JobCreateModel> createModels =
new []
{
createModelOne,
createModelTwo
};
jobsApiClient
.TryCreateJobs(Arg.Is <IEnumerable <JobCreateModel> >(_ => _.SequenceEqual(createModels)))
.Returns(new ApiResponse <IEnumerable <JobCreateResult> >(HttpStatusCode.OK, new[]
{
expectedCreateResultOne,
expectedCreateResultTwo
}));
JobManagement jobManagement = new JobManagement(jobsApiClient, logger, policies, messengerService);
//Act
IEnumerable <JobCreateResult> actualResult = await jobManagement.TryQueueJobs(createModels);
actualResult
.Should()
.BeEquivalentTo <JobCreateResult>(new []
{
expectedCreateResultOne,
expectedCreateResultTwo
});
}
private async Task <Job> SendInstructAllocationsToJobService(string specificationId, Reference user, Trigger trigger, string correlationId, bool generateAggregations = false)
{
JobCreateModel job = new JobCreateModel
{
InvokerUserDisplayName = user.Name,
InvokerUserId = user.Id,
JobDefinitionId = generateAggregations ? JobConstants.DefinitionNames.CreateInstructGenerateAggregationsAllocationJob : JobConstants.DefinitionNames.CreateInstructAllocationJob,
SpecificationId = specificationId,
Properties = new Dictionary <string, string>
{
{ "specification-id", specificationId },
{ "ignore-save-provider-results", "true" }
},
Trigger = trigger,
CorrelationId = correlationId
};
return(await _jobsApiClientPolicy.ExecuteAsync(() => _jobsApiClient.CreateJob(job)));
}
public async Task <ActionResult <JobModel> > PostJob(JobCreateModel model)
{
var campaign = DB.Campaigns.Find(model.Campaign_Id);
var result = Check(campaign is Campaign, NotFound).OkNull() ?? Check(Operation.Create);
if (result.Fail())
{
return(result);
}
var entity = GetEntity(model);
DB_TABLE.Add(entity);
await DB.SaveChangesAsync();
Log(DB_TABLE.GetName(), Operation.Create, campaign.Id, GetModel(entity));
return(CreatedAtAction(nameof(GetJob), new { id = entity.Id }, GetModel(entity)));
}
private async Task <Job> QueueCsvGenerationMessage(string specificationId, string specificationName)
{
JobCreateModel jobCreateModel = new JobCreateModel
{
Trigger = new Trigger
{
EntityId = specificationId,
EntityType = "Specification",
Message = "Generate Calc Csv Results Timer Job"
},
JobDefinitionId = JobConstants.DefinitionNames.GenerateCalcCsvResultsJob,
SpecificationId = specificationId,
Properties = new Dictionary <string, string>
{
{ "specification-id", specificationId },
{ "specification-name", specificationName }
}
};
return(await QueueJob(jobCreateModel));
}
//Change model information into Topic class
public Job Model_Job(JobCreateModel model, int PurchaseJobPackageId)
{
Job temp = new Job();
temp.RecruiterID = model.JobInfo.RecruiterID;
temp.JobTitle = model.JobInfo.JobTitle;
//temp.Company = model.JobInfo.Company;
//temp.Address = model.JobInfo.Address;
temp.MinSalary = model.JobInfo.MinSalary;
temp.MaxSalary = model.JobInfo.MaxSalary;
temp.JobDescription = model.JobInfo.JobDescription;
temp.JobRequirement = model.JobInfo.JobRequirement;
temp.JobLevel_ID = model.JobInfo.JobLevel_ID;
temp.MinSchoolLevel_ID = model.JobInfo.MinSchoolLevel_ID;
temp.JobView = model.JobInfo.JobView;
temp.StartedDate = DateTime.Now;
temp.EndedDate = DateTime.Now.AddDays(30);
temp.IsPublic = model.JobInfo.IsPublic;
temp.PurchaseJobPackageId = PurchaseJobPackageId;
return(temp);
}
private async Task SendInstructAllocationsToJobService(string providerCacheKey, string specificationId, string userId, string userName, Trigger trigger, string correlationId, bool generateCalculationAggregations)
{
JobCreateModel job = new JobCreateModel
{
InvokerUserDisplayName = userName,
InvokerUserId = userId,
JobDefinitionId = generateCalculationAggregations ? JobConstants.DefinitionNames.CreateInstructGenerateAggregationsAllocationJob : JobConstants.DefinitionNames.CreateInstructAllocationJob,
SpecificationId = specificationId,
Properties = new Dictionary <string, string>
{
{ "specification-id", specificationId },
{ "provider-cache-key", providerCacheKey }
},
Trigger = trigger,
CorrelationId = correlationId
};
Job createdJob = await _jobsApiClientPolicy.ExecuteAsync(() => _jobsApiClient.CreateJob(job));
_logger.Information($"New job of type '{createdJob.JobDefinitionId}' created with id: '{createdJob.Id}'");
return;
}
public async Task <IActionResult> QueueMergeSpecificationInformationJob(MergeSpecificationInformationRequest mergeRequest,
Reference user,
string correlationId)
{
Guard.ArgumentNotNull(mergeRequest, nameof(mergeRequest));
JobCreateModel job = new JobCreateModel
{
JobDefinitionId = JobConstants.DefinitionNames.MergeSpecificationInformationForProviderJob,
InvokerUserId = user?.Id,
InvokerUserDisplayName = user?.Name,
CorrelationId = correlationId,
Trigger = new Trigger
{
Message = "Specification or Results change require merging specification information for providers with results",
EntityType = "Specification",
EntityId = mergeRequest.SpecificationInformation.Id
},
MessageBody = mergeRequest.AsJson()
};
return(new OkObjectResult(await _jobsPolicy.ExecuteAsync(() => _jobs.QueueJob(job))));
}
