SignalR Hub about chatjs HOT 19 OPEN

constructor(chatHubServer: HubProxy, chatClientAdapter: IClientAdapter) {
    this.hubServer = chatHubServer;
    this.clientAdapter = chatClientAdapter;
}

// sends a message to a room, conversation or user
sendMessage(roomId: number, conversationId: number, otherUserId: number, messageText: string, clientGuid: string, done: () => void): void {
    var mensagem = { UsuarioId: otherUserId, Texto: messageText };
    var token = $('#Token').val();

    var bounceMessage = new ChatMessageInfo();
    bounceMessage.UserFromId = 0;
    bounceMessage.UserToId = otherUserId;
    bounceMessage.RoomId = roomId;
    bounceMessage.ConversationId = conversationId;
    bounceMessage.Message = messageText;
    bounceMessage.ClientGuid = clientGuid;

    var _this = this;
    this.hubServer.invoke('enviar', token, mensagem).done(function () {
        _this.mudarStatus(otherUserId, 3);
        _this.clientAdapter.triggerMessagesChanged(bounceMessage);
        done();
    });
}

// sends a typing signal to a room, conversation or user
sendTypingSignal(roomId: number, conversationId: number, userToId: number, done: () => void): void {
    done();
}

// gets the message history from a room, conversation or user
getMessageHistory(roomId: number, conversationId: number, otherUserId: number, done: (messages: Array<ChatMessageInfo>) => void): void {
    this.hubServer.invoke('obterHistorico', $('#Token').val(), otherUserId).done(function (messageHistory) {
        done(messageHistory);
    });
}

// gets the given user info
getUserInfo(userId: number, done: (userInfo: ChatUserInfo) => void): void {
    this.hubServer.invoke('getUserInfo', $('#Token').val(), userId).done(function (userInfo) {
        done(userInfo);
    });
}

// gets the user list in a room or conversation
getUserList(roomId: number, conversationId: number, done: (userList: Array<ChatUserInfo>) => void): void {
    this.hubServer.invoke('listarUsuariosEmAtendimento', $('#Token').val()).done(function (userList) {
        done(userList);
    });
}

// gets the rooms list
getRoomsList(done: (roomsList: Array<ChatRoomInfo>) => void) {
    done(new Array <ChatRoomInfo>());
}

// enters the given room
enterRoom(roomId: number, done: () => void) {
    done();
}

// leaves the given room
leaveRoom(roomId: number, done: () => void) {
    done();
}

// Fecha um atendimento
fecharAtendimento(otherUserId: number, done: (userList: Array<ChatUserInfo>) => void): void {
    var _this = this;
    var token = $('#Token').val();

    this.hubServer.invoke('fecharAtendimento', token, otherUserId).done(function (userList) {
        //_this.clientAdapter.triggerUserListChanged(userList); //Já retorna a lista atualizada de atendimentos ativos.
        done(userList);
    });
}

// sends a typing signal to a room, conversation or user
mudarStatus(otherUserId: number, status: number): void {
    var token = $('#Token').val();
    this.hubServer.invoke('mudarStatus', token, otherUserId, status);
}

hubServer: HubProxy;
clientAdapter: IClientAdapter;

constructor(chatHubClient: HubProxy) {
    this.registeredListernersIds = [];
    this.messagesChangedHandlers = [];
    this.typingSignalReceivedHandlers = [];
    this.userListChangedHandlers = [];
    this.roomListChangedHandlers = [];
    this.hubClient = chatHubClient;
    this.handlersIndex = -1;

    var _this = this;
    // called by the server when a new message arrives
    this.hubClient.on('NotificarMensagem', function (message) {
        var token = $('#Token').val();
        var bounceMessage = new ChatMessageInfo();
        bounceMessage.UserFromId = message.UsuarioId;
        bounceMessage.UserToId = message.RemetenteId;
        bounceMessage.Message = message.Texto;
        //bounceMessage.ClientGuid = message.Id;

        console.log(bounceMessage);

        _this.triggerMessagesChanged(bounceMessage);

        _this.hubClient.invoke('mudarStatus', token, message.UsuarioId, 2);
    });

    //this.hubClient.sendTypingSignal = (typingSignal: ChatTypingSignalInfo) => {
    //    this.triggerTypingSignalReceived(typingSignal);
    //};

    //this.hubClient.userListChanged = (userListChangedInfo: ChatUserListChangedInfo) => {
    //    this.triggerUserListChanged(userListChangedInfo);
    //};

    //this.hubClient.roomListChanged = (roomListChangedInfo: ChatRoomListChangedInfo) => {
    //    this.triggerRoomListChanged(roomListChangedInfo);
    //};
}

// adds a handler to the messagesChanged event
onMessagesChanged(userId: number, handler: (message: ChatMessageInfo) => void): void {
    var indiceRegistrado = -1;

    for (var i = 0; i < this.registeredListernersIds.length; i++) {
        if (this.registeredListernersIds[i] === userId) {
            indiceRegistrado = i;
        }
    }

    if (indiceRegistrado >= 0) {
        this.registeredListernersIds.splice(indiceRegistrado, 1);
        this.messagesChangedHandlers.splice(indiceRegistrado, 1);
        console.log("Índice previamente registrado sendo removido. Valor => " + indiceRegistrado);   
    }
    this.registeredListernersIds.push(userId);
    this.messagesChangedHandlers.push(handler);
}

// adds a handler to the typingSignalReceived event
onTypingSignalReceived(handler: (typingSignal: ChatTypingSignalInfo) => void): void {
    this.typingSignalReceivedHandlers.push(handler);
}

// adds a handler to the userListChanged event
onUserListChanged(handler: (userListData: ChatUserListChangedInfo) => void): void {
    this.userListChangedHandlers.push(handler);
}

// adds a handler to the roomListChanged
onRoomListChanged(handler: (roomListData: ChatRoomListChangedInfo) => void): void {
    this.roomListChangedHandlers.push(handler);
}

triggerMessagesChanged(message: ChatMessageInfo): void {
    for (var i = 0; i < this.messagesChangedHandlers.length; i++)
        this.messagesChangedHandlers[i](message);
}

triggerTypingSignalReceived(typingSignal: ChatTypingSignalInfo): void {
    for (var i = 0; i < this.typingSignalReceivedHandlers.length; i++)
        this.typingSignalReceivedHandlers[i](typingSignal);
}

triggerUserListChanged(userListChangedInfo: ChatUserListChangedInfo): void {
    for (var i = 0; i < this.userListChangedHandlers.length; i++)
        this.userListChangedHandlers[i](userListChangedInfo);
}

triggerRoomListChanged(roomListChangedInfo: ChatRoomListChangedInfo): void {
    for (var i = 0; i < this.roomListChangedHandlers.length; i++)
        this.roomListChangedHandlers[i](roomListChangedInfo);
}

// event handlers
registeredListernersIds: Array<number>;
messagesChangedHandlers: Array<(message: ChatMessageInfo) => void>;
typingSignalReceivedHandlers: Array<(typingSignal: ChatTypingSignalInfo) => void>;
userListChangedHandlers: Array<(userListData: ChatUserListChangedInfo) => void>;
roomListChangedHandlers: Array<(roomListData: ChatRoomListChangedInfo) => void>;

// hub client
hubClient: HubProxy;
handlersIndex: number;

constructor(options: YatAdapterOptions) {
    var defaultOptions = new YatAdapterOptions();
    defaultOptions.hubUrl = "chatHub";
    defaultOptions.hubName = "mensagemHub";
    this.options = $.extend({}, defaultOptions, options);
}

init(done: () => void) {
    var _this = this;
    var connection = $.hubConnection();
    connection.url = this.options.hubUrl;
    this.hub = connection.createHubProxy(this.options.hubName);

    // Esta linha abaixo permite chamada de cross origin pelo chrome.
    connection.start({ jsonp: true }).done(function () {
        console.log('Iniciando comunicação Signalr do Chat. HUB Responsável: MensagemHub.');
        _this.hub.invoke('signOn', $('#Token').val());
        done();
    });

    this.client = new YatClientAdapter(this.hub);
    this.server = new YatServerAdapter(this.hub, this.client);

    //if (!window.chatJsHubReady)
    //    window.chatJsHubReady = $.connection.hub.start();

    //window.chatJsHubReady.done(() => {
    //    // function passed by ChatJS to the adapter to be called when the adapter initialization is completed
    //    done();
    //});
}

// functions called by the server, to contact the client
client: IClientAdapter;

// functions called by the client, to contact the server
server: IServerAdapter;
hub: HubProxy;
options: YatAdapterOptions;