public async Task ExecuteShouldChangePresenceForMemberAndGetPassEntry()
{
//Arrange
SchoolManagementContext context = new ContextBuilder().BuildClean();
new RoleBuilder(context).WithName(Roles.Participant).BuildAndSave();
GroupClass groupClass = new GroupClassBuilder(context)
.WithStartClasses(DateTime.Now)
.WithTimeDurationInMinutes(90)
.AddClassDayOfWeek(x => x.WithDate(DayOfWeek.Monday, new TimeSpan(18, 0, 0)))
.AddParticipant(userBuilder => userBuilder.WithName("Piotr", "Kowalski"), ParticipantRole.Follower,
passBuilder => passBuilder.WithNumberOfEntry(2))
.WithName("Boogie woogie")
.WithNumberOfClasses(5)
.CreateSchedule().BuildAndSave();
User participant = context.Users.First();
ClassTime classTime = context.ClassTimes.First();
Command command = new Command
{
ClassTimeId = classTime.Id,
ParticipantId = participant.Id,
IsPresence = true,
PresenceType = PresenceType.Member
};
//Act
DataResult dataResult = await new Handler(context).Handle(command, CancellationToken.None);
//Assert
ParticipantClassTime participantClassTime = classTime.PresenceParticipants.First();
participantClassTime.WasPresence.Should().BeTrue("we set presence");
}
public async Task ExecuteShouldThrowWrongType()
{
SchoolManagementContext context = new ContextBuilder().BuildClean();
User user = new UserBuilder(context).BuildAndSave();
new RoleBuilder(context).WithName(Roles.Participant).BuildAndSave();
GroupClass groupClassToMakeUp = new GroupClassBuilder(context)
.WithStartClasses(DateTime.Now.Subtract(TimeSpan.FromDays(30)))
.WithNumberOfClasses(14)
.AddClassDayOfWeek(x => x.WithDate(DayOfWeek.Monday, TimeSpan.FromHours(18)))
.AddParticipant(x => x.WithUser(user), ParticipantRole.Follower, passBuilder => passBuilder.AsActive())
.WithTimeDurationInMinutes(90)
.CreateSchedule()
.BuildAndSave();
List <ParticipantClassTime> participantClassTimes = context.ParticipantPresences.ToList();
for (int i = 0; i < participantClassTimes.Count - 5; i++)
{
participantClassTimes[i].WasPresence = true;
participantClassTimes[i].PresenceType = PresenceType.Member;
}
ParticipantClassTime makeUpParticipantClassTime = participantClassTimes[participantClassTimes.Count - 5];
makeUpParticipantClassTime.PresenceType = PresenceType.MakeUp;
context.UpdateRange(participantClassTimes);
context.SaveChanges();
GroupClass makeUpClass = new GroupClassBuilder(context)
.WithStartClasses(DateTime.Now.Subtract(TimeSpan.FromDays(30)))
.WithNumberOfClasses(14)
.AddClassDayOfWeek(x => x.WithDate(DayOfWeek.Monday, TimeSpan.FromHours(18)))
.AddParticipant(x => x.WithEmail("*****@*****.**"), ParticipantRole.Follower, passBuilder => passBuilder.AsActive())
.AddParticipant(x => x.WithUser(user), ParticipantRole.Follower)
.WithTimeDurationInMinutes(90)
.CreateSchedule()
.BuildAndSave();
ClassTime classTime = context.ClassTimes.Last(x => x.GroupClassId == makeUpClass.Id);
ParticipantClassTime newUserToRemove = classTime.PresenceParticipants.Last();
newUserToRemove.MakeUpParticipant = makeUpParticipantClassTime;
newUserToRemove.MakeUpParticipantId = makeUpParticipantClassTime.Id;
newUserToRemove.PresenceType = PresenceType.Help;
context.Update(newUserToRemove);
context.SaveChanges();
Command command = new Command
{
ParticipantId = user.Id,
ClassTimeId = classTime.Id
};
DataResult dataResult = await new Handler(context).Handle(command, CancellationToken.None);
dataResult.Status.Should().Be(DataResult.ResultStatus.Error);
dataResult.Message.Should().Be(PolishReadableMessage.Presence.RemoveWrongType);
classTime.PresenceParticipants.Should().HaveCount(2);
}
public async Task <DataResult> Handle(Command request, CancellationToken cancellationToken)
{
ClassTime classTime = await _context.ClassTimes
.Include(x => x.PresenceParticipants)
.Where(x => x.Id == request.ClassTimeId)
.Include(x => x.PresenceParticipants)
.FirstOrDefaultAsync(cancellationToken);
if (classTime is null)
{
return(DataResult.Error(PolishReadableMessage.Presence.ClassNotFound));
}
ParticipantClassTime participantClassTime = classTime.PresenceParticipants.FirstOrDefault(x => x.ParticipantId == request.ParticipantId);
if (participantClassTime is null)
{
return(DataResult.Error(PolishReadableMessage.Presence.ParticipantNotFound));
}
if (participantClassTime.PresenceType != PresenceType.Help)
{
return(DataResult.Error(PolishReadableMessage.Presence.RemoveWrongType));
}
ClassTimeAggregate classTimeAggregate = ClassTimeAggregate.FromState(classTime);
classTimeAggregate.RemoveParticipant(participantClassTime.ParticipantId);
_context.Remove(participantClassTime);
_context.Update(classTimeAggregate.State);
await _context.SaveChangesAsync(cancellationToken);
return(DataResult.Success());
}
public async Task <DataResult> Handle(Command request, CancellationToken cancellationToken)
{
User participant = await _context.Users.Where(x => x.Id == request.ParticipantId).FirstOrDefaultAsync(cancellationToken);
if (participant is null)
{
return(DataResult.Error(PolishReadableMessage.Presence.ParticipantNotFound));
}
ClassTime classTime = await _context.ClassTimes
.Where(x => x.Id == request.ClassTimeId)
.Include(x => x.PresenceParticipants)
.FirstOrDefaultAsync(cancellationToken);
if (classTime is null)
{
return(DataResult.Error(PolishReadableMessage.Presence.ClassNotFound));
}
ClassTimeAggregate classTimeAggregate = ClassTimeAggregate.FromState(classTime);
ParticipantClassTime participantClassTime = classTimeAggregate.AddParticipant(participant, PresenceType.Help);
participantClassTime.WasPresence = true;
await _context.AddAsync(participantClassTime, cancellationToken);
_context.Update(classTimeAggregate.State);
await _context.SaveChangesAsync(cancellationToken);
return(DataResult.Success());
}
public async Task ExecuteShouldGetSecondPassWhenFirstIsUsed()
{
//Arrange
SchoolManagementContext context = new ContextBuilder().BuildClean();
new RoleBuilder(context).WithName(Roles.Participant).BuildAndSave();
GroupClass groupClass = new GroupClassBuilder(context)
.WithStartClasses(DateTime.Now)
.WithTimeDurationInMinutes(90)
.AddClassDayOfWeek(x => x.WithDate(DayOfWeek.Monday, new TimeSpan(18, 0, 0)))
.AddParticipant(userBuilder => userBuilder.WithName("Piotr", "Kowalski"), ParticipantRole.Follower,
passBuilder => passBuilder.WithNumberOfEntry(2).AsActive())
.WithName("Boogie woogie")
.WithNumberOfClasses(1)
.CreateSchedule().BuildAndSave();
User participant = context.Users.First();
ParticipantGroupClass participantGroupClass = context.GroupClassMembers.First();
new PassBuilder(context)
.WithNumberOfEntry(5)
.WithStartDate(groupClass.StartClasses)
.With(x => x.Used = 5)
.With(x => x.Id = 4)
.WithParticipant(participant)
.WithParticipantGroupClass(participantGroupClass).BuildAndSave();
ClassTime classTime = context.ClassTimes.First();
ParticipantClassTime participantClassTime = classTime.PresenceParticipants.First();
participantClassTime.WasPresence = true;
participantClassTime.PresenceType = PresenceType.Member;
Command command = new Command
{
ParticipantClassTimeId = participantClassTime.Id
};
//Act
DataResult <PassMessage> dataResult = await new Handler(context).Handle(command, CancellationToken.None);
//Assert
participantClassTime.PassId.Should().NotBeNull("all presence member have to contains pass entry");
Pass activePass = context.Passes.First(x => x.Status == Pass.PassStatus.Active);
activePass.Used.Should().Be(1);
activePass.ParticipantClassTimes.Should().HaveCount(1);
Pass noActivePass = context.Passes.First(x => x.Status == Pass.PassStatus.NotActive);
noActivePass.Used.Should().Be(5);
dataResult.Data.Should().NotBeNull();
}
public async Task WhenPassIsOutThenDuplicateAndMarkAsNotPaidAndLogEntryFromNew()
{
//Arrange
SchoolManagementContext context = new ContextBuilder().BuildClean();
new RoleBuilder(context).WithName(Roles.Participant).BuildAndSave();
GroupClass groupClass = new GroupClassBuilder(context)
.WithStartClasses(DateTime.Now)
.WithTimeDurationInMinutes(90)
.AddClassDayOfWeek(x => x.WithDate(DayOfWeek.Monday, new TimeSpan(18, 0, 0)))
.AddParticipant(userBuilder => userBuilder.WithName("Piotr", "Kowalski"), ParticipantRole.Follower,
passBuilder => passBuilder.WithNumberOfEntry(2).AsActive())
.WithName("Boogie woogie")
.WithNumberOfClasses(5)
.CreateSchedule().BuildAndSave();
User participant = context.Users.First();
ClassTime classTime = context.ClassTimes.First();
ParticipantClassTime participantClassTime = classTime.PresenceParticipants.First();
participantClassTime.WasPresence = true;
participantClassTime.PresenceType = PresenceType.Member;
Command command = new Command
{
ParticipantClassTimeId = participantClassTime.Id
};
Pass oldPass = context.Passes.OrderBy(x => x.Id).First();
oldPass.NumberOfEntry = 10;
oldPass.Status = Pass.PassStatus.NotActive;
oldPass.Used = 10;
//Act
DataResult <PassMessage> dataResult = await new Handler(context).Handle(command, CancellationToken.None);
//Assert
participantClassTime.PassId.Should().NotBeNull("presence for make up have to contain pass ");
context.Passes.Should().HaveCount(2);
Pass newPass = context.Passes.OrderBy(x => x.Id).Last();
newPass.WasGenerateAutomatically.Should().BeTrue("we generate this pass");
newPass.Status.Should().Be(Pass.PassStatus.Active);
newPass.Used.Should().Be(1);
newPass.Start.Should().Be(participantClassTime.ClassTime.StartDate);
newPass.ParticipantClassTimes.Should().HaveCount(1);
dataResult.Data.Should().NotBeNull();
}
public async Task ExecuteShouldReturnPassAndRemoveWhenItWasGenerated()
{
//Arrange
SchoolManagementContext context = new ContextBuilder().BuildClean();
new RoleBuilder(context).WithName(Roles.Participant).BuildAndSave();
GroupClass groupClass = new GroupClassBuilder(context)
.WithStartClasses(DateTime.Now)
.WithTimeDurationInMinutes(90)
.AddClassDayOfWeek(x => x.WithDate(DayOfWeek.Monday, new TimeSpan(18, 0, 0)))
.AddParticipant(userBuilder => userBuilder.WithName("Piotr", "Kowalski"), ParticipantRole.Follower,
passBuilder => passBuilder.WithNumberOfEntry(2).AsActive())
.WithName("Boogie woogie")
.WithNumberOfClasses(5)
.CreateSchedule().BuildAndSave();
ParticipantGroupClass participantGroupClass = groupClass.Participants.First();
ParticipantClassTime participantClassTime = context.ParticipantPresences.First();
Pass pass = new PassBuilder(context)
.WithParticipant(participantGroupClass.User)
.WithParticipantGroupClass(participantGroupClass)
.WithNumberOfEntry(2)
.With(x => x.ParticipantClassTimes.Add(participantClassTime))
.With(x => x.Used = 0).BuildAndSave();
Pass generatedPass = new PassBuilder(context).AsActive()
.WithParticipant(participantGroupClass.User)
.WithParticipantGroupClass(participantGroupClass)
.With(x => x.WasGenerateAutomatically = true)
.WithNumberOfEntry(2)
.With(x => x.ParticipantClassTimes.Add(participantClassTime))
.With(x => x.Used = 0).BuildAndSave();
PassAggregate.FromState(generatedPass).UsePass(participantClassTime);
context.Update(participantClassTime);
await context.SaveChangesAsync();
Command command = new Command
{
ParticipantId = participantGroupClass.UserId,
ClassTimeId = participantClassTime.ClassTimeId
};
//Act
DataResult dataResult = await new Handler(context).Handle(command, CancellationToken.None);
//Assert
context.Passes.Should().NotContain(generatedPass);
context.Passes.Should().Contain(pass);
pass.Used.Should().Be(0);
}
public async Task <DataResult <int> > Handle(Command request, CancellationToken cancellationToken)
{
ParticipantClassTime participantClassTime = await _context.ParticipantPresences
.Where(x => x.ParticipantId == request.ParticipantId && x.ClassTimeId == request.ClassTimeId)
.FirstOrDefaultAsync(cancellationToken);
if (participantClassTime is null)
{
return(DataResult <int> .Error(PolishReadableMessage.Presence.ParticipantNotFound));
}
participantClassTime.WasPresence = request.IsPresence;
_context.Update(participantClassTime);
await _context.SaveChangesAsync(cancellationToken);
return(DataResult <int> .Success(participantClassTime.Id));
}
private async Task GenerateNextPass(CancellationToken cancellationToken, List <Model.Domain.Pass> passes, DateTime startDate,
ParticipantClassTime participantPresence)
{
Model.Domain.Pass lastPass = passes.Where(x => x.Status == Model.Domain.Pass.PassStatus.NotActive)
.OrderBy(x => x.PassNumber).First();
Model.Domain.Pass newPass = lastPass.Copy();
PassAggregate newPassAggregate = PassAggregate.FromState(newPass);
newPassAggregate.AsActive()
.WithStartDate(startDate)
.WithPassNumber(passes.Count)
.AsGenerateAutomatically();
newPassAggregate.UsePass(participantPresence);
await _context.AddAsync(newPassAggregate.State, cancellationToken);
_context.Update(participantPresence);
await _context.SaveChangesAsync(cancellationToken);
}
public async Task ExecuteShouldRemoveAdditionalUser()
{
SchoolManagementContext context = new ContextBuilder().BuildClean();
User user = new UserBuilder(context).BuildAndSave();
new RoleBuilder(context).WithName(Roles.Participant).BuildAndSave();
GroupClass makeUpClass = new GroupClassBuilder(context)
.WithStartClasses(DateTime.Now.Subtract(TimeSpan.FromDays(30)))
.WithNumberOfClasses(14)
.AddClassDayOfWeek(x => x.WithDate(DayOfWeek.Monday, TimeSpan.FromHours(18)))
.AddParticipant(x => x.WithEmail("*****@*****.**"), ParticipantRole.Follower, passBuilder => passBuilder.AsActive())
.AddParticipant(x => x.WithUser(user), ParticipantRole.Follower, passBuilder => passBuilder.AsActive())
.WithTimeDurationInMinutes(90)
.CreateSchedule()
.BuildAndSave();
ClassTime classTime = context.ClassTimes.First(x => x.GroupClassId == makeUpClass.Id);
ParticipantClassTime additionUser = classTime.PresenceParticipants.First(x => x.ParticipantId == user.Id);
additionUser.PresenceType = PresenceType.Help;
additionUser.WasPresence = true;
context.Update(additionUser);
context.SaveChanges();
Command command = new Command
{
ParticipantId = additionUser.ParticipantId,
ClassTimeId = classTime.Id
};
DataResult dataResult = await new Handler(context).Handle(command, CancellationToken.None);
dataResult.Status.Should().Be(DataResult.ResultStatus.Success);
classTime.PresenceParticipants.Should().HaveCount(1);
}
public async Task <DataResult <PassMessage> > Handle(Command request, CancellationToken cancellationToken)
{
ParticipantClassTime participantPresence = await _context.ParticipantPresences
.Where(x => x.Id == request.ParticipantClassTimeId)
.FirstOrDefaultAsync(cancellationToken);
var classTimes = await _context.ClassTimes.Where(x => x.Id == participantPresence.ClassTimeId).Select(x => new { x.GroupClassId, x.StartDate }).FirstOrDefaultAsync(cancellationToken);
List <Model.Domain.Pass> passes = await _context.Passes
.Include(x => x.ParticipantGroupClass)
.Where(x => x.ParticipantId == participantPresence.ParticipantId)
.Where(x => x.ParticipantGroupClass.GroupClassId == classTimes.GroupClassId)
.ToListAsync(cancellationToken);
Model.Domain.Pass activePass = passes
.Where(x => x.Status == Model.Domain.Pass.PassStatus.Active)
.OrderBy(x => x.PassNumber)
.FirstOrDefault();
if (activePass is null)
{
await GenerateNextPass(cancellationToken, passes, classTimes.StartDate, participantPresence);
return(DataResult <PassMessage> .Success(PassMessage.Error("Brak ważnego karnetu")));
}
PassAggregate passAggregate = PassAggregate.FromState(activePass);
passAggregate.UsePass(participantPresence);
_context.Update(passAggregate.State);
_context.Update(participantPresence);
await _context.SaveChangesAsync(cancellationToken);
return(DataResult <PassMessage> .Success(PassMessage.Success("Udanej nauki!")));
}
public async Task <DataResult> Handle(Command request, CancellationToken cancellationToken)
{
ParticipantClassTime participantPresence = await _context.ParticipantPresences
.Include(x => x.Pass)
.Where(x => x.ParticipantId == request.ParticipantId)
.Where(x => x.ClassTimeId == request.ClassTimeId)
.FirstOrDefaultAsync(cancellationToken);
Model.Domain.Pass pass = participantPresence.Pass;
if (pass is null)
{
if (participantPresence.PresenceType != PresenceType.Help)
{
return(DataResult.Error("Karnet nie został zarejestrowany "));
}
return(DataResult.Success());
}
PassAggregate passAggregate = PassAggregate.FromState(pass);
passAggregate.ReturnPass(participantPresence);
if (pass.WasGenerateAutomatically && pass.Used == 0)
{
_context.Remove(pass);
}
else
{
_context.Update(pass);
}
_context.Update(participantPresence);
await _context.SaveChangesAsync(cancellationToken);
return(DataResult.Success());
}
public async Task ExecuteShouldAddGroupAndAddPresence()
{
SchoolManagementContext context = new ContextBuilder().BuildClean();
GroupLevel groupLevel = new GroupLevelBuilder(context).With(x => x.Level = 1).With(x => x.Name = "Początkujący").BuildAndSave();
Room room = new RoomBuilder(context).WithName("Sala biała").BuildAndSave();
User anchor = new UserBuilder(context).WithEmail("*****@*****.**").BuildAndSave();
Role role = new RoleBuilder(context).WithName(Roles.Anchor).AddUserToRole(anchor).BuildAndSave();
List <User> participants = new List <User>();
var participantRoleBuilder = new RoleBuilder(context).WithName(Roles.Participant);
for (var i = 0; i < 10; i++)
{
User user = new UserBuilder(context).WithEmail($"email{i}@gmail.com").BuildAndSave();
participants.Add(user);
participantRoleBuilder.AddUserToRole(user);
}
participantRoleBuilder.BuildAndSave();
Command cmd = new Command
{
Name = "Groupa zajęciowa",
Anchors = new List <string> {
anchor.Id
},
IsSolo = true,
ParticipantLimit = 20,
PassPrice = 200,
GroupLevelId = groupLevel.Id,
UtcOffsetInMinutes = 0,
Participants = participants.Select(x => new ParticipantDto
{
Id = x.Id,
Role = ParticipantRole.Leader
}).ToList(),
RoomId = room.Id,
DayOfWeeks = new List <ClassDayOfWeekDto>
{
new ClassDayOfWeekDto()
{
DayOfWeek = System.DayOfWeek.Monday,
BeginTime = new TimeSpan(18, 0, 0)
},
new ClassDayOfWeekDto()
{
DayOfWeek = System.DayOfWeek.Thursday,
BeginTime = new TimeSpan(19, 0, 0)
}
},
Start = new DateTime(2019, 09, 01), //Sunday
DurationTimeInMinutes = 90,
NumberOfClasses = 20
};
DataResult dataResult = await new Handler(context).Handle(cmd, CancellationToken.None);
dataResult.Status.Should().Be(DataResult.ResultStatus.Success, "all parameters are corrected");
context.ParticipantPresences.Should().NotBeNullOrEmpty()
.And.HaveCount(cmd.NumberOfClasses * cmd.Participants.Count)
.And.NotContainNulls(x => x.ClassTime)
.And.NotContainNulls(x => x.Participant);
context.ClassTimes.Should().NotBeEmpty().And.HaveCount(cmd.NumberOfClasses).And
.NotContainNulls(x => x.PresenceParticipants);
ClassTime classTime = context.ClassTimes.First();
classTime.PresenceParticipants.Should().HaveCount(10);
ParticipantClassTime participantClassTime = context.ParticipantPresences.First();
AssertPass(context, participants, cmd);
}
