feat: Implement image data processing utility and enhance post content generation logic

backend/api/posts.py

@@ -6,6 +6,7 @@ from flask import Blueprint, request, jsonify, current_app, send_file
 from flask_jwt_extended import jwt_required, get_jwt_identity
 from backend.services.content_service import ContentService
 from backend.services.linkedin_service import LinkedInService
+from backend.utils.image_utils import ensure_bytes_format
 
 posts_bp = Blueprint('posts', __name__)
 
@@ -124,10 +125,14 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
         content_service = ContentService(hugging_key=hugging_key)
         generated_result = content_service.generate_post_content(user_id)
         
-        # Handle the case where generated_result might be a tuple (content, image_data)
+        # Handle the case where generated_result might be a tuple, list, or string
         # image_data could be bytes (from base64) or a string (URL)
-        if isinstance(generated_result, tuple):
-            generated_content, image_data = generated_result
+        if isinstance(generated_result, (tuple, list)) and len(generated_result) >= 2:
+            generated_content = generated_result[0] if generated_result[0] is not None else "Generated content will appear here..."
+            image_data = generated_result[1] if generated_result[1] is not None else None
+        elif isinstance(generated_result, (tuple, list)) and len(generated_result) == 1:
+            generated_content = generated_result[0] if generated_result[0] is not None else "Generated content will appear here..."
+            image_data = None
         else:
             generated_content = generated_result
             image_data = None
@@ -447,7 +452,7 @@ def publish_post_direct():
         
         # Add optional fields if provided
         if image_data:
-            post_data['image_content_url'] = image_data
+            post_data['image_content_url'] = ensure_bytes_format(image_data)
             
         if 'scheduled_at' in data:
             post_data['scheduled_at'] = data['scheduled_at']
@@ -562,7 +567,7 @@ def create_post():
         
         # Add optional fields if provided
         if image_data is not None:
-            post_data['image_content_url'] = image_data
+            post_data['image_content_url'] = ensure_bytes_format(image_data)
             
         if 'scheduled_at' in data:
             post_data['scheduled_at'] = data['scheduled_at']

backend/models/post.py

@@ -1,42 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional, Union
-from datetime import datetime
-
-@dataclass
-class Post:
-    """Post model representing a social media post."""
-    id: str
-    social_account_id: str
-    Text_content: str
-    is_published: bool = True
-    sched: Optional[str] = None
-    image_content_url: Optional[Union[str, bytes]] = None  # Can be URL string or bytes
-    created_at: Optional[datetime] = None
-    scheduled_at: Optional[datetime] = None
-    
-    @classmethod
-    def from_dict(cls, data: dict):
-        """Create a Post instance from a dictionary."""
-        return cls(
-            id=data['id'],
-            social_account_id=data['social_account_id'],
-            Text_content=data['Text_content'],
-            is_published=data.get('is_published', False),
-            sched=data.get('sched'),
-            image_content_url=data.get('image_content_url'),
-            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')) if data.get('created_at') else None,
-            scheduled_at=datetime.fromisoformat(data['scheduled_at'].replace('Z', '+00:00')) if data.get('scheduled_at') else None
-        )
-    
-    def to_dict(self):
-        """Convert Post instance to dictionary."""
-        return {
-            'id': self.id,
-            'social_account_id': self.social_account_id,
-            'Text_content': self.Text_content,
-            'is_published': self.is_published,
-            'sched': self.sched,
-            'image_content_url': self.image_content_url,
-            'created_at': self.created_at.isoformat() if self.created_at else None,
-            'scheduled_at': self.scheduled_at.isoformat() if self.scheduled_at else None
-        }

backend/models/social_account.py

@@ -1,48 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-from datetime import datetime
-
-@dataclass
-class SocialAccount:
-    """Social account model representing a social media account."""
-    id: str
-    user_id: str
-    social_network: str
-    account_name: str
-    token: Optional[str] = None
-    sub: Optional[str] = None
-    given_name: Optional[str] = None
-    family_name: Optional[str] = None
-    picture: Optional[str] = None
-    created_at: Optional[datetime] = None
-    
-    @classmethod
-    def from_dict(cls, data: dict):
-        """Create a SocialAccount instance from a dictionary."""
-        return cls(
-            id=data['id'],
-            user_id=data['user_id'],
-            social_network=data['social_network'],
-            account_name=data['account_name'],
-            token=data.get('token'),
-            sub=data.get('sub'),
-            given_name=data.get('given_name'),
-            family_name=data.get('family_name'),
-            picture=data.get('picture'),
-            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')) if data.get('created_at') else None
-        )
-    
-    def to_dict(self):
-        """Convert SocialAccount instance to dictionary."""
-        return {
-            'id': self.id,
-            'user_id': self.user_id,
-            'social_network': self.social_network,
-            'account_name': self.account_name,
-            'token': self.token,
-            'sub': self.sub,
-            'given_name': self.given_name,
-            'family_name': self.family_name,
-            'picture': self.picture,
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }

backend/models/source.py

