Base code

backend/models/component_logic.py

@@ -0,0 +1,260 @@
+"""Pydantic models for component logic requests and responses."""
+
+from typing import Dict, Any, List, Optional
+from pydantic import BaseModel, EmailStr, validator
+import re
+
+# AI Research Models
+
+class UserInfoRequest(BaseModel):
+    """Request model for user information validation."""
+    full_name: str
+    email: str
+    company: str
+    role: str
+    
+    @validator('full_name')
+    def validate_full_name(cls, v):
+        if not v or len(v.strip()) < 2:
+            raise ValueError('Full name must be at least 2 characters long')
+        return v.strip()
+    
+    @validator('email')
+    def validate_email(cls, v):
+        # Basic email validation
+        email_pattern = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
+        if not email_pattern.match(v):
+            raise ValueError('Invalid email format')
+        return v.lower()
+    
+    @validator('company')
+    def validate_company(cls, v):
+        if not v or len(v.strip()) < 1:
+            raise ValueError('Company name is required')
+        return v.strip()
+    
+    @validator('role')
+    def validate_role(cls, v):
+        valid_roles = ["Content Creator", "Marketing Manager", "Business Owner", "Other"]
+        if v not in valid_roles:
+            raise ValueError(f'Role must be one of: {", ".join(valid_roles)}')
+        return v
+
+class ResearchPreferencesRequest(BaseModel):
+    """Request model for research preferences configuration."""
+    research_depth: str
+    content_types: List[str]
+    auto_research: bool
+    factual_content: bool = True  # Default to True
+    
+    @validator('research_depth')
+    def validate_research_depth(cls, v):
+        valid_depths = ["Basic", "Standard", "Deep", "Comprehensive"]
+        if v not in valid_depths:
+            raise ValueError(f'Research depth must be one of: {", ".join(valid_depths)}')
+        return v
+    
+    @validator('content_types')
+    def validate_content_types(cls, v):
+        valid_types = ["Blog Posts", "Social Media", "Technical Articles", "News", "Academic Papers"]
+        if not v:
+            raise ValueError('At least one content type must be selected')
+        for content_type in v:
+            if content_type not in valid_types:
+                raise ValueError(f'Invalid content type: {content_type}')
+        return v
+
+class ResearchRequest(BaseModel):
+    """Request model for research processing."""
+    topic: str
+    preferences: ResearchPreferencesRequest
+    
+    @validator('topic')
+    def validate_topic(cls, v):
+        if not v or len(v.strip()) < 3:
+            raise ValueError('Topic must be at least 3 characters long')
+        return v.strip()
+
+class UserInfoResponse(BaseModel):
+    """Response model for user information validation."""
+    valid: bool
+    user_info: Optional[Dict[str, Any]] = None
+    errors: List[str] = []
+
+class ResearchPreferencesResponse(BaseModel):
+    """Response model for research preferences configuration."""
+    valid: bool
+    preferences: Optional[Dict[str, Any]] = None
+    errors: List[str] = []
+
+class ResearchResponse(BaseModel):
+    """Response model for research processing."""
+    success: bool
+    topic: str
+    results: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+# Personalization Models
+
+class ContentStyleRequest(BaseModel):
+    """Request model for content style configuration."""
+    writing_style: str
+    tone: str
+    content_length: str
+    
+    @validator('writing_style')
+    def validate_writing_style(cls, v):
+        valid_styles = ["Professional", "Casual", "Technical", "Conversational", "Academic"]
+        if v not in valid_styles:
+            raise ValueError(f'Writing style must be one of: {", ".join(valid_styles)}')
+        return v
+    
+    @validator('tone')
+    def validate_tone(cls, v):
+        valid_tones = ["Formal", "Semi-Formal", "Neutral", "Friendly", "Humorous"]
+        if v not in valid_tones:
+            raise ValueError(f'Tone must be one of: {", ".join(valid_tones)}')
+        return v
+    
+    @validator('content_length')
+    def validate_content_length(cls, v):
+        valid_lengths = ["Concise", "Standard", "Detailed", "Comprehensive"]
+        if v not in valid_lengths:
+            raise ValueError(f'Content length must be one of: {", ".join(valid_lengths)}')
+        return v
+
+class BrandVoiceRequest(BaseModel):
+    """Request model for brand voice configuration."""
+    personality_traits: List[str]
+    voice_description: Optional[str] = None
+    keywords: Optional[str] = None
+    
+    @validator('personality_traits')
+    def validate_personality_traits(cls, v):
+        valid_traits = ["Professional", "Innovative", "Friendly", "Trustworthy", "Creative", "Expert"]
+        if not v:
+            raise ValueError('At least one personality trait must be selected')
+        for trait in v:
+            if trait not in valid_traits:
+                raise ValueError(f'Invalid personality trait: {trait}')
+        return v
+    
+    @validator('voice_description')
+    def validate_voice_description(cls, v):
+        if v and len(v.strip()) < 10:
+            raise ValueError('Voice description must be at least 10 characters long')
+        return v.strip() if v else None
+
+class AdvancedSettingsRequest(BaseModel):
+    """Request model for advanced content generation settings."""
+    seo_optimization: bool
+    readability_level: str
+    content_structure: List[str]
+    
+    @validator('readability_level')
+    def validate_readability_level(cls, v):
+        valid_levels = ["Simple", "Standard", "Advanced", "Expert"]
+        if v not in valid_levels:
+            raise ValueError(f'Readability level must be one of: {", ".join(valid_levels)}')
+        return v
+    
+    @validator('content_structure')
+    def validate_content_structure(cls, v):
+        valid_structures = ["Introduction", "Key Points", "Examples", "Conclusion", "Call-to-Action"]
+        if not v:
+            raise ValueError('At least one content structure element must be selected')
+        for structure in v:
+            if structure not in valid_structures:
+                raise ValueError(f'Invalid content structure: {structure}')
+        return v
+
+class PersonalizationSettingsRequest(BaseModel):
+    """Request model for complete personalization settings."""
+    content_style: ContentStyleRequest
+    brand_voice: BrandVoiceRequest
+    advanced_settings: AdvancedSettingsRequest
+
+class ContentStyleResponse(BaseModel):
+    """Response model for content style validation."""
+    valid: bool
+    style_config: Optional[Dict[str, Any]] = None
+    errors: List[str] = []
+
+class BrandVoiceResponse(BaseModel):
+    """Response model for brand voice configuration."""
+    valid: bool
+    brand_config: Optional[Dict[str, Any]] = None
+    errors: List[str] = []
+
+class PersonalizationSettingsResponse(BaseModel):
+    """Response model for complete personalization settings."""
+    valid: bool
+    settings: Optional[Dict[str, Any]] = None
+    errors: List[str] = []
+
+# Research Utilities Models
+
+class ResearchTopicRequest(BaseModel):
+    """Request model for topic research."""
+    topic: str
+    api_keys: Dict[str, str]
+    
+    @validator('topic')
+    def validate_topic(cls, v):
+        if not v or len(v.strip()) < 3:
+            raise ValueError('Topic must be at least 3 characters long')
+        return v.strip()
+
+class ResearchResultResponse(BaseModel):
+    """Response model for research results."""
+    success: bool
+    topic: str
+    data: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None 
+
+# Style Detection Models
+class StyleAnalysisRequest(BaseModel):
+    """Request model for style analysis."""
+    content: Dict[str, Any]
+    analysis_type: str = "comprehensive"  # comprehensive, patterns, guidelines
+
+class StyleAnalysisResponse(BaseModel):
+    """Response model for style analysis."""
+    success: bool
+    analysis: Optional[Dict[str, Any]] = None
+    patterns: Optional[Dict[str, Any]] = None
+    guidelines: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    timestamp: str
+
+class WebCrawlRequest(BaseModel):
+    """Request model for web crawling."""
+    url: Optional[str] = None
+    text_sample: Optional[str] = None
+
+class WebCrawlResponse(BaseModel):
+    """Response model for web crawling."""
+    success: bool
+    content: Optional[Dict[str, Any]] = None
+    metrics: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    timestamp: str
+
+class StyleDetectionRequest(BaseModel):
+    """Request model for complete style detection workflow."""
+    url: Optional[str] = None
+    text_sample: Optional[str] = None
+    include_patterns: bool = True
+    include_guidelines: bool = True
+
+class StyleDetectionResponse(BaseModel):
+    """Response model for complete style detection workflow."""
+    success: bool
+    crawl_result: Optional[Dict[str, Any]] = None
+    style_analysis: Optional[Dict[str, Any]] = None
+    style_patterns: Optional[Dict[str, Any]] = None
+    style_guidelines: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    warning: Optional[str] = None
+    timestamp: str