fusesell 1.2.4__py3-none-any.whl → 1.2.6__py3-none-any.whl

fusesell_local/utils/data_manager.py

@@ -3,14 +3,15 @@ Local Data Manager for FuseSell Local Implementation
 Handles SQLite database operations and local file management
 """
 
-import sqlite3
+import sqlite3
 import json
 import os
 import uuid
+import shutil
 from typing import Dict, Any, List, Optional, Sequence, Union
-from datetime import datetime
-import logging
-from pathlib import Path
+from datetime import datetime
+import logging
+from pathlib import Path
 
 
 class LocalDataManager:
@@ -69,10 +70,72 @@ class LocalDataManager:
         # Initialize database with optimization check
         self._init_database_optimized()
 
-    def _create_directories(self) -> None:
-        """Create necessary directories for data storage."""
-        for directory in [self.data_dir, self.config_dir, self.drafts_dir, self.logs_dir]:
-            directory.mkdir(parents=True, exist_ok=True)
+    def _create_directories(self) -> None:
+        """Create necessary directories for data storage."""
+        for directory in [self.data_dir, self.config_dir, self.drafts_dir, self.logs_dir]:
+            directory.mkdir(parents=True, exist_ok=True)
+        self._ensure_default_config_files()
+
+    def _ensure_default_config_files(self) -> None:
+        """
+        Copy bundled configuration defaults into the writable data directory when missing.
+
+        Ensures first-run executions always have the same baseline prompts, scoring criteria,
+        and email templates as the packaged FuseSell server flows.
+        """
+        try:
+            package_config_dir = Path(__file__).resolve().parents[2] / "fusesell_data" / "config"
+        except Exception as exc:
+            self.logger.debug(f"Unable to resolve packaged config directory: {exc}")
+            return
+
+        if not package_config_dir.exists():
+            self.logger.debug("Packaged config directory not found; skipping default config seeding")
+            return
+
+        default_files = [
+            "prompts.json",
+            "scoring_criteria.json",
+            "email_templates.json",
+        ]
+
+        for filename in default_files:
+            target = self.config_dir / filename
+            if target.exists():
+                continue
+
+            source = package_config_dir / filename
+            if not source.exists():
+                self.logger.debug(f"Packaged default {filename} not found; skipping seed")
+                continue
+
+            try:
+                shutil.copyfile(source, target)
+                self.logger.info(f"Seeded default configuration file: {filename}")
+            except Exception as exc:
+                self.logger.warning(f"Failed to seed default configuration {filename}: {exc}")
+
+    def _load_packaged_config_file(self, filename: str) -> Dict[str, Any]:
+        """
+        Load a configuration JSON file bundled with the package as a fallback.
+
+        Args:
+            filename: Name of the configuration file to load.
+
+        Returns:
+            Parsed configuration dictionary or empty dict on failure.
+        """
+        try:
+            package_config_dir = Path(__file__).resolve().parents[2] / "fusesell_data" / "config"
+            path = package_config_dir / filename
+            if not path.exists():
+                return {}
+
+            with path.open("r", encoding="utf-8") as handle:
+                return json.load(handle)
+        except Exception as exc:
+            self.logger.debug(f"Failed to load packaged config {filename}: {exc}")
+            return {}
 
     def _init_database_optimized(self) -> None:
         """
@@ -454,11 +517,11 @@ class LocalDataManager:
                         submission_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                         retrieved_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                     )
