astrbot_plugin_imagestudio/database/repositories/material_repository.py

345 行
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)}"
normalized_page = _page(page)
normalized_page_size = _page_size(page_size)
offset = (normalized_page - 1) * normalized_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 + [normalized_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 _page(value: Any) -> int:
try:
page = int(value)
except (TypeError, ValueError):
page = 1
return max(page, 1)
def _page_size(value: Any) -> int:
try:
page_size = int(value)
except (TypeError, ValueError):
page_size = 30
return min(max(page_size, 1), 100)
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 []