Exemple #1
0
        public async Task <IActionResult> BlockUser(BlockUserViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var userId   = userService.GetCurrentUserId(HttpContext);
            var response = await friendshipService.BlockUser(userId, viewModel.UserID).ConfigureAwait(false);

            if (!response.IsSuccess)
            {
                return(BadRequest(response.Message));
            }

            var(requestedFriends, receivedFriends) = await friendshipService.GetUserFriends(userId).ConfigureAwait(false);

            var requestedFriendsViewModel = mapper.Map <IEnumerable <(User, FriendshipStatus)>, IEnumerable <OutFriendViewModel> >(requestedFriends);
            var receivedFriendsViewModel  = mapper.Map <IEnumerable <(User, FriendshipStatus)>, IEnumerable <OutFriendViewModel> >(receivedFriends);

            return(Ok(new
            {
                requestedFriends = requestedFriendsViewModel,
                receivedFriends = receivedFriendsViewModel
            }));
        }
        public async Task <IHttpActionResult> RemoveFriend([FromBody] BlockUserViewModel model)
        {
            var user    = GetUserLogin();
            var idUser1 = user.Id;
            var friend  = context.Friends
                          .FirstOrDefault(t => (t.User1Id == idUser1 && t.User2Id == model.IdUser) ||
                                          (t.User1Id == model.IdUser && t.User2Id == idUser1));

            if (friend == null)
            {
                return(NotFound());
            }
            context.Friends.Remove(friend);
            await context.SaveChangesAsync();

            return(Ok());
        }
        public async Task <IHttpActionResult> BlockUser([FromBody] BlockUserViewModel model)
        {
            var myUser    = GetUserLogin();
            var blockUser = context.BlockUsers.FirstOrDefault(t => t.UserID.Equals(myUser.Id) && t.UserBlockId.Equals(model.IdUser));

            if (blockUser == null)
            {
                BlockUser block = new BlockUser()
                {
                    UserID      = myUser.Id,
                    UserBlockId = model.IdUser
                };
                context.BlockUsers.Add(block);
                await context.SaveChangesAsync();
            }
            return(Ok());
        }
        public async Task <IActionResult> BlockUser(Guid accountId, [FromBody] BlockUserViewModel model)
        {
            if (ModelState.IsValid)
            {
                var admin = await _userManager.GetUserAsync(HttpContext.User);

                var user = await _userManager.FindByIdAsync(accountId.ToString());

                if (user == null || admin == null)
                {
                    return(BadRequest(Constants.Errors.UserNotFoundError));
                }
                var roles = await _userManager.GetRolesAsync(user);

                var roleResultRemove = await _userManager.RemoveFromRolesAsync(user, roles);

                var roleResultAdd = await _userManager.AddToRoleAsync(user,
                                                                      Constants.Authorization.BlockedUser);

                if (roleResultRemove.Succeeded && roleResultAdd.Succeeded)
                {
                    var lockoutResult = await _userManager.SetLockoutEndDateAsync(user, DateTimeOffset.MaxValue);

                    if (lockoutResult.Succeeded)
                    {
                        await _emailSender.SendBlockedUserAsync(user.Email, admin.Email, model.Reason, true);

                        return(Ok());
                    }
                    return(BadRequest(lockoutResult.Errors.Select(e => e.Code).FirstOrDefault()));
                }

                if (!roleResultRemove.Succeeded)
                {
                    return(BadRequest(roleResultAdd.Errors.Select(e => e.Code).FirstOrDefault()));
                }

                if (!roleResultRemove.Succeeded)
                {
                    return(BadRequest(roleResultRemove.Errors.Select(e => e.Code).FirstOrDefault()));
                }
            }

            return(BadRequest(Constants.Errors.InvalidInput));
        }
Exemple #5
0
        public ActionResult BlockUser(BlockUserViewModel model)
        {
            BanAccount banAccount = new BanAccount();

            banAccount.BannedDate        = DateTime.Now;
            banAccount.Duration          = model.Duration;
            banAccount.UnBanedDate       = DateTime.Now.AddDays(banAccount.Duration);
            banAccount.BannedUser        = cService.GetUser(model.BannedUserId);
            banAccount.BannedUser.Status = UserStatusEnum.Banned;
            banAccount.BanUser           = cService.GetUser(User.Identity.GetUserId <int>());
            banAccount.Description       = model.Description;
            banAccount.BanReasons        = aService.GetListBanReason(model.Reasons);
            aService.BlockUser(banAccount);

            Notification notification = new Notification();

            notification.AuthorId    = _currentUserId;
            notification.CreatedDate = DateTime.Now;
            notification.Content     = banAccount.Duration + " ngày. Bắt đầu từ ngày " + banAccount.BannedDate.ToShortDateString();
            notification.Seen        = false;
            notification.Type        = NotificationSettingEnum.Banned;
            notification.UserId      = model.BannedUserId;
            notification.Link        = Url.Action("BannedPage", "Account");
            cService.AddNotification(notification);

            using (RealTimeService rService = new RealTimeService(new CPMathHubModelContainer(), notification.UserId))
            {
                IEnumerable <string> connectionIds = RealTimeHub.Connections.GetConnections(notification.UserId);
                foreach (string conId in connectionIds)
                {
                    _hub.Clients.Client(conId).notifyNewActivity(rService.CountNewActivityNotification());
                }
            }

            return(PartialView("Partials/_HistoryBlockUserPartialView", banAccount.BannedUser));
        }