Exemplo n.º 1
0
        public void Arrange()
        {
            BaseArrange();

            ImportLearnerDetail        = CreateImportLearnerDetail(44444);
            _secondImportLearnerDetail = CreateImportLearnerDetail(55555);
        }
Exemplo n.º 2
0
        private ImportLearnerDetailResult CheckMissingMandatoryFields(ImportLearnerDetail request)
        {
            _logger.LogDebug("Handling Import Learner Detail Request - Checking for missing mandatory fields");

            var result = new ImportLearnerDetailResult
            {
                Uln     = request.Uln,
                StdCode = request.StdCode,
                Outcome = "ErrorMissingMandatoryField",
                Errors  = new List <string>()
            };

            AddMissingMandatoryFieldError(result, request.Source, nameof(request.Source));
            AddMissingMandatoryFieldError(result, request.Ukprn, nameof(request.Ukprn));
            AddMissingMandatoryFieldError(result, request.Uln, nameof(request.Uln));
            AddMissingMandatoryFieldError(result, request.StdCode, nameof(request.StdCode));
            AddMissingMandatoryFieldError(result, request.FundingModel, nameof(request.FundingModel));
            AddMissingMandatoryFieldError(result, request.GivenNames, nameof(request.GivenNames));
            AddMissingMandatoryFieldError(result, request.FamilyName, nameof(request.FamilyName));
            AddMissingMandatoryFieldError(result, request.LearnStartDate, nameof(request.LearnStartDate));
            AddMissingMandatoryFieldError(result, request.PlannedEndDate, nameof(request.PlannedEndDate));
            AddMissingMandatoryFieldError(result, request.CompletionStatus, nameof(request.CompletionStatus));
            AddMissingMandatoryFieldError(result, request.LearnRefNumber, nameof(request.LearnRefNumber));
            AddMissingMandatoryFieldError(result, request.DelLocPostCode, nameof(request.DelLocPostCode));

            return(result.Errors.Count > 0 ? result : null);
        }
Exemplo n.º 3
0
        private async Task <string> UpdateIlrRecord(ImportLearnerDetail importLearnerDetail, bool isUpdate, Ilr currentLearner = null)
        {
            _logger.LogDebug("Handling Import Learner Detail Request - Update Ilr");

            // for an update to certain fields if the request is null then the currrent value will be
            // retained, otherwise the request value will be used
            await _ilrRepository.Update(new Ilr
            {
                Source           = importLearnerDetail.Source,
                UkPrn            = importLearnerDetail.Ukprn.Value,
                Uln              = importLearnerDetail.Uln.Value,
                StdCode          = importLearnerDetail.StdCode.Value,
                FundingModel     = importLearnerDetail.FundingModel,
                GivenNames       = importLearnerDetail.GivenNames,
                FamilyName       = importLearnerDetail.FamilyName,
                EpaOrgId         = RetainCurrentValueForNullUpdate(currentLearner?.EpaOrgId, importLearnerDetail.EpaOrgId, isUpdate),
                LearnStartDate   = importLearnerDetail.LearnStartDate.Value,
                PlannedEndDate   = importLearnerDetail.PlannedEndDate,
                CompletionStatus = importLearnerDetail.CompletionStatus,
                LearnRefNumber   = importLearnerDetail.LearnRefNumber,
                DelLocPostCode   = importLearnerDetail.DelLocPostCode,
                LearnActEndDate  = RetainCurrentValueForNullUpdate(currentLearner?.LearnActEndDate, importLearnerDetail.LearnActEndDate, isUpdate),
                WithdrawReason   = RetainCurrentValueForNullUpdate(currentLearner?.WithdrawReason, importLearnerDetail.WithdrawReason, isUpdate),
                Outcome          = RetainCurrentValueForNullUpdate(currentLearner?.Outcome, importLearnerDetail.Outcome, isUpdate),
                AchDate          = RetainCurrentValueForNullUpdate(currentLearner?.AchDate, importLearnerDetail.AchDate, isUpdate),
                OutGrade         = RetainCurrentValueForNullUpdate(currentLearner?.OutGrade, importLearnerDetail.OutGrade, isUpdate)
            });

            return($"{(isUpdate ? "Updated" : "Replaced")}LearnerDetail");
        }
