Added fluview endpoint support

Author: Dmytro Trotsko

src/alternative_interface/helper.py

@@ -0,0 +1,64 @@
+covidcast_fluview_locations_mapping = {
+    "nation:US": "nat",
+    "hhs:1": "hhs1",
+    "hhs:2": "hhs2",
+    "hhs:3": "hhs3",
+    "hhs:4": "hhs4",
+    "hhs:5": "hhs5",
+    "hhs:6": "hhs6",
+    "hhs:7": "hhs7",
+    "hhs:8": "hhs8",
+    "hhs:9": "hhs9",
+    "hhs:10": "hhs10",
+    "state:AK": "AK",
+    "state:AL": "AL",
+    "state:AR": "AR",
+    "state:AZ": "AZ",
+    "state:CA": "CA",
+    "state:CO": "CO",
+    "state:CT": "CT",
+    "state:DC": "DC",
+    "state:DE": "DE",
+    "state:FL": "FL",
+    "state:GA": "GA",
+    "state:HI": "HI",
+    "state:IA": "IA",
+    "state:ID": "ID",
+    "state:IL": "IL",
+    "state:IN": "IN",
+    "state:KS": "KS",
+    "state:KY": "KY",
+    "state:LA": "LA",
+    "state:MA": "MA",
+    "state:MD": "MD",
+    "state:ME": "ME",
+    "state:MI": "MI",
+    "state:MN": "MN",
+    "state:MO": "MO",
+    "state:MS": "MS",
+    "state:MT": "MT",
+    "state:NC": "NC",
+    "state:ND": "ND",
+    "state:NE": "NE",
+    "state:NH": "NH",
+    "state:NJ": "NJ",
+    "state:NM": "NM",
+    "state:NV": "NV",
+    "state:NY": "NY",
+    "state:OH": "OH",
+    "state:OK": "OK",
+    "state:OR": "OR",
+    "state:PA": "PA",
+    "state:RI": "RI",
+    "state:SC": "SC",
+    "state:SD": "SD",
+    "state:TN": "TN",
+    "state:TX": "TX",
+    "state:UT": "UT",
+    "state:VA": "VA",
+    "state:VT": "VT",
+    "state:WA": "WA",
+    "state:WI": "WI",
+    "state:WV": "WV",
+    "state:WY": "WY",
+}

src/alternative_interface/utils.py

@@ -12,6 +12,7 @@
     get_epiweek,
     group_by_property,
 )
+from alternative_interface.helper import covidcast_fluview_locations_mapping
 
 
 def epiweeks_in_date_range(start_date_str: str, end_date_str: str):
@@ -72,6 +73,7 @@ def days_in_date_range(start_date_str: str, end_date_str: str):
 def get_available_geos(indicators):
     geo_values = []
     grouped_indicators = group_by_property(indicators, "data_source")
+    sources = grouped_indicators.keys()
     for data_source, indicators in grouped_indicators.items():
         indicators_str = ",".join(indicator["name"] for indicator in indicators)
         response = requests.get(
@@ -98,6 +100,27 @@ def get_available_geos(indicators):
         .prefetch_related("geo_level")
         .order_by("level")
     ]
+    if "fluview" in sources:
+        geographic_granularities.extend(
+            [
+                {
+                    "id": f"{geo_unit.geo_level.name}:{geo_unit.geo_id}",
+                    "geoType": geo_unit.geo_level.name,
+                    "text": geo_unit.display_name,
+                    "geoTypeDisplayName": geo_unit.geo_level.display_name,
+                }
+                for geo_unit in GeographyUnit.objects.filter(
+                    geo_level__name__in=[
+                        "census-region",
+                        "us-territory",
+                        "us-city",
+                        "ny_minus_jfk",
+                    ]
+                )
+                .prefetch_related("geo_level")
+                .order_by("level")
+            ]
+        )
     grouped_geographic_granularities = group_by_property(
         geographic_granularities, "geoTypeDisplayName"
     )
@@ -113,26 +136,57 @@ def get_available_geos(indicators):
 
 
 def get_covidcast_data(indicator, start_date, end_date, geo, api_key):
