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

ljy_完成项目模块第一版

上级 c173bff4
差异被折叠。
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:
......
差异被折叠。
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.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.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;
}
}
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论