269 lines
13 KiB
Python
269 lines
13 KiB
Python
"""
|
|
Enhanced Calendar Models for AI-Powered Content Planning
|
|
Defines additional database schema for intelligent calendar generation and optimization.
|
|
"""
|
|
|
|
from sqlalchemy import Column, Integer, String, Text, DateTime, Float, JSON, ForeignKey, Boolean
|
|
from sqlalchemy.ext.declarative import declarative_base
|
|
from sqlalchemy.orm import relationship
|
|
from datetime import datetime
|
|
|
|
Base = declarative_base()
|
|
|
|
class ContentCalendarTemplate(Base):
|
|
"""Template for industry-specific content calendars."""
|
|
|
|
__tablename__ = "content_calendar_templates"
|
|
|
|
id = Column(Integer, primary_key=True)
|
|
industry = Column(String(100), nullable=False)
|
|
business_size = Column(String(50), nullable=True) # startup, sme, enterprise
|
|
content_pillars = Column(JSON, nullable=True) # Core content themes
|
|
posting_frequency = Column(JSON, nullable=True) # Platform-specific frequency
|
|
platform_strategies = Column(JSON, nullable=True) # Platform-specific content types
|
|
optimal_timing = Column(JSON, nullable=True) # Best posting times per platform
|
|
content_mix = Column(JSON, nullable=True) # Content type distribution
|
|
seasonal_themes = Column(JSON, nullable=True) # Seasonal content opportunities
|
|
created_at = Column(DateTime, default=datetime.utcnow)
|
|
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
|
|
|
|
def __repr__(self):
|
|
return f"<ContentCalendarTemplate(id={self.id}, industry='{self.industry}')>"
|
|
|
|
def to_dict(self):
|
|
return {
|
|
'id': self.id,
|
|
'industry': self.industry,
|
|
'business_size': self.business_size,
|
|
'content_pillars': self.content_pillars,
|
|
'posting_frequency': self.posting_frequency,
|
|
'platform_strategies': self.platform_strategies,
|
|
'optimal_timing': self.optimal_timing,
|
|
'content_mix': self.content_mix,
|
|
'seasonal_themes': self.seasonal_themes,
|
|
'created_at': self.created_at.isoformat() if self.created_at else None,
|
|
'updated_at': self.updated_at.isoformat() if self.updated_at else None
|
|
}
|
|
|
|
class AICalendarRecommendation(Base):
|
|
"""AI-generated calendar recommendations and suggestions."""
|
|
|
|
__tablename__ = "ai_calendar_recommendations"
|
|
|
|
id = Column(Integer, primary_key=True)
|
|
strategy_id = Column(Integer, ForeignKey("content_strategies.id"), nullable=True)
|
|
user_id = Column(Integer, nullable=False)
|
|
recommendation_type = Column(String(50), nullable=False) # calendar_generation, content_optimization, performance_analysis
|
|
content_suggestions = Column(JSON, nullable=True) # Suggested content topics and themes
|
|
optimal_timing = Column(JSON, nullable=True) # Recommended posting times
|
|
performance_prediction = Column(JSON, nullable=True) # Predicted performance metrics
|
|
platform_recommendations = Column(JSON, nullable=True) # Platform-specific suggestions
|
|
content_repurposing = Column(JSON, nullable=True) # Repurposing opportunities
|
|
trending_topics = Column(JSON, nullable=True) # Trending topics to incorporate
|
|
competitor_insights = Column(JSON, nullable=True) # Competitor analysis insights
|
|
ai_confidence = Column(Float, nullable=True) # AI confidence score
|
|
created_at = Column(DateTime, default=datetime.utcnow)
|
|
updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
|
|
|
|
# Relationships
|
|
strategy = relationship("ContentStrategy")
|
|
|
|
def __repr__(self):
|
|
return f"<AICalendarRecommendation(id={self.id}, type='{self.recommendation_type}')>"
|
|
|
|
def to_dict(self):
|
|
return {
|
|
'id': self.id,
|
|
'strategy_id': self.strategy_id,
|
|
'user_id': self.user_id,
|
|
'recommendation_type': self.recommendation_type,
|
|
'content_suggestions': self.content_suggestions,
|
|
'optimal_timing': self.optimal_timing,
|
|
'performance_prediction': self.performance_prediction,
|
|
'platform_recommendations': self.platform_recommendations,
|
|
'content_repurposing': self.content_repurposing,
|
|
'trending_topics': self.trending_topics,
|
|
'competitor_insights': self.competitor_insights,
|
|
'ai_confidence': self.ai_confidence,
|
|
'created_at': self.created_at.isoformat() if self.created_at else None,
|
|
'updated_at': self.updated_at.isoformat() if self.updated_at else None
|
|
}
|
|
|
|
class ContentPerformanceTracking(Base):
|
|
"""Detailed content performance tracking and analytics."""
|
|
|
|
__tablename__ = "content_performance_tracking"
|
|
|
|
id = Column(Integer, primary_key=True)
|
|
event_id = Column(Integer, ForeignKey("calendar_events.id"), nullable=True)
|
|
strategy_id = Column(Integer, ForeignKey("content_strategies.id"), nullable=True)
|
|
platform = Column(String(50), nullable=False) # website, linkedin, instagram, etc.
|
|
content_type = Column(String(50), nullable=False) # blog_post, video, social_post, etc.
|
|
metrics = Column(JSON, nullable=True) # Engagement, reach, clicks, conversions, etc.
|
|
performance_score = Column(Float, nullable=True) # Overall performance score (0-100)
|
|
audience_demographics = Column(JSON, nullable=True) # Audience insights
|
|
engagement_rate = Column(Float, nullable=True) # Engagement rate percentage
|
|
reach_count = Column(Integer, nullable=True) # Total reach
|
|
click_count = Column(Integer, nullable=True) # Total clicks
|
|
conversion_count = Column(Integer, nullable=True) # Total conversions
|
|
roi = Column(Float, nullable=True) # Return on investment
|
|
recorded_at = Column(DateTime, default=datetime.utcnow)
|
|
|
|
# Relationships
|
|
event = relationship("CalendarEvent")
|
|
strategy = relationship("ContentStrategy")
|
|
|
|
def __repr__(self):
|
|
return f"<ContentPerformanceTracking(id={self.id}, platform='{self.platform}', score={self.performance_score})>"
|
|
|
|
def to_dict(self):
|
|
return {
|
|
'id': self.id,
|
|
'event_id': self.event_id,
|
|
'strategy_id': self.strategy_id,
|
|
'platform': self.platform,
|
|
'content_type': self.content_type,
|
|
'metrics': self.metrics,
|
|
'performance_score': self.performance_score,
|
|
'audience_demographics': self.audience_demographics,
|
|
'engagement_rate': self.engagement_rate,
|
|
'reach_count': self.reach_count,
|
|
'click_count': self.click_count,
|
|
'conversion_count': self.conversion_count,
|
|
'roi': self.roi,
|
|
'recorded_at': self.recorded_at.isoformat() if self.recorded_at else None
|
|
}
|
|
|
|
class ContentTrendAnalysis(Base):
|
|
"""Trend analysis and topic recommendations."""
|
|
|
|
__tablename__ = "content_trend_analysis"
|
|
|
|
id = Column(Integer, primary_key=True)
|
|
user_id = Column(Integer, nullable=False)
|
|
strategy_id = Column(Integer, ForeignKey("content_strategies.id"), nullable=True)
|
|
industry = Column(String(100), nullable=False)
|
|
trending_topics = Column(JSON, nullable=True) # Trending topics in the industry
|
|
keyword_opportunities = Column(JSON, nullable=True) # High-value keywords
|
|
content_gaps = Column(JSON, nullable=True) # Identified content gaps
|
|
seasonal_opportunities = Column(JSON, nullable=True) # Seasonal content opportunities
|
|
competitor_analysis = Column(JSON, nullable=True) # Competitor content analysis
|
|
viral_potential = Column(JSON, nullable=True) # Content with viral potential
|
|
audience_interests = Column(JSON, nullable=True) # Current audience interests
|
|
analysis_date = Column(DateTime, default=datetime.utcnow)
|
|
created_at = Column(DateTime, default=datetime.utcnow)
|
|
|
|
# Relationships
|
|
strategy = relationship("ContentStrategy")
|
|
|
|
def __repr__(self):
|
|
return f"<ContentTrendAnalysis(id={self.id}, industry='{self.industry}')>"
|
|
|
|
def to_dict(self):
|
|
return {
|
|
'id': self.id,
|
|
'user_id': self.user_id,
|
|
'strategy_id': self.strategy_id,
|
|
'industry': self.industry,
|
|
'trending_topics': self.trending_topics,
|
|
'keyword_opportunities': self.keyword_opportunities,
|
|
'content_gaps': self.content_gaps,
|
|
'seasonal_opportunities': self.seasonal_opportunities,
|
|
'competitor_analysis': self.competitor_analysis,
|
|
'viral_potential': self.viral_potential,
|
|
'audience_interests': self.audience_interests,
|
|
'analysis_date': self.analysis_date.isoformat() if self.analysis_date else None,
|
|
'created_at': self.created_at.isoformat() if self.created_at else None
|
|
}
|
|
|
|
class ContentOptimization(Base):
|
|
"""Content optimization recommendations and suggestions."""
|
|
|
|
__tablename__ = "content_optimizations"
|
|
|
|
id = Column(Integer, primary_key=True)
|
|
event_id = Column(Integer, ForeignKey("calendar_events.id"), nullable=True)
|
|
user_id = Column(Integer, nullable=False)
|
|
original_content = Column(JSON, nullable=True) # Original content details
|
|
optimized_content = Column(JSON, nullable=True) # Optimized content suggestions
|
|
platform_adaptations = Column(JSON, nullable=True) # Platform-specific adaptations
|
|
visual_recommendations = Column(JSON, nullable=True) # Visual content suggestions
|
|
hashtag_suggestions = Column(JSON, nullable=True) # Hashtag recommendations
|
|
keyword_optimization = Column(JSON, nullable=True) # SEO keyword optimization
|
|
tone_adjustments = Column(JSON, nullable=True) # Tone and style adjustments
|
|
length_optimization = Column(JSON, nullable=True) # Content length optimization
|
|
performance_prediction = Column(JSON, nullable=True) # Predicted performance
|
|
optimization_score = Column(Float, nullable=True) # Optimization effectiveness score
|
|
created_at = Column(DateTime, default=datetime.utcnow)
|
|
|
|
# Relationships
|
|
event = relationship("CalendarEvent")
|
|
|
|
def __repr__(self):
|
|
return f"<ContentOptimization(id={self.id}, score={self.optimization_score})>"
|
|
|
|
def to_dict(self):
|
|
return {
|
|
'id': self.id,
|
|
'event_id': self.event_id,
|
|
'user_id': self.user_id,
|
|
'original_content': self.original_content,
|
|
'optimized_content': self.optimized_content,
|
|
'platform_adaptations': self.platform_adaptations,
|
|
'visual_recommendations': self.visual_recommendations,
|
|
'hashtag_suggestions': self.hashtag_suggestions,
|
|
'keyword_optimization': self.keyword_optimization,
|
|
'tone_adjustments': self.tone_adjustments,
|
|
'length_optimization': self.length_optimization,
|
|
'performance_prediction': self.performance_prediction,
|
|
'optimization_score': self.optimization_score,
|
|
'created_at': self.created_at.isoformat() if self.created_at else None
|
|
}
|
|
|
|
class CalendarGenerationSession(Base):
|
|
"""AI calendar generation sessions and results."""
|
|
|
|
__tablename__ = "calendar_generation_sessions"
|
|
|
|
id = Column(Integer, primary_key=True)
|
|
user_id = Column(Integer, nullable=False)
|
|
strategy_id = Column(Integer, ForeignKey("content_strategies.id"), nullable=True)
|
|
session_type = Column(String(50), nullable=False) # monthly, weekly, custom
|
|
generation_params = Column(JSON, nullable=True) # Parameters used for generation
|
|
generated_calendar = Column(JSON, nullable=True) # Generated calendar data
|
|
ai_insights = Column(JSON, nullable=True) # AI insights and recommendations
|
|
performance_predictions = Column(JSON, nullable=True) # Performance predictions
|
|
content_themes = Column(JSON, nullable=True) # Content themes and pillars
|
|
platform_distribution = Column(JSON, nullable=True) # Platform content distribution
|
|
optimal_schedule = Column(JSON, nullable=True) # Optimal posting schedule
|
|
repurposing_opportunities = Column(JSON, nullable=True) # Content repurposing
|
|
generation_status = Column(String(20), default="processing") # processing, completed, failed
|
|
ai_confidence = Column(Float, nullable=True) # Overall AI confidence
|
|
processing_time = Column(Float, nullable=True) # Processing time in seconds
|
|
created_at = Column(DateTime, default=datetime.utcnow)
|
|
|
|
# Relationships
|
|
strategy = relationship("ContentStrategy")
|
|
|
|
def __repr__(self):
|
|
return f"<CalendarGenerationSession(id={self.id}, type='{self.session_type}', status='{self.generation_status}')>"
|
|
|
|
def to_dict(self):
|
|
return {
|
|
'id': self.id,
|
|
'user_id': self.user_id,
|
|
'strategy_id': self.strategy_id,
|
|
'session_type': self.session_type,
|
|
'generation_params': self.generation_params,
|
|
'generated_calendar': self.generated_calendar,
|
|
'ai_insights': self.ai_insights,
|
|
'performance_predictions': self.performance_predictions,
|
|
'content_themes': self.content_themes,
|
|
'platform_distribution': self.platform_distribution,
|
|
'optimal_schedule': self.optimal_schedule,
|
|
'repurposing_opportunities': self.repurposing_opportunities,
|
|
'generation_status': self.generation_status,
|
|
'ai_confidence': self.ai_confidence,
|
|
'processing_time': self.processing_time,
|
|
'created_at': self.created_at.isoformat() if self.created_at else None
|
|
} |