added group and user entities, modified repositories method names to more accurate

src/entities/group.py

@@ -0,0 +1,34 @@
+from typing import Iterable
+from .user import User
+
+class Group():
+    __id: int
+    __users: Iterable[User] = []
+
+    def __init__(self, id: int) -> None:
+        self.__id = id
+
+    def getId(self) -> int:
+        return self.__id
+
+    def setUsers(self, users: Iterable[User]) -> None:
+        self.__users = users
+
+    def addUser(self, user: User) -> None:
+        self.__users.append(user)
+
+    def removeUser(self, user: User) -> None:
+        for index, groupUser in enumerate(self.__users):
+            if groupUser.getId() == user.getId():
+                del self.__users[index]
+
+    def getUsers(self) -> Iterable[User]:
+        return self.__users
+    
+    def hasUser(self, user: User) -> bool:
+        userIds = [int(groupUser.getId()) for groupUser in self.getUsers()]
+
+        if user.getId() in userIds:
+            return True
+
+        return False

src/entities/user.py

@@ -0,0 +1,19 @@
+from typing import Optional
+
+class User():
+    __id: int
+    __username: Optional[str]
+    __groupId: int
+
+    def __init__(self, id: int, username: Optional[str]) -> None:
+        self.__id = id
+        self.__username = username
+
+    def getId(self) -> int:
+        return self.__id
+
+    def getUsername(self) -> Optional[str]:
+        return self.__username
+    
+    def getGroupId(self) -> int:
+        return self.__groupId

src/handlers/inHandler.py

@@ -1,6 +1,6 @@
 from ..config.contents import opted_in_successfully, opted_in_failed
-from ..repositories.userRepository import UserRepository
+from ..entities.user import User
-from ..firebaseProxy import FirebaseProxy
+from ..repositories.groupRepository import GroupRepository
 from .handlerInterface import HandlerInterface
 from telegram.ext.callbackcontext import CallbackContext
 from telegram.ext.commandhandler import CommandHandler
@@ -18,18 +18,17 @@ class InHandler(HandlerInterface):
         )
 
     def handle(self, update: Update, context: CallbackContext) -> None:
-        groupId = update.effective_chat.id
+        groupRepository = GroupRepository()
-        userData = {
+        group = groupRepository.get(update.effective_chat.id)
-            FirebaseProxy.id_index: update.effective_user.id,
+        user = User(update.effective_user.id, update.effective_user.username)
-            FirebaseProxy.name_index: update.effective_user.username
-        }
-        userRepository = UserRepository()
 
-        if userRepository.isPresentInGroup(userData.get(FirebaseProxy.id_index), groupId):
+        if group.hasUser(user):
             update.message.reply_markdown_v2(text=opted_in_failed)
             return
 
-        userRepository.addForGroup(userData, groupId)
+        group.addUser(user)
+        groupRepository.save(group)
+
         update.message.reply_markdown_v2(text=opted_in_successfully)
 
     def getBotHandler(self) -> CommandHandler:

src/handlers/mentionHandler.py

@@ -1,4 +1,6 @@
 from ..config.contents import mention_failed
+from ..entities.group import Group
+from ..entities.user import User
 from ..firebaseProxy import FirebaseProxy
 from ..repositories.groupRepository import GroupRepository
 from .handlerInterface import HandlerInterface
@@ -30,13 +32,11 @@ class MentionHandler(HandlerInterface):
     def getCommandName(self) -> str:
         return self.commandName
 
-    def buildMentionMessage(self, usersData: dict) -> str:
+    def buildMentionMessage(self, group: Group) -> str:
         result = ''
 
-        for userData in usersData:
+        for user in group.getUsers():
-            userId = str(userData.get(FirebaseProxy.id_index))
+            username = user.getUsername() or user.getId()
-            username = userData.get(FirebaseProxy.name_index) or userId
+            result +=  f'*[{username}](tg://user?id={user.getId()})* '
-
-            result += "*[%s](tg://user?id=%s)* " % (username, userId)
 
         return result or mention_failed

src/handlers/outHandler.py

@@ -1,5 +1,6 @@
 from ..config.contents import opted_off_successfully, opted_off_failed
