public void Execute_DoesNotAddEnrollmentsToReport(bool reportHasEnrollmentsReference)
{
CdcReport report;
using (var context = new TestHedwigContextProvider().Context)
{
report = ReportHelper.CreateCdcReport(context) as CdcReport;
var site = SiteHelper.CreateSite(context, organization: report.Organization);
var enrollments = EnrollmentHelper.CreateEnrollments(context, 1, site: site);
report.Enrollments = enrollments;
}
if (!reportHasEnrollmentsReference)
{
report.Enrollments = null;
}
using (var context = new TestHedwigContextProvider().Context)
{
context.Attach(report);
var _serviceProvider = new Mock <IServiceProvider>();
_serviceProvider.Setup(sp => sp.GetService(typeof(IEnumerable <IValidationRule <Enrollment> >)))
.Returns(new List <IValidationRule <Enrollment> >());
var _validator = new NonBlockingValidator(_serviceProvider.Object);
var _reports = new ReportRepository(context);
// when
var rule = new EnrollmentsAreValid(_validator, _reports);
rule.Execute(report, new NonBlockingValidationContext());
// then
Assert.Equal(reportHasEnrollmentsReference, report.Enrollments != null);
}
}
public async Task GetSiteForOrganization_ReturnsSiteWithIdAndOrganizationId_IncludesEntities(
string[] include,
bool includeEnrollments,
bool includeFundings,
bool includeChildren
)
{
int orgId;
int id;
using (var context = new TestHedwigContextProvider().Context)
{
var enrollment = EnrollmentHelper.CreateEnrollment(context);
id = enrollment.SiteId;
orgId = enrollment.Site.OrganizationId;
}
using (var context = new TestHedwigContextProvider().Context)
{
var siteRepo = new SiteRepository(context);
var res = await siteRepo.GetSiteForOrganizationAsync(id, orgId, include);
Assert.Equal(includeEnrollments, res.Enrollments != null);
Assert.Equal(includeFundings, res.Enrollments != null && res.Enrollments.All(e => e.Fundings != null));
Assert.Equal(includeChildren, res.Enrollments != null && res.Enrollments.All(e => e.Child != null));
}
}
public async Task GetEnrollmentsForSite_FiltersByDates(
string entry,
string exit,
string from,
string to,
bool included
)
{
using (var context = new TestHedwigContextProvider().Context)
{
// if enrollment exists with entry and exit
var enrollment = EnrollmentHelper.CreateEnrollment(context, entry, exit);
// when repo is queried with to and from
var enrollmentRepo = new EnrollmentRepository(context);
var result = await enrollmentRepo.GetEnrollmentsForSiteAsync(
enrollment.SiteId,
DateTime.Parse(from),
DateTime.Parse(to)
);
var resultIds = result.Select(e => e.Id);
// then
Assert.Equal(included, resultIds.Contains(enrollment.Id));
}
}
public async Task GetEnrollmentsForSite_ReturnsEnrollmentsWithSiteId_IncludesEntities(
string[] include,
bool includeFundings,
bool includeChildren,
bool includeFamilies,
bool includeDeterminations
)
{
int[] ids;
int siteId;
using (var context = new TestHedwigContextProvider().Context)
{
var site = SiteHelper.CreateSite(context);
var enrollments = EnrollmentHelper.CreateEnrollments(context, 3, site: site);
ids = enrollments.Select(e => e.Id).ToArray();
siteId = site.Id;
}
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context);
var res = await enrollmentRepo.GetEnrollmentsForSiteAsync(siteId, include : include);
Assert.Equal(ids.OrderBy(id => id), res.Select(e => e.Id).OrderBy(id => id));
Assert.Equal(includeFundings, res.TrueForAll(e => e.Fundings != null));
Assert.Equal(includeChildren, res.TrueForAll(e => e.Child != null));
Assert.Equal(includeFamilies, res.TrueForAll(e => e.Child != null && e.Child.Family != null));
Assert.Equal(includeDeterminations, res.TrueForAll(e => e.Child != null && e.Child.Family != null && e.Child.Family.Determinations != null));
}
}
public async Task GetEnrollmentForSite_ReturnsEnrollmentWithIdAndSiteId_IncludesEntities(
string[] include,
bool includeFundings,
bool includeChild,
bool includeFamily,
bool includeDeterminations,
bool includePastEnrollments
)
{
int id;
int siteId;
using (var context = new TestHedwigContextProvider().Context)
{
var enrollment = EnrollmentHelper.CreateEnrollment(context);
EnrollmentHelper.CreateEnrollment(context, child: enrollment.Child);
id = enrollment.Id;
siteId = enrollment.SiteId;
}
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context);
var res = await enrollmentRepo.GetEnrollmentForSiteAsync(id, siteId, include);
Assert.Equal(id, res.Id);
Assert.Equal(includeFundings, res.Fundings != null);
Assert.Equal(includeChild, res.Child != null);
Assert.Equal(includeFamily, res.Child != null && res.Child.Family != null);
Assert.Equal(includeDeterminations, res.Child != null && res.Child.Family != null && res.Child.Family.Determinations != null);
Assert.Equal(includePastEnrollments, res.PastEnrollments != null);
}
}
public void Execute_DoesNotAddFundingsToEnrollment(bool enrollmentHasFundingsReference)
{
Enrollment enrollment;
using (var context = new TestHedwigContextProvider().Context)
{
enrollment = EnrollmentHelper.CreateEnrollment(context);
FundingHelper.CreateFunding(context, enrollment: enrollment);
}
if (!enrollmentHasFundingsReference)
{
enrollment.Fundings = null;
}
using (var context = new TestHedwigContextProvider().Context)
{
// Only attach found entity to avoid attaching the entire object graph
// (which would find & attach the fundings navigation property)
context.Attach(context.Find(enrollment.GetType(), enrollment.Id));
var _serviceProvider = new Mock <IServiceProvider>();
_serviceProvider.Setup(sp => sp.GetService(typeof(IEnumerable <IValidationRule <Funding> >)))
.Returns(new List <IValidationRule <Funding> >());
var _validator = new NonBlockingValidator(_serviceProvider.Object);
var _fundings = new FundingRepository(context);
// when
var rule = new FundingsAreValid(_validator, _fundings);
rule.Execute(enrollment, new NonBlockingValidationContext());
// then
Assert.Equal(enrollmentHasFundingsReference, enrollment.Fundings != null);
}
}
public void UpdateEnrollment_AddsFundings()
{
Enrollment enrollment;
FundingSpace fundingSpace;
using (var context = new TestHedwigContextProvider().Context)
{
enrollment = EnrollmentHelper.CreateEnrollment(context);
fundingSpace = FundingSpaceHelper.CreateFundingSpace(
context,
organizationId: enrollment.Site.OrganizationId,
source: FundingSource.CDC,
ageGroup: enrollment.AgeGroup.Value
);
}
Funding funding = new Funding
{
EnrollmentId = enrollment.Id,
Source = FundingSource.CDC,
FundingSpaceId = fundingSpace.Id
};
Assert.Null(enrollment.Fundings);
enrollment.Fundings = new List <Funding> {
funding
};
var mapper = new MapperConfiguration(opts =>
{
opts.AddProfile(new EnrollmentProfile());
opts.AddProfile(new FundingProfile());
opts.AddProfile(new ChildProfile());
opts.AddProfile(new FamilyProfile());
opts.AddProfile(new SiteProfile());
}).CreateMapper();
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var enrollmentDTO = mapper.Map <Enrollment, EnrollmentDTO>(enrollment);
enrollmentRepo.UpdateEnrollment(enrollment, enrollmentDTO);
context.SaveChanges();
}
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var retrievedEnrollment = enrollmentRepo.GetEnrollmentById(enrollment.Id);
Assert.NotEmpty(retrievedEnrollment.Fundings);
var retrievedFunding = retrievedEnrollment.Fundings.FirstOrDefault();
Assert.Equal(funding.Id, retrievedFunding.Id);
}
}
public async Task Get_Report_For_Organization(bool submitted, string[] include)
{
using (var context = new TestHedwigContextProvider().Context)
{
// Set up test data
var organization = OrganizationHelper.CreateOrganization(context);
var reportingPeriod = ReportingPeriodHelper.CreateReportingPeriod(context);
var report = ReportHelper.CreateCdcReport(context, organization: organization, reportingPeriod: reportingPeriod);
var site = SiteHelper.CreateSite(context, organization: organization);
var enrollment = EnrollmentHelper.CreateEnrollment(context, site: site, ageGroup: Age.Preschool);
var funding = FundingHelper.CreateFunding(context, enrollment: enrollment, firstReportingPeriod: reportingPeriod);
if (submitted)
{
Thread.Sleep(1000);
report.SubmittedAt = DateTime.Now;
context.SaveChanges();
Thread.Sleep(1000);
}
enrollment.AgeGroup = Age.SchoolAge;
context.SaveChanges();
// When the repository is queried
var repo = new ReportRepository(context);
var result = await repo.GetReportForOrganizationAsync(report.Id, organization.Id, include) as CdcReport;
// It returns the Report
Assert.Equal(result.Id, report.Id);
// It includes the Organization
Assert.Equal(include.Contains("organizations"), result.Organization != null);
// It includes the Sites
Assert.Equal(include.Contains("sites"), result.Organization != null && result.Organization.Sites != null);
// It includes the Enrollments (and Fundings too)
Assert.Equal(
include.Contains("enrollments"),
result.Enrollments != null &&
result.Enrollments.FirstOrDefault().Fundings != null
);
// When it includes enrollments
if (include.Contains("enrollments"))
{
var enrollmentResult = result.Enrollments.FirstOrDefault();
var fundingResult = enrollmentResult.Fundings.FirstOrDefault();
// A submitted report should return the data as of when it was submitted
Assert.Equal(submitted ? Age.Preschool : Age.SchoolAge, enrollmentResult.AgeGroup);
}
}
}
public void UpdateEnrollment_UpdatesFundings()
{
Enrollment enrollment;
Funding funding;
ReportingPeriod reportingPeriod;
using (var context = new TestHedwigContextProvider().Context)
{
enrollment = EnrollmentHelper.CreateEnrollment(context);
funding = FundingHelper.CreateFunding(context, enrollment: enrollment);
reportingPeriod = ReportingPeriodHelper.CreateReportingPeriod(context);
}
Assert.Null(funding.FirstReportingPeriodId);
funding.FirstReportingPeriodId = reportingPeriod.Id;
enrollment.Fundings = new List <Funding> {
funding
};
enrollment.Fundings.FirstOrDefault().Enrollment = null;
using (var context = new TestHedwigContextProvider().Context)
{
var mapper = new MapperConfiguration(opts =>
{
opts.AddProfile(new EnrollmentProfile());
opts.AddProfile(new FundingProfile());
opts.AddProfile(new FundingSpaceProfile());
opts.AddProfile(new ChildProfile());
opts.AddProfile(new FamilyProfile());
opts.AddProfile(new SiteProfile());
}).CreateMapper();
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var enrollmentDTO = mapper.Map <Enrollment, EnrollmentDTO>(enrollment);
enrollmentRepo.UpdateEnrollment(enrollment, enrollmentDTO);
context.SaveChanges();
}
using (var context = new TestHedwigContextProvider().Context)
{
var retrievedEnrollment = context.Enrollments
.Where(e => e.Id == enrollment.Id)
.Include(e => e.Fundings)
.FirstOrDefault();
var retrievedFunding = retrievedEnrollment.Fundings.FirstOrDefault();
Assert.NotNull(retrievedFunding.FirstReportingPeriodId);
Assert.Equal(funding.FirstReportingPeriodId, retrievedFunding.FirstReportingPeriodId);
}
}
public async Task ReportControllerOrganizationsReportsGet_ReturnsCorrectResponseShape()
{
User user;
Organization organization;
Site[] sites;
Report report;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
var site1 = SiteHelper.CreateSite(context, organization: organization);
var site2 = SiteHelper.CreateSite(context, organization: organization);
report = ReportHelper.CreateCdcReport(context, organization: organization);
sites = new Site[] { site1, site2 };
EnrollmentHelper.CreateEnrollment(context, site: site1);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site1);
PermissionHelper.CreateSitePermission(context, user, site2);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var client = _factory.CreateClient();
var request = HedwigAPIRequests.OrganizationReports(
user,
organization
);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseReports = JsonConvert.DeserializeObject <List <CdcReport> >(responseString);
Assert.NotEmpty(responseReports);
var responseReport = responseReports.First();
Assert.NotNull(responseReport);
Assert.Equal(report.Id, responseReport.Id);
Assert.NotNull(responseReport.Organization);
Assert.Null(responseReport.Organization.FundingSpaces);
Assert.Null(responseReport.Organization.Sites);
Assert.NotNull(responseReport.ReportingPeriod);
Assert.Null(responseReport.Enrollments);
}
public async Task GetEnrollmentForSite_ReturnsEnrollmentWithIdAndSiteId_IncludesEntities(
bool includeFundings,
bool includeChild,
bool includeFamily,
bool includeDeterminations,
bool includePastEnrollments
)
{
int id;
int siteId;
using (var context = new TestHedwigContextProvider().Context)
{
var enrollment = EnrollmentHelper.CreateEnrollment(context);
EnrollmentHelper.CreateEnrollment(context, child: enrollment.Child);
id = enrollment.Id;
siteId = enrollment.SiteId;
}
var mapper = new MapperConfiguration(opts =>
{
opts.AddProfile(new EnrollmentProfile());
opts.AddProfile(new FundingProfile());
opts.AddProfile(new ChildProfile());
opts.AddProfile(new FamilyProfile());
opts.AddProfile(new SiteProfile());
}).CreateMapper();
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var res = await enrollmentRepo.GetEnrollmentForSiteAsync(id, siteId);
Assert.Equal(id, res.Id);
Assert.Equal(includeFundings, res.Fundings != null);
Assert.Equal(includeChild, res.Child != null);
Assert.Equal(includeFamily, res.Child != null && res.Child.Family != null);
Assert.Equal(includeDeterminations, res.Child != null && res.Child.Family != null && res.Child.Family.Determinations != null);
Assert.Equal(includePastEnrollments, res.PastEnrollments != null);
}
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
var categoryGuids = GetAttributeValue(AttributeKeys.Categories).SplitDelimitedValues();
var categories = categoryGuids.Select(c => CategoryCache.Get(c.AsGuid())).ToList();
lBlockName.Text = this.BlockName;
if (Person != null)
{
var courses = EnrollmentHelper.GetPersonCourses(Person, categories, GetAttributeValue(AttributeKeys.EnrolledOnly).AsBoolean());
foreach (var item in courses)
{
phCourses.Controls.Add(new RockLiteral
{
Label = item.Course.Name,
Text = item.Experiences.Where(ex => ex.Result.WasSuccess).Any() ? "Complete" : "Incomplete"
});
}
}
}
private void ShowDetails()
{
var courseGuids = GetAttributeValues(AttributeKeys.Categories);
var categories = new List <CategoryCache>();
foreach (var guid in courseGuids)
{
var category = CategoryCache.Get(guid);
if (category != null)
{
categories.Add(category);
}
}
List <EnrollmentHelper.CourseResult> courses = EnrollmentHelper.GetPersonCourses(CurrentPerson, categories);
var mergeFields = LavaHelper.GetCommonMergeFields(RockPage, CurrentPerson);
mergeFields.Add("Courses", courses);
ltContent.Text = GetAttributeValue(AttributeKeys.Lava)
.ResolveMergeFields(mergeFields, CurrentPerson, GetAttributeValue(AttributeKeys.EnabledCommands));
}
public void UpdateEnrollment_RemovesFundings()
{
Enrollment enrollment;
using (var context = new TestHedwigContextProvider().Context)
{
enrollment = EnrollmentHelper.CreateEnrollment(context);
FundingHelper.CreateFunding(context, enrollment: enrollment);
}
Assert.NotEmpty(enrollment.Fundings);
enrollment.Fundings = new List <Funding>();
var mapper = new MapperConfiguration(opts =>
{
opts.AddProfile(new EnrollmentProfile());
opts.AddProfile(new FundingProfile());
opts.AddProfile(new ChildProfile());
opts.AddProfile(new FamilyProfile());
opts.AddProfile(new SiteProfile());
}).CreateMapper();
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var enrollmentDTO = mapper.Map <Enrollment, EnrollmentDTO>(enrollment);
enrollmentRepo.UpdateEnrollment(enrollment, enrollmentDTO);
context.SaveChanges();
}
using (var context = new TestHedwigContextProvider().Context)
{
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var retrievedEnrollment = enrollmentRepo.GetEnrollmentById(enrollment.Id);
Assert.Empty(retrievedEnrollment.Fundings);
}
}
public async Task GetEnrollmentsForSite_FiltersByDates(
string entry,
string exit,
string from,
string to,
bool included
)
{
var mapper = new MapperConfiguration(opts =>
{
opts.AddProfile(new EnrollmentProfile());
opts.AddProfile(new FundingProfile());
opts.AddProfile(new ChildProfile());
opts.AddProfile(new FamilyProfile());
opts.AddProfile(new SiteProfile());
}).CreateMapper();
using (var context = new TestHedwigContextProvider().Context)
{
// if enrollment exists with entry and exit
var enrollment = EnrollmentHelper.CreateEnrollment(context, entry, exit);
// when repo is queried with to and from
var enrollmentRepo = new EnrollmentRepository(context, mapper);
var result = await enrollmentRepo.GetEnrollmentsForSiteAsync(
enrollment.SiteId,
DateTime.Parse(from),
DateTime.Parse(to)
);
var resultIds = result.Select(e => e.Id);
// then
Assert.Equal(included, resultIds.Contains(enrollment.Id));
}
}
public async Task EnrollmentControllerOrganizationSiteEnrollmentGet_ReturnsCorrectResponseShape()
{
Enrollment enrollment;
User user;
Organization organization;
Site site;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
site = SiteHelper.CreateSite(context, organization: organization);
enrollment = EnrollmentHelper.CreateEnrollment(context, site: site);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var client = _factory.CreateClient();
var request = HedwigAPIRequests.OrganizationSiteEnrollmentDetail(
user,
enrollment,
organization,
site
);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseEnrollment = JsonConvert.DeserializeObject <Enrollment>(responseString);
Assert.NotNull(responseEnrollment);
Assert.Equal(enrollment.Id, responseEnrollment.Id);
Assert.Equal(enrollment.ChildId, responseEnrollment.ChildId);
Assert.NotNull(responseEnrollment.Child);
Assert.Equal(enrollment.ChildId, responseEnrollment.Child.Id);
Assert.Equal(enrollment.Child.FirstName, responseEnrollment.Child.FirstName);
Assert.Equal(enrollment.Child.MiddleName, responseEnrollment.Child.MiddleName);
Assert.Equal(enrollment.Child.LastName, responseEnrollment.Child.LastName);
Assert.Empty(responseEnrollment.Child.Enrollments);
Assert.Equal(enrollment.SiteId, responseEnrollment.SiteId);
Assert.NotNull(responseEnrollment.Site);
Assert.NotNull(responseEnrollment.Site.Name);
Assert.Empty(responseEnrollment.Site.Enrollments);
Assert.Equal(enrollment.AgeGroup, responseEnrollment.AgeGroup);
Assert.Equal(enrollment.Entry, responseEnrollment.Entry);
Assert.Equal(enrollment.Exit, responseEnrollment.Exit);
Assert.Equal(enrollment.ExitReason, responseEnrollment.ExitReason);
Assert.All(
responseEnrollment.Fundings,
funding =>
{
Assert.NotNull(funding.FundingSpace);
Assert.Equal(funding.FundingSpace.Time == FundingTime.Split, funding.FundingSpace.TimeSplit != null);
Assert.NotNull(funding.Source);
Assert.NotNull(funding.FirstReportingPeriod);
Assert.NotNull(funding.LastReportingPeriod);
}
);
}
public async Task OrganizationControllerOrganizationsGet_ReturnsCorrectResponseShape(
string[] include,
bool isInclude
)
{
User user;
Organization organization;
Site[] sites;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
var site1 = SiteHelper.CreateSite(context, organization: organization);
var site2 = SiteHelper.CreateSite(context, organization: organization);
sites = new Site[] { site1, site2 };
EnrollmentHelper.CreateEnrollment(context, site: site1);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site1);
PermissionHelper.CreateSitePermission(context, user, site2);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var client = _factory.CreateClient();
var request = HedwigAPIRequests.Organizations(
user,
organization,
include
);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseOrganization = JsonConvert.DeserializeObject <Organization>(responseString);
Assert.NotNull(responseOrganization);
Assert.Equal(organization.Id, responseOrganization.Id);
Assert.Equal(organization.Name, responseOrganization.Name);
Assert.Null(responseOrganization.Reports);
if (isInclude)
{
Assert.NotEmpty(responseOrganization.Sites);
Assert.All(
responseOrganization.Sites,
site =>
{
Assert.NotNull(site.Name);
Assert.Null(site.Organization);
Assert.Null(site.Enrollments);
}
);
Assert.Null(responseOrganization.Reports);
Assert.NotNull(responseOrganization.FundingSpaces);
Assert.All(
responseOrganization.FundingSpaces,
fundingSpace =>
{
Assert.NotNull(fundingSpace);
Assert.Equal(fundingSpace.Time == FundingTime.Split, fundingSpace.TimeSplit != null);
}
);
}
else
{
Assert.Null(responseOrganization.Sites);
Assert.Null(responseOrganization.FundingSpaces);
}
}
public async Task ReportControllerOrganizationsReportPut_IsSuccessfull_OrReturnsValidationError(
int partTimeWeeksUsed,
bool shouldSucceed
)
{
User user;
Organization organization;
FundingSpace fundingSpace;
Site site;
CdcReport report;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
var reportingPeriod = ReportingPeriodHelper.CreateReportingPeriod(context, period: "2010-01-01", periodStart: "2010-01-01", periodEnd: "2010-01-31");
fundingSpace = FundingSpaceHelper.CreateFundingSpace(context, organization.Id, time: FundingTime.Split);
site = SiteHelper.CreateSite(context, organization: organization);
report = ReportHelper.CreateCdcReport(context, organization: organization, reportingPeriod: reportingPeriod) as CdcReport;
EnrollmentHelper.CreateEnrollment(context, site: site);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var timeSplitUtilization = new FundingTimeSplitUtilization
{
ReportId = report.Id,
ReportingPeriodId = report.ReportingPeriodId,
FundingSpaceId = fundingSpace.Id,
PartTimeWeeksUsed = partTimeWeeksUsed,
FullTimeWeeksUsed = 0,
};
typeof(FundingTimeSplitUtilization).GetProperty(nameof(FundingTimeSplitUtilization.ReportingPeriod)).SetValue(timeSplitUtilization, report.ReportingPeriod);
var reportForPut = new CdcReport
{
Id = report.Id,
Accredited = report.Accredited,
Comment = report.Comment,
Enrollments = report.Enrollments,
C4KRevenue = 0,
FamilyFeesRevenue = 0,
OrganizationId = report.OrganizationId,
ReportingPeriodId = report.ReportingPeriodId,
TimeSplitUtilizations = new List <FundingTimeSplitUtilization> {
timeSplitUtilization
},
};
typeof(Report).GetProperty(nameof(Report.ReportingPeriod)).SetValue(reportForPut, report.ReportingPeriod);
var request = HedwigAPIRequests.OrganizationReportPut(
user,
organization,
reportForPut
);
var client = _factory.CreateClient();
var response = await client.SendAsync(request);
if (shouldSucceed)
{
response.EnsureSuccessStatusCode();
}
else
{
Assert.False(response.IsSuccessStatusCode);
}
}
public async Task ReportControllerOrganizationsReportGet_ReturnsCorrectResponseShape()
{
User user;
Organization organization;
Site[] sites;
Report report;
using (var context = new TestHedwigContextProvider().Context)
{
organization = OrganizationHelper.CreateOrganization(context);
var site1 = SiteHelper.CreateSite(context, organization: organization);
var site2 = SiteHelper.CreateSite(context, organization: organization);
report = ReportHelper.CreateCdcReport(context, organization: organization);
sites = new Site[] { site1, site2 };
EnrollmentHelper.CreateEnrollment(context, site: site1);
user = UserHelper.CreateUser(context);
PermissionHelper.CreateSitePermission(context, user, site1);
PermissionHelper.CreateSitePermission(context, user, site2);
PermissionHelper.CreateOrganizationPermission(context, user, organization);
}
var client = _factory.CreateClient();
var request = HedwigAPIRequests.OrganizationReport(
user,
organization,
report
);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var responseReport = JsonConvert.DeserializeObject <CdcReport>(responseString);
Assert.NotNull(responseReport);
Assert.Equal(report.Id, responseReport.Id);
Assert.NotNull(responseReport.Organization);
Assert.All(
responseReport.Organization.Sites,
site =>
{
Assert.NotNull(site.Name);
Assert.Null(site.Organization);
Assert.Null(site.Enrollments);
}
);
Assert.NotNull(responseReport.Organization.FundingSpaces);
Assert.All(
responseReport.Organization.FundingSpaces,
fundingSpace =>
{
Assert.NotNull(fundingSpace);
Assert.Equal(fundingSpace.Time == FundingTime.Split, fundingSpace.TimeSplit != null);
}
);
Assert.NotNull(responseReport.ReportingPeriod);
Assert.NotNull(responseReport.Enrollments);
Assert.All(
responseReport.Enrollments,
enrollment =>
{
Assert.NotNull(enrollment.Child);
Assert.Null(enrollment.Child.Family);
Assert.Null(enrollment.Child.Enrollments);
Assert.Null(enrollment.Child.Organization);
Assert.Null(enrollment.Site);
Assert.All(
enrollment.Fundings,
funding =>
{
Assert.NotNull(funding.FundingSpace);
Assert.Equal(funding.FundingSpace.Time == FundingTime.Split, funding.FundingSpace.TimeSplit != null);
Assert.NotNull(funding.Source);
Assert.NotNull(funding.FirstReportingPeriod);
Assert.NotNull(funding.LastReportingPeriod);
}
);
Assert.Null(enrollment.PastEnrollments);
}
);
}
