350 lines
13 KiB
Python
350 lines
13 KiB
Python
import json
|
||
import logging
|
||
import uuid
|
||
from datetime import datetime, timezone
|
||
|
||
from sqlalchemy import select, func
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.models.schema_suggestion import SchemaSuggestion
|
||
from app.services.llm import LLMFactory, LLMError
|
||
from app.prompts.schema_advisor import SCHEMA_ADVISOR_TEMPLATE
|
||
from app.utils.json_extractor import extract_json
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
SCHEMA_TEMPLATES = {
|
||
"Organization": {
|
||
"@context": "https://schema.org",
|
||
"@type": "Organization",
|
||
"name": "",
|
||
"description": "",
|
||
"url": "",
|
||
"logo": "",
|
||
"sameAs": [],
|
||
"contactPoint": {
|
||
"@type": "ContactPoint",
|
||
"contactType": "customer service",
|
||
"telephone": "",
|
||
},
|
||
},
|
||
"Product": {
|
||
"@context": "https://schema.org",
|
||
"@type": "Product",
|
||
"name": "",
|
||
"description": "",
|
||
"brand": {"@type": "Brand", "name": ""},
|
||
"offers": {
|
||
"@type": "Offer",
|
||
"priceCurrency": "CNY",
|
||
"availability": "https://schema.org/InStock",
|
||
},
|
||
},
|
||
"FAQPage": {
|
||
"@context": "https://schema.org",
|
||
"@type": "FAQPage",
|
||
"mainEntity": [
|
||
{
|
||
"@type": "Question",
|
||
"name": "",
|
||
"acceptedAnswer": {
|
||
"@type": "Answer",
|
||
"text": "",
|
||
},
|
||
}
|
||
],
|
||
},
|
||
"Article": {
|
||
"@context": "https://schema.org",
|
||
"@type": "Article",
|
||
"headline": "",
|
||
"description": "",
|
||
"author": {"@type": "Organization", "name": ""},
|
||
"datePublished": "",
|
||
"image": "",
|
||
},
|
||
"LocalBusiness": {
|
||
"@context": "https://schema.org",
|
||
"@type": "LocalBusiness",
|
||
"name": "",
|
||
"address": {
|
||
"@type": "PostalAddress",
|
||
"streetAddress": "",
|
||
"addressLocality": "",
|
||
"addressRegion": "",
|
||
"postalCode": "",
|
||
"addressCountry": "CN",
|
||
},
|
||
"geo": {
|
||
"@type": "GeoCoordinates",
|
||
"latitude": "",
|
||
"longitude": "",
|
||
},
|
||
"telephone": "",
|
||
"openingHours": "",
|
||
},
|
||
}
|
||
|
||
DIMENSION_SCHEMA_MAP = {
|
||
"schema_marketing": ["Organization", "LocalBusiness"],
|
||
"entity_clarity": ["Organization", "Product"],
|
||
"citation_readiness": ["FAQPage", "Article"],
|
||
"brand_visibility": ["Organization", "Product"],
|
||
"local_seo": ["LocalBusiness"],
|
||
}
|
||
|
||
PRIORITY_THRESHOLD = {
|
||
"high": 30.0,
|
||
"medium": 60.0,
|
||
}
|
||
|
||
DIFFICULTY_MAP = {
|
||
"Organization": "easy",
|
||
"Product": "medium",
|
||
"FAQPage": "medium",
|
||
"Article": "easy",
|
||
"LocalBusiness": "hard",
|
||
}
|
||
|
||
|
||
class SchemaAdvisorService:
|
||
|
||
async def generate_suggestions(
|
||
self,
|
||
db: AsyncSession,
|
||
brand_id: uuid.UUID,
|
||
diagnosis_data: dict,
|
||
brand_info: dict,
|
||
target_url: str | None = None,
|
||
focus_dimensions: list[str] | None = None,
|
||
) -> list[SchemaSuggestion]:
|
||
missing_dimensions = self._identify_missing_dimensions(diagnosis_data, focus_dimensions)
|
||
matched = self.match_templates(missing_dimensions)
|
||
filled = await self.fill_template_with_llm(matched, brand_info)
|
||
|
||
suggestions = []
|
||
for item in filled:
|
||
validation = self.validate_json_ld(item.get("json_ld_filled") or {})
|
||
suggestion = SchemaSuggestion(
|
||
brand_id=brand_id,
|
||
schema_type=item["schema_type"],
|
||
target_url=target_url,
|
||
json_ld_template=item["json_ld_template"],
|
||
json_ld_filled=item.get("json_ld_filled"),
|
||
priority=item["priority"],
|
||
status="pending",
|
||
diagnosis_dimensions=item.get("diagnosis_dimensions"),
|
||
implementation_difficulty=DIFFICULTY_MAP.get(item["schema_type"], "medium"),
|
||
estimated_impact=item.get("estimated_impact"),
|
||
validation_errors=None if validation["is_valid"] else {"errors": validation["errors"]},
|
||
)
|
||
db.add(suggestion)
|
||
suggestions.append(suggestion)
|
||
|
||
await db.commit()
|
||
for s in suggestions:
|
||
await db.refresh(s)
|
||
return self.prioritize_suggestions(suggestions)
|
||
|
||
def match_templates(self, missing_dimensions: list[dict]) -> list[dict]:
|
||
matched = []
|
||
seen_types = set()
|
||
for dim in missing_dimensions:
|
||
schema_types = DIMENSION_SCHEMA_MAP.get(dim["dimension"], [])
|
||
for schema_type in schema_types:
|
||
if schema_type in seen_types:
|
||
continue
|
||
seen_types.add(schema_type)
|
||
template = SCHEMA_TEMPLATES.get(schema_type)
|
||
if template:
|
||
import copy
|
||
percentage = dim["percentage"]
|
||
if percentage < PRIORITY_THRESHOLD["high"]:
|
||
priority = "high"
|
||
elif percentage < PRIORITY_THRESHOLD["medium"]:
|
||
priority = "medium"
|
||
else:
|
||
priority = "low"
|
||
matched.append({
|
||
"schema_type": schema_type,
|
||
"priority": priority,
|
||
"diagnosis_dimensions": {
|
||
"dimension": dim["dimension"],
|
||
"current_score": dim["current_score"],
|
||
"max_score": dim["max_score"],
|
||
"percentage": dim["percentage"],
|
||
},
|
||
"json_ld_template": copy.deepcopy(template),
|
||
})
|
||
return matched
|
||
|
||
async def fill_template_with_llm(self, matched: list[dict], brand_info: dict) -> list[dict]:
|
||
provider = LLMFactory.get_default()
|
||
results = []
|
||
for item in matched:
|
||
schema_type = item["schema_type"]
|
||
template = item["json_ld_template"]
|
||
try:
|
||
variables = {
|
||
"brand_name": brand_info.get("name", ""),
|
||
"brand_website": brand_info.get("website", ""),
|
||
"brand_industry": brand_info.get("industry", ""),
|
||
"schema_type": schema_type,
|
||
"diagnosis_data": json.dumps(item.get("diagnosis_dimensions", {}), ensure_ascii=False),
|
||
"existing_schemas": "无",
|
||
}
|
||
messages = SCHEMA_ADVISOR_TEMPLATE.render(variables)
|
||
response = await provider.chat(
|
||
messages,
|
||
temperature=0.3,
|
||
max_tokens=2048,
|
||
)
|
||
filled = json.loads(extract_json(response.content))
|
||
item["json_ld_filled"] = filled
|
||
item["estimated_impact"] = self._generate_impact_description(
|
||
schema_type, item.get("diagnosis_dimensions", {}).get("dimension", "")
|
||
)
|
||
except (json.JSONDecodeError, LLMError, ValueError) as e:
|
||
logger.warning(f"LLM填充Schema {schema_type} 失败: {e}")
|
||
item["json_ld_filled"] = None
|
||
item["estimated_impact"] = self._generate_impact_description(
|
||
schema_type, item.get("diagnosis_dimensions", {}).get("dimension", "")
|
||
)
|
||
results.append(item)
|
||
return results
|
||
|
||
def validate_json_ld(self, json_ld: dict) -> dict:
|
||
errors = []
|
||
warnings = []
|
||
|
||
if not json_ld:
|
||
return {"is_valid": False, "errors": ["JSON-LD为空"], "warnings": []}
|
||
|
||
if "@context" not in json_ld:
|
||
errors.append("缺少@context字段")
|
||
|
||
if "@type" not in json_ld:
|
||
errors.append("缺少@type字段")
|
||
|
||
if "@context" in json_ld and json_ld["@context"] != "https://schema.org":
|
||
warnings.append(f"@context值非标准: {json_ld.get('@context')}")
|
||
|
||
if "@type" in json_ld and json_ld["@type"] not in SCHEMA_TEMPLATES:
|
||
warnings.append(f"@type非推荐类型: {json_ld.get('@type')}")
|
||
|
||
try:
|
||
json.dumps(json_ld)
|
||
except (json.JSONDecodeError, TypeError) as e:
|
||
errors.append(f"JSON序列化失败: {e}")
|
||
|
||
return {
|
||
"is_valid": len(errors) == 0,
|
||
"errors": errors,
|
||
"warnings": warnings,
|
||
}
|
||
|
||
def prioritize_suggestions(self, suggestions: list[SchemaSuggestion]) -> list[SchemaSuggestion]:
|
||
priority_order = {"high": 0, "medium": 1, "low": 2}
|
||
return sorted(suggestions, key=lambda x: priority_order.get(x.priority, 1))
|
||
|
||
async def get_suggestions(
|
||
self,
|
||
db: AsyncSession,
|
||
brand_id: uuid.UUID,
|
||
status_filter: str | None = None,
|
||
schema_type: str | None = None,
|
||
skip: int = 0,
|
||
limit: int = 20,
|
||
) -> tuple[list[SchemaSuggestion], int]:
|
||
conditions = [SchemaSuggestion.brand_id == brand_id]
|
||
if status_filter:
|
||
conditions.append(SchemaSuggestion.status == status_filter)
|
||
if schema_type:
|
||
conditions.append(SchemaSuggestion.schema_type == schema_type)
|
||
|
||
count_stmt = select(func.count()).select_from(SchemaSuggestion).where(*conditions)
|
||
count_result = await db.execute(count_stmt)
|
||
total = count_result.scalar_one()
|
||
|
||
stmt = (
|
||
select(SchemaSuggestion)
|
||
.where(*conditions)
|
||
.order_by(SchemaSuggestion.created_at.desc())
|
||
.offset(skip)
|
||
.limit(limit)
|
||
)
|
||
result = await db.execute(stmt)
|
||
suggestions = list(result.scalars().all())
|
||
return self.prioritize_suggestions(suggestions), total
|
||
|
||
async def get_suggestion_by_id(
|
||
self,
|
||
db: AsyncSession,
|
||
suggestion_id: uuid.UUID,
|
||
) -> SchemaSuggestion | None:
|
||
stmt = select(SchemaSuggestion).where(SchemaSuggestion.id == suggestion_id)
|
||
result = await db.execute(stmt)
|
||
return result.scalar_one_or_none()
|
||
|
||
async def update_status(
|
||
self,
|
||
db: AsyncSession,
|
||
suggestion_id: uuid.UUID,
|
||
new_status: str,
|
||
) -> SchemaSuggestion | None:
|
||
stmt = select(SchemaSuggestion).where(SchemaSuggestion.id == suggestion_id)
|
||
result = await db.execute(stmt)
|
||
suggestion = result.scalar_one_or_none()
|
||
if not suggestion:
|
||
return None
|
||
suggestion.status = new_status
|
||
await db.commit()
|
||
await db.refresh(suggestion)
|
||
return suggestion
|
||
|
||
def _identify_missing_dimensions(
|
||
self,
|
||
diagnosis_data: dict,
|
||
focus_dimensions: list[str] | None = None,
|
||
) -> list[dict]:
|
||
dimensions = []
|
||
dimension_scores = diagnosis_data.get("dimensions", {})
|
||
for dim_name, dim_info in dimension_scores.items():
|
||
if dim_name not in DIMENSION_SCHEMA_MAP:
|
||
continue
|
||
if focus_dimensions and dim_name not in focus_dimensions:
|
||
continue
|
||
score = dim_info.get("score", 0) if isinstance(dim_info, dict) else dim_info
|
||
max_score = dim_info.get("max_score", 100) if isinstance(dim_info, dict) else 100
|
||
percentage = (score / max_score * 100) if max_score > 0 else 0
|
||
if percentage < 80:
|
||
dimensions.append({
|
||
"dimension": dim_name,
|
||
"current_score": round(score, 2),
|
||
"max_score": max_score,
|
||
"percentage": round(percentage, 2),
|
||
})
|
||
if not dimensions and diagnosis_data:
|
||
overall = diagnosis_data.get("overall_score", 0)
|
||
if overall < 80:
|
||
for dim_name in DIMENSION_SCHEMA_MAP:
|
||
if focus_dimensions and dim_name not in focus_dimensions:
|
||
continue
|
||
dimensions.append({
|
||
"dimension": dim_name,
|
||
"current_score": 0,
|
||
"max_score": 100,
|
||
"percentage": 0,
|
||
})
|
||
return dimensions
|
||
|
||
def _generate_impact_description(self, schema_type: str, dimension: str) -> str:
|
||
impacts = {
|
||
"Organization": "增强品牌实体识别，提升AI搜索引擎对品牌的理解和引用概率",
|
||
"Product": "提升产品在搜索结果中的富摘要展示，增加点击率和引用率",
|
||
"FAQPage": "增加FAQ富摘要展示机会，提升在AI回答中的直接引用概率",
|
||
"Article": "优化文章内容的结构化表达，提升AI搜索引擎的内容理解和引用",
|
||
"LocalBusiness": "增强本地搜索可见性，提升地理位置相关查询的引用率",
|
||
}
|
||
return impacts.get(schema_type, f"提升{dimension}维度的得分和AI引用率")
|