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

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

@ -1,14 +1,13 @@
package com.da.dangan.controller; 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.config.RuoYiConfig;
import com.da.common.core.controller.BaseController; import com.da.common.core.controller.BaseController;
import com.da.common.core.domain.AjaxResult; import com.da.common.core.domain.AjaxResult;
import com.da.common.utils.file.FileUploadUtils; import com.da.common.utils.file.FileUploadUtils;
import com.da.common.utils.file.FileUtils; import com.da.common.utils.file.FileUtils;
import com.da.dangan.domain.*; import com.da.dangan.domain.DaPicturesRecard;
import com.da.dangan.domain.vo.*; import com.da.dangan.domain.DaTask;
import com.da.dangan.domain.vo.PicParams;
import com.da.dangan.service.*; import com.da.dangan.service.*;
import com.da.dangan.util.CallThirdInterface; import com.da.dangan.util.CallThirdInterface;
import com.da.framework.config.ServerConfig; import com.da.framework.config.ServerConfig;
@ -28,7 +27,6 @@ import java.util.Date;
import java.util.List; import java.util.List;
import java.util.concurrent.Executor; import java.util.concurrent.Executor;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import java.util.stream.Stream;
/** /**
* 档案采集Controller * 档案采集Controller
@ -121,7 +119,7 @@ public class DangAnCollectController extends BaseController {
/** /**
* 调用ocr识别接口——识别单张/或者正反面图片 * 调用ocr识别接口——识别单张/或者正反面图片
*/ */
@PostMapping("/recongnize") /*@PostMapping("/recongnize")
public AjaxResult recognize(@RequestBody List<DaPicturesRecard> picRecards) { public AjaxResult recognize(@RequestBody List<DaPicturesRecard> picRecards) {
String code; String code;
String msg=""; String msg="";
@ -164,37 +162,146 @@ public class DangAnCollectController extends BaseController {
daTaskService.updateDaTask(daTask); daTaskService.updateDaTask(daTask);
} }
}else{ }else{
return AjaxResult.error("识别图片不能为0"); return AjaxResult.error("识别图片不能为空");
} }
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
return AjaxResult.error(e.getMessage()); return AjaxResult.error(e.getMessage());
} }
return AjaxResult.success("任务接收成功"); 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") @PostMapping("/reRecongnize")
public AjaxResult reRecongnize(Long taskId) { public AjaxResult reRecongnize(Long taskId) {
DaTask daTask = daTaskService.selectDaTaskById(taskId);
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;
try { 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) {
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<>(); List<File> files = new ArrayList<>();
for (DaPicturesRecard picRecard : picRecards) { for (DaPicturesRecard picRecard : picRecards) {
@ -202,331 +309,61 @@ public class DangAnCollectController extends BaseController {
File file = new File(path); File file = new File(path);
files.add(file); files.add(file);
} }
//调用第三方接口 先清数据
CallThirdInterface.callThirdInterfaceClearByTaskId(url4,taskId); //判断第三方接口识别中的任务数量
String result = CallThirdInterface.callThirdInterfaceUpload(url1, files, daTask.getYwType(), ids,taskId); DaTask param = new DaTask();
//! 解析JSON字符串,获取键对应的值 param.setStatus("1"); //处理中
JSONObject jsonobject = new JSONObject(result); List<DaTask> daTasks = daTaskService.selectDaTaskListByStatus(param);
code = jsonobject.getStr("code"); if (daTasks != null && daTasks.size() >= maxTask) {//当前识别任务超过10个
msg = jsonobject.getStr("msg"); daTask.setStatus("-1"); //设置状态等待
daTask.setUpdateTime(new Date());//等待队列order by 字段
//记录最后一次识别的操作时间、操作人
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{
daTask.setStatus("1");
daTask.setLastNum(picRecards.size());
daTaskService.updateDaTask(daTask); daTaskService.updateDaTask(daTask);
return AjaxResult.success("任务进入等待队列");
} else {//识别中任务<10
//调用第三方接口 先清数据
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());
if (code.equals("0")) { //code=0 任务接收失败，code=1成功
daTask.setStatus("0");
daTaskService.updateDaTask(daTask);
return AjaxResult.error(msg);
} else {
daTask.setStatus("1");
daTask.setLastNum(picRecards.size());
daTaskService.updateDaTask(daTask);
}
} }
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
return AjaxResult.error(e.getMessage()); return AjaxResult.error(e.getMessage());
} }
return AjaxResult.success("任务接收成功"); return AjaxResult.success("任务接收成功");
} }*/
/** /**
* 调用ocr识别接口——旧接口，已弃用 * 任务重新识别
*/ */
@PostMapping("/recongnize-old") @PostMapping("/reRecongnize")
public AjaxResult recognizeOld(@RequestBody List<DaPicturesRecard> picRecards) { public AjaxResult reRecongnize(Long taskId) {
String code;
String msg;
int success;
int total;
List<DaPicturesRecard> failList = new ArrayList<>();
try { try {
//取所有id的集合 stream()有顺序 DaTask daTask = daTaskService.selectDaTaskById(taskId);
List<Long> ids = picRecards.stream().map(DaPicturesRecard::getId).collect(Collectors.toList()); // daTask.setCreateBy(getUsername());//存入操作用户
String ywType = picRecards.get(0).getYwType(); //修改任务状态
Long muId = picRecards.get(0).getMuId(); daTask.setStatus("-1");//默认等待状态
String muPath = picRecards.get(0).getMuPath(); daTaskService.updateDaTask(daTask);
// 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;
}
/*//修改图片信息记录表为已识别 .如果有失败数据，剔除失败数据---现在新增合集信息处做图片已识别修改
if (failList.size() > 0) {
picRecards.removeAll(failList);
}
for (DaPicturesRecard picRecard : picRecards) {
picRecard.setRecognize("1");
daPicturesRecardService.updateDaPicturesRecard(picRecard);
}*/
}
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
return AjaxResult.error(e.getMessage()); 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(); long start = System.currentTimeMillis();
//参数:地址、文件、业务类型、单双面： 1单面 2双面 //参数:地址、文件、业务类型、单双面： 1单面 2双面
//String result = CallThirdInterface.callThirdInterface(url, files, ywType,singleOrDouble,ids); //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(); long end = System.currentTimeMillis();
logger.info("CompletableFuture耗时--——————————————————》" + (end - start) + "ms"); 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 结果 * @return 结果
*/ */
public int deleteDaTaskByIds(Long[] ids); 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 结果 * @return 结果
*/ */
public int deleteDaTaskById(Long id); 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); 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); return daTaskMapper.deleteDaTaskById(id);
} }
} }