Exemplo n.º 4
0
        private async Task <string> CreateIlrRecord(ImportLearnerDetail importLearnerDetail)
        {
            _logger.LogDebug("Handling Import Learner Detail Request - Create Ilr");

            await _ilrRepository.Create(new Ilr
            {
                Source           = importLearnerDetail.Source,
                UkPrn            = importLearnerDetail.Ukprn.Value,
                Uln              = importLearnerDetail.Uln.Value,
                StdCode          = importLearnerDetail.StdCode.Value,
                FundingModel     = importLearnerDetail.FundingModel,
                GivenNames       = importLearnerDetail.GivenNames,
                FamilyName       = importLearnerDetail.FamilyName,
                EpaOrgId         = importLearnerDetail.EpaOrgId,
                LearnStartDate   = importLearnerDetail.LearnStartDate.Value,
                PlannedEndDate   = importLearnerDetail.PlannedEndDate,
                CompletionStatus = importLearnerDetail.CompletionStatus,
                LearnRefNumber   = importLearnerDetail.LearnRefNumber,
                DelLocPostCode   = importLearnerDetail.DelLocPostCode,
                LearnActEndDate  = importLearnerDetail.LearnActEndDate,
                WithdrawReason   = importLearnerDetail.WithdrawReason,
                Outcome          = importLearnerDetail.Outcome,
                AchDate          = importLearnerDetail.AchDate,
                OutGrade         = importLearnerDetail.OutGrade
            });

            return("CreatedLearnerDetail");
        }
Exemplo n.º 5
0
        private async Task <string> HandleSameSourceRequest(Ilr learner, ImportLearnerDetail importLearnerDetail, CancellationToken cancellationToken)
        {
            if (importLearnerDetail.Ukprn == learner.UkPrn)
            {
                if (importLearnerDetail.LearnActEndDate != null && importLearnerDetail.LearnStartDate == importLearnerDetail.LearnActEndDate)
                {
                    return("IgnoreLearnActEndDateSameAsLearnStartDate");
                }

                if (importLearnerDetail.PlannedEndDate == learner.PlannedEndDate && importLearnerDetail.LearnStartDate == learner.LearnStartDate)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, true, learner));
                }

                if (importLearnerDetail.LearnStartDate > learner.LearnStartDate)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, false));
                }
            }
            else
            {
                var certificate = await _certificateRepository.GetCertificate(importLearnerDetail.Uln.Value, importLearnerDetail.StdCode.Value);

                if (certificate != null)
                {
                    return("IgnoreUkprnChangedButCertficateAlreadyExists");
                }

                if (importLearnerDetail.FundingModel == 99 && learner.FundingModel != 99)
                {
                    return("IgnoreFundingModelChangedTo99WhenPrevioulsyNot99");
                }

                if (importLearnerDetail.LearnActEndDate == null && learner.LearnActEndDate != null)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, false));
                }

                if (importLearnerDetail.LearnActEndDate != null && importLearnerDetail.PlannedEndDate > learner.PlannedEndDate)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, false));
                }

                if (importLearnerDetail.LearnStartDate > learner.LearnStartDate)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, false));
                }
            }

            return("IgnoreOutOfDate");
        }
Exemplo n.º 6
0
        private async Task <string> HandleRequest(ImportLearnerDetail importLearnerDetail, CancellationToken cancellationToken)
        {
            if (importLearnerDetail.Uln == 9999999999 || importLearnerDetail.Uln == 1000000000)
            {
                return("IgnoreUlnDummyValue");
            }

            var learner = await _ilrRepository.Get(importLearnerDetail.Uln.Value, importLearnerDetail.StdCode.Value);

            if (learner != null)
            {
                return(await HandleExistingLearnerRequest(learner, importLearnerDetail, cancellationToken));
            }

            return(await CreateIlrRecord(importLearnerDetail));
        }
Exemplo n.º 7
0
        private async Task <string> HandleExistingLearnerRequest(Ilr learner, ImportLearnerDetail importLearnerDetail, CancellationToken cancellationToken)
        {
            // the source represents an academic year which should be compared as a number
            var requestSource = int.Parse(importLearnerDetail.Source);
            var learnerSource = int.Parse(learner.Source);

            if (requestSource < learnerSource)
            {
                return("IgnoreSourcePriorToCurrentSource");
            }
            else if (requestSource > learnerSource)
            {
                return(await UpdateIlrRecord(importLearnerDetail, false));
            }

            return(await HandleSameSourceRequest(learner, importLearnerDetail, cancellationToken));
        }
        public void Arrange()
        {
            BaseArrange();

            // Arrange
            ImportLearnerDetail       = CreateImportLearnerDetail(4444, 44444444444, 44);
            SecondImportLearnerDetail = CreateImportLearnerDetail(5555, 55555555555, 55);

            Request = new ImportLearnerDetailRequest
            {
                ImportLearnerDetails = new List <ImportLearnerDetail>
                {
                    ImportLearnerDetail,
                    SecondImportLearnerDetail
                }
            };
        }
