private async Task <ActionResult> RetrieveDataReturnsSubmissionResults(int year, Guid schemeId, DataReturnSubmissionsHistoryOrderBy orderBy)
        {
            if (Request != null &&
                !Request.IsAjaxRequest())
            {
                throw new InvalidOperationException();
            }

            if (!ModelState.IsValid)
            {
                return(Json(null, JsonRequestBehavior.AllowGet));
            }
            using (var client = apiClient())
            {
                try
                {
                    var schemeData = await client.SendAsync(User.GetAccessToken(), new GetSchemeById(schemeId));

                    var getDataReturnSubmissionsHistoryResults = new GetDataReturnSubmissionsHistoryResults(
                        schemeId, schemeData.OrganisationId, year, ordering: orderBy, includeSummaryData: true, compareEeeOutputData: true);

                    DataReturnSubmissionsHistoryResult searchResults = await client.SendAsync(User.GetAccessToken(), getDataReturnSubmissionsHistoryResults);

                    var model = new DataReturnSubmissionsResultsViewModel
                    {
                        Year    = year,
                        Scheme  = schemeId,
                        Results = searchResults.Data,
                        OrderBy = orderBy
                    };

                    return(PartialView("_dataReturnSubmissionsResults", model));
                }
                catch (ApiBadRequestException ex)
                {
                    this.HandleBadRequest(ex);
                    throw;
                }
            }
        }
Exemple #2
0
        public async void GetDataReturnSubmissionsHistoryResultHandler_ReturnsSubmissionDataCount()
        {
            // Arrange
            IGetDataReturnSubmissionsHistoryResultsDataAccess resultsDataAccess = CreateFakeResultsDataAccess();
            var submissionsDataAccess        = A.Fake <IDataReturnSubmissionsDataAccess>();
            IWeeeAuthorization authorization = A.Fake <IWeeeAuthorization>();
            var dataReturnVersionComparer    = A.Fake <IDataReturnVersionComparer>();

            GetDataReturnSubmissionsHistoryResultsHandler handler =
                new GetDataReturnSubmissionsHistoryResultsHandler(authorization, resultsDataAccess,
                                                                  submissionsDataAccess, dataReturnVersionComparer);

            GetDataReturnSubmissionsHistoryResults request = new GetDataReturnSubmissionsHistoryResults(A.Dummy <Guid>(), A.Dummy <Guid>(), A.Dummy <int>());

            request.Ordering = DataReturnSubmissionsHistoryOrderBy.SubmissionDateAscending;

            // Act
            DataReturnSubmissionsHistoryResult results = await handler.HandleAsync(request);

            // Assert
            Assert.Equal(2, results.ResultCount);
        }
Exemple #3
0
        public async Task GetDataReturnSubmissionsHistoryResultHandler_RequestByExternalUser_ReturnDataReturnSubmissionsHistoryData()
        {
            // Arrange
            IGetDataReturnSubmissionsHistoryResultsDataAccess resultsDataAccess = CreateFakeResultsDataAccess();
            var submissionsDataAccess        = A.Fake <IDataReturnSubmissionsDataAccess>();
            var dataReturnVersionComparer    = A.Fake <IDataReturnVersionComparer>();
            IWeeeAuthorization authorization = A.Fake <IWeeeAuthorization>();

            GetDataReturnSubmissionsHistoryResultsHandler handler =
                new GetDataReturnSubmissionsHistoryResultsHandler(authorization, resultsDataAccess,
                                                                  submissionsDataAccess, dataReturnVersionComparer);

            GetDataReturnSubmissionsHistoryResults request = new GetDataReturnSubmissionsHistoryResults(A.Dummy <Guid>(), A.Dummy <Guid>(), A.Dummy <int>());

            request.Ordering = DataReturnSubmissionsHistoryOrderBy.SubmissionDateAscending;

            // Act
            DataReturnSubmissionsHistoryResult results = await handler.HandleAsync(request);

            // Assert
            A.CallTo(() => authorization.EnsureInternalOrOrganisationAccess(A <Guid> ._)).MustHaveHappened();
            Assert.Equal(2, results.Data.Count);
        }
