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

ljy_完成项目模块第一版

上级 c173bff4
差异被折叠。
name: knowledge_extract_v1 name: knowledge_extract_v1
version: v1 version: v1
response_schema: knowledge_extract_response.schema.json
required_variables: required_variables:
- project_name - project_name
- project_content - project_content
system: | system: |
You extract learnable knowledge points for intern training materials. You extract learnable knowledge points for intern training materials.
Prefer structured and reviewable output over creative writing. Prefer structured and reviewable output over creative writing.
When response_format is json, return strict JSON only.
user: | user: |
Project: {project_name} Project: {project_name}
Source content: Source content:
......
差异被折叠。
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 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论