public static EnrollmentRepository GetEnrollmentRepository()
{
var repository = new EnrollmentRepository();
repository.UnitOfWork = GetUnitOfWork();
return(repository);
}
public EnrollmentsController()
{
_termRepository = new TermRepository();
_enrollmentRepository = new EnrollmentRepository();
_evaluationRepository = new EvaluationRepository();
_offeringRepository = new OfferingRepository();
_scheduleRepository = new ScheduleRepository();
}
public OfferingEnrollmentsController()
{
_offeringRepository = new OfferingRepository();
_termRepository = new TermRepository();
_scheduleRepository = new ScheduleRepository();
_enrollmentRepository = new EnrollmentRepository();
_studentRepository = new StudentRepository();
}
public UnitOfWork()
{
context = new Context();
Enrollments = new EnrollmentRepository(context);
Positions = new PositionRepository(context);
Workers = new WorkerRepository(context);
WorkerPositions = new WorkerPositionRepository(context);
}
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 void AddEnrollment()
{
using (var context = new TestHedwigContextProvider().Context)
{
var enrollment = new Enrollment();
var enrollmentRepo = new EnrollmentRepository(context);
enrollmentRepo.AddEnrollment(enrollment);
Assert.Equal(EntityState.Added, context.Entry(enrollment).State);
}
}
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 UnitOfWork(ApplicationDbContext context, IMapper mapper)
{
Releases = new ReleaseRepository(context);
Sites = new SiteRepository(context);
Categories = new CategoryRepository(context, mapper);
Words = new WordRepository(context, mapper);
ComplexWords = new ComplexWordRepository(context, mapper);
Packages = new PackageRepository(context);
Enrollments = new EnrollmentRepository(context);
PreDbs = new PreDbRepository(context);
_context = context;
Mapper = mapper;
}
public async Task RemoveEnrollmentAsync_WithoutQuery_ShouldReturnAll()
{
var expectedEnrollment = this.enrollments.Single(e => e.StudentId == 1);
var mockContext = new Mock <StudentInfoSysDbContext>();
mockContext.Setup(c => c.Set <Enrollment>())
.Returns(this.mockSet.Object);
var repository = new EnrollmentRepository(mockContext.Object);
Task act = repository.RemoveEnrollmentAsync(expectedEnrollment);
await act;
}
public async Task AddEnrollmentAsync_WithoutQuery_ShouldReturnAll()
{
var expectedEnrollment = this.enrollments.Single(e => e.StudentId == 1);
var mockContext = new Mock <StudentInfoSysDbContext>();
mockContext.Setup(c => c.Set <Enrollment>())
.Returns(this.mockSet.Object);
var repository = new EnrollmentRepository(mockContext.Object);
var result = await repository.AddEnrollmentAsync(expectedEnrollment);
Assert.Equal(expectedEnrollment, result);
}
public string InsertEnrollment([FromBody] Enrollment enrollmentInfo)
{
var errors = new List <string>();
IEnrollmentRepository enrollment = new EnrollmentRepository();
new EnrollmentService(enrollment).InsertEnrollment(enrollmentInfo, ref errors);
if (errors.Count == 0)
{
return("ok");
}
return("error");
}
public string DeleteEnrollment(string studentId, int scheduleId)
{
var errors = new List <string>();
IEnrollmentRepository enrollment = new EnrollmentRepository();
new EnrollmentService(enrollment).DeleteEnrollment(studentId, scheduleId, ref errors);
if (errors.Count == 0)
{
return("ok");
}
return("error");
}
public StudentType(EnrollmentRepository enrollmentRepository, IDataLoaderContextAccessor dataLoader)
{
Field(t => t.Id);
Field(t => t.DateOfBirth);
Field(t => t.FirstName);
Field(t => t.LastName);
Field <ListGraphType <EnrollmentType> >("enrollments",
resolve: context =>
{
var loader = dataLoader.Context.GetOrAddCollectionBatchLoader <int, Enrollment>("enrollments", enrollmentRepository.GetEnrollmentsForStudents);
return(loader.LoadAsync(context.Source.Id));
}
);
}
public async Task <ActionResult> EditEnrollment(FormCollection form)
{
Enrollment enrollment = null;
var enrollmentId = Int32.Parse(form["EnrollmentID"]);
decimal? grade = decimal.Parse(form["Grade"].Replace('.', ','));
using (_enrollmentRepository = new EnrollmentRepository())
{
enrollment = await _enrollmentRepository.GetAsync(enrollmentId);
enrollment.Grade = grade;
await _enrollmentRepository.UpdateAsync(enrollment);
}
return(RedirectToAction("EditJournal/" + enrollment.CourseID));
}
public async Task When_recruitment_form_is_submitted_repo_contains_its_readmodel()
{
// Arrange
var repo = new EnrollmentRepository();
var campaign = new Impl.Entities.Campaign(now.Minus(aWeek), now.Plus(aWeek), editionId: 1);
campaign.GetType().GetProperty(nameof(campaign.Id)).SetValue(campaign, 1);
var training = new Impl.Entities.Training("Papieska 21/37", "Wadowice", now.Plus(2 * aWeek), now.Plus(2 * aWeek + anHour), Guid.NewGuid());
training.GetType().GetProperty(nameof(training.ID)).SetValue(training, 1);
campaign.ScheduleTraining(training);
var campaignRepo = Mock.Of <ICampaignRepository>(mock => mock.GetById(1) == Task.FromResult(campaign), MockBehavior.Strict);
var trainingRepo = Mock.Of <ITrainingRepository>(MockBehavior.Strict);
var readStoreManager = new ReadStoreManager(repo, campaignRepo, trainingRepo);
// Act
var @event = new RecruitmentFormSubmitted(
now.ToInstant(), "Andrzej", "Strzelba",
EmailAddress.Parse("*****@*****.**"), PhoneNumber.Parse("505551888"),
"no elo",
campaignID: 1, region: "Wolne Miasto Gdańsk", preferredLecturingCities: new[] { "Rumia", "Reda", "Wejherowo" }, preferredTrainingIds: new[] { 1 },
gdprConsentGiven: true);
var domainEvent = new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, RecruitmentFormSubmitted>(@event, new Metadata(), DateTimeOffset.Now, EnrollmentAggregate.EnrollmentId.New, 1);
await readStoreManager.UpdateReadStoresAsync(new[] { domainEvent }, CancellationToken.None);
// Assert
var enrollment = Assert.Single(repo.Query());
Assert.Equal("Andrzej Strzelba", enrollment.FullName);
Assert.Equal(EmailAddress.Parse("*****@*****.**"), enrollment.Email);
Assert.Equal(PhoneNumber.Parse("505551888"), enrollment.PhoneNumber);
Assert.Equal("no elo", enrollment.AboutMe);
Assert.Equal("Wolne Miasto Gdańsk", enrollment.Region);
Assert.Equal(1, enrollment.Campaign.Id);
Assert.Null(enrollment.ResumeDate);
Assert.Collection(enrollment.PreferredLecturingCities,
first => Assert.Equal("Rumia", first),
second => Assert.Equal("Reda", second),
third => Assert.Equal("Wejherowo", third));
var preferredTraining = Assert.Single(enrollment.PreferredTrainings);
Assert.Equal("Wadowice", preferredTraining.City);
}
public async Task If_candidate_was_absent_on_training__he_is_contained_in_AbsentCandidates()
{
// Arrange
var trainerId = Guid.NewGuid();
(var campaignRepo, var trainingRepo, var trainerProvider) = BuildMocks(trainerId, 1, 1);
var enrollmentId = EnrollmentAggregate.EnrollmentId.New;
var enrollmentRepo = new EnrollmentRepository();
var readStoreManager = new ReadStoreManager(enrollmentRepo, campaignRepo, trainingRepo);
var events = new IDomainEvent[]
{
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, RecruitmentFormSubmitted>(
new RecruitmentFormSubmitted(clock.GetCurrentInstant().Minus(anHour), "Andrzej", "Strzelba", EmailAddress.Parse("*****@*****.**"), Consts.FakePhoneNumber, "jo", 1, "Wolne Miasto Gdańsk", new[] { "Gdańsk", "Wrzeszcz", "Oliwa" }, new[] { 1 }, true),
new Metadata(), clock.GetCurrentInstant().ToDateTimeOffset(), enrollmentId, 1),
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, CandidateAcceptedTrainingInvitation>(
new CandidateAcceptedTrainingInvitation(trainerId, Recruitment.Enrollments.CommunicationChannel.OutgoingPhone, 1, string.Empty),
new Metadata(), clock.GetCurrentInstant().ToDateTimeOffset(), enrollmentId, 2),
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, CandidateWasAbsentFromTraining>(
new CandidateWasAbsentFromTraining(trainerId, 1, string.Empty),
new Metadata(), clock.GetCurrentInstant().ToDateTimeOffset(), enrollmentId, 3),
};
await readStoreManager.UpdateReadStoresAsync(events, CancellationToken.None);
// Act
var handler = new DetailsHandler(clock, trainingRepo, trainerProvider, enrollmentRepo);
var result = await handler.Handle(new Details.Query()
{
TrainingId = 1
}, CancellationToken.None);
// Assert
Assert.True(result.HasValue);
Assert.Equal(TrainingTiming.Past, result.Value.Timing);
var pastTraining = Assert.IsType <Details.PastTrainingDetails>(result.Value);
var candidate = Assert.Single(pastTraining.AbsentCandidates);
Assert.Equal(enrollmentId.GetGuid(), candidate.Id);
candidate.WasAbsent.Should().BeTrue();
candidate.WasPresentAndAcceptedAsLecturer.Should().BeFalse();
candidate.WasPresentButDidNotAcceptedAsLecturer.Should().BeFalse();
candidate.WasAbsent.Should().BeTrue();
candidate.HasRefusedTraining.Should().BeFalse();
candidate.HasResignedPermanently.Should().BeFalse();
candidate.HasResignedTemporarily.Should().BeFalse();
candidate.ResignationEndDate.Should().BeNull();
}
public async Task When_training_invitation_is_refused__readmodel_does_not_contain_training_ID()
{
// Arrange
var id = EnrollmentAggregate.EnrollmentId.New;
var repo = new EnrollmentRepository();
var campaign = new Impl.Entities.Campaign(now.Minus(3 * aWeek), now.Minus(2 * aWeek), editionId: 1);
campaign.GetType().GetProperty(nameof(campaign.Id)).SetValue(campaign, 1);
var training = new Impl.Entities.Training("Papieska 21/37", "Wadowice", now.Minus(2 * aWeek + anHour), now.Minus(2 * aWeek), Guid.NewGuid());
training.GetType().GetProperty(nameof(training.ID)).SetValue(training, 1);
campaign.ScheduleTraining(training);
var campaignRepo = Mock.Of <ICampaignRepository>(mock => mock.GetById(1) == Task.FromResult(campaign), MockBehavior.Strict);
var trainingRepo = Mock.Of <ITrainingRepository>(mock => mock.GetById(1) == Task.FromResult(Maybe <Training> .From(training)), MockBehavior.Strict);
await repo.Insert(new EnrollmentReadModel()
{
Id = id, SelectedTraining = new EnrollmentReadModel.TrainingSummary()
{
ID = 1
}
});
var readStoreManager = new ReadStoreManager(repo, campaignRepo, trainingRepo);
// Act
await readStoreManager.UpdateReadStoresAsync(new[] {
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, CandidateRefusedTrainingInvitation>(
new CandidateRefusedTrainingInvitation(
Guid.NewGuid(),
Recruitment.Enrollments.CommunicationChannel.IncomingPhone,
string.Empty, string.Empty),
new Metadata(), DateTimeOffset.Now, id, 1),
},
CancellationToken.None);
// Assert
var enrollment = Assert.Single(repo.Query());
Assert.Equal(id, enrollment.Id);
Assert.Null(enrollment.SelectedTraining);
}
public async Task When_queried_with_flag_HasResigned_set_to_false__results_contains_enrollments_with_temporary_resignations_with_past_ResumeDate()
{
// Arrange
var newCampaign = new Impl.Entities.Campaign(now.Minus(aWeek), now.Plus(aWeek), editionId: 1);
newCampaign.GetType().GetProperty(nameof(newCampaign.Id)).SetValue(newCampaign, 1);
var training = new Impl.Entities.Training("Papieska 21/37", "Wadowice", now.Plus(2 * aWeek), now.Plus(2 * aWeek + anHour), Guid.NewGuid());
training.GetType().GetProperty(nameof(training.ID)).SetValue(training, 1);
newCampaign.ScheduleTraining(training);
var campaignRepo = Mock.Of <ICampaignRepository>(mock =>
mock.GetById(1) == Task.FromResult(newCampaign) &&
mock.GetAll() == Task.FromResult(new[] { newCampaign } as IReadOnlyCollection <Impl.Entities.Campaign>), MockBehavior.Strict);
var repo = new EnrollmentRepository();
await repo.Insert(new EnrollmentReadModel()
{
Id = EnrollmentAggregate.EnrollmentId.New,
Campaign = new EnrollmentReadModel.CampaignSummary()
{
Id = 1
},
PreferredTrainings = Array.Empty <EnrollmentReadModel.TrainingSummary>(),
PreferredLecturingCities = Array.Empty <string>(),
HasResignedTemporarily = true,
ResumeDate = now.Minus(aDay).Date
});
var queryHandler = new GetSubmissionsQueryHandler(repo, campaignRepo, clock);
// Act
var results = await queryHandler.Handle(new Recruitment.Enrollments.GetSubmissions.Query()
{
HasResigned = false
}, CancellationToken.None);
// Assert
var summary = Assert.Single(results);
Assert.False(summary.HasResignedTemporarily);
Assert.Null(summary.ResumeDate);
}
public async Task When_recruitment_form_from_past_recruitment_campaign_is_submitted__its_summary_has_flag_IsNewSubmission_set_to_true()
{
// Arrange
var oldCampaign = new Impl.Entities.Campaign(now.Minus(Duration.FromDays(30)), now.Minus(Duration.FromDays(25)), editionId: 1);
oldCampaign.GetType().GetProperty(nameof(oldCampaign.Id)).SetValue(oldCampaign, 1);
var newCampaign = new Impl.Entities.Campaign(now.Minus(aWeek), now.Plus(aWeek), editionId: 1);
newCampaign.GetType().GetProperty(nameof(newCampaign.Id)).SetValue(newCampaign, 2);
var training = new Impl.Entities.Training("Papieska 21/37", "Wadowice", now.Plus(2 * aWeek), now.Plus(2 * aWeek + anHour), Guid.NewGuid());
training.GetType().GetProperty(nameof(training.ID)).SetValue(training, 1);
newCampaign.ScheduleTraining(training);
var campaignRepo = Mock.Of <ICampaignRepository>(mock =>
mock.GetById(1) == Task.FromResult(oldCampaign) &&
mock.GetById(2) == Task.FromResult(newCampaign) &&
mock.GetAll() == Task.FromResult(new[] { oldCampaign, newCampaign } as IReadOnlyCollection <Impl.Entities.Campaign>), MockBehavior.Strict);
var repo = new EnrollmentRepository();
await repo.Insert(new EnrollmentReadModel()
{
Id = EnrollmentAggregate.EnrollmentId.New,
Campaign = new EnrollmentReadModel.CampaignSummary()
{
Id = 1
},
PreferredTrainings = Array.Empty <EnrollmentReadModel.TrainingSummary>(),
PreferredLecturingCities = Array.Empty <string>()
});
var queryHandler = new GetSubmissionsQueryHandler(repo, campaignRepo, clock);
// Act
var result = await queryHandler.Handle(new Recruitment.Enrollments.GetSubmissions.Query(), CancellationToken.None);
// Assert
var summary = Assert.Single(result);
Assert.True(summary.Campaign.ID == 1);
Assert.True(summary.IsOldSubmission);
}
public void Execute_DoesNotAddEnrollmentToFunding(bool fundingHasEnrollmentReference)
{
Funding funding;
using (var context = new TestHedwigContextProvider().Context)
{
funding = FundingHelper.CreateFunding(context);
}
if (!fundingHasEnrollmentReference)
{
funding.Enrollment = null;
}
using (var context = new TestHedwigContextProvider().Context)
{
// Only attach found entity to avoid attaching the entire object graph
// (which would find & attach the enrollment navigation property)
context.Attach(context.Find(funding.GetType(), funding.Id));
var _serviceProvider = new Mock <IServiceProvider>();
var _validator = new NonBlockingValidator(_serviceProvider.Object);
var _fundings = new FundingRepository(context);
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();
var _enrollments = new EnrollmentRepository(context, mapper);
var _reportingPeriods = new ReportingPeriodRepository(context);
// when
var rule = new FundingTimelinesAreValid(_fundings, _enrollments, _reportingPeriods);
rule.Execute(funding, new NonBlockingValidationContext());
// then
Assert.Equal(fundingHasEnrollmentReference, funding.Enrollment != null);
}
}
public async Task When_temporary_resignation_is_recorded_without_providing_end_date__readmodel_has_no_suspension_end_date()
{
// Arrange
var id = EnrollmentAggregate.EnrollmentId.New;
var repo = new EnrollmentRepository();
var campaign = new Impl.Entities.Campaign(now.Minus(3 * aWeek), now.Minus(2 * aWeek), editionId: 1);
campaign.GetType().GetProperty(nameof(campaign.Id)).SetValue(campaign, 1);
var training = new Impl.Entities.Training("Papieska 21/37", "Wadowice", now.Minus(2 * aWeek + anHour), now.Minus(2 * aWeek), Guid.NewGuid());
training.GetType().GetProperty(nameof(training.ID)).SetValue(training, 1);
campaign.ScheduleTraining(training);
var campaignRepo = Mock.Of <ICampaignRepository>(mock => mock.GetById(1) == Task.FromResult(campaign), MockBehavior.Strict);
var trainingRepo = Mock.Of <ITrainingRepository>(MockBehavior.Strict);
await repo.Insert(new EnrollmentReadModel()
{
Id = id
});
var readStoreManager = new ReadStoreManager(repo, campaignRepo, trainingRepo);
// Act
await readStoreManager.UpdateReadStoresAsync(new[] {
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, CandidateResignedTemporarily>(
new CandidateResignedTemporarily(
Guid.NewGuid(),
Recruitment.Enrollments.CommunicationChannel.IncomingPhone,
string.Empty, string.Empty,
resumeDate: null),
new Metadata(), DateTimeOffset.Now, id, 1),
},
CancellationToken.None);
// Assert
var enrollment = Assert.Single(repo.Query());
Assert.Equal(id, enrollment.Id);
Assert.True(enrollment.HasResignedTemporarily);
Assert.Null(enrollment.ResumeDate);
}
public async Task <ActionResult> EditJournal(int id)
{
Course viewResult = null;
List <Student> courseStudents = new List <Student>();
using (_enrollmentRepository = new EnrollmentRepository())
{
viewResult = await _enrollmentRepository.GetListEnrollment(id);
}
using (_studentRepository = new StudentRepository())
{
foreach (var enrollment in viewResult.Enrollments)
{
courseStudents.Add(await _studentRepository.GetAsync(enrollment.StudentID));
}
}
ViewBag.Students = courseStudents;
ViewBag.Course = viewResult;
return(View(viewResult));
}
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);
}
}
public async Task <ActionResult <dynamic> > Post(
[FromServices] EnrollmentRepository enrollmentRepository,
[FromBody] EnrollmentRequest model
)
{
if (ModelState.IsValid)
{
var enrollment = await enrollmentRepository.Add(model);
if (enrollment == null)
{
return(BadRequest(new { message = "Usuário ou curso estão incorretos" }));
}
return(enrollment);
}
else
{
return(BadRequest(ModelState));
}
}
public void AddEnrollment()
{
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 enrollment = new Enrollment();
var enrollmentRepo = new EnrollmentRepository(context, mapper);
enrollmentRepo.AddEnrollment(enrollment);
Assert.Equal(EntityState.Added, context.Entry(enrollment).State);
}
}
public async Task GetEnrollmentsForSite_ReturnsEnrollmentsWithSiteId_IncludesEntities(
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;
}
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.GetEnrollmentsForSiteAsync(siteId);
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 If_candidate_was_invited_and_resigned_temporarily_without_resume_date__AvailableCandidates_contain_that_candidate()
{
// Arrange
var trainerId = Guid.NewGuid();
(var campaignRepo, var trainingRepo, var trainerProvider) = BuildMocks(trainerId, 1, 1);
var enrollmentId = EnrollmentAggregate.EnrollmentId.New;
var enrollmentRepo = new EnrollmentRepository();
var readStoreManager = new ReadStoreManager(enrollmentRepo, campaignRepo, trainingRepo);
var events = new IDomainEvent[]
{
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, RecruitmentFormSubmitted>(
new RecruitmentFormSubmitted(clock.GetCurrentInstant().Minus(anHour), "Andrzej", "Strzelba", EmailAddress.Parse("*****@*****.**"), Consts.FakePhoneNumber, "jo", 1, "Wolne Miasto Gdańsk", new[] { "Gdańsk", "Wrzeszcz", "Oliwa" }, new[] { 1 }, true),
new Metadata(), clock.GetCurrentInstant().ToDateTimeOffset(), enrollmentId, 1),
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, CandidateAcceptedTrainingInvitation>(
new CandidateAcceptedTrainingInvitation(trainerId, Recruitment.Enrollments.CommunicationChannel.OutgoingPhone, 1, string.Empty),
new Metadata(), clock.GetCurrentInstant().ToDateTimeOffset(), enrollmentId, 2),
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, CandidateResignedTemporarily>(
new CandidateResignedTemporarily(trainerId, Recruitment.Enrollments.CommunicationChannel.OutgoingPhone, string.Empty, string.Empty, resumeDate: null),
new Metadata(), clock.GetCurrentInstant().ToDateTimeOffset(), enrollmentId, 3)
};
await readStoreManager.UpdateReadStoresAsync(events, CancellationToken.None);
// Act
var handler = new DetailsHandler(clock, trainingRepo, trainerProvider, enrollmentRepo);
var result = await handler.Handle(new Details.Query()
{
TrainingId = 1
}, CancellationToken.None);
// Assert
Assert.True(result.HasValue);
Assert.Equal(TrainingTiming.Future, result.Value.Timing);
var futureTraining = Assert.IsType <Details.FutureTrainingDetails>(result.Value);
var candidate = Assert.Single(futureTraining.AvailableCandidates);
Assert.Equal(enrollmentId.GetGuid(), candidate.Id);
}
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 When_candidate_obtains_lecturer_rights_Readmodel_has_flag_HasLecturerRigths_set_to_true()
{
// Arrange
var id = EnrollmentAggregate.EnrollmentId.New;
var repo = new EnrollmentRepository();
var campaign = new Impl.Entities.Campaign(now.Minus(3 * aWeek), now.Minus(2 * aWeek), editionId: 1);
campaign.GetType().GetProperty(nameof(campaign.Id)).SetValue(campaign, 1);
var training = new Impl.Entities.Training("Papieska 21/37", "Wadowice", now.Minus(2 * aWeek + anHour), now.Minus(2 * aWeek), Guid.NewGuid());
training.GetType().GetProperty(nameof(training.ID)).SetValue(training, 1);
campaign.ScheduleTraining(training);
var campaignRepo = Mock.Of <ICampaignRepository>(mock => mock.GetById(1) == Task.FromResult(campaign), MockBehavior.Strict);
var trainingRepo = Mock.Of <ITrainingRepository>(MockBehavior.Strict);
await repo.Insert(new EnrollmentReadModel()
{
Id = id
});
var readStoreManager = new ReadStoreManager(repo, campaignRepo, trainingRepo);
// Act
await readStoreManager.UpdateReadStoresAsync(new[] {
new DomainEvent <EnrollmentAggregate, EnrollmentAggregate.EnrollmentId, CandidateObtainedLecturerRights>(
new CandidateObtainedLecturerRights(Guid.NewGuid(), "zdobył uprawnienia"),
new Metadata(), DateTimeOffset.Now, id, 1),
},
CancellationToken.None);
// Assert
var enrollment = Assert.Single(repo.Query());
Assert.Equal(id, enrollment.Id);
Assert.True(enrollment.HasLecturerRights);
}
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));
}
}
