Example #1
0
        public async Task HandleAsync()
        {
            NodeResponse response;

            try
            {
                switch (request.RequestType)
                {
                case Enums.NodeRequestType.GetChats:
                {
                    IEnumerable <ChatVm> chats = await loadChatsService.GetChatsByIdAsync(request.ObjectsId, request.RequestorUserId).ConfigureAwait(false);

                    response = new ChatsNodeResponse(request.RequestId, chats);
                }
                break;

                case Enums.NodeRequestType.GetUsers:
                {
                    IEnumerable <UserVm> users = await loadUsersService.GetUsersByIdAsync(request.ObjectsId, request.RequestorUserId).ConfigureAwait(false);

                    users = await privacyService.ApplyPrivacySettingsAsync(users, request.RequestorUserId).ConfigureAwait(false);

                    response = new UsersNodeResponse(request.RequestId, users);
                }
                break;

                case Enums.NodeRequestType.GetChannels:
                {
                    IEnumerable <ChannelDto> channels = await loadChannelsService.GetChannelsWithSubscribersAsync(request.ObjectsId).ConfigureAwait(false);

                    response = new ChannelsNodeResponse(request.RequestId, channels);
                }
                break;

                case Enums.NodeRequestType.GetFiles:
                {
                    IEnumerable <FileInfoVm> files = await filesService.GetFilesInfoAsync(request.FilesIds).ConfigureAwait(false);

                    response = new FilesInformationResponse(request.RequestId, files);
                }
                break;

                default:
                    response = new ResultNodeResponse(request.RequestId, ObjectsLibrary.Enums.ErrorCode.InvalidRequestData, "Unsupported request type.");
                    break;
                }
            }
            catch
            {
                response = new ResultNodeResponse(request.RequestId, ObjectsLibrary.Enums.ErrorCode.UnknownError, "An error occurred while processing the request.");
            }
            NodeWebSocketCommunicationManager.SendResponse(response, nodeConnection);
        }
Example #2
0
        public async Task <List <UserVm> > GetUsersInfoAsync(List <long> usersId, long?requestorUserId, NodeConnection nodeConnection)
        {
            try
            {
                GetObjectsInfoNodeRequest request = new GetObjectsInfoNodeRequest(usersId, requestorUserId, Enums.NodeRequestType.GetUsers);
                SendRequest(nodeConnection, request);
                UsersNodeResponse nodeResponse = (UsersNodeResponse) await GetResponseAsync(request).ConfigureAwait(false);

                return(nodeResponse.Users);
            }
            catch (Exception ex)
            {
                Logger.WriteLog(ex);
                return(new List <UserVm>());
            }
        }
 public UsersNodeResponseHandler(NodeResponse response, NodeConnection nodeConnection, ICrossNodeService crossNodeService)
 {
     this.response         = (UsersNodeResponse)response;
     this.crossNodeService = crossNodeService;
     this.nodeConnection   = nodeConnection;
 }