示例#1
0
        public async Task AddBlacklistUser(int userId, int roomId)
        {
            try
            {
                ChatHubUser user = await this.GetChatHubUserAsync();

                ChatHubUser targetUser = await this.chatHubRepository.GetUserByIdAsync(userId);

                if (user != null && targetUser != null)
                {
                    var room = this.chatHubRepository.GetChatHubRoom(roomId);
                    if (user.UserId != room.CreatorId && !Context.User.HasClaim(ClaimTypes.Role, RoleNames.Admin))
                    {
                        throw new HubException("Only room creators and administrators can add blacklist users.");
                    }

                    ChatHubBlacklistUser blacklistUser = this.chatHubRepository.AddChatHubBlacklistUser(targetUser);

                    ChatHubRoomChatHubBlacklistUser room_blacklistuser = new ChatHubRoomChatHubBlacklistUser()
                    {
                        ChatHubRoomId          = roomId,
                        ChatHubBlacklistUserId = blacklistUser.Id,
                    };
                    this.chatHubRepository.AddChatHubRoomChatHubBlacklistUser(room_blacklistuser);

                    var targetBlacklistUserClientModel = this.chatHubService.CreateChatHubBlacklistUserClientModel(blacklistUser);
                    await Clients.Group(roomId.ToString()).SendAsync("AddBlacklistUser", targetBlacklistUserClientModel, roomId);
                }
            }
            catch (Exception ex)
            {
                throw new HubException(ex.Message);
            }
        }
示例#2
0
 public void DeleteChatHubRoomChatHubBlacklistUser(int ChatHubRoomId, int ChatHubBlacklistUserId)
 {
     try
     {
         ChatHubRoomChatHubBlacklistUser item = this.GetChatHubRoomChatHubBlacklistUser(ChatHubRoomId, ChatHubBlacklistUserId);
         if (item != null)
         {
             db.ChatHubRoomChatHubBlacklistUser.Remove(item);
             db.SaveChanges();
         }
     }
     catch
     {
         throw;
     }
 }
示例#3
0
        public ChatHubRoomChatHubBlacklistUser AddChatHubRoomChatHubBlacklistUser(ChatHubRoomChatHubBlacklistUser ChatHubRoomChatHubBlacklistUser)
        {
            try
            {
                var item = this.GetChatHubRoomChatHubBlacklistUser(ChatHubRoomChatHubBlacklistUser.ChatHubRoomId, ChatHubRoomChatHubBlacklistUser.ChatHubBlacklistUserId);
                if (item == null)
                {
                    db.ChatHubRoomChatHubBlacklistUser.Add(ChatHubRoomChatHubBlacklistUser);
                    db.SaveChanges();
                    return(ChatHubRoomChatHubBlacklistUser);
                }

                return(item);
            }
            catch
            {
                throw;
            }
        }
        public override async Task Execute(CommandServicesContext context, CommandCallerContext callerContext, string[] args, ChatHubUser caller)
        {
            if (args.Length == 0)
            {
                await context.ChatHub.SendClientNotification("No arguments found.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);

                return;
            }

            string targetUserName = args[0];

            ChatHubUser targetUser = await context.ChatHubRepository.GetUserByDisplayName(targetUserName);

            targetUser = targetUser == null ? await context.ChatHubRepository.GetUserByUserNameAsync(targetUserName) : targetUser;

            if (targetUser == null)
            {
                await context.ChatHub.SendClientNotification("No user found.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);

                return;
            }

            if (!targetUser.Online())
            {
                await context.ChatHub.SendClientNotification("User not online.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);

                return;
            }

            if (caller.UserId == targetUser.UserId)
            {
                await context.ChatHub.SendClientNotification("Calling user can not be target user.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);

                return;
            }

            string msg = null;

            if (args.Length > 1)
            {
                msg = String.Join(" ", args.Skip(1)).Trim();
            }

            var callerRoom = context.ChatHubRepository.GetChatHubRoom(callerContext.RoomId);

            if (caller.UserId != callerRoom.CreatorId)
            {
                await context.ChatHub.SendClientNotification("Blacklist user command can be executed from room creator only.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);

                return;
            }

            if (callerRoom.Public() || callerRoom.Protected() || callerRoom.Private())
            {
                ChatHubBlacklistUser chatHubBlacklistUser = context.ChatHubRepository.AddChatHubBlacklistUser(targetUser);

                ChatHubRoomChatHubBlacklistUser room_blacklistuser = new ChatHubRoomChatHubBlacklistUser()
                {
                    ChatHubRoomId          = callerRoom.Id,
                    ChatHubBlacklistUserId = chatHubBlacklistUser.Id,
                };
                context.ChatHubRepository.AddChatHubRoomChatHubBlacklistUser(room_blacklistuser);

                foreach (var connection in caller.Connections.Active())
                {
                    await context.ChatHub.SendClientNotification("Command blacklist user succeeded.", callerContext.RoomId, connection.ConnectionId, caller, ChatHubMessageType.System);
                }
            }
        }