public void Has_Central_Should_Return_CorrectResult(bool isCentralUser)
        {
            var username = DataProvider.Get <string>();

            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var reportingFrequency = ReportingFrequency.Monthly;

                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations(
                    stateReportingFrequency: reportingFrequency,
                    zoneReportingFrequency: ReportingFrequency.Monthly);
                var central = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Central).Value;
                var nsw     = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;

                var organizationUser1 = new TestObjectBuilder <OrganizationUser>()
                                        .SetArgument(o => o.Username, username)
                                        .SetArgument(o => o.Organization, isCentralUser?central: nsw)
                                        .BuildAndPersist(s);


                new UserContextBuilder()
                .SetUsername(username)
                .AddClaims(TestHelper.GetOrganizationClaims(username, new[] { organizationUser1 }))
                .SetCurrentPrincipal();

                return(new { organizationUser1 });
            });

            var result = NsbWebTest.Act(AssemblySetupFixture.WebTestContainer,
                                        c => c.GetInstance <OrganizationUserQueryService>()
                                        .HasCentralAccess(testParams.organizationUser1.Username));

            result.Should().Be(isCentralUser);
        }
        public void GetManagedOrganizationViewModel_For_Zone_Should_Return_CorrectResult()
        {
            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var reportingFrequency = ReportingFrequency.Monthly;

                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations(
                    stateReportingFrequency: reportingFrequency,
                    zoneReportingFrequency: ReportingFrequency.Monthly);
                var zone = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswZoneOne).Value;

                return(new
                {
                    organizations,
                    zone
                });
            });

            var result = NsbWebTest.Act(AssemblySetupFixture.WebTestContainer,
                                        c => c.GetInstance <OrganizationQueryService>()
                                        .GetOrganizationViewModel(testParams.zone.Id));

            result.Should().NotBeNull();
            result.ManagedOrganizations.Count().Should().Be(2);
        }
        public void GetMyOrganizations_For_CentralUser_Should_Return_CorrectResult()
        {
            var username   = DataProvider.Get <string>();
            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var reportingFrequency = ReportingFrequency.Monthly;

                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations(
                    stateReportingFrequency: reportingFrequency,
                    zoneReportingFrequency: ReportingFrequency.Monthly);

                TestHelper.SetUserAccessAllOrganizationsClaim(username);

                return(new
                {
                    organizations,
                });
            });

            var result = NsbWebTest.Act(AssemblySetupFixture.WebTestContainer,
                                        c => c.GetInstance <OrganizationQueryService>()
                                        .GetMyOrganizations());

            result.Should().NotBeNull();
            result.Length.Should().Be(testParams.organizations.Count);
        }
        public void GetManagedOrganizationIds_For_Central_Should_Return_CorrectResult()
        {
            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var reportingFrequency = ReportingFrequency.Monthly;

                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations(
                    stateReportingFrequency: reportingFrequency,
                    zoneReportingFrequency: ReportingFrequency.Monthly);
                var central = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Central).Value;

                return(new
                {
                    organizations,
                    central
                });
            });

            var result = NsbWebTest.Act(AssemblySetupFixture.WebTestContainer,
                                        c => c.GetInstance <OrganizationQueryService>()
                                        .GetManagedOrganizationIds(testParams.central.Id));

            result.Should().NotBeNull();
            result.Length.Should().Be(7);
        }
        public void GetManagedOrganizationsAsExpected()
        {
            DateTimeDbTestExtensions.SetUtcNowToRandomDate();
            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations();

                var central        = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Central).Value;
                var nswState       = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;
                var victoriaState  = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.VictoriaState).Value;
                var footscray      = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Footscray).Value;
                var truganinaNorth = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.TruganinaNorth).Value;

                return(new
                {
                    central,
                    victoriaState,
                    expectedCentralManagedOrganizations = new List <Organization> {
                        victoriaState, nswState
                    },
                    expectedVictoriaStateManagedOrganizations = new List <Organization> {
                        footscray, truganinaNorth
                    },
                });
            });

            var result = Endpoint.Act(AssemblySetupFixture.EndpointTestContainer,
                                      c =>
            {
                var centralManagedOrganizations       = c.GetInstance <IOrganizationService>().GetManagedOrganizations(testParams.central.Id);
                var victoriaStateManagedOrganizations = c.GetInstance <IOrganizationService>().GetManagedOrganizations(testParams.victoriaState.Id);
                return(new
                {
                    centralManagedOrganizations,
                    victoriaStateManagedOrganizations
                });
            });

            result.centralManagedOrganizations.Should()
            .BeEquivalentTo(testParams.expectedCentralManagedOrganizations,
                            x => x.WithStrictOrderingFor(o => o));
            result.victoriaStateManagedOrganizations.Should().BeEquivalentTo(testParams.expectedVictoriaStateManagedOrganizations);
        }
        public void GetMyOrganizations_For_User_Should_Return_CorrectResult(OrganizationType organizationType)
        {
            var username   = DataProvider.Get <string>();
            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var reportingFrequency = ReportingFrequency.Monthly;

                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations(
                    stateReportingFrequency: reportingFrequency,
                    zoneReportingFrequency: ReportingFrequency.Monthly);

                var state = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;
                var unit  = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Footscray).Value;



                var organizationUser1 = new TestObjectBuilder <OrganizationUser>()
                                        .SetArgument(o => o.Username, username)
                                        .SetArgument(o => o.Organization, organizationType == OrganizationType.State? state : unit)
                                        .BuildAndPersist(s);

                new UserContextBuilder()
                .SetUsername(username)
                .AddClaims(TestHelper.GetOrganizationClaims(username, new[] { organizationUser1 }))
                .SetCurrentPrincipal();
                return(new
                {
                    state,
                    unit
                });
            });

            var result = NsbWebTest.Act(AssemblySetupFixture.WebTestContainer,
                                        c => c.GetInstance <OrganizationQueryService>()
                                        .GetMyOrganizations());

            var organizationId = organizationType == OrganizationType.State ? testParams.state.Id : testParams.unit.Id;

            result.Should().NotBeNull();
            result.Where(o => o.Id == organizationId).Should().NotBeNull();
        }
        public void CreateNewPlan_For_State_Unit_SavesMaterialDataCorrectly(
            bool thisPeriodSubmitted,
            bool lastPeriod1Submitted,
            bool lastPeriod2Submitted
            )
        {
            DateTimeDbTestExtensions.SetUtcNowToRandomDate();
            var reportingTerms = ReportingPeriod.GetReportingTerms(reportingFrequency);

            if (reportingTerms.All(o => o != reportingTerm))
            {
                return;
            }

            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations(
                    stateReportingFrequency: reportingFrequency,
                    zoneReportingFrequency: ReportingFrequency.Monthly);

                var nswState  = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;
                var laPerouse = new OrganizationBuilder()
                                .SetDescription("La perouse")
                                .SetOrganizationType(OrganizationType.Unit)
                                .SetReportingFreQuency(ReportingFrequency.Monthly)
                                .SetParent(nswState)
                                .BuildAndPersist(s);

                var lalorPark = new OrganizationBuilder()
                                .SetDescription("Lalor park")
                                .SetOrganizationType(OrganizationType.Unit)
                                .SetReportingFreQuency(ReportingFrequency.Monthly)
                                .SetParent(nswState)
                                .BuildAndPersist(s);

                var description = DataProvider.Get <string>();
                var year        = 2019;
                OrganizationReference organizationRef = nswState;

                var reportingPeriod = new ReportingPeriod(reportingFrequency, reportingTerm, year);
                var expected        = new StateReportBuilder()
                                      .SetDescription(description)
                                      .SetOrganization(organizationRef)
                                      .SetReportingPeriod(new ReportingPeriod(reportingFrequency, reportingPeriod.ReportingTerm,
                                                                              reportingPeriod.Year))
                                      .Build();


                var lastPeriod1 = reportingPeriod.GetReportingPeriodOfPreviousTerm();
                var lastPeriod2 = lastPeriod1.GetReportingPeriodOfPreviousTerm();

                var laPerouseThisPeriodUnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(thisPeriodSubmitted, laPerouse, reportingPeriod, s);
                var laPerouseLastPeriod1UnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod1Submitted, laPerouse, lastPeriod1, s);
                var laPerouseLastPeriod2UnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod2Submitted, laPerouse, lastPeriod2, s);

                var lalorParkThisPeriodUnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(thisPeriodSubmitted, lalorPark, reportingPeriod, s);
                var lalorParkLastPeriod1UnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod1Submitted, lalorPark, lastPeriod1, s);
                var lalorParkLastPeriod2UnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod2Submitted, lalorPark, lastPeriod2, s);

                var allUnitReports = new[]
                {
                    laPerouseThisPeriodUnitReport,
                    laPerouseLastPeriod1UnitReport,
                    laPerouseLastPeriod2UnitReport,
                    lalorParkThisPeriodUnitReport,
                    lalorParkLastPeriod1UnitReport,
                    lalorParkLastPeriod2UnitReport,
                };

                var submittedReports = IntegrationTestStateReportHelper.GetSubmittedReports(allUnitReports, reportingPeriod);

                var expectedBookSaleMaterialData          = IntegrationTestStateReportHelper.GetExpectedMaterialData(submittedReports, nameof(StateReport.BookSaleMaterialData));
                var expectedBookSaleMaterialGeneratedData = expectedBookSaleMaterialData;

                var expectedBookDistributionMaterialData          = IntegrationTestStateReportHelper.GetExpectedMaterialData(submittedReports, nameof(StateReport.BookDistributionMaterialData));
                var expectedBookDistributionMaterialGeneratedData = expectedBookDistributionMaterialData;

                var expectedVhsSaleMaterialData          = IntegrationTestStateReportHelper.GetExpectedMaterialData(submittedReports, nameof(StateReport.VhsSaleMaterialData));
                var expectedVhsSaleMaterialGeneratedData = expectedVhsSaleMaterialData;

                var expectedVhsDistributionMaterialData          = IntegrationTestStateReportHelper.GetExpectedMaterialData(submittedReports, nameof(StateReport.VhsDistributionMaterialData));
                var expectedVhsDistributionMaterialGeneratedData = expectedVhsDistributionMaterialData;

                var expectedEmailDistributionMaterialData          = IntegrationTestStateReportHelper.GetExpectedMaterialData(submittedReports, nameof(StateReport.EmailDistributionMaterialData));
                var expectedEmailDistributionMaterialGeneratedData = expectedEmailDistributionMaterialData;

                var expectedIpdcLeafletDistributionMaterialData          = IntegrationTestStateReportHelper.GetExpectedMaterialData(submittedReports, nameof(StateReport.IpdcLeafletDistributionMaterialData));
                var expectedIpdcLeafletDistributionMaterialGeneratedData = expectedIpdcLeafletDistributionMaterialData;


                return(new
                {
                    description,
                    reportingPeriod,
                    organizationRef,
                    expected,
                    expectedBookSaleMaterialData,
                    expectedBookSaleMaterialGeneratedData,
                    expectedBookDistributionMaterialData,
                    expectedBookDistributionMaterialGeneratedData,
                    expectedVhsSaleMaterialData,
                    expectedVhsSaleMaterialGeneratedData,
                    expectedVhsDistributionMaterialData,
                    expectedVhsDistributionMaterialGeneratedData,
                    expectedEmailDistributionMaterialData,
                    expectedEmailDistributionMaterialGeneratedData,
                    expectedIpdcLeafletDistributionMaterialData,
                    expectedIpdcLeafletDistributionMaterialGeneratedData
                });
            });
            var result = Endpoint.Act(AssemblySetupFixture.EndpointTestContainer,
                                      c =>
            {
                var stateReport = c.GetInstance <IStateReportFactory>()
                                  .CreateNewStatePlan(testParams.description,
                                                      testParams.organizationRef,
                                                      testParams.reportingPeriod.ReportingTerm,
                                                      testParams.reportingPeriod.Year,
                                                      reportingFrequency);
                return(new
                {
                    stateReport
                });
            });

            result.stateReport.Should().NotBeNull();

            result.stateReport.BookSaleMaterialData.Should().BeEquivalentTo(testParams.expectedBookSaleMaterialData);
            result.stateReport.BookSaleMaterialGeneratedData.Should().BeEquivalentTo(testParams.expectedBookSaleMaterialGeneratedData);

            result.stateReport.BookDistributionMaterialData.Should().BeEquivalentTo(testParams.expectedBookDistributionMaterialData);
            result.stateReport.BookDistributionMaterialGeneratedData.Should().BeEquivalentTo(testParams.expectedBookDistributionMaterialGeneratedData);

            result.stateReport.VhsSaleMaterialData.Should().BeEquivalentTo(testParams.expectedVhsSaleMaterialData);
            result.stateReport.VhsSaleMaterialGeneratedData.Should().BeEquivalentTo(testParams.expectedVhsSaleMaterialGeneratedData);

            result.stateReport.VhsDistributionMaterialData.Should().BeEquivalentTo(testParams.expectedVhsDistributionMaterialData);
            result.stateReport.VhsDistributionMaterialGeneratedData.Should().BeEquivalentTo(testParams.expectedVhsDistributionMaterialGeneratedData);

            result.stateReport.EmailDistributionMaterialData.Should().BeEquivalentTo(testParams.expectedEmailDistributionMaterialData);
            result.stateReport.EmailDistributionMaterialGeneratedData.Should().BeEquivalentTo(testParams.expectedEmailDistributionMaterialGeneratedData);

            result.stateReport.IpdcLeafletDistributionMaterialData.Should().BeEquivalentTo(testParams.expectedIpdcLeafletDistributionMaterialData);
            result.stateReport.IpdcLeafletDistributionMaterialGeneratedData.Should().BeEquivalentTo(testParams.expectedIpdcLeafletDistributionMaterialGeneratedData);
        }
        public async Task Handle_Publishes_ExpectedResult()
        {
            DateTimeDbTestExtensions.SetUtcNowToRandomDate();
            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var username      = DataProvider.Get <string>();
                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations();
                var central       = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Central).Value;
                var nswState      = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;
                var nswZone1      = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswZoneOne).Value;
                var lakemba       = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Lakemba).Value;

                var year1 = 2019;
                var year2 = 2020;

                var period1 = new ReportingPeriod(ReportingFrequency.Monthly, ReportingTerm.One, year1);
                var period2 = new ReportingPeriod(ReportingFrequency.Monthly, ReportingTerm.One, year2);

                var period1ReportingData = new ReportDataBuilder().Build();
                var period2ReportingData = new ReportDataBuilder().Build();

                var period1UnitReport =
                    new UnitReport(DataProvider.Get <string>(), lakemba, period1, period1ReportingData);
                s.Save(period1UnitReport);
                var period2UnitReport =
                    new UnitReport(DataProvider.Get <string>(), lakemba, period2, period2ReportingData);
                s.Save(period2UnitReport);

                var period1ZoneReport =
                    new ZoneReport(DataProvider.Get <string>(), nswZone1, period1, period1ReportingData);
                s.Save(period1ZoneReport);
                var period2ZoneReport =
                    new ZoneReport(DataProvider.Get <string>(), nswZone1, period2, period2ReportingData);
                s.Save(period2ZoneReport);

                var period1StateReport =
                    new StateReport(DataProvider.Get <string>(), nswState, period1, period1ReportingData);
                s.Save(period1StateReport);
                var period2StateReport =
                    new StateReport(DataProvider.Get <string>(), nswState, period2, period2ReportingData);
                s.Save(period2StateReport);

                var period1CentralReport =
                    new CentralReport(DataProvider.Get <string>(), central, period1, period1ReportingData);
                s.Save(period1CentralReport);
                var period2CentralReport =
                    new CentralReport(DataProvider.Get <string>(), central, period2, period2ReportingData);
                s.Save(period2CentralReport);

                var reportIds = new[]
                {
                    period1UnitReport.Id, period2UnitReport.Id, period1ZoneReport.Id, period2ZoneReport.Id,
                    period1StateReport.Id, period2StateReport.Id, period1CentralReport.Id, period2CentralReport.Id,
                };
                var expectedReportData = ReportDataCalculator.GetCalculatedReportData(new[] { period2UnitReport },
                                                                                      new[] { period1UnitReport, period2UnitReport }, new[] { period2ZoneReport },
                                                                                      new[] { period1ZoneReport, period2ZoneReport }, new[] { period2StateReport },
                                                                                      new[] { period1StateReport, period2StateReport }, new[] { period2CentralReport },
                                                                                      new[] { period1CentralReport, period2CentralReport });

                return(new
                {
                    username,
                    expectedReportData,
                    cmd = new ConsolidateReportCommand(reportIds),
                });
            });

            var context = await Endpoint.Act <ConsolidateReportCommandHandler>(AssemblySetupFixture.EndpointTestContainer,
                                                                               (h, ctx) =>
            {
                ctx.SetUsernameOnHeader(testParams.username);
                return(h.Handle(testParams.cmd, ctx));
            });

            var evt = context.ExpectPublish <IConsolidateReportSucceeded>();

            evt.ReportIds.Should().BeEquivalentTo(testParams.cmd.ReportIds);
            evt.ReportData.Should().BeEquivalentTo(testParams.expectedReportData);
            evt.Username.Should().BeEquivalentTo(testParams.username);
        }
        public void CreateNewPlan_For_State_Unit_SavesMemberDataCorrectly(
            bool thisPeriodSubmitted,
            bool lastPeriod1Submitted,
            bool lastPeriod2Submitted
            )
        {
            DateTimeDbTestExtensions.SetUtcNowToRandomDate();
            var reportingTerms = ReportingPeriod.GetReportingTerms(reportingFrequency);

            if (reportingTerms.All(o => o != reportingTerm))
            {
                return;
            }

            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations(
                    stateReportingFrequency: reportingFrequency,
                    zoneReportingFrequency: ReportingFrequency.Monthly);

                var nswState  = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;
                var laPerouse = new OrganizationBuilder()
                                .SetDescription("La perouse")
                                .SetOrganizationType(OrganizationType.Unit)
                                .SetReportingFreQuency(ReportingFrequency.Monthly)
                                .SetParent(nswState)
                                .BuildAndPersist(s);

                var lalorPark = new OrganizationBuilder()
                                .SetDescription("Lalor park")
                                .SetOrganizationType(OrganizationType.Unit)
                                .SetReportingFreQuency(ReportingFrequency.Monthly)
                                .SetParent(nswState)
                                .BuildAndPersist(s);

                var description = DataProvider.Get <string>();
                var year        = 2019;
                OrganizationReference organizationRef = nswState;

                var reportingPeriod = new ReportingPeriod(reportingFrequency, reportingTerm, year);
                var expected        = new StateReportBuilder()
                                      .SetDescription(description)
                                      .SetOrganization(organizationRef)
                                      .SetReportingPeriod(new ReportingPeriod(reportingFrequency, reportingPeriod.ReportingTerm,
                                                                              reportingPeriod.Year))
                                      .Build();


                var lastPeriod1 = reportingPeriod.GetReportingPeriodOfPreviousTerm();
                var lastPeriod2 = lastPeriod1.GetReportingPeriodOfPreviousTerm();

                var laPerouseThisPeriodUnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(thisPeriodSubmitted, laPerouse, reportingPeriod, s);
                var laPerouseLastPeriod1UnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod1Submitted, laPerouse, lastPeriod1, s);
                var laPerouseLastPeriod2UnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod2Submitted, laPerouse, lastPeriod2, s);

                var lalorParkThisPeriodUnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(thisPeriodSubmitted, lalorPark, reportingPeriod, s);
                var lalorParkLastPeriod1UnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod1Submitted, lalorPark, lastPeriod1, s);
                var lalorParkLastPeriod2UnitReport =
                    IntegrationTestStateReportHelper.BuildAndPersistUnitReport(lastPeriod2Submitted, lalorPark, lastPeriod2, s);

                var laPerouseUnitReports = new[]
                {
                    laPerouseThisPeriodUnitReport,
                    laPerouseLastPeriod1UnitReport,
                    laPerouseLastPeriod2UnitReport,
                };

                var lalorParkeUnitReports = new[]
                {
                    lalorParkThisPeriodUnitReport,
                    lalorParkLastPeriod1UnitReport,
                    lalorParkLastPeriod2UnitReport,
                };

                var lastSubmittedLapeRouseReport = IntegrationTestStateReportHelper.GetLastSubmittedReport(laPerouseUnitReports, reportingPeriod);
                var lastSubmittedLalorParkReport = IntegrationTestStateReportHelper.GetLastSubmittedReport(lalorParkeUnitReports, reportingPeriod);

                var submittedReports = new[] { lastSubmittedLapeRouseReport, lastSubmittedLalorParkReport }.Where(o => o != null).ToArray();

                var expectedMemberMemberData               = IntegrationTestStateReportHelper.GetExpectedMemberData(submittedReports, nameof(StateReport.MemberMemberData));
                var expectedMemberMemberGeneratedData      = expectedMemberMemberData;
                var expectedAssociateMemberData            = IntegrationTestStateReportHelper.GetExpectedMemberData(submittedReports, nameof(StateReport.AssociateMemberData));
                var expectedAssociateMemberGeneratedData   = expectedAssociateMemberData;
                var expectedPreliminaryMemberData          = IntegrationTestStateReportHelper.GetExpectedMemberData(submittedReports, nameof(StateReport.PreliminaryMemberData));
                var expectedPreliminaryMemberGeneratedData = expectedPreliminaryMemberData;
                var expectedSupporterMemberData            = IntegrationTestStateReportHelper.GetExpectedMemberData(submittedReports, nameof(StateReport.SupporterMemberData));
                var expectedSupporterMemberGeneratedData   = expectedSupporterMemberData;

                return(new
                {
                    description,
                    reportingPeriod,
                    organizationRef,
                    expected,
                    expectedMemberMemberData,
                    expectedMemberMemberGeneratedData,
                    expectedAssociateMemberData,
                    expectedAssociateMemberGeneratedData,
                    expectedPreliminaryMemberData,
                    expectedPreliminaryMemberGeneratedData,
                    expectedSupporterMemberData,
                    expectedSupporterMemberGeneratedData,
                });
            });
            var result = Endpoint.Act(AssemblySetupFixture.EndpointTestContainer,
                                      c =>
            {
                var stateReport = c.GetInstance <IStateReportFactory>()
                                  .CreateNewStatePlan(testParams.description,
                                                      testParams.organizationRef,
                                                      testParams.reportingPeriod.ReportingTerm,
                                                      testParams.reportingPeriod.Year,
                                                      reportingFrequency);
                return(new
                {
                    stateReport
                });
            });

            result.stateReport.Should().NotBeNull();

            //no need to repeat this section for the other field types
            result.stateReport.Should().BeEquivalentTo(testParams.expected, e =>
                                                       e.Excluding(p => p.Id)
                                                       .Excluding(p => p.MemberMemberData)
                                                       .Excluding(p => p.MemberMemberGeneratedData)
                                                       .Excluding(p => p.AssociateMemberData)
                                                       .Excluding(p => p.AssociateMemberGeneratedData)
                                                       .Excluding(p => p.PreliminaryMemberData)
                                                       .Excluding(p => p.PreliminaryMemberGeneratedData)
                                                       .Excluding(p => p.SupporterMemberData)
                                                       .Excluding(p => p.SupporterMemberGeneratedData)

                                                       .Excluding(p => p.WorkerMeetingProgramData)
                                                       .Excluding(p => p.WorkerMeetingProgramGeneratedData)
                                                       .Excluding(p => p.DawahMeetingProgramData)
                                                       .Excluding(p => p.DawahMeetingProgramGeneratedData)
                                                       .Excluding(p => p.StateLeaderMeetingProgramData)
                                                       .Excluding(p => p.StateLeaderMeetingProgramGeneratedData)
                                                       .Excluding(p => p.StateOutingMeetingProgramData)
                                                       .Excluding(p => p.StateOutingMeetingProgramGeneratedData)
                                                       .Excluding(p => p.IftarMeetingProgramData)
                                                       .Excluding(p => p.IftarMeetingProgramGeneratedData)
                                                       .Excluding(p => p.LearningMeetingProgramData)
                                                       .Excluding(p => p.LearningMeetingProgramGeneratedData)
                                                       .Excluding(p => p.SocialDawahMeetingProgramData)
                                                       .Excluding(p => p.SocialDawahMeetingProgramGeneratedData)
                                                       .Excluding(p => p.DawahGroupMeetingProgramData)
                                                       .Excluding(p => p.DawahGroupMeetingProgramGeneratedData)
                                                       .Excluding(p => p.NextGMeetingProgramData)
                                                       .Excluding(p => p.NextGMeetingProgramGeneratedData)

                                                       .Excluding(p => p.CmsMeetingProgramData)
                                                       .Excluding(p => p.CmsMeetingProgramGeneratedData)
                                                       .Excluding(p => p.SmMeetingProgramData)
                                                       .Excluding(p => p.SmMeetingProgramGeneratedData)
                                                       .Excluding(p => p.MemberMeetingProgramData)
                                                       .Excluding(p => p.MemberMeetingProgramGeneratedData)
                                                       .Excluding(p => p.TafsirMeetingProgramData)
                                                       .Excluding(p => p.TafsirMeetingProgramGeneratedData)
                                                       .Excluding(p => p.UnitMeetingProgramData)
                                                       .Excluding(p => p.UnitMeetingProgramGeneratedData)
                                                       .Excluding(p => p.FamilyVisitMeetingProgramData)
                                                       .Excluding(p => p.FamilyVisitMeetingProgramGeneratedData)
                                                       .Excluding(p => p.EidReunionMeetingProgramData)
                                                       .Excluding(p => p.EidReunionMeetingProgramGeneratedData)
                                                       .Excluding(p => p.BbqMeetingProgramData)
                                                       .Excluding(p => p.BbqMeetingProgramGeneratedData)
                                                       .Excluding(p => p.GatheringMeetingProgramData)
                                                       .Excluding(p => p.GatheringMeetingProgramGeneratedData)
                                                       .Excluding(p => p.OtherMeetingProgramData)
                                                       .Excluding(p => p.OtherMeetingProgramGeneratedData)

                                                       .Excluding(p => p.GroupStudyTeachingLearningProgramData)
                                                       .Excluding(p => p.GroupStudyTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.StudyCircleTeachingLearningProgramData)
                                                       .Excluding(p => p.StudyCircleTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.PracticeDarsTeachingLearningProgramData)
                                                       .Excluding(p => p.PracticeDarsTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.StateLearningCampTeachingLearningProgramData)
                                                       .Excluding(p => p.StateLearningCampTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.QuranStudyTeachingLearningProgramData)
                                                       .Excluding(p => p.QuranStudyTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.QuranClassTeachingLearningProgramData)
                                                       .Excluding(p => p.QuranClassTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.MemorizingAyatTeachingLearningProgramData)
                                                       .Excluding(p => p.MemorizingAyatTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.StateLearningSessionTeachingLearningProgramData)
                                                       .Excluding(p => p.StateLearningSessionTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.StateQiyamulLailTeachingLearningProgramData)
                                                       .Excluding(p => p.StateQiyamulLailTeachingLearningProgramGeneratedData)

                                                       .Excluding(p => p.StudyCircleForAssociateMemberTeachingLearningProgramData)
                                                       .Excluding(p => p.StudyCircleForAssociateMemberTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.HadithTeachingLearningProgramData)
                                                       .Excluding(p => p.HadithTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.WeekendIslamicSchoolTeachingLearningProgramData)
                                                       .Excluding(p => p.WeekendIslamicSchoolTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.MemorizingHadithTeachingLearningProgramData)
                                                       .Excluding(p => p.MemorizingHadithTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.MemorizingDoaTeachingLearningProgramData)
                                                       .Excluding(p => p.MemorizingDoaTeachingLearningProgramGeneratedData)
                                                       .Excluding(p => p.OtherTeachingLearningProgramData)
                                                       .Excluding(p => p.OtherTeachingLearningProgramGeneratedData)

                                                       .Excluding(p => p.BookSaleMaterialData)
                                                       .Excluding(p => p.BookSaleMaterialGeneratedData)
                                                       .Excluding(p => p.BookDistributionMaterialData)
                                                       .Excluding(p => p.BookDistributionMaterialGeneratedData)
                                                       .Excluding(p => p.BookLibraryStockData)
                                                       .Excluding(p => p.BookLibraryStockGeneratedData)
                                                       .Excluding(p => p.OtherSaleMaterialData)
                                                       .Excluding(p => p.OtherSaleMaterialGeneratedData)
                                                       .Excluding(p => p.OtherDistributionMaterialData)
                                                       .Excluding(p => p.OtherDistributionMaterialGeneratedData)
                                                       .Excluding(p => p.OtherLibraryStockData)
                                                       .Excluding(p => p.OtherLibraryStockGeneratedData)
                                                       .Excluding(p => p.VhsSaleMaterialData)
                                                       .Excluding(p => p.VhsSaleMaterialGeneratedData)
                                                       .Excluding(p => p.VhsDistributionMaterialData)
                                                       .Excluding(p => p.VhsDistributionMaterialGeneratedData)
                                                       .Excluding(p => p.VhsLibraryStockData)
                                                       .Excluding(p => p.VhsLibraryStockGeneratedData)
                                                       .Excluding(p => p.EmailDistributionMaterialData)
                                                       .Excluding(p => p.EmailDistributionMaterialGeneratedData)
                                                       .Excluding(p => p.IpdcLeafletDistributionMaterialData)
                                                       .Excluding(p => p.IpdcLeafletDistributionMaterialGeneratedData)
                                                       .Excluding(p => p.BaitulMalFinanceData)
                                                       .Excluding(p => p.BaitulMalFinanceGeneratedData)
                                                       .Excluding(p => p.ADayMasjidProjectFinanceData)
                                                       .Excluding(p => p.ADayMasjidProjectFinanceGeneratedData)
                                                       .Excluding(p => p.MasjidTableBankFinanceData)
                                                       .Excluding(p => p.MasjidTableBankFinanceGeneratedData)


                                                       .Excluding(p => p.QardeHasanaSocialWelfareData)
                                                       .Excluding(p => p.QardeHasanaSocialWelfareGeneratedData)
                                                       .Excluding(p => p.PatientVisitSocialWelfareData)
                                                       .Excluding(p => p.PatientVisitSocialWelfareGeneratedData)
                                                       .Excluding(p => p.SocialVisitSocialWelfareData)
                                                       .Excluding(p => p.SocialVisitSocialWelfareGeneratedData)
                                                       .Excluding(p => p.TransportSocialWelfareData)
                                                       .Excluding(p => p.TransportSocialWelfareGeneratedData)
                                                       .Excluding(p => p.ShiftingSocialWelfareData)
                                                       .Excluding(p => p.ShiftingSocialWelfareGeneratedData)
                                                       .Excluding(p => p.ShoppingSocialWelfareData)
                                                       .Excluding(p => p.ShoppingSocialWelfareGeneratedData)
                                                       .Excluding(p => p.FoodDistributionSocialWelfareData)
                                                       .Excluding(p => p.FoodDistributionSocialWelfareGeneratedData)
                                                       .Excluding(p => p.CleanUpAustraliaSocialWelfareData)
                                                       .Excluding(p => p.CleanUpAustraliaSocialWelfareGeneratedData)
                                                       .Excluding(p => p.OtherSocialWelfareData)
                                                       .Excluding(p => p.OtherSocialWelfareGeneratedData)

                                                       );

            result.stateReport.MemberMemberData.Should().BeEquivalentTo(testParams.expectedMemberMemberData);
            result.stateReport.MemberMemberGeneratedData.Should().BeEquivalentTo(testParams.expectedMemberMemberGeneratedData);

            result.stateReport.AssociateMemberData.Should().BeEquivalentTo(testParams.expectedAssociateMemberData);
            result.stateReport.AssociateMemberGeneratedData.Should().BeEquivalentTo(testParams.expectedAssociateMemberGeneratedData);

            result.stateReport.PreliminaryMemberData.Should().BeEquivalentTo(testParams.expectedPreliminaryMemberData);
            result.stateReport.PreliminaryMemberGeneratedData.Should().BeEquivalentTo(testParams.expectedPreliminaryMemberGeneratedData);

            result.stateReport.SupporterMemberData.Should().BeEquivalentTo(testParams.expectedSupporterMemberData);
            result.stateReport.SupporterMemberGeneratedData.Should().BeEquivalentTo(testParams.expectedSupporterMemberGeneratedData);
        }
        public void GetConsolidatedReportData_Returns_ExpectedReportData()
        {
            DateTimeDbTestExtensions.SetUtcNowToRandomDate();
            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer, s =>
            {
                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations();
                var central       = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Central).Value;
                var nswState      = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;
                var nswZone1      = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswZoneOne).Value;
                var lakemba       = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Lakemba).Value;

                var year1 = 2019;
                var year2 = 2020;

                var period1 = new ReportingPeriod(ReportingFrequency.Monthly, ReportingTerm.One, year1);
                var period2 = new ReportingPeriod(ReportingFrequency.Monthly, ReportingTerm.One, year2);

                var period1ReportingData = new ReportDataBuilder().Build();
                var period2ReportingData = new ReportDataBuilder().Build();

                var period1UnitReport =
                    new UnitReport(DataProvider.Get <string>(), lakemba, period1, period1ReportingData);
                s.Save(period1UnitReport);
                var period2UnitReport =
                    new UnitReport(DataProvider.Get <string>(), lakemba, period2, period2ReportingData);
                s.Save(period2UnitReport);

                var period1ZoneReport =
                    new ZoneReport(DataProvider.Get <string>(), nswZone1, period1, period1ReportingData);
                s.Save(period1ZoneReport);
                var period2ZoneReport =
                    new ZoneReport(DataProvider.Get <string>(), nswZone1, period2, period2ReportingData);
                s.Save(period2ZoneReport);

                var period1StateReport =
                    new StateReport(DataProvider.Get <string>(), nswState, period1, period1ReportingData);
                s.Save(period1StateReport);
                var period2StateReport =
                    new StateReport(DataProvider.Get <string>(), nswState, period2, period2ReportingData);
                s.Save(period2StateReport);

                var period1CentralReport =
                    new CentralReport(DataProvider.Get <string>(), central, period1, period1ReportingData);
                s.Save(period1CentralReport);
                var period2CentralReport =
                    new CentralReport(DataProvider.Get <string>(), central, period2, period2ReportingData);
                s.Save(period2CentralReport);

                var reportIds = new[]
                {
                    period1UnitReport.Id, period2UnitReport.Id, period1ZoneReport.Id, period2ZoneReport.Id,
                    period1StateReport.Id, period2StateReport.Id, period1CentralReport.Id, period2CentralReport.Id,
                };
                var expectedReportData = ReportDataCalculator.GetCalculatedReportData(new[] { period2UnitReport },
                                                                                      new[] { period1UnitReport, period2UnitReport }, new[] { period2ZoneReport },
                                                                                      new[] { period1ZoneReport, period2ZoneReport }, new[] { period2StateReport },
                                                                                      new[] { period1StateReport, period2StateReport }, new[] { period2CentralReport },
                                                                                      new[] { period1CentralReport, period2CentralReport });
                return(new { reportIds, expectedReportData });
            });
            var result = Endpoint.Act(AssemblySetupFixture.EndpointTestContainer,
                                      c => c.GetInstance <ConsolidatedReportService>().GetConsolidatedReportData(testParams.reportIds));

            result.Should().NotBeNull();
            result.Should().BeEquivalentTo(testParams.expectedReportData);
        }
        public void GetReportingPeriodsToCreatePlan_For_User_Should_Return_CorrectResult(OrganizationType organizationType)
        {
            DateTimeDbTestExtensions.SetLocalNowToRandomDate();
            var username   = DataProvider.Get <string>();
            var testParams = Endpoint.ArrangeOnSqlSession(AssemblySetupFixture.EndpointTestContainer,
                                                          s =>
            {
                var organizations = IntegrationTestOrganizationHelper.SetupOrzanizations();

                var central = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Central).Value;
                var state   = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswState).Value;
                var zone    = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.NswZoneOne).Value;
                var unit    = organizations.First(o => o.Key == IntegrationTestOrganizationHelper.Footscray).Value;

                EntityReference sut = null;
                switch (organizationType)
                {
                case OrganizationType.Central:
                    sut = central;
                    break;

                case OrganizationType.State:
                    sut = state;
                    break;

                case OrganizationType.Zone:
                    sut = zone;
                    break;

                default:
                    sut = unit;
                    break;
                }

                var organizationUser1 = new TestObjectBuilder <OrganizationUser>()
                                        .SetArgument(o => o.Username, username)
                                        .SetArgument(o => o.Organization, sut)
                                        .BuildAndPersist(s);

                new UserContextBuilder()
                .SetUsername(username)
                .AddClaims(TestHelper.GetOrganizationClaims(username, new[] { organizationUser1 }))
                .SetCurrentPrincipal();


                return(new
                {
                    sut
                });
            });

            var result = NsbWebTest.Act(AssemblySetupFixture.WebTestContainer,
                                        c =>
            {
                return(c.GetInstance <OrganizationQueryService>()
                       .GetReportingPeriods(testParams.sut.Id));
            });

            if (organizationType == OrganizationType.Unit)
            {
                result.Length.Should().Be(36);
                var activeReportPeriod = result.Single(o => o.IsActive);
                activeReportPeriod.Should().NotBeNull();
            }
            else
            {
                result.Length.Should().Be(20);
                var activeAnnualReportPeriod = result.Single(o => o.IsActive && o.ReportingFrequency == ReportingFrequency.Yearly);
                activeAnnualReportPeriod.Should().NotBeNull();

                var activeQuarterlyReportPeriod = result.Single(o => o.IsActive && o.ReportingFrequency == ReportingFrequency.Quarterly);
                activeQuarterlyReportPeriod.Should().NotBeNull();
            }
        }