added tests

Author: rabbit0021

app.py

@@ -36,6 +36,8 @@ def get_companies():
 
     techteams = app.db.get_publishers_by_type(conn, publisher_type="techteam")
     teamNames = [team["publisher_name"] for team in techteams if query in team["publisher_name"].lower()]
+    teamNames.sort()
+    conn.close()  
     return jsonify(teamNames)
 
 @app.route('/subscribe', methods=['POST'])
@@ -102,6 +104,7 @@ def subscriptions_for_email():
 
     # Convert sets to lists for JSON serializability
     result = {topic: list(publishers) for topic, publishers in grouped.items()}
+    conn.close()  
     return jsonify(result)
 
 @app.route("/interested", methods=["POST"])

classifier.py

@@ -22,7 +22,7 @@
     enums.PublisherCategory.PRODUCT_MANAGEMENT.value: (
         "product strategy, design, UX/UI, customer research, roadmap planning, prioritization, market analysis, cross-functional collaboration, agile, lean, product launch, product lifecycle management, product metrics, stakeholder communication"
     ),
-    "GENERAL": (
+    enums.PublisherCategory.GENERAL.value: (
         "general technology, business, professional development, industry news, opinions, AI and tech trends, interdisciplinary topics, updates not fitting other categories"
     )
 }
@@ -89,6 +89,6 @@ def classify_post(post_title, tags="", content=""):
     top_score = sorted_scores[0]
     second_score = sorted_scores[1] if len(sorted_scores) > 1 else 0.0
     if top_score < 0.25 or (top_score - second_score) < 0.05:
-        return "GENERAL"
+        return enums.PublisherCategory.GENERAL.value
 
     return best_cat

db/base.py

@@ -26,7 +26,7 @@ def remove_subscription(self, email, topic, publisher_id):
         pass
 
     @abstractmethod
-    def get_notifications(self):
+    def get_active_notifications(self):
         pass                                
 
     @abstractmethod

db/enums.py

@@ -10,4 +10,5 @@ class PublisherCategory(Enum):
     DATA_ANALYTICS = "Data Analytics"
     DATA_SCIENCE = "Data Science"
     SOFTWARE_TESTING = "Software Testing"
-    PRODUCT_MANAGEMENT = "Product Management"
+    PRODUCT_MANAGEMENT = "Product Management"
+    GENERAL = "General"

db/sqlite.py

@@ -11,31 +11,32 @@ class SQLiteDatabase:
 
     def __init__(self, db_path):
         self.db_path = db_path
-        self.conn = None
-        self._connect()
         conn = self.get_connection()
         c = conn.cursor()
 
         # Ensure tables
         c.execute("""
         CREATE TABLE IF NOT EXISTS notifications (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT,
-            heading TEXT,
+            email TEXT NOT NULL,
+            heading TEXT NOT NULL,
+            post_url TEXT NOT NULL,
+            post_title TEXT NOT NULL,
             style_version INTEGER,
-            post_url TEXT,
-            post_title TEXT,
-            deleted BOOL DEFAULT 0
+            deleted BOOL DEFAULT 0,
+            maturity_date DATETIME NOT NULL
         )
         """)
         c.execute("""
         CREATE TABLE IF NOT EXISTS subscriptions (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT,
-            publisher_id INTEGER,
+            email TEXT NOT NULL,
+            publisher_id INTEGER NOT NULL,
             joined_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
             topic TEXT NOT NULL CHECK (topic IN ('Software Engineering', 'Data Analytics', 'Data Science', 'Software Testing', 'Product Management')),
+            frequency_in_days INTEGER DEFAULT 3,
             last_notified_at DATETIME DEFAULT NULL,
+            active BOOL DEFAULT 1,
             FOREIGN KEY (publisher_id) REFERENCES publishers(id),
             UNIQUE (email, publisher_id, topic)
         )
@@ -49,49 +50,54 @@ def __init__(self, db_path):
             UNIQUE (publisher_name)
         )
         """)
+        c.execute("""
+        CREATE TABLE IF NOT EXISTS posts(
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            publisher_id INTEGER NOT NULL,
+            url TEXT NOT NULL,
+            title TEXT NOT NULL,
+            tags TEXT,
+            published_at DATETIME NOT NULL,
+            modified_at DATETIME NOT NULL,
+            labelled BOOL DEFAULT 0,
+            topic TEXT NOT NULL CHECK (topic IN ('Software Engineering', 'Data Analytics', 'Data Science', 'Software Testing', 'Product Management', 'General')),
+            FOREIGN KEY (publisher_id) REFERENCES publishers(id),
+            UNIQUE (url)
+        )
+        """)
         logger.info(f"SQLite database initialized Successfully")
         conn.commit()
-
-    def _connect(self):
-        if self.conn:
-            try:
-                self.conn.execute("SELECT 1")
-                return  # connection is still alive
-            except Exception:
-                self.close()
-                
-        self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
-        self.conn.row_factory = sqlite3.Row
-        logger.info("Connection Initialized")
+        conn.close()
 
     def get_connection(self):