-    if indicator["_endpoint"] == "covidcast":
-        time_values = f"{start_date}--{end_date}"
-        if indicator["time_type"] == "week":
-            start_day, end_day = get_epiweek(start_date, end_date)
-            time_values = f"{start_day}-{end_day}"
-        geo_type, geo_value = geo.split(":")
-        params = {
-            "time_type": indicator["time_type"],
-            "time_values": time_values,
-            "data_source": indicator["data_source"],
-            "signal": indicator["name"],
-            "geo_type": geo_type,
-            "geo_values": geo_value.lower(),
-            "api_key": api_key if api_key else settings.EPIDATA_API_KEY,
-        }
-        response = requests.get(f"{settings.EPIDATA_URL}covidcast", params=params)
-        if response.status_code == 200:
-            response_data = response.json()
-            if len(response_data["epidata"]):
-                return response_data["epidata"]
+    time_values = f"{start_date}--{end_date}"
+    if indicator["time_type"] == "week":
+        start_day, end_day = get_epiweek(start_date, end_date)
+        time_values = f"{start_day}-{end_day}"
+    geo_type, geo_value = geo.split(":")
+    params = {
+        "time_type": indicator["time_type"],
+        "time_values": time_values,
+        "data_source": indicator["data_source"],
+        "signal": indicator["name"],
+        "geo_type": geo_type,
+        "geo_values": geo_value.lower(),
+        "api_key": api_key if api_key else settings.EPIDATA_API_KEY,
+    }
+    response = requests.get(f"{settings.EPIDATA_URL}covidcast", params=params)
+    if response.status_code == 200:
+        response_data = response.json()
+        if len(response_data["epidata"]):
+            return response_data["epidata"]
+    return []
+
+
+def get_fluview_data(indicator, geo, start_date, end_date, api_key):
+    region = None
+    try:
+        region = covidcast_fluview_locations_mapping[geo]
+    except KeyError:
+        region = geo.split(":")[1]
+    time_values = f"{start_date}--{end_date}"
+    if indicator["time_type"] == "week":
+        start_day, end_day = get_epiweek(start_date, end_date)
+        time_values = f"{start_day}-{end_day}"
+    params = {
+        "regions": region,
+        "epiweeks": time_values,
+        "api_key": api_key if api_key else settings.EPIDATA_API_KEY,
+    }
+    print(indicator)
+    response = requests.get(f"{settings.EPIDATA_URL}{indicator['data_source']}", params=params)
+    if response.status_code == 200:
+        data = response.json()
+        if len(data["epidata"]):
+            return [
+                {
+                    "time_value": el["epiweek"],
+                    "value": el[indicator["name"]],
+                    "signal": indicator["name"],
+                    "time_type": indicator["time_type"],
+                }
+                for el in data["epidata"]
+            ]
     return []
 
 
@@ -379,20 +433,30 @@ def get_chart_data(indicators, geography):
     chart_data["initialViewEnd"] = end_date
 
     # Fetch data from a wider range (2020 to today) for scrolling
-    data_start_date = "2010-01-01"
+    data_start_date = "1990-01-01"
     data_end_date = today.strftime("%Y-%m-%d")
 
     for indicator in indicators:
         title = generate_epivis_custom_title(indicator, geo_display_name)
         color = generate_random_color()
         indicator_time_type = indicator.get("time_type", "week")
-        data = get_covidcast_data(
-            indicator,
-            data_start_date,
-            data_end_date,
-            geography,
-            settings.EPIDATA_API_KEY,
-        )
+        data = None
+        if indicator["_endpoint"] == "covidcast":
+            data = get_covidcast_data(
+                indicator,
+                data_start_date,
+                data_end_date,
+                geography,
+                settings.EPIDATA_API_KEY,
+            )
+        elif indicator["data_source"] in ["fluview", "fluview_clinical"]:
+            data = get_fluview_data(
+                indicator,
+                geography,
+                data_start_date,
+                data_end_date,
+                settings.EPIDATA_API_KEY,
+            )
         if data:
             # Prepare series with full data range for scrolling
             series = prepare_chart_series_multi(

src/epiportal/management/commands/reset_ids.py

@@ -0,0 +1,89 @@
+from django.core.management.base import BaseCommand
+from django.apps import apps
+from django.db import connection
+
+
+class Command(BaseCommand):
+    help = "Reset AUTO_INCREMENT values for all database tables based on current max IDs"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be done without actually making changes',
+        )
+
+    def handle(self, *args, **options):
+        dry_run = options['dry_run']
+        
+        if dry_run:
+            self.stdout.write(self.style.WARNING("DRY RUN MODE - No changes will be made\n"))
+        
+        models_processed = 0
+        models_skipped = 0
+        
+        # Get all models from installed apps
+        for app_config in apps.get_app_configs():
+            for model in app_config.get_models():
+                # Skip proxy models (they use the same table as their parent)
+                if model._meta.proxy:
+                    continue
+                
+                # Skip models without a primary key or with non-auto-increment PK
+                pk_field = model._meta.pk
+                if not pk_field or not pk_field.auto_created:
+                    continue
+                
+                table_name = model._meta.db_table
+                
+                try:
+                    with connection.cursor() as cursor:
+                        # Get the current max ID
+                        cursor.execute(f"SELECT MAX(`{pk_field.column}`) FROM `{table_name}`")
+                        result = cursor.fetchone()
+                        max_id = result[0] if result[0] is not None else 0
+                        
+                        # Calculate the next AUTO_INCREMENT value
+                        next_auto_increment = max_id + 1 if max_id > 0 else 1
+                        
+                        if dry_run:
+                            self.stdout.write(
+                                f"Would reset {model._meta.label}: "
+                                f"table `{table_name}` AUTO_INCREMENT to {next_auto_increment} "
+                                f"(current max ID: {max_id})"
+                            )
+                        else:
+                            # Reset AUTO_INCREMENT
+                            cursor.execute(
+                                f"ALTER TABLE `{table_name}` AUTO_INCREMENT = {next_auto_increment}"
+                            )
+                            self.stdout.write(
+                                self.style.SUCCESS(
+                                    f"Reset {model._meta.label}: "
+                                    f"table `{table_name}` AUTO_INCREMENT to {next_auto_increment} "
+                                    f"(current max ID: {max_id})"
+                                )
+                            )
+                        
+                        models_processed += 1
+                        
+                except Exception as e:
+                    self.stdout.write(
+                        self.style.ERROR(
+                            f"Error processing {model._meta.label} ({table_name}): {str(e)}"
+                        )
+                    )
+                    models_skipped += 1
+        
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"\nCompleted: {models_processed} tables processed"
+            )
+        )
+        if models_skipped > 0:
+            self.stdout.write(
+                self.style.WARNING(
+                    f"{models_skipped} tables skipped due to errors"
+                )
+            )
+