Exemple #4
0
        public async void GetDataReturnSubmissionsHistoryResultHandler_MapsPropertiesToDataReturnSubmissionsHistoryResultObject()
        {
            // Arrange
            var resultsDataAccess         = A.Fake <IGetDataReturnSubmissionsHistoryResultsDataAccess>();
            var submissionsDataAccess     = A.Fake <IDataReturnSubmissionsDataAccess>();
            var authorization             = A.Fake <IWeeeAuthorization>();
            var dataReturnVersionComparer = A.Fake <IDataReturnVersionComparer>();

            var handler = new GetDataReturnSubmissionsHistoryResultsHandler(authorization, resultsDataAccess,
                                                                            submissionsDataAccess, dataReturnVersionComparer);

            var request = new GetDataReturnSubmissionsHistoryResults(A.Dummy <Guid>(), A.Dummy <Guid>(), A.Dummy <int>());

            request.Ordering = DataReturnSubmissionsHistoryOrderBy.SubmissionDateAscending;

            var schemeId           = Guid.NewGuid();
            var organisationId     = Guid.NewGuid();
            var complianceYear     = 2016;
            var dataReturnUploadId = Guid.NewGuid();
            var fileName           = "TestFileName";
            var quarter            = QuarterType.Q3;
            var submittedBy        = "TestUser";
            var submissionDateTime = new DateTime(2016, 1, 1);

            var dataReturnVersionId = Guid.NewGuid();
            var dataReturnVersion   = A.Fake <DataReturnVersion>();

            A.CallTo(() => dataReturnVersion.Id)
            .Returns(dataReturnVersionId);

            var eeeOutputB2b = 1;
            var eeeOutputB2c = 2;

            var weeeCollectedB2b = 3;
            var weeeCollectedB2c = 4;

            var weeeDeliveredB2b = 5;
            var weeeDeliveredB2c = 6;

            var data = new DataReturnSubmissionsData
            {
                SchemeId           = schemeId,
                OrganisationId     = organisationId,
                ComplianceYear     = complianceYear,
                DataReturnUploadId = dataReturnUploadId,
                FileName           = fileName,
                Quarter            = quarter,
                SubmittedBy        = submittedBy,
                SubmissionDateTime = submissionDateTime,
                DataReturnVersion  = dataReturnVersion,
                EeeOutputB2b       = eeeOutputB2b,
                EeeOutputB2c       = eeeOutputB2c,
                WeeeCollectedB2b   = weeeCollectedB2b,
                WeeeCollectedB2c   = weeeCollectedB2c,
                WeeeDeliveredB2b   = weeeDeliveredB2b,
                WeeeDeliveredB2c   = weeeDeliveredB2c
            };

            A.CallTo(() => resultsDataAccess.GetDataReturnSubmissionsHistory(A <Guid> ._, A <int> ._, A <DataReturnSubmissionsHistoryOrderBy> ._, A <bool> ._))
            .Returns(new List <DataReturnSubmissionsData> {
                data
            });

            // Act
            DataReturnSubmissionsHistoryResult results = await handler.HandleAsync(request);

            // Assert
            Assert.Single(results.Data);

            var result = results.Data[0];

            Assert.Equal(schemeId, result.SchemeId);
            Assert.Equal(organisationId, result.OrganisationId);
            Assert.Equal(complianceYear, result.ComplianceYear);
            Assert.Equal(dataReturnUploadId, result.DataReturnUploadId);
            Assert.Equal(fileName, result.FileName);
            Assert.Equal(quarter, result.Quarter);
            Assert.Equal(submissionDateTime, result.SubmissionDateTime);
            Assert.Equal(dataReturnVersionId, result.DataReturnVersionId);
            Assert.Equal(eeeOutputB2b, result.EeeOutputB2b);
            Assert.Equal(eeeOutputB2c, result.EeeOutputB2c);
            Assert.Equal(weeeCollectedB2b, result.WeeeCollectedB2b);
            Assert.Equal(weeeCollectedB2c, result.WeeeCollectedB2c);
            Assert.Equal(weeeDeliveredB2b, result.WeeeDeliveredB2b);
            Assert.Equal(weeeDeliveredB2c, result.WeeeDeliveredB2c);
        }