-        self._connect()
-        return self.conn
-
-    def close(self):
-        if self.conn:
-            try:
-                self.conn.close()
-            except Exception:
-                pass
-            self.conn = None
+        """
+        Always returns a new SQLite connection.
+        Caller is responsible for closing it after use.
+        """
+        conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        logger.info("New SQLite connection created")
+        return conn
 
     def get_subscriptions(self, conn):
         c = conn.cursor()
         c.execute("""
             SELECT s.email, s.publisher_id, s.joined_time, s.last_notified_at,
-               p.id as publisher_id, p.publisher_name, p.last_scraped_at, p.publisher_type
+               p.id as publisher_id, p.publisher_name, p.last_scraped_at, p.publisher_type, s.topic, s.frequency_in_days
             FROM subscriptions s
             JOIN publishers p ON s.publisher_id = p.id
+            WHERE s.active=1
         """)
         rows = c.fetchall()
         result = []
         for row in rows:
             subscription = {
             "email": row["email"],
+            'topic': row['topic'],
             "publisher_id": row["publisher_id"],
             "joined_time": row["joined_time"],
             "last_notified_at": row["last_notified_at"],
+            'frequency_in_days': row['frequency_in_days'],
             "publisher": {
                 "id": row["publisher_id"],
                 "publisher_name": row["publisher_name"],
@@ -109,7 +115,7 @@ def get_subscriptions_by_email(self, conn, email):
             FROM (
                 SELECT *
                 FROM subscriptions
-                WHERE email = ?
+                WHERE email = ? and active = 1
             ) s
             JOIN publishers p ON s.publisher_id = p.id
         """
@@ -132,51 +138,80 @@ def get_subscriptions_by_email(self, conn, email):
             for row in cursor.fetchall()
         ]  
 
+    def get_subscriptions_by_email_and_topic_and_publisher_id(self, conn, email, topic, publisher_id):
+        query = """
+            SELECT s.email, s.topic, s.publisher_id, s.joined_time, s.last_notified_at,
+                   p.id AS publisher_id, p.publisher_name, p.last_scraped_at, p.publisher_type
+            FROM subscriptions s
+            JOIN publishers p ON s.publisher_id = p.id
+            WHERE s.email = ? and s.topic = ? and s.active = 1 and  p.id = ?
+        """
+        cursor = conn.execute(query, (email, topic, publisher_id))
+        row = cursor.fetchone()
+        if row:
+            return dict(row)
+        else:
+            return None
+    
     def get_subscriptions_by_publisher(self, conn, publisher_id):
         c = conn.cursor()
         c.execute("""
-            SELECT s.email, s.topic, s.joined_time, s.last_notified_at
+            SELECT *
             FROM subscriptions s
             JOIN publishers p ON s.publisher_id = p.id
-            WHERE p.id = ?
+            WHERE p.id = ? and s.active=1
         """, (publisher_id,))
         rows = c.fetchall()
-        return [
-            {
-                "email": row["email"],
-                "topic": row["topic"],
-                "joined_time": row["joined_time"],
-                "last_notified_at": row["last_notified_at"]
-            }
-            for row in rows
-        ]  
+        return [dict(row) for row in rows]
 
-    def add_subscription(self, conn, email, topic, publisher_id, joined_time=None):
+    def add_subscription(self, conn, email, topic, publisher_id, joined_time=None, operation=""):
         c = conn.cursor()
-        logger.info(f"Adding subscription for email: {email}, topic: {topic}, publisher_id: {publisher_id}, joined_time: {joined_time}")    
+        logger.info(f"Adding subscription for email: {email}, topic: {topic}, publisher_id: {publisher_id}, joined_time: {joined_time}")   
+        
+        sub = self.get_subscriptions_by_email_and_topic_and_publisher_id(conn, email, topic, publisher_id); 
 
-        if joined_time is None:
-            # Let SQLite fill in the default CURRENT_TIMESTAMP
+        if operation == "resume":
             c.execute("""
-                INSERT INTO subscriptions (email, topic, publisher_id)
-                VALUES (?, ?, ?)
-            """, (email, topic, publisher_id))
+                UPDATE subscriptions
+                SET last_notified_at = CURRENT_TIMESTAMP, active = 1
+                WHERE id = ?
+            """, (sub['id'],))
+            
+            logger.info(f"Subscription for {email} resumed successfully")
+            
+            return sub['id']
+
+        elif not sub:
+           if joined_time is None:
+               # Let SQLite fill in the default CURRENT_TIMESTAMP
+               c.execute("""
+                   INSERT INTO subscriptions (email, topic, publisher_id)
+                   VALUES (?, ?, ?)
+               """, (email, topic, publisher_id))
+           else:
+               c.execute("""
+                   INSERT INTO subscriptions (email, topic, publisher_id, joined_time)
+                   VALUES (?, ?, ?, ?)
+               """, (email, topic, publisher_id, joined_time))    
+   
+           logger.info(f"Subscription for {email} addeed successfully")
+           
+           return c.lastrowid
         else:
-            c.execute("""
-                INSERT INTO subscriptions (email, topic, publisher_id, joined_time)
-                VALUES (?, ?, ?, ?)
-            """, (email, topic, publisher_id, joined_time))    
+            logger.info(f"Subscription for {email} already exists")
+            return sub['id']
 
-        logger.info(f"Subscription for {email} added successfully")
+           
 
-    def remove_subscription(self, conn, email, topic, publisher_id):
+    def remove_subscription(self, conn, id):
         c = conn.cursor()
         c.execute("""
-            DELETE FROM subscriptions
-            WHERE email = ? AND topic = ? AND publisher_id = ?
-        """, (email, topic, publisher_id))
+            UPDATE subscriptions
+            SET active=0
+            WHERE id = ?
+        """, (id,))
 
-    def get_notifications(self, conn):
+    def get_active_notifications(self, conn):
         c = conn.cursor()
         c.execute("""
             SELECT *
@@ -196,23 +231,23 @@ def get_notifications_by_email(self, conn, email):
         rows = c.fetchall()
         return [dict(row) for row in rows]
 
-    def add_notification(self, conn, email, heading, style_version, post_url, post_title):
+    def add_notification(self, conn, email, heading, style_version, post_url, post_title, maturity_date):
         logger.info(f"Adding notification: {email}, type: {post_title}")
         c = conn.cursor()
         c.execute("""
-            INSERT INTO notifications (email, heading, style_version, post_url, post_title)
-            VALUES (?, ?, ?, ?, ?)
-        """, (email, heading, style_version, post_url, post_title))
+            INSERT INTO notifications (email, heading, style_version, post_url, post_title, maturity_date)
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (email, heading, style_version, post_url, post_title, maturity_date))
         logger.info("notification added successfully!")
 
