public async Task <IEnumerable <JobServiceModel> > GetJobsAsync(
JobType?jobType,
JobStatus?jobStatus,
int?pageSize,
string queryFrom,
string queryTo)
{
var from = DateTimeOffsetExtension.Parse(queryFrom, DateTimeOffset.MinValue);
var to = DateTimeOffsetExtension.Parse(queryTo, DateTimeOffset.MaxValue);
var data = await this.client.GetAllAsync(DEVICE_JOBS_COLLECTION_ID);
var Coverteddata = data.Items.Select(CreatejobServiceModel);
//var query = this.jobClient.CreateQuery(
// JobServiceModel.ToJobTypeAzureModel(jobType),
// JobServiceModel.ToJobStatusAzureModel(jobStatus),
// pageSize);
var results = new List <JobServiceModel>();
results.AddRange(Coverteddata
.Where(j => j.CreatedTimeUtc >= from && j.CreatedTimeUtc <= to &&
(jobType == null || j.Type.ToString() == JobServiceModel.ToJobTypeAzureModel(jobType).ToString()) &&
(jobStatus == null || j.Status.ToString() == JobServiceModel.ToJobStatusAzureModel(jobStatus).ToString()))
.Select(r => r));
//while (query.HasMoreResults)
//{
// var jobs = await query.GetNextAsJobResponseAsync();
//}
return(results);
}
public async Task <IEnumerable <JobServiceModel> > GetJobsAsync(
JobType?jobType,
JobStatus?jobStatus,
int?pageSize,
string queryFrom,
string queryTo)
{
var from = DateTimeOffsetExtension.Parse(queryFrom, DateTimeOffset.MinValue);
var to = DateTimeOffsetExtension.Parse(queryTo, DateTimeOffset.MaxValue);
var query = this.tenantConnectionHelper.GetJobClient().CreateQuery(
JobServiceModel.ToJobTypeAzureModel(jobType),
JobServiceModel.ToJobStatusAzureModel((Microsoft.Azure.Devices.JobStatus?)jobStatus),
pageSize);
var results = new List <JobServiceModel>();
while (query.HasMoreResults)
{
var jobs = await query.GetNextAsJobResponseAsync();
results.AddRange(jobs
.Where(j => j.CreatedTimeUtc >= from && j.CreatedTimeUtc <= to)
.Select(r => new JobServiceModel(r)));
}
return(results);
}
public async Task UpdateAsync_WithValidModel_WorksCorrectly()
{
// Arrange
const string expectedResult = "TestJobTitle";
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new Job()
{
Location = "Test Location",
Description = "Random description",
EndDate = DateTime.UtcNow,
Company = new Company()
{
CompanyName = "Test Company",
User = new User()
{
UserName = "******"
},
},
Category = new Category()
{
CategoryType = "NewCategory"
},
JobType = new JobType()
{
Type = "NewType"
}
};
await context.AddAsync(model);
context.SaveChanges();
var jobService = new JobService(new EfRepository <Company>(context),
new EfRepository <Job>(context),
new EfRepository <JobCandidate>(context),
new EfRepository <User>(context),
new EfRepository <JobSeeker>(context));
var serviceModel = new JobServiceModel
{
Id = model.Id,
Title = expectedResult,
Location = model.Location,
Description = model.Description,
EndDate = model.EndDate
};
var result = await jobService.UpdateAsync(serviceModel);
Assert.True(result);
var actualResult = (await context.Jobs.SingleAsync(j => j.Id == model.Id)).Title;
Assert.Equal(expectedResult, actualResult);
}
public async Task <int?> CreateAsync(JobServiceModel model)
{
if (!this.IsEntityStateValid(model))
{
return(null);
}
var company = await this.companyRepository.All()
.SingleOrDefaultAsync(c => c.User.UserName == model.Company.User.UserName);
if (company == null)
{
return(null);
}
var job = Mapper.Map <Job>(model);
job.Company = company;
await this.jobsRepository.AddAsync(job);
await this.jobsRepository.SaveChangesAsync();
return(job.Id);
}
private JobServiceModel CreatejobServiceModel(ValueApiModel input)
{
JobServiceModel output = JsonConvert.DeserializeObject <JobServiceModel>(input.Data);
output.JobId = input.objectid;
return(output);
}
public async Task <bool> ApplyToJob(JobServiceModel jobServiceModel, string userName)
{
if (userName == null || jobServiceModel == null)
{
return(false);
}
var user = await this.usersRepository.All().SingleOrDefaultAsync(u => u.UserName == userName);
if (user == null)
{
return(false);
}
var jobSeeker = (await this.candidatesRepository.All().Include(j => j.UserJobs)
.SingleOrDefaultAsync(j => j.User.UserName == userName));
if (jobSeeker == null)
{
return(false);
}
var jobCandidate = new JobCandidate
{
JobSeekerId = jobSeeker.Id,
JobId = jobServiceModel.Id,
};
await this.jobCandidatesRepository.AddAsync(jobCandidate);
await this.jobCandidatesRepository.SaveChangesAsync();
return(true);
}
public async Task <bool> UpdateAsync(JobServiceModel model)
{
if (!this.IsEntityStateValid(model))
{
return(false);
}
var job = await this.jobsRepository.All().SingleOrDefaultAsync(c => c.Id == model.Id);
if (job == null)
{
return(false);
}
job.Title = model.Title;
job.Location = model.Location;
job.CategoryId = model.CategoryId;
job.JobTypeId = model.JobTypeId;
job.Description = model.Description;
job.Responsibilities = model.Responsibilities;
job.Benefits = model.Benefits;
job.Education = model.Education;
job.EndDate = model.EndDate;
job.Qualification = model.Qualification;
this.jobsRepository.Update(job);
await this.jobsRepository.SaveChangesAsync();
return(true);
}
public async Task CreateAsync_WithValidModel_WorksCorrectly()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var companyModel = new Company()
{
CompanyName = "Test Company Name",
User = new User()
{
UserName = "******"
}
};
await context.AddAsync(companyModel);
context.SaveChanges();
var serviceModel = new JobServiceModel()
{
Title = "Test title",
Location = "Test Location",
Description = "Random description",
EndDate = DateTime.UtcNow,
Company = new CompanyServiceModel()
{
User = new UserServiceModel()
{
UserName = companyModel.User.UserName
},
}
};
var jobService = new JobService(new EfRepository <Company>(context),
new EfRepository <Job>(context),
new EfRepository <JobCandidate>(context),
new EfRepository <User>(context),
new EfRepository <JobSeeker>(context));
var result = await jobService.CreateAsync(serviceModel);
var dbModel = context.Jobs.SingleOrDefault();
Assert.NotNull(dbModel);
Assert.Equal(result, dbModel.Id);
}
public async Task <JobServiceModel> ScheduleDeviceMethodAsync(
string jobId,
string queryCondition,
MethodParameterServiceModel parameter,
DateTimeOffset startTimeUtc,
long maxExecutionTimeInSeconds)
{
//var result = await this.jobClient.ScheduleDeviceMethodAsync(
// jobId, queryCondition,
// parameter.ToAzureModel(),
// startTimeUtc.DateTime,
// maxExecutionTimeInSeconds);
var devicelistString = queryCondition.Replace("deviceId in", "").Trim();
var devicelist = JsonConvert.DeserializeObject <List <dynamic> >(devicelistString);
List <DeviceJobServiceModel> devicemodellist = new List <DeviceJobServiceModel>();
foreach (var item in devicelist)
{
DeviceJobServiceModel data = new DeviceJobServiceModel();
data.DeviceId = item;
data.Status = DeviceJobStatus.Scheduled;
data.CreatedDateTimeUtc = DateTime.UtcNow;
devicemodellist.Add(data);
}
var devicecount = devicemodellist.Count();
JobServiceModel json = new JobServiceModel();
json.CreatedTimeUtc = DateTime.UtcNow;
json.Devices = devicemodellist.ToList();
json.Status = JobStatus.Scheduled;
json.MethodParameter = parameter;
json.Type = JobType.ScheduleUpdateTwin;
JobStatistics ResultStatistics = new JobStatistics();
ResultStatistics.DeviceCount = devicecount;
ResultStatistics.SucceededCount = 0;
ResultStatistics.FailedCount = 0;
ResultStatistics.PendingCount = 0;
ResultStatistics.RunningCount = 0;
json.ResultStatistics = ResultStatistics;
var value = JsonConvert.SerializeObject(json, Formatting.Indented, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
var result = await this.client.CreateAsync(DEVICE_JOBS_COLLECTION_ID, value);
var Job = this.CreatejobServiceModel(result);
return(Job);
}
public async Task CreateAsync_WithInvalidModel_ReturnsFalse()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var companyModel = new Company()
{
CompanyName = "Test Company Name",
User = new User()
{
UserName = "******"
}
};
await context.AddAsync(companyModel);
context.SaveChanges();
var serviceModel = new JobServiceModel()
{
Location = "Test Location",
Description = "Random description",
EndDate = DateTime.UtcNow,
Company = new CompanyServiceModel()
{
User = new UserServiceModel()
{
UserName = companyModel.User.UserName
},
}
};
var jobService = new JobService(new EfRepository <Company>(context),
new EfRepository <Job>(context),
new EfRepository <JobCandidate>(context),
new EfRepository <User>(context),
new EfRepository <JobSeeker>(context));
var result = await jobService.CreateAsync(serviceModel);
Assert.Null(result);
var dbModel = await context.JobSeekers.AnyAsync();
Assert.False(dbModel);
}
public async Task UpdateAsync_WithNonExistentJob_WorksCorrectly()
{
var context = new JobFinderDbContext(new DbContextOptionsBuilder <JobFinderDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options);
var model = new Job()
{
Location = "Test Location",
Description = "Random description",
EndDate = DateTime.UtcNow,
Company = new Company()
{
CompanyName = "Test Company",
User = new User()
{
UserName = "******"
},
},
Category = new Category()
{
CategoryType = "NewCategory"
},
JobType = new JobType()
{
Type = "NewType"
}
};
var jobService = new JobService(new EfRepository <Company>(context),
new EfRepository <Job>(context),
new EfRepository <JobCandidate>(context),
new EfRepository <User>(context),
new EfRepository <JobSeeker>(context));
var serviceModel = new JobServiceModel
{
Id = model.Id,
Location = model.Location,
Description = model.Description,
EndDate = model.EndDate
};
var result = await jobService.UpdateAsync(serviceModel);
Assert.False(result);
}
public async Task <bool> UpdateEmployeeJob(JobServiceModel job, SalaryServiceModel model)
{
try
{
_unitOfWork.BeginTransaction();
var jobModel = _mapper.Map <Job>(job);
var updateModel = _mapper.Map <Salary>(model);
var salaryHistoryRepo = _unitOfWork.GetRepository <SalaryHistory>();
var employeeRepo = _unitOfWork.GetRepository <Employee>();
var employee = employeeRepo.GetById(updateModel.Employee.Id);
employee.Job = jobModel;
var salaryHistory = await PrepareSalaryHistory(model);
var jobHistory = new JobHistory
{
DateChanged = salaryHistory.DateChanged,
EmployeeId = employee.Id,
FromDate = salaryHistory.FromDate,
ToDate = salaryHistory.ToDate,
Job = jobModel,
SalaryHistoryId = salaryHistory.SalaryId
};
await _unitOfWork.GetRepository <Salary>().UpdateAsync(updateModel);
await salaryHistoryRepo.AddItemAsync(salaryHistory);
await employeeRepo.UpdateAsync(employee);
await _unitOfWork.GetRepository <JobHistory>().AddItemAsync(jobHistory);
await _unitOfWork.CommitAsync();
return(true);
}
catch
{
await _unitOfWork.RollbackAsync();
throw;
}
}
public JobApiModel(JobServiceModel serviceModel)
{
if (serviceModel != null)
{
this.JobId = serviceModel.JobId;
this.QueryCondition = serviceModel.QueryCondition;
this.CreatedTimeUtc = serviceModel.CreatedTimeUtc;
this.StartTimeUtc = serviceModel.StartTimeUtc;
this.EndTimeUtc = serviceModel.EndTimeUtc;
this.MaxExecutionTimeInSeconds = serviceModel.MaxExecutionTimeInSeconds;
this.Type = serviceModel.Type;
this.Status = serviceModel.Status;
this.MethodParameter = serviceModel.MethodParameter == null ? null : new MethodParameterApiModel(serviceModel.MethodParameter);
this.UpdateTwin = serviceModel.UpdateTwin == null ? null : new JobUpdateTwinApiModel(null, serviceModel.UpdateTwin);
this.FailureReason = serviceModel.FailureReason;
this.StatusMessage = serviceModel.StatusMessage;
this.ResultStatistics = serviceModel.ResultStatistics;
this.Devices = serviceModel.Devices?.Select(j => new DeviceJobApiModel(j));
}
}
public async Task <bool> CreateJob(JobServiceModel model)
{
try
{
_unitOfWork.BeginTransaction();
var createModel = _mapper.Map <Job>(model);
await _unitOfWork.GetRepository <Job>().AddItemAsync(createModel);
await _unitOfWork.CommitAsync();
return(true);
}
catch
{
await _unitOfWork.RollbackAsync();
throw;
}
}
public async Task <JobServiceModel> ScheduleTwinUpdateAsync(
string jobId,
string queryCondition,
TwinServiceModel twin,
DateTimeOffset startTimeUtc,
long maxExecutionTimeInSeconds)
{
//var result = await this.jobClient.ScheduleTwinUpdateAsync(
// jobId,
// queryCondition,
// twin.ToAzureModel(),
// startTimeUtc.DateTime,
// maxExecutionTimeInSeconds);
var devicelistString = queryCondition.Replace("deviceId in", "").Trim();
var devicelist = JsonConvert.DeserializeObject <List <dynamic> >(devicelistString);
List <DeviceJobServiceModel> devicemodellist = new List <DeviceJobServiceModel>();
foreach (var item in devicelist)
{
DeviceJobServiceModel data = new DeviceJobServiceModel();
data.DeviceId = item;
data.Status = DeviceJobStatus.Scheduled;
data.CreatedDateTimeUtc = DateTime.UtcNow;
devicemodellist.Add(data);
}
var devicecount = devicemodellist.Count();
JobServiceModel json = new JobServiceModel();
json.CreatedTimeUtc = DateTime.UtcNow;
json.Devices = devicemodellist.ToList();
json.Status = JobStatus.Scheduled;
json.UpdateTwin = twin;
json.Type = JobType.ScheduleUpdateTwin;
JobStatistics ResultStatistics = new JobStatistics();
ResultStatistics.DeviceCount = devicecount;
ResultStatistics.SucceededCount = 0;
ResultStatistics.FailedCount = 0;
ResultStatistics.PendingCount = 0;
ResultStatistics.RunningCount = 0;
json.ResultStatistics = ResultStatistics;
var value = JsonConvert.SerializeObject(json, Formatting.Indented, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
var result = await this.client.CreateAsync(DEVICE_JOBS_COLLECTION_ID, value);
var Job = this.CreatejobServiceModel(result);
// Update the deviceProperties cache, no need to wait
var model = new DevicePropertyServiceModel();
var tagRoot = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(twin.Tags)) as JToken;
if (tagRoot != null)
{
model.Tags = new HashSet <string>(tagRoot.GetAllLeavesPath());
}
var reportedRoot = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(twin.ReportedProperties)) as JToken;
if (reportedRoot != null)
{
model.Reported = new HashSet <string>(reportedRoot.GetAllLeavesPath());
}
var unused = deviceProperties.UpdateListAsync(model);
return(Job);
}
public bool HasUserApplied(JobServiceModel jobServiceModel, string userName)
{
return(userName != null && jobServiceModel.JobCandidates.Any(j => j.JobSeeker.User.UserName == userName));
}
