Exemple #1
0
        public async Task GetLatestJobByUkprn_Success()
        {
            IContainer container = Registrations();
            IEnumerable <FileUploadJob> items;

            using (var scope = container.BeginLifetimeScope())
            {
                // Create the schema in the database
                var options = scope.Resolve <DbContextOptions <JobQueueDataContext> >();
                using (var context = new JobQueueDataContext(options))
                {
                    context.Database.EnsureCreated();
                }

                IFileUploadJobManager manager = scope.Resolve <IFileUploadJobManager>();

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 1,
                    Ukprn          = 10000116,
                    PeriodNumber   = 1,
                    FileName       = "ilr.xml",
                    CollectionName = "ILR1819"
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 2,
                    Ukprn          = 10000116,
                    PeriodNumber   = 2,
                    FileName       = "10000116/SUPPDATA-10000116-ESF-99999-20181109-090919.csv",
                    CollectionName = "ESF"
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 3,
                    Ukprn          = 10000116,
                    PeriodNumber   = 2,
                    FileName       = "eas.csv",
                    CollectionName = "EAS"
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 4,
                    Ukprn          = 10000119,
                    PeriodNumber   = 2,
                    FileName       = "eas11.csv",
                    CollectionName = "EAS"
                });

                items = (await manager.GetLatestJobByUkprn(new long[] { 10000116, 10000119 })).ToList();
            }

            items.Should().NotBeEmpty();

            items.Single(x => x.FileName.Equals("ilr.xml") && x.Ukprn == 10000116 && x.JobId == 1).Should().NotBeNull();
            items.Single(x => x.FileName.Equals("eas11.csv") && x.Ukprn == 10000119 && x.JobId == 4).Should().NotBeNull();
        }
Exemple #2
0
        public async Task GetJobsByUkprnForDateRange_Success()
        {
            IContainer           container = Registrations();
            List <FileUploadJob> result;

            using (var scope = container.BeginLifetimeScope())
            {
                // Create the schema in the database
                var options = scope.Resolve <DbContextOptions <JobQueueDataContext> >();
                using (var context = new JobQueueDataContext(options))
                {
                    context.Database.EnsureCreated();
                }

                IFileUploadJobManager manager = scope.Resolve <IFileUploadJobManager>();

                await manager.AddJob(new FileUploadJob()
                {
                    JobId = 1,
                    Ukprn = 100
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId = 2,
                    Ukprn = 100
                });

                result = (await manager.GetJobsByUkprnForDateRange(100, DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow)).ToList();
            }

            result.Should().NotBeNull();
            result.Count.Should().Be(2);
        }
Exemple #3
0
        public async Task GetLatestJobByUkprnAndContractReference_Success()
        {
            IContainer    container = Registrations();
            FileUploadJob result;

            using (var scope = container.BeginLifetimeScope())
            {
                // Create the schema in the database
                var options = scope.Resolve <DbContextOptions <JobQueueDataContext> >();
                using (var context = new JobQueueDataContext(options))
                {
                    context.Database.EnsureCreated();
                }

                IFileUploadJobManager manager = scope.Resolve <IFileUploadJobManager>();

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 1,
                    Ukprn          = 10000116,
                    PeriodNumber   = 1,
                    FileName       = "10000116/SUPPDATA-10000116-ESF-2270-20181109-090919.csv",
                    CollectionName = "ESF"
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 2,
                    Ukprn          = 10000116,
                    PeriodNumber   = 2,
                    FileName       = "10000116/SUPPDATA-10000116-ESF-99999-20181109-090919.csv",
                    CollectionName = "ESF"
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 3,
                    Ukprn          = 10000119,
                    PeriodNumber   = 2,
                    FileName       = "10000119/SUPPDATA-10000119-ESF-2270-20181109-090919.csv",
                    CollectionName = "ESF"
                });

                result = await manager.GetLatestJobByUkprnAndContractReference(10000116, "ESF-2270", "ESF");
            }

            result.Should().NotBeNull();
            result.FileName.Should().Be("10000116/SUPPDATA-10000116-ESF-2270-20181109-090919.csv");
            result.Ukprn.Should().Be(10000116);
            result.JobId.Should().Be(1);
        }
