migrate finfast summary data draft

app/app.py

@@ -1,23 +1,23 @@
 """Flask application entry point."""
-# import json
+import json
 import logging
 from flask import Flask
 from flask_apscheduler import APScheduler
 from asgiref.wsgi import WsgiToAsgi
-from routes.category_router import category_bp
 
-# from routes.summary import summary_bp
+from routes.summary import summary_bp
+from routes.category_router import category_bp
 
-# class Config:
-#     """
-#     Config class for application settings.
+class Config:
+    """
+    Config class for application settings.
 
-#     Attributes:
-#         SCHEDULER_API_ENABLED (bool): Indicates whether the scheduler's API is enabled.
-#     """
-#     with open('jobs.json', 'r', encoding='utf-8') as jobs_file:
-#         JOBS = json.load(jobs_file)
-#     SCHEDULER_API_ENABLED = True
+    Attributes:
+        SCHEDULER_API_ENABLED (bool): Indicates whether the scheduler's API is enabled.
+    """
+    with open('jobs.json', 'r', encoding='utf-8') as jobs_file:
+        JOBS = json.load(jobs_file)
+    SCHEDULER_API_ENABLED = True
 
 def create_app():
     """

app/controllers/summary/__init__.py

@@ -0,0 +1,99 @@
+"""Summary controller package for handling summary page related operations."""
+import os
+import importlib
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict, Any
+from .utils import get_content_flow_data, get_entity_analysis_data, get_sentiment_analysis_data, get_entity_sentiment_data
+
+
+def _run_process(args):
+    """
+    Dynamically imports and runs the 'process' function from a specified summary module.
+
+    Args:
+        args (tuple):
+            - module (str): The name of the summary module folder to import from.
+            - chart_id (str): The name of the chart module to import and run.
+
+    Returns:
+        Any: The result returned by the 'process' function of the specified module.
+
+    Raises:
+        ModuleNotFoundError: If the specified summary module does not exist.
+        AttributeError: If the 'process' function is not found in the module.
+    """
+    module, chart_id = args
+    return importlib.import_module(f"controllers.summary.{module}.{chart_id}").process()
+
+
+def process(module):
+    """
+    Processes all Python chart modules within a specified subdirectory.
+
+    Args:
+        module (str): The name of the subdirectory (module) containing chart Python files.
+
+    Returns:
+        list: A list of results returned by processing each chart Python file.
+
+    Notes:
+        - Only files ending with ".py" and not named "__init__.py" are considered.
+        - Utility files (utils.py, common.py, etc.) are automatically excluded.
+        - Chart files are processed concurrently using a thread pool.
+        - The helper function `_run_process` is used to process each chart file.
+    """
+    current_dir = os.path.join(os.path.dirname(__file__), module)
+    chart_ids = [
+        f[:-3] for f in os.listdir(current_dir)
+        if f.endswith(".py") and f not in ("__init__.py",)
+    ]
+    with ThreadPoolExecutor() as executor:
+        charts = list(executor.map(
+            _run_process,
+            [(module, chart_id) for chart_id in sorted(chart_ids)]
+        ))
+    return charts
+
+
+def get_summary_data(include_content: bool = True, include_entity: bool = True, include_sentiment: bool = True) -> Dict[str, Any]:
+    """
+    Get complete summary dashboard data for all time periods.
+    
+    This function aggregates content flow, entity analysis, and sentiment analysis data across
+    three time periods: today, week, and month.
+    
+    Args:
+        include_content (bool, optional): Whether to include content flow data. 
+            Defaults to True.
+        include_entity (bool, optional): Whether to include entity analysis data. 
+            Defaults to True.
+        include_sentiment (bool, optional): Whether to include sentiment analysis data.
+            Defaults to True.
+    
+    Returns:
+        Dict[str, Any]: Summary data containing content, entity, and/or sentiment information:
+            - "content": Content flow data for today/week/month (if include_content=True)
+            - "entity": Entity analysis data for today/week/month (if include_entity=True)
+            - "sentiment": Sentiment analysis data for today/week/month (if include_sentiment=True)
+    """
+    summary = {}
+    if include_content:
+        summary["content"] = {
+            "today": get_content_flow_data("today"),
+            "week": get_content_flow_data("week"),
+            "month": get_content_flow_data("month")
+        }
+    if include_entity:
+        summary["entity"] = {
+            "today": get_entity_analysis_data("today"),
+            "week": get_entity_analysis_data("week"),
+            "month": get_entity_analysis_data("month")
+        }
+    if include_sentiment:
+        summary["sentiment"] = {
+            "today": get_sentiment_analysis_data("today"),
+            "week": get_sentiment_analysis_data("week"),
+            "month": get_sentiment_analysis_data("month"),
+            "entities": get_entity_sentiment_data("week")
+        }
+    return summary

