Beispiel #1
0
        public async Task <GetUserResponse> Handle(GetUserRequest request, CancellationToken cancellationToken)
        {
            string currentUserId = httpContextReader.CurrentUserId;

            var user = await userService.GetUser(request.UserId, currentUserId);

            var userToReturn = !await rolesService.IsPermitted(currentUserId, RoleName.Admin)
                ? (UserDtoBase)mapper.Map <UserDto>(user)
                : mapper.Map <UserAdminDto>(user);

            if (user != null)
            {
                userToReturn = FriendUtils.SetFriendProperties(userToReturn, user, currentUserId);

                user.SortPosts();

                var userGroups = user.Groups.Concat(user.GroupMembers.Where(m => m.IsAccepted).Select(m => m.Group))
                                 .ToList();

                GroupUtils.SetGroupMemberParams(userToReturn.Groups.ToList(), userGroups, currentUserId);

                return(new GetUserResponse {
                    User = userToReturn
                });
            }

            throw new CrudException("User cannot be loaded");
        }
Beispiel #2
0
        public async Task <ToggleReportStatusResult> ToggleReportStatus(string reportId)
        {
            if (!rolesService.IsPermitted(await profileService.GetCurrentUser(), Constants.SupportRoles))
            {
                throw new NoPermissionsException("You are not permitted to toggle this report status");
            }

            var report = await GetReport(reportId);

            if (report.ReporterId == null)
            {
                return(null);
            }

            report.ToggleStatus();

            return(await database.Complete() ? new ToggleReportStatusResult(report.IsClosed) : null);
        }
Beispiel #3
0
        public async Task <bool> DeleteRoom(string roomId)
        {
            bool isAdmin = await rolesService.IsPermitted(RoleName.Admin, currentUserId);

            var room = await database.ChatRoomRepository.Find(c => c.Id == roomId && (c.CreatorId == currentUserId || isAdmin));

            database.ChatRoomRepository.Delete(room);

            return(await database.Complete());
        }
Beispiel #4
0
        public async Task <bool> ArrangeTask(string description, DateTime dateDeadline)
        {
            var task = !await rolesService.IsPermitted(RoleName.Admin, currentUserId)
                ? new TaskItemBuilder()
                       .SetDescription(description)
                       .SetDeadline(dateDeadline)
                       .WithExecutor(currentUserId)
                       .SetProgress(TaskProgress.Assigned)
                       .Build()
                : new TaskItemBuilder()
                       .SetDescription(description)
                       .SetDeadline(dateDeadline)
                       .WithExecutor()
                       .SetProgress()
                       .Build();

            database.TaskRepository.Add(task);

            return(await database.Complete());
        }
Beispiel #5
0
        public async Task <Report> GetReport(string reportId, string userId)
        {
            var report = (await database.ReportRepository.Find(r => r.Id == reportId))?.SortReplies()
                         ?? throw new EntityNotFoundException("Report not found");

            if (report.ReporterId != userId && !await rolesService.IsPermitted(userId, Constants.SupportRoles))
            {
                throw new NoPermissionsException("This is not your report");
            }

            return(report);
        }
 public async Task <IViewComponentResult> InvokeAsync()
 => View(await rolesService.IsPermitted(RoleName.Admin, httpContextAccessor.HttpContext.GetCurrentUserId()));