admin/smartDriveEE
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

图像模型

Browse Source
This commit is contained in:
spllzh
2025-10-15 09:22:08 +08:00
parent 71c0a04b53
commit abd370beb5
23 changed files with 1613 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

652
src/main/java/com/rj/controller/ImageModelController.java Normal file
View File

@@ -0,0 +1,652 @@
package com.rj.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.rj.entity.ImageModel;
import com.rj.service.IImageModelService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
/**
* 图像模型控制器
*
* 提供图像模型相关的RESTful API接口，包括：
* - 图像模型记录的创建、查询、更新、删除操作
* - 分页查询和条件查询功能
* - 根据各种条件查询图像模型记录
* - 统一的响应格式和异常处理
*
* 使用Swagger注解进行API文档生成，支持在线API测试。
* 所有接口都包含完整的参数验证、异常处理和日志记录。
*
* @author 系统生成
* @date 2025/1/30
* @version 1.0
*/
@Slf4j
@RestController
@RequestMapping("/api/image-model")
@Tag(name = "图像模型管理", description = "图像模型相关接口")
public class ImageModelController {
/**
* 图像模型服务接口
* 用于处理图像模型相关的业务逻辑
*/
@Autowired
private IImageModelService imageModelService;
/**
* 图像模型请求DTO
*
* 用于接收创建图像模型记录的请求参数。
* 包含所有必要的字段验证，确保数据的完整性和有效性。
*/
@Data
public static class ImageModelRequest {
/**
* 图像名称，必填字段
*/
@NotBlank(message = "图像名称不能为空")
private String imageName;
private String uuid;
/**
* 模型名称，必填字段
*/
@NotBlank(message = "模型名称不能为空")
private String modelName;
/**
* 所属人姓名，必填字段
*/
@NotBlank(message = "所属人姓名不能为空")
private String ownerName;
/**
* 所属人电话，必填字段
*/
@NotBlank(message = "所属人电话不能为空")
private String ownerPhone;
/**
* 图片类型，必填字段
*/
@NotBlank(message = "图片类型不能为空")
private String imageType;
/**
* 素材URL，可选字段
*/
private String materialUrl;
/**
* 素材临时URL，可选字段
*/
private String materialTempUrl;
/**
* 成品图片URL，可选字段
*/
private String resultImageUrl;
/**
* 成品图片临时URL，可选字段
*/
private String resultImageTempUrl;
/**
* 提示词，可选字段
*/
private String prompt;
/**
* 功能函数名称，可选字段
*/
private String functionName;
/**
* 放大倍数，可选字段
*/
private java.math.BigDecimal scaleFactor;
/**
* 请求ID，可选字段
*/
private String requestId;
/**
* 任务ID，可选字段
*/
private String taskId;
}
/**
* 分页查询请求DTO
*
* 用于接收分页查询图像模型记录的请求参数。
* 支持多种条件筛选，包括所属人信息、模型名称、图片类型等。
*/
@Data
public static class PageRequest {
/**
* 当前页码，默认为1
*/
private Integer current = 1;
/**
* 每页大小，默认为10
*/
private Integer size = 10;
/**
* 所属人姓名，支持模糊查询
*/
private String ownerName;
/**
* 所属人电话，支持模糊查询
*/
private String ownerPhone;
/**
* 模型名称，支持模糊查询
*/
private String modelName;
/**
* 图片类型，精确匹配
*/
private String imageType;
/**
* 开始时间，用于时间范围查询
*/
private String startTime;
/**
* 结束时间，用于时间范围查询
*/
private String endTime;
}
/**
* 创建图像模型记录
*
* 接收图像模型请求参数，创建新的图像模型记录并保存到数据库。
* 该方法会进行参数验证、数据转换、业务处理等完整流程。
*
* @param request 图像模型请求参数，包含所有必要的字段信息
* @return ResponseEntity 包含操作结果的响应实体
* - success: 操作是否成功
* - message: 操作结果消息
* - data: 创建的图像模型记录（成功时）
*/
@PostMapping("/create")
@Operation(summary = "创建图像模型记录", description = "创建新的图像模型记录")
public ResponseEntity<Map<String, Object>> createImageModel(@Valid @RequestBody ImageModelRequest request) {
try {
log.info("创建图像模型记录开始，参数：{}", request);
// 构建图像模型对象，使用属性拷贝简化代码
ImageModel imageModel = new ImageModel();
BeanUtils.copyProperties(request, imageModel);
imageModel.setCreateTime(LocalDateTime.now());
imageModel.setUpdateTime(LocalDateTime.now());
boolean result = imageModelService.saveImageModel(imageModel);
Map<String, Object> response = new HashMap<>();
if (result) {
response.put("success", true);
response.put("message", "图像模型记录创建成功");
response.put("data", imageModel);
log.info("图像模型记录创建成功，ID: {}", imageModel.getUuid());
} else {
response.put("success", false);
response.put("message", "图像模型记录创建失败");
}
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("创建图像模型记录异常", e);
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "创建图像模型记录异常: " + e.getMessage());
return ResponseEntity.status(500).body(response);
}
}
/**
* 根据UUID删除图像模型记录
*
* 通过唯一标识符删除对应的图像模型记录。
* UUID是主键，删除操作是幂等的。
*
* @param uuid 唯一标识符，对应数据库主键
* @return ResponseEntity 包含删除结果的响应实体
* - success: 删除是否成功
* - message: 删除结果消息
*/
@DeleteMapping("/delete/{uuid}")
@Operation(summary = "根据UUID删除图像模型记录", description = "根据唯一标识符删除图像模型记录")
public ResponseEntity<Map<String, Object>> deleteImageModelByUuid(
@Parameter(description = "唯一标识符") @PathVariable String uuid) {
try {
log.info("根据UUID删除图像模型记录，uuid: {}", uuid);
boolean result = imageModelService.removeByUuid(uuid);
Map<String, Object> response = new HashMap<>();
if (result) {
response.put("success", true);
response.put("message", "图像模型记录删除成功");
} else {
response.put("success", false);
response.put("message", "未找到对应的图像模型记录或删除失败");
}
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("根据UUID删除图像模型记录异常", e);
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "删除异常: " + e.getMessage());
return ResponseEntity.status(500).body(response);
}
}
/**
* 去除图像中的中英文字符或常见水印
*
* 调用AI模型去除图像中的水印，支持中英文字符和常见水印的检测与去除。
* 使用场景包括：素材二次处理、广告图净化、图片去水印等。
*
* @param request 图像模型请求参数，包含素材URL和处理参数
* @return ResponseEntity 包含处理结果的响应实体
* - success: 处理是否成功
* - message: 处理结果消息
* - data: 处理后的图像模型记录（包含结果URL）
*/
@PostMapping("/removeWatermar")
@Operation(summary = "去除图像中的中英文字符或常见水印", description = "去除图像中的中英文字符或常见水印。使用场景包括：素材二次处理、广告图净化等")
public ResponseEntity<Map<String, Object>> removeWatermar(@Valid @RequestBody ImageModelRequest request) {
try {
log.info("去除图像中的中英文字符或常见水印开始，参数：{}", request);
// 构建图像模型对象，使用属性拷贝简化代码
ImageModel imageModel = new ImageModel();
BeanUtils.copyProperties(request, imageModel);
imageModel.setCreateTime(LocalDateTime.now());
imageModel.setUpdateTime(LocalDateTime.now());
// 调用服务层进行水印去除处理
ImageModel result = imageModelService.removeWatermar(imageModel);
Map<String, Object> response = new HashMap<>();
response.put("success", true);
response.put("message", "水印去除处理成功");
response.put("data", result);
log.info("水印去除处理成功，ID: {}, 结果URL: {}",
result.getUuid(), result.getResultImageUrl());
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("去除图像水印异常", e);
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "去除图像水印失败: " + e.getMessage());
return ResponseEntity.status(500).body(response);
}
}
/**
* 上传图片素材
*
* 支持图片文件上传，包括文件验证、MinIO存储、URL生成和数据库记录保存。
* 支持多种图片格式：jpg, jpeg, png, gif, bmp, webp
* 文件大小限制：10MB
*
* @param file 上传的图片文件
* @param ownerName 所属人姓名
* @param ownerPhone 所属人电话
* @return ResponseEntity 包含上传结果的响应实体
* - success: 上传是否成功
* - message: 上传结果消息
* - data: 图像模型记录（包含永久URL和临时URL）
*/
@PostMapping("/upload")
@Operation(summary = "上传图片素材", description = "上传图片素材到MinIO存储，生成永久URL和临时URL，并保存记录到数据库")
public ResponseEntity<Map<String, Object>> uploadImageMaterial(
@Parameter(description = "图片文件") @RequestParam("file") MultipartFile file,
@Parameter(description = "所属人姓名") @RequestParam("ownerName") String ownerName,
@Parameter(description = "所属人电话") @RequestParam("ownerPhone") String ownerPhone,
@Parameter(description = "素材名称") @RequestParam("imageName") String imageName) {
try {
String imageType = "material"; // 默认上传的全部是素材。
log.info("开始上传图片素材，文件名：{}，所属人：{}，电话：{}，类型：{}",
file.getOriginalFilename(), ownerName, ownerPhone, imageType);
// 参数验证
if (ownerName == null || ownerName.trim().isEmpty()) {
throw new IllegalArgumentException("所属人姓名不能为空");
}
if (ownerPhone == null || ownerPhone.trim().isEmpty()) {
throw new IllegalArgumentException("所属人电话不能为空");
}
if (imageType == null || imageType.trim().isEmpty()) {
throw new IllegalArgumentException("图片类型不能为空");
}
// 调用服务层进行图片上传
ImageModel result = imageModelService.uploadImageMaterial(file, ownerName, ownerPhone, imageType,imageName);
Map<String, Object> response = new HashMap<>();
response.put("success", true);
response.put("message", "图片素材上传成功");
response.put("data", result);
log.info("图片素材上传成功，ID: {}，永久URL: {}，临时URL: {}",
result.getUuid(), result.getMaterialUrl(), result.getMaterialTempUrl());
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("上传图片素材异常", e);
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "上传图片素材失败: " + e.getMessage());
return ResponseEntity.status(500).body(response);
}
}
/**
* 根据UUID查询图像模型记录
*
* 通过唯一标识符查询对应的图像模型记录。
* UUID是主键，查询结果唯一且准确。
*
* @param uuid 唯一标识符，对应数据库主键
* @return ResponseEntity 包含查询结果的响应实体
* - success: 查询是否成功
* - message: 查询结果消息
* - data: 图像模型记录（找到时）
*/
@GetMapping("/get/{uuid}")
@Operation(summary = "根据UUID查询图像模型记录", description = "根据唯一标识符查询图像模型记录")
public ResponseEntity<Map<String, Object>> getImageModelByUuid(
@Parameter(description = "唯一标识符") @PathVariable String uuid) {
try {
log.info("根据UUID查询图像模型记录，UUID: {}", uuid);
ImageModel imageModel = imageModelService.getByUuid(uuid);
Map<String, Object> response = new HashMap<>();
if (imageModel != null) {
response.put("success", true);
response.put("message", "查询成功");
response.put("data", imageModel);
} else {
response.put("success", false);
response.put("message", "未找到对应的图像模型记录");
}
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("根据UUID查询图像模型记录异常", e);
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "查询异常: " + e.getMessage());
return ResponseEntity.status(500).body(response);
}
}
/**
* 分页查询图像模型记录
*
* 支持多种条件的分页查询功能，包括：
* - 按所属人姓名、电话模糊查询
* - 按模型名称模糊查询
* - 按图片类型精确查询
* - 按时间范围查询
*
* @param request 分页查询请求参数，包含查询条件和分页信息
* @return ResponseEntity 包含分页查询结果的响应实体
* - success: 查询是否成功
* - message: 查询结果消息
* - data: 分页结果（包含记录列表和分页信息）
*/
@Operation(summary = "分页查询图像模型记录", description = "分页查询图像模型记录")
public ResponseEntity<Map<String, Object>> pageImageModel(@RequestBody PageRequest request) {
try {
log.info("分页查询图像模型记录开始，参数：{}", request);
Page<ImageModel> page = new Page<>(request.getCurrent(), request.getSize());
LambdaQueryWrapper<ImageModel> queryWrapper = new LambdaQueryWrapper<>();
if (request.getOwnerName() != null && !request.getOwnerName().trim().isEmpty()) {
queryWrapper.like(ImageModel::getOwnerName, request.getOwnerName());
}
if (request.getOwnerPhone() != null && !request.getOwnerPhone().trim().isEmpty()) {
queryWrapper.like(ImageModel::getOwnerPhone, request.getOwnerPhone());
}
if (request.getModelName() != null && !request.getModelName().trim().isEmpty()) {
queryWrapper.like(ImageModel::getModelName, request.getModelName());
}
if (request.getImageType() != null && !request.getImageType().trim().isEmpty()) {
queryWrapper.eq(ImageModel::getImageType, request.getImageType());
}
queryWrapper.orderByDesc(ImageModel::getCreateTime);
Page<ImageModel> result = imageModelService.page(page, queryWrapper);
Map<String, Object> response = new HashMap<>();
response.put("success", true);
response.put("message", "查询成功");
response.put("data", result);
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("分页查询图像模型记录异常", e);
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "查询异常: " + e.getMessage());
return ResponseEntity.status(500).body(response);
}
}
/**
* 分页查询图像模型列表
*
* 参考face-detect/logs接口实现，返回标准格式的分页查询结果，包含：
* - total: 总记录数
* - current: 当前页码
* - pages: 总页数
* - data: 数据列表
* - size: 每页大小
* - success: 操作是否成功
* - message: 响应消息
*
* @param current 当前页码，默认为1
* @param size 每页大小，默认为10
* @param ownerName 所属人姓名，支持模糊查询
* @param ownerPhone 所属人电话，支持模糊查询
* @param modelName 模型名称，支持模糊查询
* @param imageType 图片类型，精确匹配
* @param startTime 开始时间
* @param endTime 结束时间
* @return ResponseEntity 包含标准格式分页查询结果的响应实体
*/
@PostMapping("/page")
@Operation(summary = "分页查询图像模型列表", description = "分页查询图像模型列表，返回标准格式")
public ResponseEntity<Map<String, Object>> listImageModel(
@Parameter(description = "页码", example = "1")
@RequestParam(defaultValue = "1") Integer current,
@Parameter(description = "每页大小", example = "10")
@RequestParam(defaultValue = "10") Integer size,
@Parameter(description = "所属人姓名")
@RequestParam(required = false) String ownerName,
@Parameter(description = "图像名称")
@RequestParam(required = false) String imageName,
@Parameter(description = "所属人电话")
@RequestParam(required = false) String ownerPhone,
@Parameter(description = "模型名称")
@RequestParam(required = false) String modelName,
@Parameter(description = "图片类型")
@RequestParam(required = false) String imageType,
@Parameter(description = "开始时间")
@RequestParam(required = false) String startTime,
@Parameter(description = "结束时间")
@RequestParam(required = false) String endTime) {
Map<String, Object> result = new HashMap<>();
try {
log.info("分页查询图像模型列表开始，参数：current={}, size={}, ownerName={}, ownerPhone={}, modelName={}, imageType={}, startTime={}, endTime={}",
current, size, ownerName, ownerPhone, modelName, imageType, startTime, endTime);
Page<ImageModel> page = new Page<>(current, size);
LambdaQueryWrapper<ImageModel> queryWrapper = new LambdaQueryWrapper<>();
// 构建查询条件
if (ownerName != null && !ownerName.trim().isEmpty()) {
queryWrapper.like(ImageModel::getOwnerName, ownerName);
}
if (ownerPhone != null && !ownerPhone.trim().isEmpty()) {
queryWrapper.like(ImageModel::getOwnerPhone, ownerPhone);
}
if (modelName != null && !modelName.trim().isEmpty()) {
queryWrapper.like(ImageModel::getModelName, modelName);
}
if (imageType != null && !imageType.trim().isEmpty()) {
queryWrapper.eq(ImageModel::getImageType, imageType);
}
if (startTime != null && !startTime.trim().isEmpty()) {
queryWrapper.ge(ImageModel::getCreateTime, startTime);
}
if (endTime != null && !endTime.trim().isEmpty()) {
queryWrapper.le(ImageModel::getCreateTime, endTime);
}
// 按创建时间降序排列
queryWrapper.orderByDesc(ImageModel::getUpdateTime);
// 执行分页查询
Page<ImageModel> pageResult = imageModelService.page(page, queryWrapper);
// 构建标准格式响应
result.put("success", true);
result.put("message", "查询成功");
result.put("data", pageResult.getRecords());
result.put("total", pageResult.getTotal());
result.put("current", pageResult.getCurrent());
result.put("size", pageResult.getSize());
result.put("pages", pageResult.getPages());
return ResponseEntity.ok(result);
} catch (Exception e) {
log.error("分页查询图像模型列表异常", e);
result.put("success", false);
result.put("message", "查询异常: " + e.getMessage());
return ResponseEntity.status(500).body(result);
}
}
/**
* 根据请求ID查询图像模型记录
*
* 通过请求ID查询对应的图像模型记录。
* 一个请求ID可能对应多条记录，此方法返回最新的一条。
* 主要用于追踪特定请求的处理结果。
*
* @param requestId 请求ID，用于追踪处理请求
* @return ResponseEntity 包含查询结果的响应实体
* - success: 查询是否成功
* - message: 查询结果消息
* - data: 图像模型记录（找到时）
*/
@GetMapping("/get-by-request/{requestId}")
@Operation(summary = "根据请求ID查询图像模型记录", description = "根据请求ID查询图像模型记录")
public ResponseEntity<Map<String, Object>> getImageModelByRequestId(
@Parameter(description = "请求ID") @PathVariable String requestId) {
try {
log.info("根据请求ID查询图像模型记录，requestId: {}", requestId);
ImageModel imageModel = imageModelService.getByRequestId(requestId);
Map<String, Object> response = new HashMap<>();
if (imageModel != null) {
response.put("success", true);
response.put("message", "查询成功");
response.put("data", imageModel);
} else {
response.put("success", false);
response.put("message", "未找到对应的图像模型记录");
}
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("根据请求ID查询图像模型记录异常", e);
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "查询异常: " + e.getMessage());
return ResponseEntity.status(500).body(response);
}
}
/**
* 根据任务ID查询图像模型记录
*
* 通过任务ID查询对应的图像模型记录。
* 一个任务ID可能对应多条记录，此方法返回最新的一条。
* 主要用于查询异步处理任务的结果。
*
* @param taskId 任务ID，用于追踪异步处理任务
* @return ResponseEntity 包含查询结果的响应实体
* - success: 查询是否成功
* - message: 查询结果消息
* - data: 图像模型记录（找到时）
*/
@GetMapping("/get-by-task/{taskId}")
@Operation(summary = "根据任务ID查询图像模型记录", description = "根据任务ID查询图像模型记录")
public ResponseEntity<Map<String, Object>> getImageModelByTaskId(
@Parameter(description = "任务ID") @PathVariable String taskId) {
try {
log.info("根据任务ID查询图像模型记录，taskId: {}", taskId);
ImageModel imageModel = imageModelService.getByTaskId(taskId);
Map<String, Object> response = new HashMap<>();
if (imageModel != null) {
response.put("success", true);
response.put("message", "查询成功");
response.put("data", imageModel);
} else {
response.put("success", false);
response.put("message", "未找到对应的图像模型记录");
}
return ResponseEntity.ok(response);
} catch (Exception e) {
log.error("根据任务ID查询图像模型记录异常", e);
Map<String, Object> response = new HashMap<>();
response.put("success", false);
response.put("message", "查询异常: " + e.getMessage());
return ResponseEntity.status(500).body(response);
}
}
}

