ruanfa
/
dangan
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

识别任务添加等待状态，添加提交识别定时任务

Browse Source
master
hansha 1 year ago
parent 15c5d7fbd3
commit d38a1e062b
9 changed files with 630 additions and 638 deletions
Show Stats Download Patch File Download Diff File

25
dangan-admin/src/main/resources/application.yml
Unescape View File

@ -7,8 +7,8 @@ ruoyi:
# 版权年份
copyrightYear: 2024
# 文件路径 示例（ Windows配置D:/ruoyi/uploadPath，Linux配置 /home/ruoyi/uploadPath）
#profile: /usr/local/dangan/uploadPath
profile: D:/dangan/uploadPath
profile: /usr/local/dangan/uploadPath
#profile: D:/dangan/uploadPath
# 获取ip地址开关
addressEnabled: false
@ -61,7 +61,7 @@ spring:
# 单个文件大小
max-file-size: 10MB
# 设置总上传的文件大小
max-request-size: 100MB
max-request-size: 300MB
# 服务模块
devtools:
restart:
@ -133,7 +133,18 @@ xss:
urlPatterns: /system/*,/monitor/*,/tool/*
ocr:
#第三方访问地址
url: http://123.57.142.195:443/upload_api
#url: http://localhost:22443/upload_api
#20.206.150.166
#第三方访问地址 #深县服务器IP：20.206.150.166
url1: https://4493yu98cz42.vicp.fun/upload_api
#url1: http://123.57.142.195:443/upload_api
#url1: http://20.206.150.166:22443/upload_api
url2: https://4493yu98cz42.vicp.fun/get_result
#url2: http://123.57.142.195:443/get_result
#url2: http://20.206.150.166:22443/get_result
#url3: http://123.57.142.195:443/get_file_count
#url3: http://20.206.150.166:22443/get_file_count
url4: https://4493yu98cz42.vicp.fun/clear
#url4: http://123.57.142.195:443/clear
#url4: http://20.206.150.166:22443/clear

463
dangan-dangan/src/main/java/com/da/dangan/controller/DangAnCollectController.java
Unescape View File

@ -1,14 +1,13 @@
package com.da.dangan.controller;
import cn.hutool.json.JSONObject;
import com.alibaba.fastjson2.JSONArray;
import com.da.common.config.RuoYiConfig;
import com.da.common.core.controller.BaseController;
import com.da.common.core.domain.AjaxResult;
import com.da.common.utils.file.FileUploadUtils;
import com.da.common.utils.file.FileUtils;
import com.da.dangan.domain.*;
import com.da.dangan.domain.vo.*;
import com.da.dangan.domain.DaPicturesRecard;
import com.da.dangan.domain.DaTask;
import com.da.dangan.domain.vo.PicParams;
import com.da.dangan.service.*;
import com.da.dangan.util.CallThirdInterface;
import com.da.framework.config.ServerConfig;
@ -28,7 +27,6 @@ import java.util.Date;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 档案采集Controller
@ -121,7 +119,7 @@ public class DangAnCollectController extends BaseController {
/**
* 调用ocr识别接口——识别单张/或者正反面图片
*/
@PostMapping("/recongnize")
/*@PostMapping("/recongnize")
public AjaxResult recognize(@RequestBody List<DaPicturesRecard> picRecards) {
String code;
String msg="";
@ -164,27 +162,137 @@ public class DangAnCollectController extends BaseController {
daTaskService.updateDaTask(daTask);
}
}else{
return AjaxResult.error("识别图片不能为0");
return AjaxResult.error("识别图片不能为空");
}
} catch (Exception e) {
e.printStackTrace();
return AjaxResult.error(e.getMessage());
}
return AjaxResult.success("任务接收成功");
}*/
/**
* 创建识别任务
*/
/*@Transactional
@PostMapping("/recongnize")
public AjaxResult recognize(@RequestBody List<DaPicturesRecard> picRecards) {
try {
//获取字典第三方任务最大数量
Integer maxTask = Integer.parseInt(DictUtils.getDictValue("total_task", "third_task_max"));
String code;
String msg = "";
//取所有id的集合 stream()有顺序
if (picRecards != null && picRecards.size() > 0) {
List<Long> ids = picRecards.stream().map(DaPicturesRecard::getId).collect(Collectors.toList());
String ywType = picRecards.get(0).getYwType();
Long muId = picRecards.get(0).getMuId();
String muPath = picRecards.get(0).getMuPath();
//获取所有的文件
List<File> files = new ArrayList<>();
for (DaPicturesRecard picRecard : picRecards) {
String path = getPath(picRecard.getPicUrl());
File file = new File(path);
files.add(file);
}
//创建任务
DaTask daTask = new DaTask();
daTask.setCreateBy(getUsername());
daTask.setMuId(muId);
daTask.setMuPath(muPath);
daTask.setYwType(ywType);
daTask.setNum(picRecards.size());
daTask.setStatus("-1");//默认等待状态 接收成功后修改为1
daTask.setPicIds(StringUtils.join(ids, ","));//逗号分割);
daTask.setUpdateTime(new Date());//等待队列order by 字段
daTaskService.insertDaTask(daTask);
//判断识别中的任务数量
DaTask param = new DaTask();
param.setStatus("1"); //处理中
List<DaTask> daTasks = daTaskService.selectDaTaskListByStatus(param);
if (daTasks != null && daTasks.size() >= maxTask) {//当前识别任务超过10个
return AjaxResult.success("任务进入等待队列");
} else {
//识别中任务<10，调用第三方接口
String result = CallThirdInterface.callThirdInterfaceUpload(url1, files, ywType, ids, daTask.getId());
//! 解析JSON字符串,获取键对应的值
JSONObject jsonobject = new JSONObject(result);
code = jsonobject.getStr("code");
msg = jsonobject.getStr("msg");
//如果code=0 任务接收失败，code=1成功
if (code.equals("0")) {
return AjaxResult.error(msg).put("taskId", daTask.getId());
} else {
daTask.setStatus("1");
daTask.setUpdateTime(new Date());//同时设置updateTime 因定时任务判断任务超时使用updatetime
daTaskService.updateDaTask(daTask);
}
}
return AjaxResult.success("任务接收成功");
} else {
return AjaxResult.error("识别图片不能为空");
}
} catch (Exception e) {
e.printStackTrace();
return AjaxResult.error(e.getMessage());
}
}*/
/**
* 创建识别任务
*/
@PostMapping("/recongnize")
public AjaxResult recognize(@RequestBody List<DaPicturesRecard> picRecards) {
//取所有id的集合 stream()有顺序
try {
if (picRecards != null && picRecards.size() > 0) {
List<Long> ids = picRecards.stream().map(DaPicturesRecard::getId).collect(Collectors.toList());
String ywType = picRecards.get(0).getYwType();
Long muId = picRecards.get(0).getMuId();
String muPath = picRecards.get(0).getMuPath();
//创建任务
DaTask daTask = new DaTask();
daTask.setCreateBy(getUsername());
daTask.setCreateTime(new Date());
daTask.setMuId(muId);
daTask.setMuPath(muPath);
daTask.setYwType(ywType);
daTask.setNum(picRecards.size());
daTask.setStatus("-1");//默认等待状态 接收成功后修改为1
daTask.setPicIds(StringUtils.join(ids, ","));//逗号分割);
daTaskService.insertDaTask(daTask);
} else {
return AjaxResult.error("识别图片不能为空");
}
} catch (Exception e) {
e.printStackTrace();
return AjaxResult.error(e.getMessage());
}
return AjaxResult.success("任务创建成功");
}
/**
* 任务重新识别
*/
/*@Transactional
@PostMapping("/reRecongnize")
public AjaxResult reRecongnize(Long taskId) {
try {
//获取字典第三方任务最大数量
Integer maxTask = Integer.parseInt(DictUtils.getDictValue("total_task", "third_task_max"));
DaTask daTask = daTaskService.selectDaTaskById(taskId);
daTask.setCreateBy(getUsername());//存入操作用户
List<Long> ids;
if(daTask.getSuccessNum()!=null&&daTask.getSuccessNum()>0){
//判断需要上传的图片
if (daTask.getSuccessNum() != null && daTask.getSuccessNum() > 0) {
String failIds = daTask.getFailIds();
ids = Stream.of(failIds.split(","))
.map(Long::parseLong)
.collect(Collectors.toList());
}else {
} else {
String picIds = daTask.getPicIds();
ids = Stream.of(picIds.split(","))
.map(Long::parseLong)
@ -194,7 +302,6 @@ public class DangAnCollectController extends BaseController {
List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(ids.toArray(new Long[ids.size()]));
String code;
String msg;
try {
//获取所有的文件
List<File> files = new ArrayList<>();
for (DaPicturesRecard picRecard : picRecards) {
@ -202,331 +309,61 @@ public class DangAnCollectController extends BaseController {
File file = new File(path);
files.add(file);
}
//判断第三方接口识别中的任务数量
DaTask param = new DaTask();
param.setStatus("1"); //处理中
List<DaTask> daTasks = daTaskService.selectDaTaskListByStatus(param);
if (daTasks != null && daTasks.size() >= maxTask) {//当前识别任务超过10个
daTask.setStatus("-1"); //设置状态等待
daTask.setUpdateTime(new Date());//等待队列order by 字段
daTaskService.updateDaTask(daTask);
return AjaxResult.success("任务进入等待队列");
} else {//识别中任务<10
//调用第三方接口 先清数据
CallThirdInterface.callThirdInterfaceClearByTaskId(url4,taskId);
String result = CallThirdInterface.callThirdInterfaceUpload(url1, files, daTask.getYwType(), ids,taskId);
CallThirdInterface.callThirdInterfaceClearByTaskId(url4, taskId);
String result = CallThirdInterface.callThirdInterfaceUpload(url1, files, daTask.getYwType(), ids, taskId);
//! 解析JSON字符串,获取键对应的值
JSONObject jsonobject = new JSONObject(result);
code = jsonobject.getStr("code");
msg = jsonobject.getStr("msg");
//记录最后一次识别的操作时间、操作人
//记录最后一次识别的操作时间
daTask.setUpdateTime(new Date());
daTask.setUpdateBy(getUsername());
if (code.equals("0")) { //code=0 任务接收失败，code=1成功
daTask.setStatus("0");
daTaskService.updateDaTask(daTask);
return AjaxResult.error(msg);
}else{
} else {
daTask.setStatus("1");
daTask.setLastNum(picRecards.size());
daTaskService.updateDaTask(daTask);
}
}
} catch (Exception e) {
e.printStackTrace();
return AjaxResult.error(e.getMessage());
}
return AjaxResult.success("任务接收成功");
}
}*/
/**
* 调用ocr识别接口——旧接口，已弃用
* 任务重新识别
*/
@PostMapping("/recongnize-old")
public AjaxResult recognizeOld(@RequestBody List<DaPicturesRecard> picRecards) {
String code;
String msg;
int success;
int total;
List<DaPicturesRecard> failList = new ArrayList<>();
@PostMapping("/reRecongnize")
public AjaxResult reRecongnize(Long taskId) {
try {
//取所有id的集合 stream()有顺序
List<Long> ids = picRecards.stream().map(DaPicturesRecard::getId).collect(Collectors.toList());
String ywType = picRecards.get(0).getYwType();
Long muId = picRecards.get(0).getMuId();
String muPath = picRecards.get(0).getMuPath();
// String singleOrDouble = picRecards.get(0).getSingelOrDouble();
//获取所有的文件
List<File> files = new ArrayList<>();
for (DaPicturesRecard picRecard : picRecards) {
String path = getPath(picRecard.getPicUrl());
File file = new File(path);
files.add(file);
}
// TODO————————多线程循环调用第三方接口
long start = System.currentTimeMillis();
/*List<CompletableFuture<String>> futures = new ArrayList<>();
List<String> results = new ArrayList<>();
for(File file :files){
System.out.println("线程执行前----------------"+file.getName());
futures.add(CompletableFuture.supplyAsync(() ->testAsync(file,picRecards[0].getYwType()) , threadPoolTaskExecutor)); // 用自定义线程池
}
// 所有请求完成后处理逻辑
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).thenRun(() -> {
//join控制线程顺序
results = futures.stream().map(CompletableFuture::join).collect(Collectors.toList());
logger.info("线程执行完毕：{}", JSON.toJSONString(results));
});
long end =System.currentTimeMillis();
logger.info("CompletableFuture耗时--——————————————————》"+ (end-start)+"ms");*/
//不使用循环调用接口 直接传递数组 ，在callThirdInterface方法内直接添加了username参数
String result = CallThirdInterface.callThirdInterfaceUpload(url1, files, ywType, ids,1l);
long end = System.currentTimeMillis();
logger.info("CompletableFuture耗时--——————————————————》" + (end - start) + "ms");
//! 解析JSON字符串,获取键对应的值
JSONObject jsonobject = new JSONObject(result);
code = jsonobject.getStr("code");
msg = jsonobject.getStr("msg");
success = jsonobject.getInt("success");
total = jsonobject.getInt("total");
//失败id
String failPicid = jsonobject.getStr("failPicid");
//获取失败的id集合
List<Long> failIds = JSONArray.parseArray(failPicid, Long.class);
//并行不带顺序取出失败集合
failList = picRecards.parallelStream().filter(recard -> failIds.contains(recard.getId())).collect(Collectors.toList());
//如果code=0 识别失败，直接返回
if (code.equals("0")) {
return AjaxResult.error(msg + ", 成功：" + success + " , 总共：" + total);
} else {
String datas = jsonobject.getStr("datas");
// TODO 数据解析 根据业务类型存储识别后的信息
/*<option value="option1">常住人口登记表1</option> <option value="option2">常住卡</option>
<option value="option3">常住人口登记表2</option>
<option value="option4">出生医学证明</option>
<option value="option5">迁移证</option>
<option value="option6">一胎证明</option>
<option value="option7">转非农业人口批复存根</option>
<option value="option8">准迁证</option>
<option value="option9">常住人口登记表3</option>*/
Long dajlId = null;
switch (ywType) {
case "option1":
//break;
case "option2":
// break;
case "option3":
//break;
case "option9":
//获取常住人口信息集合
List<CzrkDatas> czrkDatas = JSONArray.parseArray(datas, CzrkDatas.class);
for (CzrkDatas czrkData : czrkDatas) {
List<Long> picids = czrkData.getPicid();
String picIds = StringUtils.join(picids, ",");//逗号分割
List<String> picUrls = picRecards.stream()
.filter(recard -> picids.contains(recard.getId()))
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaCzrkdj> info = czrkData.getInfo();
if (info != null && info.size() > 0) {
for (DaCzrkdj daCzrkdj : info) {
//判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(daCzrkdj,"无")){
continue;
}*/
daCzrkdj.setAllPicIds(picIds);
daCzrkdj.setAllPics(pictures);
daCzrkdj.setPicIds(picIds);
daCzrkdj.setPictures(pictures);
//其他字段存储
daCzrkdj.setYwType(ywType);
daCzrkdj.setMuId(muId);
daCzrkdj.setMuPath(muPath);
daCzrkdj.setAuditStatus("0");
daCzrkdj.setErrorCorrect("0");
//daCzrkdj.setCreateBy();
daCzrkdjService.insertDaCzrkdj(daCzrkdj);
}
}
}
break;
case "option4":
//获取出生医学证明信息集合
List<CszmDatas> cszmDatas = JSONArray.parseArray(datas, CszmDatas.class);
for (CszmDatas cszmData : cszmDatas) {
List<Long> picids = cszmData.getPicid();
String picIds = StringUtils.join(picids, ",");//逗号分割
List<String> picUrls = picRecards.stream()
.filter(recard -> picids.contains(recard.getId()))
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaBirthDj> info = cszmData.getInfo();
if (info != null && info.size() > 0) {
for (DaBirthDj daBirthdj : info) {
//判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(daBirthdj,"无")){
continue;
}*/
daBirthdj.setAllPicIds(picIds);
daBirthdj.setAllPics(pictures);
daBirthdj.setPicIds(picIds);
daBirthdj.setPictures(pictures);
//其他字段存储
daBirthdj.setYwType(ywType);
daBirthdj.setMuId(muId);
daBirthdj.setMuPath(muPath);
daBirthdj.setAuditStatus("0");
daBirthdj.setErrorCorrect("0");
daBirthDjService.insertDaBirthDj(daBirthdj);
}
}
}
break;
case "option5":
//获取迁移证信息集合
List<QyzDatas> qyzDatas = JSONArray.parseArray(datas, QyzDatas.class);
for (QyzDatas qyzData : qyzDatas) {
List<Long> picids = qyzData.getPicid();
String picIds = StringUtils.join(picids, ",");//逗号分割
List<String> picUrls = picRecards.stream()
.filter(recard -> picids.contains(recard.getId()))
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaQyz> info = qyzData.getInfo();
if (info != null && info.size() > 0) {
for (DaQyz qyz : info) {
//判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(qyz,"无")){
continue;
}*/
qyz.setAllPicIds(picIds);
qyz.setAllPics(pictures);
qyz.setPicIds(picIds);
qyz.setPictures(pictures);
//其他字段存储
qyz.setYwType(ywType);
qyz.setMuId(muId);
qyz.setMuPath(muPath);
qyz.setAuditStatus("0");
qyz.setErrorCorrect("0");
daQyzService.insertDaQyz(qyz);
}
}
}
break;
case "option6":
//获取一胎证明信息集合
List<YtzmDatas> ytzmDatas = JSONArray.parseArray(datas, YtzmDatas.class);
for (YtzmDatas ytzmData : ytzmDatas) {
List<Long> picids = ytzmData.getPicid();
String picIds = StringUtils.join(picids, ",");//逗号分割
List<String> picUrls = picRecards.stream()
.filter(recard -> picids.contains(recard.getId()))
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaYtzm> info = ytzmData.getInfo();
if (info != null && info.size() > 0) {
for (DaYtzm ytzm : info) {
//判断返回结果是否都是字符串 "无"
/* if(CallThirdInterface.allFieldsEqualTo(ytzm,"无")){
continue;
}*/
ytzm.setAllPicIds(picIds);
ytzm.setAllPics(pictures);
ytzm.setPicIds(picIds);
ytzm.setPictures(pictures);
//其他字段存储
ytzm.setYwType(ywType);
ytzm.setMuId(muId);
ytzm.setMuPath(muPath);
ytzm.setAuditStatus("0");
ytzm.setErrorCorrect("0");
daYtzmService.insertDaYtzm(ytzm);
}
}
}
break;
case "option7":
//获取转非农业人口批复存根信息集合
List<ZfnyDatas> zfnyDatas = JSONArray.parseArray(datas, ZfnyDatas.class);
for (ZfnyDatas zfnyData : zfnyDatas) {
List<Long> picids = zfnyData.getPicid();
String picIds = StringUtils.join(picids, ",");//逗号分割
List<String> picUrls = picRecards.stream()
.filter(recard -> picids.contains(recard.getId()))
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaZfnyhkcg> info = zfnyData.getInfo();
if (info != null && info.size() > 0) {
for (DaZfnyhkcg zfnyhkcg : info) {
//判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(zfnyhkcg,"无")){
continue;
}*/
zfnyhkcg.setAllPicIds(picIds);
zfnyhkcg.setAllPics(pictures);
zfnyhkcg.setPicIds(picIds);
zfnyhkcg.setPictures(pictures);
//其他字段存储
zfnyhkcg.setYwType(ywType);
zfnyhkcg.setMuId(muId);
zfnyhkcg.setMuPath(muPath);
zfnyhkcg.setAuditStatus("0");
zfnyhkcg.setErrorCorrect("0");
daZfnyhkcgService.insertDaZfnyhkcg(zfnyhkcg);
}
}
}
break;
case "option8":
//获取准迁证信息集合
List<ZqzDatas> zqzDatas = JSONArray.parseArray(datas, ZqzDatas.class);
for (ZqzDatas zqzData : zqzDatas) {
List<Long> picids = zqzData.getPicid();
String picIds = StringUtils.join(picids, ",");//逗号分割
List<String> picUrls = picRecards.stream()
.filter(recard -> picids.contains(recard.getId()))
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaZqz> info = zqzData.getInfo();
if (info != null && info.size() > 0) {
for (DaZqz zqz : info) {
//判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(zqz,"无")){
continue;
}*/
zqz.setAllPicIds(picIds);
zqz.setAllPics(pictures);
zqz.setPicIds(picIds);
zqz.setPictures(pictures);
//其他字段存储
zqz.setYwType(ywType);
zqz.setMuId(muId);
zqz.setMuPath(muPath);
zqz.setAuditStatus("0");
zqz.setErrorCorrect("0");
daZqzService.insertDaZqz(zqz);
}
}
}
break;
}
DaTask daTask = daTaskService.selectDaTaskById(taskId);
// daTask.setCreateBy(getUsername());//存入操作用户
//修改任务状态
daTask.setStatus("-1");//默认等待状态
daTaskService.updateDaTask(daTask);
/*//修改图片信息记录表为已识别 .如果有失败数据，剔除失败数据---现在新增合集信息处做图片已识别修改
if (failList.size() > 0) {
picRecards.removeAll(failList);
}
for (DaPicturesRecard picRecard : picRecards) {
picRecard.setRecognize("1");
daPicturesRecardService.updateDaPicturesRecard(picRecard);
}*/
}
} catch (Exception e) {
e.printStackTrace();
return AjaxResult.error(e.getMessage());
}
return AjaxResult.success("成功：" + success + " , 总共："+total).put("fails", failList);
// return AjaxResult.success();
return AjaxResult.success("提交成功");
}
/**
@ -565,7 +402,7 @@ public class DangAnCollectController extends BaseController {
long start = System.currentTimeMillis();
//参数:地址、文件、业务类型、单双面： 1单面 2双面
//String result = CallThirdInterface.callThirdInterface(url, files, ywType,singleOrDouble,ids);
String result = CallThirdInterface.callThirdInterfaceUpload(url1, files, ywType, ids,1l);
String result = CallThirdInterface.callThirdInterfaceUpload(url1, files, ywType, ids, 1l);
long end = System.currentTimeMillis();
logger.info("CompletableFuture耗时--——————————————————》" + (end - start) + "ms");
@ -717,18 +554,6 @@ public class DangAnCollectController extends BaseController {
}*/
/**
* 图片批量识别处理进度____暂时未用 前端直接调用第三方进度接口
*/
/*@GetMapping("/progress")
public ResponseEntity<Double> getProgress() {
//调用第三方进度条接口
// 返回进度值，例如：0.5代表50%
return ResponseEntity.ok(0.5);
}*/
/**
* 测试第三方接口
*/

