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

fusesell_local/utils/event_scheduler.py

@@ -3,14 +3,14 @@ Event Scheduler - Database-based event scheduling system
 Creates scheduled events in database for external app to handle
 """
 
-import logging
-from datetime import datetime, timedelta
-from typing import Dict, Any, Optional, List
-import pytz
-import json
-import sqlite3
-import uuid
-from pathlib import Path
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional, List, Union
+import pytz
+import json
+import sqlite3
+import uuid
+from pathlib import Path
 
 
 class EventScheduler:
@@ -73,15 +73,53 @@ class EventScheduler:
                 ON scheduled_events(scheduled_time, status)
             """)
             
-            cursor.execute("""
-                CREATE INDEX IF NOT EXISTS idx_scheduled_events_org_team 
-                ON scheduled_events(org_id, team_id)
-            """)
-            
-            conn.commit()
-            conn.close()
-            
-            self.logger.info("Scheduled events database initialized")
+            cursor.execute("""
+                CREATE INDEX IF NOT EXISTS idx_scheduled_events_org_team 
+                ON scheduled_events(org_id, team_id)
+            """)
+
+            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
+                )
+            """)
+
+            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)
+            """)
+            
+            conn.commit()
+            conn.close()
+            
+            self.logger.info("Scheduled events database initialized")
             
         except Exception as e:
             self.logger.error(f"Failed to initialize scheduled events DB: {str(e)}")
@@ -122,15 +160,225 @@ class EventScheduler:
             conn.commit()
             conn.close()
             
