Merge pull request #78 from geotribu/refactor/rename-messages

refactor(models): rename models from Gischat* to QChat*

Author: gounux

README.md

@@ -12,18 +12,28 @@
 
 ---
 
-Gischat API backend for chatting with your tribe in GIS tools like QGIS (using [QTribu](https://github.com/geotribu/qtribu) plugin available [from official plugin repository](https://plugins.qgis.org/plugins/qtribu/)), GIS mobile apps (e.g [QField plugin)(https://github.com/geotribu/qchat-qfield-plugin), and other to come!
+Gischat API backend for chatting with your tribe in GIS tools.
 
 **No database : messages are not stored. Just stateless websockets.**
 
+## Known clients
+
+Here are the known clients implementing gischat / QChat, at the moment:
+
+- [QChat](https://github.com/geotribu/qchat) QGIS plugin.
+- [QTribu](https://github.com/geotribu/qtribu) QGIS plugin, available [from the official QGIS plugin repository](https://plugins.qgis.org/plugins/qtribu/).
+- [QField plugin](https://github.com/geotribu/qchat-qfield-plugin).
+
+And other to come!
+
 ## Known instances
 
 Following instances are up and running :
 
 | URL | Description | Location |
 | :-: | :---------- | :------- |
-| <https://gischat.geotribu.net> | "official" international instance | Germany |
-| <https://gischat.geotribu.fr> | "official" french-speaking instance | Germany |
+| <https://gischat.geotribu.net> | Geotribu's international instance | Germany |
+| <https://gischat.geotribu.fr> | Geotribu's fr-speaking instance | Germany |
 
 ## Developer information
 

gischat/app.py

@@ -31,20 +31,20 @@
 from gischat.logging import logger
 from gischat.models import (
     ChannelStatusModel,
-    GischatBboxMessage,
-    GischatCrsMessage,
-    GischatGeojsonLayerMessage,
-    GischatImageMessage,
-    GischatLikeMessage,
-    GischatMessageModel,
-    GischatMessageTypeEnum,
-    GischatModelMessage,
-    GischatNewcomerMessage,
-    GischatPositionMessage,
-    GischatTextMessage,
-    GischatUncompliantMessage,
     MatrixRegisterRequest,
     MatrixRegisterResponse,
+    QChatBboxMessage,
+    QChatCrsMessage,
+    QChatGeojsonLayerMessage,
+    QChatImageMessage,
+    QChatLikeMessage,
+    QChatMessageModel,
+    QChatMessageTypeEnum,
+    QChatModelMessage,
+    QChatNewcomerMessage,
+    QChatPositionMessage,
+    QChatTextMessage,
+    QChatUncompliantMessage,
     QMatrixChatTextMessage,
     RulesModel,
     StatusModel,
@@ -199,11 +199,9 @@ async def get_last_messages(channel: str) -> list:
 
 @app.put(
     "/channel/{channel}/text",
-    response_model=GischatTextMessage,
+    response_model=QChatTextMessage,
 )
-async def put_text_message(
-    channel: str, message: GischatTextMessage
-) -> GischatTextMessage:
+async def put_text_message(channel: str, message: QChatTextMessage) -> QChatTextMessage:
 
     if channel not in redis_dispatcher.channels:
         raise HTTPException(
@@ -245,11 +243,11 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
             payload = await websocket.receive_json()
 
             try:
-                message = GischatMessageModel(**payload)
+                message = QChatMessageModel(**payload)
 
                 # text message
-                if message.type == GischatMessageTypeEnum.TEXT:
-                    message = GischatTextMessage(**payload)
+                if message.type == QChatMessageTypeEnum.TEXT:
+                    message = QChatTextMessage(**payload)
 
                     logger.info(f"💬 [{channel}]: ({message.author}): '{message.text}'")
                     await redis_dispatcher.broadcast_to_redis_channel(channel, message)
@@ -258,8 +256,8 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                         redis_dispatcher.store_message(channel, message)
 
                 # image message
-                if message.type == GischatMessageTypeEnum.IMAGE:
-                    message = GischatImageMessage(**payload)
+                if message.type == QChatMessageTypeEnum.IMAGE:
+                    message = QChatImageMessage(**payload)
 
                     # resize image if needed using MAX_IMAGE_SIZE env var
                     image = Image.open(BytesIO(base64.b64decode(message.image_data)))
@@ -277,15 +275,15 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                     redis_dispatcher.store_message(channel, message)
 
                 # newcomer message
-                if message.type == GischatMessageTypeEnum.NEWCOMER:
-                    message = GischatNewcomerMessage(**payload)
+                if message.type == QChatMessageTypeEnum.NEWCOMER:
+                    message = QChatNewcomerMessage(**payload)
 
                     # check if user is already registered
                     if redis_dispatcher.is_user_present(channel, message.newcomer):
                         logger.info(
                             f"❌ User '{message.newcomer}' wants to register but there is already a '{message.newcomer}' in channel {channel}"
                         )
-                        message = GischatUncompliantMessage(
+                        message = QChatUncompliantMessage(
                             reason=f"User '{message.newcomer}' already registered in channel {channel}"
                         )
                         await websocket.send_json(jsonable_encoder(message))
@@ -296,17 +294,17 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                     await redis_dispatcher.notify_newcomer(channel, message.newcomer)
 
                 # like message
-                if message.type == GischatMessageTypeEnum.LIKE:
-                    message = GischatLikeMessage(**payload)
+                if message.type == QChatMessageTypeEnum.LIKE:
+                    message = QChatLikeMessage(**payload)
 
                     logger.info(
                         f"👍 [{channel}]: {message.liker_author} liked {message.liked_author}'s message ({message.message})"
                     )
                     await redis_dispatcher.broadcast_to_redis_channel(channel, message)
 
                 # geojson layer message
-                if message.type == GischatMessageTypeEnum.GEOJSON:
-                    message = GischatGeojsonLayerMessage(**payload)
+                if message.type == QChatMessageTypeEnum.GEOJSON:
+                    message = QChatGeojsonLayerMessage(**payload)
 
                     # check if the number of features is compliant
                     # must not be greater than the MAX_GEOJSON_FEATURES env variable
@@ -317,7 +315,7 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                             f"❌ {message.author} sent a geojson layer ('{message.layer_name}') with too many features ({nb_features}"
                         )
                         # notify user with an uncompliant message
-                        message = GischatUncompliantMessage(
+                        message = QChatUncompliantMessage(
                             reason=f"Too many geojson features : {nb_features} vs max {max_nb_features} allowed"
                         )
                         await websocket.send_json(jsonable_encoder(message))
@@ -331,8 +329,8 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                     redis_dispatcher.store_message(channel, message)
 
                 # crs message
-                if message.type == GischatMessageTypeEnum.CRS:
-                    message = GischatCrsMessage(**payload)
+                if message.type == QChatMessageTypeEnum.CRS:
+                    message = QChatCrsMessage(**payload)
 
                     logger.info(
                         f"📐 [{channel}]: ({message.author}): shared crs '{message.crs_authid}'"
@@ -342,8 +340,8 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                     redis_dispatcher.store_message(channel, message)
 
                 # bbox message
-                if message.type == GischatMessageTypeEnum.BBOX:
-                    message = GischatBboxMessage(**payload)
+                if message.type == QChatMessageTypeEnum.BBOX:
+                    message = QChatBboxMessage(**payload)
 
                     logger.info(
                         f"🔳 [{channel}]: ({message.author}): shared bbox using crs '{message.crs_authid}'"
@@ -353,8 +351,8 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                     redis_dispatcher.store_message(channel, message)
 
                 # position message
-                if message.type == GischatMessageTypeEnum.POSITION:
-                    message = GischatPositionMessage(**payload)
+                if message.type == QChatMessageTypeEnum.POSITION:
+                    message = QChatPositionMessage(**payload)
 
                     logger.info(
                         f"📍 [{channel}]: ({message.author}): shared position '{message.x} x {message.y}' using crs '{message.crs_authid}'"
@@ -364,8 +362,8 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                     redis_dispatcher.store_message(channel, message)
 
                 # graphic model message
-                if message.type == GischatMessageTypeEnum.MODEL:
-                    message = GischatModelMessage(**payload)
+                if message.type == QChatMessageTypeEnum.MODEL:
+                    message = QChatModelMessage(**payload)
 
                     logger.info(
                         f"🧮 [{channel}]: ({message.author}): shared graphic model '{message.model_name}'"
@@ -375,7 +373,7 @@ async def websocket_endpoint(websocket: WebSocket, channel: str) -> None:
                     redis_dispatcher.store_message(channel, message)
 
             except ValidationError as e:
-                message = GischatUncompliantMessage(reason=str(e))
+                message = QChatUncompliantMessage(reason=str(e))
 
                 logger.error(f"❌ Uncompliant message shared: {e}")
                 await redis_dispatcher.broadcast_to_redis_channel(channel, message)
@@ -445,10 +443,10 @@ async def matrix_websocket_endpoint(websocket: WebSocket, request_id: UUID) -> N
                 payload = await websocket.receive_json()
 
                 try:
-                    message = GischatMessageModel(**payload)
+                    message = QChatMessageModel(**payload)
 
                     # text message
-                    if message.type == GischatMessageTypeEnum.TEXT:
+                    if message.type == QChatMessageTypeEnum.TEXT:
                         print("payload: ", payload)
                         message = QMatrixChatTextMessage(**payload)
 
@@ -462,7 +460,7 @@ async def matrix_websocket_endpoint(websocket: WebSocket, request_id: UUID) -> N
                         )
 
                 except ValidationError as e:
-                    message = GischatUncompliantMessage(reason=str(e))
+                    message = QChatUncompliantMessage(reason=str(e))
                     logger.error(f"❌ Uncompliant message shared: {e}")
                     await websocket.send_json(jsonable_encoder(message))
 

gischat/dispatchers.py

@@ -17,13 +17,13 @@
 )
 from gischat.logging import logger
 from gischat.models import (
-    GischatExiterMessage,
-    GischatMessageModel,
-    GischatNbUsersMessage,
-    GischatNewcomerMessage,
     MatrixRegisterRequest,
+    QChatExiterMessage,
+    QChatMessageModel,
+    QChatNbUsersMessage,
+    QChatNewcomerMessage,
     QMatrixChatTextMessage,
-    parse_gischat_message,
+    parse_qchat_message,
 )
 
 
@@ -122,7 +122,7 @@ async def broadcast_to_active_websockets(self, channel: str, message: str) -> No
                 active_connections.remove(ws)
 
     async def broadcast_to_redis_channel(
-        self, channel: str, message: GischatMessageModel
+        self, channel: str, message: QChatMessageModel
     ) -> None:
         await self.redis_pub.publish(
             get_redis_channel_key(channel), message.model_dump_json()
@@ -147,7 +147,7 @@ async def notify_nb_users(self, channel: str) -> None:
         Notifies connected users in a channel with the number of connected users.
         :param channel: channel to notify.
         """
-        message = GischatNbUsersMessage(nb_users=self.get_nb_connected_users(channel))
+        message = QChatNbUsersMessage(nb_users=self.get_nb_connected_users(channel))
         await self.broadcast_to_redis_channel(channel, message)
 
     async def notify_newcomer(self, channel: str, user: str) -> None:
@@ -156,7 +156,7 @@ async def notify_newcomer(self, channel: str, user: str) -> None:
         :param channel: channel to notify.
         :param user: nickname of the newcomer.
         """
-        message = GischatNewcomerMessage(newcomer=user)
+        message = QChatNewcomerMessage(newcomer=user)
         await self.broadcast_to_redis_channel(channel, message)
 
     async def notify_exiter(self, channel: str, user: str) -> None:
@@ -165,7 +165,7 @@ async def notify_exiter(self, channel: str, user: str) -> None:
         :param channel: channel to notify.
         :param user: nickname of the exiter.
         """
-        message = GischatExiterMessage(exiter=user)
+        message = QChatExiterMessage(exiter=user)
         await self.broadcast_to_redis_channel(channel, message)
 
     def register_user(self, channel: str, websocket: WebSocket, user: str) -> None:
@@ -196,7 +196,7 @@ def is_user_present(self, channel: str, user: str) -> bool:
         return user in users_list
 
     async def notify_user(
-        self, channel: str, user: str, message: GischatMessageModel
+        self, channel: str, user: str, message: QChatMessageModel
     ) -> None:
         """
         Notifies a user in a channel with a "private" message.
@@ -215,7 +215,7 @@ async def notify_user(
             except KeyError:
                 continue
 
-    def store_message(self, channel: str, message: GischatMessageModel) -> None:
+    def store_message(self, channel: str, message: QChatMessageModel) -> None:
         """
         Stores a message sent in a channel.
         Will keep only the last MAX_STORED_MESSAGES (env var).
@@ -228,7 +228,7 @@ def store_message(self, channel: str, message: GischatMessageModel) -> None:
         self.redis_connection.lpush(last_message_key, text_value)
         self.redis_connection.ltrim(last_message_key, 0, MAX_STORED_MESSAGES - 1)
 
-    def get_stored_messages(self, channel: str) -> list[GischatMessageModel]:
+    def get_stored_messages(self, channel: str) -> list[QChatMessageModel]:
         """
         Returns the last messages sent and stored in a channel.
         :param channel: channel with stored messages.
@@ -239,7 +239,7 @@ def get_stored_messages(self, channel: str) -> list[GischatMessageModel]:
 
         messages = []
         for raw in reversed(raw_stored):
-            message = parse_gischat_message(json.loads(raw))
+            message = parse_qchat_message(json.loads(raw))
             messages.append(message)
 
         return messages