2
dangan-dangan/src/main/java/com/da/dangan/mapper/DaTaskMapper.java
Unescape View File

@ -59,4 +59,6 @@ public interface DaTaskMapper
* @return 结果
*/
public int deleteDaTaskByIds(Long[] ids);
List<DaTask> selectDaTaskListByStatus(DaTask daTask);
}

2
dangan-dangan/src/main/java/com/da/dangan/service/IDaTaskService.java
Unescape View File

@ -59,4 +59,6 @@ public interface IDaTaskService
* @return 结果
*/
public int deleteDaTaskById(Long id);
List<DaTask> selectDaTaskListByStatus(DaTask param);
}

11
dangan-dangan/src/main/java/com/da/dangan/service/impl/DaTaskServiceImpl.java
Unescape View File

@ -45,6 +45,15 @@ public class DaTaskServiceImpl implements IDaTaskService
return daTaskMapper.selectDaTaskList(daTask);
}
/**
* 根据任务状态查询符合条件的任务
* @param param
* @return
*/
@Override
public List<DaTask> selectDaTaskListByStatus(DaTask param) {
return daTaskMapper.selectDaTaskListByStatus(param);
}
/**
* 新增识别任务记录
*
@ -94,4 +103,6 @@ public class DaTaskServiceImpl implements IDaTaskService
{
return daTaskMapper.deleteDaTaskById(id);
}
}

164
dangan-dangan/src/main/java/com/da/dangan/timetask/TimeTask.java
Unescape View File

@ -2,6 +2,7 @@ package com.da.dangan.timetask;
import cn.hutool.json.JSONObject;
import com.alibaba.fastjson2.JSONArray;
import com.da.common.config.RuoYiConfig;
import com.da.common.utils.DictUtils;
import com.da.dangan.domain.*;
import com.da.dangan.domain.vo.*;
@ -13,8 +14,9 @@ import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
@ -26,8 +28,7 @@ import java.util.stream.Stream;
* @author ruoyi
*/
@Component("timeTask")
public class TimeTask
{
public class TimeTask {
@Autowired
private IDaTaskService daTaskService;
@Autowired
@ -48,20 +49,28 @@ public class TimeTask
private String url2;
@Value("${ocr.url4}")
private String url4;
@Value("${ocr.url1}")
private String url1;
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Transactional
public void daNoParams() throws Exception {
/**
* 定时任务查询识别中任务的结果，并对结果进行解析存储，相应的改变任务状态
*
* @throws Exception
*/
public void getTaskResult() {
String result = "";
try {
DaTask param = new DaTask();
param.setStatus("1"); //处理中
//查询所有未完成的任务
List<DaTask> daTasks = daTaskService.selectDaTaskList(param);
if(daTasks!=null&&daTasks.size()>0){
for(DaTask datask:daTasks){
//查询所有识别中的任务
List<DaTask> daTasks = daTaskService.selectDaTaskListByStatus(param);
if (daTasks != null && daTasks.size() > 0) {
for (DaTask datask : daTasks) {
//查看认识是否超时, 计算两个日期之间的差值（毫秒） 分钟-> / (1000 * 60)
long diff = (new Date().getTime()-datask.getUpdateTime().getTime())/(1000 * 60 );
long diff = (new Date().getTime() - datask.getUpdateTime().getTime()) / (1000 * 60);
String expired = DictUtils.getDictValue("task_time_out", "task_timeout");
if(diff> Long.parseLong(expired)){
if (diff > Long.parseLong(expired)) {
datask.setStatus("3"); //设置状态任务超时
daTaskService.updateDaTask(datask);
continue;
@ -70,24 +79,27 @@ public class TimeTask
String ywType = datask.getYwType();
Long muId = datask.getMuId();
String muPath = datask.getMuPath();
logger.info("--------开启任务:"+datask.getId()+"结果查询");
logger.info("--------开启任务:" + datask.getId() + "结果查询");
//调用第三方接口查看识别任务状态 已结束直接取结果，处理中跳过
String result = CallThirdInterface.callThirdInterfaceGetByTaskId(url2, datask.getId());
result = CallThirdInterface.callThirdInterfaceGetByTaskId(url2, datask.getId());
//! 解析JSON字符串,获取键对应的值
JSONObject jsonobject = new JSONObject(result);
String status = jsonobject.getStr("status");
// if(status!=null&&!status.trim().equals("")){
if(status.equals("1")){ //1处理中
JSONObject jsonobject = null;
String status = null;
String msg = null;
jsonobject = new JSONObject(result);
status = jsonobject.getStr("status");
msg = jsonobject.getStr("msg");
if (status.equals("1")) { //1处理中
continue;
}else if(status.equals("2")){ //识别任务已结束，获取并存储数据
}else if (status.equals("2")) { //2识别任务已结束，获取并存储数据
datask.setRemark(msg); //记录返回结果的msg信息
String code = jsonobject.getStr("code");
Integer success = jsonobject.getInt("success");
Integer total = jsonobject.getInt("total");
//失败id
// Integer total = jsonobject.getInt("total");
//获取失败id
String failPicid = jsonobject.getStr("failPicid");
//获取失败的id集合
List<Long> failIds = JSONArray.parseArray(failPicid, Long.class);
//更新任务记录信息
datask.setStatus("2");//已结束
datask.setFailIds(StringUtils.join(failIds, ","));
@ -98,13 +110,12 @@ public class TimeTask
List<Long> successIds = allpicIds.stream().filter(item -> !failIds.contains(item)).collect(Collectors.toList());
datask.setSuccessIds(StringUtils.join(successIds, ","));
datask.setFailNum(failIds.size());
datask.setSuccessNum(allpicIds.size()-failIds.size());
datask.setSuccessNum(allpicIds.size() - failIds.size());
datask.setResultStr(result);
daTaskService.updateDaTask(datask);
//如果code=0 识别失败 无需存储响应的合集信息 code=1 识别成功或者部分成功
if (code.equals("0")) {
} else {
// code=1 识别成功或者部分成功，如果code=0 识别全部失败 无需存储信息
if (code.equals("1")) {
//数据解析 根据业务类型存储识别后的信息
String datas = jsonobject.getStr("datas");
switch (ywType) {
@ -329,19 +340,112 @@ public class TimeTask
//获取数据成功后，清除对应taskId的信息
clearThirdTaskResult(datask.getId());
}
} else if (status.equals("3")) { //=3第三方服务崩溃或者其他异常---任务丢失
datask.setRemark(msg); //记录返回结果的msg信息
datask.setStatus("4"); //设置状态任务丢失
daTaskService.updateDaTask(datask);
continue;
}
}
} else {
logger.info("-------------------------------------暂时没有识别中的任务----------------------------------");
}
}else{
System.out.println("-------------------------------------暂时没有未完成的识别任务----------------------------------");
} catch (Exception e) {
e.printStackTrace();
System.err.println("get_result:" + result);
}
}
/**
* 定时任务，对等待中的任务进行提交（识别中任务<third_task_max值时）
*/
public void submitTask(){
String result="";
try {
//获取字典第三方任务最大数量
Integer maxTask = Integer.parseInt(DictUtils.getDictValue("total_task", "third_task_max"));
//1.获取所有等待任务
DaTask param = new DaTask();
param.setStatus("-1"); //等待中
//查询所有识别中的任务
List<DaTask> daTasks = daTaskService.selectDaTaskListByStatus(param);
if (daTasks != null && daTasks.size() > 0) {
for (DaTask daTask : daTasks) {
DaTask sbz = new DaTask();
sbz.setStatus("1"); //处理中
//2.获取所有识别中的任务
List<DaTask> sbzTasks = daTaskService.selectDaTaskListByStatus(sbz);
if (sbzTasks != null && sbzTasks.size() >= maxTask) {//识别中任务>=10
logger.info("-------------------------------------当前识别中的任务数：" + sbzTasks.size() + " --系统稍后提交任务--------------------------------");
break;
} else {
List<Long> ids;
//判断需要上传的图片
if (daTask.getSuccessNum() != null && daTask.getSuccessNum() > 0) {
String failIds = daTask.getFailIds();
ids = Stream.of(failIds.split(","))
.map(Long::parseLong)
.collect(Collectors.toList());
} else {
String picIds = daTask.getPicIds();
ids = Stream.of(picIds.split(","))
.map(Long::parseLong)
.collect(Collectors.toList());
}
//获取所有需要重新识别上传的图片
List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(ids.toArray(new Long[ids.size()]));
String code;
String msg;
//获取所有的文件
List<File> files = new ArrayList<>();
for (DaPicturesRecard picRecard : picRecards) {
String path = getPath(picRecard.getPicUrl());
File file = new File(path);
files.add(file);
}
//调用第三方接口 先清数据
CallThirdInterface.callThirdInterfaceClearByTaskId(url4, daTask.getId());
result = CallThirdInterface.callThirdInterfaceUpload(url1, files, daTask.getYwType(), ids, daTask.getId());
//! 解析JSON字符串,获取键对应的值
JSONObject jsonobject = new JSONObject(result);
code = jsonobject.getStr("code");
msg = jsonobject.getStr("msg");
//记录最后一次识别的操作时间
daTask.setUpdateTime(new Date());
if (code.equals("1")) { //code=0 任务接收失败，code=1成功
daTask.setStatus("1"); //识别中
daTask.setLastNum(picRecards.size());
daTaskService.updateDaTask(daTask);
} else {
daTask.setStatus("0");
daTask.setRemark(msg);
daTaskService.updateDaTask(daTask);
}
}
}
} else {
logger.info("-------------------------------------当前等待队列中没有任务----------------------------------");
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("upload_api接口:"+result);
}
}
public void clearThirdTaskResult(Long taskId) throws Exception {
String result = CallThirdInterface.callThirdInterfaceClearByTaskId(url4,taskId);
String result = CallThirdInterface.callThirdInterfaceClearByTaskId(url4, taskId);
//! 解析JSON字符串,获取键对应的值
JSONObject jsonobject = new JSONObject(result);
String msg = jsonobject.getStr("msg");
String code = jsonobject.getStr("code");
logger.info("clearByTaskId------------------------------------"+taskId+" ---"+code+"---"+msg);
logger.info("clearByTaskId------------------------------------" + taskId + " ---" + code + "---" + msg);
}
public String getPath(String path) {
String profile = RuoYiConfig.getUploadPath();
int i = path.indexOf("upload");
String filePath = profile + path.substring(i + 6);
return filePath;
}
}

60
dangan-dangan/src/main/java/com/da/dangan/util/CallThirdInterface.java
Unescape View File

@ -2,12 +2,12 @@ package com.da.dangan.util;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.http.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.lang.reflect.Field;
import java.net.HttpCookie;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -16,8 +16,16 @@ import java.util.Map;
* 调用第三方接口，传文件，获取识别结果
*/
public class CallThirdInterface {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
public static String callThirdInterfaceClearByTaskId(String url3,Long taskId) throws Exception {
/**
* 根据任务id清除第三方数据信息
* @param url4
* @param taskId
* @return
* @throws Exception
*/
public static String callThirdInterfaceClearByTaskId(String url4,Long taskId) throws Exception {
// 定义上传的URL
//String url = "http://yourserver.com:8080/upload";
//添加json
@ -36,20 +44,30 @@ public class CallThirdInterface {
Map<String, Object> map = new HashMap<>();//存放参数
// map.put("taskId", taskId);
// 使用Hutool的HttpUtil上传文件
result = HttpUtil.createPost(url3)
result = HttpUtil.createPost(url4).timeout(10000)
// .addHeaders(headers)
.charset(CharsetUtil.CHARSET_UTF_8)
//.form("file", file) // 文件名称为"file"
//.form(map)// 添加其他表单参数
.form("taskId", taskId)
.execute().body();
// 输出结果
System.out.println("---clear："+result);
} catch (HttpException e) {
e.printStackTrace();
throw new Exception("查询结果接口连接失败！！！");
throw new Exception("清除数据接口连接超时！！！");
}
return result;
}
public static String callThirdInterfaceGetByTaskId(String url,Long taskId) throws Exception {
/**
* 根据任务id获取识别结果
* @param url2
* @param taskId
* @return
* @throws Exception
*/
public static String callThirdInterfaceGetByTaskId(String url2,Long taskId) throws Exception {
// 定义上传的URL
//String url = "http://yourserver.com:8080/upload";
//添加json
@ -68,7 +86,7 @@ public class CallThirdInterface {
Map<String, Object> map = new HashMap<>();//存放参数
// map.put("taskId", taskId);
// 使用Hutool的HttpUtil上传文件
result = HttpUtil.createPost(url)
result = HttpUtil.createPost(url2).timeout(10000)
// .addHeaders(headers)
.charset(CharsetUtil.CHARSET_UTF_8)
//.form("file", file) // 文件名称为"file"
@ -76,24 +94,33 @@ public class CallThirdInterface {
.form("taskId", taskId)
.execute().body();
// 输出结果
SimpleDateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(simpleDateFormat.format(new Date())+""+result);
// SimpleDateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//System.out.println(simpleDateFormat.format(new Date())+""+result);
} catch (HttpException e) {
e.printStackTrace();
throw new Exception("查询结果接口连接失败！！！");
throw new Exception("查询结果接口连接超时！！！");
}
return result;
}
public static String callThirdInterfaceUpload(String url,List<File> files,String fileType,List<Long> picIds,Long taskId) throws Exception {
/**
* 任务上传第三方接口
* @param url1
* @param files
* @param fileType
* @param picIds
* @param taskId
* @return
* @throws Exception
*/
public static String callThirdInterfaceUpload(String url1,List<File> files,String fileType,List<Long> picIds,Long taskId) throws Exception {
String body = null; // 获取响应主体
try {
// 1. 创建HttpRequest对象 - 指定好 url 地址
HttpRequest httpRequest = new HttpRequest(url);
HttpRequest httpRequest = new HttpRequest(url1);
// 2. 设置请求方式，默认是GET请求
httpRequest.setMethod(Method.POST);
httpRequest.timeout(120000).setMethod(Method.POST); //设置2min超时
// 3. 设置请求参数 可通过 form表单方法 设置 可以是文件类型
// form方法有很多重载方法,可以一个一个参数设置，也可以将参数封装进一个map集合然后一块儿
// File file = new File("C:\\Users\\hssym\\Downloads\\UBQ.png");
@ -123,12 +150,11 @@ public class CallThirdInterface {
body = execute.body();
/*byte[] bytes = execute.bodyBytes();
String body = new String (bytes,CharsetUtil.UTF_8);*/
// 输出结果
System.out.println(body);
System.out.println("---上传结果："+body);
} catch (HttpException e) {
e.printStackTrace();
throw new Exception("识别上传接口连接失败！！！");
throw new Exception("识别上传接口连接超时！！！");
}
return body;
}

10
dangan-dangan/src/main/resources/mapper/dangan/DaTaskMapper.xml
Unescape View File

@ -46,10 +46,20 @@
<if test="failNum != null "> and fail_num = #{failNum}</if>
<if test="failIds != null and failIds != ''"> and fail_ids = #{failIds}</if>
<if test="resultStr != null and resultStr != ''"> and result_str = #{resultStr}</if>
<if test="remark != null and remark != ''">and remark like concat('%', #{remark}, '%') </if>
</where>
order by id desc
</select>
<!--根据任务状态获取任务（不区分用户权限），在定时任务、统计任务状态时使用-->
<select id="selectDaTaskListByStatus" parameterType="DaTask" resultMap="DaTaskResult">
<include refid="selectDaTaskVo"/>
<where>
<if test="status != null and status != ''"> and status = #{status}</if>
</where>
order by update_time asc
</select>
<select id="selectDaTaskById" parameterType="Long" resultMap="DaTaskResult">
<include refid="selectDaTaskVo"/>
where id = #{id}

5
dangan-ui/src/views/dangan/task/index.vue
Unescape View File

@ -310,8 +310,9 @@
/** 查询识别进度 */
getProgress() {
// 向给定ID的用户发起请求
//axios.post('http://20.206.150.166:22443/get_file_count',`username=${this.$store.state.user.name}`, {
axios.post('http://123.57.142.195:443/get_file_count',`taskId=${this.form.id}`, {
axios.post('https://4493yu98cz42.vicp.fun/get_file_count',`taskId=${this.form.id}`, {
//axios.post('http://123.57.142.195:443/get_file_count',`taskId=${this.form.id}`, {
//axios.post('http://20.206.150.166:22443/get_file_count',`taskId=${this.form.id}`, {
headers: {
'Content-Type': 'application/x-www-form-urlencoded'
}

Write Preview
Loading…
Cancel
Save