-            self.logger.info("Scheduling rules database initialized")
-            
-        except Exception as e:
-            self.logger.error(f"Failed to initialize scheduling rules DB: {str(e)}")
-            raise
+            self.logger.info("Scheduling rules database initialized")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize scheduling rules DB: {str(e)}")
+            raise
+
+    def _format_datetime(self, value: Union[str, datetime, None]) -> str:
+        """
+        Normalize datetime-like values to ISO 8601 strings.
+
+        Args:
+            value: Datetime, ISO string, or None.
+
+        Returns:
+            ISO 8601 formatted string.
+        """
+        if isinstance(value, datetime):
+            return value.isoformat()
+        if value is None:
+            return datetime.utcnow().isoformat()
+
+        value_str = str(value).strip()
+        if not value_str:
+            return datetime.utcnow().isoformat()
+
+        try:
+            parsed = datetime.fromisoformat(value_str)
+            return parsed.isoformat()
+        except ValueError:
+            return value_str
+
+    def _build_reminder_payload(
+        self,
+        base_context: Dict[str, Any],
+        *,
+        event_id: str,
+        send_time: datetime,
+        email_type: str,
+        org_id: str,
+        recipient_address: str,
+        recipient_name: str,
+        draft_id: str,
+        customer_timezone: str,
+        follow_up_iteration: Optional[int] = None
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Construct reminder_task payload mirroring server implementation.
+
+        Args:
+            base_context: Context data supplied by caller.
+            event_id: Scheduled event identifier.
+            send_time: Planned send time (UTC).
+            email_type: 'initial' or 'follow_up'.
+            org_id: Organization identifier.
+            recipient_address: Recipient email.
+            recipient_name: Recipient name.
+            draft_id: Draft identifier.
+            customer_timezone: Customer timezone.
+            follow_up_iteration: Optional follow-up iteration counter.
+
+        Returns:
+            Reminder payload dictionary or None if insufficient data.
+        """
+        if not base_context:
+            return None
+
+        context = dict(base_context)
+        customextra_raw = context.pop('customextra', {}) or {}
+        if isinstance(customextra_raw, str):
+            try:
+                customextra = json.loads(customextra_raw)
+            except (json.JSONDecodeError, TypeError):
+                customextra = {}
+        elif isinstance(customextra_raw, dict):
+            customextra = dict(customextra_raw)
+        else:
+            customextra = {}
+
+        status = context.pop('status', 'published') or 'published'
+        cron_value = context.pop('cron', None)
+        scheduled_time_value = context.pop('scheduled_time', None)
+        room_id = context.pop('room_id', context.pop('room', None))
+        tags = context.pop('tags', None)
+        task_label = context.pop('task', None)
+        org_id_override = context.pop('org_id', None) or org_id
+        customer_id = context.pop('customer_id', None) or customextra.get('customer_id')
+        task_id = context.pop('task_id', None) or context.pop('execution_id', None) or customextra.get('task_id')
+        customer_name = context.pop('customer_name', None)
+        language = context.pop('language', None)
+        team_id = context.pop('team_id', None)
+        team_name = context.pop('team_name', None)
+        staff_name = context.pop('staff_name', None)
+        import_uuid = context.pop('import_uuid', None) or customextra.get('import_uuid')
+
+        customextra.setdefault('reminder_content', 'draft_send' if email_type == 'initial' else 'follow_up')
+        customextra.setdefault('org_id', org_id_override)
+        customextra.setdefault('customer_id', customer_id)
+        customextra.setdefault('task_id', task_id)
+        customextra.setdefault('event_id', event_id)
+        customextra.setdefault('email_type', email_type)
+        customextra.setdefault('recipient_address', recipient_address)
+        customextra.setdefault('recipient_name', recipient_name)
+        customextra.setdefault('draft_id', draft_id)
+        customextra.setdefault('customer_timezone', customer_timezone)
+        customextra.setdefault('scheduled_time_utc', send_time.isoformat())
+
+        if team_id and 'team_id' not in customextra:
+            customextra['team_id'] = team_id
+        if team_name and 'team_name' not in customextra:
+            customextra['team_name'] = team_name
+        if language and 'language' not in customextra:
+            customextra['language'] = language
+        if staff_name and 'staff_name' not in customextra:
+            customextra['staff_name'] = staff_name
+        if customer_name and 'customer_name' not in customextra:
+            customextra['customer_name'] = customer_name
+
+        iteration = follow_up_iteration or context.pop('current_follow_up_time', None)
+        if iteration is not None and 'current_follow_up_time' not in customextra:
+            customextra['current_follow_up_time'] = iteration
+
+        if not import_uuid:
+            import_uuid = f"{customextra.get('org_id', '')}_{customextra.get('customer_id', '')}_{customextra.get('task_id', '')}_{event_id}"
+        customextra.setdefault('import_uuid', import_uuid)
+
+        if not tags:
+            tags = ['fusesell', 'init-outreach' if email_type == 'initial' else 'follow-up']
+
+        if not task_label:
+            readable_type = "Initial Outreach" if email_type == 'initial' else "Follow-up"
+            identifier = customextra.get('customer_name') or customextra.get('customer_id') or customer_id or 'customer'
+            tracking_id = customextra.get('task_id') or task_id or draft_id
+            task_label = f"FuseSell {readable_type} {identifier} - {tracking_id}"
+
+        cron_value = self._format_datetime(cron_value or send_time)
+        scheduled_time_str = self._format_datetime(scheduled_time_value or send_time)
+
+        return {
+            'status': status,
+            'task': task_label,
+            'cron': cron_value,
+            'room_id': room_id,
+            'tags': tags,
+            'customextra': customextra,
+            'org_id': customextra.get('org_id'),
+            'customer_id': customextra.get('customer_id'),
+            'task_id': customextra.get('task_id'),
+            'import_uuid': customextra.get('import_uuid'),
+            'scheduled_time': scheduled_time_str
+        }
+
+    def _insert_reminder_task(self, payload: Optional[Dict[str, Any]]) -> Optional[str]:
+        """
+        Insert reminder_task record into local database.
+
+        Args:
+            payload: Reminder payload produced by _build_reminder_payload.
+
+        Returns:
+            Reminder task identifier or None on failure.
+        """
+        if not payload:
+            return None
+
+        try:
+            reminder_id = payload.get('id') or f"uuid:{str(uuid.uuid4())}"
+
+            tags_value = payload.get('tags')
+            if isinstance(tags_value, (list, tuple)):
+                tags_str = json.dumps(list(tags_value))
+            elif isinstance(tags_value, str):
+                tags_str = tags_value
+            else:
+                tags_str = json.dumps([])
+
+            customextra_value = payload.get('customextra') or {}
+            if isinstance(customextra_value, dict):
+                customextra_str = json.dumps(customextra_value)
+            elif isinstance(customextra_value, str):
+                customextra_str = customextra_value
+            else:
+                customextra_str = json.dumps({})
+
+            conn = sqlite3.connect(self.main_db_path)
+            cursor = conn.cursor()
+
+            cursor.execute("""
+                INSERT INTO reminder_task
+                (id, status, task, cron, room_id, tags, customextra, org_id, customer_id, task_id, import_uuid, scheduled_time)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                reminder_id,
+                payload.get('status', 'published'),
+                payload.get('task') or 'FuseSell Reminder',
+                self._format_datetime(payload.get('cron')),
+                payload.get('room_id'),
+                tags_str,
+                customextra_str,
+                payload.get('org_id'),
+                payload.get('customer_id'),
+                payload.get('task_id'),
+                payload.get('import_uuid'),
+                self._format_datetime(payload.get('scheduled_time'))
+            ))
+
+            conn.commit()
+            conn.close()
+
+            self.logger.debug(f"Created reminder_task record {reminder_id}")
+            return reminder_id
+
+        except Exception as exc:
+            self.logger.error(f"Failed to create reminder_task record: {str(exc)}")
+            return None
 