Exemple #4
0
        public async Task GetJobMetaDataById_Success()
        {
            IContainer    container = Registrations();
            FileUploadJob result;

            using (var scope = container.BeginLifetimeScope())
            {
                // Create the schema in the database
                var options = scope.Resolve <DbContextOptions <JobQueueDataContext> >();
                using (var context = new JobQueueDataContext(options))
                {
                    context.Database.EnsureCreated();
                }

                IFileUploadJobManager manager = scope.Resolve <IFileUploadJobManager>();
                var jobId = await manager.AddJob(new FileUploadJob()
                {
                    JobId = 1,
                });

                result = await manager.GetJobById(1);
            }

            result.Should().NotBeNull();
            result.JobId.Should().Be(1);
        }
Exemple #5
0
        public async Task AddJob_Null()
        {
            IContainer container = Registrations();

            using (var scope = container.BeginLifetimeScope())
            {
                IFileUploadJobManager manager = scope.Resolve <IFileUploadJobManager>();
                await Assert.ThrowsAsync <ArgumentNullException>(() => manager.AddJob(null));
            }
        }
Exemple #6
0
        public async Task AddJobMetaData_Success_Values()
        {
            IContainer    container = Registrations();
            FileUploadJob savedJob;

            using (var scope = container.BeginLifetimeScope())
            {
                // Create the schema in the database
                var options = scope.Resolve <DbContextOptions <JobQueueDataContext> >();
                using (var context = new JobQueueDataContext(options))
                {
                    context.Database.EnsureCreated();
                }

                FileUploadJob job = new FileUploadJob()
                {
                    JobId            = 1,
                    Ukprn            = 1000,
                    FileName         = "test.xml",
                    StorageReference = "test-ref",
                    FileSize         = 10.5m,
                    IsFirstStage     = true,
                    CollectionName   = "ILR1718",
                    PeriodNumber     = 10,
                    TermsAccepted    = true,
                    CollectionYear   = 1819
                };

                IFileUploadJobManager manager = scope.Resolve <IFileUploadJobManager>();
                await manager.AddJob(job);

                savedJob = await manager.GetJobById(1);
            }

            savedJob.Should().NotBeNull();
            savedJob.JobId.Should().Be(1);
            savedJob.Ukprn.Should().Be(1000);
            savedJob.FileName.Should().Be("test.xml");
            savedJob.FileSize.Should().Be(10.5m);
            savedJob.StorageReference.Should().Be("test-ref");
            savedJob.IsFirstStage.Should().Be(true);
            savedJob.CollectionName.Should().Be("ILR1718");
            savedJob.PeriodNumber.Should().Be(10);
            savedJob.TermsAccepted.Should().Be(true);
            savedJob.CollectionYear.Should().Be(1819);
        }
Exemple #7
0
        public async Task GetLatestJobsPerPeriodByUkprn_Success()
        {
            IContainer           container = Registrations();
            List <FileUploadJob> result;

            using (var scope = container.BeginLifetimeScope())
            {
                // Create the schema in the database
                var options = scope.Resolve <DbContextOptions <JobQueueDataContext> >();
                using (var context = new JobQueueDataContext(options))
                {
                    context.Database.EnsureCreated();
                }

                IFileUploadJobManager manager = scope.Resolve <IFileUploadJobManager>();

                await manager.AddJob(new FileUploadJob()
                {
                    JobId                = 1,
                    JobType              = JobType.EsfSubmission,
                    Ukprn                = 10000116,
                    FileName             = "esf.csv",
                    CollectionName       = "ESF",
                    CollectionYear       = 1819,
                    Status               = JobStatusType.Completed,
                    PeriodNumber         = 1,
                    DateTimeSubmittedUtc = DateTime.Now.AddMinutes(-10),
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId                = 2,
                    JobType              = JobType.EasSubmission,
                    Ukprn                = 10000116,
                    FileName             = "eas.csv",
                    CollectionName       = "EAS",
                    CollectionYear       = 1819,
                    PeriodNumber         = 1,
                    Status               = JobStatusType.Completed,
                    DateTimeSubmittedUtc = DateTime.Now.AddMinutes(-10),
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 3,
                    Ukprn          = 10000116,
                    FileName       = "ilr1819.xml",
                    CollectionName = "ILR1819",
                    CollectionYear = 1819,
                    PeriodNumber   = 1,
                    JobType        = JobType.IlrSubmission,
                    Status         = JobStatusType.Completed,
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId          = 4,
                    Ukprn          = 10000116,
                    FileName       = "ilr1718.xml",
                    CollectionName = "ILR1718",
                    CollectionYear = 1718,
                    PeriodNumber   = 1,
                    JobType        = JobType.IlrSubmission,
                    Status         = JobStatusType.Completed,
                });

                await manager.AddJob(new FileUploadJob()
                {
                    JobId                = 5,
                    Ukprn                = 10000116,
                    FileName             = "ilr_latest_not_completed.xml",
                    CollectionName       = "ILR1819",
                    CollectionYear       = 1819,
                    PeriodNumber         = 1,
                    JobType              = JobType.IlrSubmission,
                    Status               = JobStatusType.Failed,
                    DateTimeSubmittedUtc = DateTime.Now.AddMinutes(-50),
                });

                result =
                    (await manager.GetLatestJobsPerPeriodByUkprn(10000116, DateTime.Now.AddDays(-1), DateTime.Now))
                    .ToList();
            }

            result.Should().NotBeNull();
            result.Count.Should().Be(4);
            result.Single(x => x.JobType == JobType.EsfSubmission && x.JobId == 1 && x.FileName == "esf.csv").Should().NotBeNull();
            result.Single(x => x.JobType == JobType.EasSubmission && x.JobId == 2 && x.FileName == "eas.csv").Should().NotBeNull();
            result.Single(x => x.JobType == JobType.IlrSubmission && x.JobId == 3 && x.FileName == "ilr1819.xml" && x.CollectionYear == 1819).Should().NotBeNull();
            result.Single(x => x.JobType == JobType.IlrSubmission && x.JobId == 4 && x.FileName == "ilr1718.xml" && x.CollectionYear == 1718).Should().NotBeNull();
        }
Exemple #8
0
        public ActionResult Post([FromBody] FileUploadJob job)
        {
            _logger.LogInfo("Post for job received for job: {@job}", new[] { job });
            if (job == null)
            {
                _logger.LogWarning("Job Post request received with empty data");
                return(BadRequest());
            }

            if (!Enum.IsDefined(typeof(JobStatusType), job.Status))
            {
                _logger.LogWarning($"Job Post request received with bad status {job.Status}");
                return(BadRequest("Status is not a valid value"));
            }

            if (!Enum.IsDefined(typeof(JobType), job.JobType))
            {
                _logger.LogWarning($"Job Post request received with bad job type {job.JobType}");
                return(BadRequest("Job type is not a valid value"));
            }

            try
            {
                var jobModel = new Jobs.Model.Job
                {
                    Status               = job.Status,
                    JobId                = job.JobId,
                    JobType              = job.JobType,
                    Priority             = job.Priority,
                    SubmittedBy          = job.SubmittedBy,
                    NotifyEmail          = job.NotifyEmail,
                    DateTimeSubmittedUtc = job.DateTimeSubmittedUtc,
                };

                if (job.JobId > 0)
                {
                    if (job.Status == JobStatusType.Ready || job.Status == JobStatusType.Paused ||
                        job.Status == JobStatusType.FailedRetry)
                    {
                        _logger.LogInfo($"Going to update job with job Id: {job.JobId}");

                        var result = _jobManager.UpdateJob(jobModel);
                        if (result)
                        {
                            _logger.LogInfo($"Successfully updated job with job Id: {job.JobId}");
                            return(Ok());
                        }

                        _logger.LogWarning($"Update job failed for job Id: {job.JobId}");
                        return(BadRequest());
                    }

                    _logger.LogWarning($"Update job rejected because job status is not updateable for job Id: {job.JobId}; status: {job.Status}");
                    return(BadRequest($"Only job with status of {nameof(JobStatusType.Ready)}, {nameof(JobStatusType.Paused)} or {nameof(JobStatusType.FailedRetry)} can be updated."));
                }

                _logger.LogInfo($"Create Job request received with object: {job} ");

                job.JobId = _fileUploadJobManager.AddJob(job);

                if (job.JobId > 0)
                {
                    _logger.LogInfo($"Created job successfully with Id: {job.JobId}");
                    return(Ok(job.JobId));
                }

                _logger.LogInfo("Create job failed for job: {@job}", new[] { job });
                return(BadRequest());
            }
            catch (Exception ex)
            {
                _logger.LogError("Post for job failed for job: {@job}", ex, new[] { job });

                return(BadRequest());
            }
        }