提交 a3abd226 authored 作者: caifuming's avatar caifuming

ljy_完成项目模块第一版

上级 c173bff4
"""Project-module AI business endpoints."""
from __future__ import annotations
import time
from typing import Any
from pydantic import AliasChoices, BaseModel, Field
from fastapi import APIRouter, HTTPException
from app.vector_store import VectorIndexService
router = APIRouter()
vector_index = VectorIndexService()
class DifficultyScoreRequest(BaseModel):
project_id: int
project_type: str = "internal"
project_name: str | None = None
difficulty_level: str | None = None
knowledge_count: int = Field(default=0, ge=0)
dependency_depth: int = Field(default=1, ge=0)
estimated_hours: int = Field(default=0, ge=0)
requires_integration: bool = False
class DifficultyScoreData(BaseModel):
ai_score: float
suggested_level: str
class DifficultyScoreResponse(BaseModel):
success: bool
data: DifficultyScoreData
class KnowledgeExtractRequest(BaseModel):
project_id: int
project_type: str = "internal"
project_name: str | None = None
difficulty_level: str | None = None
tech_stack: list[str] | None = None
tags: list[str] | None = None
knowledge_tags: list[str] | None = None
source_code_url: str | None = None
requirement_doc_url: str | None = None
project_content: str | None = None
class KnowledgePointData(BaseModel):
name: str
description: str
category: str
difficulty: str
estimated_hours: float
material_url: str | None = None
prerequisites: list[str] = Field(default_factory=list)
class KnowledgeExtractData(BaseModel):
knowledge_points: list[KnowledgePointData]
class KnowledgeExtractResponse(BaseModel):
success: bool
data: KnowledgeExtractData
class RecommendSeedProject(BaseModel):
id: int
name: str
difficulty_level: str | None = None
tech_stack: list[str] = Field(default_factory=list)
tags: list[str] = Field(default_factory=list)
class RecommendCandidate(BaseModel):
project_id: int
project_name: str
project_type: str
description: str | None = None
difficulty_level: str | None = None
tech_stack: list[str] = Field(default_factory=list)
tags: list[str] = Field(default_factory=list)
stars: int | None = None
github_url: str | None = None
class RecommendRequest(BaseModel):
project_type: str
seed_project: RecommendSeedProject
limit: int = 5
exclude_ids: list[int] = Field(default_factory=list)
candidates: list[RecommendCandidate] = Field(default_factory=list)
class RecommendItem(BaseModel):
project_id: int
project_name: str
project_type: str
github_url: str | None = None
description: str | None = None
difficulty_level: str | None = None
tech_stack: list[str] = Field(default_factory=list)
match_score: float
match_reason: str
stars: int | None = None
class RecommendData(BaseModel):
source: str
total_time: int
recommendations: list[RecommendItem]
class RecommendResponse(BaseModel):
success: bool
data: RecommendData
class EmbedDocument(BaseModel):
doc_id: str = Field(validation_alias=AliasChoices("doc_id", "docId"))
project_id: int = Field(validation_alias=AliasChoices("project_id", "projectId"))
project_type: str = Field(validation_alias=AliasChoices("project_type", "projectType"))
title: str
content: str
metadata: dict[str, Any] = Field(default_factory=dict)
class EmbedRequest(BaseModel):
action: str = "upsert"
documents: list[EmbedDocument] = Field(default_factory=list)
doc_ids: list[str] = Field(default_factory=list, validation_alias=AliasChoices("doc_ids", "docIds"))
class EmbedData(BaseModel):
backend: str
collection: str
synced_count: int
deleted_count: int
enabled: bool
fallback: bool = False
class EmbedResponse(BaseModel):
success: bool
data: EmbedData
@router.post("/difficulty/score", response_model=DifficultyScoreResponse)
async def score_difficulty(req: DifficultyScoreRequest) -> DifficultyScoreResponse:
"""Return a deterministic MVP difficulty score for project-module integration."""
base_score = {
"L1": 35.0,
"L2": 55.0,
"L3": 72.0,
"L4": 85.0,
"L5": 95.0,
}.get(req.difficulty_level or "", 65.0)
signal_score = min(req.knowledge_count * 2.5 + req.dependency_depth * 4 + req.estimated_hours * 0.4, 25.0)
integration_score = 5.0 if req.requires_integration else 0.0
ai_score = max(0.0, min(100.0, base_score + signal_score + integration_score - 10.0))
suggested_level = _level_from_score(ai_score)
return DifficultyScoreResponse(
success=True,
data=DifficultyScoreData(ai_score=round(ai_score, 2), suggested_level=suggested_level),
)
@router.post("/knowledge/extract", response_model=KnowledgeExtractResponse)
async def extract_knowledge(req: KnowledgeExtractRequest) -> KnowledgeExtractResponse:
"""Return deterministic MVP knowledge points for project-module integration."""
points: list[KnowledgePointData] = [
KnowledgePointData(
name="项目需求理解",
description="理解项目目标、业务边界、输入输出和验收要求。",
category="concept",
difficulty="easy",
estimated_hours=2.0,
prerequisites=[],
)
]
seen = {"项目需求理解"}
for tech in _clean_values(req.tech_stack)[:4]:
name = f"{tech} 实践"
if name in seen:
continue
seen.add(name)
points.append(
KnowledgePointData(
name=name,
description=f"掌握 {tech} 在该项目中的核心用法,并能完成基础集成。",
category="tool",
difficulty=_knowledge_difficulty(req.difficulty_level),
estimated_hours=4.0,
prerequisites=["项目需求理解"],
)
)
for tag in (_clean_values(req.knowledge_tags) or _clean_values(req.tags))[:5]:
if tag in seen:
continue
seen.add(tag)
points.append(
KnowledgePointData(
name=tag,
description=f"围绕项目任务学习并应用 {tag},形成可验收的实践能力。",
category="skill",
difficulty=_knowledge_difficulty(req.difficulty_level),
estimated_hours=3.0,
prerequisites=["项目需求理解"],
)
)
if len(points) == 1:
points.extend(_fallback_points(req))
return KnowledgeExtractResponse(
success=True,
data=KnowledgeExtractData(knowledge_points=points),
)
@router.post("/recommend", response_model=RecommendResponse)
async def recommend_projects(req: RecommendRequest) -> RecommendResponse:
"""Return deterministic MVP recommendations for project-module integration."""
started = time.perf_counter()
seed_tags = _clean_values(req.seed_project.tags + req.seed_project.tech_stack)
scored: list[tuple[float, RecommendItem]] = []
vector_rank = _vector_rank(req)
for candidate in req.candidates:
if candidate.project_id in set(req.exclude_ids):
continue
candidate_tags = _clean_values(candidate.tags + candidate.tech_stack)
shared = [tag for tag in candidate_tags if tag in seed_tags][:4]
overlap = len(shared)
difficulty_bonus = _difficulty_similarity(req.seed_project.difficulty_level, candidate.difficulty_level)
stars_bonus = min((candidate.stars or 0) / 5000.0, 0.15)
vector_bonus = vector_rank.get(candidate.project_id, 0.0)
# 推荐主链路:优先使用向量召回得分增强排序;没有向量结果时仍按标签/难度兜底。
score = min(0.99, 0.30 + overlap * 0.16 + difficulty_bonus * 0.30 + stars_bonus + vector_bonus * 0.22)
reason_parts = []
if vector_bonus > 0:
reason_parts.append("向量语义相似度较高")
if shared:
reason_parts.append(f"共享标签 { '、'.join(shared) }")
if candidate.difficulty_level:
reason_parts.append(f"难度 {candidate.difficulty_level}")
if not reason_parts:
reason_parts.append("与种子项目主题接近")
item = RecommendItem(
project_id=candidate.project_id,
project_name=candidate.project_name,
project_type=candidate.project_type,
github_url=candidate.github_url,
description=candidate.description,
difficulty_level=candidate.difficulty_level,
tech_stack=candidate.tech_stack,
match_score=round(score, 4),
match_reason=f"与种子项目“{req.seed_project.name}”匹配:{','.join(reason_parts)}。",
stars=candidate.stars,
)
scored.append((score, item))
recommendations = [item for _, item in sorted(scored, key=lambda pair: pair[0], reverse=True)[: max(req.limit, 1)]]
total_time = int((time.perf_counter() - started) * 1000)
source = "vector" if vector_rank else "ai"
return RecommendResponse(
success=True,
data=RecommendData(
source=source,
total_time=total_time,
recommendations=recommendations,
),
)
@router.post("/embed", response_model=EmbedResponse)
async def embed_projects(req: EmbedRequest) -> EmbedResponse:
"""Sync project vectors into Milvus or fallback memory store."""
action = (req.action or "").strip().lower()
if action == "upsert":
if not req.documents:
raise HTTPException(status_code=400, detail="documents 不能为空")
result = vector_index.upsert([document.model_dump() for document in req.documents])
elif action == "delete":
doc_ids = req.doc_ids or [document.doc_id for document in req.documents]
if not doc_ids:
raise HTTPException(status_code=400, detail="doc_ids 不能为空")
result = vector_index.delete(doc_ids)
else:
raise HTTPException(status_code=400, detail="action 仅支持 upsert/delete")
return EmbedResponse(success=True, data=EmbedData(**result))
def _level_from_score(score: float) -> str:
if score < 45:
return "L1"
if score < 65:
return "L2"
if score < 80:
return "L3"
if score < 90:
return "L4"
return "L5"
def _clean_values(values: list[str] | None) -> list[str]:
if not values:
return []
cleaned: list[str] = []
for value in values:
item = value.strip() if isinstance(value, str) else ""
if item and item not in cleaned:
cleaned.append(item)
return cleaned
def _knowledge_difficulty(level: str | None) -> str:
return {
"L1": "easy",
"L2": "easy",
"L3": "medium",
"L4": "hard",
"L5": "hard",
}.get(level or "", "medium")
def _fallback_points(req: KnowledgeExtractRequest) -> list[KnowledgePointData]:
project_name = req.project_name or "项目"
return [
KnowledgePointData(
name="方案设计与任务拆解",
description=f"围绕{project_name}拆解功能模块、数据流和实现步骤。",
category="skill",
difficulty=_knowledge_difficulty(req.difficulty_level),
estimated_hours=4.0,
prerequisites=["项目需求理解"],
),
KnowledgePointData(
name="交付验收与问题定位",
description="根据验收标准检查功能完整性,并定位实现过程中的常见问题。",
category="skill",
difficulty="medium",
estimated_hours=3.0,
prerequisites=["方案设计与任务拆解"],
),
]
def _vector_rank(req: RecommendRequest) -> dict[int, float]:
"""从向量索引召回候选项目;失败或无命中时返回空,让推荐自动回到规则兜底。"""
query_text = "\n".join(
[
req.seed_project.name,
req.seed_project.difficulty_level or "",
" ".join(_clean_values(req.seed_project.tech_stack)),
" ".join(_clean_values(req.seed_project.tags)),
]
)
exclude_doc_ids = {f"{req.project_type}:{project_id}" for project_id in req.exclude_ids}
result = vector_index.search(
query_text=query_text,
project_type=req.project_type,
exclude_doc_ids=exclude_doc_ids,
top_k=max(req.limit * 3, 10),
)
rank: dict[int, float] = {}
for index, hit in enumerate(result.get("hits", [])):
project_id = int(hit.get("project_id") or 0)
if not project_id:
continue
semantic_score = max(0.0, min(float(hit.get("score") or 0.0), 1.0))
position_bonus = max(0.0, 1.0 - index * 0.08)
rank[project_id] = max(semantic_score, position_bonus)
return rank
def _difficulty_similarity(seed_level: str | None, candidate_level: str | None) -> float:
seed_index = _level_index(seed_level)
candidate_index = _level_index(candidate_level)
return 1.0 - abs(seed_index - candidate_index) / 4.0
def _level_index(level: str | None) -> int:
return {
"L1": 0,
"L2": 1,
"L3": 2,
"L4": 3,
"L5": 4,
}.get(level or "", 2)
name: knowledge_extract_v1 name: knowledge_extract_v1
version: v1 version: v1
response_schema: knowledge_extract_response.schema.json
required_variables: required_variables:
- project_name - project_name
- project_content - project_content
system: | system: |
You extract learnable knowledge points for intern training materials. You extract learnable knowledge points for intern training materials.
Prefer structured and reviewable output over creative writing. Prefer structured and reviewable output over creative writing.
When response_format is json, return strict JSON only.
user: | user: |
Project: {project_name} Project: {project_name}
Source content: Source content:
......
"""可选 Milvus 向量索引封装。
这个模块只负责 project-module 的向量写入、删除和召回。
Milvus 不可用时自动降级到内存索引,保证推荐主流程不会因为向量库故障中断。
"""
from __future__ import annotations
import hashlib
import logging
import math
import os
from typing import Any
try:
from pymilvus import CollectionSchema, DataType, FieldSchema, MilvusClient
except Exception: # pragma: no cover - optional dependency
CollectionSchema = None
DataType = None
FieldSchema = None
MilvusClient = None
logger = logging.getLogger(__name__)
class VectorIndexService:
def __init__(self) -> None:
self.enabled = os.getenv("MILVUS_ENABLED", "false").lower() == "true"
self.host = os.getenv("MILVUS_HOST", "127.0.0.1")
self.port = os.getenv("MILVUS_PORT", "19530")
self.uri = os.getenv("MILVUS_URI", f"http://{self.host}:{self.port}")
self.collection_name = os.getenv("MILVUS_COLLECTION", "project_embeddings")
self.dimension = int(os.getenv("MILVUS_DIMENSION", "1536"))
self._client: Any | None = None
self._collection_ready = False
self._memory_store: dict[str, dict[str, Any]] = {}
def upsert(self, documents: list[dict[str, Any]]) -> dict[str, Any]:
if not documents:
return self._result(backend=self._backend_name(), synced_count=0, deleted_count=0)
if self.enabled:
try:
client = self._client_or_raise()
self._ensure_collection(client)
records = [
{
"id": str(doc["doc_id"]),
"project_id": int(doc["project_id"]),
"project_type": str(doc["project_type"]),
"title": str(doc.get("title") or ""),
"content": str(doc.get("content") or "")[:4000],
"metadata_json": self._metadata_json(doc.get("metadata")),
"embedding": self._embedding(str(doc.get("content") or "")),
}
for doc in documents
]
client.upsert(collection_name=self.collection_name, data=records)
return self._result(backend="milvus", synced_count=len(records), deleted_count=0)
except Exception as exc: # pragma: no cover - runtime integration fallback
logger.warning("Milvus upsert failed, fallback to memory store: %s", exc)
for doc in documents:
self._memory_store[str(doc["doc_id"])] = {
**doc,
"embedding": self._embedding(str(doc.get("content") or "")),
}
return self._result(backend="memory", synced_count=len(documents), deleted_count=0, fallback=True)
def delete(self, doc_ids: list[str]) -> dict[str, Any]:
if not doc_ids:
return self._result(backend=self._backend_name(), synced_count=0, deleted_count=0)
if self.enabled:
try:
client = self._client_or_raise()
self._ensure_collection(client)
client.delete(collection_name=self.collection_name, ids=[str(doc_id) for doc_id in doc_ids])
return self._result(backend="milvus", synced_count=0, deleted_count=len(doc_ids))
except Exception as exc: # pragma: no cover - runtime integration fallback
logger.warning("Milvus delete failed, fallback to memory store: %s", exc)
deleted = 0
for doc_id in doc_ids:
if self._memory_store.pop(str(doc_id), None) is not None:
deleted += 1
return self._result(backend="memory", synced_count=0, deleted_count=deleted, fallback=True)
def search(
self,
*,
query_text: str,
project_type: str,
exclude_doc_ids: set[str],
top_k: int,
) -> dict[str, Any]:
"""向量召回入口:优先查 Milvus,失败时查内存索引,均失败则返回空结果。"""
query_vector = self._embedding(query_text)
if self.enabled:
try:
client = self._client_or_raise()
self._ensure_collection(client)
results = client.search(
collection_name=self.collection_name,
data=[query_vector],
anns_field="embedding",
limit=max(top_k, 1),
filter=f'project_type == "{project_type}"',
output_fields=["id", "project_id", "project_type", "title"],
)
hits = []
for hit in (results[0] if results else []):
entity = hit.get("entity", {}) if isinstance(hit, dict) else {}
doc_id = str(entity.get("id") or hit.get("id"))
if doc_id in exclude_doc_ids:
continue
hits.append(
{
"doc_id": doc_id,
"project_id": int(entity.get("project_id") or self._project_id_from_doc_id(doc_id)),
"project_type": str(entity.get("project_type") or project_type),
"score": float(hit.get("distance") or 0.0),
"title": entity.get("title"),
}
)
return self._search_result("milvus", hits[:top_k])
except Exception as exc: # pragma: no cover - runtime integration fallback
logger.warning("Milvus search failed, fallback to memory store: %s", exc)
scored = []
for doc_id, doc in self._memory_store.items():
if doc_id in exclude_doc_ids or str(doc.get("project_type")) != project_type:
continue
score = self._cosine_similarity(query_vector, doc.get("embedding") or [])
scored.append(
{
"doc_id": doc_id,
"project_id": int(doc.get("project_id") or self._project_id_from_doc_id(doc_id)),
"project_type": str(doc.get("project_type") or project_type),
"score": score,
"title": doc.get("title"),
}
)
scored.sort(key=lambda item: item["score"], reverse=True)
return self._search_result("memory", scored[:top_k], fallback=not self.enabled)
def _client_or_raise(self) -> Any:
if MilvusClient is None or CollectionSchema is None or FieldSchema is None or DataType is None:
raise RuntimeError("pymilvus is not installed")
if self._client is None:
self._client = MilvusClient(uri=self.uri)
return self._client
def _ensure_collection(self, client: Any) -> None:
if self._collection_ready:
return
if client.has_collection(self.collection_name):
self._collection_ready = True
return
schema = CollectionSchema(
fields=[
FieldSchema(name="id", dtype=DataType.VARCHAR, max_length=128, is_primary=True, auto_id=False),
FieldSchema(name="project_id", dtype=DataType.INT64),
FieldSchema(name="project_type", dtype=DataType.VARCHAR, max_length=20),
FieldSchema(name="title", dtype=DataType.VARCHAR, max_length=200),
FieldSchema(name="content", dtype=DataType.VARCHAR, max_length=4000),
FieldSchema(name="metadata_json", dtype=DataType.VARCHAR, max_length=4000),
FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=self.dimension),
],
description="Project-module embeddings",
enable_dynamic_field=False,
)
client.create_collection(
collection_name=self.collection_name,
schema=schema,
index_params={
"index_type": "IVF_FLAT",
"metric_type": "COSINE",
"params": {"nlist": 128},
},
)
self._collection_ready = True
def _embedding(self, text: str) -> list[float]:
# MVP 阶段使用稳定哈希向量,保证无模型依赖时也能完成同步和召回链路验证。
values: list[float] = []
seed = text or "project"
nonce = 0
while len(values) < self.dimension:
digest = hashlib.sha256(f"{seed}:{nonce}".encode("utf-8")).digest()
for index in range(0, len(digest), 4):
chunk = digest[index:index + 4]
if len(chunk) < 4:
continue
number = int.from_bytes(chunk, "big", signed=False) / 4294967295.0
values.append(number * 2.0 - 1.0)
if len(values) >= self.dimension:
break
nonce += 1
norm = math.sqrt(sum(value * value for value in values)) or 1.0
return [round(value / norm, 6) for value in values]
def _result(
self,
*,
backend: str,
synced_count: int,
deleted_count: int,
fallback: bool = False,
) -> dict[str, Any]:
return {
"backend": backend,
"collection": self.collection_name,
"synced_count": synced_count,
"deleted_count": deleted_count,
"enabled": self.enabled,
"fallback": fallback,
}
def _backend_name(self) -> str:
return "milvus" if self.enabled else "memory"
def _metadata_json(self, metadata: Any) -> str:
if metadata is None:
return "{}"
text = str(metadata)
return text[:4000]
def _search_result(self, backend: str, hits: list[dict[str, Any]], fallback: bool = False) -> dict[str, Any]:
return {
"backend": backend,
"collection": self.collection_name,
"hits": hits,
"fallback": fallback,
}
def _cosine_similarity(self, left: list[float], right: list[float]) -> float:
if not left or not right:
return 0.0
size = min(len(left), len(right))
dot = sum(left[index] * right[index] for index in range(size))
left_norm = math.sqrt(sum(value * value for value in left[:size])) or 1.0
right_norm = math.sqrt(sum(value * value for value in right[:size])) or 1.0
return round(dot / (left_norm * right_norm), 6)
def _project_id_from_doc_id(self, doc_id: str) -> int:
try:
return int(doc_id.split(":", 1)[1])
except Exception:
return 0
package com.platform.backend.project.common;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ApiResponse<T> {
private int code;
private String message;
private T data;
public static <T> ApiResponse<T> success(T data) {
return new ApiResponse<>(0, "success", data);
}
public static <T> ApiResponse<T> error(String message) {
return new ApiResponse<>(1, message, null);
}
}
package com.platform.backend.project.common;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageResult<T> {
private long total;
private int page;
private int size;
private List<T> items;
}
package com.platform.backend.project.common;
public class ProjectBusinessException extends RuntimeException {
public ProjectBusinessException(String message) {
super(message);
}
}
package com.platform.backend.project.common;
import java.util.Set;
public final class ProjectConstants {
public static final Set<String> PROJECT_TYPES = Set.of("internal", "github", "annotation");
public static final Set<String> DIFFICULTY_LEVELS = Set.of("L1", "L2", "L3", "L4", "L5");
public static final Set<String> TAG_CATEGORIES = Set.of("技术", "方向", "场景");
public static final Set<String> KNOWLEDGE_CATEGORIES = Set.of("concept", "skill", "tool");
public static final Set<String> KNOWLEDGE_DIFFICULTIES = Set.of("easy", "medium", "hard");
private ProjectConstants() {
}
public static String difficultyName(String level) {
return switch (level == null ? "" : level) {
case "L1" -> "入门";
case "L2" -> "初级";
case "L3" -> "中级";
case "L4" -> "高级";
case "L5" -> "专家";
default -> "";
};
}
}
package com.platform.backend.project.common;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import java.util.stream.Collectors;
@RestControllerAdvice(basePackages = "com.platform.backend.project.controller")
public class ProjectExceptionHandler {
@ExceptionHandler(ProjectBusinessException.class)
public ResponseEntity<ApiResponse<Void>> handleBusiness(ProjectBusinessException ex) {
return ResponseEntity.badRequest().body(ApiResponse.error(ex.getMessage()));
}
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<ApiResponse<Void>> handleValidation(MethodArgumentNotValidException ex) {
String message = ex.getBindingResult().getFieldErrors().stream()
.map(error -> error.getField() + " " + error.getDefaultMessage())
.collect(Collectors.joining("; "));
return ResponseEntity.badRequest().body(ApiResponse.error(message));
}
@ExceptionHandler(AccessDeniedException.class)
public ResponseEntity<ApiResponse<Void>> handleAccessDenied(AccessDeniedException ex) {
return ResponseEntity.status(HttpStatus.FORBIDDEN).body(ApiResponse.error("无权限访问"));
}
}
package com.platform.backend.project.config;
import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.reactive.function.client.WebClient;
@Configuration
@EnableAsync
public class ProjectClientConfig {
@Bean
public WebClient aiWebClient(
WebClient.Builder builder,
@Value("${ai-service.base-url}") String baseUrl,
@Value("${ai-service.internal-token}") String internalToken
) {
return builder
.baseUrl(baseUrl)
.defaultHeader("X-Internal-Token", internalToken)
.build();
}
@Bean
public MinioClient minioClient(
@Value("${minio.endpoint}") String endpoint,
@Value("${minio.access-key}") String accessKey,
@Value("${minio.secret-key}") String secretKey
) {
return MinioClient.builder()
.endpoint(endpoint)
.credentials(accessKey, secretKey)
.build();
}
}
package com.platform.backend.project.controller;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.ApiResponse;
import com.platform.backend.project.common.PageResult;
import com.platform.backend.project.dto.DifficultyDtos;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.entity.DifficultyScore;
import com.platform.backend.project.service.DifficultyService;
import com.platform.backend.project.service.ProjectAiClientService;
import com.platform.backend.project.service.ProjectPermissionService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
@RestController
@RequestMapping("/api/v1/difficulty")
@RequiredArgsConstructor
public class DifficultyController {
private final DifficultyService difficultyService;
private final ProjectAiClientService projectAiService;
private final ProjectPermissionService accessService;
@GetMapping("/scorecard")
public ApiResponse<DifficultyDtos.ScorecardResponse> scorecard(
@RequestParam(required = false, name = "department_id") Long departmentId
) {
return ApiResponse.success(difficultyService.getScorecard(departmentId));
}
@PutMapping("/scorecard/{id}")
public ApiResponse<DifficultyDtos.ScorecardItem> updateScorecard(
@PathVariable Long id,
@Valid @RequestBody DifficultyDtos.ScorecardUpdateRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(difficultyService.updateScorecard(id, request));
}
@GetMapping("/project/{id}")
public ApiResponse<DifficultyDtos.ProjectDifficultyResponse> projectDifficulty(
@PathVariable Long id,
@RequestParam(defaultValue = "internal") String projectType
) {
return ApiResponse.success(difficultyService.getProjectDifficulty(id, projectType));
}
@PostMapping("/project/evaluate")
public ApiResponse<DifficultyScore> evaluate(
@Valid @RequestBody ProjectDtos.AiFeedbackRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN", "SUPERVISOR");
return ApiResponse.success(projectAiService.evaluateDifficulty(request.getProjectId(), request.getProjectType()));
}
@PostMapping("/calibrate")
public ApiResponse<DifficultyDtos.ProjectDifficultyResponse> calibrate(
@Valid @RequestBody DifficultyDtos.CalibrateRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "SUPERVISOR", "ADMIN");
User user = accessService.currentUser(authentication);
return ApiResponse.success(difficultyService.calibrate(request, user));
}
@GetMapping("/calibration-history")
public ApiResponse<PageResult<DifficultyDtos.CalibrationHistoryItem>> history(
@RequestParam(required = false, name = "project_id") Long projectId,
@RequestParam(required = false, name = "start_time")
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime startTime,
@RequestParam(required = false, name = "end_time")
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime endTime,
@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "10") int size,
Authentication authentication
) {
accessService.requireRole(authentication, "SUPERVISOR", "ADMIN");
return ApiResponse.success(difficultyService.history(projectId, startTime, endTime, page, size));
}
}
package com.platform.backend.project.controller;
import com.platform.backend.project.common.ApiResponse;
import com.platform.backend.project.dto.KnowledgeDtos;
import com.platform.backend.project.service.KnowledgePointService;
import com.platform.backend.project.service.ProjectPermissionService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/v1/knowledge-points")
@RequiredArgsConstructor
public class KnowledgePointController {
private final KnowledgePointService knowledgePointService;
private final ProjectPermissionService accessService;
@GetMapping
public ApiResponse<KnowledgeDtos.KnowledgeListResponse> list(
@RequestParam(name = "project_id") Long projectId,
@RequestParam(name = "project_type") String projectType,
@RequestParam(required = false) String category,
@RequestParam(required = false) String difficulty
) {
return ApiResponse.success(knowledgePointService.list(projectId, projectType, category, difficulty));
}
@PostMapping("/extract")
public ApiResponse<KnowledgeDtos.ExtractResponse> extract(
@Valid @RequestBody KnowledgeDtos.ExtractRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(knowledgePointService.extract(request));
}
@PostMapping
public ApiResponse<KnowledgeDtos.KnowledgePointItem> create(
@Valid @RequestBody KnowledgeDtos.KnowledgePointRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(knowledgePointService.create(request));
}
@PutMapping("/{id}")
public ApiResponse<KnowledgeDtos.KnowledgePointItem> update(
@PathVariable Long id,
@Valid @RequestBody KnowledgeDtos.KnowledgePointRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(knowledgePointService.update(id, request));
}
@DeleteMapping("/{id}")
public ApiResponse<Void> delete(@PathVariable Long id, Authentication authentication) {
accessService.requireRole(authentication, "ADMIN");
knowledgePointService.delete(id);
return ApiResponse.success(null);
}
}
package com.platform.backend.project.controller;
import com.platform.backend.project.common.ApiResponse;
import com.platform.backend.project.common.PageResult;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.dto.VectorSyncDtos;
import com.platform.backend.project.service.ProjectPermissionService;
import com.platform.backend.project.service.ProjectService;
import com.platform.backend.project.service.ProjectVectorSyncService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.*;
import com.platform.backend.entity.User;
import java.util.List;
@RestController
@RequestMapping("/api/v1/projects")
@RequiredArgsConstructor
public class ProjectController {
private final ProjectService projectService;
private final ProjectVectorSyncService projectVectorSyncService;
private final ProjectPermissionService accessService;
@GetMapping
public ApiResponse<PageResult<ProjectDtos.ProjectListItem>> list(
ProjectDtos.ProjectQuery query,
@RequestParam(required = false, name = "project_type") String projectType,
@RequestParam(required = false, name = "department_id") Long departmentId
) {
if (projectType != null) {
query.setProjectType(projectType);
}
if (departmentId != null) {
query.setDepartmentId(departmentId);
}
return ApiResponse.success(projectService.list(query));
}
@GetMapping("/{id}")
public ApiResponse<ProjectDtos.ProjectDetail> detail(
@PathVariable Long id,
@RequestParam String projectType,
Authentication authentication
) {
User user = accessService.currentUser(authentication);
return ApiResponse.success(projectService.detail(id, projectType, user));
}
@PostMapping
public ApiResponse<ProjectDtos.ProjectDetail> create(
@Valid @RequestBody ProjectDtos.ProjectRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(projectService.create(request));
}
@PutMapping("/{id}")
public ApiResponse<ProjectDtos.ProjectDetail> update(
@PathVariable Long id,
@Valid @RequestBody ProjectDtos.ProjectRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(projectService.update(id, request, accessService.currentUser(authentication)));
}
@DeleteMapping("/{id}")
public ApiResponse<Void> delete(
@PathVariable Long id,
@RequestParam String projectType,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
projectService.delete(id, projectType);
return ApiResponse.success(null);
}
@GetMapping("/simple")
public ApiResponse<List<ProjectDtos.ProjectSimpleItem>> simple(
ProjectDtos.ProjectSimpleQuery query,
@RequestParam(required = false, name = "project_type") String projectType,
@RequestParam(required = false, name = "department_id") Long departmentId
) {
if (projectType != null) {
query.setProjectType(projectType);
}
if (departmentId != null) {
query.setDepartmentId(departmentId);
}
return ApiResponse.success(projectService.simple(query));
}
@PostMapping("/vector-sync/full")
public ApiResponse<VectorSyncDtos.FullSyncResponse> fullVectorSync(Authentication authentication) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(projectVectorSyncService.fullSync());
}
}
package com.platform.backend.project.controller;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.ApiResponse;
import com.platform.backend.project.dto.FileDtos;
import com.platform.backend.project.service.ProjectPermissionService;
import com.platform.backend.project.service.ProjectFileService;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
@RestController
@RequestMapping("/api/v1/files")
@RequiredArgsConstructor
public class ProjectFileController {
private final ProjectFileService fileService;
private final ProjectPermissionService accessService;
@PostMapping("/upload")
public ApiResponse<FileDtos.UploadResponse> upload(
@RequestParam("file") MultipartFile file,
@RequestParam("project_id") Long projectId,
@RequestParam("project_type") String projectType,
@RequestParam("file_type") String fileType,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
User user = accessService.currentUser(authentication);
return ApiResponse.success(fileService.upload(file, projectId, projectType, fileType, user));
}
@GetMapping("/{fileId}/download-url")
public ApiResponse<FileDtos.DownloadUrlResponse> downloadUrl(
@PathVariable Long fileId,
Authentication authentication
) {
User user = accessService.currentUser(authentication);
return ApiResponse.success(fileService.downloadUrl(fileId, user));
}
}
package com.platform.backend.project.controller;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.ApiResponse;
import com.platform.backend.project.dto.RecommendationDtos;
import com.platform.backend.project.service.ProjectPermissionService;
import com.platform.backend.project.service.ProjectRecommendationService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/v1/recommendations")
@RequiredArgsConstructor
public class ProjectRecommendationController {
private final ProjectRecommendationService recommendationService;
private final ProjectPermissionService permissionService;
@PostMapping
public ApiResponse<RecommendationDtos.RecommendationResponse> recommend(
@Valid @RequestBody RecommendationDtos.RecommendationRequest request,
Authentication authentication
) {
// 需求口径要求学员可发起推荐,同时兼容库里可能仍存在的旧 USER 角色编码。
permissionService.requireRole(authentication, "STUDENT", "USER", "ADMIN");
User user = permissionService.currentUser(authentication);
return ApiResponse.success(recommendationService.recommend(request, user));
}
@PostMapping("/{projectId}/choose")
public ApiResponse<RecommendationDtos.RecommendationItem> choose(
@PathVariable Long projectId,
@Valid @RequestBody RecommendationDtos.RecommendationActionRequest request,
Authentication authentication
) {
permissionService.requireRole(authentication, "STUDENT", "USER", "ADMIN");
User user = permissionService.currentUser(authentication);
return ApiResponse.success(recommendationService.choose(projectId, request, user));
}
@PostMapping("/{projectId}/ignore")
public ApiResponse<RecommendationDtos.RecommendationItem> ignore(
@PathVariable Long projectId,
@Valid @RequestBody RecommendationDtos.RecommendationActionRequest request,
Authentication authentication
) {
permissionService.requireRole(authentication, "STUDENT", "USER", "ADMIN");
User user = permissionService.currentUser(authentication);
return ApiResponse.success(recommendationService.ignore(projectId, request, user));
}
@GetMapping("/history")
public ApiResponse<RecommendationDtos.RecommendationHistoryResponse> history(
@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "10") int size,
Authentication authentication
) {
permissionService.requireRole(authentication, "STUDENT", "USER", "ADMIN");
User user = permissionService.currentUser(authentication);
return ApiResponse.success(recommendationService.history(user, page, size));
}
}
package com.platform.backend.project.controller;
import com.platform.backend.project.common.ApiResponse;
import com.platform.backend.project.dto.TagDtos;
import com.platform.backend.project.service.ProjectPermissionService;
import com.platform.backend.project.service.TagService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/v1/tags")
@RequiredArgsConstructor
public class TagController {
private final TagService tagService;
private final ProjectPermissionService accessService;
@GetMapping
public ApiResponse<TagDtos.TagListResponse> list(@RequestParam(required = false) String category) {
return ApiResponse.success(tagService.list(category));
}
@PostMapping
public ApiResponse<TagDtos.TagItem> create(
@Valid @RequestBody TagDtos.TagRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(tagService.create(request));
}
@PutMapping("/{id}")
public ApiResponse<TagDtos.TagItem> update(
@PathVariable Long id,
@Valid @RequestBody TagDtos.TagRequest request,
Authentication authentication
) {
accessService.requireRole(authentication, "ADMIN");
return ApiResponse.success(tagService.update(id, request));
}
@DeleteMapping("/{id}")
public ApiResponse<Void> delete(@PathVariable Long id, Authentication authentication) {
accessService.requireRole(authentication, "ADMIN");
tagService.delete(id);
return ApiResponse.success(null);
}
}
package com.platform.backend.project.dto;
import jakarta.validation.constraints.DecimalMax;
import jakarta.validation.constraints.DecimalMin;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
public final class DifficultyDtos {
private DifficultyDtos() {
}
@Data
public static class ScorecardResponse {
private Long departmentId;
private String departmentName;
private List<ScorecardItem> dimensions;
}
@Data
public static class ScorecardItem {
private Long id;
private String dimensionName;
private BigDecimal weight;
}
@Data
public static class ScorecardUpdateRequest {
@NotBlank
private String dimensionName;
@NotNull
@DecimalMin("0.00")
@DecimalMax("1.00")
private BigDecimal weight;
}
@Data
public static class ProjectDifficultyResponse {
private Long projectId;
private String projectName;
private BigDecimal aiScore;
private String aiSuggestedLevel;
private String calibratedLevel;
private String calibrationStatus;
private Long anchorProjectId;
private String anchorProjectName;
private String anchorProjectType;
private String anchorLevel;
private String anchorText;
private List<CalibrationHistoryItem> calibrationHistory;
}
@Data
public static class CalibrateRequest {
@NotNull
private Long projectId;
@NotBlank
private String projectType;
@NotBlank
private String newLevel;
private String reason;
}
@Data
public static class CalibrationHistoryItem {
private Long id;
private Long projectId;
private String projectName;
private String previousLevel;
private String newLevel;
private String reason;
private String calibratedBy;
private LocalDateTime calibratedAt;
}
}
package com.platform.backend.project.dto;
import lombok.Data;
public final class FileDtos {
private FileDtos() {
}
@Data
public static class UploadResponse {
private Long fileId;
private String fileName;
private String fileUrl;
}
@Data
public static class DownloadUrlResponse {
private String url;
private int expiresMinutes;
}
}
package com.platform.backend.project.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
public final class KnowledgeDtos {
private KnowledgeDtos() {
}
@Data
public static class KnowledgeListResponse {
private Long projectId;
private String projectType;
private int totalCount;
private List<KnowledgePointItem> knowledgePoints;
}
@Data
public static class KnowledgePointItem {
private Long id;
private Long projectId;
private String projectType;
private String name;
private String description;
private String category;
private String difficulty;
private BigDecimal estimatedHours;
private String materialUrl;
private List<KnowledgePointRef> prerequisites;
private List<KnowledgePointRef> dependents;
private LocalDateTime createdAt;
}
@Data
public static class KnowledgePointRef {
private Long id;
private String name;
}
@Data
public static class KnowledgePointRequest {
@NotNull
private Long projectId;
@NotBlank
private String projectType;
@NotBlank
private String name;
private String description;
@NotBlank
private String category;
@NotBlank
private String difficulty;
private BigDecimal estimatedHours;
private String materialUrl;
private List<Long> prerequisiteIds;
}
@Data
public static class ExtractRequest {
@NotNull
private Long projectId;
@NotBlank
private String projectType;
}
@Data
public static class ExtractResponse {
private boolean accepted;
private String message;
private int totalCount;
private List<KnowledgePointItem> knowledgePoints;
}
}
package com.platform.backend.project.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
public final class ProjectDtos {
private ProjectDtos() {
}
@Data
public static class ProjectRequest {
@NotBlank
private String name;
private String description;
@NotBlank
private String projectType;
private Long departmentId;
private String departmentName;
private List<String> techStack;
private String annotationType;
private String businessDomain;
@NotBlank
private String difficultyLevel;
private List<String> knowledgeTags;
private String sourceCodeUrl;
private String requirementDocUrl;
private String acceptanceReportUrl;
private Integer status = 1;
private String githubUrl;
private Integer stars;
private String industry;
}
@Data
public static class ProjectListItem {
private Long id;
private String name;
private String description;
private String projectType;
private String difficultyLevel;
private String difficultyName;
private String departmentName;
private List<String> tags;
private Long viewCount;
private Long choiceCount;
private Integer status;
private LocalDateTime createdAt;
}
@Data
public static class ProjectDetail {
private Long id;
private String name;
private String description;
private String projectType;
private String difficultyLevel;
private String difficultyName;
private Long departmentId;
private String departmentName;
private List<String> techStack;
private String annotationType;
private String businessDomain;
private List<String> knowledgeTags;
private String sourceCodeUrl;
private String requirementDocUrl;
private String acceptanceReportUrl;
private String githubUrl;
private String industry;
private Integer stars;
private List<String> tags;
private List<ProjectAttachmentItem> attachments;
private List<KnowledgePointItem> knowledgePoints;
private Long viewCount;
private Long choiceCount;
private Integer status;
private LocalDateTime createdAt;
}
@Data
public static class ProjectSimpleItem {
private Long id;
private String name;
private String difficultyLevel;
}
@Data
public static class ProjectAttachmentItem {
private Long id;
private String fileName;
private String fileUrl;
private String fileType;
}
@Data
public static class KnowledgePointItem {
private Long id;
private String name;
private String difficulty;
private Double estimatedHours;
private String materialUrl;
}
@Data
public static class ProjectQuery {
private int page = 1;
private int size = 10;
private String keyword;
private String projectType;
private Long departmentId;
private String difficulty;
private String tag;
private String tagMode = "OR";
private String sort = "newest";
private String order = "desc";
}
@Data
public static class ProjectSimpleQuery {
private String keyword;
private String projectType;
private String difficulty;
private Long departmentId;
}
@Data
public static class AiFeedbackRequest {
@NotNull
private Long projectId;
@NotBlank
private String projectType;
}
}
package com.platform.backend.project.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
public final class RecommendationDtos {
private RecommendationDtos() {
}
@Data
public static class RecommendationRequest {
@NotBlank
private String projectType;
@NotNull
private Long seedProjectId;
private Integer limit = 5;
private List<Long> excludeProjectIds;
}
@Data
public static class RecommendationResponse {
private String source;
private Integer totalTime;
private List<RecommendationItem> recommendations;
}
@Data
public static class RecommendationItem {
private Long recommendationId;
private Long projectId;
private String projectName;
private String projectType;
private String githubUrl;
private String description;
private String difficultyLevel;
private List<String> techStack;
private BigDecimal matchScore;
private String matchReason;
private Integer stars;
}
@Data
public static class RecommendationActionRequest {
private Long recommendationId;
@NotBlank
private String projectType;
}
@Data
public static class RecommendationHistoryItem {
private Long recommendationId;
private Long seedProjectId;
private String seedProjectName;
private Long projectId;
private String projectName;
private String projectType;
private BigDecimal matchScore;
private String matchReason;
private String source;
private String userAction;
private LocalDateTime createdAt;
private LocalDateTime actionAt;
}
@Data
public static class RecommendationHistoryResponse {
private long total;
private int page;
private int size;
private List<RecommendationHistoryItem> items;
}
}
package com.platform.backend.project.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
import java.util.List;
import java.util.Map;
public final class TagDtos {
private TagDtos() {
}
@Data
public static class TagRequest {
@NotBlank
private String name;
@NotBlank
private String category;
@NotBlank
@Pattern(regexp = "^#[0-9a-fA-F]{6}$")
private String color;
}
@Data
public static class TagItem {
private Long id;
private String name;
private String category;
private String color;
}
@Data
public static class TagListResponse {
private Map<String, List<TagItem>> categories;
private List<TagItem> flatList;
}
}
package com.platform.backend.project.dto;
import lombok.Data;
import java.util.List;
public final class VectorSyncDtos {
private VectorSyncDtos() {
}
@Data
public static class FullSyncResponse {
private int total;
private int successCount;
private int failedCount;
private List<SyncItem> items;
}
@Data
public static class SyncItem {
private Long projectId;
private String projectType;
private String projectName;
private boolean success;
private String backend;
private String collection;
private String errorMessage;
}
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Entity
@Table(name = "proj_annotation_project")
@Data
public class AnnotationProject {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 200)
private String name;
@Column(length = 100)
private String industry;
@Column(length = 100)
private String annotationType;
@Column(length = 10)
private String difficultyLevel;
@Column(precision = 5, scale = 4)
private BigDecimal matchScore;
private Integer status = 1;
private Boolean isDeleted = false;
private Long viewCount = 0L;
private Long choiceCount = 0L;
private LocalDateTime createdAt = LocalDateTime.now();
private LocalDateTime updatedAt = LocalDateTime.now();
@PreUpdate
public void preUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Entity
@Table(name = "proj_difficulty_calibration")
@Data
public class DifficultyCalibration {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private Long scoreId;
private Long projectId;
@Column(length = 20)
private String projectType;
@Column(length = 200)
private String projectName;
@Column(length = 10)
private String previousLevel;
@Column(nullable = false, length = 10)
private String newLevel;
@Column(length = 500)
private String reason;
private Long calibrationBy;
@Column(length = 100)
private String calibrationByName;
private LocalDateTime calibratedAt = LocalDateTime.now();
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Entity
@Table(name = "proj_difficulty_score")
@Data
public class DifficultyScore {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private Long projectId;
@Column(length = 20)
private String projectType;
@Column(precision = 5, scale = 2)
private BigDecimal aiScore;
@Column(length = 10)
private String aiSuggestedLevel;
@Column(length = 10)
private String calibratedLevel;
@Column(length = 20)
private String calibrationStatus = "pending";
private LocalDateTime createdAt = LocalDateTime.now();
private LocalDateTime updatedAt = LocalDateTime.now();
@PreUpdate
public void preUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.math.BigDecimal;
@Entity
@Table(name = "proj_difficulty_scorecard")
@Data
public class DifficultyScorecard {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private Long departmentId;
@Column(length = 100)
private String departmentName;
@Column(nullable = false, length = 100)
private String dimensionName;
@Column(nullable = false, precision = 3, scale = 2)
private BigDecimal weight;
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Entity
@Table(name = "proj_github_project")
@Data
public class GithubProject {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private Long seedProjectId;
@Column(nullable = false, length = 500)
private String githubUrl;
@Column(length = 200)
private String repoName;
@Column(length = 1000)
private String techStack;
@Column(columnDefinition = "TEXT")
private String description;
@Column(length = 10)
private String difficultyLevel;
private Integer stars;
@Column(precision = 5, scale = 4)
private BigDecimal matchScore;
@Column(columnDefinition = "TEXT")
private String matchReason;
private Integer status = 1;
private Boolean isDeleted = false;
private Long viewCount = 0L;
private Long choiceCount = 0L;
private LocalDateTime createdAt = LocalDateTime.now();
private LocalDateTime updatedAt = LocalDateTime.now();
@PreUpdate
public void preUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Entity
@Table(name = "proj_internal_project")
@Data
public class InternalProject {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 200)
private String name;
@Column(columnDefinition = "TEXT")
private String description;
private Long departmentId;
@Column(length = 100)
private String departmentName;
@Column(length = 1000)
private String techStack;
@Column(length = 100)
private String annotationType;
@Column(length = 100)
private String businessDomain;
@Column(length = 10)
private String difficultyLevel;
@Column(length = 1000)
private String knowledgeTags;
@Column(length = 500)
private String sourceCodeUrl;
@Column(length = 500)
private String requirementDocUrl;
@Column(length = 500)
private String acceptanceReportUrl;
private Integer status = 0;
private Boolean isDeleted = false;
private Long viewCount = 0L;
private Long choiceCount = 0L;
private LocalDateTime createdAt = LocalDateTime.now();
private LocalDateTime updatedAt = LocalDateTime.now();
@PreUpdate
public void preUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
@Entity
@Table(
name = "kp_knowledge_dependency",
uniqueConstraints = @UniqueConstraint(columnNames = {"knowledgeId", "prerequisiteId"})
)
@Data
public class KnowledgeDependency {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private Long knowledgeId;
@Column(nullable = false)
private Long prerequisiteId;
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Entity
@Table(name = "kp_knowledge_point")
@Data
public class KnowledgePoint {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private Long projectId;
@Column(nullable = false, length = 20)
private String projectType;
@Column(nullable = false, length = 200)
private String name;
@Column(columnDefinition = "TEXT")
private String description;
@Column(length = 50)
private String category;
@Column(length = 10)
private String difficulty;
@Column(precision = 4, scale = 1)
private BigDecimal estimatedHours;
@Column(length = 500)
private String materialUrl;
private LocalDateTime createdAt = LocalDateTime.now();
private LocalDateTime updatedAt = LocalDateTime.now();
@PreUpdate
public void preUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Entity
@Table(name = "proj_ai_call_log")
@Data
public class ProjectAiCallLog {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private Long projectId;
@Column(length = 20)
private String projectType;
@Column(length = 50)
private String taskType;
private Boolean success;
@Column(length = 50)
private String errorCode;
@Column(length = 500)
private String errorMessage;
@Column(columnDefinition = "TEXT")
private String responseBody;
private LocalDateTime createdAt = LocalDateTime.now();
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Entity
@Table(name = "proj_project_attachment")
@Data
public class ProjectAttachment {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private Long projectId;
@Column(length = 20)
private String projectType;
@Column(nullable = false, length = 200)
private String fileName;
@Column(length = 500)
private String fileUrl;
@Column(length = 50)
private String fileType;
private Long uploadedBy;
private LocalDateTime createdAt = LocalDateTime.now();
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
@Entity
@Table(
name = "proj_project_tag",
uniqueConstraints = @UniqueConstraint(columnNames = {"projectId", "projectType", "tagName"})
)
@Data
public class ProjectTag {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private Long projectId;
@Column(nullable = false, length = 20)
private String projectType;
private Long tagId;
@Column(nullable = false, length = 50)
private String tagName;
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Entity
@Table(name = "proj_tag", uniqueConstraints = @UniqueConstraint(columnNames = {"name"}))
@Data
public class Tag {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 50)
private String name;
@Column(nullable = false, length = 20)
private String category;
@Column(nullable = false, length = 7)
private String color;
private LocalDateTime createdAt = LocalDateTime.now();
private LocalDateTime updatedAt = LocalDateTime.now();
@PreUpdate
public void preUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Entity
@Table(name = "train_advanced_match")
@Data
public class TrainAdvancedMatch {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private Long taskId;
private Long userId;
private Long seedProjectId;
@Column(length = 20)
private String seedProjectType;
@Column(length = 200)
private String seedProjectName;
private Long projectId;
@Column(length = 20)
private String projectType;
@Column(length = 200)
private String projectName;
@Column(precision = 5, scale = 4)
private BigDecimal matchScore;
@Column(columnDefinition = "TEXT")
private String matchReason;
@Column(length = 20)
private String source;
@Column(length = 20)
private String userAction = "pending";
private LocalDateTime actionAt;
private LocalDateTime createdAt = LocalDateTime.now();
private LocalDateTime updatedAt = LocalDateTime.now();
@PreUpdate
public void preUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Entity
@Table(name = "train_preview_record")
@Data
public class TrainPreviewRecord {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private Long taskId;
@Column(nullable = false)
private Long knowledgeId;
@Column(nullable = false, length = 20)
private String status = "pending";
private LocalDateTime completedAt;
private LocalDateTime createdAt = LocalDateTime.now();
}
package com.platform.backend.project.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Entity
@Table(name = "train_task")
@Data
public class TrainTask {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private Long userId;
@Column(nullable = false, length = 20)
private String projectType;
@Column(nullable = false)
private Long projectId;
@Column(length = 200)
private String projectName;
@Column(length = 10)
private String difficultyLevel;
private Integer cycleNumber = 1;
@Column(nullable = false, length = 20)
private String status = "preview";
private Long mentorId;
@Column(length = 100)
private String mentorName;
@Column(length = 100)
private String containerId;
@Column(length = 500)
private String codeServerUrl;
private LocalDateTime previewCompletedAt;
private LocalDateTime practiceSubmittedAt;
private LocalDateTime defenseAppliedAt;
private LocalDateTime defenseCompletedAt;
private LocalDateTime reviewedAt;
private LocalDateTime createdAt = LocalDateTime.now();
private LocalDateTime updatedAt = LocalDateTime.now();
@PreUpdate
public void preUpdate() {
this.updatedAt = LocalDateTime.now();
}
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.AnnotationProject;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface AnnotationProjectRepository extends JpaRepository<AnnotationProject, Long>, JpaSpecificationExecutor<AnnotationProject> {
boolean existsByNameAndIsDeletedFalse(String name);
boolean existsByNameAndIdNotAndIsDeletedFalse(String name, Long id);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.DifficultyCalibration;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import java.time.LocalDateTime;
import java.util.List;
public interface DifficultyCalibrationRepository extends JpaRepository<DifficultyCalibration, Long> {
List<DifficultyCalibration> findTop20ByProjectIdAndProjectTypeOrderByCalibratedAtDesc(Long projectId, String projectType);
Page<DifficultyCalibration> findByProjectIdAndCalibratedAtBetween(Long projectId, LocalDateTime start, LocalDateTime end, Pageable pageable);
Page<DifficultyCalibration> findByCalibratedAtBetween(LocalDateTime start, LocalDateTime end, Pageable pageable);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.DifficultyScore;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;
public interface DifficultyScoreRepository extends JpaRepository<DifficultyScore, Long> {
Optional<DifficultyScore> findByProjectIdAndProjectType(Long projectId, String projectType);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.DifficultyScorecard;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface DifficultyScorecardRepository extends JpaRepository<DifficultyScorecard, Long> {
List<DifficultyScorecard> findByDepartmentId(Long departmentId);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.GithubProject;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface GithubProjectRepository extends JpaRepository<GithubProject, Long>, JpaSpecificationExecutor<GithubProject> {
boolean existsByGithubUrlAndIsDeletedFalse(String githubUrl);
boolean existsByGithubUrlAndIdNotAndIsDeletedFalse(String githubUrl, Long id);
boolean existsByRepoNameAndIsDeletedFalse(String repoName);
boolean existsByRepoNameAndIdNotAndIsDeletedFalse(String repoName, Long id);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.InternalProject;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface InternalProjectRepository extends JpaRepository<InternalProject, Long>, JpaSpecificationExecutor<InternalProject> {
boolean existsByNameAndIsDeletedFalse(String name);
boolean existsByNameAndIdNotAndIsDeletedFalse(String name, Long id);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.KnowledgeDependency;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Collection;
import java.util.List;
public interface KnowledgeDependencyRepository extends JpaRepository<KnowledgeDependency, Long> {
List<KnowledgeDependency> findByKnowledgeIdInOrPrerequisiteIdIn(Collection<Long> knowledgeIds, Collection<Long> prerequisiteIds);
void deleteByKnowledgeId(Long knowledgeId);
void deleteByPrerequisiteId(Long prerequisiteId);
boolean existsByKnowledgeIdAndPrerequisiteId(Long knowledgeId, Long prerequisiteId);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.KnowledgePoint;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Collection;
import java.util.List;
public interface KnowledgePointRepository extends JpaRepository<KnowledgePoint, Long> {
List<KnowledgePoint> findByProjectIdAndProjectType(Long projectId, String projectType);
List<KnowledgePoint> findByProjectIdAndProjectTypeAndCategory(Long projectId, String projectType, String category);
List<KnowledgePoint> findByProjectIdAndProjectTypeAndDifficulty(Long projectId, String projectType, String difficulty);
List<KnowledgePoint> findByIdIn(Collection<Long> ids);
void deleteByProjectIdAndProjectType(Long projectId, String projectType);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.ProjectAiCallLog;
import org.springframework.data.jpa.repository.JpaRepository;
public interface ProjectAiCallLogRepository extends JpaRepository<ProjectAiCallLog, Long> {
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.ProjectAttachment;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface ProjectAttachmentRepository extends JpaRepository<ProjectAttachment, Long> {
List<ProjectAttachment> findByProjectIdAndProjectType(Long projectId, String projectType);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.ProjectTag;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface ProjectTagRepository extends JpaRepository<ProjectTag, Long> {
List<ProjectTag> findByProjectIdAndProjectType(Long projectId, String projectType);
List<ProjectTag> findByProjectTypeAndTagNameIn(String projectType, List<String> tagNames);
long countByTagName(String tagName);
void deleteByProjectIdAndProjectType(Long projectId, String projectType);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.Tag;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
import java.util.Optional;
public interface TagRepository extends JpaRepository<Tag, Long> {
boolean existsByName(String name);
boolean existsByNameAndIdNot(String name, Long id);
Optional<Tag> findByName(String name);
List<Tag> findByCategory(String category);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.TrainAdvancedMatch;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
import java.util.Optional;
public interface TrainAdvancedMatchRepository extends JpaRepository<TrainAdvancedMatch, Long> {
List<TrainAdvancedMatch> findByUserIdAndSeedProjectIdAndSeedProjectTypeOrderByCreatedAtDesc(
Long userId, Long seedProjectId, String seedProjectType);
Optional<TrainAdvancedMatch> findFirstByUserIdAndProjectIdAndProjectTypeOrderByCreatedAtDesc(
Long userId, Long projectId, String projectType);
Optional<TrainAdvancedMatch> findByIdAndUserId(Long id, Long userId);
Page<TrainAdvancedMatch> findByUserIdOrderByCreatedAtDesc(Long userId, Pageable pageable);
boolean existsByProjectIdAndProjectTypeAndUserAction(Long projectId, String projectType, String userAction);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.TrainPreviewRecord;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface TrainPreviewRecordRepository extends JpaRepository<TrainPreviewRecord, Long> {
List<TrainPreviewRecord> findByTaskIdOrderByIdAsc(Long taskId);
}
package com.platform.backend.project.repository;
import com.platform.backend.project.entity.TrainTask;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;
public interface TrainTaskRepository extends JpaRepository<TrainTask, Long> {
Optional<TrainTask> findTopByUserIdAndProjectIdAndProjectTypeOrderByCycleNumberDesc(
Long userId,
Long projectId,
String projectType
);
boolean existsByProjectIdAndProjectType(Long projectId, String projectType);
}
package com.platform.backend.project.service;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.PageResult;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.common.ProjectConstants;
import com.platform.backend.project.dto.DifficultyDtos;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.entity.DifficultyCalibration;
import com.platform.backend.project.entity.DifficultyScore;
import com.platform.backend.project.entity.DifficultyScorecard;
import com.platform.backend.project.repository.DifficultyCalibrationRepository;
import com.platform.backend.project.repository.DifficultyScoreRepository;
import com.platform.backend.project.repository.DifficultyScorecardRepository;
import com.platform.backend.project.repository.GithubProjectRepository;
import com.platform.backend.project.repository.InternalProjectRepository;
import com.platform.backend.project.repository.AnnotationProjectRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
@Service
@RequiredArgsConstructor
public class DifficultyService {
private final DifficultyScorecardRepository scorecardRepository;
private final DifficultyScoreRepository scoreRepository;
private final DifficultyCalibrationRepository calibrationRepository;
private final ProjectService projectService;
private final ProjectAiClientService projectAiService;
private final InternalProjectRepository internalProjectRepository;
private final GithubProjectRepository githubProjectRepository;
private final AnnotationProjectRepository annotationProjectRepository;
@Transactional
public DifficultyDtos.ScorecardResponse getScorecard(Long departmentId) {
Long resolvedDepartmentId = departmentId == null ? 1L : departmentId;
ensureDefaultScorecard(resolvedDepartmentId);
List<DifficultyScorecard> scorecards = scorecardRepository.findByDepartmentId(resolvedDepartmentId);
DifficultyDtos.ScorecardResponse response = new DifficultyDtos.ScorecardResponse();
response.setDepartmentId(resolvedDepartmentId);
response.setDepartmentName(scorecards.isEmpty() ? null : scorecards.get(0).getDepartmentName());
response.setDimensions(scorecards.stream().map(this::toScorecardItem).toList());
return response;
}
@Transactional
public DifficultyDtos.ScorecardItem updateScorecard(Long id, DifficultyDtos.ScorecardUpdateRequest request) {
DifficultyScorecard scorecard = scorecardRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("打分卡维度不存在"));
BigDecimal oldWeight = scorecard.getWeight();
scorecard.setDimensionName(request.getDimensionName());
scorecard.setWeight(request.getWeight());
List<DifficultyScorecard> dimensions = scorecardRepository.findByDepartmentId(scorecard.getDepartmentId());
BigDecimal total = dimensions.stream()
.map(dimension -> dimension.getId().equals(id) ? request.getWeight() : dimension.getWeight())
.reduce(BigDecimal.ZERO, BigDecimal::add);
if (total.compareTo(BigDecimal.ONE) != 0) {
scorecard.setWeight(oldWeight);
throw new ProjectBusinessException("权重总和必须等于 1.00");
}
return toScorecardItem(scorecardRepository.save(scorecard));
}
@Transactional
public DifficultyDtos.ProjectDifficultyResponse getProjectDifficulty(Long projectId, String projectType) {
String resolvedType = projectType == null || projectType.isBlank() ? "internal" : projectType;
ProjectDtos.ProjectDetail project = projectService.getDetailWithoutViewIncrement(projectId, resolvedType);
DifficultyScore score = scoreRepository.findByProjectIdAndProjectType(projectId, resolvedType)
.orElseGet(() -> projectAiService.evaluateDifficulty(projectId, resolvedType));
return toProjectDifficulty(project, score);
}
@Transactional
public DifficultyDtos.ProjectDifficultyResponse calibrate(DifficultyDtos.CalibrateRequest request, User user) {
if (!ProjectConstants.DIFFICULTY_LEVELS.contains(request.getNewLevel())) {
throw new ProjectBusinessException("newLevel 仅接受 L1~L5");
}
ProjectDtos.ProjectDetail project = projectService.getDetailWithoutViewIncrement(
request.getProjectId(), request.getProjectType());
DifficultyScore score = scoreRepository.findByProjectIdAndProjectType(
request.getProjectId(), request.getProjectType())
.orElseGet(() -> {
DifficultyScore created = new DifficultyScore();
created.setProjectId(request.getProjectId());
created.setProjectType(request.getProjectType());
created.setAiSuggestedLevel(project.getDifficultyLevel());
created.setCalibratedLevel(project.getDifficultyLevel());
created.setCalibrationStatus("pending");
return scoreRepository.save(created);
});
String previousLevel = score.getCalibratedLevel();
score.setCalibratedLevel(request.getNewLevel());
score.setCalibrationStatus("confirmed");
scoreRepository.save(score);
DifficultyCalibration calibration = new DifficultyCalibration();
calibration.setScoreId(score.getId());
calibration.setProjectId(request.getProjectId());
calibration.setProjectType(request.getProjectType());
calibration.setProjectName(project.getName());
calibration.setPreviousLevel(previousLevel);
calibration.setNewLevel(request.getNewLevel());
calibration.setReason(request.getReason());
calibration.setCalibrationBy(user.getId());
calibration.setCalibrationByName(user.getRealName() == null ? user.getUsername() : user.getRealName());
calibrationRepository.save(calibration);
return toProjectDifficulty(project, score);
}
public PageResult<DifficultyDtos.CalibrationHistoryItem> history(
Long projectId,
LocalDateTime startTime,
LocalDateTime endTime,
int page,
int size
) {
LocalDateTime start = startTime == null ? LocalDateTime.of(1970, 1, 1, 0, 0) : startTime;
LocalDateTime end = endTime == null ? LocalDateTime.now().plusYears(1) : endTime;
PageRequest pageRequest = PageRequest.of(Math.max(0, page - 1), Math.max(1, Math.min(size, 100)));
Page<DifficultyCalibration> result = projectId == null
? calibrationRepository.findByCalibratedAtBetween(start, end, pageRequest)
: calibrationRepository.findByProjectIdAndCalibratedAtBetween(projectId, start, end, pageRequest);
return new PageResult<>(
result.getTotalElements(),
page,
size,
result.getContent().stream().map(this::toHistoryItem).toList()
);
}
private DifficultyDtos.ProjectDifficultyResponse toProjectDifficulty(ProjectDtos.ProjectDetail project, DifficultyScore score) {
DifficultyDtos.ProjectDifficultyResponse response = new DifficultyDtos.ProjectDifficultyResponse();
response.setProjectId(project.getId());
response.setProjectName(project.getName());
response.setAiScore(score.getAiScore());
response.setAiSuggestedLevel(score.getAiSuggestedLevel());
response.setCalibratedLevel(score.getCalibratedLevel());
response.setCalibrationStatus(score.getCalibrationStatus());
response.setCalibrationHistory(calibrationRepository
.findTop20ByProjectIdAndProjectTypeOrderByCalibratedAtDesc(project.getId(), project.getProjectType())
.stream().map(this::toHistoryItem).toList());
fillAnchorProject(response, project, score);
return response;
}
/**
* 返回一个同等级的参照项目,方便前端展示“与某个已定级项目难度相当”的锚点信息。
*/
private void fillAnchorProject(
DifficultyDtos.ProjectDifficultyResponse response,
ProjectDtos.ProjectDetail project,
DifficultyScore score
) {
String targetLevel = score.getCalibratedLevel() == null || score.getCalibratedLevel().isBlank()
? score.getAiSuggestedLevel()
: score.getCalibratedLevel();
if (targetLevel == null || targetLevel.isBlank()) {
return;
}
AnchorProject anchor = resolveAnchorProject(project.getId(), project.getProjectType(), targetLevel);
if (anchor == null) {
return;
}
response.setAnchorProjectId(anchor.projectId());
response.setAnchorProjectName(anchor.projectName());
response.setAnchorProjectType(anchor.projectType());
response.setAnchorLevel(targetLevel);
response.setAnchorText("与 " + targetLevel + " 项目 " + anchor.projectName() + " 难度相当");
}
private AnchorProject resolveAnchorProject(Long projectId, String projectType, String targetLevel) {
for (DifficultyScore candidate : scoreRepository.findAll()) {
if (projectId.equals(candidate.getProjectId()) && projectType.equals(candidate.getProjectType())) {
continue;
}
String candidateLevel = candidate.getCalibratedLevel() == null || candidate.getCalibratedLevel().isBlank()
? candidate.getAiSuggestedLevel()
: candidate.getCalibratedLevel();
if (!targetLevel.equals(candidateLevel)) {
continue;
}
ProjectDtos.ProjectDetail detail = safeLoadProject(candidate.getProjectId(), candidate.getProjectType());
if (detail != null) {
return new AnchorProject(detail.getId(), detail.getName(), detail.getProjectType());
}
}
return fallbackAnchorByProjectLevel(projectId, projectType, targetLevel);
}
private AnchorProject fallbackAnchorByProjectLevel(Long projectId, String projectType, String targetLevel) {
AnchorProject internalAnchor = internalProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.filter(project -> !Objects.equals(project.getId(), projectId) || !"internal".equals(projectType))
.filter(project -> targetLevel.equals(project.getDifficultyLevel()))
.findFirst()
.map(project -> new AnchorProject(project.getId(), project.getName(), "internal"))
.orElse(null);
if (internalAnchor != null) {
return internalAnchor;
}
AnchorProject githubAnchor = githubProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.filter(project -> !Objects.equals(project.getId(), projectId) || !"github".equals(projectType))
.filter(project -> targetLevel.equals(project.getDifficultyLevel()))
.findFirst()
.map(project -> new AnchorProject(project.getId(), project.getRepoName(), "github"))
.orElse(null);
if (githubAnchor != null) {
return githubAnchor;
}
return annotationProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.filter(project -> !Objects.equals(project.getId(), projectId) || !"annotation".equals(projectType))
.filter(project -> targetLevel.equals(project.getDifficultyLevel()))
.findFirst()
.map(project -> new AnchorProject(project.getId(), project.getName(), "annotation"))
.orElse(null);
}
private ProjectDtos.ProjectDetail safeLoadProject(Long projectId, String projectType) {
try {
return projectService.getDetailWithoutViewIncrement(projectId, projectType);
} catch (ProjectBusinessException ex) {
return null;
}
}
private record AnchorProject(Long projectId, String projectName, String projectType) {
}
private DifficultyDtos.ScorecardItem toScorecardItem(DifficultyScorecard scorecard) {
DifficultyDtos.ScorecardItem item = new DifficultyDtos.ScorecardItem();
item.setId(scorecard.getId());
item.setDimensionName(scorecard.getDimensionName());
item.setWeight(scorecard.getWeight());
return item;
}
private DifficultyDtos.CalibrationHistoryItem toHistoryItem(DifficultyCalibration calibration) {
DifficultyDtos.CalibrationHistoryItem item = new DifficultyDtos.CalibrationHistoryItem();
item.setId(calibration.getId());
item.setProjectId(calibration.getProjectId());
item.setProjectName(calibration.getProjectName());
item.setPreviousLevel(calibration.getPreviousLevel());
item.setNewLevel(calibration.getNewLevel());
item.setReason(calibration.getReason());
item.setCalibratedBy(calibration.getCalibrationByName());
item.setCalibratedAt(calibration.getCalibratedAt());
return item;
}
private void ensureDefaultScorecard(Long departmentId) {
if (!scorecardRepository.findByDepartmentId(departmentId).isEmpty()) {
return;
}
String departmentName = departmentId == 2L ? "标注部" : "技术部";
List<String> names = departmentId == 2L
? List.of("标注量", "标注规则复杂度", "质检标准严格度", "领域专业度", "预计工时")
: List.of("技术栈复杂度", "知识点数量与依赖深度", "代码/项目规模", "预计工时", "是否需跨系统联调");
List<BigDecimal> weights = List.of(
BigDecimal.valueOf(0.20),
BigDecimal.valueOf(0.25),
BigDecimal.valueOf(0.20),
BigDecimal.valueOf(0.15),
BigDecimal.valueOf(0.20)
);
for (int i = 0; i < names.size(); i++) {
DifficultyScorecard scorecard = new DifficultyScorecard();
scorecard.setDepartmentId(departmentId);
scorecard.setDepartmentName(departmentName);
scorecard.setDimensionName(names.get(i));
scorecard.setWeight(weights.get(i));
scorecardRepository.save(scorecard);
}
}
}
package com.platform.backend.project.service;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.entity.KnowledgeDependency;
import com.platform.backend.project.entity.KnowledgePoint;
import com.platform.backend.project.repository.KnowledgeDependencyRepository;
import com.platform.backend.project.repository.KnowledgePointRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@Slf4j
@Service
@RequiredArgsConstructor
public class KnowledgeExtractionService {
private final ProjectAiClientService projectAiClientService;
private final KnowledgePointRepository knowledgePointRepository;
private final KnowledgeDependencyRepository dependencyRepository;
@Async
@Transactional
public void extractIfAbsentAsync(ProjectDtos.ProjectDetail project) {
if (!knowledgePointRepository.findByProjectIdAndProjectType(project.getId(), project.getProjectType()).isEmpty()) {
return;
}
try {
extractAndReplace(project);
} catch (Exception ex) {
log.warn("Knowledge extraction failed: projectId={}, projectType={}, error={}",
project.getId(), project.getProjectType(), ex.getMessage());
}
}
@Async
@Transactional
public void extractAndReplaceAsync(ProjectDtos.ProjectDetail project) {
try {
extractAndReplace(project);
} catch (Exception ex) {
log.warn("Knowledge extraction failed: projectId={}, projectType={}, error={}",
project.getId(), project.getProjectType(), ex.getMessage());
}
}
@Transactional
public List<KnowledgePoint> extractAndReplace(ProjectDtos.ProjectDetail project) {
ProjectAiClientService.AiKnowledgeExtractData data = projectAiClientService.extractKnowledge(project);
List<ProjectAiClientService.AiKnowledgePointData> extracted = data == null ? List.of() : data.getKnowledgePoints();
if (extracted == null || extracted.isEmpty()) {
return List.of();
}
removeProjectKnowledge(project.getId(), project.getProjectType());
Map<String, KnowledgePoint> savedByName = new LinkedHashMap<>();
for (ProjectAiClientService.AiKnowledgePointData item : extracted) {
KnowledgePoint point = new KnowledgePoint();
point.setProjectId(project.getId());
point.setProjectType(project.getProjectType());
point.setName(cleanName(item.getName()));
point.setDescription(item.getDescription());
point.setCategory(normalizeCategory(item.getCategory()));
point.setDifficulty(normalizeDifficulty(item.getDifficulty()));
point.setEstimatedHours(item.getEstimatedHours());
point.setMaterialUrl(item.getMaterialUrl());
KnowledgePoint saved = knowledgePointRepository.save(point);
savedByName.put(saved.getName(), saved);
}
for (ProjectAiClientService.AiKnowledgePointData item : extracted) {
KnowledgePoint current = savedByName.get(cleanName(item.getName()));
if (current == null || item.getPrerequisites() == null) {
continue;
}
for (String prerequisiteName : item.getPrerequisites()) {
String normalizedName = cleanName(prerequisiteName);
if (normalizedName.isBlank() || normalizedName.equals(current.getName())) {
continue;
}
KnowledgePoint prerequisite = savedByName.computeIfAbsent(normalizedName, name -> createPrerequisite(project, name));
if (!dependencyRepository.existsByKnowledgeIdAndPrerequisiteId(current.getId(), prerequisite.getId())) {
KnowledgeDependency dependency = new KnowledgeDependency();
dependency.setKnowledgeId(current.getId());
dependency.setPrerequisiteId(prerequisite.getId());
dependencyRepository.save(dependency);
}
}
}
return knowledgePointRepository.findByProjectIdAndProjectType(project.getId(), project.getProjectType());
}
private void removeProjectKnowledge(Long projectId, String projectType) {
List<KnowledgePoint> existing = knowledgePointRepository.findByProjectIdAndProjectType(projectId, projectType);
if (existing.isEmpty()) {
return;
}
List<Long> ids = existing.stream().map(KnowledgePoint::getId).toList();
dependencyRepository.deleteAll(dependencyRepository.findByKnowledgeIdInOrPrerequisiteIdIn(ids, ids));
knowledgePointRepository.deleteAll(existing);
}
private KnowledgePoint createPrerequisite(ProjectDtos.ProjectDetail project, String name) {
KnowledgePoint point = new KnowledgePoint();
point.setProjectId(project.getId());
point.setProjectType(project.getProjectType());
point.setName(name);
point.setDescription("AI 提取的前置知识点");
point.setCategory("concept");
point.setDifficulty("easy");
point.setEstimatedHours(BigDecimal.valueOf(2.0));
return knowledgePointRepository.save(point);
}
private String cleanName(String value) {
return value == null ? "" : value.trim();
}
private String normalizeCategory(String value) {
if ("concept".equals(value) || "skill".equals(value) || "tool".equals(value)) {
return value;
}
return "skill";
}
private String normalizeDifficulty(String value) {
if ("easy".equals(value) || "medium".equals(value) || "hard".equals(value)) {
return value;
}
return "medium";
}
}
package com.platform.backend.project.service;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.common.ProjectConstants;
import com.platform.backend.project.dto.KnowledgeDtos;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.entity.KnowledgeDependency;
import com.platform.backend.project.entity.KnowledgePoint;
import com.platform.backend.project.repository.KnowledgeDependencyRepository;
import com.platform.backend.project.repository.KnowledgePointRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
@Service
@RequiredArgsConstructor
public class KnowledgePointService {
private final KnowledgePointRepository knowledgePointRepository;
private final KnowledgeDependencyRepository dependencyRepository;
private final ProjectService projectService;
private final KnowledgeExtractionService extractionService;
public KnowledgeDtos.KnowledgeListResponse list(
Long projectId,
String projectType,
String category,
String difficulty
) {
validateProject(projectId, projectType);
List<KnowledgePoint> points = knowledgePointRepository.findByProjectIdAndProjectType(projectId, projectType)
.stream()
.filter(point -> category == null || category.isBlank() || category.equals(point.getCategory()))
.filter(point -> difficulty == null || difficulty.isBlank() || difficulty.equals(point.getDifficulty()))
.toList();
KnowledgeDtos.KnowledgeListResponse response = new KnowledgeDtos.KnowledgeListResponse();
response.setProjectId(projectId);
response.setProjectType(projectType);
response.setTotalCount(points.size());
response.setKnowledgePoints(toItems(points));
return response;
}
public KnowledgeDtos.ExtractResponse extract(KnowledgeDtos.ExtractRequest request) {
ProjectDtos.ProjectDetail project = validateProject(request.getProjectId(), request.getProjectType());
// 手动触发接口也按异步任务提交,避免管理员在页面上等待 AI 提取完成。
// 当前接口保留原响应结构,先返回任务受理状态和当前已有知识点,前端再轮询刷新结果做人工确认。
List<KnowledgePoint> currentPoints = knowledgePointRepository.findByProjectIdAndProjectType(
request.getProjectId(),
request.getProjectType()
);
extractionService.extractAndReplaceAsync(project);
KnowledgeDtos.ExtractResponse response = new KnowledgeDtos.ExtractResponse();
response.setAccepted(true);
response.setMessage("知识点提取任务已提交,请稍后刷新确认");
response.setTotalCount(currentPoints.size());
response.setKnowledgePoints(toItems(currentPoints));
return response;
}
@Transactional
public KnowledgeDtos.KnowledgePointItem create(KnowledgeDtos.KnowledgePointRequest request) {
validateRequest(request);
KnowledgePoint point = new KnowledgePoint();
apply(point, request);
KnowledgePoint saved = knowledgePointRepository.save(point);
replacePrerequisites(saved, request.getPrerequisiteIds());
return toItem(saved, loadProjectGraph(saved.getProjectId(), saved.getProjectType()));
}
@Transactional
public KnowledgeDtos.KnowledgePointItem update(Long id, KnowledgeDtos.KnowledgePointRequest request) {
validateRequest(request);
KnowledgePoint point = knowledgePointRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("知识点不存在"));
if (!Objects.equals(point.getProjectId(), request.getProjectId())
|| !Objects.equals(point.getProjectType(), request.getProjectType())) {
throw new ProjectBusinessException("不可修改知识点所属项目");
}
apply(point, request);
KnowledgePoint saved = knowledgePointRepository.save(point);
replacePrerequisites(saved, request.getPrerequisiteIds());
return toItem(saved, loadProjectGraph(saved.getProjectId(), saved.getProjectType()));
}
@Transactional
public void delete(Long id) {
KnowledgePoint point = knowledgePointRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("知识点不存在"));
dependencyRepository.deleteByKnowledgeId(id);
dependencyRepository.deleteByPrerequisiteId(id);
knowledgePointRepository.delete(point);
}
private ProjectDtos.ProjectDetail validateProject(Long projectId, String projectType) {
if (!ProjectConstants.PROJECT_TYPES.contains(projectType)) {
throw new ProjectBusinessException("project_type 仅支持 internal/github/annotation");
}
return projectService.getDetailWithoutViewIncrement(projectId, projectType);
}
private void validateRequest(KnowledgeDtos.KnowledgePointRequest request) {
validateProject(request.getProjectId(), request.getProjectType());
if (!ProjectConstants.KNOWLEDGE_CATEGORIES.contains(request.getCategory())) {
throw new ProjectBusinessException("category 仅支持 concept/skill/tool");
}
if (!ProjectConstants.KNOWLEDGE_DIFFICULTIES.contains(request.getDifficulty())) {
throw new ProjectBusinessException("difficulty 仅支持 easy/medium/hard");
}
}
private void apply(KnowledgePoint point, KnowledgeDtos.KnowledgePointRequest request) {
point.setProjectId(request.getProjectId());
point.setProjectType(request.getProjectType());
point.setName(request.getName());
point.setDescription(request.getDescription());
point.setCategory(request.getCategory());
point.setDifficulty(request.getDifficulty());
point.setEstimatedHours(request.getEstimatedHours());
point.setMaterialUrl(request.getMaterialUrl());
}
private void replacePrerequisites(KnowledgePoint point, List<Long> prerequisiteIds) {
dependencyRepository.deleteByKnowledgeId(point.getId());
if (prerequisiteIds == null || prerequisiteIds.isEmpty()) {
return;
}
List<KnowledgePoint> prerequisites = knowledgePointRepository.findByIdIn(prerequisiteIds);
for (KnowledgePoint prerequisite : prerequisites) {
if (Objects.equals(prerequisite.getId(), point.getId())) {
continue;
}
if (!Objects.equals(prerequisite.getProjectId(), point.getProjectId())
|| !Objects.equals(prerequisite.getProjectType(), point.getProjectType())) {
throw new ProjectBusinessException("前置知识点必须属于同一项目");
}
KnowledgeDependency dependency = new KnowledgeDependency();
dependency.setKnowledgeId(point.getId());
dependency.setPrerequisiteId(prerequisite.getId());
dependencyRepository.save(dependency);
}
}
public List<ProjectDtos.KnowledgePointItem> projectDetailItems(Long projectId, String projectType) {
return knowledgePointRepository.findByProjectIdAndProjectType(projectId, projectType).stream()
.map(point -> {
ProjectDtos.KnowledgePointItem item = new ProjectDtos.KnowledgePointItem();
item.setId(point.getId());
item.setName(point.getName());
item.setDifficulty(point.getDifficulty());
item.setEstimatedHours(point.getEstimatedHours() == null ? null : point.getEstimatedHours().doubleValue());
item.setMaterialUrl(point.getMaterialUrl());
return item;
})
.toList();
}
private List<KnowledgeDtos.KnowledgePointItem> toItems(List<KnowledgePoint> points) {
if (points.isEmpty()) {
return List.of();
}
KnowledgeGraph graph = loadProjectGraph(points.get(0).getProjectId(), points.get(0).getProjectType());
return points.stream().map(point -> toItem(point, graph)).toList();
}
private KnowledgeDtos.KnowledgePointItem toItem(KnowledgePoint point, KnowledgeGraph graph) {
KnowledgeDtos.KnowledgePointItem item = new KnowledgeDtos.KnowledgePointItem();
item.setId(point.getId());
item.setProjectId(point.getProjectId());
item.setProjectType(point.getProjectType());
item.setName(point.getName());
item.setDescription(point.getDescription());
item.setCategory(point.getCategory());
item.setDifficulty(point.getDifficulty());
item.setEstimatedHours(point.getEstimatedHours());
item.setMaterialUrl(point.getMaterialUrl());
item.setPrerequisites(graph.prerequisites().getOrDefault(point.getId(), List.of()));
item.setDependents(graph.dependents().getOrDefault(point.getId(), List.of()));
item.setCreatedAt(point.getCreatedAt());
return item;
}
private KnowledgeGraph loadProjectGraph(Long projectId, String projectType) {
List<KnowledgePoint> allPoints = knowledgePointRepository.findByProjectIdAndProjectType(projectId, projectType);
Map<Long, KnowledgePoint> byId = new HashMap<>();
allPoints.forEach(point -> byId.put(point.getId(), point));
List<Long> ids = allPoints.stream().map(KnowledgePoint::getId).toList();
List<KnowledgeDependency> dependencies = ids.isEmpty()
? List.of()
: dependencyRepository.findByKnowledgeIdInOrPrerequisiteIdIn(ids, ids);
Map<Long, List<KnowledgeDtos.KnowledgePointRef>> prerequisites = new HashMap<>();
Map<Long, List<KnowledgeDtos.KnowledgePointRef>> dependents = new HashMap<>();
for (KnowledgeDependency dependency : dependencies) {
KnowledgePoint knowledge = byId.get(dependency.getKnowledgeId());
KnowledgePoint prerequisite = byId.get(dependency.getPrerequisiteId());
if (knowledge == null || prerequisite == null) {
continue;
}
prerequisites.computeIfAbsent(knowledge.getId(), ignored -> new ArrayList<>()).add(toRef(prerequisite));
dependents.computeIfAbsent(prerequisite.getId(), ignored -> new ArrayList<>()).add(toRef(knowledge));
}
return new KnowledgeGraph(prerequisites, dependents);
}
private KnowledgeDtos.KnowledgePointRef toRef(KnowledgePoint point) {
KnowledgeDtos.KnowledgePointRef ref = new KnowledgeDtos.KnowledgePointRef();
ref.setId(point.getId());
ref.setName(point.getName());
return ref;
}
private record KnowledgeGraph(
Map<Long, List<KnowledgeDtos.KnowledgePointRef>> prerequisites,
Map<Long, List<KnowledgeDtos.KnowledgePointRef>> dependents
) {
}
}
package com.platform.backend.project.service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.github.resilience4j.circuitbreaker.CallNotPermittedException;
import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import io.github.resilience4j.timelimiter.TimeLimiter;
import io.github.resilience4j.timelimiter.TimeLimiterRegistry;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.dto.RecommendationDtos;
import com.platform.backend.project.entity.*;
import com.platform.backend.project.repository.*;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.reactive.function.client.WebClient;
import jakarta.annotation.PreDestroy;
import java.math.BigDecimal;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Supplier;
import java.util.stream.Collectors;
@Slf4j
@Service
@RequiredArgsConstructor
public class ProjectAiClientService {
private final WebClient aiWebClient;
private final ObjectMapper objectMapper;
private final InternalProjectRepository internalProjectRepository;
private final GithubProjectRepository githubProjectRepository;
private final AnnotationProjectRepository annotationProjectRepository;
private final DifficultyScoreRepository difficultyScoreRepository;
private final KnowledgePointRepository knowledgePointRepository;
private final KnowledgeDependencyRepository knowledgeDependencyRepository;
private final ProjectAiCallLogRepository aiCallLogRepository;
private final CircuitBreakerRegistry circuitBreakerRegistry;
private final TimeLimiterRegistry timeLimiterRegistry;
@Value("${ai-service.timeout-seconds:8}")
private long timeoutSeconds;
/**
* 统一给 project-module 的 AI 请求做超时控制,避免业务线程被外部调用长期阻塞。
*/
private final ExecutorService aiExecutor = Executors.newFixedThreadPool(4);
private final ScheduledExecutorService aiScheduler = Executors.newScheduledThreadPool(2);
@PreDestroy
void shutdownExecutors() {
aiExecutor.shutdown();
aiScheduler.shutdown();
}
@Async
public void evaluateDifficultyAsync(Long projectId, String projectType) {
try {
evaluateDifficulty(projectId, projectType);
} catch (Exception ex) {
log.warn("AI difficulty evaluation failed: projectId={}, projectType={}, error={}",
projectId, projectType, ex.getMessage());
}
}
@Transactional
public DifficultyScore evaluateDifficulty(Long projectId, String projectType) {
ProjectSnapshot snapshot = loadSnapshot(projectId, projectType);
AiDifficultyData data;
boolean success = true;
String errorMessage = null;
String responseBody = null;
try {
data = runProtected("difficulty_score", () -> {
AiDifficultyResponse response = aiWebClient.post()
.uri("/ai/difficulty/score")
.bodyValue(Map.of(
"project_id", projectId,
"project_type", projectType,
"project_name", snapshot.name(),
"difficulty_level", snapshot.difficultyLevel(),
"knowledge_count", snapshot.knowledgeCount(),
"dependency_depth", snapshot.dependencyDepth(),
"estimated_hours", snapshot.estimatedHours(),
"requires_integration", snapshot.requiresIntegration()
))
.retrieve()
.bodyToMono(AiDifficultyResponse.class)
.block(Duration.ofSeconds(timeoutSeconds));
return response == null ? null : response.getData();
});
responseBody = safeJson(data);
if (data == null || data.getAiScore() == null || data.getSuggestedLevel() == null) {
throw new ProjectBusinessException("AI 难度评分结果为空");
}
} catch (Exception ex) {
success = false;
errorMessage = ex.getMessage();
data = fallbackScore(snapshot);
}
DifficultyScore score = difficultyScoreRepository
.findByProjectIdAndProjectType(projectId, projectType)
.orElseGet(DifficultyScore::new);
score.setProjectId(projectId);
score.setProjectType(projectType);
score.setAiScore(data.getAiScore());
score.setAiSuggestedLevel(data.getSuggestedLevel());
if (score.getCalibratedLevel() == null || score.getCalibratedLevel().isBlank()) {
score.setCalibratedLevel(data.getSuggestedLevel());
score.setCalibrationStatus("pending");
}
DifficultyScore saved = difficultyScoreRepository.save(score);
ProjectAiCallLog callLog = new ProjectAiCallLog();
callLog.setProjectId(projectId);
callLog.setProjectType(projectType);
callLog.setTaskType("difficulty_score");
callLog.setSuccess(success);
callLog.setErrorMessage(errorMessage);
callLog.setResponseBody(responseBody);
aiCallLogRepository.save(callLog);
return saved;
}
public AiKnowledgeExtractData extractKnowledge(ProjectDtos.ProjectDetail project) {
AiKnowledgeExtractData data;
boolean success = true;
String errorMessage = null;
String responseBody = null;
try {
Map<String, Object> body = new LinkedHashMap<>();
body.put("project_id", project.getId());
body.put("project_type", project.getProjectType());
body.put("project_name", project.getName());
body.put("difficulty_level", project.getDifficultyLevel());
body.put("tech_stack", project.getTechStack());
body.put("tags", project.getTags());
body.put("knowledge_tags", project.getKnowledgeTags());
body.put("source_code_url", project.getSourceCodeUrl());
body.put("requirement_doc_url", project.getRequirementDocUrl());
body.put("project_content", buildProjectContent(project));
data = runProtected("knowledge_extract", () -> {
AiKnowledgeExtractResponse response = aiWebClient.post()
.uri("/ai/knowledge/extract")
.bodyValue(body)
.retrieve()
.bodyToMono(AiKnowledgeExtractResponse.class)
.block(Duration.ofSeconds(timeoutSeconds));
return response == null ? null : response.getData();
});
if (data == null || data.getKnowledgePoints() == null || data.getKnowledgePoints().isEmpty()) {
throw new ProjectBusinessException("AI 知识点提取结果为空");
}
responseBody = safeJson(data);
} catch (Exception ex) {
success = false;
errorMessage = ex.getMessage();
data = fallbackKnowledge(project);
responseBody = safeJson(data);
}
ProjectAiCallLog callLog = new ProjectAiCallLog();
callLog.setProjectId(project.getId());
callLog.setProjectType(project.getProjectType());
callLog.setTaskType("knowledge_extract");
callLog.setSuccess(success);
callLog.setErrorMessage(errorMessage);
callLog.setResponseBody(responseBody);
aiCallLogRepository.save(callLog);
return data;
}
public RecommendationDtos.RecommendationResponse recommend(
ProjectDtos.ProjectDetail seedProject,
String projectType,
List<ProjectRecommendationService.CandidateProject> candidates,
Integer limit
) {
long startedAt = System.currentTimeMillis();
AiRecommendResponse response;
boolean success = true;
String errorMessage = null;
String responseBody = null;
try {
AiRecommendRequest request = new AiRecommendRequest();
request.setProjectType(projectType);
request.setLimit(limit == null ? 5 : limit);
request.setSeedProject(toSeedProject(seedProject));
request.setCandidates(candidates.stream().map(this::toCandidate).toList());
response = runProtected("recommend", () -> aiWebClient.post()
.uri("/ai/recommend")
.bodyValue(request)
.retrieve()
.bodyToMono(AiRecommendResponse.class)
.block(Duration.ofSeconds(timeoutSeconds)));
responseBody = safeJson(response);
if (response == null || response.getData() == null || response.getData().getRecommendations() == null
|| response.getData().getRecommendations().isEmpty()) {
throw new ProjectBusinessException("AI 推荐结果为空");
}
} catch (Exception ex) {
success = false;
errorMessage = ex.getMessage();
log.warn("AI recommend fallback triggered: projectId={}, projectType={}, error={}",
seedProject.getId(), projectType, ex.getMessage());
response = fallbackRecommend(seedProject, projectType, candidates, limit);
responseBody = safeJson(response);
}
ProjectAiCallLog callLog = new ProjectAiCallLog();
callLog.setProjectId(seedProject.getId());
callLog.setProjectType(projectType);
callLog.setTaskType("recommend");
callLog.setSuccess(success);
callLog.setErrorMessage(errorMessage);
callLog.setResponseBody(responseBody);
aiCallLogRepository.save(callLog);
RecommendationDtos.RecommendationResponse result = new RecommendationDtos.RecommendationResponse();
if (response != null && response.getData() != null) {
result.setSource(response.getData().getSource());
result.setTotalTime(response.getData().getTotalTime() == null
? (int) (System.currentTimeMillis() - startedAt)
: response.getData().getTotalTime());
result.setRecommendations(response.getData().getRecommendations().stream()
.map(this::toRecommendationItem)
.toList());
} else {
result.setSource("fallback");
result.setTotalTime((int) (System.currentTimeMillis() - startedAt));
result.setRecommendations(List.of());
}
return result;
}
@Async
public void syncProjectVectorAsync(ProjectDtos.ProjectDetail project) {
try {
syncProjectVector(project);
} catch (Exception ex) {
log.warn("Project vector sync failed: projectId={}, projectType={}, error={}",
project.getId(), project.getProjectType(), ex.getMessage());
}
}
@Async
public void deleteProjectVectorAsync(Long projectId, String projectType) {
try {
deleteProjectVector(projectId, projectType);
} catch (Exception ex) {
log.warn("Project vector delete failed: projectId={}, projectType={}, error={}",
projectId, projectType, ex.getMessage());
}
}
public VectorSyncResult syncProjectVector(ProjectDtos.ProjectDetail project) {
AiEmbedRequest request = new AiEmbedRequest();
request.setAction("upsert");
request.setDocuments(List.of(toEmbedDocument(project)));
// AI 服务按 list 校验字段类型,未使用的列表也传空数组,避免 null 触发 422。
request.setDocIds(List.of());
return callEmbed(project.getId(), project.getProjectType(), "vector_sync", request);
}
public VectorSyncResult deleteProjectVector(Long projectId, String projectType) {
AiEmbedRequest request = new AiEmbedRequest();
request.setAction("delete");
// AI 服务按 list 校验字段类型,未使用的列表也传空数组,避免 null 触发 422。
request.setDocuments(List.of());
request.setDocIds(List.of(vectorDocId(projectId, projectType)));
return callEmbed(projectId, projectType, "vector_delete", request);
}
private ProjectSnapshot loadSnapshot(Long projectId, String projectType) {
return switch (projectType) {
case "internal" -> internalProjectRepository.findById(projectId)
.map(project -> new ProjectSnapshot(
requireAvailable(project.getName(), project.getIsDeleted()),
project.getDifficultyLevel(),
resolveKnowledgeCount(projectId, "internal", countJsonArray(project.getKnowledgeTags())),
resolveDependencyDepth(projectId, "internal"),
resolveEstimatedHours(projectId, "internal", estimateHours(project.getDifficultyLevel())),
inferRequiresIntegration(project.getDescription(), parseJsonList(project.getTechStack()), project.getBusinessDomain())
))
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
case "github" -> githubProjectRepository.findById(projectId)
.map(project -> new ProjectSnapshot(
requireAvailable(project.getRepoName(), project.getIsDeleted()),
project.getDifficultyLevel(),
resolveKnowledgeCount(projectId, "github", countJsonArray(project.getTechStack())),
resolveDependencyDepth(projectId, "github"),
resolveEstimatedHours(projectId, "github", estimateHours(project.getDifficultyLevel())),
inferRequiresIntegration(project.getDescription(), parseJsonList(project.getTechStack()), project.getRepoName())
))
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
case "annotation" -> annotationProjectRepository.findById(projectId)
.map(project -> new ProjectSnapshot(
requireAvailable(project.getName(), project.getIsDeleted()),
project.getDifficultyLevel(),
resolveKnowledgeCount(projectId, "annotation", 1),
resolveDependencyDepth(projectId, "annotation"),
resolveEstimatedHours(projectId, "annotation", estimateHours(project.getDifficultyLevel())),
inferRequiresIntegration(
project.getIndustry(),
project.getAnnotationType() == null ? List.of() : List.of(project.getAnnotationType()),
project.getName()
)
))
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
default -> throw new ProjectBusinessException("projectType 仅支持 internal/github/annotation");
};
}
private String requireAvailable(String projectName, Boolean isDeleted) {
if (Boolean.TRUE.equals(isDeleted)) {
throw new ProjectBusinessException("项目不存在");
}
return projectName;
}
private AiDifficultyData fallbackScore(ProjectSnapshot snapshot) {
BigDecimal score = switch (snapshot.difficultyLevel()) {
case "L1" -> BigDecimal.valueOf(35);
case "L2" -> BigDecimal.valueOf(55);
case "L4" -> BigDecimal.valueOf(85);
case "L5" -> BigDecimal.valueOf(95);
default -> BigDecimal.valueOf(75);
};
AiDifficultyData data = new AiDifficultyData();
data.setAiScore(score);
data.setSuggestedLevel(snapshot.difficultyLevel() == null ? "L3" : snapshot.difficultyLevel());
return data;
}
private int countJsonArray(String json) {
if (json == null || json.isBlank()) {
return 0;
}
try {
return objectMapper.readTree(json).size();
} catch (JsonProcessingException e) {
return 0;
}
}
private List<String> parseJsonList(String json) {
if (json == null || json.isBlank()) {
return List.of();
}
try {
List<String> values = objectMapper.readerForListOf(String.class).readValue(json);
return values == null ? List.of() : values.stream().filter(value -> value != null && !value.isBlank()).toList();
} catch (JsonProcessingException e) {
return List.of();
}
}
private int estimateHours(String level) {
return switch (level == null ? "" : level) {
case "L1" -> 8;
case "L2" -> 16;
case "L4" -> 48;
case "L5" -> 80;
default -> 32;
};
}
private int resolveKnowledgeCount(Long projectId, String projectType, int fallbackCount) {
List<KnowledgePoint> points = knowledgePointRepository.findByProjectIdAndProjectType(projectId, projectType);
return points.isEmpty() ? fallbackCount : points.size();
}
private int resolveEstimatedHours(Long projectId, String projectType, int fallbackHours) {
List<KnowledgePoint> points = knowledgePointRepository.findByProjectIdAndProjectType(projectId, projectType);
int totalHours = points.stream()
.map(KnowledgePoint::getEstimatedHours)
.filter(Objects::nonNull)
.mapToInt(value -> value.intValue())
.sum();
return totalHours > 0 ? totalHours : fallbackHours;
}
/**
* 依赖深度取知识点有向图的最长链路长度;若暂时没有依赖关系,则回退为 0。
*/
private int resolveDependencyDepth(Long projectId, String projectType) {
List<KnowledgePoint> points = knowledgePointRepository.findByProjectIdAndProjectType(projectId, projectType);
if (points.isEmpty()) {
return 0;
}
List<Long> pointIds = points.stream().map(KnowledgePoint::getId).toList();
List<KnowledgeDependency> dependencies = knowledgeDependencyRepository.findByKnowledgeIdInOrPrerequisiteIdIn(pointIds, pointIds);
if (dependencies.isEmpty()) {
return 0;
}
Map<Long, List<Long>> adjacency = new LinkedHashMap<>();
for (KnowledgeDependency dependency : dependencies) {
adjacency.computeIfAbsent(dependency.getPrerequisiteId(), ignored -> new ArrayList<>())
.add(dependency.getKnowledgeId());
}
Map<Long, Integer> memo = new LinkedHashMap<>();
int maxDepth = 0;
for (Long pointId : pointIds) {
maxDepth = Math.max(maxDepth, dfsDepth(pointId, adjacency, memo, new LinkedHashSet<>()));
}
return maxDepth;
}
private int dfsDepth(
Long pointId,
Map<Long, List<Long>> adjacency,
Map<Long, Integer> memo,
Set<Long> visiting
) {
if (memo.containsKey(pointId)) {
return memo.get(pointId);
}
if (!visiting.add(pointId)) {
return 0;
}
int depth = 0;
for (Long nextId : adjacency.getOrDefault(pointId, List.of())) {
depth = Math.max(depth, 1 + dfsDepth(nextId, adjacency, memo, visiting));
}
visiting.remove(pointId);
memo.put(pointId, depth);
return depth;
}
private boolean inferRequiresIntegration(String... values) {
String text = String.join(" ", values).toLowerCase(Locale.ROOT);
return text.contains("微服务")
|| text.contains("联调")
|| text.contains("集成")
|| text.contains("跨系统")
|| text.contains("third-party")
|| text.contains("integration")
|| text.contains("api")
|| text.contains("service");
}
private boolean inferRequiresIntegration(String description, List<String> techStack, String extraText) {
if (techStack != null && techStack.size() >= 3) {
return true;
}
return inferRequiresIntegration(description == null ? "" : description, extraText == null ? "" : extraText);
}
private String safeJson(Object value) {
try {
return objectMapper.writeValueAsString(value);
} catch (JsonProcessingException e) {
return null;
}
}
private String buildProjectContent(ProjectDtos.ProjectDetail project) {
return String.join("\n",
"项目名称: " + nullToEmpty(project.getName()),
nullToEmpty(project.getDescription()),
"技术栈: " + listText(project.getTechStack()),
"知识标签: " + listText(project.getKnowledgeTags()),
"项目标签: " + listText(project.getTags()),
"业务领域: " + nullToEmpty(project.getBusinessDomain()),
"标注类型: " + nullToEmpty(project.getAnnotationType()),
"行业: " + nullToEmpty(project.getIndustry()),
"知识点: " + knowledgePointText(project.getKnowledgePoints())
);
}
private String knowledgePointText(List<ProjectDtos.KnowledgePointItem> knowledgePoints) {
if (knowledgePoints == null || knowledgePoints.isEmpty()) {
return "";
}
return knowledgePoints.stream()
.map(ProjectDtos.KnowledgePointItem::getName)
.filter(value -> value != null && !value.isBlank())
.collect(Collectors.joining(", "));
}
private AiRecommendResponse fallbackRecommend(
ProjectDtos.ProjectDetail seedProject,
String projectType,
List<ProjectRecommendationService.CandidateProject> candidates,
Integer limit
) {
Set<String> seedTags = normalizeTags(seedProject.getKnowledgeTags(), seedProject.getTags(), seedProject.getTechStack());
List<ProjectRecommendationService.CandidateProject> randomized = new ArrayList<>(candidates.stream()
.filter(candidate -> {
Set<String> candidateTags = normalizeTags(candidate.getTags(), candidate.getTechStack());
return !Collections.disjoint(candidateTags, seedTags);
})
.toList());
if (randomized.isEmpty()) {
randomized = new ArrayList<>(candidates);
}
Collections.shuffle(randomized);
List<AiRecommendItem> items = randomized.stream()
.limit(limit == null ? 5 : limit)
.map(candidate -> {
Set<String> candidateTags = normalizeTags(candidate.getTags(), candidate.getTechStack());
long overlap = candidateTags.stream().filter(seedTags::contains).count();
double difficultyMatch = 1.0 - (Math.abs(levelIndex(seedProject.getDifficultyLevel()) - levelIndex(candidate.getDifficultyLevel())) / 4.0);
double starsBonus = Math.min(candidate.getStars() == null ? 0 : candidate.getStars() / 5000.0, 0.15);
BigDecimal score = BigDecimal.valueOf(Math.min(0.99, 0.35 + overlap * 0.18 + difficultyMatch * 0.35 + starsBonus))
.setScale(4, java.math.RoundingMode.HALF_UP);
AiRecommendItem item = new AiRecommendItem();
item.setProjectId(candidate.getProjectId());
item.setProjectName(candidate.getProjectName());
item.setProjectType(projectType);
item.setGithubUrl(candidate.getGithubUrl());
item.setDescription(candidate.getDescription());
item.setDifficultyLevel(candidate.getDifficultyLevel());
item.setTechStack(candidate.getTechStack());
item.setMatchScore(score);
item.setMatchReason(buildReason(seedProject.getName(), candidate, overlap));
item.setStars(candidate.getStars());
return item;
})
.toList();
AiRecommendData data = new AiRecommendData();
data.setSource("fallback");
data.setTotalTime(0);
data.setRecommendations(items);
AiRecommendResponse response = new AiRecommendResponse();
response.setSuccess(true);
response.setData(data);
return response;
}
private String buildReason(String seedName, ProjectRecommendationService.CandidateProject candidate, long overlap) {
String shared = candidate.getTags() == null ? "" : candidate.getTags().stream().limit(3).collect(Collectors.joining("、"));
String sharedText = overlap > 0 && !shared.isBlank() ? "共享标签 " + shared : "与种子项目主题接近";
return "与种子项目“" + seedName + "”匹配:" + sharedText + ",难度 " + candidate.getDifficultyLevel() + "。";
}
private int levelIndex(String level) {
return switch (level == null ? "" : level) {
case "L1" -> 0;
case "L2" -> 1;
case "L3" -> 2;
case "L4" -> 3;
case "L5" -> 4;
default -> 2;
};
}
private Set<String> normalizeTags(List<String>... groups) {
return java.util.Arrays.stream(groups)
.filter(group -> group != null)
.flatMap(List::stream)
.filter(value -> value != null && !value.isBlank())
.map(value -> value.trim().toLowerCase(Locale.ROOT))
.collect(Collectors.toCollection(java.util.LinkedHashSet::new));
}
private AiSeedProject toSeedProject(ProjectDtos.ProjectDetail project) {
AiSeedProject seed = new AiSeedProject();
seed.setId(project.getId());
seed.setName(project.getName());
seed.setDifficultyLevel(project.getDifficultyLevel());
seed.setTechStack(project.getTechStack());
seed.setTags(project.getKnowledgeTags());
return seed;
}
private AiCandidate toCandidate(ProjectRecommendationService.CandidateProject candidate) {
AiCandidate aiCandidate = new AiCandidate();
aiCandidate.setProjectId(candidate.getProjectId());
aiCandidate.setProjectName(candidate.getProjectName());
aiCandidate.setProjectType(candidate.getProjectType());
aiCandidate.setDescription(candidate.getDescription());
aiCandidate.setDifficultyLevel(candidate.getDifficultyLevel());
aiCandidate.setTechStack(candidate.getTechStack());
aiCandidate.setTags(candidate.getTags());
aiCandidate.setStars(candidate.getStars());
aiCandidate.setGithubUrl(candidate.getGithubUrl());
return aiCandidate;
}
private RecommendationDtos.RecommendationItem toRecommendationItem(AiRecommendItem item) {
RecommendationDtos.RecommendationItem result = new RecommendationDtos.RecommendationItem();
result.setProjectId(item.getProjectId());
result.setProjectName(item.getProjectName());
result.setProjectType(item.getProjectType());
result.setGithubUrl(item.getGithubUrl());
result.setDescription(item.getDescription());
result.setDifficultyLevel(item.getDifficultyLevel());
result.setTechStack(item.getTechStack());
result.setMatchScore(item.getMatchScore());
result.setMatchReason(item.getMatchReason());
result.setStars(item.getStars());
return result;
}
private AiKnowledgeExtractData fallbackKnowledge(ProjectDtos.ProjectDetail project) {
List<AiKnowledgePointData> points = new ArrayList<>();
addFallbackPoint(points, "项目需求理解", "理解项目目标、业务边界和验收要求。", "concept", "easy", BigDecimal.valueOf(2.0), List.of());
List<String> techStack = project.getTechStack() == null ? List.of() : project.getTechStack();
for (String tech : techStack.stream().filter(value -> value != null && !value.isBlank()).limit(4).toList()) {
addFallbackPoint(points, tech + " 实践", "掌握 " + tech + " 在该项目中的核心用法。", "tool", "medium", BigDecimal.valueOf(4.0), List.of("项目需求理解"));
}
List<String> tags = project.getKnowledgeTags() == null || project.getKnowledgeTags().isEmpty()
? project.getTags()
: project.getKnowledgeTags();
if (tags != null) {
for (String tag : tags.stream().filter(value -> value != null && !value.isBlank()).limit(4).toList()) {
addFallbackPoint(points, tag, "围绕项目任务学习并应用 " + tag + "。", "skill", "medium", BigDecimal.valueOf(3.0), List.of("项目需求理解"));
}
}
if (points.size() == 1) {
addFallbackPoint(points, "方案设计与实现", "拆解功能、设计实现路径并完成基础交付。", "skill", "medium", BigDecimal.valueOf(6.0), List.of("项目需求理解"));
}
AiKnowledgeExtractData data = new AiKnowledgeExtractData();
data.setKnowledgePoints(points);
return data;
}
private void addFallbackPoint(
List<AiKnowledgePointData> points,
String name,
String description,
String category,
String difficulty,
BigDecimal estimatedHours,
List<String> prerequisites
) {
AiKnowledgePointData point = new AiKnowledgePointData();
point.setName(name);
point.setDescription(description);
point.setCategory(category);
point.setDifficulty(difficulty);
point.setEstimatedHours(estimatedHours);
point.setPrerequisites(prerequisites);
points.add(point);
}
private String listText(List<String> values) {
return values == null ? "" : String.join(", ", values);
}
private String nullToEmpty(String value) {
return value == null ? "" : value;
}
private AiEmbedDocument toEmbedDocument(ProjectDtos.ProjectDetail project) {
AiEmbedDocument document = new AiEmbedDocument();
document.setDocId(vectorDocId(project.getId(), project.getProjectType()));
document.setProjectId(project.getId());
document.setProjectType(project.getProjectType());
document.setTitle(projectTitle(project));
document.setContent(buildProjectContent(project));
Map<String, Object> metadata = new LinkedHashMap<>();
metadata.put("difficulty_level", project.getDifficultyLevel());
metadata.put("difficulty_name", project.getDifficultyName());
metadata.put("tech_stack", project.getTechStack());
metadata.put("tags", project.getTags());
metadata.put("knowledge_tags", project.getKnowledgeTags());
metadata.put("business_domain", project.getBusinessDomain());
metadata.put("annotation_type", project.getAnnotationType());
metadata.put("industry", project.getIndustry());
metadata.put("status", project.getStatus());
document.setMetadata(metadata);
return document;
}
private String vectorDocId(Long projectId, String projectType) {
return projectType + ":" + projectId;
}
private String projectTitle(ProjectDtos.ProjectDetail project) {
if (project.getName() != null && !project.getName().isBlank()) {
return project.getName();
}
return vectorDocId(project.getId(), project.getProjectType());
}
private VectorSyncResult callEmbed(Long projectId, String projectType, String taskType, AiEmbedRequest request) {
boolean success = true;
String errorMessage = null;
String responseBody = null;
AiEmbedData data = null;
try {
AiEmbedResponse response = runProtected(taskType, () -> aiWebClient.post()
.uri("/ai/embed")
.bodyValue(request)
.retrieve()
.bodyToMono(AiEmbedResponse.class)
.block(Duration.ofSeconds(timeoutSeconds)));
data = response == null ? null : response.getData();
responseBody = safeJson(response);
if (data == null) {
throw new ProjectBusinessException("AI 向量同步结果为空");
}
} catch (Exception ex) {
success = false;
errorMessage = ex.getMessage();
}
ProjectAiCallLog callLog = new ProjectAiCallLog();
callLog.setProjectId(projectId);
callLog.setProjectType(projectType);
callLog.setTaskType(taskType);
callLog.setSuccess(success);
callLog.setErrorMessage(errorMessage);
callLog.setResponseBody(responseBody);
aiCallLogRepository.save(callLog);
VectorSyncResult result = new VectorSyncResult();
result.setSuccess(success && data != null);
result.setBackend(data == null ? null : data.getBackend());
result.setCollection(data == null ? null : data.getCollection());
result.setSyncedCount(data == null ? 0 : data.getSyncedCount());
result.setDeletedCount(data == null ? 0 : data.getDeletedCount());
result.setErrorMessage(errorMessage);
return result;
}
/**
* 统一封装 AI 调用的熔断 + 超时保护。
* 说明:
* 1. 超时由 Resilience4j TimeLimiter 控制,避免外部服务慢响应拖住业务线程。
* 2. 熔断器打开后会直接拒绝请求,外层维持现有 fallback 逻辑,不改变返回结构。
*/
private <T> T runProtected(String operation, Supplier<T> supplier) {
CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("aiProject");
TimeLimiter timeLimiter = timeLimiterRegistry.timeLimiter("aiProject");
Supplier<T> guardedSupplier = CircuitBreaker.decorateSupplier(circuitBreaker, () -> {
try {
return timeLimiter.executeCompletionStage(
aiScheduler,
() -> CompletableFuture.supplyAsync(supplier, aiExecutor))
.toCompletableFuture()
.join();
} catch (CompletionException ex) {
Throwable cause = ex.getCause() == null ? ex : ex.getCause();
throw new ProjectBusinessException("AI 调用失败(" + operation + "): " + cause.getMessage());
} catch (Exception ex) {
throw new ProjectBusinessException("AI 调用失败(" + operation + "): " + ex.getMessage());
}
});
try {
return guardedSupplier.get();
} catch (CallNotPermittedException ex) {
throw new ProjectBusinessException("AI 熔断中,请稍后重试");
}
}
private record ProjectSnapshot(
String name,
String difficultyLevel,
int knowledgeCount,
int dependencyDepth,
int estimatedHours,
boolean requiresIntegration
) {
}
@Data
public static class AiDifficultyResponse {
private boolean success;
private AiDifficultyData data;
}
@Data
public static class AiDifficultyData {
@JsonProperty("ai_score")
private BigDecimal aiScore;
@JsonProperty("suggested_level")
private String suggestedLevel;
}
@Data
public static class AiKnowledgeExtractResponse {
private boolean success;
private AiKnowledgeExtractData data;
}
@Data
public static class AiKnowledgeExtractData {
@JsonProperty("knowledge_points")
private List<AiKnowledgePointData> knowledgePoints;
}
@Data
public static class AiKnowledgePointData {
private String name;
private String description;
private String category;
private String difficulty;
@JsonProperty("estimated_hours")
private BigDecimal estimatedHours;
@JsonProperty("material_url")
private String materialUrl;
private List<String> prerequisites;
}
@Data
public static class AiRecommendResponse {
private boolean success;
private AiRecommendData data;
}
@Data
public static class AiRecommendData {
private String source;
@JsonProperty("total_time")
private Integer totalTime;
private List<AiRecommendItem> recommendations;
}
@Data
public static class AiRecommendRequest {
@JsonProperty("project_type")
private String projectType;
@JsonProperty("seed_project")
private AiSeedProject seedProject;
private Integer limit;
@JsonProperty("exclude_ids")
private List<Long> excludeIds;
private List<AiCandidate> candidates;
}
@Data
public static class AiSeedProject {
private Long id;
private String name;
@JsonProperty("difficulty_level")
private String difficultyLevel;
@JsonProperty("tech_stack")
private List<String> techStack;
private List<String> tags;
}
@Data
public static class AiCandidate {
@JsonProperty("project_id")
private Long projectId;
@JsonProperty("project_name")
private String projectName;
@JsonProperty("project_type")
private String projectType;
private String description;
@JsonProperty("difficulty_level")
private String difficultyLevel;
@JsonProperty("tech_stack")
private List<String> techStack;
private List<String> tags;
private Integer stars;
@JsonProperty("github_url")
private String githubUrl;
}
@Data
public static class AiRecommendItem {
@JsonProperty("project_id")
private Long projectId;
@JsonProperty("project_name")
private String projectName;
@JsonProperty("project_type")
private String projectType;
@JsonProperty("github_url")
private String githubUrl;
private String description;
@JsonProperty("difficulty_level")
private String difficultyLevel;
@JsonProperty("tech_stack")
private List<String> techStack;
@JsonProperty("match_score")
private BigDecimal matchScore;
@JsonProperty("match_reason")
private String matchReason;
private Integer stars;
}
@Data
public static class AiEmbedResponse {
private boolean success;
private AiEmbedData data;
}
@Data
public static class AiEmbedData {
private String backend;
private String collection;
@JsonProperty("synced_count")
private Integer syncedCount;
@JsonProperty("deleted_count")
private Integer deletedCount;
private Boolean enabled;
private Boolean fallback;
}
@Data
public static class AiEmbedRequest {
private String action;
private List<AiEmbedDocument> documents;
@JsonProperty("doc_ids")
private List<String> docIds;
}
@Data
public static class AiEmbedDocument {
@JsonProperty("doc_id")
private String docId;
@JsonProperty("project_id")
private Long projectId;
@JsonProperty("project_type")
private String projectType;
private String title;
private String content;
private Map<String, Object> metadata;
}
@Data
public static class VectorSyncResult {
private boolean success;
private String backend;
private String collection;
private int syncedCount;
private int deletedCount;
private String errorMessage;
}
}
package com.platform.backend.project.service;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.platform.backend.project.common.ProjectBusinessException;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
@Component
@RequiredArgsConstructor
public class ProjectArrayJsonCodec {
private final ObjectMapper objectMapper;
public String writeList(List<String> values) {
try {
return objectMapper.writeValueAsString(values == null ? List.of() : values);
} catch (JsonProcessingException e) {
throw new ProjectBusinessException("数组字段序列化失败");
}
}
public List<String> readList(String value) {
if (value == null || value.isBlank()) {
return new ArrayList<>();
}
try {
return objectMapper.readValue(value, new TypeReference<>() {
});
} catch (JsonProcessingException e) {
return new ArrayList<>();
}
}
}
package com.platform.backend.project.service;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.common.ProjectConstants;
import com.platform.backend.project.dto.FileDtos;
import com.platform.backend.project.entity.ProjectAttachment;
import com.platform.backend.project.repository.ProjectAttachmentRepository;
import com.platform.backend.project.storage.MinioStorageService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
@Service
@RequiredArgsConstructor
public class ProjectFileService {
private final ProjectAttachmentRepository attachmentRepository;
private final MinioStorageService minioStorageService;
private final ProjectService projectService;
private final ProjectPermissionService permissionService;
@Transactional
public FileDtos.UploadResponse upload(
MultipartFile file,
Long projectId,
String projectType,
String fileType,
User user
) {
if (!ProjectConstants.PROJECT_TYPES.contains(projectType)) {
throw new ProjectBusinessException("project_type 仅支持 internal/github/annotation");
}
projectService.getDetailWithoutViewIncrement(projectId, projectType);
String objectName = minioStorageService.upload(file, projectId, projectType);
ProjectAttachment attachment = new ProjectAttachment();
attachment.setProjectId(projectId);
attachment.setProjectType(projectType);
attachment.setFileName(file.getOriginalFilename());
attachment.setFileUrl(objectName);
attachment.setFileType(fileType);
attachment.setUploadedBy(user.getId());
ProjectAttachment saved = attachmentRepository.save(attachment);
FileDtos.UploadResponse response = new FileDtos.UploadResponse();
response.setFileId(saved.getId());
response.setFileName(saved.getFileName());
// 上传接口直接返回可访问的签名 URL,更符合文档里的“文件 URL”语义;
// 数据库存储仍保持 object key,不影响现有下载签名接口和详情页逻辑。
response.setFileUrl(minioStorageService.signedUrl(saved.getFileUrl()));
return response;
}
public FileDtos.DownloadUrlResponse downloadUrl(Long fileId, User user) {
ProjectAttachment attachment = attachmentRepository.findById(fileId)
.orElseThrow(() -> new ProjectBusinessException("文件不存在"));
// 仅在项目模块内按真实 role_code 判断,避免被 User.getRole() 的旧兼容实现误导。
if (!permissionService.hasRole(user, "ADMIN") && !user.getId().equals(attachment.getUploadedBy())) {
throw new ProjectBusinessException("仅文件所有者或 ADMIN 可获取");
}
FileDtos.DownloadUrlResponse response = new FileDtos.DownloadUrlResponse();
response.setUrl(minioStorageService.signedUrl(attachment.getFileUrl()));
response.setExpiresMinutes(30);
return response;
}
}
package com.platform.backend.project.service;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.dto.RecommendationDtos;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.entity.AnnotationProject;
import com.platform.backend.project.entity.GithubProject;
import com.platform.backend.project.entity.ProjectTag;
import com.platform.backend.project.entity.TrainAdvancedMatch;
import com.platform.backend.project.repository.AnnotationProjectRepository;
import com.platform.backend.project.repository.GithubProjectRepository;
import com.platform.backend.project.repository.ProjectTagRepository;
import com.platform.backend.project.repository.TrainAdvancedMatchRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.*;
@Service
@RequiredArgsConstructor
public class ProjectRecommendationService {
private final ProjectService projectService;
private final ProjectAiClientService projectAiClientService;
private final GithubProjectRepository githubProjectRepository;
private final AnnotationProjectRepository annotationProjectRepository;
private final ProjectTagRepository projectTagRepository;
private final TrainAdvancedMatchRepository matchRepository;
private final TrainingTaskCreationService trainingTaskCreationService;
public RecommendationDtos.RecommendationResponse recommend(
RecommendationDtos.RecommendationRequest request,
User user
) {
validateRequest(request);
ProjectDtos.ProjectDetail seedProject = projectService.getDetailWithoutViewIncrement(
request.getSeedProjectId(), "internal");
List<Long> excludeIds = request.getExcludeProjectIds() == null ? List.of() : request.getExcludeProjectIds();
List<CandidateProject> candidates = loadCandidates(request.getProjectType(), excludeIds);
RecommendationDtos.RecommendationResponse response;
try {
response = projectAiClientService.recommend(seedProject, request.getProjectType(), candidates, request.getLimit());
} catch (Exception ex) {
response = buildFallbackResponse(seedProject, request.getProjectType(), candidates, request.getLimit());
}
normalizeRecommendations(seedProject, response);
persistRecommendations(user, seedProject, request.getProjectType(), response);
return response;
}
@Transactional
public RecommendationDtos.RecommendationItem choose(
Long projectId,
RecommendationDtos.RecommendationActionRequest request,
User user
) {
return updateAction(projectId, request, user, "choose");
}
@Transactional
public RecommendationDtos.RecommendationItem ignore(
Long projectId,
RecommendationDtos.RecommendationActionRequest request,
User user
) {
return updateAction(projectId, request, user, "ignore");
}
public RecommendationDtos.RecommendationHistoryResponse history(User user, int page, int size) {
int resolvedPage = Math.max(1, page);
int resolvedSize = Math.max(1, Math.min(size, 100));
var result = matchRepository.findByUserIdOrderByCreatedAtDesc(
user.getId(),
PageRequest.of(resolvedPage - 1, resolvedSize)
);
RecommendationDtos.RecommendationHistoryResponse response = new RecommendationDtos.RecommendationHistoryResponse();
response.setTotal(result.getTotalElements());
response.setPage(resolvedPage);
response.setSize(resolvedSize);
response.setItems(result.getContent().stream().map(this::toHistoryItem).toList());
return response;
}
private void validateRequest(RecommendationDtos.RecommendationRequest request) {
if (!"github".equals(request.getProjectType()) && !"annotation".equals(request.getProjectType())) {
throw new ProjectBusinessException("projectType 仅支持 github/annotation");
}
if (request.getLimit() != null && request.getLimit() < 1) {
throw new ProjectBusinessException("limit 必须大于 0");
}
}
private List<CandidateProject> loadCandidates(String projectType, List<Long> excludeIds) {
Set<Long> excluded = new HashSet<>(excludeIds);
if ("github".equals(projectType)) {
return githubProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.filter(project -> !excluded.contains(project.getId()))
.map(project -> toCandidate(project, loadTags(project.getId(), "github")))
.toList();
}
return annotationProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.filter(project -> !excluded.contains(project.getId()))
.map(project -> toCandidate(project, loadTags(project.getId(), "annotation")))
.toList();
}
private List<String> loadTags(Long projectId, String projectType) {
return projectTagRepository.findByProjectIdAndProjectType(projectId, projectType).stream()
.map(ProjectTag::getTagName)
.toList();
}
private CandidateProject toCandidate(GithubProject project, List<String> tags) {
CandidateProject candidate = new CandidateProject();
candidate.setProjectId(project.getId());
candidate.setProjectType("github");
candidate.setProjectName(project.getRepoName());
candidate.setDescription(project.getDescription());
candidate.setDifficultyLevel(project.getDifficultyLevel());
candidate.setTechStack(parseList(project.getTechStack()));
candidate.setTags(tags);
candidate.setStars(project.getStars() == null ? 0 : project.getStars());
candidate.setGithubUrl(project.getGithubUrl());
return candidate;
}
private CandidateProject toCandidate(AnnotationProject project, List<String> tags) {
CandidateProject candidate = new CandidateProject();
candidate.setProjectId(project.getId());
candidate.setProjectType("annotation");
candidate.setProjectName(project.getName());
candidate.setDescription(project.getIndustry());
candidate.setDifficultyLevel(project.getDifficultyLevel());
candidate.setTechStack(List.of());
candidate.setTags(tags);
candidate.setStars(0);
return candidate;
}
private List<String> parseList(String value) {
if (value == null || value.isBlank()) {
return List.of();
}
return Arrays.stream(value.replace("[", "").replace("]", "").split(","))
.map(String::trim)
.map(item -> item.replaceAll("^\"|\"$", ""))
.filter(item -> !item.isBlank())
.toList();
}
private RecommendationDtos.RecommendationResponse buildFallbackResponse(
ProjectDtos.ProjectDetail seedProject,
String projectType,
List<CandidateProject> candidates,
Integer limit
) {
Set<String> seedTags = normalizeTags(seedProject);
List<CandidateProject> randomized = new ArrayList<>(candidates.stream()
.filter(candidate -> !Collections.disjoint(seedTags, normalizeTags(candidate.getTags(), candidate.getTechStack())))
.toList());
if (randomized.isEmpty()) {
randomized = new ArrayList<>(candidates);
}
Collections.shuffle(randomized);
List<CandidateScore> scored = randomized.stream()
.limit(limit == null ? 5 : limit)
.map(candidate -> new CandidateScore(candidate, fallbackScore(seedProject, candidate), fallbackReason(seedProject, candidate)))
.toList();
RecommendationDtos.RecommendationResponse response = new RecommendationDtos.RecommendationResponse();
response.setSource("fallback");
response.setTotalTime(0);
response.setRecommendations(scored.stream().map(item -> toResponseItem(null, item.candidate(), projectType, item.score(), item.reason()))
.toList());
return response;
}
private BigDecimal fallbackScore(ProjectDtos.ProjectDetail seed, CandidateProject candidate) {
Set<String> seedTags = normalizeTags(seed);
Set<String> candidateTags = normalizeTags(candidate.getTags(), candidate.getTechStack());
long overlap = candidateTags.stream().filter(seedTags::contains).count();
double difficulty = difficultyMatch(seed.getDifficultyLevel(), candidate.getDifficultyLevel());
double starBoost = Math.min(candidate.getStars() / 5000.0, 0.15);
return BigDecimal.valueOf(Math.min(0.99, 0.35 + overlap * 0.18 + difficulty * 0.35 + starBoost))
.setScale(4, RoundingMode.HALF_UP);
}
private double difficultyMatch(String seedLevel, String candidateLevel) {
return 1.0 - (Math.abs(levelIndex(seedLevel) - levelIndex(candidateLevel)) / 4.0);
}
private int levelIndex(String level) {
return switch (level == null ? "" : level) {
case "L1" -> 0;
case "L2" -> 1;
case "L3" -> 2;
case "L4" -> 3;
case "L5" -> 4;
default -> 2;
};
}
private String fallbackReason(ProjectDtos.ProjectDetail seed, CandidateProject candidate) {
List<String> shared = sharedTags(seed, candidate);
String difficulty = candidate.getDifficultyLevel() == null ? "难度适中" : "难度 " + candidate.getDifficultyLevel();
String sharedText = shared.isEmpty() ? "与种子项目的主题较接近" : "共享标签 " + String.join("、", shared);
return "与种子项目“" + seed.getName() + "”匹配:" + sharedText + "," + difficulty + "。";
}
private List<String> sharedTags(ProjectDtos.ProjectDetail seed, CandidateProject candidate) {
Set<String> seedTags = normalizeTags(seed);
Set<String> candidateTags = normalizeTags(candidate.getTags(), candidate.getTechStack());
return candidateTags.stream().filter(seedTags::contains).limit(4).toList();
}
private Set<String> normalizeTags(ProjectDtos.ProjectDetail seed) {
return normalizeTags(seed.getKnowledgeTags(), seed.getTags(), seed.getTechStack());
}
private Set<String> normalizeTags(List<String>... groups) {
Set<String> tags = new LinkedHashSet<>();
for (List<String> group : groups) {
if (group == null) {
continue;
}
for (String value : group) {
if (value != null && !value.isBlank()) {
tags.add(value.trim().toLowerCase(Locale.ROOT));
}
}
}
return tags;
}
private void persistRecommendations(
User user,
ProjectDtos.ProjectDetail seedProject,
String targetProjectType,
RecommendationDtos.RecommendationResponse response
) {
if (response.getRecommendations() == null) {
return;
}
for (RecommendationDtos.RecommendationItem item : response.getRecommendations()) {
TrainAdvancedMatch record = new TrainAdvancedMatch();
record.setUserId(user.getId());
record.setSeedProjectId(seedProject.getId());
record.setSeedProjectType(seedProject.getProjectType());
record.setSeedProjectName(seedProject.getName());
record.setProjectId(item.getProjectId());
record.setProjectType(targetProjectType);
record.setProjectName(item.getProjectName());
record.setMatchScore(item.getMatchScore());
record.setMatchReason(item.getMatchReason());
record.setSource(response.getSource());
record.setUserAction("pending");
matchRepository.save(record);
item.setRecommendationId(record.getId());
}
}
private RecommendationDtos.RecommendationItem updateAction(
Long projectId,
RecommendationDtos.RecommendationActionRequest request,
User user,
String action
) {
if (!"github".equals(request.getProjectType()) && !"annotation".equals(request.getProjectType())) {
throw new ProjectBusinessException("projectType 仅支持 github/annotation");
}
TrainAdvancedMatch record = findMatchRecord(projectId, request, user);
if (!Objects.equals(record.getProjectId(), projectId)
|| !Objects.equals(record.getProjectType(), request.getProjectType())) {
throw new ProjectBusinessException("推荐记录与当前项目不匹配");
}
// 同一条推荐重复提交相同动作时直接返回,避免 choice_count 被重复累加。
if (action.equals(record.getUserAction())) {
return toResponseItem(record, null, request.getProjectType(), record.getMatchScore(), record.getMatchReason());
}
record.setUserAction(action);
record.setActionAt(LocalDateTime.now());
if ("choose".equals(action) && "github".equals(request.getProjectType())) {
githubProjectRepository.findById(projectId).ifPresent(project -> {
project.setChoiceCount((project.getChoiceCount() == null ? 0L : project.getChoiceCount()) + 1);
githubProjectRepository.save(project);
});
}
if ("choose".equals(action)) {
record.setTaskId(trainingTaskCreationService.ensureTaskForRecommendation(user, record).getId());
}
matchRepository.save(record);
return toResponseItem(record, null, request.getProjectType(), record.getMatchScore(), record.getMatchReason());
}
/**
* 统一收口推荐结果,保证匹配度落在 0-1 且保留 4 位小数,并补齐过短的推荐理由。
*/
private void normalizeRecommendations(
ProjectDtos.ProjectDetail seedProject,
RecommendationDtos.RecommendationResponse response
) {
if (response == null || response.getRecommendations() == null) {
return;
}
for (RecommendationDtos.RecommendationItem item : response.getRecommendations()) {
item.setMatchScore(normalizeScore(item.getMatchScore()));
item.setMatchReason(normalizeReason(seedProject, item));
}
}
private BigDecimal normalizeScore(BigDecimal score) {
BigDecimal resolved = score == null ? BigDecimal.ZERO : score;
if (resolved.compareTo(BigDecimal.ZERO) < 0) {
resolved = BigDecimal.ZERO;
} else if (resolved.compareTo(BigDecimal.ONE) > 0) {
resolved = BigDecimal.ONE;
}
return resolved.setScale(4, RoundingMode.HALF_UP);
}
private String normalizeReason(ProjectDtos.ProjectDetail seedProject, RecommendationDtos.RecommendationItem item) {
String projectName = item.getProjectName() == null ? "该项目" : item.getProjectName();
String difficulty = item.getDifficultyLevel() == null || item.getDifficultyLevel().isBlank()
? "难度适中"
: "难度等级为 " + item.getDifficultyLevel();
String techStackText = item.getTechStack() == null || item.getTechStack().isEmpty()
? "主题方向与种子项目较接近"
: "技术栈覆盖 " + String.join("、", item.getTechStack().stream().filter(value -> value != null && !value.isBlank()).limit(4).toList());
String reason = item.getMatchReason();
if (reason == null || reason.isBlank()) {
reason = "";
} else {
reason = reason.trim();
}
String prefix = "与种子项目“" + seedProject.getName() + "”对比,推荐项目“" + projectName + "”";
if (!reason.startsWith("与种子项目")) {
reason = prefix + "在技术主题和训练目标上具备较高相关性。 " + reason;
}
if (reason.length() < 50) {
String supplement = "该推荐结合了当前项目的知识标签、候选项目的技术特征以及 "
+ difficulty + ",同时考虑到 " + techStackText + ",适合作为后续训练任务。";
reason = reason + " " + supplement;
}
if (reason.length() > 200) {
reason = reason.substring(0, 200);
}
return reason.trim();
}
private TrainAdvancedMatch findMatchRecord(Long projectId, RecommendationDtos.RecommendationActionRequest request, User user) {
if (request.getRecommendationId() != null) {
return matchRepository.findByIdAndUserId(request.getRecommendationId(), user.getId())
.orElseThrow(() -> new ProjectBusinessException("推荐记录不存在"));
}
return matchRepository.findFirstByUserIdAndProjectIdAndProjectTypeOrderByCreatedAtDesc(
user.getId(), projectId, request.getProjectType())
.orElseThrow(() -> new ProjectBusinessException("推荐记录不存在"));
}
private RecommendationDtos.RecommendationItem toResponseItem(
TrainAdvancedMatch record,
CandidateProject candidate,
String projectType,
BigDecimal matchScore,
String matchReason
) {
RecommendationDtos.RecommendationItem item = new RecommendationDtos.RecommendationItem();
if (record != null) {
item.setRecommendationId(record.getId());
item.setProjectId(record.getProjectId());
item.setProjectName(record.getProjectName());
item.setProjectType(record.getProjectType());
item.setMatchScore(record.getMatchScore());
item.setMatchReason(record.getMatchReason());
}
if (candidate != null) {
item.setProjectId(candidate.getProjectId());
item.setProjectName(candidate.getProjectName());
item.setProjectType(projectType);
item.setGithubUrl(candidate.getGithubUrl());
item.setDescription(candidate.getDescription());
item.setDifficultyLevel(candidate.getDifficultyLevel());
item.setTechStack(candidate.getTechStack());
item.setStars(candidate.getStars());
item.setMatchScore(matchScore);
item.setMatchReason(matchReason);
}
return item;
}
private RecommendationDtos.RecommendationHistoryItem toHistoryItem(TrainAdvancedMatch record) {
RecommendationDtos.RecommendationHistoryItem item = new RecommendationDtos.RecommendationHistoryItem();
item.setRecommendationId(record.getId());
item.setSeedProjectId(record.getSeedProjectId());
item.setSeedProjectName(record.getSeedProjectName());
item.setProjectId(record.getProjectId());
item.setProjectName(record.getProjectName());
item.setProjectType(record.getProjectType());
item.setMatchScore(record.getMatchScore());
item.setMatchReason(record.getMatchReason());
item.setSource(record.getSource());
item.setUserAction(record.getUserAction());
item.setCreatedAt(record.getCreatedAt());
item.setActionAt(record.getActionAt());
return item;
}
private record CandidateScore(CandidateProject candidate, BigDecimal score, String reason) {
}
public static class CandidateProject {
private Long projectId;
private String projectType;
private String projectName;
private String description;
private String difficultyLevel;
private List<String> techStack = List.of();
private List<String> tags = List.of();
private Integer stars = 0;
private String githubUrl;
public Long getProjectId() {
return projectId;
}
public void setProjectId(Long projectId) {
this.projectId = projectId;
}
public String getProjectType() {
return projectType;
}
public void setProjectType(String projectType) {
this.projectType = projectType;
}
public String getProjectName() {
return projectName;
}
public void setProjectName(String projectName) {
this.projectName = projectName;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getDifficultyLevel() {
return difficultyLevel;
}
public void setDifficultyLevel(String difficultyLevel) {
this.difficultyLevel = difficultyLevel;
}
public List<String> getTechStack() {
return techStack;
}
public void setTechStack(List<String> techStack) {
this.techStack = techStack;
}
public List<String> getTags() {
return tags;
}
public void setTags(List<String> tags) {
this.tags = tags;
}
public Integer getStars() {
return stars;
}
public void setStars(Integer stars) {
this.stars = stars;
}
public String getGithubUrl() {
return githubUrl;
}
public void setGithubUrl(String githubUrl) {
this.githubUrl = githubUrl;
}
}
}
package com.platform.backend.project.service;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.PageResult;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.common.ProjectConstants;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.entity.*;
import com.platform.backend.project.repository.*;
import com.platform.backend.project.storage.MinioStorageService;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;
@Service
@RequiredArgsConstructor
public class ProjectService {
private final InternalProjectRepository internalProjectRepository;
private final GithubProjectRepository githubProjectRepository;
private final AnnotationProjectRepository annotationProjectRepository;
private final ProjectTagRepository projectTagRepository;
private final ProjectAttachmentRepository projectAttachmentRepository;
private final KnowledgePointRepository knowledgePointRepository;
private final DifficultyScoreRepository difficultyScoreRepository;
private final DifficultyCalibrationRepository difficultyCalibrationRepository;
private final TrainTaskRepository trainTaskRepository;
private final TrainAdvancedMatchRepository trainAdvancedMatchRepository;
private final ProjectArrayJsonCodec jsonCodec;
private final ProjectAiClientService projectAiService;
private final KnowledgeExtractionService knowledgeExtractionService;
private final MinioStorageService minioStorageService;
private final ProjectPermissionService permissionService;
@Transactional
public ProjectDtos.ProjectDetail create(ProjectDtos.ProjectRequest request) {
validateRequest(request);
ProjectDtos.ProjectDetail detail = switch (request.getProjectType()) {
case "internal" -> createInternal(request);
case "github" -> createGithub(request);
case "annotation" -> createAnnotation(request);
default -> throw new ProjectBusinessException("projectType 仅支持 internal/github/annotation");
};
replaceTags(detail.getId(), detail.getProjectType(), request.getKnowledgeTags());
fillAssociations(detail, null);
projectAiService.evaluateDifficultyAsync(detail.getId(), detail.getProjectType());
knowledgeExtractionService.extractIfAbsentAsync(detail);
projectAiService.syncProjectVectorAsync(detail);
return detail;
}
@Transactional
public ProjectDtos.ProjectDetail update(Long id, ProjectDtos.ProjectRequest request, User user) {
validateRequest(request);
String existingProjectType = resolveExistingProjectType(id);
if (!existingProjectType.equals(request.getProjectType())) {
throw new ProjectBusinessException("projectType 不可修改");
}
ProjectDtos.ProjectDetail before = getDetailWithoutViewIncrement(id, request.getProjectType());
ProjectDtos.ProjectDetail detail = switch (request.getProjectType()) {
case "internal" -> updateInternal(id, request);
case "github" -> updateGithub(id, request);
case "annotation" -> updateAnnotation(id, request);
default -> throw new ProjectBusinessException("projectType 仅支持 internal/github/annotation");
};
replaceTags(detail.getId(), detail.getProjectType(), request.getKnowledgeTags());
fillAssociations(detail, user);
recordDifficultyCalibrationIfNeeded(before, detail, user);
projectAiService.evaluateDifficultyAsync(detail.getId(), detail.getProjectType());
knowledgeExtractionService.extractIfAbsentAsync(detail);
projectAiService.syncProjectVectorAsync(detail);
return detail;
}
@Transactional
public void delete(Long id, String projectType) {
validateProjectType(projectType);
switch (projectType) {
case "internal" -> {
InternalProject project = internalProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (isProjectUsed(id, "internal", project.getChoiceCount())) {
throw new ProjectBusinessException("该项目已被使用,无法删除");
}
project.setIsDeleted(true);
internalProjectRepository.save(project);
}
case "github" -> {
GithubProject project = githubProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (isProjectUsed(id, "github", project.getChoiceCount())) {
throw new ProjectBusinessException("该项目已被使用,无法删除");
}
project.setIsDeleted(true);
githubProjectRepository.save(project);
}
case "annotation" -> {
AnnotationProject project = annotationProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (isProjectUsed(id, "annotation", project.getChoiceCount())) {
throw new ProjectBusinessException("该项目已被使用,无法删除");
}
project.setIsDeleted(true);
annotationProjectRepository.save(project);
}
default -> throw new ProjectBusinessException("projectType 仅支持 internal/github/annotation");
}
projectAiService.deleteProjectVectorAsync(id, projectType);
}
/**
* 删除前同时检查聚合计数和真实业务记录,避免 choiceCount 未同步时误删已被学员选择的项目。
*/
private boolean isProjectUsed(Long projectId, String projectType, Long choiceCount) {
if (choiceCount != null && choiceCount > 0) {
return true;
}
if (trainTaskRepository.existsByProjectIdAndProjectType(projectId, projectType)) {
return true;
}
return trainAdvancedMatchRepository.existsByProjectIdAndProjectTypeAndUserAction(
projectId,
projectType,
"choose"
);
}
@Transactional
public ProjectDtos.ProjectDetail detail(Long id, String projectType, User user) {
validateProjectType(projectType);
ProjectDtos.ProjectDetail detail = switch (projectType) {
case "internal" -> {
InternalProject project = internalProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (Boolean.TRUE.equals(project.getIsDeleted())) {
throw new ProjectBusinessException("项目不存在");
}
project.setViewCount(project.getViewCount() + 1);
yield toDetail(internalProjectRepository.save(project));
}
case "github" -> {
GithubProject project = githubProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (Boolean.TRUE.equals(project.getIsDeleted())) {
throw new ProjectBusinessException("项目不存在");
}
project.setViewCount(project.getViewCount() + 1);
yield toDetail(githubProjectRepository.save(project));
}
case "annotation" -> {
AnnotationProject project = annotationProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (Boolean.TRUE.equals(project.getIsDeleted())) {
throw new ProjectBusinessException("项目不存在");
}
project.setViewCount(project.getViewCount() + 1);
yield toDetail(annotationProjectRepository.save(project));
}
default -> throw new ProjectBusinessException("projectType 仅支持 internal/github/annotation");
};
fillAssociations(detail, user);
return detail;
}
public PageResult<ProjectDtos.ProjectListItem> list(ProjectDtos.ProjectQuery query) {
int page = Math.max(1, query.getPage());
int size = Math.max(1, Math.min(query.getSize(), 100));
List<ProjectDtos.ProjectListItem> all = new ArrayList<>();
if (query.getProjectType() == null || query.getProjectType().isBlank() || "internal".equals(query.getProjectType())) {
internalProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.map(this::toListItem)
.forEach(all::add);
}
if (query.getProjectType() == null || query.getProjectType().isBlank() || "github".equals(query.getProjectType())) {
githubProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.map(this::toListItem)
.forEach(all::add);
}
if (query.getProjectType() == null || query.getProjectType().isBlank() || "annotation".equals(query.getProjectType())) {
annotationProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.map(this::toListItem)
.forEach(all::add);
}
List<String> tagFilters = splitTags(query.getTag());
List<ProjectDtos.ProjectListItem> filtered = all.stream()
.filter(item -> keywordMatches(item, query.getKeyword()))
.filter(item -> query.getDepartmentId() == null || query.getDepartmentId().equals(0L)
|| Objects.equals(query.getDepartmentId(), findDepartmentId(item.getId(), item.getProjectType())))
.filter(item -> query.getDifficulty() == null || query.getDifficulty().isBlank()
|| query.getDifficulty().equals(item.getDifficultyLevel()))
.filter(item -> tagMatches(item.getTags(), tagFilters, query.getTagMode()))
.sorted(comparator(query.getSort(), query.getOrder()))
.toList();
int from = Math.min((page - 1) * size, filtered.size());
int to = Math.min(from + size, filtered.size());
return new PageResult<>(filtered.size(), page, size, filtered.subList(from, to));
}
public List<ProjectDtos.ProjectSimpleItem> simple(ProjectDtos.ProjectSimpleQuery query) {
ProjectDtos.ProjectQuery listQuery = new ProjectDtos.ProjectQuery();
listQuery.setPage(1);
listQuery.setSize(100);
listQuery.setKeyword(query.getKeyword());
listQuery.setProjectType(query.getProjectType());
listQuery.setDifficulty(query.getDifficulty());
listQuery.setDepartmentId(query.getDepartmentId());
return list(listQuery).getItems().stream().map(item -> {
ProjectDtos.ProjectSimpleItem simple = new ProjectDtos.ProjectSimpleItem();
simple.setId(item.getId());
simple.setName(item.getName());
simple.setDifficultyLevel(item.getDifficultyLevel());
return simple;
}).toList();
}
public ProjectDtos.ProjectDetail getDetailWithoutViewIncrement(Long id, String projectType) {
validateProjectType(projectType);
return switch (projectType) {
case "internal" -> {
InternalProject project = internalProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (Boolean.TRUE.equals(project.getIsDeleted())) {
throw new ProjectBusinessException("项目不存在");
}
yield toDetail(project);
}
case "github" -> {
GithubProject project = githubProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (Boolean.TRUE.equals(project.getIsDeleted())) {
throw new ProjectBusinessException("项目不存在");
}
yield toDetail(project);
}
case "annotation" -> {
AnnotationProject project = annotationProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (Boolean.TRUE.equals(project.getIsDeleted())) {
throw new ProjectBusinessException("项目不存在");
}
yield toDetail(project);
}
default -> throw new ProjectBusinessException("projectType 仅支持 internal/github/annotation");
};
}
private ProjectDtos.ProjectDetail createInternal(ProjectDtos.ProjectRequest request) {
if (internalProjectRepository.existsByNameAndIsDeletedFalse(request.getName())) {
throw new ProjectBusinessException("项目名称已存在");
}
InternalProject project = new InternalProject();
applyInternal(project, request);
return toDetail(internalProjectRepository.save(project));
}
private ProjectDtos.ProjectDetail updateInternal(Long id, ProjectDtos.ProjectRequest request) {
InternalProject project = internalProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (internalProjectRepository.existsByNameAndIdNotAndIsDeletedFalse(request.getName(), id)) {
throw new ProjectBusinessException("项目名称已存在");
}
applyInternal(project, request);
return toDetail(internalProjectRepository.save(project));
}
private void applyInternal(InternalProject project, ProjectDtos.ProjectRequest request) {
project.setName(request.getName());
project.setDescription(request.getDescription());
project.setDepartmentId(request.getDepartmentId());
project.setDepartmentName(request.getDepartmentName());
project.setTechStack(jsonCodec.writeList(request.getTechStack()));
project.setAnnotationType(request.getAnnotationType());
project.setBusinessDomain(request.getBusinessDomain());
project.setDifficultyLevel(request.getDifficultyLevel());
project.setKnowledgeTags(jsonCodec.writeList(request.getKnowledgeTags()));
project.setSourceCodeUrl(request.getSourceCodeUrl());
project.setRequirementDocUrl(request.getRequirementDocUrl());
project.setAcceptanceReportUrl(request.getAcceptanceReportUrl());
project.setStatus(request.getStatus());
}
private ProjectDtos.ProjectDetail createGithub(ProjectDtos.ProjectRequest request) {
if (request.getGithubUrl() == null || request.getGithubUrl().isBlank()) {
throw new ProjectBusinessException("githubUrl 为必填");
}
if (githubProjectRepository.existsByRepoNameAndIsDeletedFalse(request.getName())) {
throw new ProjectBusinessException("项目名称已存在");
}
if (githubProjectRepository.existsByGithubUrlAndIsDeletedFalse(request.getGithubUrl())) {
throw new ProjectBusinessException("GitHub 链接已存在");
}
GithubProject project = new GithubProject();
applyGithub(project, request);
return toDetail(githubProjectRepository.save(project));
}
private ProjectDtos.ProjectDetail updateGithub(Long id, ProjectDtos.ProjectRequest request) {
GithubProject project = githubProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (request.getGithubUrl() == null || request.getGithubUrl().isBlank()) {
throw new ProjectBusinessException("githubUrl 为必填");
}
if (githubProjectRepository.existsByRepoNameAndIdNotAndIsDeletedFalse(request.getName(), id)) {
throw new ProjectBusinessException("项目名称已存在");
}
if (githubProjectRepository.existsByGithubUrlAndIdNotAndIsDeletedFalse(request.getGithubUrl(), id)) {
throw new ProjectBusinessException("GitHub 链接已存在");
}
applyGithub(project, request);
return toDetail(githubProjectRepository.save(project));
}
private void applyGithub(GithubProject project, ProjectDtos.ProjectRequest request) {
project.setRepoName(request.getName());
project.setGithubUrl(request.getGithubUrl());
project.setTechStack(jsonCodec.writeList(request.getTechStack()));
project.setDescription(request.getDescription());
project.setDifficultyLevel(request.getDifficultyLevel());
project.setStars(request.getStars());
project.setStatus(request.getStatus());
}
private ProjectDtos.ProjectDetail createAnnotation(ProjectDtos.ProjectRequest request) {
if (annotationProjectRepository.existsByNameAndIsDeletedFalse(request.getName())) {
throw new ProjectBusinessException("项目名称已存在");
}
AnnotationProject project = new AnnotationProject();
applyAnnotation(project, request);
return toDetail(annotationProjectRepository.save(project));
}
private ProjectDtos.ProjectDetail updateAnnotation(Long id, ProjectDtos.ProjectRequest request) {
AnnotationProject project = annotationProjectRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("项目不存在"));
if (annotationProjectRepository.existsByNameAndIdNotAndIsDeletedFalse(request.getName(), id)) {
throw new ProjectBusinessException("项目名称已存在");
}
applyAnnotation(project, request);
return toDetail(annotationProjectRepository.save(project));
}
private void applyAnnotation(AnnotationProject project, ProjectDtos.ProjectRequest request) {
project.setName(request.getName());
project.setIndustry(request.getIndustry());
project.setAnnotationType(request.getAnnotationType());
project.setDifficultyLevel(request.getDifficultyLevel());
project.setStatus(request.getStatus());
}
@Transactional
public void replaceTags(Long projectId, String projectType, List<String> tags) {
projectTagRepository.deleteByProjectIdAndProjectType(projectId, projectType);
// 先落库删除旧标签,避免同一事务内重新插入同名标签触发唯一索引冲突。
projectTagRepository.flush();
if (tags == null) {
return;
}
tags.stream()
.filter(tag -> tag != null && !tag.isBlank())
.map(String::trim)
.distinct()
.forEach(tag -> {
ProjectTag projectTag = new ProjectTag();
projectTag.setProjectId(projectId);
projectTag.setProjectType(projectType);
projectTag.setTagName(tag);
projectTagRepository.save(projectTag);
});
}
private void validateRequest(ProjectDtos.ProjectRequest request) {
validateProjectType(request.getProjectType());
if (!ProjectConstants.DIFFICULTY_LEVELS.contains(request.getDifficultyLevel())) {
throw new ProjectBusinessException("difficultyLevel 仅接受 L1~L5");
}
}
private void validateProjectType(String projectType) {
if (!ProjectConstants.PROJECT_TYPES.contains(projectType)) {
throw new ProjectBusinessException("projectType 为必填,且仅支持 internal/github/annotation");
}
}
/**
* 更新接口只有 path id + body projectType,需要先反查当前真实类型。
* 若同一个 id 在多张项目表都存在,则拒绝更新,避免错改到其他类型项目。
*/
private String resolveExistingProjectType(Long id) {
List<String> matchedTypes = new ArrayList<>();
internalProjectRepository.findById(id)
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.ifPresent(project -> matchedTypes.add("internal"));
githubProjectRepository.findById(id)
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.ifPresent(project -> matchedTypes.add("github"));
annotationProjectRepository.findById(id)
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.ifPresent(project -> matchedTypes.add("annotation"));
if (matchedTypes.isEmpty()) {
throw new ProjectBusinessException("项目不存在");
}
if (matchedTypes.size() > 1) {
throw new ProjectBusinessException("项目ID存在跨类型冲突,无法确认原始类型");
}
return matchedTypes.get(0);
}
private ProjectDtos.ProjectListItem toListItem(InternalProject project) {
ProjectDtos.ProjectListItem item = new ProjectDtos.ProjectListItem();
item.setId(project.getId());
item.setName(project.getName());
item.setDescription(project.getDescription());
item.setProjectType("internal");
item.setDifficultyLevel(project.getDifficultyLevel());
item.setDifficultyName(ProjectConstants.difficultyName(project.getDifficultyLevel()));
item.setDepartmentName(project.getDepartmentName());
item.setTags(loadTags(project.getId(), "internal"));
item.setViewCount(project.getViewCount());
item.setChoiceCount(project.getChoiceCount());
item.setStatus(project.getStatus());
item.setCreatedAt(project.getCreatedAt());
return item;
}
private ProjectDtos.ProjectListItem toListItem(GithubProject project) {
ProjectDtos.ProjectListItem item = new ProjectDtos.ProjectListItem();
item.setId(project.getId());
item.setName(project.getRepoName());
item.setDescription(project.getDescription());
item.setProjectType("github");
item.setDifficultyLevel(project.getDifficultyLevel());
item.setDifficultyName(ProjectConstants.difficultyName(project.getDifficultyLevel()));
item.setTags(loadTags(project.getId(), "github"));
item.setViewCount(project.getViewCount());
item.setChoiceCount(project.getChoiceCount());
item.setStatus(project.getStatus());
item.setCreatedAt(project.getCreatedAt());
return item;
}
private ProjectDtos.ProjectListItem toListItem(AnnotationProject project) {
ProjectDtos.ProjectListItem item = new ProjectDtos.ProjectListItem();
item.setId(project.getId());
item.setName(project.getName());
item.setProjectType("annotation");
item.setDifficultyLevel(project.getDifficultyLevel());
item.setDifficultyName(ProjectConstants.difficultyName(project.getDifficultyLevel()));
item.setTags(loadTags(project.getId(), "annotation"));
item.setViewCount(project.getViewCount());
item.setChoiceCount(project.getChoiceCount());
item.setStatus(project.getStatus());
item.setCreatedAt(project.getCreatedAt());
return item;
}
private ProjectDtos.ProjectDetail toDetail(InternalProject project) {
ProjectDtos.ProjectDetail detail = new ProjectDtos.ProjectDetail();
detail.setId(project.getId());
detail.setName(project.getName());
detail.setDescription(project.getDescription());
detail.setProjectType("internal");
detail.setDifficultyLevel(project.getDifficultyLevel());
detail.setDifficultyName(ProjectConstants.difficultyName(project.getDifficultyLevel()));
detail.setDepartmentId(project.getDepartmentId());
detail.setDepartmentName(project.getDepartmentName());
detail.setTechStack(jsonCodec.readList(project.getTechStack()));
detail.setAnnotationType(project.getAnnotationType());
detail.setBusinessDomain(project.getBusinessDomain());
detail.setKnowledgeTags(jsonCodec.readList(project.getKnowledgeTags()));
detail.setSourceCodeUrl(project.getSourceCodeUrl());
detail.setRequirementDocUrl(project.getRequirementDocUrl());
detail.setAcceptanceReportUrl(project.getAcceptanceReportUrl());
detail.setViewCount(project.getViewCount());
detail.setChoiceCount(project.getChoiceCount());
detail.setStatus(project.getStatus());
detail.setCreatedAt(project.getCreatedAt());
fillAssociations(detail, null);
return detail;
}
private ProjectDtos.ProjectDetail toDetail(GithubProject project) {
ProjectDtos.ProjectDetail detail = new ProjectDtos.ProjectDetail();
detail.setId(project.getId());
detail.setName(project.getRepoName());
detail.setDescription(project.getDescription());
detail.setProjectType("github");
detail.setDifficultyLevel(project.getDifficultyLevel());
detail.setDifficultyName(ProjectConstants.difficultyName(project.getDifficultyLevel()));
detail.setTechStack(jsonCodec.readList(project.getTechStack()));
detail.setGithubUrl(project.getGithubUrl());
detail.setStars(project.getStars());
detail.setViewCount(project.getViewCount());
detail.setChoiceCount(project.getChoiceCount());
detail.setStatus(project.getStatus());
detail.setCreatedAt(project.getCreatedAt());
fillAssociations(detail, null);
return detail;
}
private ProjectDtos.ProjectDetail toDetail(AnnotationProject project) {
ProjectDtos.ProjectDetail detail = new ProjectDtos.ProjectDetail();
detail.setId(project.getId());
detail.setName(project.getName());
detail.setProjectType("annotation");
detail.setDifficultyLevel(project.getDifficultyLevel());
detail.setDifficultyName(ProjectConstants.difficultyName(project.getDifficultyLevel()));
detail.setAnnotationType(project.getAnnotationType());
detail.setIndustry(project.getIndustry());
detail.setViewCount(project.getViewCount());
detail.setChoiceCount(project.getChoiceCount());
detail.setStatus(project.getStatus());
detail.setCreatedAt(project.getCreatedAt());
fillAssociations(detail, null);
return detail;
}
private void fillAssociations(ProjectDtos.ProjectDetail detail, User user) {
detail.setTags(loadTags(detail.getId(), detail.getProjectType()));
detail.setAttachments(projectAttachmentRepository
.findByProjectIdAndProjectType(detail.getId(), detail.getProjectType())
.stream().map(attachment -> {
ProjectDtos.ProjectAttachmentItem item = new ProjectDtos.ProjectAttachmentItem();
item.setId(attachment.getId());
item.setFileName(attachment.getFileName());
item.setFileUrl(resolveAttachmentUrl(attachment, user));
item.setFileType(attachment.getFileType());
return item;
}).toList());
detail.setKnowledgePoints(knowledgePointRepository
.findByProjectIdAndProjectType(detail.getId(), detail.getProjectType())
.stream().map(point -> {
ProjectDtos.KnowledgePointItem item = new ProjectDtos.KnowledgePointItem();
item.setId(point.getId());
item.setName(point.getName());
item.setDifficulty(point.getDifficulty());
item.setEstimatedHours(point.getEstimatedHours() == null ? null : point.getEstimatedHours().doubleValue());
item.setMaterialUrl(point.getMaterialUrl());
return item;
}).toList());
}
private String resolveAttachmentUrl(ProjectAttachment attachment, User user) {
String objectName = attachment.getFileUrl();
if (objectName == null || objectName.isBlank()) {
return objectName;
}
// 详情接口只对上传者或管理员回填签名 URL,避免绕过下载接口的权限判断。
if (user == null) {
return null;
}
boolean isOwner = user.getId() != null && user.getId().equals(attachment.getUploadedBy());
boolean isAdmin = permissionService.hasRole(user, "ADMIN");
if (!isOwner && !isAdmin) {
return null;
}
try {
return minioStorageService.signedUrl(objectName);
} catch (ProjectBusinessException ex) {
return null;
}
}
private List<String> loadTags(Long projectId, String projectType) {
return projectTagRepository.findByProjectIdAndProjectType(projectId, projectType)
.stream().map(ProjectTag::getTagName).toList();
}
private boolean keywordMatches(ProjectDtos.ProjectListItem item, String keyword) {
if (keyword == null || keyword.isBlank()) {
return true;
}
String lower = keyword.toLowerCase(Locale.ROOT);
return (item.getName() != null && item.getName().toLowerCase(Locale.ROOT).contains(lower))
|| (item.getDescription() != null && item.getDescription().toLowerCase(Locale.ROOT).contains(lower));
}
private boolean tagMatches(List<String> tags, List<String> filters, String mode) {
if (filters.isEmpty()) {
return true;
}
Set<String> tagSet = tags == null ? Set.of() : tags.stream().collect(Collectors.toSet());
if ("AND".equalsIgnoreCase(mode)) {
return tagSet.containsAll(filters);
}
return filters.stream().anyMatch(tagSet::contains);
}
private List<String> splitTags(String value) {
if (value == null || value.isBlank()) {
return List.of();
}
return Arrays.stream(value.split(","))
.map(String::trim)
.filter(tag -> !tag.isBlank())
.toList();
}
private Comparator<ProjectDtos.ProjectListItem> comparator(String sort, String order) {
Comparator<ProjectDtos.ProjectListItem> comparator = switch (sort == null ? "" : sort) {
case "popular" -> Comparator.comparing(ProjectDtos.ProjectListItem::getViewCount, Comparator.nullsLast(Long::compareTo));
case "difficulty" -> Comparator.comparing(ProjectDtos.ProjectListItem::getDifficultyLevel, Comparator.nullsLast(String::compareTo));
default -> Comparator.comparing(ProjectDtos.ProjectListItem::getCreatedAt, Comparator.nullsLast(Comparator.naturalOrder()));
};
if (!"asc".equalsIgnoreCase(order)) {
comparator = comparator.reversed();
}
return comparator;
}
private Long findDepartmentId(Long projectId, String projectType) {
if (!"internal".equals(projectType)) {
return null;
}
return internalProjectRepository.findById(projectId).map(InternalProject::getDepartmentId).orElse(null);
}
private void recordDifficultyCalibrationIfNeeded(
ProjectDtos.ProjectDetail before,
ProjectDtos.ProjectDetail after,
User user
) {
if (before == null || after == null) {
return;
}
if (Objects.equals(before.getDifficultyLevel(), after.getDifficultyLevel())) {
return;
}
DifficultyScore score = difficultyScoreRepository.findByProjectIdAndProjectType(after.getId(), after.getProjectType())
.orElseGet(DifficultyScore::new);
score.setProjectId(after.getId());
score.setProjectType(after.getProjectType());
if (score.getAiSuggestedLevel() == null || score.getAiSuggestedLevel().isBlank()) {
score.setAiSuggestedLevel(after.getDifficultyLevel());
}
score.setCalibratedLevel(after.getDifficultyLevel());
score.setCalibrationStatus("confirmed");
DifficultyScore saved = difficultyScoreRepository.save(score);
DifficultyCalibration calibration = new DifficultyCalibration();
calibration.setScoreId(saved.getId());
calibration.setProjectId(after.getId());
calibration.setProjectType(after.getProjectType());
calibration.setProjectName(after.getName());
calibration.setPreviousLevel(before.getDifficultyLevel());
calibration.setNewLevel(after.getDifficultyLevel());
calibration.setReason("项目更新时调整难度等级");
calibration.setCalibrationBy(user == null ? null : user.getId());
calibration.setCalibrationByName(user == null ? null : (user.getRealName() == null ? user.getUsername() : user.getRealName()));
calibration.setCalibratedAt(LocalDateTime.now());
difficultyCalibrationRepository.save(calibration);
}
}
package com.platform.backend.project.service;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.dto.VectorSyncDtos;
import com.platform.backend.project.repository.AnnotationProjectRepository;
import com.platform.backend.project.repository.GithubProjectRepository;
import com.platform.backend.project.repository.InternalProjectRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service
@RequiredArgsConstructor
public class ProjectVectorSyncService {
private final InternalProjectRepository internalProjectRepository;
private final GithubProjectRepository githubProjectRepository;
private final AnnotationProjectRepository annotationProjectRepository;
private final ProjectService projectService;
private final ProjectAiClientService projectAiClientService;
public VectorSyncDtos.FullSyncResponse fullSync() {
List<ProjectRef> refs = new ArrayList<>();
internalProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.forEach(project -> refs.add(new ProjectRef(project.getId(), "internal")));
githubProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.forEach(project -> refs.add(new ProjectRef(project.getId(), "github")));
annotationProjectRepository.findAll().stream()
.filter(project -> !Boolean.TRUE.equals(project.getIsDeleted()))
.forEach(project -> refs.add(new ProjectRef(project.getId(), "annotation")));
List<VectorSyncDtos.SyncItem> items = new ArrayList<>();
int successCount = 0;
for (ProjectRef ref : refs) {
VectorSyncDtos.SyncItem item = new VectorSyncDtos.SyncItem();
item.setProjectId(ref.projectId());
item.setProjectType(ref.projectType());
try {
ProjectDtos.ProjectDetail detail = projectService.getDetailWithoutViewIncrement(ref.projectId(), ref.projectType());
item.setProjectName(detail.getName());
ProjectAiClientService.VectorSyncResult result = projectAiClientService.syncProjectVector(detail);
item.setSuccess(result.isSuccess());
item.setBackend(result.getBackend());
item.setCollection(result.getCollection());
item.setErrorMessage(result.getErrorMessage());
if (result.isSuccess()) {
successCount++;
}
} catch (Exception ex) {
item.setSuccess(false);
item.setErrorMessage(ex.getMessage());
}
items.add(item);
}
VectorSyncDtos.FullSyncResponse response = new VectorSyncDtos.FullSyncResponse();
response.setTotal(items.size());
response.setSuccessCount(successCount);
response.setFailedCount(items.size() - successCount);
response.setItems(items);
return response;
}
private record ProjectRef(Long projectId, String projectType) {
}
}
package com.platform.backend.project.service;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.common.ProjectConstants;
import com.platform.backend.project.dto.TagDtos;
import com.platform.backend.project.entity.Tag;
import com.platform.backend.project.repository.ProjectTagRepository;
import com.platform.backend.project.repository.TagRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
@Service
@RequiredArgsConstructor
public class TagService {
private final TagRepository tagRepository;
private final ProjectTagRepository projectTagRepository;
public TagDtos.TagListResponse list(String category) {
List<TagDtos.TagItem> items = (category == null || category.isBlank()
? tagRepository.findAll()
: tagRepository.findByCategory(category)).stream()
.sorted(Comparator.comparing(Tag::getCategory).thenComparing(Tag::getName))
.map(this::toItem)
.toList();
Map<String, List<TagDtos.TagItem>> grouped = new LinkedHashMap<>();
for (String tagCategory : ProjectConstants.TAG_CATEGORIES) {
List<TagDtos.TagItem> categoryItems = items.stream()
.filter(item -> tagCategory.equals(item.getCategory()))
.toList();
grouped.put(tagCategory, categoryItems);
}
TagDtos.TagListResponse response = new TagDtos.TagListResponse();
response.setCategories(grouped);
response.setFlatList(items);
return response;
}
@Transactional
public TagDtos.TagItem create(TagDtos.TagRequest request) {
validate(request);
if (tagRepository.existsByName(request.getName())) {
throw new ProjectBusinessException("标签名称已存在");
}
Tag tag = new Tag();
apply(tag, request);
return toItem(tagRepository.save(tag));
}
@Transactional
public TagDtos.TagItem update(Long id, TagDtos.TagRequest request) {
validate(request);
Tag tag = tagRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("标签不存在"));
if (tagRepository.existsByNameAndIdNot(request.getName(), id)) {
throw new ProjectBusinessException("标签名称已存在");
}
apply(tag, request);
return toItem(tagRepository.save(tag));
}
@Transactional
public void delete(Long id) {
Tag tag = tagRepository.findById(id)
.orElseThrow(() -> new ProjectBusinessException("标签不存在"));
long usedCount = projectTagRepository.countByTagName(tag.getName());
if (usedCount > 0) {
throw new ProjectBusinessException("该标签已被 " + usedCount + " 个项目使用");
}
tagRepository.delete(tag);
}
private void validate(TagDtos.TagRequest request) {
if (!ProjectConstants.TAG_CATEGORIES.contains(request.getCategory())) {
throw new ProjectBusinessException("分类仅支持:技术/方向/场景");
}
}
private void apply(Tag tag, TagDtos.TagRequest request) {
tag.setName(request.getName());
tag.setCategory(request.getCategory());
tag.setColor(request.getColor());
}
private TagDtos.TagItem toItem(Tag tag) {
TagDtos.TagItem item = new TagDtos.TagItem();
item.setId(tag.getId());
item.setName(tag.getName());
item.setCategory(tag.getCategory());
item.setColor(tag.getColor());
return item;
}
}
package com.platform.backend.project.service;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.entity.KnowledgePoint;
import com.platform.backend.project.entity.TrainAdvancedMatch;
import com.platform.backend.project.entity.TrainPreviewRecord;
import com.platform.backend.project.entity.TrainTask;
import com.platform.backend.project.repository.KnowledgePointRepository;
import com.platform.backend.project.repository.TrainPreviewRecordRepository;
import com.platform.backend.project.repository.TrainTaskRepository;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
@Service
@RequiredArgsConstructor
public class TrainingTaskCreationService {
private static final List<String> MENTOR_ROLE_CODES = List.of("ROLE_MENTOR", "ROLE_SUPERVISOR", "ROLE_ADMIN");
private final TrainTaskRepository trainTaskRepository;
private final TrainPreviewRecordRepository trainPreviewRecordRepository;
private final KnowledgePointRepository knowledgePointRepository;
private final ProjectService projectService;
private final UserRepository userRepository;
private final RoleRepository roleRepository;
@Transactional
public TrainTask ensureTaskForRecommendation(User user, TrainAdvancedMatch matchRecord) {
Optional<TrainTask> existing = trainTaskRepository.findTopByUserIdAndProjectIdAndProjectTypeOrderByCycleNumberDesc(
user.getId(),
matchRecord.getProjectId(),
matchRecord.getProjectType()
);
if (existing.isPresent()) {
ensurePreviewRecords(existing.get(), matchRecord.getProjectId(), matchRecord.getProjectType());
return existing.get();
}
ProjectDtos.ProjectDetail project = projectService.getDetailWithoutViewIncrement(
matchRecord.getProjectId(),
matchRecord.getProjectType()
);
User mentor = resolveMentor(user.getDepartmentId());
TrainTask task = new TrainTask();
task.setUserId(user.getId());
task.setProjectType(project.getProjectType());
task.setProjectId(project.getId());
task.setProjectName(project.getName());
task.setDifficultyLevel(project.getDifficultyLevel());
task.setCycleNumber(1);
task.setStatus("preview");
if (mentor != null) {
task.setMentorId(mentor.getId());
task.setMentorName(mentor.getRealName());
}
TrainTask saved = trainTaskRepository.save(task);
ensurePreviewRecords(saved, project.getId(), project.getProjectType());
return saved;
}
private void ensurePreviewRecords(TrainTask task, Long projectId, String projectType) {
List<TrainPreviewRecord> existingRecords = trainPreviewRecordRepository.findByTaskIdOrderByIdAsc(task.getId());
if (!existingRecords.isEmpty()) {
return;
}
List<KnowledgePoint> knowledgePoints = knowledgePointRepository.findByProjectIdAndProjectType(projectId, projectType);
if (knowledgePoints.isEmpty()) {
return;
}
List<TrainPreviewRecord> records = new ArrayList<>();
for (KnowledgePoint point : knowledgePoints) {
TrainPreviewRecord record = new TrainPreviewRecord();
record.setTaskId(task.getId());
record.setKnowledgeId(point.getId());
record.setStatus("pending");
records.add(record);
}
trainPreviewRecordRepository.saveAll(records);
}
private User resolveMentor(Long departmentId) {
List<Long> roleIds = MENTOR_ROLE_CODES.stream()
.map(roleRepository::findByRoleCode)
.flatMap(Optional::stream)
.map(Role::getId)
.toList();
if (roleIds.isEmpty()) {
return null;
}
List<User> users = userRepository.findAll();
return users.stream()
.filter(user -> user.getStatus() != null && user.getStatus() == 1)
.filter(user -> roleIds.contains(user.getRoleId()))
.filter(user -> departmentId == null || user.getDepartmentId() == null || departmentId.equals(user.getDepartmentId()))
.findFirst()
.orElseGet(() -> users.stream()
.filter(user -> user.getStatus() != null && user.getStatus() == 1)
.filter(user -> roleIds.contains(user.getRoleId()))
.findFirst()
.orElse(null));
}
}
package com.platform.backend.project.storage;
import com.platform.backend.project.common.ProjectBusinessException;
import io.minio.*;
import io.minio.http.Method;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@Service
@RequiredArgsConstructor
public class MinioStorageService {
private static final long MAX_FILE_SIZE = 50L * 1024 * 1024;
private static final Set<String> ALLOWED_EXTENSIONS = Set.of(
"pdf", "doc", "docx", "xls", "xlsx", "zip", "rar", "7z"
);
private final MinioClient minioClient;
@Value("${minio.bucket}")
private String bucket;
public String upload(MultipartFile file, Long projectId, String projectType) {
validateFile(file);
ensureBucket();
String originalName = file.getOriginalFilename() == null ? "file" : file.getOriginalFilename();
// 按需求文档约定使用 project_id/project_type 分目录,便于对象存储侧排查项目资料。
String objectName = "projects/%s/%s/%s_%s".formatted(
projectId,
projectType,
UUID.randomUUID(),
originalName.replaceAll("[\\\\/]", "_")
);
try {
minioClient.putObject(PutObjectArgs.builder()
.bucket(bucket)
.object(objectName)
.stream(file.getInputStream(), file.getSize(), -1)
.contentType(file.getContentType())
.build());
return objectName;
} catch (Exception e) {
throw new ProjectBusinessException("文件上传失败:" + e.getMessage());
}
}
public String signedUrl(String objectName) {
try {
return minioClient.getPresignedObjectUrl(GetPresignedObjectUrlArgs.builder()
.method(Method.GET)
.bucket(bucket)
.object(objectName)
.expiry(30, TimeUnit.MINUTES)
.build());
} catch (Exception e) {
throw new ProjectBusinessException("签名 URL 生成失败:" + e.getMessage());
}
}
private void ensureBucket() {
try {
boolean exists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucket).build());
if (!exists) {
minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucket).build());
}
} catch (Exception e) {
throw new ProjectBusinessException("MinIO bucket 检查失败:" + e.getMessage());
}
}
private void validateFile(MultipartFile file) {
if (file == null || file.isEmpty()) {
throw new ProjectBusinessException("文件不能为空");
}
if (file.getSize() > MAX_FILE_SIZE) {
throw new ProjectBusinessException("单文件最大 50MB");
}
String name = file.getOriginalFilename();
String extension = "";
if (name != null && name.contains(".")) {
extension = name.substring(name.lastIndexOf('.') + 1).toLowerCase();
}
if (!ALLOWED_EXTENSIONS.contains(extension)) {
throw new ProjectBusinessException("仅支持 PDF/Word/Excel/压缩包");
}
}
}
package com.platform.backend.project.service;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.dto.FileDtos;
import com.platform.backend.project.entity.ProjectAttachment;
import com.platform.backend.project.repository.ProjectAttachmentRepository;
import com.platform.backend.project.storage.MinioStorageService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class ProjectFileServiceTest {
@Mock
private ProjectAttachmentRepository attachmentRepository;
@Mock
private MinioStorageService minioStorageService;
@Mock
private ProjectService projectService;
@Mock
private ProjectPermissionService permissionService;
private ProjectFileService projectFileService;
@BeforeEach
void setUp() {
projectFileService = new ProjectFileService(
attachmentRepository,
minioStorageService,
projectService,
permissionService
);
}
@Test
void downloadUrlAllowsAdminEvenWhenLegacyUserRoleFieldIsNotAdminText() {
User user = new User();
user.setId(100L);
user.setRoleId(1L);
ProjectAttachment attachment = new ProjectAttachment();
attachment.setId(20L);
attachment.setFileUrl("project/github/readme.pdf");
attachment.setUploadedBy(200L);
when(attachmentRepository.findById(20L)).thenReturn(Optional.of(attachment));
when(permissionService.hasRole(user, "ADMIN")).thenReturn(true);
when(minioStorageService.signedUrl("project/github/readme.pdf")).thenReturn("https://signed.example/file");
FileDtos.DownloadUrlResponse response = projectFileService.downloadUrl(20L, user);
assertEquals("https://signed.example/file", response.getUrl());
assertEquals(30, response.getExpiresMinutes());
verify(permissionService).hasRole(user, "ADMIN");
}
@Test
void downloadUrlRejectsNonOwnerNonAdmin() {
User user = new User();
user.setId(100L);
ProjectAttachment attachment = new ProjectAttachment();
attachment.setId(21L);
attachment.setFileUrl("project/github/archive.zip");
attachment.setUploadedBy(200L);
when(attachmentRepository.findById(21L)).thenReturn(Optional.of(attachment));
when(permissionService.hasRole(user, "ADMIN")).thenReturn(false);
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> projectFileService.downloadUrl(21L, user)
);
assertEquals("仅文件所有者或 ADMIN 可获取", exception.getMessage());
}
}
package com.platform.backend.project.service;
import com.platform.backend.entity.User;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.dto.RecommendationDtos;
import com.platform.backend.project.entity.GithubProject;
import com.platform.backend.project.entity.TrainAdvancedMatch;
import com.platform.backend.project.repository.AnnotationProjectRepository;
import com.platform.backend.project.repository.GithubProjectRepository;
import com.platform.backend.project.repository.ProjectTagRepository;
import com.platform.backend.project.repository.TrainAdvancedMatchRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class ProjectRecommendationServiceTest {
@Mock
private ProjectService projectService;
@Mock
private ProjectAiClientService projectAiClientService;
@Mock
private GithubProjectRepository githubProjectRepository;
@Mock
private AnnotationProjectRepository annotationProjectRepository;
@Mock
private ProjectTagRepository projectTagRepository;
@Mock
private TrainAdvancedMatchRepository matchRepository;
@Mock
private TrainingTaskCreationService trainingTaskCreationService;
private ProjectRecommendationService recommendationService;
@BeforeEach
void setUp() {
recommendationService = new ProjectRecommendationService(
projectService,
projectAiClientService,
githubProjectRepository,
annotationProjectRepository,
projectTagRepository,
matchRepository,
trainingTaskCreationService
);
}
@Test
void chooseRejectsRecommendationRecordThatDoesNotMatchPathProject() {
User user = new User();
user.setId(10L);
RecommendationDtos.RecommendationActionRequest request = new RecommendationDtos.RecommendationActionRequest();
request.setRecommendationId(99L);
request.setProjectType("github");
TrainAdvancedMatch record = new TrainAdvancedMatch();
record.setId(99L);
record.setUserId(10L);
record.setProjectId(88L);
record.setProjectType("github");
when(matchRepository.findByIdAndUserId(99L, 10L)).thenReturn(Optional.of(record));
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> recommendationService.choose(77L, request, user)
);
assertEquals("推荐记录与当前项目不匹配", exception.getMessage());
verify(matchRepository, never()).save(any());
}
@Test
void chooseIsIdempotentForAlreadyChosenRecommendation() {
User user = new User();
user.setId(10L);
RecommendationDtos.RecommendationActionRequest request = new RecommendationDtos.RecommendationActionRequest();
request.setRecommendationId(100L);
request.setProjectType("github");
TrainAdvancedMatch record = new TrainAdvancedMatch();
record.setId(100L);
record.setUserId(10L);
record.setProjectId(77L);
record.setProjectType("github");
record.setProjectName("Spring Demo");
record.setMatchScore(new BigDecimal("0.8123"));
record.setMatchReason("已有推荐理由");
record.setUserAction("choose");
when(matchRepository.findByIdAndUserId(100L, 10L)).thenReturn(Optional.of(record));
RecommendationDtos.RecommendationItem result = recommendationService.choose(77L, request, user);
assertEquals(100L, result.getRecommendationId());
assertEquals(new BigDecimal("0.8123"), result.getMatchScore());
verify(githubProjectRepository, never()).findById(any());
verify(trainingTaskCreationService, never()).ensureTaskForRecommendation(any(), any());
verify(matchRepository, never()).save(any());
}
@Test
void recommendNormalizesScoreAndReasonBeforePersisting() {
User user = new User();
user.setId(10L);
ProjectDtos.ProjectDetail seed = new ProjectDtos.ProjectDetail();
seed.setId(1L);
seed.setName("用户管理系统");
seed.setProjectType("internal");
seed.setDifficultyLevel("L3");
seed.setKnowledgeTags(List.of("Java", "Spring Boot"));
seed.setTags(List.of("后端"));
seed.setTechStack(List.of("Java", "MySQL"));
RecommendationDtos.RecommendationRequest request = new RecommendationDtos.RecommendationRequest();
request.setProjectType("github");
request.setSeedProjectId(1L);
request.setLimit(5);
GithubProject githubProject = new GithubProject();
githubProject.setId(2L);
githubProject.setRepoName("demo-repo");
githubProject.setDescription("demo");
githubProject.setDifficultyLevel("L4");
githubProject.setTechStack("[\"Java\",\"Spring Boot\"]");
githubProject.setStars(100);
githubProject.setGithubUrl("https://github.com/demo/repo");
githubProject.setIsDeleted(false);
RecommendationDtos.RecommendationItem aiItem = new RecommendationDtos.RecommendationItem();
aiItem.setProjectId(2L);
aiItem.setProjectName("demo-repo");
aiItem.setProjectType("github");
aiItem.setDifficultyLevel("L4");
aiItem.setTechStack(List.of("Java", "Spring Boot"));
aiItem.setMatchScore(new BigDecimal("1.23456"));
aiItem.setMatchReason("匹配");
RecommendationDtos.RecommendationResponse aiResponse = new RecommendationDtos.RecommendationResponse();
aiResponse.setSource("ai");
aiResponse.setTotalTime(123);
aiResponse.setRecommendations(List.of(aiItem));
when(projectService.getDetailWithoutViewIncrement(1L, "internal")).thenReturn(seed);
when(githubProjectRepository.findAll()).thenReturn(List.of(githubProject));
when(projectTagRepository.findByProjectIdAndProjectType(2L, "github")).thenReturn(List.of());
when(projectAiClientService.recommend(any(), any(), any(), any())).thenReturn(aiResponse);
when(matchRepository.save(any(TrainAdvancedMatch.class))).thenAnswer(invocation -> {
TrainAdvancedMatch saved = invocation.getArgument(0);
saved.setId(501L);
return saved;
});
RecommendationDtos.RecommendationResponse result = recommendationService.recommend(request, user);
assertEquals(new BigDecimal("1.0000"), result.getRecommendations().get(0).getMatchScore());
assertTrue(result.getRecommendations().get(0).getMatchReason().length() >= 50);
verify(matchRepository).save(any(TrainAdvancedMatch.class));
}
}
package com.platform.backend.project.service;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.entity.User;
import com.platform.backend.project.entity.GithubProject;
import com.platform.backend.project.entity.InternalProject;
import com.platform.backend.project.repository.*;
import com.platform.backend.project.storage.MinioStorageService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class ProjectServiceTest {
@Mock
private InternalProjectRepository internalProjectRepository;
@Mock
private GithubProjectRepository githubProjectRepository;
@Mock
private AnnotationProjectRepository annotationProjectRepository;
@Mock
private ProjectTagRepository projectTagRepository;
@Mock
private ProjectAttachmentRepository attachmentRepository;
@Mock
private KnowledgePointRepository knowledgePointRepository;
@Mock
private DifficultyScoreRepository difficultyScoreRepository;
@Mock
private DifficultyCalibrationRepository difficultyCalibrationRepository;
@Mock
private TrainTaskRepository trainTaskRepository;
@Mock
private TrainAdvancedMatchRepository trainAdvancedMatchRepository;
@Mock
private ProjectAiClientService projectAiService;
@Mock
private KnowledgeExtractionService knowledgeExtractionService;
@Mock
private MinioStorageService minioStorageService;
@Mock
private ProjectPermissionService permissionService;
private ProjectService projectService;
@BeforeEach
void setUp() {
projectService = new ProjectService(
internalProjectRepository,
githubProjectRepository,
annotationProjectRepository,
projectTagRepository,
attachmentRepository,
knowledgePointRepository,
difficultyScoreRepository,
difficultyCalibrationRepository,
trainTaskRepository,
trainAdvancedMatchRepository,
new ProjectArrayJsonCodec(new ObjectMapper()),
projectAiService,
knowledgeExtractionService,
minioStorageService,
permissionService
);
}
@Test
void createInternalProjectPersistsTagsAndTriggersAi() {
ProjectDtos.ProjectRequest request = validInternalRequest();
when(internalProjectRepository.existsByNameAndIsDeletedFalse(request.getName())).thenReturn(false);
when(internalProjectRepository.save(any(InternalProject.class))).thenAnswer(invocation -> {
InternalProject project = invocation.getArgument(0);
project.setId(1L);
return project;
});
when(projectTagRepository.findByProjectIdAndProjectType(1L, "internal")).thenReturn(List.of());
when(attachmentRepository.findByProjectIdAndProjectType(1L, "internal")).thenReturn(List.of());
when(knowledgePointRepository.findByProjectIdAndProjectType(1L, "internal")).thenReturn(List.of());
ProjectDtos.ProjectDetail result = projectService.create(request);
assertEquals(1L, result.getId());
assertEquals("internal", result.getProjectType());
verify(projectTagRepository).deleteByProjectIdAndProjectType(1L, "internal");
verify(projectTagRepository).flush();
verify(projectTagRepository, times(2)).save(any());
verify(projectAiService).evaluateDifficultyAsync(1L, "internal");
verify(knowledgeExtractionService).extractIfAbsentAsync(any());
verify(projectAiService).syncProjectVectorAsync(any());
}
@Test
void replaceTagsFlushesDeleteBeforeSavingNormalizedTags() {
projectService.replaceTags(1L, "internal", List.of("Java", " Java ", "后端", " "));
InOrder inOrder = inOrder(projectTagRepository);
inOrder.verify(projectTagRepository).deleteByProjectIdAndProjectType(1L, "internal");
inOrder.verify(projectTagRepository).flush();
verify(projectTagRepository, times(2)).save(any());
verify(projectTagRepository).save(argThat(tag -> "Java".equals(tag.getTagName())));
verify(projectTagRepository).save(argThat(tag -> "后端".equals(tag.getTagName())));
}
@Test
void createRejectsDuplicateName() {
ProjectDtos.ProjectRequest request = validInternalRequest();
when(internalProjectRepository.existsByNameAndIsDeletedFalse(request.getName())).thenReturn(true);
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> projectService.create(request)
);
assertEquals("项目名称已存在", exception.getMessage());
verify(internalProjectRepository, never()).save(any());
}
@Test
void createRejectsInvalidDifficulty() {
ProjectDtos.ProjectRequest request = validInternalRequest();
request.setDifficultyLevel("L6");
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> projectService.create(request)
);
assertEquals("difficultyLevel 仅接受 L1~L5", exception.getMessage());
}
@Test
void updateRejectsProjectTypeChange() {
ProjectDtos.ProjectRequest request = validInternalRequest();
request.setProjectType("github");
InternalProject internal = new InternalProject();
internal.setId(1L);
internal.setIsDeleted(false);
when(internalProjectRepository.findById(1L)).thenReturn(java.util.Optional.of(internal));
when(githubProjectRepository.findById(1L)).thenReturn(java.util.Optional.empty());
when(annotationProjectRepository.findById(1L)).thenReturn(java.util.Optional.empty());
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> projectService.update(1L, request, new User())
);
assertEquals("projectType 不可修改", exception.getMessage());
}
@Test
void createGithubRejectsDuplicateProjectName() {
ProjectDtos.ProjectRequest request = validGithubRequest();
when(githubProjectRepository.existsByRepoNameAndIsDeletedFalse("studyweb")).thenReturn(true);
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> projectService.create(request)
);
assertEquals("项目名称已存在", exception.getMessage());
verify(githubProjectRepository, never()).save(any());
}
@Test
void deleteRejectsProjectWhenTrainTaskExistsEvenIfChoiceCountIsZero() {
GithubProject project = new GithubProject();
project.setId(10L);
project.setChoiceCount(0L);
project.setIsDeleted(false);
when(githubProjectRepository.findById(10L)).thenReturn(java.util.Optional.of(project));
when(trainTaskRepository.existsByProjectIdAndProjectType(10L, "github")).thenReturn(true);
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> projectService.delete(10L, "github")
);
assertEquals("该项目已被使用,无法删除", exception.getMessage());
verify(githubProjectRepository, never()).save(any());
verify(projectAiService, never()).deleteProjectVectorAsync(any(), any());
}
@Test
void deleteRejectsProjectWhenRecommendationChooseRecordExists() {
GithubProject project = new GithubProject();
project.setId(11L);
project.setChoiceCount(0L);
project.setIsDeleted(false);
when(githubProjectRepository.findById(11L)).thenReturn(java.util.Optional.of(project));
when(trainTaskRepository.existsByProjectIdAndProjectType(11L, "github")).thenReturn(false);
when(trainAdvancedMatchRepository.existsByProjectIdAndProjectTypeAndUserAction(11L, "github", "choose"))
.thenReturn(true);
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> projectService.delete(11L, "github")
);
assertEquals("该项目已被使用,无法删除", exception.getMessage());
verify(githubProjectRepository, never()).save(any());
verify(projectAiService, never()).deleteProjectVectorAsync(any(), any());
}
@Test
void deleteSoftDeletesUnusedProjectAndTriggersVectorRemoval() {
GithubProject project = new GithubProject();
project.setId(12L);
project.setChoiceCount(0L);
project.setIsDeleted(false);
when(githubProjectRepository.findById(12L)).thenReturn(java.util.Optional.of(project));
when(trainTaskRepository.existsByProjectIdAndProjectType(12L, "github")).thenReturn(false);
when(trainAdvancedMatchRepository.existsByProjectIdAndProjectTypeAndUserAction(12L, "github", "choose"))
.thenReturn(false);
projectService.delete(12L, "github");
assertTrue(Boolean.TRUE.equals(project.getIsDeleted()));
verify(githubProjectRepository).save(project);
verify(projectAiService).deleteProjectVectorAsync(12L, "github");
}
private ProjectDtos.ProjectRequest validInternalRequest() {
ProjectDtos.ProjectRequest request = new ProjectDtos.ProjectRequest();
request.setName("用户管理系统");
request.setProjectType("internal");
request.setDifficultyLevel("L3");
request.setTechStack(List.of("Java", "Spring Boot"));
request.setKnowledgeTags(List.of("Java", "后端"));
request.setStatus(1);
return request;
}
private ProjectDtos.ProjectRequest validGithubRequest() {
ProjectDtos.ProjectRequest request = new ProjectDtos.ProjectRequest();
request.setName("studyweb");
request.setProjectType("github");
request.setDifficultyLevel("L3");
request.setTechStack(List.of("Java", "Spring Boot"));
request.setGithubUrl("https://github.com/org/studyweb");
request.setStatus(1);
return request;
}
}
package com.platform.backend.project.service;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.dto.VectorSyncDtos;
import com.platform.backend.project.entity.AnnotationProject;
import com.platform.backend.project.entity.GithubProject;
import com.platform.backend.project.entity.InternalProject;
import com.platform.backend.project.repository.AnnotationProjectRepository;
import com.platform.backend.project.repository.GithubProjectRepository;
import com.platform.backend.project.repository.InternalProjectRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class ProjectVectorSyncServiceTest {
@Mock
private InternalProjectRepository internalProjectRepository;
@Mock
private GithubProjectRepository githubProjectRepository;
@Mock
private AnnotationProjectRepository annotationProjectRepository;
@Mock
private ProjectService projectService;
@Mock
private ProjectAiClientService projectAiClientService;
private ProjectVectorSyncService projectVectorSyncService;
@BeforeEach
void setUp() {
projectVectorSyncService = new ProjectVectorSyncService(
internalProjectRepository,
githubProjectRepository,
annotationProjectRepository,
projectService,
projectAiClientService
);
}
@Test
void fullSyncSummarizesSuccessAndFailure() {
InternalProject internal = new InternalProject();
internal.setId(1L);
internal.setIsDeleted(false);
GithubProject github = new GithubProject();
github.setId(2L);
github.setIsDeleted(false);
AnnotationProject annotation = new AnnotationProject();
annotation.setId(3L);
annotation.setIsDeleted(true);
when(internalProjectRepository.findAll()).thenReturn(List.of(internal));
when(githubProjectRepository.findAll()).thenReturn(List.of(github));
when(annotationProjectRepository.findAll()).thenReturn(List.of(annotation));
ProjectDtos.ProjectDetail internalDetail = new ProjectDtos.ProjectDetail();
internalDetail.setId(1L);
internalDetail.setProjectType("internal");
internalDetail.setName("内部项目");
ProjectDtos.ProjectDetail githubDetail = new ProjectDtos.ProjectDetail();
githubDetail.setId(2L);
githubDetail.setProjectType("github");
githubDetail.setName("GitHub 项目");
when(projectService.getDetailWithoutViewIncrement(1L, "internal")).thenReturn(internalDetail);
when(projectService.getDetailWithoutViewIncrement(2L, "github")).thenReturn(githubDetail);
ProjectAiClientService.VectorSyncResult success = new ProjectAiClientService.VectorSyncResult();
success.setSuccess(true);
success.setBackend("memory");
success.setCollection("project_embeddings");
ProjectAiClientService.VectorSyncResult failed = new ProjectAiClientService.VectorSyncResult();
failed.setSuccess(false);
failed.setBackend("memory");
failed.setCollection("project_embeddings");
failed.setErrorMessage("sync failed");
when(projectAiClientService.syncProjectVector(internalDetail)).thenReturn(success);
when(projectAiClientService.syncProjectVector(githubDetail)).thenReturn(failed);
VectorSyncDtos.FullSyncResponse response = projectVectorSyncService.fullSync();
assertEquals(2, response.getTotal());
assertEquals(1, response.getSuccessCount());
assertEquals(1, response.getFailedCount());
assertEquals(2, response.getItems().size());
}
}
package com.platform.backend.project.service;
import com.platform.backend.project.common.ProjectBusinessException;
import com.platform.backend.project.dto.TagDtos;
import com.platform.backend.project.entity.Tag;
import com.platform.backend.project.repository.ProjectTagRepository;
import com.platform.backend.project.repository.TagRepository;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class TagServiceTest {
@Mock
private TagRepository tagRepository;
@Mock
private ProjectTagRepository projectTagRepository;
@InjectMocks
private TagService tagService;
@Test
void createRejectsUnsupportedCategory() {
TagDtos.TagRequest request = request("Java", "其他", "#2196F3");
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> tagService.create(request)
);
assertEquals("分类仅支持:技术/方向/场景", exception.getMessage());
}
@Test
void createRejectsDuplicateName() {
TagDtos.TagRequest request = request("Java", "技术", "#2196F3");
when(tagRepository.existsByName("Java")).thenReturn(true);
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> tagService.create(request)
);
assertEquals("标签名称已存在", exception.getMessage());
}
@Test
void deleteRejectsTagUsedByProjects() {
Tag tag = new Tag();
tag.setId(1L);
tag.setName("Java");
when(tagRepository.findById(1L)).thenReturn(Optional.of(tag));
when(projectTagRepository.countByTagName("Java")).thenReturn(3L);
ProjectBusinessException exception = assertThrows(
ProjectBusinessException.class,
() -> tagService.delete(1L)
);
assertEquals("该标签已被 3 个项目使用", exception.getMessage());
verify(tagRepository, never()).delete(any());
}
private TagDtos.TagRequest request(String name, String category, String color) {
TagDtos.TagRequest request = new TagDtos.TagRequest();
request.setName(name);
request.setCategory(category);
request.setColor(color);
return request;
}
}
package com.platform.backend.project.service;
import com.platform.backend.entity.Role;
import com.platform.backend.entity.User;
import com.platform.backend.project.dto.ProjectDtos;
import com.platform.backend.project.entity.KnowledgePoint;
import com.platform.backend.project.entity.TrainAdvancedMatch;
import com.platform.backend.project.entity.TrainTask;
import com.platform.backend.project.repository.KnowledgePointRepository;
import com.platform.backend.project.repository.TrainPreviewRecordRepository;
import com.platform.backend.project.repository.TrainTaskRepository;
import com.platform.backend.repository.RoleRepository;
import com.platform.backend.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class TrainingTaskCreationServiceTest {
@Mock
private TrainTaskRepository trainTaskRepository;
@Mock
private TrainPreviewRecordRepository trainPreviewRecordRepository;
@Mock
private KnowledgePointRepository knowledgePointRepository;
@Mock
private ProjectService projectService;
@Mock
private UserRepository userRepository;
@Mock
private RoleRepository roleRepository;
private TrainingTaskCreationService trainingTaskCreationService;
@BeforeEach
void setUp() {
trainingTaskCreationService = new TrainingTaskCreationService(
trainTaskRepository,
trainPreviewRecordRepository,
knowledgePointRepository,
projectService,
userRepository,
roleRepository
);
}
@Test
void createTaskFromRecommendationCreatesPreviewRecords() {
User student = new User();
student.setId(101L);
student.setDepartmentId(1L);
student.setStatus(1);
User mentor = new User();
mentor.setId(201L);
mentor.setDepartmentId(1L);
mentor.setRoleId(11L);
mentor.setRealName("导师A");
mentor.setStatus(1);
Role mentorRole = new Role();
mentorRole.setId(11L);
mentorRole.setRoleCode("ROLE_MENTOR");
TrainAdvancedMatch match = new TrainAdvancedMatch();
match.setProjectId(10L);
match.setProjectType("github");
ProjectDtos.ProjectDetail detail = new ProjectDtos.ProjectDetail();
detail.setId(10L);
detail.setName("推荐项目");
detail.setProjectType("github");
detail.setDifficultyLevel("L3");
KnowledgePoint point1 = new KnowledgePoint();
point1.setId(1L);
KnowledgePoint point2 = new KnowledgePoint();
point2.setId(2L);
when(trainTaskRepository.findTopByUserIdAndProjectIdAndProjectTypeOrderByCycleNumberDesc(101L, 10L, "github"))
.thenReturn(Optional.empty());
when(projectService.getDetailWithoutViewIncrement(10L, "github")).thenReturn(detail);
when(roleRepository.findByRoleCode("ROLE_MENTOR")).thenReturn(Optional.of(mentorRole));
when(roleRepository.findByRoleCode("ROLE_SUPERVISOR")).thenReturn(Optional.empty());
when(roleRepository.findByRoleCode("ROLE_ADMIN")).thenReturn(Optional.empty());
when(userRepository.findAll()).thenReturn(List.of(mentor));
when(trainTaskRepository.save(any(TrainTask.class))).thenAnswer(invocation -> {
TrainTask task = invocation.getArgument(0);
task.setId(1001L);
return task;
});
when(trainPreviewRecordRepository.findByTaskIdOrderByIdAsc(1001L)).thenReturn(List.of());
when(knowledgePointRepository.findByProjectIdAndProjectType(10L, "github")).thenReturn(List.of(point1, point2));
TrainTask result = trainingTaskCreationService.ensureTaskForRecommendation(student, match);
assertNotNull(result.getId());
assertEquals(1001L, result.getId());
assertEquals("preview", result.getStatus());
assertEquals(201L, result.getMentorId());
ArgumentCaptor<TrainTask> taskCaptor = ArgumentCaptor.forClass(TrainTask.class);
verify(trainTaskRepository).save(taskCaptor.capture());
assertEquals("推荐项目", taskCaptor.getValue().getProjectName());
verify(trainPreviewRecordRepository).saveAll(argThat(records -> {
int count = 0;
for (var record : records) {
if (!"pending".equals(record.getStatus())) {
return false;
}
count++;
}
return count == 2;
}));
}
@Test
void existingTaskIsReused() {
User student = new User();
student.setId(101L);
TrainAdvancedMatch match = new TrainAdvancedMatch();
match.setProjectId(10L);
match.setProjectType("github");
TrainTask existing = new TrainTask();
existing.setId(3001L);
existing.setUserId(101L);
existing.setProjectId(10L);
existing.setProjectType("github");
when(trainTaskRepository.findTopByUserIdAndProjectIdAndProjectTypeOrderByCycleNumberDesc(101L, 10L, "github"))
.thenReturn(Optional.of(existing));
when(trainPreviewRecordRepository.findByTaskIdOrderByIdAsc(3001L)).thenReturn(List.of());
when(knowledgePointRepository.findByProjectIdAndProjectType(10L, "github")).thenReturn(List.of());
TrainTask result = trainingTaskCreationService.ensureTaskForRecommendation(student, match);
assertEquals(3001L, result.getId());
verify(trainTaskRepository, never()).save(any(TrainTask.class));
verify(projectService, never()).getDetailWithoutViewIncrement(any(), any());
}
}
...@@ -257,13 +257,53 @@ type KnowledgeFilter = { ...@@ -257,13 +257,53 @@ type KnowledgeFilter = {
const api = axios.create({ baseURL: '/api/v1' }); const api = axios.create({ baseURL: '/api/v1' });
api.interceptors.request.use((config) => { api.interceptors.request.use((config) => {
const token = localStorage.getItem('token') || localStorage.getItem('authToken'); const token = localStorage.getItem('accessToken') || localStorage.getItem('token') || localStorage.getItem('authToken');
if (token) { if (token) {
config.headers.Authorization = `Bearer ${token}`; config.headers.Authorization = `Bearer ${token}`;
} }
return config; return config;
}); });
api.interceptors.response.use(
(response) => response,
async (error) => {
const originalRequest = error.config;
if (error.response?.status !== 401 || originalRequest?._retry) {
return Promise.reject(error);
}
const refreshToken = localStorage.getItem('refreshToken');
if (!refreshToken) {
localStorage.removeItem('accessToken');
window.location.href = '/login';
return Promise.reject(error);
}
try {
originalRequest._retry = true;
// 项目页独立 axios 实例也需要 refresh 兜底,避免 accessToken 过期后所有接口直接 401。
const response = await axios.post('/api/v1/auth/refresh', { refreshToken });
const nextAccessToken = response.data?.data?.accessToken;
const nextRefreshToken = response.data?.data?.refreshToken;
if (!nextAccessToken) {
throw new Error('refresh token response missing accessToken');
}
localStorage.setItem('accessToken', nextAccessToken);
if (nextRefreshToken) {
localStorage.setItem('refreshToken', nextRefreshToken);
}
originalRequest.headers = originalRequest.headers || {};
originalRequest.headers.Authorization = `Bearer ${nextAccessToken}`;
return api(originalRequest);
} catch (refreshError) {
localStorage.removeItem('accessToken');
localStorage.removeItem('refreshToken');
window.location.href = '/login';
return Promise.reject(refreshError);
}
},
);
const projectTypeOptions = [ const projectTypeOptions = [
{ label: '内部种子项目', value: 'internal' }, { label: '内部种子项目', value: 'internal' },
{ label: 'GitHub 项目', value: 'github' }, { label: 'GitHub 项目', value: 'github' },
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论