app/controllers/summary/content/__init__.py

@@ -0,0 +1,29 @@
+"""Public interface for content-related summary calculations."""
+
+from ..utils import get_content_flow_data as _base
+
+
+def get_today_content_flow_data():
+    """Return Content Flow data for *today*."""
+    return _base("today")
+
+
+def get_weekly_content_flow_data():
+    """Return Content Flow data for the *latest 7 days*."""
+    # the internal util accepts either ``week`` or ``weekly``
+    return _base("week")
+
+
+def get_monthly_content_flow_data():
+    """Return Content Flow data for the *latest 30 days*."""
+    return _base("month")
+
+# Re-export the generic helper so legacy imports keep working
+get_content_flow_data = _base  # type: ignore
+
+__all__ = [
+    "get_content_flow_data",
+    "get_today_content_flow_data",
+    "get_weekly_content_flow_data",
+    "get_monthly_content_flow_data",
+]

app/controllers/summary/content/monthly.py

@@ -0,0 +1,12 @@
+"""Content Flow Tracker - Monthly Module.
+
+This module provides content flow analysis for the latest 30 days of data.
+It processes and returns aggregated article statistics by source and category 
+for the past 30 days from the most recent article date.
+"""
+from ..utils import get_content_flow_data
+
+
+def process():
+    """Return Content Flow Tracker data for the *latest 30 days*."""
+    return get_content_flow_data("month")

app/controllers/summary/content/today.py

@@ -0,0 +1,12 @@
+"""Content Flow Tracker - Today Module.
+
+This module provides content flow analysis for today's data only.
+It processes and returns aggregated article statistics by source and category 
+for the current day.
+"""
+from ..utils import get_content_flow_data
+
+
+def process():
+    """Return Content Flow Tracker data for *today* only."""
+    return get_content_flow_data("today")

app/controllers/summary/content/weekly.py

@@ -0,0 +1,12 @@
+"""Content Flow Tracker - Weekly Module.
+
+This module provides content flow analysis for the latest 7 days of data.
+It processes and returns aggregated article statistics by source and category 
+for the past 7 days from the most recent article date.
+"""
+from ..utils import get_content_flow_data
+
+
+def process():
+    """Return Content Flow Tracker data for the *latest 7 days*."""
+    return get_content_flow_data("week")

app/controllers/summary/entity/__init__.py

@@ -0,0 +1,27 @@
+"""Public interface for entity analysis calculations."""
+from ..utils import get_entity_analysis_data as _base
+
+
+def get_today_entity_analysis_data():
+    """Return Entity Analysis data for *today*."""
+    return _base("today")
+
+
+def get_weekly_entity_analysis_data():
+    """Return Entity Analysis data for the *latest 7 days*."""
+    return _base("week")
+
+
+def get_monthly_entity_analysis_data():
+    """Return Entity Analysis data for the *latest 30 days*."""
+    return _base("month")
+
+# Re-export generic helper for backward compatibility
+get_entity_analysis_data = _base  # type: ignore
+
+__all__ = [
+    "get_entity_analysis_data",
+    "get_today_entity_analysis_data",
+    "get_weekly_entity_analysis_data",
+    "get_monthly_entity_analysis_data",
+]

app/controllers/summary/entity/monthly.py

@@ -0,0 +1,12 @@
+"""Entity Analysis - Monthly Module.
+
+This module provides entity analysis for the latest 30 days of data.
+It processes and returns top entities with their mention counts and types
+for the past 30 days from the most recent article date.
+"""
+from ..utils import get_entity_analysis_data
+
+
+def process():
+    """Return Entity Analysis data for the *latest 30 days*."""
+    return get_entity_analysis_data("month")

