比较提交

...

9 提交

共有 30 个文件被更改,包括 1753 次插入 和 9 次删除

查看文件

@ -29,6 +29,7 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("GET", "profiles", "backend.routes.profile_routes.list_profiles", "read"), RouteSpec("GET", "profiles", "backend.routes.profile_routes.list_profiles", "read"),
RouteSpec("POST", "profiles", "backend.routes.profile_routes.create_profile", "write"), RouteSpec("POST", "profiles", "backend.routes.profile_routes.create_profile", "write"),
RouteSpec("POST", "profiles/quick-draft", "backend.routes.profile_routes.create_quick_profile_draft", "read"), RouteSpec("POST", "profiles/quick-draft", "backend.routes.profile_routes.create_quick_profile_draft", "read"),
RouteSpec("POST", "profiles/quick-draft/save", "backend.routes.profile_routes.save_quick_profile_draft", "write"),
RouteSpec("GET", "profiles/{profile_id}", "backend.routes.profile_routes.get_profile", "read"), RouteSpec("GET", "profiles/{profile_id}", "backend.routes.profile_routes.get_profile", "read"),
RouteSpec("PUT", "profiles/{profile_id}", "backend.routes.profile_routes.update_profile", "write"), RouteSpec("PUT", "profiles/{profile_id}", "backend.routes.profile_routes.update_profile", "write"),
RouteSpec("DELETE", "profiles/{profile_id}", "backend.routes.profile_routes.delete_profile", "write"), RouteSpec("DELETE", "profiles/{profile_id}", "backend.routes.profile_routes.delete_profile", "write"),
@ -40,6 +41,7 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("POST", "workflows/{workflow_id}/start", "backend.routes.workflow_routes.start_workflow", "write"), RouteSpec("POST", "workflows/{workflow_id}/start", "backend.routes.workflow_routes.start_workflow", "write"),
RouteSpec("POST", "workflows/{workflow_id}/cancel", "backend.routes.workflow_routes.cancel_workflow", "write"), RouteSpec("POST", "workflows/{workflow_id}/cancel", "backend.routes.workflow_routes.cancel_workflow", "write"),
RouteSpec("POST", "workflows/{workflow_id}/archive", "backend.routes.workflow_routes.archive_workflow", "write"), RouteSpec("POST", "workflows/{workflow_id}/archive", "backend.routes.workflow_routes.archive_workflow", "write"),
RouteSpec("POST", "workflows/{workflow_id}/execute-character", "backend.routes.workflow_routes.execute_character_workflow", "write"),
RouteSpec("GET", "workflows/{workflow_id}/nodes", "backend.routes.node_routes.list_workflow_nodes", "read"), RouteSpec("GET", "workflows/{workflow_id}/nodes", "backend.routes.node_routes.list_workflow_nodes", "read"),
RouteSpec("POST", "workflows/{workflow_id}/nodes", "backend.routes.node_routes.create_workflow_node", "write"), RouteSpec("POST", "workflows/{workflow_id}/nodes", "backend.routes.node_routes.create_workflow_node", "write"),
RouteSpec("GET", "workflows/{workflow_id}/branches", "backend.routes.branch_routes.list_workflow_branches", "read"), RouteSpec("GET", "workflows/{workflow_id}/branches", "backend.routes.branch_routes.list_workflow_branches", "read"),
@ -47,6 +49,7 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("POST", "workflows/{workflow_id}/switch-branch", "backend.routes.branch_routes.switch_workflow_branch", "write"), RouteSpec("POST", "workflows/{workflow_id}/switch-branch", "backend.routes.branch_routes.switch_workflow_branch", "write"),
RouteSpec("GET", "workflows/{workflow_id}/history", "backend.routes.history_routes.list_workflow_history", "read"), RouteSpec("GET", "workflows/{workflow_id}/history", "backend.routes.history_routes.list_workflow_history", "read"),
RouteSpec("GET", "nodes/{node_id}", "backend.routes.node_routes.get_node", "read"), RouteSpec("GET", "nodes/{node_id}", "backend.routes.node_routes.get_node", "read"),
RouteSpec("GET", "nodes/{node_id}/dependency-context", "backend.routes.node_routes.get_node_dependency_context", "read"),
RouteSpec("PUT", "nodes/{node_id}", "backend.routes.node_routes.update_node", "write"), RouteSpec("PUT", "nodes/{node_id}", "backend.routes.node_routes.update_node", "write"),
RouteSpec("POST", "nodes/{node_id}/generate", "backend.routes.node_routes.generate_node", "write"), RouteSpec("POST", "nodes/{node_id}/generate", "backend.routes.node_routes.generate_node", "write"),
RouteSpec("POST", "nodes/{node_id}/retry", "backend.routes.node_routes.retry_node", "write"), RouteSpec("POST", "nodes/{node_id}/retry", "backend.routes.node_routes.retry_node", "write"),
@ -57,6 +60,7 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("GET", "review/policy", "backend.routes.review_routes.get_review_policy", "read"), RouteSpec("GET", "review/policy", "backend.routes.review_routes.get_review_policy", "read"),
RouteSpec("POST", "review/policy/validate", "backend.routes.review_routes.validate_review_policy", "config"), RouteSpec("POST", "review/policy/validate", "backend.routes.review_routes.validate_review_policy", "config"),
RouteSpec("POST", "review/policy/save", "backend.routes.review_routes.save_review_policy", "config"), RouteSpec("POST", "review/policy/save", "backend.routes.review_routes.save_review_policy", "config"),
RouteSpec("POST", "prompts/expand", "backend.routes.prompt_routes.expand_prompt", "read"),
RouteSpec("GET", "nodes/{node_id}/review", "backend.routes.review_routes.review_node", "read"), RouteSpec("GET", "nodes/{node_id}/review", "backend.routes.review_routes.review_node", "read"),
RouteSpec("GET", "nodes/{node_id}/images", "backend.routes.image_routes.list_node_images", "read"), RouteSpec("GET", "nodes/{node_id}/images", "backend.routes.image_routes.list_node_images", "read"),
RouteSpec("GET", "workflows/{workflow_id}/review", "backend.routes.review_routes.review_workflow", "read"), RouteSpec("GET", "workflows/{workflow_id}/review", "backend.routes.review_routes.review_workflow", "read"),
@ -64,6 +68,7 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("POST", "images/{image_id}/select", "backend.routes.image_routes.select_image", "write"), RouteSpec("POST", "images/{image_id}/select", "backend.routes.image_routes.select_image", "write"),
RouteSpec("POST", "images/{image_id}/unselect", "backend.routes.image_routes.unselect_image", "write"), RouteSpec("POST", "images/{image_id}/unselect", "backend.routes.image_routes.unselect_image", "write"),
RouteSpec("POST", "images/{image_id}/archive", "backend.routes.image_routes.archive_image", "write"), RouteSpec("POST", "images/{image_id}/archive", "backend.routes.image_routes.archive_image", "write"),
RouteSpec("POST", "images/{image_id}/safe-delete", "backend.routes.image_routes.safe_delete_image", "write"),
RouteSpec("DELETE", "images/{image_id}", "backend.routes.image_routes.delete_image", "write"), RouteSpec("DELETE", "images/{image_id}", "backend.routes.image_routes.delete_image", "write"),
RouteSpec("GET", "jobs", "backend.routes.job_routes.list_jobs", "read"), RouteSpec("GET", "jobs", "backend.routes.job_routes.list_jobs", "read"),
RouteSpec("GET", "jobs/{task_id}", "backend.routes.job_routes.get_job", "read"), RouteSpec("GET", "jobs/{task_id}", "backend.routes.job_routes.get_job", "read"),
@ -87,6 +92,8 @@ ROUTES: tuple[RouteSpec, ...] = (
RouteSpec("GET", "storage/status", "backend.routes.storage_routes.get_storage_status", "read"), RouteSpec("GET", "storage/status", "backend.routes.storage_routes.get_storage_status", "read"),
RouteSpec("POST", "storage/migrate", "backend.routes.storage_routes.migrate_storage", "config"), RouteSpec("POST", "storage/migrate", "backend.routes.storage_routes.migrate_storage", "config"),
RouteSpec("GET", "media/sign", "backend.routes.media_routes.sign_media", "read"), RouteSpec("GET", "media/sign", "backend.routes.media_routes.sign_media", "read"),
RouteSpec("GET", "media/index", "backend.routes.media_routes.index_media", "read"),
RouteSpec("GET", "media/orphans", "backend.routes.media_routes.scan_orphan_media", "read"),
RouteSpec("GET", "media/fetch", "backend.routes.media_routes.fetch_media", "public_token"), RouteSpec("GET", "media/fetch", "backend.routes.media_routes.fetch_media", "public_token"),
RouteSpec("GET", "material-categories", "backend.routes.material_routes.list_material_categories", "read"), RouteSpec("GET", "material-categories", "backend.routes.material_routes.list_material_categories", "read"),
RouteSpec("POST", "material-categories", "backend.routes.material_routes.create_material_category", "materials"), RouteSpec("POST", "material-categories", "backend.routes.material_routes.create_material_category", "materials"),

查看文件

@ -7,6 +7,7 @@ from typing import Any
from backend.dto.common import ApiError from backend.dto.common import ApiError
from backend.dto.image_dto import GenerationImage from backend.dto.image_dto import GenerationImage
from backend.routes.common import handle_request from backend.routes.common import handle_request
from backend.services.deletion_safety_service import DeletionSafetyService
from backend.services.image_service import ImageService from backend.services.image_service import ImageService
from backend.services.media_service import MediaService from backend.services.media_service import MediaService
from core.audit_service import AuditService from core.audit_service import AuditService
@ -116,6 +117,31 @@ def delete_image(
return handle_request(ctx, action) return handle_request(ctx, action)
def safe_delete_image(
ctx: RequestContext,
image_id: str,
payload: dict[str, Any] | None = None,
service: DeletionSafetyService | None = None,
image_service: ImageService | None = None,
media_service: MediaService | None = None,
) -> dict:
params = payload or {}
resolved_image_service = image_service or _create_image_service()
resolved_media_service = media_service or MediaService()
deletion_service = service or DeletionSafetyService(resolved_image_service, resolved_media_service)
def action() -> dict[str, Any]:
require_write(ctx)
return deletion_service.delete_image(
image_id,
ctx,
dry_run=_as_bool(params.get("dry_run", True)),
delete_files=_as_bool(params.get("delete_files")),
)
return handle_request(ctx, action)
def _create_image_service() -> ImageService: def _create_image_service() -> ImageService:
database = Database(load_database_settings()) database = Database(load_database_settings())
return ImageService( return ImageService(

查看文件

@ -6,9 +6,12 @@ from typing import Any
from backend.dto.common import ApiError, ErrorCode from backend.dto.common import ApiError, ErrorCode
from backend.routes.common import handle_request from backend.routes.common import handle_request
from backend.services.media_index_service import MediaIndexService
from backend.services.media_service import MediaService from backend.services.media_service import MediaService
from backend.services.orphan_media_service import OrphanMediaService
from core.identity import RequestContext from core.identity import RequestContext
from core.security import require_authenticated from core.security import require_authenticated
from database.db_helper import Database, load_database_settings
def sign_media( def sign_media(
@ -42,3 +45,56 @@ def fetch_media(
return media_service.fetch_media(token) return media_service.fetch_media(token)
return handle_request(ctx, action) return handle_request(ctx, action)
def index_media(
ctx: RequestContext,
query: dict[str, Any] | None = None,
service: MediaIndexService | None = None,
) -> dict:
params = query or {}
index_service = service or MediaIndexService(MediaService())
def action() -> dict[str, Any]:
require_authenticated(ctx)
return index_service.index_files(
root=_optional_str(params.get("root")),
limit=_int_or_default(params.get("limit"), 500),
)
return handle_request(ctx, action)
def scan_orphan_media(
ctx: RequestContext,
query: dict[str, Any] | None = None,
service: OrphanMediaService | None = None,
) -> dict:
params = query or {}
orphan_service = service or OrphanMediaService(
Database(load_database_settings()),
MediaIndexService(MediaService()),
)
def action() -> dict[str, Any]:
require_authenticated(ctx)
return orphan_service.scan(
root=_optional_str(params.get("root")),
limit=_int_or_default(params.get("limit"), 500),
)
return handle_request(ctx, action)
def _optional_str(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _int_or_default(value: Any, default: int) -> int:
try:
return int(value)
except (TypeError, ValueError):
return default

查看文件

@ -12,6 +12,7 @@ from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService from backend.services.image_service import ImageService
from backend.services.model_provider_runtime import ModelProviderRuntime from backend.services.model_provider_runtime import ModelProviderRuntime
from backend.services.model_provider_service import ModelProviderService from backend.services.model_provider_service import ModelProviderService
from backend.services.node_dependency_context_service import NodeDependencyContextService
from backend.services.queue_service import QueueService from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService from core.audit_service import AuditService
@ -68,6 +69,28 @@ def get_node(
return handle_request(ctx, action) return handle_request(ctx, action)
def get_node_dependency_context(
ctx: RequestContext,
node_id: str,
query: dict[str, Any] | None = None,
service: NodeDependencyContextService | None = None,
workflow_service: WorkflowService | None = None,
image_service: ImageService | None = None,
) -> dict:
params = query or {}
if service:
context_service = service
else:
resolved_image_service, resolved_workflow_service = _resolve_services(image_service, workflow_service)
context_service = NodeDependencyContextService(resolved_workflow_service, resolved_image_service)
def action() -> dict[str, Any]:
require_authenticated(ctx)
return context_service.get_context(node_id, include_draft=_bool(params.get("include_draft")))
return handle_request(ctx, action)
def update_node( def update_node(
ctx: RequestContext, ctx: RequestContext,
node_id: str, node_id: str,
@ -235,3 +258,9 @@ def _create_generation_service() -> GenerationService:
model_provider_service=model_provider_service, model_provider_service=model_provider_service,
event_bus=event_bus, event_bus=event_bus,
) )
def _bool(value: Any) -> bool:
if isinstance(value, str):
return value.strip().lower() in {"1", "true", "yes", "on"}
return bool(value)

查看文件

@ -115,6 +115,22 @@ def create_quick_profile_draft(
return handle_request(ctx, action) return handle_request(ctx, action)
def save_quick_profile_draft(
ctx: RequestContext,
payload: dict[str, Any],
service: QuickProfileService | None = None,
profile_service: ProfileService | None = None,
) -> dict:
quick_service = service or QuickProfileService()
resolved_profile_service = profile_service or _create_profile_service()
def action() -> dict:
require_write(ctx)
return quick_service.save_draft(payload, resolved_profile_service, ctx)
return handle_request(ctx, action)
def _create_profile_service() -> ProfileService: def _create_profile_service() -> ProfileService:
database = Database(load_database_settings()) database = Database(load_database_settings())
return ProfileService( return ProfileService(

查看文件

@ -0,0 +1,25 @@
"""Prompt expansion route handlers."""
from __future__ import annotations
from typing import Any
from backend.routes.common import handle_request
from backend.services.prompt_expansion_service import PromptExpansionService
from core.identity import RequestContext
from core.security import require_authenticated
def expand_prompt(
ctx: RequestContext,
payload: dict[str, Any] | None = None,
service: PromptExpansionService | None = None,
) -> dict:
prompt_service = service or PromptExpansionService()
request_payload = payload or {}
def action() -> dict[str, Any]:
require_authenticated(ctx)
return prompt_service.expand_payload(request_payload)
return handle_request(ctx, action)

查看文件

@ -5,6 +5,7 @@ from __future__ import annotations
from typing import Any from typing import Any
from backend.routes.common import handle_request from backend.routes.common import handle_request
from backend.services.character_workflow_service import CharacterWorkflowService
from backend.services.event_stream_service import get_default_event_bus from backend.services.event_stream_service import get_default_event_bus
from backend.services.workflow_service import WorkflowService from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService from core.audit_service import AuditService
@ -112,6 +113,20 @@ def _set_workflow_status(
return handle_request(ctx, action) return handle_request(ctx, action)
def execute_character_workflow(
ctx: RequestContext,
workflow_id: str,
service: CharacterWorkflowService | None = None,
) -> dict:
character_service = service or CharacterWorkflowService(_create_workflow_service())
def action() -> dict:
require_write(ctx)
return character_service.execute_workflow(workflow_id, ctx)
return handle_request(ctx, action)
def _create_workflow_service() -> WorkflowService: def _create_workflow_service() -> WorkflowService:
database = Database(load_database_settings()) database = Database(load_database_settings())
return WorkflowService( return WorkflowService(

查看文件

@ -0,0 +1,141 @@
"""Deterministic execution helpers for character workflows."""
from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.dto.profile_dto import CharacterProfile
from backend.dto.workflow_dto import ProfileWorkflow, WorkflowNode
from backend.services.workflow_service import WorkflowService
from core.identity import RequestContext
CHARACTER_WORKFLOW_TYPES = {"character_fast", "character_gradual"}
class CharacterWorkflowService:
def __init__(self, workflow_service: WorkflowService):
self.workflow_service = workflow_service
def execute_workflow(self, workflow_id: str, ctx: RequestContext) -> dict[str, Any]:
detail = self.workflow_service.get_workflow(workflow_id)
workflow = detail.workflow
if workflow.workflow_type not in CHARACTER_WORKFLOW_TYPES:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"workflow is not a character workflow",
{"workflow_id": workflow_id, "workflow_type": workflow.workflow_type},
)
profile = self.workflow_service.profile_repository.get(workflow.profile_id)
if profile is None:
raise ApiError(ErrorCode.RESOURCE_NOT_FOUND, "profile not found", {"profile_id": workflow.profile_id})
active_nodes = [
node
for node in sorted(detail.nodes, key=lambda item: item.sort_order)
if node.branch_name == workflow.current_branch
]
if not active_nodes:
raise ApiError(ErrorCode.VALIDATION_FAILED, "workflow has no executable nodes", {"workflow_id": workflow_id})
running_workflow = workflow
if workflow.status != "running":
running_workflow = self.workflow_service.update_workflow(workflow_id, {"status": "running"}, ctx)
completed_nodes: list[WorkflowNode] = []
prompt_context: list[str] = []
for node in active_nodes:
prompt = _node_prompt(profile, node, running_workflow, prompt_context)
negative_prompt = _negative_prompt(profile, node)
completed = self.workflow_service.update_node(
node.node_id,
{
"status": "completed",
"prompt": prompt,
"negative_prompt": negative_prompt,
"metadata": {
**node.metadata,
"execution": {
"executor": "character_workflow",
"workflow_type": workflow.workflow_type,
"context_prompts": len(prompt_context),
},
},
},
ctx,
)
completed_nodes.append(completed)
prompt_context.append(prompt)
completed_workflow = self.workflow_service.update_workflow(
workflow_id,
{
"status": "completed",
"current_node_id": completed_nodes[-1].node_id,
"metadata": {
**running_workflow.metadata,
"character_execution": {
"executor": "character_workflow",
"workflow_type": workflow.workflow_type,
"completed_node_ids": [node.node_id for node in completed_nodes],
},
},
},
ctx,
)
return {
"workflow": completed_workflow.to_dict(),
"nodes": [node.to_dict() for node in completed_nodes],
"completed_node_ids": [node.node_id for node in completed_nodes],
}
def _node_prompt(
profile: CharacterProfile,
node: WorkflowNode,
workflow: ProfileWorkflow,
prompt_context: list[str],
) -> str:
parts = [
profile.name,
profile.base_prompt,
profile.appearance_prompt,
profile.style_prompt,
_step_instruction(workflow.workflow_type, node.node_key),
node.prompt,
]
if prompt_context:
parts.append(f"consistency reference: {prompt_context[-1]}")
return ", ".join(_unique_text(parts))
def _negative_prompt(profile: CharacterProfile, node: WorkflowNode) -> str:
return ", ".join(_unique_text([profile.negative_prompt, node.negative_prompt, "low quality, blurry"]))
def _step_instruction(workflow_type: str, node_key: str) -> str:
fast = {
"fast_profile": "condensed character design brief",
"fast_candidates": "candidate batch, varied composition, keep identity consistent",
"fast_final": "final selected character illustration, production ready",
}
gradual = {
"profile_brief": "core identity and visual anchors",
"headshot": "headshot, face, hair, eyes, expression",
"half_body": "half body, upper outfit, posture and silhouette",
"full_body": "full body, complete outfit and proportions",
"expression_sheet": "expression sheet with reusable emotions",
"pose_sheet": "pose sheet with action variants",
"style_lock": "style consistency lock and final rendering rules",
"final_pack": "final character pack, accepted images and reusable metadata",
}
table = fast if workflow_type == "character_fast" else gradual
return table.get(node_key, node_key.replace("_", " "))
def _unique_text(values: list[Any]) -> list[str]:
result: list[str] = []
seen: set[str] = set()
for value in values:
text = str(value or "").strip()
if text and text not in seen:
result.append(text)
seen.add(text)
return result

查看文件

@ -0,0 +1,75 @@
"""Safe deletion planners for media-backed records."""
from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.services.image_service import ImageService
from backend.services.media_service import MediaService
from core.identity import RequestContext
class DeletionSafetyService:
def __init__(self, image_service: ImageService, media_service: MediaService):
self.image_service = image_service
self.media_service = media_service
def plan_image_delete(self, image_id: str, *, delete_files: bool = False) -> dict[str, Any]:
image = self.image_service.get_image(image_id)
files = [_file_entry(uri) for uri in (image.image_uri, image.thumbnail_uri) if uri]
return {
"target_type": "generation_image",
"image_id": image.image_id,
"metadata_delete": True,
"delete_files": bool(delete_files),
"requires_explicit_file_delete": not bool(delete_files),
"files": [self._hydrate_entry(entry) for entry in files],
}
def delete_image(
self,
image_id: str,
ctx: RequestContext,
*,
dry_run: bool = True,
delete_files: bool = False,
) -> dict[str, Any]:
plan = self.plan_image_delete(image_id, delete_files=delete_files)
if dry_run:
return {**plan, "dry_run": True, "status": "planned", "deleted_files": []}
deleted_files = []
deleted = self.image_service.delete_image_metadata(image_id, ctx)
if delete_files:
for file_entry in plan["files"]:
if self._delete_storage_file(str(file_entry["uri"])):
deleted_files.append(file_entry["uri"])
return {
**plan,
"dry_run": False,
"status": "completed",
"deleted_image": deleted.to_dict(),
"deleted_files": deleted_files,
}
def _hydrate_entry(self, entry: dict[str, Any]) -> dict[str, Any]:
try:
path = self.media_service.storage.resolve_uri(entry["uri"])
except ApiError:
return {**entry, "exists": False, "bytes": 0}
if path.exists() and not path.is_file():
raise ApiError(ErrorCode.FORBIDDEN, "refusing to delete non-file media path", {"uri": entry["uri"]})
return {**entry, "exists": path.exists(), "bytes": path.stat().st_size if path.exists() else 0}
def _delete_storage_file(self, uri: str) -> bool:
path = self.media_service.storage.resolve_uri(uri)
if not path.exists():
return False
if not path.is_file():
raise ApiError(ErrorCode.FORBIDDEN, "refusing to delete non-file media path", {"uri": uri})
path.unlink()
return True
def _file_entry(uri: str) -> dict[str, Any]:
return {"uri": uri, "exists": False, "bytes": 0}

查看文件

@ -9,6 +9,7 @@ from backend.dto.job_dto import GenerationTask
from backend.services.cost_guard_service import CostGuardService from backend.services.cost_guard_service import CostGuardService
from backend.services.image_service import ImageService from backend.services.image_service import ImageService
from backend.services.model_provider_service import ModelProviderService from backend.services.model_provider_service import ModelProviderService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.queue_service import QueueService from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService from backend.services.workflow_service import WorkflowService
from core.event_bus import EventBus from core.event_bus import EventBus
@ -25,6 +26,7 @@ class GenerationService:
single_flow_engine: SingleFlowEngine | None = None, single_flow_engine: SingleFlowEngine | None = None,
model_provider_service: ModelProviderService | None = None, model_provider_service: ModelProviderService | None = None,
cost_guard_service: CostGuardService | None = None, cost_guard_service: CostGuardService | None = None,
prompt_expansion_service: PromptExpansionService | None = None,
event_bus: EventBus | None = None, event_bus: EventBus | None = None,
): ):
self.workflow_service = workflow_service self.workflow_service = workflow_service
@ -33,6 +35,7 @@ class GenerationService:
self.single_flow_engine = single_flow_engine or SingleFlowEngine() self.single_flow_engine = single_flow_engine or SingleFlowEngine()
self.model_provider_service = model_provider_service self.model_provider_service = model_provider_service
self.cost_guard_service = cost_guard_service self.cost_guard_service = cost_guard_service
self.prompt_expansion_service = prompt_expansion_service
self.event_bus = event_bus self.event_bus = event_bus
def generate_node(self, node_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]: def generate_node(self, node_id: str, payload: dict[str, Any], ctx: RequestContext) -> dict[str, Any]:
@ -41,11 +44,21 @@ class GenerationService:
model_route = str(payload.get("model_route") or node.model_route or "image_low") model_route = str(payload.get("model_route") or node.model_route or "image_low")
route_resolution = self._resolve_model_route(model_route) route_resolution = self._resolve_model_route(model_route)
cost_guard = self._check_cost_budget(payload, model_route, route_resolution) cost_guard = self._check_cost_budget(payload, model_route, route_resolution)
prompt_expansion = self._expand_prompt(workflow.profile_id, node, payload)
generation_request = { generation_request = {
**payload, **payload,
"model_route": model_route, "model_route": model_route,
"resolved_model_route": route_resolution, "resolved_model_route": route_resolution,
**({"cost_guard": cost_guard} if cost_guard else {}), **({"cost_guard": cost_guard} if cost_guard else {}),
**(
{
"prompt_expansion": prompt_expansion,
"expanded_prompt": prompt_expansion["prompt"],
"expanded_negative_prompt": prompt_expansion["negative_prompt"],
}
if prompt_expansion
else {}
),
} }
idempotency_key = _optional_text(payload.get("idempotency_key")) idempotency_key = _optional_text(payload.get("idempotency_key"))
if idempotency_key: if idempotency_key:
@ -112,6 +125,7 @@ class GenerationService:
"image_uri": asset.image_uri, "image_uri": asset.image_uri,
"thumbnail_uri": asset.thumbnail_uri, "thumbnail_uri": asset.thumbnail_uri,
"positive_prompt": asset.positive_prompt, "positive_prompt": asset.positive_prompt,
"negative_prompt": asset.negative_prompt,
"model_route": asset.model_route, "model_route": asset.model_route,
"seed": asset.seed, "seed": asset.seed,
"width": asset.width, "width": asset.width,
@ -216,6 +230,19 @@ class GenerationService:
raise ApiError(ErrorCode.VALIDATION_FAILED, "generation budget exceeded", guard) raise ApiError(ErrorCode.VALIDATION_FAILED, "generation budget exceeded", guard)
return guard return guard
def _expand_prompt(
self,
profile_id: str,
node,
payload: dict[str, Any],
) -> dict[str, Any] | None:
if not self.prompt_expansion_service:
return None
profile = self.workflow_service.profile_repository.get(profile_id)
if profile is None:
return None
return self.prompt_expansion_service.expand_for_node(profile, node, payload)
def _publish(self, event_type: str, payload: dict[str, Any]) -> None: def _publish(self, event_type: str, payload: dict[str, Any]) -> None:
if self.event_bus: if self.event_bus:
self.event_bus.publish(event_type, payload) self.event_bus.publish(event_type, payload)

查看文件

@ -2,6 +2,7 @@
from __future__ import annotations from __future__ import annotations
from pathlib import PurePosixPath
from typing import Any from typing import Any
from uuid import uuid4 from uuid import uuid4
@ -13,6 +14,14 @@ from database.repositories.material_repository import MaterialRepository
MATERIAL_STATUSES = {"pending_upload", "pending_recognition", "pending_confirm", "confirmed", "archived"} MATERIAL_STATUSES = {"pending_upload", "pending_recognition", "pending_confirm", "confirmed", "archived"}
MAX_UPLOAD_BYTES = 20 * 1024 * 1024
UPLOAD_SIZE_FIELDS = ("size_bytes", "content_length", "file_size", "size")
UPLOAD_ALLOWED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp"}
UPLOAD_ALLOWED_CONTENT_TYPES = {
"image/jpeg": {".jpg", ".jpeg"},
"image/png": {".png"},
"image/webp": {".webp"},
}
class MaterialService: class MaterialService:
@ -173,21 +182,31 @@ class MaterialService:
return self.update_material(material_id, {"recognition_status": "archived"}, ctx) return self.update_material(material_id, {"recognition_status": "archived"}, ctx)
def upload_material(self, payload: dict[str, Any], ctx: RequestContext) -> Material: def upload_material(self, payload: dict[str, Any], ctx: RequestContext) -> Material:
image_uri = payload.get("image_uri") image_uri = str(payload.get("image_uri") or "").strip()
if not image_uri: if not image_uri:
raise ApiError(ErrorCode.VALIDATION_FAILED, "image_uri is required", {"field": "image_uri"}) raise ApiError(ErrorCode.VALIDATION_FAILED, "image_uri is required", {"field": "image_uri"})
display_name = str(payload.get("display_name") or payload.get("filename") or "Uploaded material").strip() filename = _normalize_upload_filename(payload.get("filename"))
content_type = _normalize_upload_content_type(payload.get("content_type"))
declared_size = _normalize_upload_size(payload)
upload_metadata = _normalize_upload_metadata(payload.get("metadata"))
extension = _validate_upload_file_type(filename=filename, image_uri=image_uri, content_type=content_type)
display_name = str(payload.get("display_name") or _display_name_from_filename(filename) or "Uploaded material").strip()
thumbnail_uri = str(payload.get("thumbnail_uri") or image_uri).strip()
return self.create_material( return self.create_material(
{ {
"category_id": payload.get("category_id"), "category_id": payload.get("category_id"),
"display_name": display_name, "display_name": display_name,
"image_uri": image_uri, "image_uri": image_uri,
"thumbnail_uri": payload.get("thumbnail_uri") or image_uri, "thumbnail_uri": thumbnail_uri,
"recognition_status": "pending_recognition", "recognition_status": "pending_recognition",
"metadata": { "metadata": {
**upload_metadata,
"upload": { "upload": {
"filename": payload.get("filename"), "filename": filename,
"content_type": payload.get("content_type"), "content_type": content_type,
"extension": extension,
"size_bytes": declared_size,
"max_size_bytes": MAX_UPLOAD_BYTES,
"mock": True, "mock": True,
} }
}, },
@ -289,3 +308,101 @@ def _mock_tags(material: Material) -> list[str]:
if keyword in text: if keyword in text:
tags.append(keyword) tags.append(keyword)
return tags return tags
def _normalize_upload_filename(value: Any) -> str | None:
if value is None:
return None
filename = str(value).strip()
if not filename:
return None
if len(filename) > 255 or filename in {".", ".."} or any(marker in filename for marker in ("/", "\\", "\x00", ":")):
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"filename must be a safe basename",
{"field": "filename"},
)
return filename
def _normalize_upload_content_type(value: Any) -> str | None:
if value is None:
return None
content_type = str(value).split(";", 1)[0].strip().lower()
if not content_type:
return None
if content_type not in UPLOAD_ALLOWED_CONTENT_TYPES:
raise ApiError(
ErrorCode.UNSUPPORTED_FILE_TYPE,
"unsupported upload content type",
{
"field": "content_type",
"content_type": content_type,
"allowed": sorted(UPLOAD_ALLOWED_CONTENT_TYPES),
},
)
return content_type
def _normalize_upload_size(payload: dict[str, Any]) -> int | None:
for field in UPLOAD_SIZE_FIELDS:
if field not in payload or payload[field] in (None, ""):
continue
try:
size = int(payload[field])
except (TypeError, ValueError):
raise ApiError(ErrorCode.VALIDATION_FAILED, "upload size must be an integer", {"field": field}) from None
if size < 0:
raise ApiError(ErrorCode.VALIDATION_FAILED, "upload size must not be negative", {"field": field})
if size > MAX_UPLOAD_BYTES:
raise ApiError(
ErrorCode.UPLOAD_TOO_LARGE,
"upload exceeds maximum allowed size",
{"field": field, "size_bytes": size, "max_size_bytes": MAX_UPLOAD_BYTES},
)
return size
return None
def _normalize_upload_metadata(value: Any) -> dict[str, Any]:
if value in (None, ""):
return {}
if not isinstance(value, dict):
raise ApiError(ErrorCode.VALIDATION_FAILED, "metadata must be an object", {"field": "metadata"})
return dict(value)
def _validate_upload_file_type(*, filename: str | None, image_uri: str, content_type: str | None) -> str:
extension = _suffix(filename) or _suffix(image_uri)
if not extension:
raise ApiError(
ErrorCode.UNSUPPORTED_FILE_TYPE,
"upload filename or image_uri must include a supported image extension",
{"field": "filename", "allowed": sorted(UPLOAD_ALLOWED_EXTENSIONS)},
)
if extension not in UPLOAD_ALLOWED_EXTENSIONS:
raise ApiError(
ErrorCode.UNSUPPORTED_FILE_TYPE,
"unsupported upload file extension",
{"field": "filename", "extension": extension, "allowed": sorted(UPLOAD_ALLOWED_EXTENSIONS)},
)
if content_type and extension not in UPLOAD_ALLOWED_CONTENT_TYPES[content_type]:
raise ApiError(
ErrorCode.UNSUPPORTED_FILE_TYPE,
"upload extension does not match content type",
{"field": "content_type", "extension": extension, "content_type": content_type},
)
return extension
def _suffix(value: str | None) -> str | None:
if not value:
return None
suffix = PurePosixPath(str(value).split("?", 1)[0]).suffix.lower()
return suffix or None
def _display_name_from_filename(filename: str | None) -> str | None:
if not filename:
return None
return PurePosixPath(filename).stem.replace("_", " ").strip() or None

查看文件

@ -0,0 +1,15 @@
"""Media file index service."""
from __future__ import annotations
from typing import Any
from backend.services.media_service import MediaService
class MediaIndexService:
def __init__(self, media_service: MediaService):
self.media_service = media_service
def index_files(self, *, root: str | None = None, limit: int = 500) -> dict[str, Any]:
return self.media_service.storage.index_files(root=root, limit=limit)

查看文件

@ -0,0 +1,76 @@
"""Build dependency context for workflow nodes."""
from __future__ import annotations
from typing import Any
from backend.dto.common import ApiError, ErrorCode
from backend.services.image_service import ImageService
from backend.services.workflow_service import WorkflowService
CONTEXT_STATUSES = {"completed", "selected"}
class NodeDependencyContextService:
def __init__(
self,
workflow_service: WorkflowService,
image_service: ImageService | None = None,
):
self.workflow_service = workflow_service
self.image_service = image_service
def get_context(self, node_id: str, *, include_draft: bool = False) -> dict[str, Any]:
target = self.workflow_service.get_node(node_id)
detail = self.workflow_service.get_workflow(target.workflow_id)
dependencies = []
for node in sorted(detail.nodes, key=lambda item: item.sort_order):
if node.branch_name != target.branch_name or node.sort_order >= target.sort_order:
continue
if not include_draft and node.status not in CONTEXT_STATUSES:
continue
dependencies.append(self._node_context(node))
prompt_parts = [item["prompt"] for item in dependencies if item.get("prompt")]
selected_image_ids = [
item["selected_image"]["image_id"]
for item in dependencies
if isinstance(item.get("selected_image"), dict)
]
return {
"workflow_id": target.workflow_id,
"node_id": target.node_id,
"branch_name": target.branch_name,
"dependency_count": len(dependencies),
"dependencies": dependencies,
"prompt_context": ", ".join(prompt_parts),
"selected_image_ids": selected_image_ids,
}
def _node_context(self, node) -> dict[str, Any]:
selected_image = None
if node.selected_image_id and self.image_service:
try:
image = self.image_service.get_image(node.selected_image_id)
selected_image = {
"image_id": image.image_id,
"image_uri": image.image_uri,
"thumbnail_uri": image.thumbnail_uri,
"model_route": image.model_route,
"metadata": image.metadata,
}
except ApiError as exc:
if exc.error_code != ErrorCode.RESOURCE_NOT_FOUND:
raise
return {
"node_id": node.node_id,
"node_key": node.node_key,
"title": node.title,
"status": node.status,
"sort_order": node.sort_order,
"prompt": node.prompt,
"negative_prompt": node.negative_prompt,
"selected_image_id": node.selected_image_id,
"selected_image": selected_image,
"metadata": node.metadata,
}

查看文件

@ -0,0 +1,46 @@
"""Find storage files that are not referenced by database records."""
from __future__ import annotations
from typing import Any
from backend.services.media_index_service import MediaIndexService
from database.db_helper import Database
class OrphanMediaService:
def __init__(self, database: Database, media_index_service: MediaIndexService):
self.database = database
self.media_index_service = media_index_service
def scan(self, *, root: str | None = None, limit: int = 500) -> dict[str, Any]:
references = self._referenced_uris()
index = self.media_index_service.index_files(root=root, limit=limit)
orphans = [item for item in index["items"] if item["uri"] not in references]
return {
"root": root,
"total_indexed": len(index["items"]),
"total_files": index["total"],
"index_truncated": index["truncated"],
"referenced_uri_count": len(references),
"orphan_count": len(orphans),
"orphans": orphans,
}
def _referenced_uris(self) -> set[str]:
refs: set[str] = set()
conn = self.database.connect()
try:
for table, columns in (
("generation_images", ("image_uri", "thumbnail_uri")),
("materials", ("image_uri", "thumbnail_uri")),
("character_profiles", ("avatar_image_uri",)),
):
for row in conn.execute(f"SELECT {', '.join(columns)} FROM {table}").fetchall():
for column in columns:
uri = str(row[column] or "").strip()
if uri.startswith("storage://"):
refs.add(uri)
finally:
conn.close()
return refs

查看文件

@ -0,0 +1,85 @@
"""Prompt expansion service for generation requests."""
from __future__ import annotations
from typing import Any
from backend.dto.profile_dto import CharacterProfile
from backend.dto.workflow_dto import WorkflowNode
from core.prompt_pipeline import merge_prompt_sections
class PromptExpansionService:
def expand_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
sections = payload.get("sections")
if not isinstance(sections, list):
sections = [payload]
result = merge_prompt_sections(*[section for section in sections if isinstance(section, dict)])
return {
**result.to_dict(),
"source": "payload",
}
def expand_for_node(
self,
profile: CharacterProfile,
node: WorkflowNode,
payload: dict[str, Any],
) -> dict[str, Any]:
variables = {
"profile_name": profile.name,
"node_title": node.title,
**(profile.metadata.get("prompt_variables") if isinstance(profile.metadata.get("prompt_variables"), dict) else {}),
**(payload.get("variables") if isinstance(payload.get("variables"), dict) else {}),
}
result = merge_prompt_sections(
{
"parts": [profile.base_prompt, profile.appearance_prompt, profile.style_prompt],
"negative_parts": [profile.negative_prompt],
"variables": variables,
},
{
"parts": [node.prompt],
"negative_parts": [node.negative_prompt],
"variables": variables,
},
{
"parts": _payload_parts(payload),
"negative_parts": _payload_negative_parts(payload),
"variables": variables,
},
)
return {
**result.to_dict(),
"source": "profile_node",
"profile_id": profile.profile_id,
"node_id": node.node_id,
}
def _payload_parts(payload: dict[str, Any]) -> list[Any]:
parts: list[Any] = []
parts.extend(_as_list(payload.get("prompt_parts")))
for key in ("prompt_patch", "extra_prompt", "style_prompt"):
value = payload.get(key)
if value:
parts.append(value)
return parts
def _payload_negative_parts(payload: dict[str, Any]) -> list[Any]:
parts: list[Any] = []
parts.extend(_as_list(payload.get("negative_parts")))
for key in ("negative_prompt", "negative_prompt_patch"):
value = payload.get(key)
if value:
parts.append(value)
return parts
def _as_list(value: Any) -> list[Any]:
if value is None:
return []
if isinstance(value, list):
return value
return [value]

查看文件

@ -10,6 +10,8 @@ from typing import Any
from uuid import uuid4 from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode from backend.dto.common import ApiError, ErrorCode
from backend.services.profile_service import ProfileService
from core.identity import RequestContext
class QuickProfileService: class QuickProfileService:
@ -64,6 +66,48 @@ class QuickProfileService:
}, },
} }
def save_draft(
self,
payload: dict[str, Any],
profile_service: ProfileService,
ctx: RequestContext,
) -> dict[str, Any]:
draft = payload.get("draft") if isinstance(payload.get("draft"), dict) else {}
preview = payload.get("profile_preview") if isinstance(payload.get("profile_preview"), dict) else None
preview = preview or (draft.get("profile_preview") if isinstance(draft.get("profile_preview"), dict) else None)
if not preview:
raise ApiError(
ErrorCode.VALIDATION_FAILED,
"\u7f3a\u5c11\u5feb\u901f\u4eba\u8bbe\u9884\u89c8",
{"field": "profile_preview"},
)
name = _text(preview.get("name"))
if not name:
raise ApiError(ErrorCode.VALIDATION_FAILED, "\u89d2\u8272\u540d\u79f0\u4e0d\u80fd\u4e3a\u7a7a", {"field": "name"})
draft_id = _text(payload.get("draft_id") or draft.get("draft_id"))
profile = profile_service.create_profile(
{
"name": name,
"description": payload.get("description"),
"base_prompt": preview.get("base_prompt"),
"appearance_prompt": preview.get("appearance_prompt"),
"style_prompt": preview.get("style_prompt"),
"negative_prompt": preview.get("negative_prompt"),
"default_model_route": payload.get("default_model_route") or preview.get("default_model_route"),
"avatar_image_uri": payload.get("avatar_image_uri") or preview.get("avatar_image_uri"),
"metadata": {
**(payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {}),
"source": "quick_profile",
**({"draft_id": draft_id} if draft_id else {}),
},
},
ctx,
)
return {
"draft_id": draft_id or None,
"profile": profile.to_dict(),
}
def _text(value: Any) -> str: def _text(value: Any) -> str:
return str(value or "").strip() return str(value or "").strip()

查看文件

@ -4,6 +4,7 @@ from __future__ import annotations
import shutil import shutil
from dataclasses import dataclass from dataclasses import dataclass
from datetime import datetime, timezone
from pathlib import Path from pathlib import Path
from typing import Any from typing import Any
@ -61,6 +62,41 @@ class VfsStorage:
"execution_enabled": True, "execution_enabled": True,
} }
def index_files(self, *, root: str | None = None, limit: int = 500) -> dict[str, Any]:
roots = self._root_paths()
if root and root not in roots:
raise ApiError(ErrorCode.MEDIA_NOT_FOUND, "unknown storage root", {"root": root})
selected_roots = [root] if root else sorted(roots)
normalized_limit = min(max(int(limit or 500), 1), 5000)
items: list[dict[str, Any]] = []
total = 0
for root_name in selected_roots:
root_path = _resolve_data_path(roots[root_name]).resolve()
if not root_path.exists():
continue
for path in sorted(root_path.rglob("*")):
if not path.is_file():
continue
total += 1
if len(items) >= normalized_limit:
continue
relative = path.relative_to(root_path).as_posix()
items.append(
{
"root": root_name,
"uri": f"storage://{root_name}/{relative}",
"bytes": path.stat().st_size,
"modified_at": datetime.fromtimestamp(path.stat().st_mtime, timezone.utc).isoformat(),
}
)
return {
"root": root,
"limit": normalized_limit,
"total": total,
"truncated": total > len(items),
"items": items,
}
def resolve_uri(self, uri: str) -> Path: def resolve_uri(self, uri: str) -> Path:
root, relative = self.split_uri(uri) root, relative = self.split_uri(uri)
root_path = self._root_paths().get(root) root_path = self._root_paths().get(root)

查看文件

@ -110,6 +110,7 @@ class ReviewFlowEngine:
def review_node(self, node: WorkflowNode, images: list[GenerationImage]) -> dict[str, Any]: def review_node(self, node: WorkflowNode, images: list[GenerationImage]) -> dict[str, Any]:
warnings: list[dict[str, Any]] = [] warnings: list[dict[str, Any]] = []
errors: list[dict[str, Any]] = [] errors: list[dict[str, Any]] = []
selected_image = next((image for image in images if image.image_id == node.selected_image_id), None)
if self.policy.warn_without_images and not images: if self.policy.warn_without_images and not images:
warnings.append({"code": "NO_IMAGES", "message": "node has no generated images"}) warnings.append({"code": "NO_IMAGES", "message": "node has no generated images"})
if node.status in self.policy.require_selected_image_for_statuses and not node.selected_image_id: if node.status in self.policy.require_selected_image_for_statuses and not node.selected_image_id:
@ -124,6 +125,25 @@ class ReviewFlowEngine:
image.image_id == node.selected_image_id and image.is_archived for image in images image.image_id == node.selected_image_id and image.is_archived for image in images
): ):
errors.append({"code": "SELECTED_IMAGE_ARCHIVED", "message": "selected image is archived"}) errors.append({"code": "SELECTED_IMAGE_ARCHIVED", "message": "selected image is archived"})
if selected_image and node.model_route and selected_image.model_route and node.model_route != selected_image.model_route:
warnings.append(
{
"code": "MODEL_ROUTE_MISMATCH",
"message": "selected image model_route differs from node model_route",
"node_model_route": node.model_route,
"image_model_route": selected_image.model_route,
}
)
if selected_image and node.prompt and selected_image.positive_prompt:
node_prompt = _normalize_prompt(node.prompt)
image_prompt = _normalize_prompt(selected_image.positive_prompt)
if node_prompt and image_prompt and node_prompt not in image_prompt and image_prompt not in node_prompt:
warnings.append(
{
"code": "PROMPT_MISMATCH",
"message": "selected image prompt differs from node prompt",
}
)
return { return {
"target_type": "node", "target_type": "node",
"target_id": node.node_id, "target_id": node.node_id,
@ -133,7 +153,9 @@ class ReviewFlowEngine:
"summary": { "summary": {
"image_count": len(images), "image_count": len(images),
"selected_image_id": node.selected_image_id, "selected_image_id": node.selected_image_id,
"selected_image_model_route": selected_image.model_route if selected_image else None,
"node_status": node.status, "node_status": node.status,
"node_model_route": node.model_route,
"policy_version": self.policy.version, "policy_version": self.policy.version,
}, },
} }
@ -155,6 +177,21 @@ class ReviewFlowEngine:
"node_ids": incomplete, "node_ids": incomplete,
} }
) )
selected_model_routes = sorted(
{
str(result["summary"].get("selected_image_model_route"))
for result in node_results
if result["summary"].get("selected_image_model_route")
}
)
if len(selected_model_routes) > 1:
warnings.append(
{
"code": "INCONSISTENT_SELECTED_MODEL_ROUTES",
"message": "workflow selected images use multiple model routes",
"model_routes": selected_model_routes,
}
)
return { return {
"target_type": "workflow", "target_type": "workflow",
"target_id": workflow.workflow_id, "target_id": workflow.workflow_id,
@ -165,6 +202,7 @@ class ReviewFlowEngine:
"workflow_type": workflow.workflow_type, "workflow_type": workflow.workflow_type,
"node_count": len(nodes), "node_count": len(nodes),
"incomplete_count": len(incomplete), "incomplete_count": len(incomplete),
"selected_model_routes": selected_model_routes,
"policy_version": self.policy.version, "policy_version": self.policy.version,
}, },
"nodes": node_results, "nodes": node_results,
@ -185,3 +223,7 @@ def _normalize_status_list(value: Any) -> tuple[str, ...]:
if status and status not in statuses: if status and status not in statuses:
statuses.append(status) statuses.append(status)
return tuple(statuses) return tuple(statuses)
def _normalize_prompt(value: str) -> str:
return " ".join(str(value or "").lower().replace(",", " ").split())

查看文件

@ -26,6 +26,7 @@ class MockGeneratedAsset:
image_uri: str image_uri: str
thumbnail_uri: str thumbnail_uri: str
positive_prompt: str positive_prompt: str
negative_prompt: str | None
model_route: str | None model_route: str | None
width: int width: int
height: int height: int
@ -44,32 +45,45 @@ class SingleFlowEngine:
def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]: def generate(self, node: WorkflowNode, task: GenerationTask, request: dict[str, Any]) -> list[MockGeneratedAsset]:
count = _bounded_count(request.get("count", 1)) count = _bounded_count(request.get("count", 1))
prompt = _compose_prompt(node.prompt, request.get("prompt_patch")) prompt = _optional_text(request.get("expanded_prompt")) or _compose_prompt(node.prompt, request.get("prompt_patch"))
negative_prompt = _optional_text(request.get("expanded_negative_prompt")) or _optional_text(node.negative_prompt)
model_route = str(request.get("model_route") or node.model_route or "image_low") model_route = str(request.get("model_route") or node.model_route or "image_low")
width, height = _dimensions(str(request.get("aspect_ratio") or "1:1")) width, height = _dimensions(str(request.get("aspect_ratio") or "1:1"))
provider = self._image_provider(request) provider = self._image_provider(request)
if provider is not None: if provider is not None:
try: try:
return self._generate_with_provider(provider, task, request, prompt, model_route, width, height, count) return self._generate_with_provider(
provider,
task,
request,
prompt,
negative_prompt,
model_route,
width,
height,
count,
)
except ImageProviderError as exc: except ImageProviderError as exc:
route = request.get("resolved_model_route") if isinstance(request.get("resolved_model_route"), dict) else {} route = request.get("resolved_model_route") if isinstance(request.get("resolved_model_route"), dict) else {}
return self._generate_mock( return self._generate_mock(
task, task,
request, request,
prompt, prompt,
negative_prompt,
model_route, model_route,
width, width,
height, height,
count, count,
provider_error=provider_failure_attribution(exc, route_context=route, fallback_used=True), provider_error=provider_failure_attribution(exc, route_context=route, fallback_used=True),
) )
return self._generate_mock(task, request, prompt, model_route, width, height, count) return self._generate_mock(task, request, prompt, negative_prompt, model_route, width, height, count)
def _generate_mock( def _generate_mock(
self, self,
task: GenerationTask, task: GenerationTask,
request: dict[str, Any], request: dict[str, Any],
prompt: str, prompt: str,
negative_prompt: str | None,
model_route: str, model_route: str,
width: int, width: int,
height: int, height: int,
@ -90,6 +104,7 @@ class SingleFlowEngine:
image_uri=image_uri, image_uri=image_uri,
thumbnail_uri=thumbnail_uri, thumbnail_uri=thumbnail_uri,
positive_prompt=prompt, positive_prompt=prompt,
negative_prompt=negative_prompt,
model_route=model_route, model_route=model_route,
width=width, width=width,
height=height, height=height,
@ -110,6 +125,7 @@ class SingleFlowEngine:
task: GenerationTask, task: GenerationTask,
request: dict[str, Any], request: dict[str, Any],
prompt: str, prompt: str,
negative_prompt: str | None,
model_route: str, model_route: str,
width: int, width: int,
height: int, height: int,
@ -141,6 +157,7 @@ class SingleFlowEngine:
image_uri=image_uri, image_uri=image_uri,
thumbnail_uri=thumbnail_uri, thumbnail_uri=thumbnail_uri,
positive_prompt=image.revised_prompt or prompt, positive_prompt=image.revised_prompt or prompt,
negative_prompt=negative_prompt,
model_route=model_route, model_route=model_route,
width=width, width=width,
height=height, height=height,
@ -190,6 +207,13 @@ def _compose_prompt(base_prompt: str | None, prompt_patch: Any) -> str:
return ", ".join(parts) if parts else "single image mock generation" return ", ".join(parts) if parts else "single image mock generation"
def _optional_text(value: Any) -> str | None:
if value is None:
return None
text = str(value).strip()
return text or None
def _dimensions(aspect_ratio: str) -> tuple[int, int]: def _dimensions(aspect_ratio: str) -> tuple[int, int]:
if aspect_ratio == "3:4": if aspect_ratio == "3:4":
return 768, 1024 return 768, 1024

查看文件

@ -0,0 +1,104 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.workflow_routes import execute_character_workflow
from backend.services.character_workflow_service import CharacterWorkflowService
from backend.services.profile_service import ProfileService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
class CharacterWorkflowServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db")))
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.profile_service = ProfileService(self.profile_repository, self.audit_service)
self.workflow_service = WorkflowService(
self.workflow_repository,
self.profile_repository,
self.audit_service,
)
self.character_service = CharacterWorkflowService(self.workflow_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
self.profile = self.profile_service.create_profile(
{
"name": "Nova",
"base_prompt": "mage student",
"appearance_prompt": "silver hair, blue eyes",
"style_prompt": "watercolor",
"negative_prompt": "low quality",
},
self.ctx,
)
def tearDown(self):
self.tmp.cleanup()
def test_execute_fast_character_workflow_completes_nodes_with_prompts(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_fast", "display_name": "Fast"},
self.ctx,
)
result = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
self.assertEqual(result["workflow"]["status"], "completed")
self.assertEqual(len(result["nodes"]), 3)
self.assertTrue(all(node["status"] == "completed" for node in result["nodes"]))
candidate = next(node for node in result["nodes"] if node["node_key"] == "fast_candidates")
self.assertIn("candidate batch", candidate["prompt"])
self.assertIn("mage student", candidate["prompt"])
self.assertEqual(candidate["metadata"]["execution"]["workflow_type"], "character_fast")
def test_execute_gradual_character_workflow_completes_all_template_steps(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_gradual", "display_name": "Gradual"},
self.ctx,
)
result = self.character_service.execute_workflow(detail.workflow.workflow_id, self.ctx)
self.assertEqual(len(result["completed_node_ids"]), 8)
final_pack = result["nodes"][-1]
self.assertEqual(final_pack["node_key"], "final_pack")
self.assertIn("final character pack", final_pack["prompt"])
self.assertIn("consistency reference", final_pack["prompt"])
def test_execute_character_workflow_route_requires_write_permission(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_fast", "display_name": "Fast"},
self.ctx,
)
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = execute_character_workflow(read_only, detail.workflow.workflow_id, self.character_service)
allowed = execute_character_workflow(self.ctx, detail.workflow.workflow_id, self.character_service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
self.assertTrue(allowed["ok"])
self.assertEqual(allowed["data"]["workflow"]["status"], "completed")
if __name__ == "__main__":
unittest.main()

查看文件

@ -0,0 +1,122 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.image_routes import safe_delete_image
from backend.services.deletion_safety_service import DeletionSafetyService
from backend.services.image_service import ImageService
from backend.services.media_service import MediaService
from backend.services.profile_service import ProfileService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.config_service import ConfigService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
class DeletionSafetyServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
self.config_path.write_text(
f"""
storage:
images_path: "{(self.root / "images").as_posix()}"
thumbnails_path: "{(self.root / "thumbnails").as_posix()}"
materials_path: "{(self.root / "materials").as_posix()}"
styles_path: "{(self.root / "styles").as_posix()}"
archives_path: "{(self.root / "archives").as_posix()}"
temp_path: "{(self.root / "temp").as_posix()}"
""",
encoding="utf-8",
)
for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"):
(self.root / folder).mkdir(parents=True, exist_ok=True)
self.database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db"))))
self.database.initialize()
self.audit_service = AuditService(self.database)
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.image_repository = ImageRepository(self.database)
self.profile_service = ProfileService(self.profile_repository, self.audit_service)
self.workflow_service = WorkflowService(self.workflow_repository, self.profile_repository, self.audit_service)
self.image_service = ImageService(self.image_repository, self.workflow_repository, self.audit_service)
self.media_service = MediaService(ConfigService(self.config_path))
self.deletion_service = DeletionSafetyService(self.image_service, self.media_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
workflow = self.workflow_service.create_workflow(
profile.profile_id,
{"workflow_type": "single_image", "display_name": "Single"},
self.ctx,
)
self.node = workflow.nodes[0]
def tearDown(self):
self.tmp.cleanup()
def test_safe_delete_dry_run_exposes_plan_without_local_paths(self):
image = self._create_image_with_files()
plan = self.deletion_service.delete_image(image.image_id, self.ctx, dry_run=True)
self.assertEqual(plan["status"], "planned")
self.assertTrue(plan["requires_explicit_file_delete"])
self.assertEqual({item["uri"] for item in plan["files"]}, {image.image_uri, image.thumbnail_uri})
self.assertNotIn(str(self.root), str(plan))
self.assertIsNotNone(self.image_service.get_image(image.image_id))
def test_safe_delete_can_remove_metadata_and_files_when_explicit(self):
image = self._create_image_with_files(is_selected=True)
result = self.deletion_service.delete_image(
image.image_id,
self.ctx,
dry_run=False,
delete_files=True,
)
self.assertEqual(result["status"], "completed")
self.assertEqual(set(result["deleted_files"]), {image.image_uri, image.thumbnail_uri})
self.assertFalse((self.root / "images" / "delete.png").exists())
self.assertFalse((self.root / "thumbnails" / "delete.webp").exists())
self.assertIsNone(self.workflow_repository.get_node(self.node.node_id).selected_image_id)
def test_safe_delete_route_requires_write_permission(self):
image = self._create_image_with_files()
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = safe_delete_image(read_only, image.image_id, {}, self.deletion_service)
planned = safe_delete_image(self.ctx, image.image_id, {}, self.deletion_service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
self.assertTrue(planned["ok"])
self.assertEqual(planned["data"]["status"], "planned")
def _create_image_with_files(self, *, is_selected: bool = False):
(self.root / "images" / "delete.png").write_bytes(b"image")
(self.root / "thumbnails" / "delete.webp").write_bytes(b"thumb")
return self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": "storage://images/delete.png",
"thumbnail_uri": "storage://thumbnails/delete.webp",
"is_selected": is_selected,
},
self.ctx,
)
if __name__ == "__main__":
unittest.main()

查看文件

@ -17,8 +17,9 @@ from backend.routes.material_routes import (
update_material, update_material,
upload_material, upload_material,
) )
from backend.dto.common import ApiError, ErrorCode
from backend.services.media_service import MediaService from backend.services.media_service import MediaService
from backend.services.material_service import MaterialService from backend.services.material_service import MAX_UPLOAD_BYTES, MaterialService
from core.audit_service import AuditService from core.audit_service import AuditService
from core.config_service import ConfigService from core.config_service import ConfigService
from core.identity import RequestContext from core.identity import RequestContext
@ -132,12 +133,21 @@ storage:
{ {
"category_id": category.category_id, "category_id": category.category_id,
"filename": "white_blouse.png", "filename": "white_blouse.png",
"content_type": "image/png; charset=binary",
"size_bytes": "2048",
"image_uri": "storage://materials/white_blouse.png", "image_uri": "storage://materials/white_blouse.png",
"metadata": {"source": "unit_test"},
}, },
self.ctx, self.ctx,
) )
self.assertEqual(uploaded.recognition_status, "pending_recognition") self.assertEqual(uploaded.recognition_status, "pending_recognition")
self.assertEqual(uploaded.thumbnail_uri, "storage://materials/white_blouse.png") self.assertEqual(uploaded.thumbnail_uri, "storage://materials/white_blouse.png")
self.assertEqual(uploaded.display_name, "white blouse")
self.assertEqual(uploaded.metadata["source"], "unit_test")
self.assertEqual(uploaded.metadata["upload"]["filename"], "white_blouse.png")
self.assertEqual(uploaded.metadata["upload"]["content_type"], "image/png")
self.assertEqual(uploaded.metadata["upload"]["extension"], ".png")
self.assertEqual(uploaded.metadata["upload"]["size_bytes"], 2048)
recognized = self.material_service.recognize_material(uploaded.material_id, self.ctx) recognized = self.material_service.recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(recognized.recognition_status, "pending_confirm") self.assertEqual(recognized.recognition_status, "pending_confirm")
@ -160,6 +170,73 @@ storage:
self.assertEqual(re_recognized.recognition_status, "pending_confirm") self.assertEqual(re_recognized.recognition_status, "pending_confirm")
self.assertIn("white", re_recognized.tags) self.assertIn("white", re_recognized.tags)
def test_upload_rejects_unsafe_filename(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "../white_blouse.png",
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(caught.exception.details["field"], "filename")
def test_upload_rejects_unsupported_file_type(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.gif",
"content_type": "image/gif",
"image_uri": "storage://materials/white_blouse.gif",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
def test_upload_rejects_mismatched_content_type(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.jpg",
"content_type": "image/png",
"image_uri": "storage://materials/white_blouse.jpg",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
self.assertEqual(caught.exception.details["field"], "content_type")
def test_upload_rejects_oversized_payload(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"content_type": "image/png",
"size_bytes": MAX_UPLOAD_BYTES + 1,
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UPLOAD_TOO_LARGE)
self.assertEqual(caught.exception.details["max_size_bytes"], MAX_UPLOAD_BYTES)
def test_material_routes_wrap_responses_and_require_permission(self): def test_material_routes_wrap_responses_and_require_permission(self):
category = create_material_category(self.ctx, {"name": "Accessory"}, self.material_service) category = create_material_category(self.ctx, {"name": "Accessory"}, self.material_service)
self.assertTrue(category["ok"]) self.assertTrue(category["ok"])
@ -230,6 +307,20 @@ storage:
self.assertTrue(uploaded["data"]["thumbnail_url"].startswith("/api/v1/plugins/extensions/")) self.assertTrue(uploaded["data"]["thumbnail_url"].startswith("/api/v1/plugins/extensions/"))
self.assertNotIn(str(self.root), str(uploaded["data"])) self.assertNotIn(str(self.root), str(uploaded["data"]))
rejected = upload_material(
self.ctx,
{
"category_id": category["data"]["category_id"],
"filename": "blue_dress.exe",
"content_type": "application/octet-stream",
"image_uri": "storage://materials/blue_dress.exe",
},
self.material_service,
self.media_service,
)
self.assertFalse(rejected["ok"])
self.assertEqual(rejected["error_code"], "UNSUPPORTED_FILE_TYPE")
material_id = uploaded["data"]["material_id"] material_id = uploaded["data"]["material_id"]
recognized = recognize_material(self.ctx, material_id, self.material_service, self.media_service) recognized = recognize_material(self.ctx, material_id, self.material_service, self.media_service)
self.assertTrue(recognized["ok"]) self.assertTrue(recognized["ok"])

查看文件

@ -0,0 +1,68 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.media_routes import index_media
from backend.services.media_index_service import MediaIndexService
from backend.services.media_service import MediaService
from core.config_service import ConfigService
from core.identity import RequestContext
class MediaIndexServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
self.config_path.write_text(
f"""
storage:
images_path: "{(self.root / "images").as_posix()}"
thumbnails_path: "{(self.root / "thumbnails").as_posix()}"
materials_path: "{(self.root / "materials").as_posix()}"
styles_path: "{(self.root / "styles").as_posix()}"
archives_path: "{(self.root / "archives").as_posix()}"
temp_path: "{(self.root / "temp").as_posix()}"
""",
encoding="utf-8",
)
for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"):
(self.root / folder).mkdir(parents=True, exist_ok=True)
(self.root / "images" / "a.png").write_bytes(b"aaa")
(self.root / "images" / "nested").mkdir()
(self.root / "images" / "nested" / "b.png").write_bytes(b"bb")
(self.root / "materials" / "mat.png").write_bytes(b"m")
self.media_service = MediaService(ConfigService(self.config_path))
self.index_service = MediaIndexService(self.media_service)
self.ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
def tearDown(self):
self.tmp.cleanup()
def test_index_files_returns_storage_uris_without_local_paths(self):
index = self.index_service.index_files(root="images")
self.assertEqual(index["total"], 2)
self.assertFalse(index["truncated"])
self.assertEqual(
[item["uri"] for item in index["items"]],
["storage://images/a.png", "storage://images/nested/b.png"],
)
self.assertEqual(index["items"][0]["bytes"], 3)
self.assertNotIn(str(self.root), str(index))
def test_index_media_route_requires_authentication_and_honors_limit(self):
response = index_media(self.ctx, {"limit": "1"}, self.index_service)
anonymous = index_media(RequestContext(), {}, self.index_service)
self.assertTrue(response["ok"])
self.assertEqual(len(response["data"]["items"]), 1)
self.assertTrue(response["data"]["truncated"])
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -0,0 +1,111 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.node_routes import get_node_dependency_context
from backend.services.image_service import ImageService
from backend.services.node_dependency_context_service import NodeDependencyContextService
from backend.services.profile_service import ProfileService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
class NodeDependencyContextServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db")))
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.image_repository = ImageRepository(self.database)
self.profile_service = ProfileService(self.profile_repository, self.audit_service)
self.workflow_service = WorkflowService(
self.workflow_repository,
self.profile_repository,
self.audit_service,
)
self.image_service = ImageService(self.image_repository, self.workflow_repository, self.audit_service)
self.context_service = NodeDependencyContextService(self.workflow_service, self.image_service)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
self.profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
def tearDown(self):
self.tmp.cleanup()
def test_context_includes_completed_predecessor_prompts_and_selected_images(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_gradual", "display_name": "Gradual"},
self.ctx,
)
first, second, target = detail.nodes[:3]
image = self.image_service.create_image(
{
"node_id": first.node_id,
"image_uri": "storage://images/headshot.png",
"thumbnail_uri": "storage://thumbnails/headshot.png",
"is_selected": True,
"metadata": {"kind": "headshot"},
},
self.ctx,
)
self.workflow_service.update_node(
first.node_id,
{"status": "completed", "prompt": "headshot, silver hair"},
self.ctx,
)
self.workflow_service.update_node(
second.node_id,
{"status": "completed", "prompt": "half body, white blouse"},
self.ctx,
)
context = self.context_service.get_context(target.node_id)
self.assertEqual(context["dependency_count"], 2)
self.assertEqual(context["selected_image_ids"], [image.image_id])
self.assertIn("headshot, silver hair", context["prompt_context"])
self.assertEqual(context["dependencies"][0]["selected_image"]["image_uri"], "storage://images/headshot.png")
self.assertNotIn(str(self.tmp.name), str(context))
def test_dependency_context_route_requires_authentication(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "character_fast", "display_name": "Fast"},
self.ctx,
)
allowed = get_node_dependency_context(
self.ctx,
detail.nodes[1].node_id,
{},
self.context_service,
)
anonymous = get_node_dependency_context(
RequestContext(),
detail.nodes[1].node_id,
{},
self.context_service,
)
self.assertTrue(allowed["ok"])
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -0,0 +1,72 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.media_routes import scan_orphan_media
from backend.services.media_index_service import MediaIndexService
from backend.services.media_service import MediaService
from backend.services.orphan_media_service import OrphanMediaService
from core.config_service import ConfigService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.image_repository import ImageRepository
class OrphanMediaServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
self.config_path.write_text(
f"""
storage:
images_path: "{(self.root / "images").as_posix()}"
thumbnails_path: "{(self.root / "thumbnails").as_posix()}"
materials_path: "{(self.root / "materials").as_posix()}"
styles_path: "{(self.root / "styles").as_posix()}"
archives_path: "{(self.root / "archives").as_posix()}"
temp_path: "{(self.root / "temp").as_posix()}"
""",
encoding="utf-8",
)
for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"):
(self.root / folder).mkdir(parents=True, exist_ok=True)
(self.root / "images" / "used.png").write_bytes(b"used")
(self.root / "images" / "orphan.png").write_bytes(b"orphan")
self.database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db"))))
self.database.initialize()
ImageRepository(self.database).create(
{
"image_id": "img_used",
"image_uri": "storage://images/used.png",
}
)
media_service = MediaService(ConfigService(self.config_path))
self.service = OrphanMediaService(self.database, MediaIndexService(media_service))
self.ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
def tearDown(self):
self.tmp.cleanup()
def test_scan_reports_unreferenced_storage_files_without_local_paths(self):
result = self.service.scan(root="images")
self.assertEqual(result["total_files"], 2)
self.assertEqual(result["orphan_count"], 1)
self.assertEqual(result["orphans"][0]["uri"], "storage://images/orphan.png")
self.assertNotIn(str(self.root), str(result))
def test_scan_orphan_media_route_requires_authentication(self):
response = scan_orphan_media(self.ctx, {"root": "images"}, self.service)
anonymous = scan_orphan_media(RequestContext(), {"root": "images"}, self.service)
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["orphan_count"], 1)
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -0,0 +1,84 @@
from __future__ import annotations
import unittest
from backend.dto.profile_dto import CharacterProfile
from backend.dto.workflow_dto import WorkflowNode
from backend.routes.prompt_routes import expand_prompt
from backend.services.prompt_expansion_service import PromptExpansionService
from core.identity import RequestContext
class PromptExpansionServiceTests(unittest.TestCase):
def test_expand_for_node_combines_profile_node_and_payload(self):
profile = CharacterProfile(
profile_id="profile_001",
name="Nova",
description=None,
base_prompt="portrait of {profile_name}",
appearance_prompt="silver hair",
style_prompt="soft watercolor",
negative_prompt="low quality",
default_model_route="image_low",
owner_platform="webui",
owner_context_id=None,
owner_user_id="user_001",
owner_session_key=None,
avatar_image_uri=None,
status="active",
metadata={"prompt_variables": {"mood": "calm"}},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
node = WorkflowNode(
node_id="node_001",
workflow_id="workflow_001",
node_key="single",
title="Single",
description=None,
step_name=None,
node_type="single_image",
status="draft",
branch_name="main",
prompt="{mood} expression",
negative_prompt="bad hands",
model_route="image_low",
selected_image_id=None,
sort_order=1,
metadata={},
created_at="2026-01-01T00:00:00Z",
updated_at="2026-01-01T00:00:00Z",
)
result = PromptExpansionService().expand_for_node(
profile,
node,
{"prompt_patch": "white blouse", "negative_prompt_patch": "watermark"},
)
self.assertEqual(
result["prompt"],
"portrait of Nova, silver hair, soft watercolor, calm expression, white blouse",
)
self.assertEqual(result["negative_prompt"], "low quality, bad hands, watermark")
self.assertEqual(result["source"], "profile_node")
def test_expand_prompt_route_requires_authentication(self):
ctx = RequestContext.from_astrbot(username="admin", user_id="user_001")
response = expand_prompt(
ctx,
{"sections": [{"prompt": "portrait"}, {"prompt": "portrait", "negative_prompt": "blur"}]},
PromptExpansionService(),
)
anonymous = expand_prompt(RequestContext(), {"prompt": "portrait"}, PromptExpansionService())
self.assertTrue(response["ok"])
self.assertEqual(response["data"]["prompt"], "portrait")
self.assertEqual(response["data"]["negative_prompt"], "blur")
self.assertFalse(anonymous["ok"])
self.assertEqual(anonymous["error_code"], "UNAUTHORIZED")
if __name__ == "__main__":
unittest.main()

查看文件

@ -0,0 +1,84 @@
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.profile_routes import save_quick_profile_draft
from backend.services.profile_service import ProfileService
from backend.services.quick_profile_service import QuickProfileService
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.profile_repository import ProfileRepository
class QuickProfileServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.database = Database(
DatabaseSettings(sqlite=SqliteSettings(path=str(Path(self.tmp.name) / "imagestudio.db")))
)
self.database.initialize()
self.profile_service = ProfileService(ProfileRepository(self.database), AuditService(self.database))
self.quick_service = QuickProfileService()
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
def tearDown(self):
self.tmp.cleanup()
def test_save_draft_persists_preview_as_character_profile(self):
draft = self.quick_service.create_draft(
{
"questionnaire": {
"name": "Nova",
"identity": "mage student",
"personality": ["calm", "kind"],
"hair_color": "silver",
"hairstyle": "long hair",
"eye_color": "blue",
"style": "watercolor",
"clothing_keywords": ["white blouse"],
}
}
)
saved = self.quick_service.save_draft({"draft": draft}, self.profile_service, self.ctx)
profile = self.profile_service.get_profile(saved["profile"]["profile_id"])
self.assertEqual(profile.name, "Nova")
self.assertIn("mage student", profile.base_prompt)
self.assertIn("silver hair", profile.appearance_prompt)
self.assertEqual(profile.style_prompt, "watercolor")
self.assertEqual(profile.metadata["source"], "quick_profile")
self.assertEqual(profile.metadata["draft_id"], draft["draft_id"])
def test_save_quick_profile_route_requires_write_permission(self):
draft = self.quick_service.create_draft({"questionnaire": {"name": "Nova"}})
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = save_quick_profile_draft(
read_only,
{"draft": draft},
self.quick_service,
self.profile_service,
)
allowed = save_quick_profile_draft(
self.ctx,
{"draft": draft},
self.quick_service,
self.profile_service,
)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
self.assertTrue(allowed["ok"])
self.assertEqual(allowed["data"]["profile"]["name"], "Nova")
if __name__ == "__main__":
unittest.main()

查看文件

@ -100,6 +100,55 @@ class ReviewServiceTests(unittest.TestCase):
self.assertTrue(result["passed"]) self.assertTrue(result["passed"])
self.assertEqual(result["summary"]["selected_image_id"], image.image_id) self.assertEqual(result["summary"]["selected_image_id"], image.image_id)
def test_review_warns_about_prompt_and_model_route_mismatch(self):
node = self.workflow.nodes[1]
self.workflow_service.update_node(
node.node_id,
{"status": "completed", "prompt": "portrait, silver hair", "model_route": "image_high"},
self.ctx,
)
image = self.image_service.create_image(
{
"node_id": node.node_id,
"image_uri": "storage://images/mismatch.png",
"positive_prompt": "landscape, blue sky",
"model_route": "image_low",
"is_selected": True,
},
self.ctx,
)
result = self.review_service.review_node(node.node_id)
self.assertTrue(result["passed"])
self.assertEqual(result["summary"]["selected_image_id"], image.image_id)
self.assertIn("MODEL_ROUTE_MISMATCH", [warning["code"] for warning in result["warnings"]])
self.assertIn("PROMPT_MISMATCH", [warning["code"] for warning in result["warnings"]])
def test_review_workflow_warns_when_selected_images_mix_model_routes(self):
first, second = self.workflow.nodes[:2]
for node, route in ((first, "image_low"), (second, "image_high")):
self.workflow_service.update_node(
node.node_id,
{"status": "completed", "prompt": f"{route} prompt", "model_route": route},
self.ctx,
)
self.image_service.create_image(
{
"node_id": node.node_id,
"image_uri": f"storage://images/{route}.png",
"positive_prompt": f"{route} prompt",
"model_route": route,
"is_selected": True,
},
self.ctx,
)
result = self.review_service.review_workflow(self.workflow.workflow.workflow_id)
self.assertIn("INCONSISTENT_SELECTED_MODEL_ROUTES", [warning["code"] for warning in result["warnings"]])
self.assertEqual(result["summary"]["selected_model_routes"], ["image_high", "image_low"])
def test_review_routes_require_authentication(self): def test_review_routes_require_authentication(self):
node = self.workflow.nodes[0] node = self.workflow.nodes[0]
response = review_node(self.ctx, node.node_id, self.review_service) response = review_node(self.ctx, node.node_id, self.review_service)

查看文件

@ -26,6 +26,7 @@ class RouteRegistryTests(unittest.TestCase):
self.assertIn(("GET", "ui/bootstrap"), keys) self.assertIn(("GET", "ui/bootstrap"), keys)
self.assertIn(("GET", "ui/actions"), keys) self.assertIn(("GET", "ui/actions"), keys)
self.assertIn(("POST", "nodes/{node_id}/generate"), keys) self.assertIn(("POST", "nodes/{node_id}/generate"), keys)
self.assertIn(("POST", "profiles/quick-draft/save"), keys)
self.assertIn(("GET", "security/audit-logs"), keys) self.assertIn(("GET", "security/audit-logs"), keys)
self.assertIn(("POST", "api-discovery/probe-provider"), keys) self.assertIn(("POST", "api-discovery/probe-provider"), keys)
self.assertIn(("PUT", "material-categories/{category_id}"), keys) self.assertIn(("PUT", "material-categories/{category_id}"), keys)
@ -36,11 +37,15 @@ class RouteRegistryTests(unittest.TestCase):
self.assertIn(("POST", "workflows/{workflow_id}/start"), keys) self.assertIn(("POST", "workflows/{workflow_id}/start"), keys)
self.assertIn(("POST", "workflows/{workflow_id}/cancel"), keys) self.assertIn(("POST", "workflows/{workflow_id}/cancel"), keys)
self.assertIn(("POST", "workflows/{workflow_id}/archive"), keys) self.assertIn(("POST", "workflows/{workflow_id}/archive"), keys)
self.assertIn(("POST", "workflows/{workflow_id}/execute-character"), keys)
self.assertIn(("GET", "nodes/{node_id}/review"), keys) self.assertIn(("GET", "nodes/{node_id}/review"), keys)
self.assertIn(("GET", "nodes/{node_id}/dependency-context"), keys)
self.assertIn(("GET", "workflows/{workflow_id}/review"), keys) self.assertIn(("GET", "workflows/{workflow_id}/review"), keys)
self.assertIn(("GET", "review/policy"), keys) self.assertIn(("GET", "review/policy"), keys)
self.assertIn(("POST", "review/policy/validate"), keys) self.assertIn(("POST", "review/policy/validate"), keys)
self.assertIn(("POST", "review/policy/save"), keys) self.assertIn(("POST", "review/policy/save"), keys)
self.assertIn(("POST", "prompts/expand"), keys)
self.assertIn(("POST", "images/{image_id}/safe-delete"), keys)
self.assertIn(("POST", "nodes/{node_id}/retry"), keys) self.assertIn(("POST", "nodes/{node_id}/retry"), keys)
self.assertIn(("POST", "nodes/{node_id}/complete"), keys) self.assertIn(("POST", "nodes/{node_id}/complete"), keys)
self.assertIn(("POST", "nodes/{node_id}/mark-completed"), keys) self.assertIn(("POST", "nodes/{node_id}/mark-completed"), keys)
@ -52,6 +57,8 @@ class RouteRegistryTests(unittest.TestCase):
self.assertIn(("GET", "settings/snapshots/{snapshot_id}"), keys) self.assertIn(("GET", "settings/snapshots/{snapshot_id}"), keys)
self.assertIn(("POST", "settings/rollback"), keys) self.assertIn(("POST", "settings/rollback"), keys)
self.assertIn(("POST", "storage/migrate"), keys) self.assertIn(("POST", "storage/migrate"), keys)
self.assertIn(("GET", "media/index"), keys)
self.assertIn(("GET", "media/orphans"), keys)
self.assertIn(("GET", "events/stream"), keys) self.assertIn(("GET", "events/stream"), keys)
self.assertIn(("GET", "costs/usage"), keys) self.assertIn(("GET", "costs/usage"), keys)
self.assertIn(("POST", "costs/guard"), keys) self.assertIn(("POST", "costs/guard"), keys)

查看文件

@ -13,6 +13,7 @@ from backend.services.cost_service import CostService
from backend.services.generation_service import GenerationService from backend.services.generation_service import GenerationService
from backend.services.image_service import ImageService from backend.services.image_service import ImageService
from backend.services.model_provider_service import ModelProviderService from backend.services.model_provider_service import ModelProviderService
from backend.services.prompt_expansion_service import PromptExpansionService
from backend.services.profile_service import ProfileService from backend.services.profile_service import ProfileService
from backend.services.queue_service import QueueService from backend.services.queue_service import QueueService
from backend.services.workflow_service import WorkflowService from backend.services.workflow_service import WorkflowService
@ -461,6 +462,55 @@ storage:
self.assertIn("cost_budget_exceeded", response["details"]["violations"]) self.assertIn("cost_budget_exceeded", response["details"]["violations"])
self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0)
def test_generate_node_uses_prompt_expansion_when_service_is_configured(self):
profile = self.profile_service.create_profile(
{
"name": "Nova",
"base_prompt": "portrait of {profile_name}",
"appearance_prompt": "silver hair",
"style_prompt": "watercolor",
"negative_prompt": "low quality",
},
self.ctx,
)
workflow = self.workflow_service.create_workflow(
profile.profile_id,
{"workflow_type": "single_image", "display_name": "Single"},
self.ctx,
)
node_id = workflow.nodes[0].node_id
self.workflow_service.update_node(
node_id,
{"prompt": "calm expression", "negative_prompt": "bad hands"},
self.ctx,
)
generation_service = GenerationService(
workflow_service=self.workflow_service,
queue_service=self.queue_service,
image_service=self.image_service,
single_flow_engine=SingleFlowEngine(VfsStorage(self.config_service)),
model_provider_service=self.model_provider_service,
prompt_expansion_service=PromptExpansionService(),
event_bus=self.event_bus,
)
response = generate_node(
self.ctx,
node_id,
{"prompt_patch": "white blouse", "negative_prompt_patch": "watermark"},
generation_service=generation_service,
)
self.assertTrue(response["ok"])
image = response["data"]["images"][0]
self.assertEqual(
image["positive_prompt"],
"portrait of Nova, silver hair, watercolor, calm expression, white blouse",
)
self.assertEqual(image["negative_prompt"], "low quality, bad hands, watermark")
task = self.queue_service.get_job(response["data"]["task_id"])
self.assertEqual(task.request["prompt_expansion"]["source"], "profile_node")
def test_queue_service_rejects_invalid_task_transition(self): def test_queue_service_rejects_invalid_task_transition(self):
task = self.queue_service.create_task({"status": "succeeded"}, self.ctx) task = self.queue_service.create_task({"status": "succeeded"}, self.ctx)