Esempio n. 1
0
        public override async Task <MeetingDto> CreateMeeting(CreateMeetingCommandDto request, ServerCallContext context)
        {
            var result = await db.Meetings.AddAsync(new Meeting
            {
                UserId      = Guid.Parse(request.UserId),
                Start       = request.Start.ToDateTimeOffset(),
                End         = request.End.ToDateTimeOffset(),
                Name        = request.Name,
                Description = request.Descripton
            }, context.CancellationToken);

            await db.SaveChangesAsync(context.CancellationToken);

            return(result.Entity.ToTransfer());
        }
Esempio n. 2
0
        public async Task <Meeting> Handle(CreateMeetingCommand request, CancellationToken cancellationToken)
        {
            var userOidc = auth.GetUserIdentifier();
            var user     = await db.Users
                           .SingleOrDefaultAsync(u => u.OidcIdentifier == userOidc, cancellationToken);

            if (user == null)
            {
                throw new NotFoundException($"Unable to find user with {userOidc}");
            }

            var invited = await db.Users
                          .Where(u => request.InvitedUserIds.Contains(u.Id))
                          .ToListAsync(cancellationToken);

            //invited.Add(user);

            var result = await db.Meetings.AddAsync(new Meeting
            {
                Creator     = user,
                Title       = request.Title,
                Invitations = invited.Select(i => new Invitation {
                    User = i
                }).ToList(),
                Proposals = request.Proposals.Select(p => new Proposal {
                    Time = p
                }).ToList(),
            }, cancellationToken);

            await db.SaveChangesAsync(cancellationToken);

            return(result.Entity);
        }
Esempio n. 3
0
        public async Task <User> Handle(CreateUserCommand request, CancellationToken cancellationToken)
        {
            var result = await db.Users.AddAsync(new User
            {
                Name           = request.Name,
                Email          = request.Email,
                OidcIdentifier = auth.GetUserIdentifier()
            }, cancellationToken);

            await db.SaveChangesAsync(cancellationToken);

            return(result.Entity);
        }
Esempio n. 4
0
        public async Task <Meeting> Handle(EjectCommand request, CancellationToken cancellationToken)
        {
            var userOidc = auth.GetUserIdentifier();
            var user     = await db.Users
                           .AsNoTracking()
                           .SingleOrDefaultAsync(u => u.OidcIdentifier == userOidc, cancellationToken);

            if (user == null)
            {
                throw new NotFoundException($"Unable to find user {userOidc}");
            }

            var uninvitedUser = await db.Users
                                .SingleOrDefaultAsync(u => u.Id == request.UserId, cancellationToken);

            if (user == null)
            {
                throw new NotFoundException($"Unable to find user {request.UserId}");
            }

            var meeting = await db.Meetings
                          .Include(m => m.Creator)
                          .Include(m => m.Proposals)
                          .Include(m => m.Invitations)
                          .ThenInclude(i => i.User)
                          .Include(m => m.Invitations)
                          .ThenInclude(i => i.Votes)
                          .FirstOrDefaultAsync(m => m.Id == request.MeetingId, cancellationToken);

            if (meeting == null)
            {
                throw new NotFoundException($"Unable to find meeting {request.MeetingId}");
            }

            if (meeting.Creator.Id != user.Id)
            {
                throw new ForbiddenException($"User {user.OidcIdentifier} is not eligible to view meeting {request.MeetingId}");
            }

            if (meeting.Invitations.All(i => i.User.Id != request.UserId))
            {
                throw new NotFoundException($"User {request.UserId} is not invited to meeting {request.MeetingId}");
            }

            meeting.Invitations.RemoveAll(i => i.User.Id == request.UserId);

            var result = db.Meetings.Attach(meeting);
            await db.SaveChangesAsync(cancellationToken);

            return(result.Entity);
        }
 public async Task <int> Commit()
 {
     return(await _meetingsContext.SaveChangesAsync());
 }