app/controllers/summary/entity/today.py

@@ -0,0 +1,12 @@
+"""Entity Analysis - Today Module.
+
+This module provides entity analysis for today's data only.
+It processes and returns top entities with their mention counts and types
+for the current day.
+"""
+from ..utils import get_entity_analysis_data
+
+
+def process():
+    """Return Entity Analysis data for *today*."""
+    return get_entity_analysis_data("today")

app/controllers/summary/entity/weekly.py

@@ -0,0 +1,12 @@
+"""Entity Analysis - Weekly Module.
+
+This module provides entity analysis for the latest 7 days of data.
+It processes and returns top entities with their mention counts and types
+for the past 7 days from the most recent article date.
+"""
+from ..utils import get_entity_analysis_data
+
+
+def process():
+    """Return Entity Analysis data for the *latest 7 days*."""
+    return get_entity_analysis_data("week")

app/controllers/summary/sentiment/__init__.py

@@ -0,0 +1,38 @@
+"""Public interface for sentiment analysis calculations."""
+
+from ..utils import get_sentiment_analysis_data as _base_sentiment
+from ..utils import get_entity_sentiment_data as _base_entity_sentiment
+
+
+def get_today_sentiment_data():
+    """Return Sentiment Analysis data for *today*."""
+    return _base_sentiment("today")
+
+
+def get_weekly_sentiment_data():
+    """Return Sentiment Analysis data for the *latest 7 days*."""
+    return _base_sentiment("week")
+
+
+def get_monthly_sentiment_data():
+    """Return Sentiment Analysis data for the *latest 30 days*."""
+    return _base_sentiment("month")
+
+
+def get_entity_sentiment_data():
+    """Return Entity Sentiment Analysis data for the *latest 7 days*."""
+    return _base_entity_sentiment("week")
+
+
+# Re-export the generic helpers for backward compatibility
+get_sentiment_analysis_data = _base_sentiment
+get_entities_sentiment_data = _base_entity_sentiment
+
+__all__ = [
+    "get_sentiment_analysis_data",
+    "get_today_sentiment_data", 
+    "get_weekly_sentiment_data",
+    "get_monthly_sentiment_data",
+    "get_entity_sentiment_data",
+    "get_entities_sentiment_data",
+]

app/controllers/summary/sentiment/entitites.py

@@ -0,0 +1,12 @@
+"""Entity Sentiment Analysis Module.
+
+This module provides sentiment analysis for entities mentioned in articles.
+It processes and returns aggregated sentiment scores by entity type and entity name
+for the current week.
+"""
+from ..utils import get_entity_sentiment_data
+
+
+def process():
+    """Return Entity Sentiment Analysis data for the *current week*."""
+    return get_entity_sentiment_data("week")

app/controllers/summary/sentiment/monthly.py

@@ -0,0 +1,11 @@
+"""Sentiment Analysis - Monthly Module.
+
+This module provides sentiment analysis for the current month's articles by category.
+It processes and returns aggregated sentiment scores by category for the current month.
+"""
+from ..utils import get_sentiment_analysis_data
+
+
+def process():
+    """Return Sentiment Analysis data for the *current month*."""
+    return get_sentiment_analysis_data("month")

app/controllers/summary/sentiment/today.py

@@ -0,0 +1,11 @@
+"""Sentiment Analysis - Today Module.
+
+This module provides sentiment analysis for today's articles by category.
+It processes and returns aggregated sentiment scores by category for the current day.
+"""
+from ..utils import get_sentiment_analysis_data
+
+
+def process():
+    """Return Sentiment Analysis data for *today* only."""
+    return get_sentiment_analysis_data("today")

app/controllers/summary/sentiment/weekly.py

@@ -0,0 +1,11 @@
+"""Sentiment Analysis - Weekly Module.
+
+This module provides sentiment analysis for the current week's articles by category.
+It processes and returns aggregated sentiment scores by category for the past 7 days.
+"""
+from ..utils import get_sentiment_analysis_data
+
+
+def process():
+    """Return Sentiment Analysis data for the *current week*."""
+    return get_sentiment_analysis_data("week")

app/controllers/summary/utils.py