-    def delete_notification(self, conn, email, heading, post_title):
-        logger.info(f"Deleting notification: {email}, type: {post_title}")
+    def delete_notification(self, conn, email, post_url):
+        logger.info(f"Deleting notification: {email}, url: {post_url}")
         c = conn.cursor()
         c.execute("""
             UPDATE notifications
             SET deleted = 1
-            WHERE email = ? AND heading = ? AND post_title = ?
-        """, (email, heading, post_title))
+            WHERE email = ? AND post_url = ?
+        """, (email, post_url))
         logger.info("notification deleted successfully!")
 
     def delete_notifications_by_email(self, conn, email):
@@ -272,6 +307,66 @@ def update_publisher(self, conn, publisher_id, last_scraped_at):
             WHERE id = ?
         """, (last_scraped_at, publisher_id))
         logger.info(f"Publisher {publisher_id} updated successfully")
+    
+    def add_post(self, conn, post_url, post_title, published_by, tags, published_at, topic):
+        logger.info(f"Adding post: {post_title}, published_by: {published_by}")
+        c = conn.cursor()
+        
+        post = self.get_post_by_url(conn, post_url)
+        
+        if not post:
+            c.execute("""
+                INSERT INTO posts (url, title, publisher_id, topic, tags, published_at, modified_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, (post_url, post_title, published_by, topic, tags, published_at, published_at))
+            logger.info(f"post {post_title} added successfully!")
+            return c.lastrowid
+        else:
+            logger.info(f"post {post_title} already exists!")
+            return post['id']
+
+    
+    def get_post_by_url(self, conn, url):
+        c = conn.cursor()
+        c.execute("""
+            SELECT *
+            FROM posts
+            WHERE url = ?
+        """, (url,))
+        row = c.fetchone()
+        return dict(row) if row else None
+    
+    def get_labelled_post_by_publisher_and_topic(self,conn, publisher_id, topic):
+        c = conn.cursor()
+        c.execute("""
+            SELECT *
+            FROM posts
+            WHERE publisher_id = ? AND topic = ? AND labelled=1 
+        """, (publisher_id, topic))
+        rows = c.fetchall()
+        return [dict(row) for row in rows]
+    
+    def get_posts(self, conn):
+        c = conn.cursor()
+        c.execute("""
+            SELECT *
+            FROM posts
+        """)
+        rows = c.fetchall()
+        return [dict(row) for row in rows]
+    
+    def update_post_label(self, conn, post_id, label):
+        logger.info(f"Updating post: {post_id}, with label: {label}")
+        c = conn.cursor()
+        c.execute("""
+            UPDATE posts
+            SET topic = ?, 
+                modified_at = CURRENT_TIMESTAMP,
+                labelled = 1
+            WHERE id = ?
+        """, (label, post_id))
+        conn.commit()  # don’t forget to commit the change
+        logger.info(f"Post {post_id} updated successfully")
 
     @classmethod
     def get_instance(cls, db_path):

handlers/facebook.py

@@ -105,7 +105,7 @@ def search_blog_posts(self, category, last_scan_time):
                 posts.append({
                     "title": title,
                     "url": post_url,
-                    "categories": cats,
+                    "tags": cats,
                     "published": published.isoformat()
                 })