-from ..repositories.userRepository import UserRepository
+from ..entities.user import User
+from ..repositories.groupRepository import GroupRepository
 from .handlerInterface import HandlerInterface
 from telegram.ext.callbackcontext import CallbackContext
 from telegram.ext.commandhandler import CommandHandler
@@ -17,20 +18,18 @@ class OutHandler(HandlerInterface):
         )
 
     def handle(self, update: Update, context: CallbackContext) -> None:
-        groupId = update.effective_chat.id
+        groupRepository = GroupRepository()
-        userData = {
+        group = groupRepository.get(update.effective_chat.id)
-            'id': update.effective_user.id,
+        user = User(update.effective_user.id, update.effective_user.username)
-            'name': update.effective_user.username
-        }
 
-        userRepository = UserRepository()
+        if group.hasUser(user):
-        if not userRepository.isPresentInGroup(userData.get('id'), groupId):
+            group.removeUser(user)
-            update.message.reply_markdown_v2(text=opted_off_failed)
+            groupRepository.save(group)
+            
+            update.message.reply_markdown_v2(text=opted_off_successfully)
             return
 
-        userRepository.removeForGroup(userId=userData.get('id'), groupId=groupId)
+        update.message.reply_markdown_v2(text=opted_off_failed)
-
-        update.message.reply_markdown_v2(text=opted_off_successfully)
 
     def getBotHandler(self) -> CommandHandler:
         return self.botHandler

src/repositories/groupRepository.py

@@ -1,3 +1,5 @@
+from ..entities.group import Group
+from ..entities.user import User
 from ..firebaseProxy import FirebaseProxy
 
 
@@ -7,12 +9,40 @@ class GroupRepository():
     def __init__(self) -> None:
         self.firebase = FirebaseProxy()
 
-    def get(self, id: int) -> dict:
+    def get(self, id: int) -> Group:
-        result = []
+        group = Group(id)
-        groupData = self.firebase.getChilds(FirebaseProxy.group_index, id).get()
+        fbData = self.firebase.getChilds(FirebaseProxy.group_index, id).get()
-        
+        users = []
-        if groupData.each():
-            for user_root in groupData.each():
-                result.append(user_root.val())
 
-        return result
+        for userData in fbData.each() or []:
+            userData = userData.val()
+            users.append(
+                User(
+                    userData.get(FirebaseProxy.id_index),
+                    userData.get(FirebaseProxy.name_index)
+                )
+            )
+    
+        group.setUsers(users)
+
+        return group
+
+    def save(self, group: Group) -> None:
+        users = {}
+
+        if not group.getUsers():
+            self.remove(group)
+
+        for user in group.getUsers():
+            users[user.getId()] = {
+                FirebaseProxy.id_index: user.getId(),
+                FirebaseProxy.name_index: user.getUsername()
+            }
+        
+        self.firebase.getChilds(
+            FirebaseProxy.group_index,
+            group.getId()
+        ).update(users)
+
+    def remove(self, group: Group) -> None:
+        self.firebase.getChilds(FirebaseProxy.group_index, group.getId()).remove()

src/repositories/userRepository.py

@@ -7,24 +7,6 @@ class UserRepository():
     def __init__(self) -> None:
         self.firebaseProxy = FirebaseProxy()
 
-    def addForGroup(self, userData: dict, groupId: int) -> None:
+    # TODO : this repository needs to handle user save/deletion/update
-        self.firebaseProxy.getChilds(FirebaseProxy.getGroupPath(groupId)).update({
+    # right now, all of those above is handled by GroupRepository
-            f'{groupId}_{userData.get("id")}': {
-                FirebaseProxy.id_index: userData.get("id"),
-                FirebaseProxy.name_index: userData.get("name")
-            }
-        })
-
-    def removeForGroup(self, userId: int, groupId: int) -> None:
-        self.firebaseProxy.getChilds(FirebaseProxy.getGroupPath(groupId)).update({
-            FirebaseProxy.getUserPath(userId, groupId): {}
-        })
-
-    def isPresentInGroup(self, userId: int, groupId: int) -> bool:
-        user = self.firebaseProxy.getChilds(
-            FirebaseProxy.getGroupPath(groupId),
-            FirebaseProxy.getUserPath(userId, groupId)
-        ).get().val()
-
-        return bool(user)