@@ -62,7 +62,7 @@ this.App =

     sendMessage: (message, to, from, callbackOk, callbackFail) ->

       App.Com.trigger(event: 'app.chat.sendMessage', data: {message: message, to: to, from: from}, success: callbackOk, error: callbackFail)

-    sendMultiMessage: sendMessage: (message, chatId, from, callbackOk, callbackFail) ->

+    sendMultiMessage: (message, chatId, from, callbackOk, callbackFail) ->

       App.Com.trigger(event: 'app.chat.sendMessage', data: {message: message, chatId: chatId, from: from}, success: callbackOk, error: callbackFail)

     openNewMultiChatId: (chatOwner, attendant, chat) ->

@@ -71,6 +71,11 @@ this.App =

         @trigger(event: 'app.chat.addToMultiChat', data: {chatOwner: chatOwner, chatId: response.id, jid: attendant} )

       )

+    syncMultiChatContacts: (me, chatId) ->

+      @trigger(event: 'app.chat.syncMultiChatContacts', data: {me: me, chatId: chatId}, success: (contacts) =>

+        App.debug contacts

+      )

+

     updateMyStatus: (message, state)->

       App.Com.trigger(event: 'app.roster.updateMyStatus', data: {message: message, state: state})

@@ -3,12 +3,18 @@ class WsChatController < WsController

     def start_polling_messages

         connection_store[:clients].each do |client|

             client.add_message_callback do |message|

+                #noinspection RubyAssignmentExpressionInConditionalInspection

+

                 if message.body

-                    send_message 'app.chat.messageReceived',

-                                 from: message.from.strip.to_s,

-                                 to: message.to.strip.to_s,

-                                 message: message.body,

-                                 chat_id: if message.attribute(:is_simulating) then message.attribute(:chat_id) end

+                    process_incoming_message(message)

+                elsif request = message.first_element('sync_contacts_request')

+                    # toto mozem prijat len ako admin multichatu

+                    send_contacts(message, request.attribute('chat_id'))

+                elsif answer = message.first_element('synced_contacts')

+                    # toto mozem prijat len ako ucastnik multichatu (nie admin)

+                    sync_contacts_frontend(message, answer.attribute('chat_id'))

+                elsif message.first_element('exported_chat')

+                    import_people_in_chat(message)

                 end

                 #TODO: upozornit na pisanie spravy

                 #TODO: odoslat informaciu o tom, ze pisem spravu

@@ -23,25 +29,39 @@ class WsChatController < WsController

         end

     end

-    def open_multichat

+    def import_people_in_chat(message)

+        client = find_client(message.to)

+        chat_id = message.attribute('chat_id')

+        contacts = xml_contacts_to_array(message.first_element('exported_chat'))

+

+        connection_store[:opened_chats] = {} if ! connection_store[:opened_chats]

+        connection_store[:opened_chats][client] = {} if ! connection_store[:opened_chats][client]

+        connection_store[:opened_chats][client][chat_id] = {attendants: contacts, owner: message.from}

+    end

+

+    def new_multichat

         id = Time.now.to_f

         me = message[:chatOwner]

         client = find_client(me)

         connection_store[:opened_chats] = {} if ! connection_store[:opened_chats]

         connection_store[:opened_chats][client] = {} if ! connection_store[:opened_chats][client]

-        connection_store[:opened_chats][client][id] = []

+        connection_store[:opened_chats][client][id] = {attendants: [], owner: nil}

         trigger_success id: id

     end

-    def add_to_chat

+    # Owner posle novemu cloveku informaciu o chat_id a kontaktoch

+    def add_to_multichatw

         client = find_client(message[:chatOwner])

-        chat_id = message[:chatId]

+        chat_id  = message[:chatId]

         somebody = message[:jid]

-        connection_store[:opened_chats][client][chat_id] << somebody

+        connection_store[:opened_chats][client][chat_id][:attendants] << somebody

+

+        contacts = connection_store[:opened_chats][client][chat_id][:attendants]

+        client.send(MessageBuilder::export_multichat(client.jid.strip.to_s, somebody, chat_id, contacts))

     end

     def send_chat_message

@@ -49,7 +69,15 @@ class WsChatController < WsController

         client = find_client(me)

         if client

-            messages = build_messages(message[:message], client, message[:chatId], message[:to])

+            chat_id = message[:chatId]

+            if chat_id

+                attendants = connection_store[:opened_chats][client][chat_id][:attendants]

+                           + connection_store[:opened_chats][client][chat_id][:owner]

+

+                messages = MessageBuilder::build_multi_messages(message[:message], client.jid.strip.to_s, attendants, chat_id)

+            else

+                messages = [MessageBuilder::build_message(message[:message], client.jid.strip.to_s, message[:to])]

+            end

             # Xmpp4r doesn't support XEP-0033 (multicast messages)

             messages.each do |message|

@@ -62,19 +90,43 @@ class WsChatController < WsController

         end

     end

+    def sync_chat_contacts

+        client = find_client(message[:me])

+        chat_id = message[:chatId]

+

+        owner = connection_store[:opened_chats][client][chat_id][:owner]

+        client.send(MessageBuilder::ask_for_multichat_contacts(client.jid.strip.to_s, owner, chat_id))

+    end

+

     private

-    def build_messages(message, client_from, chat_id, jid_to)

-        from = client_from.jid.to_s

+    def process_incoming_message(message)

+        send_message 'app.chat.messageReceived',

+                     from: message.from.strip.to_s,

+                     to: message.to.strip.to_s,

+                     message: message.body,

+                     chat_id: if message.attribute(:is_simulating) then message.attribute(:chat_id) end

+    end

-        attendants = chat_id ? connection_store[:opened_chats][client_from][chat_id] : [jid_to]

+    def send_contacts(message, chat_id)

+        from = message.from

+        client = find_client(message.to)

+        contacts = connection_store[:opened_chats][client][chat_id][:attendants]

+        client.send(MessageBuilder::send_multichat_contacts(client.jid.strip.to_s, from, chat_id, contacts))

+    end

+

+    def sync_contacts_frontend(message, chat_id)

+        contacts = xml_contacts_to_array(message.first_element('sync_contacts'))

+

+        send_message 'app.chat.updateSyncedContacts',

+                     me: message.to.strip.to_s,

+                     contacts: contacts,

+                     chat_id: chat_id

+    end

-        attendants.map do |person|

-            message = Jabber::Message.new(person, message)

-            message.from = from

-            message.add_attribute('chat_id', chat_id)

-            message.add_attribute('is_simulating', true)

-            message

+    def xml_contacts_to_array(xml_contacts)

+        xml_contacts.get_elements('contact').map do |contact|

+            contact.text

         end

     end

 end

\ No newline at end of file

new file mode 100644

@@ -0,0 +1,60 @@

+module MessageBuilder

+    def self.build_multi_messages(message, from, attendants, chat_id)

+        attendants.map do |person|

+            message = Jabber::Message.new(person, message)

+            message.from = from

+            message.add_attribute('chat_id', chat_id)

+            message.add_attribute('is_simulating', true)

+            message

+        end

+    end

+

+    def self.build_message(message, from, to)

+        message = Jabber::Message.new(to, message)

+        message.from = from

+

+        message

+    end

+

+    def self.ask_for_multichat_contacts(from, to, chat_id)

+        message = Jabber::Message.new(to)

+        message.from = from

+        sync_request = REXML::Element.new('sync_contacts_request')

+        sync_request.add_attributes('chat_id' => chat_id)

+        message.add_element sync_request

+

+        message

+    end

+

+    def self.send_multichat_contacts(from, to, chat_id, contacts)

+        message = Jabber::Message.new(to)

+        message.from = from

+        sync_answer = REXML::Element.new('synced_contacts')

+        collect_contacts(sync_answer, contacts)

+        sync_answer.add_attributes('chat_id' => chat_id)

+        message.add_element sync_answer

+

+        message

+    end

+

+    def self.export_multichat(from, to, chat_id, contacts)

+        message = Jabber::Message.new(to)

+        message.from = from

+        chat = REXML::Element.new('exported_chat')

+        collect_contacts(chat, contacts)

+        chat.add_attributes('chat_id' => chat_id)

+        message.add_element chat

+

+        message

+    end

+

+    private

+

+    def self.collect_contacts(to_element, contacts)

+        contacts.each do |contact|

+            contact_xml = REXML::Element.new('contact')

+            contact_xml.text = contact

+            to_element.add_element contact_xml

+        end

+    end

+end

\ No newline at end of file

@@ -43,7 +43,7 @@ WebsocketRails::EventMap.describe do

   # The above will handle an event triggered on the client like `product.new`.

     #toto asi poide do nadtriedy spajajucej roster a chat a ine veci

-    subscribe :client_connected, to: WsRosterController, with_method: :connect

+    subscribe :client_connected,    to: WsRosterController, with_method: :connect

     subscribe :client_disconnected, to: WsRosterController, with_method: :disconnect

     namespace :app do

@@ -60,10 +60,11 @@ WebsocketRails::EventMap.describe do

         end

         namespace :chat do

-            subscribe :newMultiChatId,      to: WsChatController, with_method: :open_multichat

-            subscribe :addToMultiChat,      to: WsChatController, with_method: :add_to_multichat

-            subscribe :sendMessage,         to: WsChatController, with_method: :send_chat_message

-            subscribe :startPollingMessages,to: WsChatController, with_method: :start_polling_messages

+            subscribe :newMultiChatId,        to: WsChatController, with_method: :new_multichat

+            subscribe :addToMultiChat,        to: WsChatController, with_method: :add_to_multichat

+            subscribe :sendMessage,           to: WsChatController, with_method: :send_chat_message

+            subscribe :startPollingMessages,  to: WsChatController, with_method: :start_polling_messages

+            subscribe :syncMultiChatContacts, to: WsChatController, with_method: :sync_chat_contacts

         end

     end

 end