GitLab

at 2022-11-01T20:39:00+01:00

fix: Message selection: Don’t fail hard if log_line_id is None

Fixes #11263

imprv: Add msg_log_id to live message events

Improves the situation for #11263

         message.set_sent_timestamp()

         message.message_id = self.send_stanza(message.stanza)

 

+        log_line_id = None

         if not message.is_groupchat:

-            self.get_module('Message').log_message(message)

+            log_line_id = self.get_module('Message').log_message(message)

 

         app.ged.raise_event(

             MessageSent(jid=message.jid,

                         label=message.label,

                         correct_id=message.correct_id,

                         message_id=message.message_id,

+                        msg_log_id=log_line_id,

                         play_sound=message.play_sound))

 

     def _prepare_for_connect(self) -> None:

     jid: JID

     message: str

     message_id: str

+    msg_log_id: Optional[int]

     chatstate: Optional[str]

     timestamp: float

     additional_data: AdditionalDataDict

     fjid: str

     resource: str

     delayed: Optional[float]

-    msg_log_id: int

+    msg_log_id: Optional[int]

     displaymarking: Optional[Displaymarking]

 

 

             event_attr.update({

                 'room_jid': jid,

             })

+

             event = GcMessageReceived(**event_attr)

-            app.ged.raise_event(event)

+

             # TODO: Some plugins modify msgtxt in the GUI event

-            self._log_muc_message(event)

+            msg_log_id = self._log_muc_message(event)

+            event.msg_log_id = msg_log_id

+            app.ged.raise_event(event)

             return

 

-        app.ged.raise_event(MessageReceived(**event_attr))

-

+        event = MessageReceived(**event_attr)

         if not msgtxt:

+            app.ged.raise_event(event)

             return

 

-        app.storage.archive.insert_into_logs(

+        msg_log_id = app.storage.archive.insert_into_logs(

             self._account,

             fjid if properties.is_muc_pm else jid,

             properties.timestamp,

             stanza_id=stanza_id or message_id,

             message_id=properties.id)

 

+        event.msg_log_id = msg_log_id

+        app.ged.raise_event(event)

+

     def _message_error_received(self,

                                 _con: types.xmppClient,

                                 _stanza: nbxmpp.Message,

                          message_id=properties.id,

                          error=properties.error))

 

-    def _log_muc_message(self, event: GcMessageReceived) -> None:

+    def _log_muc_message(self, event: GcMessageReceived) -> Optional[int]:

         self._check_for_mam_compliance(event.room_jid, event.stanza_id)

 

         if event.msgtxt and event.properties.muc_nickname:

-            app.storage.archive.insert_into_logs(

+            msg_log_id = app.storage.archive.insert_into_logs(

                 self._account,

                 event.jid,

                 event.properties.timestamp,

                 additional_data=event.additional_data,

                 stanza_id=event.stanza_id,

                 message_id=event.properties.id)

+            return msg_log_id

+

+        return None

 

     def _check_for_mam_compliance(self, room_jid: str, stanza_id: str) -> None:

         disco_info = app.storage.cache.get_last_disco_info(room_jid)

 

         return stanza

 

-    def log_message(self, message: OutgoingMessage) -> None:

+    def log_message(self, message: OutgoingMessage) -> Optional[int]:

         if not message.is_loggable:

             return

 

                 message.correct_id,

                 KindConstant.CHAT_MSG_SENT,

                 message.timestamp)

-            return

+            return None

 

-        app.storage.archive.insert_into_logs(

+        msg_log_id = app.storage.archive.insert_into_logs(

             self._account,

             message.jid,

             message.timestamp,

             additional_data=message.additional_data,

             message_id=message.message_id,

             stanza_id=message.message_id)

+        return msg_log_id
                          tim=event.timestamp,

                          displaymarking=displaymarking,

                          message_id=message_id,

+                         msg_log_id=event.msg_log_id,

                          additional_data=event.additional_data)

 

     def _on_message_received(self, event: events.MessageReceived) -> None:

                                  displaymarking=event.displaymarking,

                                  message_id=event.properties.id,

                                  stanza_id=event.stanza_id,

+                                 msg_log_id=event.msg_log_id,

                                  additional_data=event.additional_data)

 

     def _on_message_updated(self, event: events.MessageUpdated) -> None:

                         displaymarking: Optional[Displaymarking] = None,

                         message_id: Optional[str] = None,

                         stanza_id: Optional[str] = None,

+                        msg_log_id: Optional[int] = None,

                         additional_data: Optional[AdditionalDataDict] = None,

                         ) -> None:

 

                           displaymarking=displaymarking,

                           message_id=message_id,

                           stanza_id=stanza_id,

+                          msg_log_id=msg_log_id,

                           additional_data=additional_data)

 

     def _on_room_subject(self,

     def _on_activate_message_selection(self, _button: Gtk.ModelButton) -> None:

         app.window.activate_action(

             'activate-message-selection',

-            GLib.Variant('u', self._row.log_line_id))

+            GLib.Variant('u', self._row.log_line_id or 0))

 

     @staticmethod

     def _on_closed(popover: Gtk.Popover) -> None:

Daniel Brötzmann pushed to branch master at gajim / gajim

Commits:

5 changed files:

Changes: