initial push

util/lovehate_db.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3.12
+import os
+import logging
+from typing import Optional, LiteralString
+import aiosqlite as sqlite3
+from constructors import LoveHateException
+
+class DB:
+    """LoveHate DB Utility Class"""
+    def __init__(self, bot) -> None:
+        self.db_path: str|LiteralString = os.path.join("/usr/local/share",
+                                    "sqlite_dbs", "lovehate.db") 
+        
+    async def get_wholovehates(self, thing: str, loves: bool = False,
+                               hates: bool = False) -> list[tuple]|bool:
+        """
+        Get a list of users who have professed their love OR hatred for <thing>
+        
+        Args:
+            thing (str): The <thing> to check
+            loves (bool): Are we looking for loves?
+            hates (bool): ...or are we looking for hates?
+        Returns:
+            list[tuple]
+        """        
+
+        query: str = "SELECT display_name FROM lovehate WHERE thing LIKE ? AND flag = ?"
+        params: tuple = tuple()
+        flag: Optional[int] = None
+
+        if hates and loves:
+            raise LoveHateException("Both hates and loves may not be True")
+        elif hates:
+            flag: int = -1
+        elif loves:
+            flag: int = 1
+        elif not hates and not loves:
+            raise LoveHateException("Neither loves nor hates were requested")
+        
+        params: tuple = (thing, flag,)
+        async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
+            async with await db_conn.execute(query, params) as db_cursor:
+                result: list[tuple] = await db_cursor.fetchall()
+                logging.debug("Result: %s", result)
+                if not result:
+                    return False
+                return result
+        
+    async def get_lovehates(self, loves: bool = False, hates: bool = False,
+                            user: str = None, thing: str = None) -> list[tuple]|bool:
+        """
+        Get a list of either 1) what {user} loves/hates, or who loves/hates {thing}, depending on bools loves, hates
+        Args:
+            loves (bool): Are we looking for loves?
+            hates (bool): ...OR are we looking for hates?
+            user (Optional[str]): the user to query against
+            thing (Optional[str]): ... OR the thing to query against
+        Returns:
+            list[tuple]|bool
+        """
+
+        query: str = ""
+        params: tuple = tuple()
+        
+        if not user and not thing:
+            raise LoveHateException("Neither a <user> or <thing> was specified to query against")
+        
+        flag: Optional[int] = None
+
+        if hates and loves:
+            raise LoveHateException("Both hates and loves may not be True")
+        elif hates:
+            flag: int = -1
+        elif loves:
+            flag: int = 1
+        elif not hates and not loves:
+            raise LoveHateException("Neither loves nor hates were requested")
+
+        if user:
+            query: str = "SELECT thing FROM lovehate WHERE display_name LIKE ? AND flag == ?"
+            params: tuple  = (user, flag,)
+        elif thing:
+            query: str = "SELECT display_name FROM lovehate WHERE thing LIKE ? AND flag == ?"
+            params: tuple = (thing, flag,)
+
+        async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
+            async with await db_conn.execute(query, params) as db_cursor:
+                result = await db_cursor.fetchall()
+                if not result:
+                    return False
+                return result
+
+
+    async def check_existence(self, user: str, thing: str) -> Optional[int]:
+        """
+        Determine whether a user is opinionated on a <thing>
+        Args:
+            user (str): The user to check
+            thing (str): The thing to check if the user has an opinion on
+        Returns:
+            Optional[int]
+        """
+        
+        params = (user, thing,)
+
+        async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
+            async with await db_conn.execute("SELECT id, flag FROM lovehate WHERE display_name LIKE ? AND thing LIKE ?", params) as db_cursor:
+                result = await db_cursor.fetchone()
+                if not result:
+                    return None
+                (_, flag) = result
+                return flag
+
+    async def update(self, user: str, thing: str, flag: int) -> str:
+        """
+        Updates the lovehate database, and returns an appropriate response
+        Args:
+            user (str): The user to update
+            thing (str): The thing the user loves/hates/doesn't care about anymore
+            flag (int): int representation of love (1), hate (-1), and dontcare (0)
+        Returns:   
+            str
+        """
+        if not flag in range(-1, 2):
+            raise LoveHateException(f"Invalid flag {flag} specified, is this love (1), hate (-1), or dontcare? (0)")
+
+        db_query: str = ""
+        params: tuple = (user, thing,)
+
+        already_opinionated: bool = await self.check_existence(user, thing)
+        if already_opinionated: 
+            if flag == 0:
+                db_query: str = "DELETE FROM lovehate WHERE display_name LIKE ? AND thing LIKE ?"
+            else:
+                loves_or_hates: str = "loves"
+                if already_opinionated == -1:
+                    loves_or_hates: str = "hates"
+                raise LoveHateException(f"But {user} already {loves_or_hates} {thing}...")
+        else:
+            match flag:
+                case -1:
+                    db_query: str = "INSERT INTO lovehate(display_name, flag, thing) VALUES(?, -1, ?)"
+                case 1:
+                    db_query: str = "INSERT INTO lovehate(display_name, flag, thing) VALUES(?, 1, ?)"
+                case _:
+                    raise LoveHateException("Unknown error, default case matched")
+                
+
+        async with sqlite3.connect(self.db_path, timeout=2) as db_conn:
+            async with await db_conn.execute(db_query, params) as db_cursor:
+                await db_conn.commit()
+                if db_cursor.rowcount != 1:
+                    raise LoveHateException(f"DB Error - RowCount: {db_cursor.rowcount} for INSERT query")
+                match flag:
+                    case -1:
+                        return f"We're done here, {user} hates {thing}."
+                    case 0: 
+                        return f"We're done here, {user} no longer cares one way or the other about {thing}."
+                    case 1:
+                        return f"We're done here, {user} loves {thing}."
+                    case _:
+                        raise LoveHateException("Unknown error, default case matched [2]")