@@ -0,0 +1,365 @@
+"""Utility functions for Summary calculations.
+This module contains utility functions for both Content Flow Tracker and Entity Analysis,
+extracted and merged from the previous content/utils.py and entity/utils.py files.
+"""
+from datetime import datetime, timedelta
+from typing import Dict, Any
+from collections import defaultdict
+
+from database.mongodb import article_collection, entity_collection
+
+
+def _get_latest_publish_date_from_collection(collection) -> datetime:
+    """Return the latest publish date found in the specified collection.
+
+    Parameters
+    ----------
+    collection:
+        MongoDB collection to query for the latest publishDate.
+
+    Returns
+    -------
+    datetime
+        Latest publish date found, or current date if collection is empty.
+    """
+    latest_doc = collection.find_one(
+        sort=[("publishDate", -1)], projection={"publishDate": 1}
+    )
+    if latest_doc and "publishDate" in latest_doc:
+        return datetime.strptime(latest_doc["publishDate"], "%Y-%m-%d")
+    return datetime.today()
+
+
+def _time_range(filter_type: str, collection) -> tuple[str, str]:
+    """Calculate *inclusive* start / end date strings using rolling window approach.
+    
+    Uses rolling window logic:
+    - today: only the latest date
+    - weekly: latest date - 6 days (total 7 days)
+    - monthly: latest date - 29 days (total 30 days)
+
+    Parameters
+    ----------
+    filter_type:
+        One of ``today``, ``week``/``weekly`` or ``month``/``monthly``.  Any
+        unrecognised value will fall back to *all time* where the start date is
+        ``datetime.min``.
+    collection:
+        MongoDB collection to get the latest date from.
+
+    Returns
+    -------
+    tuple[str, str]
+        Start and end dates as strings in YYYY-MM-DD format.
+    """
+    latest_date = _get_latest_publish_date_from_collection(collection)
+
+    if filter_type in {"today"}:
+        start = latest_date.date()
+    elif filter_type in {"week", "weekly"}:
+        # Latest date minus 6 days (total 7 days)
+        start = (latest_date - timedelta(days=6)).date()
+    elif filter_type in {"month", "monthly"}:
+        # Latest date minus 29 days (total 30 days)
+        start = (latest_date - timedelta(days=29)).date()
+    else:
+        start = datetime.min.date()
+
+    return str(start), str(latest_date.date())
+
+
+
+def get_content_flow_data(time_filter: str) -> Dict[str, Any]:
+    """Return aggregated *Content Flow Tracker* data for the given period.
+
+    Uses rolling window approach:
+    - today: only the latest date
+    - weekly: latest date - 6 days (total 7 days)  
+    - monthly: latest date - 29 days (total 30 days)
+
+    Parameters
+    ----------
+    time_filter:
+        Time period filter ('today', 'week'/'weekly', 'month'/'monthly', or any other for all time).
+
+    Returns
+    -------
+    Dict[str, Any]
+        Dictionary containing title, dateRange, and aggregated content flow data.
+    """
+    start, end = _time_range(time_filter, article_collection)
+
+    pipeline = [
+        {"$match": {"publishDate": {"$gte": start, "$lte": end}}},
+        {"$group": {"_id": {"source": "$site", "category": "$category"}, "count": {"$sum": 1}}},
+        {"$sort": {"count": -1}},
+    ]
+
+    results = list(article_collection.aggregate(pipeline))
+
+    data = [
+        {
+            "category": r["_id"].get("category", "Uncategorized"),
+            "source": r["_id"]["source"],
+            "count": r["count"],
+        }
+        for r in results
+    ]
+
+    return {
+        "title": f"Content Flow Tracker — {time_filter.capitalize()}",
+        "dateRange": {"start": start, "end": end},
+        "data": data,
+    }
+
+
+def get_entity_analysis_data(time_filter: str) -> Dict[str, Any]:
+    """Return *Entity Analysis* data for the given period.
+
+    Uses rolling window approach:
+    - today: only the latest date
+    - weekly: latest date - 6 days (total 7 days)  
+    - monthly: latest date - 29 days (total 30 days)
+
+    Parameters
+    ----------
+    time_filter:
+        Time period filter ('today', 'week'/'weekly', 'month'/'monthly', or any other for all time).
+
+    Returns
+    -------
+    Dict[str, Any]
+        Dictionary containing title, dateRange, and aggregated entity analysis data.
+    """
+    start, end = _time_range(time_filter, entity_collection)
+
+    pipeline = [
+        {"$match": {"publishDate": {"$gte": start, "$lte": end}}},
+        {"$group": {"_id": {"entity": "$entity", "type": "$entityType"},
+                   "mentions": {"$sum": "$occurrence"}}},
+        {"$sort": {"mentions": -1}},
+    ]
+
+    results = list(entity_collection.aggregate(pipeline))
+
+    type_full_names = {
+        "GPE": "Geopolitical Entities (Countries/Cities)",
+        "LOC": "Locations (Non-political)",
+        "ORG": "Organizations",
+        "PER": "People",
+        "PERSON": "People",
+        "PROD": "Products",
+        "PRODUCT": "Products",
+        "PRODCAT": "Product Categories",
+        "PRODUCT_CATEGORY": "Product Categories",
+        "COM": "Companies",
+        "EVENT": "Events",
+        "LANGUAGE": "Languages",
+        "NORP": "Nationalities/Religious/Political Groups",
+        "LAW": "Laws/Legal Documents",
+        "FAC": "Facilities/Landmarks",
+        "INS": "Industry Institutions",
+    }
+
+    entity_types: Dict[str, Any] = {}
+    for r in results:
+        e_type = r["_id"]["type"]
+        entity_name = r["_id"]["entity"].replace("_", " ")
+        if e_type not in entity_types:
+            entity_types[e_type] = {
+                "fullName": type_full_names.get(e_type, e_type),
+                "entities": [],
+            }
+        entity_types[e_type]["entities"].append(
+            {"entityName": entity_name, "mentions": r["mentions"]}
+        )
+
+    # keep only the top 10 per type
+    for type_data in entity_types.values():
+        type_data["entities"] = sorted(
+            type_data["entities"], key=lambda x: -x["mentions"]
+        )[:10]
+
+    return {
+        "title": f"Top Entities - {time_filter.capitalize()}",
+        "dateRange": {"start": start, "end": end},
+        "data": entity_types,
+    }
+
+
+def get_sentiment_analysis_data(time_filter: str) -> Dict[str, Any]:
+    """Return aggregated *Sentiment Analysis* data for articles by category for the given period.
+
+    Uses rolling window approach:
+    - today: only the latest date
+    - weekly: latest date - 6 days (total 7 days)  
+    - monthly: latest date - 29 days (total 30 days)
+
+    Parameters
+    ----------
+    time_filter:
+        Time period filter ('today', 'week'/'weekly', 'month'/'monthly', or any other for all time).
+
+    Returns
+    -------
+    Dict[str, Any]
+        Dictionary containing title, dateRange, and sentiment data by category and date.
+    """
+    start, end = _time_range(time_filter, article_collection)
+
+    # Convert time_filter to match the original logic
+    if time_filter == "today":
+        start_date = datetime.strptime(end, "%Y-%m-%d").date()
+        num_days = 1
+    elif time_filter in {"week", "weekly"}:
+        start_date = datetime.strptime(start, "%Y-%m-%d").date()
+        num_days = 7
+    elif time_filter in {"month", "monthly"}:
+        start_date = datetime.strptime(start, "%Y-%m-%d").date()
+        num_days = 30
+    else:
+        start_date = datetime.strptime(start, "%Y-%m-%d").date()
+        end_date = datetime.strptime(end, "%Y-%m-%d").date()
+        num_days = (end_date - start_date).days + 1
+
+    # Query articles with sentiment scores
+    query = {
+        "publishDate": {"$gte": start, "$lte": end},
+        "sentimentScore": {"$exists": True}
+    }
+
+    docs = list(article_collection.find(query))
+    daily_scores = defaultdict(lambda: defaultdict(list))
+
+    # Aggregate sentiment scores by category and date
+    for doc in docs:
+        category = doc.get("category", "Unknown")
+        score = doc.get("sentimentScore")
+        pub_date = doc.get("publishDate")
+        if category and score is not None and pub_date:
+            daily_scores[category][pub_date].append(score)
+
+    # Generate nested data structure: date -> category -> sentiment
+    data = {}
+    for i in range(num_days):
+        day = (start_date + timedelta(days=i)).isoformat()
+        data[day] = {}
+        for category in daily_scores:
+            scores = daily_scores[category].get(day, [])
+            avg_score = sum(scores) / len(scores) if scores else None
+            data[day][category] = avg_score
+
+    return {
+        "title": f"Sentiment Analysis by Category — {time_filter.capitalize()}",
+        "dateRange": {"start": start, "end": end},
+        "data": data
+    }
+
+
+def get_entity_sentiment_data(time_filter: str = "weekly") -> Dict[str, Any]:
+    """Return *Entity Sentiment Analysis* data for the given period.
+
+    Uses rolling window approach:
+    - today: only the latest date
+    - weekly: latest date - 6 days (total 7 days)
+    - monthly: latest date - 29 days (total 30 days)
+
+    Parameters
+    ----------
+    time_filter:
+        Time period filter. Defaults to 'weekly' to match original behavior.
+
+    Returns
+    -------
+    Dict[str, Any]
+        Dictionary containing title, dateRange, and entity sentiment data.
+    """
+    start, end = _time_range(time_filter, entity_collection)
+
+    # Convert to date for calculations
+    start_date = datetime.strptime(start, "%Y-%m-%d").date()
+    end_date = datetime.strptime(end, "%Y-%m-%d").date()
+
+    # Calculate num_days based on sentiment logic
+    if time_filter == "today":
+        num_days = 1
+    elif time_filter in {"week", "weekly"}:
+        num_days = 7
+    elif time_filter in {"month", "monthly"}:
+        num_days = 30
+    else:
+        num_days = (end_date - start_date).days + 1
+
+    # Query entities with sentiment scores
+    query = {
+        "publishDate": {"$gte": start, "$lte": end},
+        "sentimentScore": {"$exists": True},
+        "entity": {"$exists": True},
+        "entityType": {"$exists": True}
+    }
+
+    docs = list(entity_collection.find(query))
+    sentiment_by_type = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
+
+    # Aggregate sentiment scores by entity type, entity name, and date
+    for doc in docs:
+        entity = doc.get("entity", "Unknown")
+        entity_type = doc.get("entityType", "Unknown")
+        score = doc.get("sentimentScore")
+        pub_date = doc.get("publishDate")
+
+        if entity and entity_type and score is not None and pub_date:
+            sentiment_by_type[entity_type][entity][pub_date].append(score)
+
+    # Filter top 10 entities per entityType based on sentiment volatility (range)
+    top_n = 10
+    selected_entities = {}
+
+    for entity_type, entities in sentiment_by_type.items():
+        volatility_scores = {}
+        for entity, date_scores in entities.items():
+            # Calculate all sentiment values for this entity
+            all_values = []
+            for i in range(num_days):
+                day = (start_date + timedelta(days=i)).isoformat()
+                scores = date_scores.get(day, [])
+                avg = sum(scores) / len(scores) if scores else None
+                if avg is not None:
+                    all_values.append(avg)
+
+            # Calculate volatility (range: max - min)
+            if len(all_values) > 1:
+                volatility = max(all_values) - min(all_values)
+            elif len(all_values) == 1:
+                volatility = abs(all_values[0])  # Use absolute value for single data point
+            else:
+                volatility = 0  # No data points
+
+            volatility_scores[entity] = volatility
+
+        # Select top N entities with highest volatility
+        top_entities = sorted(volatility_scores.items(), key=lambda x: x[1], reverse=True)[:top_n]
+        selected_entities[entity_type] = [entity for entity, _ in top_entities]
+
+    # Generate nested data structure: entityType -> date -> entity -> sentiment
+    data = {}
+    for i in range(num_days):
+        day = (start_date + timedelta(days=i)).isoformat()
+        for entity_type, entities in sentiment_by_type.items():
+            if entity_type not in data:
+                data[entity_type] = {}
+            if day not in data[entity_type]:
+                data[entity_type][day] = {}
+
+            # Only include selected top entities
+            for entity in selected_entities[entity_type]:
+                date_scores = entities.get(entity, {})
+                scores = date_scores.get(day, [])
+                avg = sum(scores) / len(scores) if scores else None
+                data[entity_type][day][entity.replace("_", " ")] = avg
+
+    return {
+        "title": f"Entity Sentiment Analysis — {time_filter.capitalize()}",
+        "dateRange": {"start": start, "end": end},
+        "data": data
+    }

