359 lines
12 KiB
Python
359 lines
12 KiB
Python
from rest_framework import serializers
|
|
from django.db import models
|
|
from django.core.exceptions import ObjectDoesNotExist
|
|
from .models import Tasks, Images, Content
|
|
from igny8_core.business.planning.models import Clusters, ContentIdeas
|
|
from igny8_core.business.content.models import (
|
|
ContentClusterMap,
|
|
ContentTaxonomyMap,
|
|
ContentAttributeMap,
|
|
)
|
|
|
|
|
|
class TasksSerializer(serializers.ModelSerializer):
|
|
"""Serializer for Tasks model"""
|
|
cluster_name = serializers.SerializerMethodField()
|
|
sector_name = serializers.SerializerMethodField()
|
|
idea_title = serializers.SerializerMethodField()
|
|
site_id = serializers.IntegerField(write_only=True, required=False)
|
|
sector_id = serializers.IntegerField(write_only=True, required=False)
|
|
content_html = serializers.SerializerMethodField()
|
|
content_primary_keyword = serializers.SerializerMethodField()
|
|
content_secondary_keywords = serializers.SerializerMethodField()
|
|
content_tags = serializers.SerializerMethodField()
|
|
content_categories = serializers.SerializerMethodField()
|
|
cluster_mappings = serializers.SerializerMethodField()
|
|
taxonomy_mappings = serializers.SerializerMethodField()
|
|
attribute_mappings = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = Tasks
|
|
fields = [
|
|
'id',
|
|
'title',
|
|
'description',
|
|
'keywords',
|
|
'cluster_id',
|
|
'cluster_name',
|
|
'sector_name',
|
|
'idea_id',
|
|
'idea_title',
|
|
'content_structure',
|
|
'content_type',
|
|
'status',
|
|
'content',
|
|
'word_count',
|
|
'meta_title',
|
|
'meta_description',
|
|
'content_html',
|
|
'content_primary_keyword',
|
|
'content_secondary_keywords',
|
|
'content_tags',
|
|
'content_categories',
|
|
'cluster_mappings',
|
|
'taxonomy_mappings',
|
|
'attribute_mappings',
|
|
'assigned_post_id',
|
|
'post_url',
|
|
'created_at',
|
|
'updated_at',
|
|
'site_id',
|
|
'sector_id',
|
|
'account_id',
|
|
]
|
|
read_only_fields = ['id', 'created_at', 'updated_at', 'account_id']
|
|
|
|
def get_cluster_name(self, obj):
|
|
"""Get cluster name from Clusters model"""
|
|
if obj.cluster_id:
|
|
try:
|
|
cluster = Clusters.objects.get(id=obj.cluster_id)
|
|
return cluster.name
|
|
except Clusters.DoesNotExist:
|
|
return None
|
|
return None
|
|
|
|
def get_sector_name(self, obj):
|
|
"""Get sector name from Sector model"""
|
|
if obj.sector_id:
|
|
try:
|
|
from igny8_core.auth.models import Sector
|
|
sector = Sector.objects.get(id=obj.sector_id)
|
|
return sector.name
|
|
except Sector.DoesNotExist:
|
|
return None
|
|
return None
|
|
|
|
def get_idea_title(self, obj):
|
|
"""Get idea title from ContentIdeas model"""
|
|
if obj.idea_id:
|
|
try:
|
|
idea = ContentIdeas.objects.get(id=obj.idea_id)
|
|
return idea.idea_title
|
|
except ContentIdeas.DoesNotExist:
|
|
return None
|
|
return None
|
|
|
|
def _get_content_record(self, obj):
|
|
try:
|
|
return obj.content_record
|
|
except (AttributeError, ObjectDoesNotExist):
|
|
return None
|
|
|
|
def get_content_html(self, obj):
|
|
record = self._get_content_record(obj)
|
|
return record.html_content if record else None
|
|
|
|
def get_content_primary_keyword(self, obj):
|
|
record = self._get_content_record(obj)
|
|
return record.primary_keyword if record else None
|
|
|
|
def get_content_secondary_keywords(self, obj):
|
|
record = self._get_content_record(obj)
|
|
return record.secondary_keywords if record else []
|
|
|
|
def get_content_tags(self, obj):
|
|
record = self._get_content_record(obj)
|
|
return record.tags if record else []
|
|
|
|
def get_content_categories(self, obj):
|
|
record = self._get_content_record(obj)
|
|
return record.categories if record else []
|
|
|
|
def _cluster_map_qs(self, obj):
|
|
return ContentClusterMap.objects.filter(task=obj).select_related('cluster')
|
|
|
|
def _taxonomy_map_qs(self, obj):
|
|
return ContentTaxonomyMap.objects.filter(task=obj).select_related('taxonomy')
|
|
|
|
def _attribute_map_qs(self, obj):
|
|
return ContentAttributeMap.objects.filter(task=obj)
|
|
|
|
def get_cluster_mappings(self, obj):
|
|
mappings = []
|
|
for mapping in self._cluster_map_qs(obj):
|
|
mappings.append({
|
|
'cluster_id': mapping.cluster_id,
|
|
'cluster_name': mapping.cluster.name if mapping.cluster else None,
|
|
'role': mapping.role,
|
|
'source': mapping.source,
|
|
})
|
|
return mappings
|
|
|
|
def get_taxonomy_mappings(self, obj):
|
|
mappings = []
|
|
for mapping in self._taxonomy_map_qs(obj):
|
|
taxonomy = mapping.taxonomy
|
|
mappings.append({
|
|
'taxonomy_id': taxonomy.id if taxonomy else None,
|
|
'taxonomy_name': taxonomy.name if taxonomy else None,
|
|
'taxonomy_type': taxonomy.taxonomy_type if taxonomy else None,
|
|
'source': mapping.source,
|
|
})
|
|
return mappings
|
|
|
|
def get_attribute_mappings(self, obj):
|
|
mappings = []
|
|
for mapping in self._attribute_map_qs(obj):
|
|
mappings.append({
|
|
'name': mapping.name,
|
|
'value': mapping.value,
|
|
'source': mapping.source,
|
|
})
|
|
return mappings
|
|
|
|
|
|
class ImagesSerializer(serializers.ModelSerializer):
|
|
"""Serializer for Images model"""
|
|
task_title = serializers.SerializerMethodField()
|
|
content_title = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = Images
|
|
fields = [
|
|
'id',
|
|
'task_id',
|
|
'task_title',
|
|
'content_id',
|
|
'content_title',
|
|
'image_type',
|
|
'image_url',
|
|
'image_path',
|
|
'prompt',
|
|
'status',
|
|
'position',
|
|
'created_at',
|
|
'updated_at',
|
|
'account_id',
|
|
]
|
|
read_only_fields = ['id', 'created_at', 'updated_at', 'account_id']
|
|
|
|
def get_task_title(self, obj):
|
|
"""Get task title"""
|
|
if obj.task_id:
|
|
try:
|
|
task = Tasks.objects.get(id=obj.task_id)
|
|
return task.title
|
|
except Tasks.DoesNotExist:
|
|
return None
|
|
return None
|
|
|
|
def get_content_title(self, obj):
|
|
"""Get content title"""
|
|
if obj.content:
|
|
return obj.content.title or obj.content.meta_title
|
|
return None
|
|
|
|
|
|
class ContentImageSerializer(serializers.ModelSerializer):
|
|
"""Serializer for individual image in grouped content images"""
|
|
image_url = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = Images
|
|
fields = [
|
|
'id',
|
|
'image_type',
|
|
'image_url',
|
|
'image_path',
|
|
'prompt',
|
|
'status',
|
|
'position',
|
|
'created_at',
|
|
'updated_at',
|
|
]
|
|
|
|
def get_image_url(self, obj):
|
|
"""
|
|
Return original image_url from database (Runware/OpenAI URL).
|
|
No transformation - returns the exact value stored in image_url field.
|
|
"""
|
|
return obj.image_url
|
|
|
|
|
|
class ContentImagesGroupSerializer(serializers.Serializer):
|
|
"""Serializer for grouped content images - one row per content"""
|
|
content_id = serializers.IntegerField()
|
|
content_title = serializers.CharField()
|
|
featured_image = ContentImageSerializer(allow_null=True)
|
|
in_article_images = ContentImageSerializer(many=True)
|
|
overall_status = serializers.CharField() # 'pending', 'partial', 'complete', 'failed'
|
|
|
|
|
|
class ContentSerializer(serializers.ModelSerializer):
|
|
"""Serializer for Content model"""
|
|
task_title = serializers.SerializerMethodField()
|
|
sector_name = serializers.SerializerMethodField()
|
|
has_image_prompts = serializers.SerializerMethodField()
|
|
has_generated_images = serializers.SerializerMethodField()
|
|
cluster_mappings = serializers.SerializerMethodField()
|
|
taxonomy_mappings = serializers.SerializerMethodField()
|
|
attribute_mappings = serializers.SerializerMethodField()
|
|
|
|
class Meta:
|
|
model = Content
|
|
fields = [
|
|
'id',
|
|
'task_id',
|
|
'task_title',
|
|
'sector_name',
|
|
'html_content',
|
|
'word_count',
|
|
'metadata',
|
|
'title',
|
|
'meta_title',
|
|
'meta_description',
|
|
'primary_keyword',
|
|
'secondary_keywords',
|
|
'tags',
|
|
'categories',
|
|
'status',
|
|
'generated_at',
|
|
'updated_at',
|
|
'account_id',
|
|
'has_image_prompts',
|
|
'has_generated_images',
|
|
# Phase 8: Universal Content Types
|
|
'entity_type',
|
|
'json_blocks',
|
|
'structure_data',
|
|
'cluster_mappings',
|
|
'taxonomy_mappings',
|
|
'attribute_mappings',
|
|
]
|
|
read_only_fields = ['id', 'generated_at', 'updated_at', 'account_id']
|
|
|
|
def get_task_title(self, obj):
|
|
"""Get task title"""
|
|
if obj.task_id:
|
|
try:
|
|
task = Tasks.objects.get(id=obj.task_id)
|
|
return task.title
|
|
except Tasks.DoesNotExist:
|
|
return None
|
|
return None
|
|
|
|
def get_sector_name(self, obj):
|
|
"""Get sector name from Sector model"""
|
|
if obj.sector_id:
|
|
try:
|
|
from igny8_core.auth.models import Sector
|
|
sector = Sector.objects.get(id=obj.sector_id)
|
|
return sector.name
|
|
except Sector.DoesNotExist:
|
|
return None
|
|
return None
|
|
|
|
def get_has_image_prompts(self, obj):
|
|
"""Check if content has any image prompts generated"""
|
|
# Check if any images exist with prompts for this content
|
|
return Images.objects.filter(
|
|
models.Q(content=obj) | models.Q(task=obj.task)
|
|
).exclude(prompt__isnull=True).exclude(prompt='').exists()
|
|
|
|
def get_has_generated_images(self, obj):
|
|
"""Check if content has any generated images (status='generated' and has URL)"""
|
|
# Check if any images are generated (have status='generated' and image_url)
|
|
return Images.objects.filter(
|
|
models.Q(content=obj) | models.Q(task=obj.task),
|
|
status='generated',
|
|
image_url__isnull=False
|
|
).exclude(image_url='').exists()
|
|
|
|
def get_cluster_mappings(self, obj):
|
|
mappings = ContentClusterMap.objects.filter(content=obj).select_related('cluster')
|
|
results = []
|
|
for mapping in mappings:
|
|
results.append({
|
|
'cluster_id': mapping.cluster_id,
|
|
'cluster_name': mapping.cluster.name if mapping.cluster else None,
|
|
'role': mapping.role,
|
|
'source': mapping.source,
|
|
})
|
|
return results
|
|
|
|
def get_taxonomy_mappings(self, obj):
|
|
mappings = ContentTaxonomyMap.objects.filter(content=obj).select_related('taxonomy')
|
|
results = []
|
|
for mapping in mappings:
|
|
taxonomy = mapping.taxonomy
|
|
results.append({
|
|
'taxonomy_id': taxonomy.id if taxonomy else None,
|
|
'taxonomy_name': taxonomy.name if taxonomy else None,
|
|
'taxonomy_type': taxonomy.taxonomy_type if taxonomy else None,
|
|
'source': mapping.source,
|
|
})
|
|
return results
|
|
|
|
def get_attribute_mappings(self, obj):
|
|
mappings = ContentAttributeMap.objects.filter(content=obj)
|
|
results = []
|
|
for mapping in mappings:
|
|
results.append({
|
|
'name': mapping.name,
|
|
'value': mapping.value,
|
|
'source': mapping.source,
|
|
})
|
|
return results
|
|
|