public override void Setup()
        {
            _tokenServiceClient = Substitute.For <ITokenServiceClient>();

            _configuration = new ResultsAndCertificationConfiguration
            {
                ResultsAndCertificationInternalApiSettings = new ResultsAndCertificationInternalApiSettings {
                    Uri = "http://tlevel.api.com"
                }
            };

            _mockHttpResult = new ChangeResultResponse
            {
                IsSuccess = true,
                Uln       = 1234567890,
                ProfileId = 7
            };

            _model = new ChangeResultRequest
            {
                AoUkprn       = 89562378,
                ProfileId     = 7,
                ResultId      = 1,
                LookupId      = 3,
                ComponentType = Common.Enum.ComponentType.Core,
                PerformedBy   = "Test User"
            };
        }
Example #2
0
        public async Task WhenAsync(ChangeResultRequest request)
        {
            if (_actualResult != null)
            {
                return;
            }

            _actualResult = await ResultService.ChangeResultAsync(request);
        }
        public async Task <ChangeResultResponse> ChangeResultAsync(ChangeResultRequest request)
        {
            if (request.ComponentType != ComponentType.Core)
            {
                return new ChangeResultResponse {
                           IsSuccess = false
                }
            }
            ;

            var existingPathwayResult = await _pathwayResultRepository.GetFirstOrDefaultAsync(pr => pr.Id == request.ResultId && pr.EndDate == null && pr.IsOptedin &&
                                                                                              pr.TqPathwayAssessment.EndDate == null && pr.IsOptedin &&
                                                                                              pr.TqPathwayAssessment.TqRegistrationPathway.TqRegistrationProfileId == request.ProfileId &&
                                                                                              pr.TqPathwayAssessment.TqRegistrationPathway.Status == RegistrationPathwayStatus.Active &&
                                                                                              pr.TqPathwayAssessment.TqRegistrationPathway.TqProvider.TqAwardingOrganisation.TlAwardingOrganisaton.UkPrn == request.AoUkprn);

            if (existingPathwayResult == null)
            {
                _logger.LogWarning(LogEvent.NoDataFound, $"No record found to change Pathway Result for ProfileId = {request.ProfileId} and ResultId = {request.ResultId}. Method: ChangeResultAsync({request})");

                return(new ChangeResultResponse {
                    IsSuccess = false
                });
            }

            var pathwayResultsToUpdate = new List <TqPathwayResult>();

            existingPathwayResult.IsOptedin  = false;
            existingPathwayResult.EndDate    = DateTime.UtcNow;
            existingPathwayResult.ModifiedBy = request.PerformedBy;
            existingPathwayResult.ModifiedOn = DateTime.UtcNow;

            pathwayResultsToUpdate.Add(existingPathwayResult);

            if (request.LookupId.HasValue && request.LookupId > 0)
            {
                pathwayResultsToUpdate.Add(new TqPathwayResult
                {
                    TqPathwayAssessmentId = existingPathwayResult.TqPathwayAssessmentId,
                    TlLookupId            = request.LookupId.Value,
                    IsOptedin             = true,
                    StartDate             = DateTime.UtcNow,
                    EndDate      = null,
                    IsBulkUpload = false,
                    CreatedBy    = request.PerformedBy
                });
            }

            var isSuccess = await _pathwayResultRepository.UpdateManyAsync(pathwayResultsToUpdate) > 0;

            return(new ChangeResultResponse {
                Uln = request.Uln, ProfileId = request.ProfileId, IsSuccess = isSuccess
            });
        }
Example #4
0
        public async Task Then_Expected_Results_Are_Returned(ChangeResultRequest request, ChangeResultResponse expectedResult)
        {
            var assessment = _pathwayAssessments.FirstOrDefault(x => x.TqRegistrationPathway.TqRegistrationProfileId == request.ProfileId && x.IsOptedin && x.EndDate == null);

            if (assessment != null)
            {
                request.Uln = assessment.TqRegistrationPathway.TqRegistrationProfile.UniqueLearnerNumber;
                var resultId = _pathwayResults.FirstOrDefault(x => x.TqPathwayAssessmentId == assessment.Id && x.IsOptedin && x.EndDate == null)?.Id;
                if (resultId != null)
                {
                    request.ResultId = resultId.Value;
                }
            }

            await WhenAsync(request);

            // Assert
            _actualResult.IsSuccess.Should().Be(expectedResult.IsSuccess);
            if (_actualResult.IsSuccess)
            {
                _actualResult.Uln.Should().Be(expectedResult.Uln);
                _actualResult.ProfileId.Should().Be(expectedResult.ProfileId);
            }
        }
        public async Task <ChangeResultResponse> ChangeResultAsync(ChangeResultRequest model)
        {
            var requestUri = ApiConstants.ChangeResultUri;

            return(await PutAsync <ChangeResultRequest, ChangeResultResponse>(requestUri, model));
        }
 public async Task <ChangeResultResponse> ChangeResultAsync(ChangeResultRequest request)
 {
     return(await _resultService.ChangeResultAsync(request));
 }