public ActionResult Detail(Guid id, string resumeGUID)
{
try
{
if (resumeGUID == null || string.IsNullOrWhiteSpace(resumeGUID))
{
resumeGUID = "6257B7B5-C4D0-4D00-ACB4-350A95861B7F";
}
var viewModel = new JobsViewModel();
Repository _repositoryMain = new Repository(_connectionString);
JobsRepository _repository = new JobsRepository(_connectionString);
Applicant applicant = _repositoryMain.GetApplicant(resumeGUID);
JobDetails jobsDetail = _repository.GetJobDetails(id);
var responsibilities = _repository.GetResponsibilities(id);
viewModel.Title = "Richard M. Cano Resume";
viewModel.Applicant = applicant;
viewModel.JobDetails = jobsDetail;
viewModel.Responsibilities = responsibilities;
return(View(viewModel));
}
catch
{
return(View("Error"));
}
}
private static bool ValidateJobNumber(string jobNumber)
{
var jobRepo = new JobsRepository(new PmcsDbContext());
var result = jobRepo.SearchData(j => j.JobNumber == jobNumber);
return(result.Any());
}
public ActionResult Index(string resumeGUID)
{
try
{
if (resumeGUID == null || string.IsNullOrWhiteSpace(resumeGUID))
{
resumeGUID = "6257B7B5-C4D0-4D00-ACB4-350A95861B7F";
}
Repository _repositoryMain = new Repository(_connectionString);
JobsRepository _repository = new JobsRepository(_connectionString);
Applicant applicant = _repositoryMain.GetApplicant(resumeGUID);
List <Job> jobsList;
var viewModel = new JobsViewModel();
jobsList = _repository.GetJobs();
viewModel.Applicant = applicant;
viewModel.Jobs = jobsList;
return(View(viewModel));
}
catch
{
return(View("Error"));
}
}
public void ProcessJobs()
{
IJobsRepository jobsRepository = new JobsRepository(_ctx);
var allJobs = jobsRepository.GetAllJobs();
var jobsToProcess = allJobs.Where(x => x.Status == JobStatus.New).ToList();
jobsToProcess.ForEach(job => job.ChangeStatus(JobStatus.InProgress));
_ctx.SaveChanges();
Parallel.ForEach(jobsToProcess, (currentjob) =>
{
new Task(async() =>
{
bool result = await this.ProcessJob(currentjob).ConfigureAwait(false);
if (result)
{
currentjob.ChangeStatus(JobStatus.Done);
}
else
{
_ctx.SaveChanges();
currentjob.ChangeStatus(JobStatus.Failed);
}
}).Start();
});
_ctx.SaveChanges();
}
public void Start()
{
this._timer = new Timer();
_jobsRepository = new JobsRepository(ConfigurationManager.AppSettings["API"]);
_timer.Elapsed += new ElapsedEventHandler(Fetch);
_timer.Interval = Convert.ToDouble(1000);
_timer.Enabled = true;
Fetch(null, null); //fire immediately
}
// GET: Tasks
public ActionResult Index()
{
using (ZavenDotNetInterviewContext _ctx = new ZavenDotNetInterviewContext())
{
JobsRepository jobsRepository = new JobsRepository(_ctx);
List <Job> jobs = jobsRepository.GetAllJobs();
return(View(jobs));
}
}
public JobsService(JobsRepository jobsRepository,
AsBuiltRepository asBuiltRepository,
PATRepository pATRepository,
OILsRepository oILsRepository,
ProjectTasksRepository projectTasksRepository)
{
this.jobsRepository = jobsRepository;
this.asBuiltRepository = asBuiltRepository;
this.pATRepository = pATRepository;
this.oILsRepository = oILsRepository;
this.projectTasksRepository = projectTasksRepository;
}
private static IJobsRepository CreateJobsRepository(params DJobMessage[] jobMessages)
{
var connection = new SqlConnectionWrapperMock();
connection.SetupQueryAsync("GetJobMessage", new Dictionary <string, object>(), jobMessages);
var artifactsMock = new Mock <IArtifactRepository>();
var permissionsMock = new Mock <IArtifactPermissionsRepository>();
var usersMock = new Mock <IUsersRepository>();
var jobsRepository = new JobsRepository(connection.Object, artifactsMock.Object, permissionsMock.Object, usersMock.Object);
return(jobsRepository);
}
private void MigrateJobs(MyDBContext context, IScheduler scheduler)
{
//Check if there are jobs in the QDMS db and no jobs in the quartz db - in that case we migrate them
var repo = new JobsRepository(context, scheduler);
if (context.DataUpdateJobs.Any() && scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup()).Count == 0)
{
foreach (DataUpdateJobSettings job in context.DataUpdateJobs)
{
repo.ScheduleJob(job);
}
}
}
public void Get_ShouldThrowException_WhenJobIdNotFound()
{
// Arrange
using (var dbContext = new JobDbContext(CreateDbContextOptions("InMemoryDatabase_GetNull")))
{
var jobsRepository = new JobsRepository(SetupAutoMapper(), dbContext);
var jobId = Guid.Empty;
// Act
var exception = new Action(() => jobsRepository.Get(jobId));
// Assert
exception
.Should()
.Throw <JobNotFoundException>()
.WithMessage(string.Format("JobId: {0} not found.", jobId));
}
}
public void Get_ShouldReturnJobDto()
{
// Arrange
var jobDto = CreateJobDto();
using (var dbContext = new JobDbContext(CreateDbContextOptions("InMemoryDatabase_Get")))
{
var jobsRepository = new JobsRepository(SetupAutoMapper(), dbContext);
jobsRepository.Create(jobDto);
// Act
var job = jobsRepository.Get(jobDto.JobId);
// Assert
job.JobId.Should().Be(jobDto.JobId);
job.FileName.Should().Be(jobDto.FileName);
job.JobStatus.Should().Be(jobDto.JobStatus);
}
}
public string MarkComplete(string jobId)
{
if (!string.IsNullOrEmpty(jobId))
{
JobsRepository jobs = new JobsRepository();
if (jobs.MarkJobAsComplete(jobId))
{
return("success");
}
else
{
return("error");
}
}
else
{
return("invalid");
}
}
public void Create_ShouldSaveJobEntity()
{
// Arrange
var jobDto = CreateJobDto();
using (var dbContext = new JobDbContext(CreateDbContextOptions("InMemoryDatabase_Create")))
{
var jobsRepository = new JobsRepository(SetupAutoMapper(), dbContext);
// Act
var result = jobsRepository.Create(jobDto);
// Assert
var jobEntity = dbContext.Jobs.Single(w => w.JobId == jobDto.JobId);
jobEntity.FileName.Should().Be(jobDto.JobId.ToString());
result.FileName.Should().Be(jobEntity.OriginalFileName);
result.JobId.Should().Be(jobEntity.JobId);
result.DateCreated.Should().Be(jobEntity.DateCreated);
result.JobStatus.Should().Be(EnumUtility.GetValue(jobEntity.JobStatus));
result.DateLastModified.Should().BeNull();
}
}
public void Update_ShouldSaveJobEntityWithNewStatusAndDateLastModified()
{
// Arrange
var jobDto = CreateJobDto();
var expectedStatus = JobStatus.Queued;
using (var dbContext = new JobDbContext(CreateDbContextOptions("InMemoryDatabase_Update")))
{
var jobsRepository = new JobsRepository(SetupAutoMapper(), dbContext);
var createdJob = jobsRepository.Create(jobDto);
// Act
var updatedJob = jobsRepository.Update(createdJob, expectedStatus);
// Assert
updatedJob.DateCreated.Should().Be(createdJob.DateCreated);
createdJob.DateLastModified.Should().BeNull();
updatedJob.DateLastModified.Should().NotBeNull();
createdJob.JobStatus.Should().Be(jobDto.JobStatus);
updatedJob.JobStatus.Should().Be(EnumUtility.GetValue(expectedStatus));
}
}
public JobsService(JobsRepository jobsRepository)
{
_jobsRepository = jobsRepository;
}
public List <JobSummaryDTO> All()
{
JobsRepository jobs = new JobsRepository();
return(jobs.GetJobSummary());
}
// GET: Home
public ActionResult Index()
{
JobsRepository jobsIO = new JobsRepository();
return(View(jobsIO.GetAllJobs()));
}
public JobsService(JobsRepository repo)
{
_repo = repo;
}
public JobsService(JobsRepository jrepo)
{
_jrepo = jrepo;
}
public JobsController(JobsRepository jobsRepo)
{
_JobsRepo = jobsRepo;
}
public ContractorsService(ContractorsRepository crepo, JobsRepository jrepo)
{
_crepo = crepo;
_jrepo = jrepo;
}
public ContractWorkersService(ContractWorkersRepository repo, JobsRepository jrepo)
{
_repo = repo;
_jrepo = jrepo;
}
public ElementsService(ElementsRepositroy elementsRepositroy, JobsRepository jobsRepository)
{
this.elementsRepositroy = elementsRepositroy;
this.jobsRepository = jobsRepository;
}
public POsService(PORepository pORepository, JobsRepository jobsRepository, ElementsRepositroy elementsRepositroy)
{
this.pORepository = pORepository;
this.jobsRepository = jobsRepository;
this.elementsRepositroy = elementsRepositroy;
}
public JobsService(JobsRepository repo, ContractorsRepository crepo)
{
_repo = repo;
_crepo = crepo;
}
public BOQService(BOQRepository bOQRepository, JobsRepository jobsRepository)
{
this.bOQRepository = bOQRepository;
this.jobsRepo = jobsRepository;
}
