Exemplo n.º 1
0
        public async Task <DataResult <int> > Handle(Command request, CancellationToken cancellationToken)
        {
            User participant = await _context.Users.Where(x => x.Id == request.ParticipantId).FirstOrDefaultAsync(cancellationToken);

            if (participant is null)
            {
                return(DataResult <int> .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 <int> .Error(PolishReadableMessage.Presence.ClassNotFound));
            }


            var makeUpClassTime = await _context.ParticipantPresences
                                  .Include(x => x.ClassTime)
                                  .Where(x => x.ParticipantId == request.ParticipantId)
                                  .Where(x => !x.WasPresence)
                                  .Where(x => x.PresenceType == PresenceType.None)
                                  .Where(x => x.ClassTime.StartDate < classTime.StartDate)
                                  .OrderBy(x => x.ClassTime.StartDate)
                                  .FirstOrDefaultAsync(cancellationToken);

            if (makeUpClassTime is null)
            {
                return(DataResult <int> .Error(PolishReadableMessage.Presence.MakeUpClassNotFound));
            }


            ClassTimeAggregate classTimeAggregate = ClassTimeAggregate.FromState(classTime);

            ParticipantClassTime participantClassTime = classTimeAggregate.AddParticipant(participant, makeUpClassTime);

            participantClassTime.WasPresence = true;
            await _context.AddAsync(participantClassTime, cancellationToken);

            _context.Update(makeUpClassTime);
            _context.Update(classTimeAggregate.State);
            await _context.SaveChangesAsync(cancellationToken);

            return(DataResult <int> .Success(makeUpClassTime.Id));
        }
Exemplo n.º 2
0
        public async Task <DataResult <ClaimsPrincipal> > Handle(Command request, CancellationToken cancellationToken)
        {
            Model.Domain.User user = await _signInManager.UserManager.FindByEmailAsync(request.Email);

            if (user == null)
            {
                return(DataResult <ClaimsPrincipal> .Error(PolishReadableMessage.Auth.WrongLoginOrPassword));
            }

            SignInResult resultPassword =
                await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);

            if (resultPassword.Succeeded)
            {
                if (user.EmailConfirmed)
                {
                    user.UtcOffsetInMinutes = request.UtcOffsetInMinutes;
                    _context.Update(user);
                    await _context.SaveChangesAsync(cancellationToken);

                    await _signInManager.SignInAsync(user, request.RememberMe);

                    ClaimsPrincipal claimsPrincipal = await _signInManager.CreateUserPrincipalAsync(user);

                    return(DataResult <ClaimsPrincipal> .Success(claimsPrincipal));
                }

                return(DataResult <ClaimsPrincipal> .Error(PolishReadableMessage.Auth.AccountNotActive));
            }

            return(DataResult <ClaimsPrincipal> .Error(PolishReadableMessage.Auth.WrongLoginOrPassword));
        }
Exemplo n.º 3
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Hours,TeacherId")] Course course)
        {
            if (id != course.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(course);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!CourseExists(course.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["TeacherId"] = new SelectList(_context.Teachers, "Id", "Id", course.TeacherId);
            return(View(course));
        }
Exemplo n.º 4
0
        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 <IActionResult> Edit(int id, [Bind("Id,Name,Lastname")] Teacher teacher)
        {
            if (id != teacher.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(teacher);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!TeacherExists(teacher.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(teacher));
        }
Exemplo n.º 6
0
        public async Task <DataResult> Handle(Command request, CancellationToken cancellationToken)
        {
            Model.Domain.Pass pass = await _context.Passes
                                     .Where(x => x.Id == request.Id)
                                     .Include(x => x.ParticipantClassTimes)
                                     .FirstOrDefaultAsync(cancellationToken);

            if (pass is null)
            {
                return(DataResult.Error(PolishReadableMessage.Pass.NotFound));
            }

            if (pass.Used == 0 && !pass.ParticipantClassTimes.Any())
            {
                _context.Remove(pass);
                await _context.SaveChangesAsync(cancellationToken);

                return(DataResult.Success());
            }

            PassAggregate.FromState(pass)
            .AsRemoved();
            _context.Update(pass);
            await _context.SaveChangesAsync(cancellationToken);

            return(DataResult.Success());
        }
Exemplo n.º 7
0
        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!")));
        }
Exemplo n.º 8
0
        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());
        }
Exemplo n.º 9
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));
        }
Exemplo n.º 10
0
        public async Task <DataResult> Handle(Command request, CancellationToken cancellationToken)
        {
            ParticipantGroupClass member = await _context.GroupClassMembers
                                           .Where(x => x.Id == request.MemberId)
                                           .Include(x => x.Passes)
                                           .FirstOrDefaultAsync(cancellationToken);

            Model.Domain.Pass pass = member.Passes.FirstOrDefault();
            if (pass != null)
            {
                pass.Paid = request.Status;
                _context.Update(pass);
            }

            await _context.SaveChangesAsync(cancellationToken);

            return(DataResult.Success());
        }
Exemplo n.º 11
0
        public async Task <DataResult> Handle(Command request, CancellationToken cancellationToken)
        {
            PassAggregate passAggregate = PassAggregate.New();

            passAggregate.UpdateByCommand(request);

            ParticipantGroupClass participantGroupClass = await _context.GroupClassMembers.Where(x => x.Id == request.MemberId)
                                                          .Include(x => x.Passes)
                                                          .Include(x => x.User)
                                                          .Include(x => x.GroupClass)
                                                          .FirstOrDefaultAsync(cancellationToken);

            passAggregate.WithParticipant(participantGroupClass.User)
            .WithPassNumber(participantGroupClass.Passes.Count)
            .WithStartDate(participantGroupClass.GroupClass.StartClasses);

            participantGroupClass.Passes.Add(passAggregate.State);
            _context.Update(participantGroupClass);
            await _context.Passes.AddAsync(passAggregate.State, cancellationToken);

            await _context.SaveChangesAsync(cancellationToken);

            return(DataResult.Success());
        }
Exemplo n.º 12
0
        public async Task <bool> Handle(Command request, CancellationToken cancellationToken)
        {
            Room room = await _context.Rooms.Where(x => x.Id == request.Id).FirstOrDefaultAsync(cancellationToken);

            Room newRoom = new Room().WithName(request.Name);

            if (newRoom.NormalizeName != room.NormalizeName)
            {
                bool isNameExist = await _context.Rooms.AnyAsync(x => x.NormalizeName == newRoom.NormalizeName, cancellationToken);

                if (isNameExist)
                {
                    throw new EditRoomException(PolishReadableMessage.Room.NameDuplicate);
                }

                room.WithName(newRoom.Name);
            }

            room.WithColor(request.Color);
            _context.Update(room);
            await _context.SaveChangesAsync(cancellationToken);

            return(true);
        }