/// <summary>
        /// Synchronization chats updatings
        /// </summary>
        /// <param name="chatResponseModelAfterUpdate"><see cref="ChatReceiveModel"/></param>
        public void SynchronizeUpdatingChat(ChatResponseModel chatResponseModelAfterUpdate, ChatResponseModel chatResponseModelBeforeUpdate)
        {
            var deletedUsers           = chatResponseModelBeforeUpdate.ChatUsers.Where(cu => chatResponseModelAfterUpdate.ChatUsers.FirstOrDefault(newChatUser => newChatUser.Id == cu.Id) == null);
            var deletedOnlineChatUsers = _connectedClients.Where(cc => deletedUsers.FirstOrDefault(du => du.Id == cc.Id) != null);

            var responseForDeletedUsers = new OperationResultInfo()
            {
                ErrorInfo       = string.Empty,
                OperationResult = OperationsResults.Successfully,
                JsonData        = _jsonStringSerializer.Serialize(chatResponseModelAfterUpdate),
                ToListener      = ListenerType.ChatListDeleteListener
            };
            var responseForDeletedUsersJson = _jsonStringSerializer.Serialize(responseForDeletedUsers);

            _logger.Info($"Sync updating chat {chatResponseModelAfterUpdate.Id}");

            //send responses for deleted users from chat
            Parallel.ForEach(deletedOnlineChatUsers, (cu) => cu.SendMessage(_encoder.Encryption(responseForDeletedUsersJson)));
            //Parallel.ForEach(deletedOnlineChatUsers, (cu) => cu.SendMessage(responseForDeletedUsersJson));

            var onlineChatUsers = _connectedClients.Where(cc => cc.Id != chatResponseModelAfterUpdate.CreatorId &&
                                                          chatResponseModelAfterUpdate.ChatUsers.FirstOrDefault(cu => cu.Id == cc.Id) != null);

            responseForDeletedUsers.ToListener = ListenerType.ChatListListener;
            var responseJson = _jsonStringSerializer.Serialize(responseForDeletedUsers);

            //send responses for users of it's chat with info about updating
            Parallel.ForEach(onlineChatUsers, (cu) => cu.SendMessage(_encoder.Encryption(responseJson)));
            //Parallel.ForEach(onlineChatUsers, (cu) => cu.SendMessage(responseJson));
        }
        /// <summary>
        /// Synchronization chats creatings
        /// </summary>
        /// <param name="chatReceiveModel"><see cref="ChatReceiveModel"/></param>
        public void SynchronizeCreatingChat(ChatResponseModel chatResponseModel)
        {
            var chatUsers = _connectedClients.Where(connClient => connClient.Id != chatResponseModel.CreatorId && chatResponseModel.ChatUsers.FirstOrDefault(cu => cu.Id == connClient.Id) != null);

            Parallel.ForEach(chatUsers, (cu) =>
            {
                _logger.Info($"Sync creating chat {chatResponseModel.Id} for user {cu.Id} by user {chatResponseModel.CreatorId}");
                var responseJson = _jsonStringSerializer.Serialize(new OperationResultInfo()
                {
                    ErrorInfo       = string.Empty,
                    OperationResult = OperationsResults.Successfully,
                    JsonData        = _jsonStringSerializer.Serialize(chatResponseModel),
                    ToListener      = ListenerType.ChatListListener
                });

                cu.SendMessage(_encoder.Encryption(responseJson));
                //cu.SendMessage(responseJson);
            });
        }