-    def schedule_email_event(self, draft_id: str, recipient_address: str, recipient_name: str,
-                           org_id: str, team_id: str = None, customer_timezone: str = None,
-                           email_type: str = 'initial', send_immediately: bool = False) -> Dict[str, Any]:
+    def schedule_email_event(self, draft_id: str, recipient_address: str, recipient_name: str,
+                           org_id: str, team_id: str = None, customer_timezone: str = None,
+                           email_type: str = 'initial', send_immediately: bool = False,
+                           reminder_context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """
         Schedule an email event in the database for external app to handle.
 
@@ -142,7 +390,8 @@ class EventScheduler:
             team_id: Team ID (optional)
             customer_timezone: Customer's timezone (optional)
             email_type: Type of email ('initial' or 'follow_up')
-            send_immediately: If True, schedule for immediate sending
+            send_immediately: If True, schedule for immediate sending
+            reminder_context: Optional metadata for reminder_task mirroring server behaviour
 
         Returns:
             Event creation result with event ID and scheduled time
@@ -180,40 +429,82 @@ class EventScheduler:
             conn = sqlite3.connect(self.main_db_path)
             cursor = conn.cursor()
             
-            cursor.execute("""
-                INSERT INTO scheduled_events 
-                (id, event_id, event_type, scheduled_time, org_id, team_id, draft_id,
-                 recipient_address, recipient_name, customer_timezone, event_data)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            cursor.execute("""
+                INSERT INTO scheduled_events 
+                (id, event_id, event_type, scheduled_time, org_id, team_id, draft_id,
+                 recipient_address, recipient_name, customer_timezone, event_data)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """, (
                 f"uuid:{str(uuid.uuid4())}", event_id, 'email_send', send_time, org_id, team_id, draft_id,
                 recipient_address, recipient_name, customer_timezone, json.dumps(event_data)
             ))
             
-            conn.commit()
-            conn.close()
-            
-            # Log the scheduling
-            self.logger.info(f"Scheduled email event {event_id} for {send_time} (draft: {draft_id})")
-            
-            # Schedule follow-up if this is an initial email
-            follow_up_event_id = None
-            if email_type == 'initial' and not send_immediately:
-                follow_up_result = self._schedule_follow_up_event(
-                    draft_id, recipient_address, recipient_name, org_id, team_id, customer_timezone
-                )
-                follow_up_event_id = follow_up_result.get('event_id')
-            
-            return {
-                'success': True,
-                'event_id': event_id,
-                'scheduled_time': send_time.isoformat(),
-                'recipient_address': recipient_address,
-                'recipient_name': recipient_name,
-                'draft_id': draft_id,
-                'email_type': email_type,
-                'follow_up_event_id': follow_up_event_id
-            }
+            conn.commit()
+            conn.close()
+
+            reminder_task_id = None
+            if reminder_context:
+                reminder_payload = self._build_reminder_payload(
+                    dict(reminder_context),
+                    event_id=event_id,
+                    send_time=send_time,
+                    email_type=email_type,
+                    org_id=org_id,
+                    recipient_address=recipient_address,
+                    recipient_name=recipient_name,
+                    draft_id=draft_id,
+                    customer_timezone=customer_timezone
+                )
+                reminder_task_id = self._insert_reminder_task(reminder_payload)
+
+            # Log the scheduling
+            self.logger.info(f"Scheduled email event {event_id} for {send_time} (draft: {draft_id})")
+
+            # Schedule follow-up if this is an initial email
+            follow_up_event_id = None
+            follow_up_reminder_id = None
+            if email_type == 'initial' and not send_immediately:
+                follow_up_context = None
+                if reminder_context:
+                    follow_up_context = dict(reminder_context)
+                    follow_up_extra = dict(follow_up_context.get('customextra', {}) or {})
+                    follow_up_extra['reminder_content'] = 'follow_up'
+                    follow_up_extra.setdefault('current_follow_up_time', 1)
+                    follow_up_context['customextra'] = follow_up_extra
+                    follow_up_context['tags'] = follow_up_context.get('tags') or ['fusesell', 'follow-up']
+
+                follow_up_result = self._schedule_follow_up_event(
+                    draft_id,
+                    recipient_address,
+                    recipient_name,
+                    org_id,
+                    team_id,
+                    customer_timezone,
+                    reminder_context=follow_up_context
+                )
+
+                if follow_up_result.get('success'):
+                    follow_up_event_id = follow_up_result.get('event_id')
+                    follow_up_reminder_id = follow_up_result.get('reminder_task_id')
+                else:
+                    self.logger.warning(
+                        "Follow-up scheduling failed for event %s: %s",
+                        event_id,
+                        follow_up_result.get('error', 'unknown error')
+                    )
+
+            return {
+                'success': True,
+                'event_id': event_id,
+                'scheduled_time': send_time.isoformat(),
+                'recipient_address': recipient_address,
+                'recipient_name': recipient_name,
+                'draft_id': draft_id,
+                'email_type': email_type,
+                'reminder_task_id': reminder_task_id,
+                'follow_up_event_id': follow_up_event_id,
+                'follow_up_reminder_task_id': follow_up_reminder_id
+            }
             
         except Exception as e:
             self.logger.error(f"Failed to schedule email event: {str(e)}")
@@ -222,9 +513,10 @@ class EventScheduler:
                 'error': str(e)
             }
 
