@@ -3,22 +3,29 @@ class WsChatController < WsController

     def start_polling_messages

         connection_store[:clients].each do |client|

             client.add_message_callback do |message|

-                #noinspection RubyAssignmentExpressionInConditionalInspection

+                from = message.from.strip.to_s

+                to   = message.to.strip.to_s

+                chat_id = message.attribute('chat_id').to_s

+                #noinspection RubyAssignmentExpressionInConditionalInspection

                 if message.body

-                    process_incoming_message(message)

+                    process_incoming_message(from, to, message.body, chat_id)

                 elsif request = message.first_element('sync_contacts_request')

                     # toto mozem prijat len ako admin multichatu

-                    send_contacts(message, request.attribute('chat_id').to_s)

+                    send_contacts(from, to, request.attribute('chat_id').to_s)

                 elsif answer = message.first_element('synced_contacts')

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

-                    sync_contacts_frontend(message, answer.attribute('chat_id').to_s)

+                    contacts = xml_contacts_to_array(answer)

+                    sync_contacts_frontend(from, to, answer.attribute('chat_id').to_s, contacts)

                 elsif answer = message.first_element('exported_chat')

-                    import_people_in_chat(message, answer.attribute('chat_id').to_s)

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

+                    import_people_in_chat(from, to, answer.attribute('chat_id').to_s, contacts)

                 elsif message.attribute('destroy_multichat')

-                    destroy_multichat(message, message.attribute('chat_id').to_s)

+                    destroy_multichat(to, chat_id)

                 elsif message.attribute('req_update_contacts')

-                    update_attendants_in_multichat(message, message.attribute('chat_id').to_s)

+                    added   = xml_contacts_to_array(message.first_element('added'))

+                    removed = xml_contacts_to_array(message.first_element('removed'))

+                    update_attendants_in_multichat(from, to, chat_id, removed, added)

                 end

                 #TODO: upozornit na pisanie spravy

                 #TODO: odoslat informaciu o tom, ze pisem spravu

@@ -33,20 +40,19 @@ class WsChatController < WsController

         end

     end

-    def import_people_in_chat(message, chat_id)

+    def import_people_in_chat(from, to, chat_id, contacts)

         #Rails.logger.debug ['imported chat arrived', message.to_s, chat_id]

-        client = find_client(message.to.strip.to_s)

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

+        client = find_client(to)

         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.strip.to_s}

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

         #Rails.logger.debug [connection_store[:opened_chats][client], client.jid.to_s]

         send_message 'app.chat.importChat',

-                     owner:    message.from.strip.to_s,

+                     owner:    from,

                      chat_id:  chat_id,

                      contacts: contacts

     end

@@ -162,48 +168,45 @@ class WsChatController < WsController

     private

-    def process_incoming_message(message)

+    def process_incoming_message(from, to, body, chat_id = nil)

         #Rails.logger.debug [message, message.to.strip.to_s]

         send_message 'app.chat.messageReceived',

-                     from: message.from.strip.to_s,

-                     to: message.to.strip.to_s,

-                     message: message.body,

-                     chat_id: message.attribute('chat_id').to_s

+                     from: from,

+                     to: to,

+                     message: body,

+                     chat_id: chat_id

     end

-    def send_contacts(message, chat_id)

-        from = message.from.strip.to_s

-        client = find_client(message.to.strip.to_s)

+    def send_contacts(from, to, chat_id)

+        client = find_client(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 destroy_multichat(message, chat_id)

-        client = find_client(message.to.strip.to_s)

+    def destroy_multichat(to, chat_id)

+        client = find_client(to)

         connection_store[:opened_chats][client].delete(chat_id)

         send_message 'app.chat.destroyMultichat', chat_id: chat_id

     end

-    def update_attendants_in_multichat(message, chat_id)

-        client = find_client(message.to.strip.to_s)

-        added = message.first_element('added')

-        removed = message.first_element('removed')

+    def update_attendants_in_multichat(from, to, chat_id, removed, added)

+        client = find_client(to)

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

-        contacts -= xml_contacts_to_array(removed)

-        contacts += xml_contacts_to_array(added)

+        contacts -= removed

+        contacts += added

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

         if contacts.empty?

-            destroy_multichat(message, chat_id)

+            destroy_multichat(to, chat_id)

         else

             contacts.each do |contact|

-                client.send(MessageBuilder::send_multichat_contacts(client.jid.strip.to_s, contact, chat_id, contacts))

+                client.send(MessageBuilder::send_multichat_contacts(to, contact, chat_id, contacts))

             end

-            sync_contacts_frontend(MessageBuilder::send_multichat_contacts('', client.jid.strip.to_s, chat_id, contacts), chat_id)

+            sync_contacts_frontend(from, to, chat_id, contacts)

         end

     end

 end

\ No newline at end of file

@@ -40,18 +40,16 @@ class WsController < WebsocketRails::BaseController

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

                 end

-                sync_contacts_frontend(MessageBuilder::send_multichat_contacts('', client.jid.strip.to_s, chat_id, contacts), chat_id)

+                sync_contacts_frontend('', client.jid.strip.to_s, chat_id, contacts)

             end

         end

     end

-    def sync_contacts_frontend(message, chat_id)

-        contacts = xml_contacts_to_array(message.first_element('synced_contacts'))

-

+    def sync_contacts_frontend(from, to, chat_id, contacts)

         send_message 'app.chat.updateSyncedContacts',

-                     me: message.to.strip.to_s,

+                     me: to,

                      contacts: contacts,

-                     owner: message.from.strip.to_s,

+                     owner: from,

                      chat_id: chat_id

     end

@@ -109,7 +109,7 @@ class WsRosterController < WsController

                 if new_presence.type == :unavailable

                     result = {status: :offline, message: ''}

                     # mozno treba vyhodit cloveka z multichatu, ak som jeho owner

-                    kick_from_multichat2(roster_item.jid.strip.to_s)

+                    #kick_from_multichat2(roster_item.jid.strip.to_s)

                 else

                     status = uniform_presence(new_presence.show)

                     result = { status: status, message: new_presence.status.to_s }