ALwrity Version 0.5.1 (Fastapi + React)

ToBeMigrated/content_calendar/core/calendar_manager.py

@@ -0,0 +1,163 @@
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional
+import logging
+import sys
+import json
+import os
+from lib.database.models import ContentItem, ContentType, Platform, get_engine, get_session, init_db
+from ..integrations.seo_tools import SEOToolsIntegration
+from ..integrations.gap_analyzer import GapAnalyzerIntegration
+from ..utils.date_utils import calculate_publish_dates
+from ..utils.error_handling import handle_calendar_error
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler('content_calendar_debug.log', mode='a')
+    ]
+)
+logger = logging.getLogger(__name__)
+
+engine = get_engine()
+init_db(engine)
+session = get_session(engine)
+
+class CalendarManager:
+    """
+    Main calendar management system that coordinates content planning,
+    scheduling, and optimization.
+    """
+    def __init__(self):
+        self.logger = logging.getLogger('content_calendar.manager')
+        self.logger.info("Initializing CalendarManager")
+        self.seo_tools = SEOToolsIntegration()
+        self.gap_analyzer = GapAnalyzerIntegration()
+        self.logger.info("CalendarManager initialized successfully")
+
+    @handle_calendar_error
+    def create_calendar(
+        self,
+        start_date: datetime,
+        duration: str,  # 'weekly', 'monthly', 'quarterly'
+        platforms: List[str],
+        website_url: str
+    ) -> List[ContentItem]:
+        self.logger.info(f"Creating new calendar for {website_url}")
+        self.logger.debug(f"Parameters: start_date={start_date}, duration={duration}, platforms={platforms}")
+        try:
+            gap_analysis = self.gap_analyzer.analyze_gaps(website_url)
+            topics = self._generate_topics(gap_analysis, platforms)
+            schedule = calculate_publish_dates(
+                topics=topics,
+                start_date=start_date,
+                duration=duration
+            )
+            # Add to DB
+            for topic in schedule:
+                session.add(topic)
+            session.commit()
+            self.logger.info("Calendar created and content scheduled in DB successfully")
+            return schedule
+        except Exception as e:
+            self.logger.error(f"Error creating calendar: {str(e)}", exc_info=True)
+            raise
+
+    def _generate_topics(
+        self,
+        gap_analysis: Dict[str, Any],
+        platforms: List[str]
+    ) -> List[ContentItem]:
+        topics = []
+        for gap in gap_analysis['gaps']:
+            topic = self._generate_topic_from_gap(gap, platforms)
+            optimized_topic = self._optimize_topic(topic)
+            topics.append(optimized_topic)
+        return topics
+
+    def _generate_topic_from_gap(
+        self,
+        gap: Dict[str, Any],
+        platforms: List[str]
+    ) -> ContentItem:
+        topic_data = {
+            'title': self._generate_title(gap),
+            'description': self._generate_description(gap),
+            'keywords': gap.get('keywords', []),
+            'platforms': platforms,
+            'content_type': self._determine_content_type(gap, platforms),
+            'publish_date': datetime.now(),
+            'status': 'Draft',
+            'author': None,
+            'tags': [],
+            'notes': None,
+            'seo_data': {}
+        }
+        return ContentItem(**topic_data)
+
+    def _optimize_topic(self, topic: ContentItem) -> ContentItem:
+        topic.title = self.seo_tools.optimize_title(topic.title)
+        topic.seo_data['meta_description'] = self.seo_tools.generate_meta_description(topic.description)
+        topic.seo_data['structured_data'] = self.seo_tools.generate_structured_data(topic.content_type)
+        return topic
+
+    def get_all_content(self) -> List[ContentItem]:
+        return session.query(ContentItem).all()
+
+    def remove_content(self, content_id):
+        content = session.query(ContentItem).get(content_id)
+        if content:
+            session.delete(content)
+            session.commit()
+
+    def update_content(self, content_id, **kwargs):
+        content = session.query(ContentItem).get(content_id)
+        if content:
+            for key, value in kwargs.items():
+                setattr(content, key, value)
+            session.commit()
+
+    def get_calendar(self) -> Optional[List[ContentItem]]:
+        """
+        Get the current calendar.
+        """
+        self.logger.debug("Getting current calendar")
+        return self.get_all_content()
+    
+    def update_calendar(self, calendar: List[ContentItem]) -> None:
+        """
+        Update the current calendar.
+        """
+        self.get_all_content()
+        for content in calendar:
+            session.add(content)
+        session.commit()
+    
+    def export_calendar(self) -> Optional[Dict[str, Any]]:
+        """Export the current calendar."""
+        self.logger.info("Exporting calendar")
+        calendar = self.get_calendar()
+        if not calendar:
+            self.logger.warning("No calendar to export")
+            return None
+        
+        try:
+            calendar_data = [content.to_dict() for content in calendar]
+            self.logger.info("Calendar exported successfully")
+            return calendar_data
+        except Exception as e:
+            self.logger.error(f"Error exporting calendar: {str(e)}", exc_info=True)
+            return None
+
+    def save_calendar_to_json(self):
+        calendar = self.get_calendar()
+        if calendar:
+            with open("calendar_data.json", "w") as f:
+                json.dump(calendar, f, indent=2, default=str)
+
+    def load_calendar_from_json(self):
+        if os.path.exists("calendar_data.json"):
+            with open("calendar_data.json", "r") as f:
+                data = json.load(f)
+            self.update_calendar(data)