app/database/mongodb.py

@@ -4,4 +4,7 @@ from pymongo import MongoClient
 
 MongodbClient = MongoClient(os.getenv('MONGODB_URI'))
 FinFastMongodbClient = MongoClient(os.getenv("MONGODB_FINFAST_URI"))
+article_collection = FinFastMongodbClient["FinFAST_China"]["Article"]
 category_collection = FinFastMongodbClient["FinFAST_China"]["Category"]
+entity_collection = FinFastMongodbClient["FinFAST_China"]["Entity"]
+

app/requirements.txt

@@ -1,19 +1,26 @@
 APScheduler==3.11.0
 asgiref==3.9.1
 blinker==1.9.0
+certifi==2025.1.31
+charset-normalizer==3.4.1
 click==8.2.1
 colorama==0.4.6
 dnspython==2.7.0
 Flask==3.1.1
 Flask-APScheduler==1.13.1
 h11==0.16.0
+idna==3.10
 itsdangerous==2.2.0
 Jinja2==3.1.6
 MarkupSafe==3.0.2
 pymongo==3.12.0
 python-dateutil==2.9.0.post0
+pytz==2025.2
+requests==2.32.3
 six==1.17.0
 tzdata==2025.2
 tzlocal==5.3.1
 uvicorn==0.35.0
 Werkzeug==3.1.3
