Update.

src/snek/service/channel_message.py

@@ -6,8 +6,10 @@ class ChannelMessageService(BaseService):
     mapper_name = "channel_message"
 
     async def maintenance(self):
+        args = {}
         async for message in self.find():
             updated_at = message["updated_at"]
+            message["is_final"] = True
             html = message["html"]
             await self.save(message)
 
@@ -20,8 +22,21 @@ class ChannelMessageService(BaseService):
             )
             if html != message["html"]:
                 print("Reredefined message", message["uid"])
+        
+        while True:
+            changed = 0
+            async for message in self.find(is_final=False):
+                message["is_final"] = True
+                await self.save(message)
+                changed += 1
+            async for message in self.find(is_final=None):
+                message["is_final"] = False
+                await self.save(message)
+                changed += 1
+            if not changed:
+                break
 
-
+        
     async def create(self, channel_uid, user_uid, message, is_final=True):
         model = await self.new()
 
@@ -87,6 +102,7 @@ class ChannelMessageService(BaseService):
         model["html"] = whitelist_attributes(model["html"])
         return await super().save(model)
 
+
     async def offset(self, channel_uid, page=0, timestamp=None, page_size=30):
         channel = await self.services.channel.get(uid=channel_uid)
         if not channel:

src/snek/service/chat.py

@@ -44,7 +44,6 @@ class ChatService(BaseService):
             channel_message["is_final"] = is_final
             if not channel_message["is_final"]:
                 async with self.app.no_save():
-                    channel_message["updated_at"] = now()
                     await self.services.channel_message.save(channel_message)
             else:
                 await self.services.channel_message.save(channel_message)

src/snek/system/mapper.py

@@ -31,7 +31,11 @@ class BaseMapper:
                 database_exception = None 
                 for x in range(20):
                     try:
+                        print("happeninggg!!")
+                        print(*args,**kwargs)
+                        print(self.table_name)
                         result = func(*args, **kwargs)
+                        print("REsult:",result)
                         self.db.commit()
                         return result
                     except Exception as ex:

src/snek/view/rpc.py

@@ -267,6 +267,15 @@ class RPCView(BaseView):
                 }
             return result
 
+        async def send_message(self, channel_uid, message, is_final=True):
+            self._require_login()
+            message = await self.services.chat.send(
+                self.user_uid, channel_uid, message, is_final
+            )
+
+            return message["uid"]
+
+
         async def start_container(self, channel_uid):
             self._require_login()
             channel_member = await self.services.channel_member.get(
@@ -294,6 +303,8 @@ class RPCView(BaseView):
                 raise Exception("Not allowed")
             return await self.services.container.get_status(channel_uid)
         
+        
+
         async def finalize_message(self, message_uid):
             self._require_login()
             message = await self.services.channel_message.get(message_uid)
@@ -308,32 +319,17 @@ class RPCView(BaseView):
 
             return True
 
-        async def _finalize_message_task(self, message_uid, timeout=5):
-            if self._finalize_task:
-                self._finalize_task.cancel()
-            await asyncio.sleep(timeout)
-            await self.services.chat.finalize(message_uid)
-
         async def update_message_text(self, message_uid, text):
-            self._require_login()
-            message = await self.services.channel_message.get(message_uid, user_uid=None)
-            if message and message['message'] == text:
-                return message_uid
-            if not message or message["is_final"]:
-                return await self.create_message(text)
             async with self.app.no_save():
+                self._require_login()
+                message = await self.services.channel_message.get(message_uid)
                 if message["user_uid"] != self.user_uid:
                     raise Exception("Not allowed")
 
-                if hasattr(message, "get_seconds_since_last_update"):
+                if message.get_seconds_since_last_update() > 5:
-                    seconds_since_last_update = message.get_seconds_since_last_update()
-                else:
-                    seconds_since_last_update = 0
-
-                if seconds_since_last_update > 5:
                     return {
                         "error": "Message too old",
-                        "seconds_since_last_update": seconds_since_last_update,
+                        "seconds_since_last_update": message.get_seconds_since_last_update(),
                         "success": False,
                     }
 
@@ -344,7 +340,7 @@ class RPCView(BaseView):
                     message["deleted_at"] = None
 
                 await self.services.channel_message.save(message)
-                data = dict(message.record)
+                data = message.record
                 data["text"] = message["message"]
                 data["message_uid"] = message_uid
 
@@ -353,16 +349,15 @@ class RPCView(BaseView):
                     {
                         "channel_uid": message["channel_uid"],
                         "event": "update_message_text",
-                        "data": data,
+                        "data": message.record,
                     },
                 )
 
-                if self._finalize_task:
+                return {"success": True}
-                    self._finalize_task.cancel()
+
-                self._finalize_task = asyncio.create_task(self._finalize_message_task(message_uid, timeout=5))
+
+
 
-            return {"success": True}
-            
         async def clear_channel(self, channel_uid):
             self._require_login()
             user = await self.services.user.get(uid=self.user_uid)
@@ -375,13 +370,6 @@ class RPCView(BaseView):
             await self.services.channel.save(channel)
             return await self.services.channel_message.clear(channel_uid)
 
-        async def send_message(self, channel_uid, message, is_final=True):
-            self._require_login()
-            message = await self.services.chat.send(
-                self.user_uid, channel_uid, message, is_final
-            )
-
-            return message["uid"]
 
         async def echo(self, *args):
             self._require_login()