119
src/main/java/com/rj/controller/TextModelController.java
View File

@@ -13,8 +13,8 @@ import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
@@ -63,12 +63,19 @@ public class TextModelController {
*/
@Data
public static class LegalRequest {
@NotBlank(message = "法律问题不能为空")
private String question;
@NotBlank(message = "咨询目的不能为空")
private String consultationPurpose;
private String category;
private String jurisdiction;
@NotBlank(message = "大模型名称")
@NotBlank(message = "咨询类型不能为空")
private String consultationType;
@NotBlank(message = "核心诉求不能为空")
private String coreDemand;
@NotBlank(message = "咨询详细内容不能为空")
private String inputText;
@NotBlank(message = "大模型名称不能为空")
private String model;
}
@@ -142,24 +149,17 @@ public class TextModelController {
Map<String, Object> result = new HashMap<>();
try {
log.info("开始法律咨询，问题类别: {}, 管辖区域: {}, 问题长度: {}",
request.getCategory(), request.getJurisdiction(), request.getQuestion().length());
log.info("开始法律咨询，咨询目的: {}, 咨询类型: {}, 核心诉求: {}, 内容长度: {}",
request.getConsultationPurpose(), request.getConsultationType(),
request.getCoreDemand(), request.getInputText().length());
// 模拟法律咨询处理（实际项目中应该调用AI法律服务）
Map<String, Object> legalResponse = performLegalConsultation(request);
result.put("success", true);
result.put("message", "法律咨询完成");
result.put("question", request.getQuestion());
result.put("answer", legalResponse.get("answer"));
result.put("category", legalResponse.get("category"));
result.put("jurisdiction", legalResponse.get("jurisdiction"));
result.put("confidence", legalResponse.get("confidence"));
result.put("relatedLaws", legalResponse.get("relatedLaws"));
result.put("suggestions", legalResponse.get("suggestions"));
result.put("processingTimeMs", 2500);
result.put("requestId", generateRequestId());
result.put("timestamp", LocalDateTime.now());
result.put("inputContent", request.getInputText());
log.info("法律咨询完成，回答长度: {}", legalResponse.get("answer").toString().length());
@@ -259,14 +259,89 @@ public class TextModelController {
*/
private Map<String, Object> performLegalConsultation(LegalRequest request) {
Map<String, Object> response = new HashMap<>();
response.put("answer", "根据您的问题，我建议您咨询专业律师。这是一个复杂的法律问题，需要详细分析具体情况。");
response.put("category", request.getCategory() != null ? request.getCategory() : "一般法律咨询");
response.put("jurisdiction", request.getJurisdiction() != null ? request.getJurisdiction() : "中国大陆");
// 根据咨询目的和类型生成更精准的回答
Generation gen = new Generation();
Message systemMsg = Message.builder()
.role(Role.SYSTEM.getValue())
.content("你是资深律师， 请根据用户咨询类型，核心诉求，咨询目的，详细描述 ，回答用户，用词要严谨 。")
.build();
Message userMsg = Message.builder()
.role(Role.USER.getValue())
.content("咨询吗目的： "+request.getConsultationPurpose() +" , 核心诉求：" + request.getCoreDemand() +
" , 咨询类型：" + request.getConsultationType()+" , 详细描述 ： "+ request.getInputText())
.build();
GenerationParam param = GenerationParam.builder()
// 若没有配置环境变量，请用百炼API Key将下行替换为：.apiKey("sk-xxx")
.apiKey(System.getenv("DASHSCOPE_API_KEY"))
// .model("farui-plus")
.model(request.getModel())
.messages(Arrays.asList(systemMsg, userMsg))
.resultFormat(GenerationParam.ResultFormat.MESSAGE)
.build();
try {
GenerationResult call = gen.call(param);
response.put("answer", call.getOutput().getChoices().get(0).getMessage().getContent());
log.info("法律咨询完成，结果长度: {} ,内容是：{} ", call);
} catch (NoApiKeyException e) {
throw new RuntimeException(e);
} catch (InputRequiredException e) {
throw new RuntimeException(e);
}
response.put("category", getCategoryByType(request.getConsultationType()));
response.put("jurisdiction", "中国大陆");
response.put("confidence", 0.85);
response.put("relatedLaws", new String[]{"民法典", "合同法", "劳动法"});
response.put("suggestions", new String[]{"收集相关证据", "咨询专业律师", "了解相关法律条文"});
response.put("relatedLaws", getRelatedLaws(request.getConsultationType()));
response.put("suggestions", getSuggestions(request.getConsultationPurpose()));
return response;
}
/**
* 根据咨询类型获取分类
*/
private String getCategoryByType(String consultationType) {
switch (consultationType) {
case "document_generation":
return "文档生成咨询";
case "contract_review":
return "合同审查";
case "legal_advice":
return "法律建议";
default:
return "一般法律咨询";
}
}
/**
* 根据咨询类型获取相关法律条文
*/
private String[] getRelatedLaws(String consultationType) {
switch (consultationType) {
case "document_generation":
return new String[]{"民法典", "合同法", "个人信息保护法"};
case "contract_review":
return new String[]{"合同法", "民法典", "公司法"};
case "legal_advice":
return new String[]{"民法典", "劳动法", "消费者权益保护法"};
default:
return new String[]{"民法典", "合同法", "劳动法"};
}
}
/**
* 根据咨询目的获取建议
*/
private String[] getSuggestions(String consultationPurpose) {
return new String[]{
"收集相关证据材料",
"咨询专业律师",
"了解相关法律条文",
"保护个人隐私信息"
};
}
/**
* 执行意图分析的模拟方法

5
src/main/java/com/rj/controller/sys/MenuController.java
View File

@@ -378,6 +378,11 @@ public class MenuController {

5
src/main/java/com/rj/controller/sys/RoleController.java
View File

@@ -348,6 +348,11 @@ public class RoleController {

5
src/main/java/com/rj/controller/sys/UserRoleController.java
View File

@@ -354,6 +354,11 @@ public class UserRoleController {