-                """)
-
-                # Create scheduler_rules table (equivalent to gs_scheduler)
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS scheduler_rules (
+                """)
+
+                # Create scheduler_rules table (equivalent to gs_scheduler)
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS scheduler_rules (
                         id TEXT PRIMARY KEY,
                         org_id TEXT NOT NULL,
                         org_name TEXT,
@@ -478,14 +541,36 @@ class LocalDataManager:
                         username TEXT,
                         fullname TEXT,
                         instance_id TEXT,
-                        submission_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                    )
-                """)
-
-                # Create extracted_files table (equivalent to gs_plan_setting_extracted_file)
-                cursor.execute("""
-                    CREATE TABLE IF NOT EXISTS extracted_files (
-                        id TEXT PRIMARY KEY,
+                        submission_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+
+                # Create reminder_task table (equivalent to Directus reminder_task)
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS reminder_task (
+                        id TEXT PRIMARY KEY,
+                        status TEXT NOT NULL,
+                        task TEXT NOT NULL,
+                        cron TEXT NOT NULL,
+                        room_id TEXT,
+                        tags TEXT,
+                        customextra TEXT,
+                        org_id TEXT,
+                        customer_id TEXT,
+                        task_id TEXT,
+                        import_uuid TEXT,
+                        scheduled_time TIMESTAMP,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        executed_at TIMESTAMP,
+                        error_message TEXT
+                    )
+                """)
+
+                # Create extracted_files table (equivalent to gs_plan_setting_extracted_file)
+                cursor.execute("""
+                    CREATE TABLE IF NOT EXISTS extracted_files (
+                        id TEXT PRIMARY KEY,
                         org_id TEXT NOT NULL,
                         plan_id TEXT,
                         team_id TEXT,
@@ -585,17 +670,25 @@ class LocalDataManager:
                     "CREATE INDEX IF NOT EXISTS idx_team_settings_team_id ON team_settings(team_id)")
                 cursor.execute(
                     "CREATE INDEX IF NOT EXISTS idx_products_org_id ON products(org_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_gs_customer_llmtask_task_id ON gs_customer_llmtask(task_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_prompts_org_id ON prompts(org_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_scheduler_rules_org_id ON scheduler_rules(org_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_extracted_files_org_id ON extracted_files(org_id)")
-                cursor.execute(
-                    "CREATE INDEX IF NOT EXISTS idx_llm_worker_plan_org_id ON llm_worker_plan(org_id)")
-                cursor.execute(
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_gs_customer_llmtask_task_id ON gs_customer_llmtask(task_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_prompts_org_id ON prompts(org_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_scheduler_rules_org_id ON scheduler_rules(org_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_status ON reminder_task(status)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_org_id ON reminder_task(org_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_task_id ON reminder_task(task_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_cron ON reminder_task(cron)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_extracted_files_org_id ON extracted_files(org_id)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_llm_worker_plan_org_id ON llm_worker_plan(org_id)")
+                cursor.execute(
                     "CREATE INDEX IF NOT EXISTS idx_gs_company_criteria_org_id ON gs_company_criteria(org_id)")
 
                 # Create compatibility views for backward compatibility
@@ -1020,56 +1113,71 @@ class LocalDataManager:
             self.logger.error(f"Failed to get stage results: {str(e)}")
             raise
 
-    def load_prompts(self) -> Dict[str, Any]:
-        """
-        Load prompt templates from configuration.
-
-        Returns:
-            Dictionary of prompt templates
-        """
-        try:
-            prompts_file = self.config_dir / "prompts.json"
-            if prompts_file.exists():
-                with open(prompts_file, 'r', encoding='utf-8') as f:
-                    return json.load(f)
-            return {}
-        except Exception as e:
-            self.logger.error(f"Failed to load prompts: {str(e)}")
-            return {}
-
-    def load_scoring_criteria(self) -> Dict[str, Any]:
+    def load_prompts(self) -> Dict[str, Any]:
+        """
+        Load prompt templates from configuration.
+
+        Returns:
+            Dictionary of prompt templates
+        """
+        try:
+            prompts_file = self.config_dir / "prompts.json"
+            if prompts_file.exists():
+                with open(prompts_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+
+            packaged = self._load_packaged_config_file("prompts.json")
+            if packaged:
+                return packaged
+
+            return {}
+        except Exception as e:
+            self.logger.error(f"Failed to load prompts: {str(e)}")
+            return {}
+
+    def load_scoring_criteria(self) -> Dict[str, Any]:
         """
         Load scoring criteria configuration.
 
-        Returns:
-            Dictionary of scoring criteria
-        """
-        try:
-            criteria_file = self.config_dir / "scoring_criteria.json"
-            if criteria_file.exists():
-                with open(criteria_file, 'r', encoding='utf-8') as f:
-                    return json.load(f)
-            return {}
-        except Exception as e:
-            self.logger.error(f"Failed to load scoring criteria: {str(e)}")
-            return {}
-
-    def load_email_templates(self) -> Dict[str, Any]:
+        Returns:
+            Dictionary of scoring criteria
+        """
+        try:
+            criteria_file = self.config_dir / "scoring_criteria.json"
+            if criteria_file.exists():
+                with open(criteria_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+
+            packaged = self._load_packaged_config_file("scoring_criteria.json")
+            if packaged:
+                return packaged
+
+            return {}
+        except Exception as e:
+            self.logger.error(f"Failed to load scoring criteria: {str(e)}")
+            return {}
+
+    def load_email_templates(self) -> Dict[str, Any]:
         """
         Load email templates configuration.
 
-        Returns:
-            Dictionary of email templates
-        """
-        try:
-            templates_file = self.config_dir / "email_templates.json"
-            if templates_file.exists():
-                with open(templates_file, 'r', encoding='utf-8') as f:
-                    return json.load(f)
-            return {}
-        except Exception as e:
-            self.logger.error(f"Failed to load email templates: {str(e)}")
-            return {}
+        Returns:
+            Dictionary of email templates
+        """
+        try:
+            templates_file = self.config_dir / "email_templates.json"
+            if templates_file.exists():
+                with open(templates_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+
+            packaged = self._load_packaged_config_file("email_templates.json")
+            if packaged:
+                return packaged
+
+            return {}
+        except Exception as e:
+            self.logger.error(f"Failed to load email templates: {str(e)}")
+            return {}
 
     def _generate_customer_id(self) -> str:
         """Generate unique customer ID."""
@@ -1463,6 +1571,59 @@ class LocalDataManager:
             'gs_team_product',
             'gs_team_auto_interaction',
         }
+        list_field_defaults = {
+            'gs_team_organization': {
+                'org_name': None,
+                'address': None,
+                'website': None,
+                'industry': None,
+                'description': None,
+                'logo': None,
+                'primary_email': None,
+                'primary_phone': None,
+                'primary_color': None,
+                'is_active': False,
+                'avg_rating': None,
+                'total_sales': None,
+                'total_products': None,
+                'date_joined': None,
+                'last_active': None,
+                'social_media_links': [],
+            },
+            'gs_team_rep': {
+                'name': None,
+                'email': None,
+                'phone': None,
+                'position': None,
+                'website': None,
+                'logo': None,
+                'username': None,
+                'is_primary': False,
+                'primary_color': None,
+                'primary_phone': None,
+            },
+            'gs_team_product': {
+                'product_id': None,
+                'product_name': None,
+                'image_url': None,
+                'enabled': True,
+                'priority': None,
+            },
+            'gs_team_auto_interaction': {
+                'from_email': '',
+                'from_name': '',
+                'from_number': '',
+                'tool_type': 'Email',
+                'email_cc': '',
+                'email_bcc': '',
+            },
+        }
+        alias_fields = {
+            'gs_team_organization': {
+                'name': 'org_name',
+                'brand_palette': 'primary_color',
+            },
+        }
 
         snapshot: Dict[str, Any] = {}
         for field in fields_to_include:
@@ -1472,9 +1633,35 @@ class LocalDataManager:
 
             if field in list_like_fields:
                 if isinstance(value, list):
-                    snapshot[field] = value
+                    normalized_items = []
+                    defaults = list_field_defaults.get(field, {})
+                    aliases = alias_fields.get(field, {})
+                    for item in value:
+                        if not isinstance(item, dict):
+                            continue
+                        normalized = {}
+                        for key, default_val in defaults.items():
+                            if key == 'social_media_links':
+                                current = item.get(key)
+                                normalized[key] = current if isinstance(current, list) else []
+                            else:
+                                normalized[key] = item.get(key, default_val)
+                        for legacy_key, target_key in aliases.items():
+                            if normalized.get(target_key) in (None, '', []):
+                                if legacy_key in item:
+                                    normalized[target_key] = item[legacy_key]
+                        # include any additional keys that might exist
+                        normalized_items.append(normalized)
+                    snapshot[field] = normalized_items
                 elif value:
-                    snapshot[field] = [value]
+                    defaults = list_field_defaults.get(field, {})
+                    aliases = alias_fields.get(field, {})
+                    normalized = {key: value.get(key, default_val) for key, default_val in defaults.items()}
+                    for legacy_key, target_key in aliases.items():
+                        if normalized.get(target_key) in (None, '', []):
+                            if legacy_key in value:
+                                normalized[target_key] = value[legacy_key]
+                    snapshot[field] = [normalized]
                 else:
                     snapshot[field] = []
             else: