提交 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
version: v1
response_schema: knowledge_extract_response.schema.json
required_variables:
- project_name
- project_content
system: |
You extract learnable knowledge points for intern training materials.
Prefer structured and reviewable output over creative writing.
When response_format is json, return strict JSON only.
user: |
Project: {project_name}
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 = {
const api = axios.create({ baseURL: '/api/v1' });
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) {
config.headers.Authorization = `Bearer ${token}`;
}
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 = [
{ label: '内部种子项目', value: 'internal' },
{ label: 'GitHub 项目', value: 'github' },
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论