feat: initial commit of AI Comic Generator

backend/app/cruds/crud_config.py

@@ -0,0 +1,35 @@
+from sqlmodel import Session, select
+from app.models.models import ModelConfig
+from app.schemas.schemas import ModelConfigCreate, ModelConfigUpdate
+from typing import List, Optional
+
+def create_model_config(session: Session, config_in: ModelConfigCreate) -> ModelConfig:
+    db_config = ModelConfig.model_validate(config_in)
+    session.add(db_config)
+    session.commit()
+    session.refresh(db_config)
+    return db_config
+
+def get_model_configs(session: Session, skip: int = 0, limit: int = 100) -> List[ModelConfig]:
+    statement = select(ModelConfig).offset(skip).limit(limit)
+    return session.exec(statement).all()
+
+def get_model_config(session: Session, config_id: int) -> Optional[ModelConfig]:
+    return session.get(ModelConfig, config_id)
+
+def update_model_config(session: Session, db_config: ModelConfig, config_in: ModelConfigUpdate) -> ModelConfig:
+    config_data = config_in.model_dump(exclude_unset=True)
+    for key, value in config_data.items():
+        setattr(db_config, key, value)
+    session.add(db_config)
+    session.commit()
+    session.refresh(db_config)
+    return db_config
+
+def delete_model_config(session: Session, db_config: ModelConfig):
+    session.delete(db_config)
+    session.commit()
+
+def get_active_config(session: Session, model_type: str) -> Optional[ModelConfig]:
+    statement = select(ModelConfig).where(ModelConfig.model_type == model_type, ModelConfig.is_active == True)
+    return session.exec(statement).first()

backend/app/cruds/crud_project.py

@@ -0,0 +1,99 @@
+from sqlmodel import Session, select
+from app.models.models import Project, Character, StoryboardItem, GlobalConfig
+from app.schemas.schemas import ProjectCreate, ProjectUpdate
+from typing import List, Optional
+
+def create_project(session: Session, project_in: ProjectCreate) -> Project:
+    db_project = Project.model_validate(project_in)
+    session.add(db_project)
+    session.commit()
+    session.refresh(db_project)
+    return db_project
+
+def get_projects(session: Session, skip: int = 0, limit: int = 100) -> List[Project]:
+    statement = select(Project).offset(skip).limit(limit).order_by(Project.updated_at.desc())
+    return session.exec(statement).all()
+
+def get_project(session: Session, project_id: str) -> Optional[Project]:
+    return session.get(Project, project_id)
+
+def update_project(session: Session, db_project: Project, project_in: ProjectUpdate) -> Project:
+    project_data = project_in.model_dump(exclude_unset=True)
+    for key, value in project_data.items():
+        setattr(db_project, key, value)
+    session.add(db_project)
+    session.commit()
+    session.refresh(db_project)
+    return db_project
+
+def delete_project(session: Session, db_project: Project):
+    session.delete(db_project)
+    session.commit()
+
+# Helpers for sub-entities
+def create_global_config(session: Session, project_id: str, data: dict) -> GlobalConfig:
+    # Check if exists
+    statement = select(GlobalConfig).where(GlobalConfig.project_id == project_id)
+    existing = session.exec(statement).first()
+    if existing:
+        existing.data = data
+        session.add(existing)
+        session.commit()
+        session.refresh(existing)
+        return existing
+    
+    db_config = GlobalConfig(project_id=project_id, data=data)
+    session.add(db_config)
+    session.commit()
+    session.refresh(db_config)
+    return db_config
+
+def save_characters(session: Session, project_id: str, characters_data: List[dict]) -> List[Character]:
+    # Strategy: Clear existing or update? 
+    # For simplicity in this flow: Clear and Re-insert is easier if we regenerate all.
+    # But user might want to edit specific ones.
+    # Better: Update by name match, create if new.
+    
+    results = []
+    for char_data in characters_data:
+        name = char_data.get("name")
+        if not name: continue
+        
+        statement = select(Character).where(Character.project_id == project_id, Character.name == name)
+        existing = session.exec(statement).first()
+        
+        if existing:
+            existing.data = char_data
+            session.add(existing)
+            results.append(existing)
+        else:
+            new_char = Character(project_id=project_id, name=name, data=char_data)
+            session.add(new_char)
+            results.append(new_char)
+            
+    session.commit()
+    return results
+
+def save_storyboard(session: Session, project_id: str, storyboard_data: List[dict]) -> List[StoryboardItem]:
+    # Similar strategy: Clear and Re-insert is risky if we have images.
+    # But storyboard is sequential.
+    # Let's delete all and re-insert for now as "Regenerate JSON" usually means fresh start.
+    # IF the user is just editing JSON text, we replace everything.
+    
+    # Check if there are existing items with images we want to preserve?
+    # Ideally, we should try to map them back, but it's hard if sequence changes.
+    # For now: delete all items for this project and insert new.
+    
+    statement = select(StoryboardItem).where(StoryboardItem.project_id == project_id)
+    existing_items = session.exec(statement).all()
+    for item in existing_items:
+        session.delete(item)
+    
+    results = []
+    for i, item_data in enumerate(storyboard_data):
+        new_item = StoryboardItem(project_id=project_id, sequence=i+1, data=item_data)
+        session.add(new_item)
+        results.append(new_item)
+        
+    session.commit()
+    return results