632
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 cn.hutool.json.JSONObject;
import com.alibaba.fastjson2.JSONArray; import com.alibaba.fastjson2.JSONArray;
import com.da.common.config.RuoYiConfig;
import com.da.common.utils.DictUtils; import com.da.common.utils.DictUtils;
import com.da.dangan.domain.*; import com.da.dangan.domain.*;
import com.da.dangan.domain.vo.*; 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.Autowired;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component; 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.Date;
import java.util.List; import java.util.List;
import java.util.stream.Collectors; import java.util.stream.Collectors;
@ -26,8 +28,7 @@ import java.util.stream.Stream;
* @author ruoyi * @author ruoyi
*/ */
@Component("timeTask") @Component("timeTask")
public class TimeTask public class TimeTask {
{
@Autowired @Autowired
private IDaTaskService daTaskService; private IDaTaskService daTaskService;
@Autowired @Autowired
@ -48,300 +49,403 @@ public class TimeTask
private String url2; private String url2;
@Value("${ocr.url4}") @Value("${ocr.url4}")
private String url4; private String url4;
@Value("${ocr.url1}")
private String url1;
protected final Logger logger = LoggerFactory.getLogger(this.getClass()); protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Transactional /**
public void daNoParams() throws Exception { * 定时任务查询识别中任务的结果，并对结果进行解析存储，相应的改变任务状态
DaTask param = new DaTask(); *
param.setStatus("1"); //处理中 * @throws Exception
//查询所有未完成的任务 */
List<DaTask> daTasks = daTaskService.selectDaTaskList(param); public void getTaskResult() {
if(daTasks!=null&&daTasks.size()>0){ String result = "";
for(DaTask datask:daTasks){ try {
//查看认识是否超时, 计算两个日期之间的差值（毫秒） 分钟-> / (1000 * 60) DaTask param = new DaTask();
long diff = (new Date().getTime()-datask.getUpdateTime().getTime())/(1000 * 60 ); param.setStatus("1"); //处理中
String expired = DictUtils.getDictValue("task_time_out", "task_timeout"); //查询所有识别中的任务
if(diff> Long.parseLong(expired)){ List<DaTask> daTasks = daTaskService.selectDaTaskListByStatus(param);
datask.setStatus("3"); //设置状态任务超时 if (daTasks != null && daTasks.size() > 0) {
daTaskService.updateDaTask(datask); for (DaTask datask : daTasks) {
continue; //查看认识是否超时, 计算两个日期之间的差值（毫秒） 分钟-> / (1000 * 60)
} long diff = (new Date().getTime() - datask.getUpdateTime().getTime()) / (1000 * 60);
//获取当前任务相关信息 String expired = DictUtils.getDictValue("task_time_out", "task_timeout");
String ywType = datask.getYwType(); if (diff > Long.parseLong(expired)) {
Long muId = datask.getMuId(); datask.setStatus("3"); //设置状态任务超时
String muPath = datask.getMuPath(); daTaskService.updateDaTask(datask);
logger.info("--------开启任务:"+datask.getId()+"结果查询"); continue;
//调用第三方接口查看识别任务状态 已结束直接取结果，处理中跳过 }
String result = CallThirdInterface.callThirdInterfaceGetByTaskId(url2, datask.getId()); //获取当前任务相关信息
//! 解析JSON字符串,获取键对应的值 String ywType = datask.getYwType();
JSONObject jsonobject = new JSONObject(result); Long muId = datask.getMuId();
String status = jsonobject.getStr("status"); String muPath = datask.getMuPath();
// if(status!=null&&!status.trim().equals("")){ logger.info("--------开启任务:" + datask.getId() + "结果查询");
if(status.equals("1")){ //1处理中 //调用第三方接口查看识别任务状态 已结束直接取结果，处理中跳过
continue; result = CallThirdInterface.callThirdInterfaceGetByTaskId(url2, datask.getId());
}else if(status.equals("2")){ //识别任务已结束，获取并存储数据 //! 解析JSON字符串,获取键对应的值
String code = jsonobject.getStr("code"); JSONObject jsonobject = null;
Integer success = jsonobject.getInt("success"); String status = null;
Integer total = jsonobject.getInt("total"); String msg = null;
//失败id jsonobject = new JSONObject(result);
String failPicid = jsonobject.getStr("failPicid"); status = jsonobject.getStr("status");
//获取失败的id集合 msg = jsonobject.getStr("msg");
List<Long> failIds = JSONArray.parseArray(failPicid, Long.class);
//更新任务记录信息 if (status.equals("1")) { //1处理中
datask.setStatus("2");//已结束 continue;
datask.setFailIds(StringUtils.join(failIds, ",")); }else if (status.equals("2")) { //2识别任务已结束，获取并存储数据
//获取成功的图片ids 重传任务时 成功ids=alls-fails datask.setRemark(msg); //记录返回结果的msg信息
List<Long> allpicIds = Stream.of(datask.getPicIds().split(",")) String code = jsonobject.getStr("code");
.map(Long::parseLong) // Integer total = jsonobject.getInt("total");
.collect(Collectors.toList()); //获取失败id
List<Long> successIds = allpicIds.stream().filter(item -> !failIds.contains(item)).collect(Collectors.toList()); String failPicid = jsonobject.getStr("failPicid");
datask.setSuccessIds(StringUtils.join(successIds, ",")); //获取失败的id集合
datask.setFailNum(failIds.size()); List<Long> failIds = JSONArray.parseArray(failPicid, Long.class);
datask.setSuccessNum(allpicIds.size()-failIds.size()); //更新任务记录信息
datask.setResultStr(result); datask.setStatus("2");//已结束
daTaskService.updateDaTask(datask); datask.setFailIds(StringUtils.join(failIds, ","));
//获取成功的图片ids 重传任务时 成功ids=alls-fails
List<Long> allpicIds = Stream.of(datask.getPicIds().split(","))
.map(Long::parseLong)
.collect(Collectors.toList());
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.setResultStr(result);
daTaskService.updateDaTask(datask);
//如果code=0 识别失败 无需存储响应的合集信息 code=1 识别成功或者部分成功 // code=1 识别成功或者部分成功，如果code=0 识别全部失败 无需存储信息
if (code.equals("0")) { if (code.equals("1")) {
} else { //数据解析 根据业务类型存储识别后的信息
//数据解析 根据业务类型存储识别后的信息 String datas = jsonobject.getStr("datas");
String datas = jsonobject.getStr("datas"); switch (ywType) {
switch (ywType) { case "option1": //常住人口登记表1
case "option1": //常住人口登记表1 //break;
//break; case "option2": //常住卡
case "option2": //常住卡 // break;
// break; case "option3": //常住人口登记表2
case "option3": //常住人口登记表2 //break;
//break; case "option9": //常住人口登记表3
case "option9": //常住人口登记表3 //获取常住人口信息集合
//获取常住人口信息集合 List<CzrkDatas> czrkDatas = JSONArray.parseArray(datas, CzrkDatas.class);
List<CzrkDatas> czrkDatas = JSONArray.parseArray(datas, CzrkDatas.class); for (CzrkDatas czrkData : czrkDatas) {
for (CzrkDatas czrkData : czrkDatas) { List<Long> picids = czrkData.getPicid();
List<Long> picids = czrkData.getPicid(); String picIds = StringUtils.join(picids, ",");//逗号分割
String picIds = StringUtils.join(picids, ",");//逗号分割 //根据picIds查找对应的图片记录
//根据picIds查找对应的图片记录 List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()]));
List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()])); List<String> picUrls = picRecards.stream()
List<String> picUrls = picRecards.stream() .map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList()); String pictures = StringUtils.join(picUrls, ",");//逗号分割
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaCzrkdj> info = czrkData.getInfo(); List<DaCzrkdj> info = czrkData.getInfo();
if (info != null && info.size() > 0) { if (info != null && info.size() > 0) {
for (DaCzrkdj daCzrkdj : info) { for (DaCzrkdj daCzrkdj : info) {
//判断返回结果是否都是字符串 "无" //判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(daCzrkdj,"无")){ /*if(CallThirdInterface.allFieldsEqualTo(daCzrkdj,"无")){
continue; continue;
}*/ }*/
daCzrkdj.setAllPicIds(picIds); daCzrkdj.setAllPicIds(picIds);
daCzrkdj.setAllPics(pictures); daCzrkdj.setAllPics(pictures);
daCzrkdj.setPicIds(picIds); daCzrkdj.setPicIds(picIds);
daCzrkdj.setPictures(pictures); daCzrkdj.setPictures(pictures);
//其他字段存储 //其他字段存储
daCzrkdj.setYwType(ywType); daCzrkdj.setYwType(ywType);
daCzrkdj.setMuId(muId); daCzrkdj.setMuId(muId);
daCzrkdj.setMuPath(muPath); daCzrkdj.setMuPath(muPath);
daCzrkdj.setAuditStatus("0"); daCzrkdj.setAuditStatus("0");
daCzrkdj.setErrorCorrect("0"); daCzrkdj.setErrorCorrect("0");
daCzrkdj.setTaskId(datask.getId()); daCzrkdj.setTaskId(datask.getId());
//daCzrkdj.setCreateBy(); //daCzrkdj.setCreateBy();
daCzrkdjService.insertDaCzrkdj(daCzrkdj); daCzrkdjService.insertDaCzrkdj(daCzrkdj);
}
} }
} }
} break;
break; case "option4":
case "option4": //获取出生医学证明信息集合
//获取出生医学证明信息集合 List<CszmDatas> cszmDatas = JSONArray.parseArray(datas, CszmDatas.class);
List<CszmDatas> cszmDatas = JSONArray.parseArray(datas, CszmDatas.class); for (CszmDatas cszmData : cszmDatas) {
for (CszmDatas cszmData : cszmDatas) { List<Long> picids = cszmData.getPicid();
List<Long> picids = cszmData.getPicid(); String picIds = StringUtils.join(picids, ",");//逗号分割
String picIds = StringUtils.join(picids, ",");//逗号分割 //根据picIds查找对应的图片记录
//根据picIds查找对应的图片记录 List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()]));
List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()])); List<String> picUrls = picRecards.stream()
List<String> picUrls = picRecards.stream() .map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList()); String pictures = StringUtils.join(picUrls, ",");//逗号分割
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaBirthDj> info = cszmData.getInfo(); List<DaBirthDj> info = cszmData.getInfo();
if (info != null && info.size() > 0) { if (info != null && info.size() > 0) {
for (DaBirthDj daBirthdj : info) { for (DaBirthDj daBirthdj : info) {
//判断返回结果是否都是字符串 "无" //判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(daBirthdj,"无")){ /*if(CallThirdInterface.allFieldsEqualTo(daBirthdj,"无")){
continue; continue;
}*/ }*/
daBirthdj.setAllPicIds(picIds); daBirthdj.setAllPicIds(picIds);
daBirthdj.setAllPics(pictures); daBirthdj.setAllPics(pictures);
daBirthdj.setPicIds(picIds); daBirthdj.setPicIds(picIds);
daBirthdj.setPictures(pictures); daBirthdj.setPictures(pictures);
//其他字段存储 //其他字段存储
daBirthdj.setTaskId(datask.getId()); daBirthdj.setTaskId(datask.getId());
daBirthdj.setYwType(ywType); daBirthdj.setYwType(ywType);
daBirthdj.setMuId(muId); daBirthdj.setMuId(muId);
daBirthdj.setMuPath(muPath); daBirthdj.setMuPath(muPath);
daBirthdj.setAuditStatus("0"); daBirthdj.setAuditStatus("0");
daBirthdj.setErrorCorrect("0"); daBirthdj.setErrorCorrect("0");
daBirthDjService.insertDaBirthDj(daBirthdj); daBirthDjService.insertDaBirthDj(daBirthdj);
}
} }
} }
} break;
break; case "option5":
case "option5": //获取迁移证信息集合
//获取迁移证信息集合 List<QyzDatas> qyzDatas = JSONArray.parseArray(datas, QyzDatas.class);
List<QyzDatas> qyzDatas = JSONArray.parseArray(datas, QyzDatas.class); for (QyzDatas qyzData : qyzDatas) {
for (QyzDatas qyzData : qyzDatas) { List<Long> picids = qyzData.getPicid();
List<Long> picids = qyzData.getPicid(); String picIds = StringUtils.join(picids, ",");//逗号分割
String picIds = StringUtils.join(picids, ",");//逗号分割 //根据picIds查找对应的图片记录
//根据picIds查找对应的图片记录 List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()]));
List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()])); List<String> picUrls = picRecards.stream()
List<String> picUrls = picRecards.stream() .map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList()); String pictures = StringUtils.join(picUrls, ",");//逗号分割
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaQyz> info = qyzData.getInfo(); List<DaQyz> info = qyzData.getInfo();
if (info != null && info.size() > 0) { if (info != null && info.size() > 0) {
for (DaQyz qyz : info) { for (DaQyz qyz : info) {
//判断返回结果是否都是字符串 "无" //判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(qyz,"无")){ /*if(CallThirdInterface.allFieldsEqualTo(qyz,"无")){
continue; continue;
}*/ }*/
qyz.setAllPicIds(picIds); qyz.setAllPicIds(picIds);
qyz.setAllPics(pictures); qyz.setAllPics(pictures);
qyz.setPicIds(picIds); qyz.setPicIds(picIds);
qyz.setPictures(pictures); qyz.setPictures(pictures);
//其他字段存储 //其他字段存储
qyz.setYwType(ywType); qyz.setYwType(ywType);
qyz.setMuId(muId); qyz.setMuId(muId);
qyz.setMuPath(muPath); qyz.setMuPath(muPath);
qyz.setAuditStatus("0"); qyz.setAuditStatus("0");
qyz.setErrorCorrect("0"); qyz.setErrorCorrect("0");
qyz.setTaskId(datask.getId()); qyz.setTaskId(datask.getId());
daQyzService.insertDaQyz(qyz); daQyzService.insertDaQyz(qyz);
}
} }
} }
} break;
break; case "option6":
case "option6": //获取一胎证明信息集合
//获取一胎证明信息集合 List<YtzmDatas> ytzmDatas = JSONArray.parseArray(datas, YtzmDatas.class);
List<YtzmDatas> ytzmDatas = JSONArray.parseArray(datas, YtzmDatas.class); for (YtzmDatas ytzmData : ytzmDatas) {
for (YtzmDatas ytzmData : ytzmDatas) { List<Long> picids = ytzmData.getPicid();
List<Long> picids = ytzmData.getPicid(); String picIds = StringUtils.join(picids, ",");//逗号分割
String picIds = StringUtils.join(picids, ",");//逗号分割 //根据picIds查找对应的图片记录
//根据picIds查找对应的图片记录 List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()]));
List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()])); List<String> picUrls = picRecards.stream()
List<String> picUrls = picRecards.stream() .map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList()); String pictures = StringUtils.join(picUrls, ",");//逗号分割
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaYtzm> info = ytzmData.getInfo(); List<DaYtzm> info = ytzmData.getInfo();
if (info != null && info.size() > 0) { if (info != null && info.size() > 0) {
for (DaYtzm ytzm : info) { for (DaYtzm ytzm : info) {
//判断返回结果是否都是字符串 "无" //判断返回结果是否都是字符串 "无"
/* if(CallThirdInterface.allFieldsEqualTo(ytzm,"无")){ /* if(CallThirdInterface.allFieldsEqualTo(ytzm,"无")){
continue; continue;
}*/ }*/
ytzm.setAllPicIds(picIds); ytzm.setAllPicIds(picIds);
ytzm.setAllPics(pictures); ytzm.setAllPics(pictures);
ytzm.setPicIds(picIds); ytzm.setPicIds(picIds);
ytzm.setPictures(pictures); ytzm.setPictures(pictures);
//其他字段存储 //其他字段存储
ytzm.setYwType(ywType); ytzm.setYwType(ywType);
ytzm.setMuId(muId); ytzm.setMuId(muId);
ytzm.setMuPath(muPath); ytzm.setMuPath(muPath);
ytzm.setAuditStatus("0"); ytzm.setAuditStatus("0");
ytzm.setErrorCorrect("0"); ytzm.setErrorCorrect("0");
ytzm.setTaskId(datask.getId()); ytzm.setTaskId(datask.getId());
daYtzmService.insertDaYtzm(ytzm); daYtzmService.insertDaYtzm(ytzm);
}
} }
} }
} break;
break; case "option7":
case "option7": //获取转非农业人口批复存根信息集合
//获取转非农业人口批复存根信息集合 List<ZfnyDatas> zfnyDatas = JSONArray.parseArray(datas, ZfnyDatas.class);
List<ZfnyDatas> zfnyDatas = JSONArray.parseArray(datas, ZfnyDatas.class); for (ZfnyDatas zfnyData : zfnyDatas) {
for (ZfnyDatas zfnyData : zfnyDatas) { List<Long> picids = zfnyData.getPicid();
List<Long> picids = zfnyData.getPicid(); String picIds = StringUtils.join(picids, ",");//逗号分割
String picIds = StringUtils.join(picids, ",");//逗号分割 //根据picIds查找对应的图片记录
//根据picIds查找对应的图片记录 List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()]));
List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()])); List<String> picUrls = picRecards.stream()
List<String> picUrls = picRecards.stream() .map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList()); String pictures = StringUtils.join(picUrls, ",");//逗号分割
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaZfnyhkcg> info = zfnyData.getInfo(); List<DaZfnyhkcg> info = zfnyData.getInfo();
if (info != null && info.size() > 0) { if (info != null && info.size() > 0) {
for (DaZfnyhkcg zfnyhkcg : info) { for (DaZfnyhkcg zfnyhkcg : info) {
//判断返回结果是否都是字符串 "无" //判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(zfnyhkcg,"无")){ /*if(CallThirdInterface.allFieldsEqualTo(zfnyhkcg,"无")){
continue; continue;
}*/ }*/
zfnyhkcg.setAllPicIds(picIds); zfnyhkcg.setAllPicIds(picIds);
zfnyhkcg.setAllPics(pictures); zfnyhkcg.setAllPics(pictures);
zfnyhkcg.setPicIds(picIds); zfnyhkcg.setPicIds(picIds);
zfnyhkcg.setPictures(pictures); zfnyhkcg.setPictures(pictures);
//其他字段存储 //其他字段存储
zfnyhkcg.setYwType(ywType); zfnyhkcg.setYwType(ywType);
zfnyhkcg.setMuId(muId); zfnyhkcg.setMuId(muId);
zfnyhkcg.setMuPath(muPath); zfnyhkcg.setMuPath(muPath);
zfnyhkcg.setAuditStatus("0"); zfnyhkcg.setAuditStatus("0");
zfnyhkcg.setErrorCorrect("0"); zfnyhkcg.setErrorCorrect("0");
zfnyhkcg.setTaskId(datask.getId()); zfnyhkcg.setTaskId(datask.getId());
daZfnyhkcgService.insertDaZfnyhkcg(zfnyhkcg); daZfnyhkcgService.insertDaZfnyhkcg(zfnyhkcg);
}
} }
} }
} break;
break; case "option8":
case "option8": //获取准迁证信息集合
//获取准迁证信息集合 List<ZqzDatas> zqzDatas = JSONArray.parseArray(datas, ZqzDatas.class);
List<ZqzDatas> zqzDatas = JSONArray.parseArray(datas, ZqzDatas.class); for (ZqzDatas zqzData : zqzDatas) {
for (ZqzDatas zqzData : zqzDatas) { List<Long> picids = zqzData.getPicid();
List<Long> picids = zqzData.getPicid(); String picIds = StringUtils.join(picids, ",");//逗号分割
String picIds = StringUtils.join(picids, ",");//逗号分割 //根据picIds查找对应的图片记录
//根据picIds查找对应的图片记录 List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()]));
List<DaPicturesRecard> picRecards = daPicturesRecardService.selectDaPicturesRecardByIds(picids.toArray(new Long[picids.size()])); List<String> picUrls = picRecards.stream()
List<String> picUrls = picRecards.stream() .map(DaPicturesRecard::getPicUrl).collect(Collectors.toList());
.map(DaPicturesRecard::getPicUrl).collect(Collectors.toList()); String pictures = StringUtils.join(picUrls, ",");//逗号分割
String pictures = StringUtils.join(picUrls, ",");//逗号分割
List<DaZqz> info = zqzData.getInfo(); List<DaZqz> info = zqzData.getInfo();
if (info != null && info.size() > 0) { if (info != null && info.size() > 0) {
for (DaZqz zqz : info) { for (DaZqz zqz : info) {
//判断返回结果是否都是字符串 "无" //判断返回结果是否都是字符串 "无"
/*if(CallThirdInterface.allFieldsEqualTo(zqz,"无")){ /*if(CallThirdInterface.allFieldsEqualTo(zqz,"无")){
continue; continue;
}*/ }*/
zqz.setAllPicIds(picIds); zqz.setAllPicIds(picIds);
zqz.setAllPics(pictures); zqz.setAllPics(pictures);
zqz.setPicIds(picIds); zqz.setPicIds(picIds);
zqz.setPictures(pictures); zqz.setPictures(pictures);
//其他字段存储 //其他字段存储
zqz.setYwType(ywType); zqz.setYwType(ywType);
zqz.setMuId(muId); zqz.setMuId(muId);
zqz.setMuPath(muPath); zqz.setMuPath(muPath);
zqz.setAuditStatus("0"); zqz.setAuditStatus("0");
zqz.setErrorCorrect("0"); zqz.setErrorCorrect("0");
zqz.setTaskId(datask.getId()); zqz.setTaskId(datask.getId());
daZqzService.insertDaZqz(zqz); daZqzService.insertDaZqz(zqz);
}
} }
} }
} break;
break; }
//获取数据成功后，清除对应taskId的信息
clearThirdTaskResult(datask.getId());
}
} else if (status.equals("3")) { //=3第三方服务崩溃或者其他异常---任务丢失
datask.setRemark(msg); //记录返回结果的msg信息
datask.setStatus("4"); //设置状态任务丢失
daTaskService.updateDaTask(datask);
continue;
}
}
} else {
logger.info("-------------------------------------暂时没有识别中的任务----------------------------------");
}
} 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);
} }
//获取数据成功后，清除对应taskId的信息
clearThirdTaskResult(datask.getId());
} }
} }
} else {
logger.info("-------------------------------------当前等待队列中没有任务----------------------------------");
} }
}else{ } catch (Exception e) {
System.out.println("-------------------------------------暂时没有未完成的识别任务----------------------------------"); e.printStackTrace();
System.out.println("upload_api接口:"+result);
} }
} }
public void clearThirdTaskResult(Long taskId) throws Exception { public void clearThirdTaskResult(Long taskId) throws Exception {
String result = CallThirdInterface.callThirdInterfaceClearByTaskId(url4,taskId); String result = CallThirdInterface.callThirdInterfaceClearByTaskId(url4, taskId);
//! 解析JSON字符串,获取键对应的值 //! 解析JSON字符串,获取键对应的值
JSONObject jsonobject = new JSONObject(result); JSONObject jsonobject = new JSONObject(result);
String msg = jsonobject.getStr("msg"); String msg = jsonobject.getStr("msg");
String code = jsonobject.getStr("code"); 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.core.util.CharsetUtil;
import cn.hutool.http.*; import cn.hutool.http.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File; import java.io.File;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.net.HttpCookie; import java.net.HttpCookie;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
@ -16,8 +16,16 @@ import java.util.Map;
* 调用第三方接口，传文件，获取识别结果 * 调用第三方接口，传文件，获取识别结果
*/ */
public class CallThirdInterface { 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 // 定义上传的URL
//String url = "http://yourserver.com:8080/upload"; //String url = "http://yourserver.com:8080/upload";
//添加json //添加json
@ -36,20 +44,30 @@ public class CallThirdInterface {
Map<String, Object> map = new HashMap<>();//存放参数 Map<String, Object> map = new HashMap<>();//存放参数
// map.put("taskId", taskId); // map.put("taskId", taskId);
// 使用Hutool的HttpUtil上传文件 // 使用Hutool的HttpUtil上传文件
result = HttpUtil.createPost(url3) result = HttpUtil.createPost(url4).timeout(10000)
// .addHeaders(headers) // .addHeaders(headers)
.charset(CharsetUtil.CHARSET_UTF_8) .charset(CharsetUtil.CHARSET_UTF_8)
//.form("file", file) // 文件名称为"file" //.form("file", file) // 文件名称为"file"
//.form(map)// 添加其他表单参数 //.form(map)// 添加其他表单参数
.form("taskId", taskId) .form("taskId", taskId)
.execute().body(); .execute().body();
// 输出结果
System.out.println("---clear："+result);
} catch (HttpException e) { } catch (HttpException e) {
e.printStackTrace(); e.printStackTrace();
throw new Exception("查询结果接口连接失败！！！"); throw new Exception("清除数据接口连接超时！！！");
} }
return result; 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 // 定义上传的URL
//String url = "http://yourserver.com:8080/upload"; //String url = "http://yourserver.com:8080/upload";
//添加json //添加json
@ -68,7 +86,7 @@ public class CallThirdInterface {
Map<String, Object> map = new HashMap<>();//存放参数 Map<String, Object> map = new HashMap<>();//存放参数
// map.put("taskId", taskId); // map.put("taskId", taskId);
// 使用Hutool的HttpUtil上传文件 // 使用Hutool的HttpUtil上传文件
result = HttpUtil.createPost(url) result = HttpUtil.createPost(url2).timeout(10000)
// .addHeaders(headers) // .addHeaders(headers)
.charset(CharsetUtil.CHARSET_UTF_8) .charset(CharsetUtil.CHARSET_UTF_8)
//.form("file", file) // 文件名称为"file" //.form("file", file) // 文件名称为"file"
@ -76,24 +94,33 @@ public class CallThirdInterface {
.form("taskId", taskId) .form("taskId", taskId)
.execute().body(); .execute().body();
// 输出结果 // 输出结果
SimpleDateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // SimpleDateFormat simpleDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(simpleDateFormat.format(new Date())+""+result); //System.out.println(simpleDateFormat.format(new Date())+""+result);
} catch (HttpException e) { } catch (HttpException e) {
e.printStackTrace(); e.printStackTrace();
throw new Exception("查询结果接口连接失败！！！"); throw new Exception("查询结果接口连接超时！！！");
} }
return result; 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; // 获取响应主体 String body = null; // 获取响应主体
try { try {
// 1. 创建HttpRequest对象 - 指定好 url 地址 // 1. 创建HttpRequest对象 - 指定好 url 地址
HttpRequest httpRequest = new HttpRequest(url); HttpRequest httpRequest = new HttpRequest(url1);
// 2. 设置请求方式，默认是GET请求 // 2. 设置请求方式，默认是GET请求
httpRequest.setMethod(Method.POST); httpRequest.timeout(120000).setMethod(Method.POST); //设置2min超时
// 3. 设置请求参数 可通过 form表单方法 设置 可以是文件类型 // 3. 设置请求参数 可通过 form表单方法 设置 可以是文件类型
// form方法有很多重载方法,可以一个一个参数设置，也可以将参数封装进一个map集合然后一块儿 // form方法有很多重载方法,可以一个一个参数设置，也可以将参数封装进一个map集合然后一块儿
// File file = new File("C:\\Users\\hssym\\Downloads\\UBQ.png"); // File file = new File("C:\\Users\\hssym\\Downloads\\UBQ.png");
@ -123,12 +150,11 @@ public class CallThirdInterface {
body = execute.body(); body = execute.body();
/*byte[] bytes = execute.bodyBytes(); /*byte[] bytes = execute.bodyBytes();
String body = new String (bytes,CharsetUtil.UTF_8);*/ String body = new String (bytes,CharsetUtil.UTF_8);*/
// 输出结果 // 输出结果
System.out.println(body); System.out.println("---上传结果："+body);
} catch (HttpException e) { } catch (HttpException e) {
e.printStackTrace(); e.printStackTrace();
throw new Exception("识别上传接口连接失败！！！"); throw new Exception("识别上传接口连接超时！！！");
} }
return body; 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="failNum != null "> and fail_num = #{failNum}</if>
<if test="failIds != null and failIds != ''"> and fail_ids = #{failIds}</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="resultStr != null and resultStr != ''"> and result_str = #{resultStr}</if>
<if test="remark != null and remark != ''">and remark like concat('%', #{remark}, '%') </if>
</where> </where>
order by id desc order by id desc
</select> </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"> <select id="selectDaTaskById" parameterType="Long" resultMap="DaTaskResult">
<include refid="selectDaTaskVo"/> <include refid="selectDaTaskVo"/>
where id = #{id} where id = #{id}

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

@ -310,8 +310,9 @@
/** 查询识别进度 */ /** 查询识别进度 */
getProgress() { getProgress() {
// 向给定ID的用户发起请求 // 向给定ID的用户发起请求
//axios.post('http://20.206.150.166:22443/get_file_count',`username=${this.$store.state.user.name}`, { 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://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: { headers: {
'Content-Type': 'application/x-www-form-urlencoded' 'Content-Type': 'application/x-www-form-urlencoded'
} }

Write Preview
Loading…
Cancel
Save