@@ -1,36 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-from datetime import datetime
-
-@dataclass
-class Source:
-    """Source model representing an RSS source."""
-    id: str
-    user_id: str
-    source: str
-    category: Optional[str] = None
-    last_update: Optional[datetime] = None
-    created_at: Optional[datetime] = None
-    
-    @classmethod
-    def from_dict(cls, data: dict):
-        """Create a Source instance from a dictionary."""
-        return cls(
-            id=data['id'],
-            user_id=data['user_id'],
-            source=data['source'],
-            category=data.get('category'),
-            last_update=datetime.fromisoformat(data['last_update'].replace('Z', '+00:00')) if data.get('last_update') else None,
-            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')) if data.get('created_at') else None
-        )
-    
-    def to_dict(self):
-        """Convert Source instance to dictionary."""
-        return {
-            'id': self.id,
-            'user_id': self.user_id,
-            'source': self.source,
-            'category': self.category,
-            'last_update': self.last_update.isoformat() if self.last_update else None,
-            'created_at': self.created_at.isoformat() if self.created_at else None
-        }

backend/scheduler/apscheduler_service.py

@@ -9,6 +9,7 @@ from apscheduler.executors.pool import ThreadPoolExecutor
 from backend.services.content_service import ContentService
 from backend.services.linkedin_service import LinkedInService
 from backend.utils.database import init_supabase
+from backend.utils.image_utils import ensure_bytes_format
 from backend.config import Config
 from backend.utils.timezone_utils import (
     parse_timezone_schedule,
@@ -247,7 +248,40 @@ class APSchedulerService:
                 content_service = ContentService()
                 
                 # Generate content using content service
-                generated_content = content_service.generate_post_content(user_id)
+                generated_result = content_service.generate_post_content(user_id)
+                
+                # Ensure proper extraction of text content and image data from tuple
+                # ContentService.generate_post_content() always returns a tuple: (text_content, image_data)
+                if isinstance(generated_result, (tuple, list)) and len(generated_result) >= 1:
+                    # Extract text content (first element) and ensure it's a string
+                    text_content = generated_result[0] if generated_result[0] is not None else "Generated content will appear here..."
+                    # Extract image data (second element) if it exists
+                    image_data = generated_result[1] if len(generated_result) >= 2 and generated_result[1] is not None else None
+                    
+                    # Additional safeguard: ensure text_content is always a string, never a list/tuple
+                    if not isinstance(text_content, str):
+                        text_content = str(text_content) if text_content is not None else "Generated content will appear here..."
+                else:
+                    # Fallback for unexpected return types
+                    text_content = str(generated_result) if generated_result is not None else "Generated content will appear here..."
+                    image_data = None
+                    
+                # Final validation to ensure text_content is never stored as a list/tuple
+                if isinstance(text_content, (list, tuple)):
+                    # Convert list/tuple to string representation
+                    text_content = str(text_content)
+                
+                # Process image data for proper storage
+                processed_image_data = None
+                if image_data is not None:
+                    try:
+                        # Use the shared utility function to ensure proper bytes format
+                        processed_image_data = ensure_bytes_format(image_data)
+                        logger.info(f"✅ Image data processed for schedule {schedule_id}")
+                    except Exception as e:
+                        logger.error(f"❌ Error processing image data for schedule {schedule_id}: {str(e)}")
+                        # Continue with text content even if image processing fails
+                        processed_image_data = None
                 
                 # Store generated content in database
                 # We need to get the social account ID from the schedule
@@ -264,16 +298,23 @@ class APSchedulerService:
                     
                 social_account_id = schedule_response.data[0]['id_social']
                 
+                # Prepare post data
+                post_data = {
+                    "id_social": social_account_id,
+                    "Text_content": text_content,
+                    "is_published": False,
+                    "sched": schedule_id
+                }
+                
+                # Add processed image data if present
+                if processed_image_data is not None:
+                    post_data["image_content_url"] = processed_image_data
+                
                 # Store the generated content
                 response = (
                     self.supabase_client
                     .table("Post_content")
-                    .insert({
-                        "id_social": social_account_id,
-                        "Text_content": generated_content,
-                        "is_published": False,
-                        "sched": schedule_id
-                    })
+                    .insert(post_data)
                     .execute()
                 )
                 

backend/utils/image_utils.py

@@ -0,0 +1,39 @@
+"""Utility functions for image handling and processing."""
+
+import base64
+
+
+def ensure_bytes_format(image_data):
+    """
+    Ensure image data is in the proper format for storage.
+    
+    Args:
+        image_data: Image data that could be bytes, base64 string, or URL string
+        
+    Returns:
+        Properly formatted data for database storage
+    """
+    if image_data is None:
+        return None
+        
+    # If it's already bytes, return as is
+    if isinstance(image_data, bytes):
+        return image_data
+        
+    # If it's a string, check if it's base64 encoded
+    if isinstance(image_data, str):
+        # Check if it's a data URL
+        if image_data.startswith('data:image/'):
+            try:
+                # Extract base64 part and decode to bytes
+                base64_part = image_data.split(',')[1]
+                return base64.b64decode(base64_part)
+            except Exception:
+                # If decoding fails, store as string (URL)
+                return image_data
+        else:
+            # Assume it's a URL, store as string
+            return image_data
+            
+    # For any other type, return as is
+    return image_data