Exemple #1
0
        public async Task AddWhitelistUser(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 whitelist users.");
                    }

                    ChatHubWhitelistUser whitelistUser = this.chatHubRepository.AddChatHubWhitelistUser(targetUser);

                    ChatHubRoomChatHubWhitelistUser room_whitelistuser = new ChatHubRoomChatHubWhitelistUser()
                    {
                        ChatHubRoomId          = roomId,
                        ChatHubWhitelistUserId = whitelistUser.Id,
                    };
                    this.chatHubRepository.AddChatHubRoomChatHubWhitelistUser(room_whitelistuser);

                    var targetWhitelistUserClientModel = this.chatHubService.CreateChatHubWhitelistUserClientModel(whitelistUser);
                    await Clients.Group(roomId.ToString()).SendAsync("AddWhitelistUser", targetWhitelistUserClientModel, roomId);
                }
            }
            catch (Exception ex)
            {
                throw new HubException(ex.Message);
            }
        }
Exemple #2
0
 public void DeleteChatHubRoomChatHubWhitelistUser(int ChatHubRoomId, int ChatHubWhitelistUserId)
 {
     try
     {
         ChatHubRoomChatHubWhitelistUser item = this.GetChatHubRoomChatHubWhitelistUser(ChatHubRoomId, ChatHubWhitelistUserId);
         if (item != null)
         {
             db.ChatHubRoomChatHubWhitelistUser.Remove(item);
             db.SaveChanges();
         }
     }
     catch
     {
         throw;
     }
 }
Exemple #3
0
        public ChatHubRoomChatHubWhitelistUser AddChatHubRoomChatHubWhitelistUser(ChatHubRoomChatHubWhitelistUser ChatHubRoomChatHubWhitelistUser)
        {
            try
            {
                var item = this.GetChatHubRoomChatHubWhitelistUser(ChatHubRoomChatHubWhitelistUser.ChatHubRoomId, ChatHubRoomChatHubWhitelistUser.ChatHubWhitelistUserId);
                if (item == null)
                {
                    db.ChatHubRoomChatHubWhitelistUser.Add(ChatHubRoomChatHubWhitelistUser);
                    db.SaveChanges();
                    return(ChatHubRoomChatHubWhitelistUser);
                }

                return(item);
            }
            catch
            {
                throw;
            }
        }
Exemple #4
0
        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("Whitelist user command can be executed from room creator only.", callerContext.RoomId, callerContext.ConnectionId, caller, ChatHubMessageType.System);

                return;
            }

            if (callerRoom.Public() || callerRoom.Protected() || callerRoom.Private())
            {
                ChatHubWhitelistUser chatHubWhitelistUser = context.ChatHubRepository.AddChatHubWhitelistUser(targetUser);

                ChatHubRoomChatHubWhitelistUser room_whitelistuser = new ChatHubRoomChatHubWhitelistUser()
                {
                    ChatHubRoomId          = callerRoom.Id,
                    ChatHubWhitelistUserId = chatHubWhitelistUser.Id,
                };
                context.ChatHubRepository.AddChatHubRoomChatHubWhitelistUser(room_whitelistuser);

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