-    def _schedule_follow_up_event(self, original_draft_id: str, recipient_address: str, 
-                                recipient_name: str, org_id: str, team_id: str = None,
-                                customer_timezone: str = None) -> Dict[str, Any]:
+    def _schedule_follow_up_event(self, original_draft_id: str, recipient_address: str, 
+                                recipient_name: str, org_id: str, team_id: str = None,
+                                customer_timezone: str = None,
+                                reminder_context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """
         Schedule follow-up email event after initial email.
 
@@ -234,7 +526,8 @@ class EventScheduler:
             recipient_name: Name of recipient
             org_id: Organization ID
             team_id: Team ID (optional)
-            customer_timezone: Customer's timezone (optional)
+            customer_timezone: Customer's timezone (optional)
+            reminder_context: Optional metadata for reminder_task rows
 
         Returns:
             Follow-up event creation result
@@ -275,24 +568,41 @@ class EventScheduler:
                 original_draft_id, recipient_address, recipient_name, 
                 customer_timezone, json.dumps(event_data)
             ))
-            
-            conn.commit()
-            conn.close()
-            
-            self.logger.info(f"Scheduled follow-up event {followup_event_id} for {follow_up_time}")
-            
-            return {
-                'success': True,
-                'event_id': followup_event_id,
-                'scheduled_time': follow_up_time.isoformat()
-            }
+            
+            conn.commit()
+            conn.close()
+            
+            reminder_task_id = None
+            if reminder_context:
+                reminder_payload = self._build_reminder_payload(
+                    dict(reminder_context),
+                    event_id=followup_event_id,
+                    send_time=follow_up_time,
+                    email_type='follow_up',
+                    org_id=org_id,
+                    recipient_address=recipient_address,
+                    recipient_name=recipient_name,
+                    draft_id=original_draft_id,
+                    customer_timezone=event_data['customer_timezone']
+                )
+                reminder_task_id = self._insert_reminder_task(reminder_payload)
+            
+            self.logger.info(f"Scheduled follow-up event {followup_event_id} for {follow_up_time}")
+            
+            return {
+                'success': True,
+                'event_id': followup_event_id,
+                'scheduled_time': follow_up_time.isoformat(),
+                'reminder_task_id': reminder_task_id
+            }
             
         except Exception as e:
-            self.logger.error(f"Failed to schedule follow-up event: {str(e)}")
-            return {
-                'success': False,
-                'error': str(e)
-            }
+            self.logger.error(f"Failed to schedule follow-up event: {str(e)}")
+            return {
+                'success': False,
+                'error': str(e),
+                'reminder_task_id': None
+            }
 
     def _get_scheduling_rule(self, org_id: str, team_id: str = None) -> Dict[str, Any]:
         """
@@ -615,4 +925,4 @@ class EventScheduler:
             
         except Exception as e:
             self.logger.error(f"Failed to create scheduling rule: {str(e)}")
-            return False
+            return False