327 行
11 KiB
Python
327 行
11 KiB
Python
"""Repository for material categories and materials."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from typing import Any
|
|
|
|
from backend.dto.material_dto import Material, MaterialCategory
|
|
from database.db_helper import Database
|
|
|
|
|
|
CATEGORY_COLUMNS = """
|
|
category_id,
|
|
name,
|
|
parent_id,
|
|
category_type,
|
|
sort_order,
|
|
metadata_json,
|
|
created_at,
|
|
updated_at
|
|
"""
|
|
|
|
MATERIAL_COLUMNS = """
|
|
material_id,
|
|
category_id,
|
|
display_name,
|
|
image_uri,
|
|
thumbnail_uri,
|
|
prompt,
|
|
negative_prompt,
|
|
tags_json,
|
|
recognition_status,
|
|
metadata_json,
|
|
created_at,
|
|
updated_at
|
|
"""
|
|
|
|
|
|
class MaterialRepository:
|
|
def __init__(self, database: Database):
|
|
self.database = database
|
|
|
|
@property
|
|
def placeholder(self) -> str:
|
|
return self.database._placeholder
|
|
|
|
def create_category(self, payload: dict[str, Any]) -> MaterialCategory:
|
|
placeholder = self.placeholder
|
|
conn = self.database.connect()
|
|
try:
|
|
conn.execute(
|
|
f"""
|
|
INSERT INTO material_categories (
|
|
category_id, name, parent_id, category_type, sort_order, metadata_json
|
|
) VALUES (
|
|
{placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}
|
|
)
|
|
""",
|
|
(
|
|
payload["category_id"],
|
|
payload["name"],
|
|
payload.get("parent_id"),
|
|
payload.get("category_type", "material"),
|
|
int(payload.get("sort_order", 0)),
|
|
_json_or_none(payload.get("metadata")),
|
|
),
|
|
)
|
|
conn.commit()
|
|
finally:
|
|
conn.close()
|
|
category = self.get_category(payload["category_id"])
|
|
if category is None:
|
|
raise RuntimeError("material category was inserted but could not be read back")
|
|
return category
|
|
|
|
def get_category(self, category_id: str) -> MaterialCategory | None:
|
|
placeholder = self.placeholder
|
|
conn = self.database.connect()
|
|
try:
|
|
row = conn.execute(
|
|
f"SELECT {CATEGORY_COLUMNS} FROM material_categories WHERE category_id = {placeholder}",
|
|
(category_id,),
|
|
).fetchone()
|
|
finally:
|
|
conn.close()
|
|
return _row_to_category(row) if row else None
|
|
|
|
def list_categories(self) -> list[MaterialCategory]:
|
|
conn = self.database.connect()
|
|
try:
|
|
rows = conn.execute(
|
|
f"""
|
|
SELECT {CATEGORY_COLUMNS}
|
|
FROM material_categories
|
|
ORDER BY parent_id ASC, sort_order ASC, created_at ASC
|
|
"""
|
|
).fetchall()
|
|
finally:
|
|
conn.close()
|
|
return [_row_to_category(row) for row in rows]
|
|
|
|
def update_category(self, category_id: str, payload: dict[str, Any]) -> MaterialCategory | None:
|
|
allowed = {"name", "parent_id", "category_type", "sort_order", "metadata"}
|
|
assignments: list[str] = []
|
|
params: list[Any] = []
|
|
placeholder = self.placeholder
|
|
for key in allowed:
|
|
if key not in payload:
|
|
continue
|
|
column = "metadata_json" if key == "metadata" else key
|
|
value = _json_or_none(payload[key]) if key == "metadata" else payload[key]
|
|
assignments.append(f"{column} = {placeholder}")
|
|
params.append(value)
|
|
if not assignments:
|
|
return self.get_category(category_id)
|
|
assignments.append("updated_at = CURRENT_TIMESTAMP")
|
|
params.append(category_id)
|
|
conn = self.database.connect()
|
|
try:
|
|
conn.execute(
|
|
f"UPDATE material_categories SET {', '.join(assignments)} WHERE category_id = {placeholder}",
|
|
tuple(params),
|
|
)
|
|
conn.commit()
|
|
finally:
|
|
conn.close()
|
|
return self.get_category(category_id)
|
|
|
|
def delete_category(self, category_id: str) -> MaterialCategory | None:
|
|
before = self.get_category(category_id)
|
|
if before is None:
|
|
return None
|
|
placeholder = self.placeholder
|
|
conn = self.database.connect()
|
|
try:
|
|
conn.execute(f"DELETE FROM material_categories WHERE category_id = {placeholder}", (category_id,))
|
|
conn.commit()
|
|
finally:
|
|
conn.close()
|
|
return before
|
|
|
|
def create_material(self, payload: dict[str, Any]) -> Material:
|
|
placeholder = self.placeholder
|
|
conn = self.database.connect()
|
|
try:
|
|
conn.execute(
|
|
f"""
|
|
INSERT INTO materials (
|
|
material_id,
|
|
category_id,
|
|
display_name,
|
|
image_uri,
|
|
thumbnail_uri,
|
|
prompt,
|
|
negative_prompt,
|
|
tags_json,
|
|
recognition_status,
|
|
metadata_json
|
|
) VALUES (
|
|
{placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder},
|
|
{placeholder}, {placeholder}, {placeholder}, {placeholder}, {placeholder}
|
|
)
|
|
""",
|
|
(
|
|
payload["material_id"],
|
|
payload.get("category_id"),
|
|
payload["display_name"],
|
|
payload.get("image_uri"),
|
|
payload.get("thumbnail_uri"),
|
|
payload.get("prompt"),
|
|
payload.get("negative_prompt"),
|
|
_json_or_none(payload.get("tags") or []),
|
|
payload.get("recognition_status", "pending_upload"),
|
|
_json_or_none(payload.get("metadata")),
|
|
),
|
|
)
|
|
conn.commit()
|
|
finally:
|
|
conn.close()
|
|
material = self.get_material(payload["material_id"])
|
|
if material is None:
|
|
raise RuntimeError("material was inserted but could not be read back")
|
|
return material
|
|
|
|
def get_material(self, material_id: str) -> Material | None:
|
|
placeholder = self.placeholder
|
|
conn = self.database.connect()
|
|
try:
|
|
row = conn.execute(
|
|
f"SELECT {MATERIAL_COLUMNS} FROM materials WHERE material_id = {placeholder}",
|
|
(material_id,),
|
|
).fetchone()
|
|
finally:
|
|
conn.close()
|
|
return _row_to_material(row) if row else None
|
|
|
|
def list_materials(
|
|
self,
|
|
*,
|
|
category_id: str | None = None,
|
|
keyword: str | None = None,
|
|
page: int = 1,
|
|
page_size: int = 30,
|
|
) -> tuple[list[Material], int]:
|
|
placeholder = self.placeholder
|
|
where = ["recognition_status != 'archived'"]
|
|
params: list[Any] = []
|
|
if category_id:
|
|
where.append(f"category_id = {placeholder}")
|
|
params.append(category_id)
|
|
if keyword:
|
|
where.append(f"(display_name LIKE {placeholder} OR prompt LIKE {placeholder})")
|
|
like = f"%{keyword}%"
|
|
params.extend([like, like])
|
|
where_clause = f"WHERE {' AND '.join(where)}"
|
|
offset = max(page - 1, 0) * page_size
|
|
conn = self.database.connect()
|
|
try:
|
|
total_row = conn.execute(
|
|
f"SELECT COUNT(*) AS total FROM materials {where_clause}",
|
|
tuple(params),
|
|
).fetchone()
|
|
rows = conn.execute(
|
|
f"""
|
|
SELECT {MATERIAL_COLUMNS}
|
|
FROM materials
|
|
{where_clause}
|
|
ORDER BY created_at DESC
|
|
LIMIT {placeholder} OFFSET {placeholder}
|
|
""",
|
|
tuple(params + [page_size, offset]),
|
|
).fetchall()
|
|
finally:
|
|
conn.close()
|
|
return [_row_to_material(row) for row in rows], int(total_row["total"] if total_row else 0)
|
|
|
|
def update_material(self, material_id: str, payload: dict[str, Any]) -> Material | None:
|
|
allowed = {
|
|
"category_id",
|
|
"display_name",
|
|
"image_uri",
|
|
"thumbnail_uri",
|
|
"prompt",
|
|
"negative_prompt",
|
|
"tags",
|
|
"recognition_status",
|
|
"metadata",
|
|
}
|
|
assignments: list[str] = []
|
|
params: list[Any] = []
|
|
placeholder = self.placeholder
|
|
for key in allowed:
|
|
if key not in payload:
|
|
continue
|
|
column = key
|
|
value = payload[key]
|
|
if key == "tags":
|
|
column = "tags_json"
|
|
value = _json_or_none(value or [])
|
|
elif key == "metadata":
|
|
column = "metadata_json"
|
|
value = _json_or_none(value)
|
|
assignments.append(f"{column} = {placeholder}")
|
|
params.append(value)
|
|
if not assignments:
|
|
return self.get_material(material_id)
|
|
assignments.append("updated_at = CURRENT_TIMESTAMP")
|
|
params.append(material_id)
|
|
conn = self.database.connect()
|
|
try:
|
|
conn.execute(
|
|
f"UPDATE materials SET {', '.join(assignments)} WHERE material_id = {placeholder}",
|
|
tuple(params),
|
|
)
|
|
conn.commit()
|
|
finally:
|
|
conn.close()
|
|
return self.get_material(material_id)
|
|
|
|
|
|
def _row_to_category(row) -> MaterialCategory:
|
|
return MaterialCategory(
|
|
category_id=row["category_id"],
|
|
name=row["name"],
|
|
parent_id=row["parent_id"],
|
|
category_type=row["category_type"],
|
|
sort_order=int(row["sort_order"] or 0),
|
|
metadata=_json_loads(row["metadata_json"]),
|
|
created_at=str(row["created_at"]),
|
|
updated_at=str(row["updated_at"]),
|
|
)
|
|
|
|
|
|
def _row_to_material(row) -> Material:
|
|
return Material(
|
|
material_id=row["material_id"],
|
|
category_id=row["category_id"],
|
|
display_name=row["display_name"],
|
|
image_uri=row["image_uri"],
|
|
thumbnail_uri=row["thumbnail_uri"],
|
|
prompt=row["prompt"],
|
|
negative_prompt=row["negative_prompt"],
|
|
tags=_json_loads_list(row["tags_json"]),
|
|
recognition_status=row["recognition_status"],
|
|
metadata=_json_loads(row["metadata_json"]),
|
|
created_at=str(row["created_at"]),
|
|
updated_at=str(row["updated_at"]),
|
|
)
|
|
|
|
|
|
def _json_or_none(value: Any | None) -> str | None:
|
|
if value is None:
|
|
return None
|
|
return json.dumps(value, ensure_ascii=False, sort_keys=True)
|
|
|
|
|
|
def _json_loads(value: str | None) -> dict[str, Any]:
|
|
if not value:
|
|
return {}
|
|
return json.loads(value)
|
|
|
|
|
|
def _json_loads_list(value: str | None) -> list[str]:
|
|
if not value:
|
|
return []
|
|
loaded = json.loads(value)
|
|
return [str(item) for item in loaded] if isinstance(loaded, list) else []
|