+bidict==0.23.1
+boto3==1.38.43

app/routes/__init__.py

@@ -2,3 +2,4 @@
 from flask import Blueprint
 
 category_bp = Blueprint("category", __name__)
+summary_bp = Blueprint('summary', __name__)

app/routes/summary.py

@@ -0,0 +1,69 @@
+"""This module defines the /summary route for the Flask application."""
+
+import importlib
+from flask import jsonify
+from controllers.summary import get_summary_data
+from . import summary_bp
+
+@summary_bp.route('', methods=['GET'])
+def get_summary():
+    """
+    Generate a summary dashboard with content flow and entity analysis data.
+    
+    This endpoint provides a complete summary overview, including:
+    - Content Flow Tracker: Article counts by source and category
+    - Entity Analysis: Top entities by type with mentions
+    
+    All data is returned together, divided into three time periods: today, week, and month.
+
+    Returns:
+        JSONResponse: A JSON response containing the complete summary dashboard data:
+        {
+            "content": {"today": {...}, "week": {...}, "month": {...}},
+            "entity": {"today": {...}, "week": {...}, "month": {...}}
+        }
+    """
+    summary_data = get_summary_data()
+    return jsonify(summary_data)
+
+
+@summary_bp.route('/<string:module>/<string:chart_id>', methods=['GET'])
+def get_summary_chart(module, chart_id):
+    """
+    Handles GET requests to the summary route with a specific module and chart ID.
+
+    Args:
+        module (str): The module identifier (content or entity).
+        chart_id (str): The chart identifier (today, weekly, monthly).
+
+    Returns:
+        tuple: The result of the chart's process function and HTTP status code 200.
+
+    Raises:
+        ImportError: If the specified chart module cannot be imported.
+        AttributeError: If the imported module does not have a 'process' function.
+
+    Endpoint:
+        GET /<module>/<chart_id>
+    """
+    result = importlib.import_module(f"controllers.summary.{module}.{chart_id}").process()
+    return jsonify(result), 200
+
+
+@summary_bp.route('/<string:module>', methods=['GET'])
+def get_summary_module(module):
+    """
+    Handles GET requests to the summary route for a specific module.
+    Triggers the process for each chart under this module concurrently.
+    
+    Args:
+        module (str): The module identifier (content or entity).
+    
+    Returns:
+        dict: {"module": module, "charts": [chart1, chart2, ...]}
+
+    Raises:
+        ImportError: If the specified module cannot be imported.
+    """
+    result = importlib.import_module("controllers.summary").process(module)
+    return jsonify(result), 200