Exemplo n.º 9
0
        protected void VerifyIlrReplaced(ImportLearnerDetail importLearnerDetail, Func <Times> times)
        {
            IlrRepository.Verify(r => r.Update(It.IsAny <Ilr>()), times);

            ModifiedIlr.Source.Should().Be(importLearnerDetail.Source);
            ModifiedIlr.UkPrn.Should().Be(importLearnerDetail.Ukprn.Value);
            ModifiedIlr.Uln.Should().Be(importLearnerDetail.Uln.Value);
            ModifiedIlr.StdCode.Should().Be(importLearnerDetail.StdCode.Value);
            ModifiedIlr.FundingModel.Should().Be(importLearnerDetail.FundingModel);
            ModifiedIlr.GivenNames.Should().Be(importLearnerDetail.GivenNames);
            ModifiedIlr.FamilyName.Should().Be(importLearnerDetail.FamilyName);
            ModifiedIlr.EpaOrgId.Should().Be(importLearnerDetail.EpaOrgId);
            ModifiedIlr.LearnStartDate.Should().Be(importLearnerDetail.LearnStartDate.Value);
            ModifiedIlr.PlannedEndDate.Should().Be(importLearnerDetail.PlannedEndDate);
            ModifiedIlr.CompletionStatus.Should().Be(importLearnerDetail.CompletionStatus);
            ModifiedIlr.LearnRefNumber.Should().Be(importLearnerDetail.LearnRefNumber);
            ModifiedIlr.DelLocPostCode.Should().Be(importLearnerDetail.DelLocPostCode);
            ModifiedIlr.LearnActEndDate.Should().Be(importLearnerDetail.LearnActEndDate);
            ModifiedIlr.WithdrawReason.Should().Be(importLearnerDetail.WithdrawReason);
            ModifiedIlr.Outcome.Should().Be(importLearnerDetail.Outcome);
            ModifiedIlr.AchDate.Should().Be(importLearnerDetail.AchDate);
            ModifiedIlr.OutGrade.Should().Be(importLearnerDetail.OutGrade);
        }
        private async Task <string> HandleSameSourceRequest(Ilr learner, ImportLearnerDetail importLearnerDetail, CancellationToken cancellationToken)
        {
            if (importLearnerDetail.Ukprn == learner.UkPrn)
            {
                if (importLearnerDetail.LearnActEndDate != null && importLearnerDetail.LearnStartDate == importLearnerDetail.LearnActEndDate)
                {
                    return("IgnoreLearnActEndDateSameAsLearnStartDate");
                }

                if (importLearnerDetail.PlannedEndDate == learner.PlannedEndDate && importLearnerDetail.LearnStartDate == learner.LearnStartDate)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, true, learner));
                }

                if (importLearnerDetail.LearnStartDate > learner.LearnStartDate)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, false));
                }
            }
            else
            {
                var certificate = await _certificateRepository.GetCertificate(importLearnerDetail.Uln.Value, importLearnerDetail.StdCode.Value);

                if (certificate != null)
                {
                    var ignore = true;

                    if (certificate.Status == CertificateStatus.Deleted || certificate.Status == CertificateStatus.Draft)
                    {
                        ignore = false;
                    }
                    else
                    {
                        var certificateData = JsonConvert.DeserializeObject <CertificateData>(certificate.CertificateData);
                        if (certificate.Status == CertificateStatus.Submitted && certificateData.OverallGrade == CertificateGrade.Fail)
                        {
                            ignore = false;
                        }
                    }

                    if (ignore)
                    {
                        return("IgnoreUkprnChangedButCertficateAlreadyExists");
                    }
                }

                if (importLearnerDetail.FundingModel == 99 && learner.FundingModel != 99)
                {
                    return("IgnoreFundingModelChangedTo99WhenPrevioulsyNot99");
                }

                if (importLearnerDetail.LearnActEndDate == null && learner.LearnActEndDate != null)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, false));
                }

                if (importLearnerDetail.LearnActEndDate != null && importLearnerDetail.PlannedEndDate > learner.PlannedEndDate)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, false));
                }

                if (importLearnerDetail.LearnStartDate > learner.LearnStartDate)
                {
                    return(await UpdateIlrRecord(importLearnerDetail, false));
                }
            }

            return("IgnoreOutOfDate");
        }