package org.jeecg.modules.lims.testing.controller;
|
|
import com.alibaba.fastjson.JSON;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.jeecg.common.api.vo.Result;
|
import org.jeecg.common.aspect.annotation.AutoLog;
|
import org.jeecg.modules.lims.testing.entity.*;
|
import org.jeecg.modules.lims.testing.service.*;
|
import org.jeecg.modules.lims.testing.vo.LimsBatchDetailVo;
|
import org.jeecg.modules.lims.testing.vo.LimsBatchSampleVo;
|
import org.jeecg.modules.lims.testing.vo.LimsTestingTypeVo;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.GetMapping;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RequestParam;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicInteger;
|
import java.util.stream.Collectors;
|
|
@Api(tags = "小程序接口")
|
@RestController
|
@RequestMapping("/lims/testing/mini")
|
@Slf4j
|
public class LimsMiniController {
|
/**
|
* description:
|
* 小程序中部分组件或页面需要组装数据或回写数据，新增接口
|
*/
|
@Autowired
|
private ILimsBatchResultService resultService;
|
@Autowired
|
private ILimsTestingTypeService typeService;
|
@Autowired
|
private ILimsBatchDetailService detailService;
|
@Autowired
|
private ILimsTestingItemService itemService;
|
@Autowired
|
private ILimsTestingBatchService batchService;
|
@Autowired
|
private ILimsTestingStandCondService condService;
|
@Autowired
|
private ILimsBatchSampleService sampleService;
|
@Autowired
|
private ILimsTestingCategoryService categoryService;
|
@Autowired
|
private ILimsTestingStandardService standardService;
|
@Autowired
|
private ILimsItemTargetService targetService;
|
|
|
@AutoLog(value = "小程序-查询批次检验分类-鉴定类别")
|
@ApiOperation(value = "小程序-查询批次检验分类-鉴定类别", notes = "小程序-查询批次检验分类-鉴定类别")
|
@GetMapping(value = "/bacthCatList")
|
public Result<?> queryBatchCatList(LimsTestingBatch limsTestingBatch) {
|
QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, limsTestingBatch.getId());
|
//1.查询批次检验结果列表，
|
List<LimsBatchResult> resultList = resultService.list(resultQueryWrapper);
|
//2.得到鉴定类别id列表
|
List<String> catIds = resultList.stream().map(LimsBatchResult::getTestingCat).collect(Collectors.toList());
|
if (catIds.isEmpty()) catIds.add("empty");
|
//3.查询鉴定类别列表
|
QueryWrapper<LimsTestingCategory> catQueryWrapper = new QueryWrapper<>();
|
catQueryWrapper.lambda().in(LimsTestingCategory::getId, catIds);
|
List<LimsTestingCategory> catList = categoryService.list(catQueryWrapper);
|
|
/* LimsTestingBatch batch = batchService.getById(limsTestingBatch.getId());
|
if (StringUtils.isEmpty(batch.getStandardId())) {
|
return Result.error("技术标准信息错误！");
|
}
|
QueryWrapper<LimsItemTarget> targetQueryWrapper = new QueryWrapper<>();
|
targetQueryWrapper.lambda().eq(LimsItemTarget::getStandardId, batch.getStandardId());
|
targetQueryWrapper.lambda().eq(LimsItemTarget::getEnabled, 1);
|
List<LimsItemTarget> itemTargetList = targetService.list(targetQueryWrapper);
|
List<String> catIds = itemTargetList.stream().map(LimsItemTarget::getCategoryId).collect(Collectors.toList());
|
if (catIds.isEmpty()) catIds.add("empty");
|
QueryWrapper<LimsTestingCategory> catQueryWrapper = new QueryWrapper<>();
|
catQueryWrapper.lambda().in(LimsTestingCategory::getId, catIds);
|
List<LimsTestingCategory> catList = categoryService.list(catQueryWrapper);*/
|
return Result.OK(catList);
|
}
|
|
@AutoLog(value = "小程序-查询批次检验分类-根据鉴定类别查询鉴定类型")
|
@ApiOperation(value = "小程序-查询批次检验分类-根据鉴定类别查询鉴定类型", notes = "小程序-查询批次检验分类-根据鉴定类别查询鉴定类型")
|
@GetMapping(value = "/typList")
|
public Result<?> queryTypListByCat(LimsBatchResult limsBatchResult) {
|
//查询BatchResult
|
QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, limsBatchResult.getBatchId());
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getTestingCat, limsBatchResult.getTestingCat());
|
List<LimsBatchResult> resultList = resultService.list(resultQueryWrapper);
|
if (resultList.isEmpty()) {
|
return Result.error("未查询到数据!");
|
}
|
|
|
List<String> typIds = resultList.stream().map(LimsBatchResult::getTestingType).distinct().collect(Collectors.toList());
|
if (typIds.isEmpty()) typIds.add("empty");
|
|
QueryWrapper<LimsTestingType> typQueryWrapper = new QueryWrapper<>();
|
typQueryWrapper.lambda().in(LimsTestingType::getId, typIds);
|
List<LimsTestingType> typList = typeService.list(typQueryWrapper);
|
|
//统计每个类型的完成数量
|
Map<String, String> typResultMap = resultList.stream().collect(Collectors.toMap(LimsBatchResult::getTestingType, LimsBatchResult::getId));
|
|
List<LimsTestingTypeVo> collect = typList.stream().map(item -> {
|
LimsTestingTypeVo vo = new LimsTestingTypeVo();
|
BeanUtils.copyProperties(item, vo);
|
try {
|
String resultId = typResultMap.get(item.getId());
|
QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getResultId, resultId);
|
List<LimsBatchDetail> detailList = detailService.list(detailQueryWrapper);
|
List<LimsBatchDetail> finishDetailList = detailList.stream().filter(d -> d.getValue() != null).collect(Collectors.toList());
|
vo.setBatchDetailTotal(detailList.size());
|
vo.setBatchDetailFinish(finishDetailList.size());
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
|
return vo;
|
}).collect(Collectors.toList());
|
|
|
return Result.OK(collect);
|
}
|
|
|
/**
|
* @param batchId 批次
|
* @param typeId 检验类型
|
* @return
|
*/
|
|
@AutoLog(value = "小程序-查询批次下type类型的检测条件")
|
@ApiOperation(value = "小程序-查询批次下type类型的检测条件", notes = "小程序-查询批次下type类型的检测条件")
|
@GetMapping(value = "/typeCond")
|
public Result<?> queryBatchTypeCond(String batchId, String typeId) {
|
if (StringUtils.isEmpty(batchId)) return Result.error("批次Id不能为空！");
|
if (StringUtils.isEmpty(typeId)) return Result.error("检验类型Id不能为空！");
|
|
//1.查询批次产品的技术标准
|
LimsTestingBatch batch = batchService.getById(batchId);
|
String standardId = batch.getStandardId();
|
//2.查询type的检验条件
|
QueryWrapper<LimsTestingStandCond> condQueryWrapper = new QueryWrapper<>();
|
condQueryWrapper.lambda().eq(LimsTestingStandCond::getStandardId, standardId);
|
condQueryWrapper.lambda().eq(LimsTestingStandCond::getTypeId, typeId);
|
List<LimsTestingStandCond> condList = condService.list(condQueryWrapper);
|
return Result.OK(condList);
|
|
}
|
|
|
@AutoLog(value = "小程序-查询批次检验结果")
|
@ApiOperation(value = "小程序-查询批次检验结果", notes = "小程序-查询批次检验结果")
|
@GetMapping(value = "/batchResult")
|
public Result<?> queryBatchResult(String batchId, String typeId) {
|
if (StringUtils.isEmpty(batchId)) return Result.error("批次Id不能为空！");
|
if (StringUtils.isEmpty(typeId)) return Result.error("检验类型Id不能为空！");
|
|
QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, batchId);
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getTestingType, typeId);
|
LimsBatchResult batchResult = resultService.getOne(resultQueryWrapper);
|
return Result.OK(batchResult);
|
|
}
|
|
|
@AutoLog(value = "小程序-查询批次检验结果")
|
@ApiOperation(value = "小程序-查询批次检验结果", notes = "小程序-查询批次检验结果")
|
@GetMapping(value = "/inputInfo")
|
public Result<?> queryInfo(@RequestParam(required = false) Map<String, String> options) {
|
Map<String, Object> result = new HashMap<>();
|
Map<String, Object> info = new HashMap<>();
|
LimsTestingBatch batch = batchService.getById(options.get("batch"));
|
LimsTestingCategory cat = categoryService.getById(options.get("cat"));
|
LimsTestingType type = typeService.getById(options.get("type"));
|
LimsBatchSample sample = sampleService.getById(options.get("sample"));
|
//1.组装页面展示信息
|
info.put("batchCode", batch.getBatchCode());
|
info.put("typeName", type.getName());
|
info.put("catName", cat.getName());
|
info.put("cond1", options.get("cond1"));
|
info.put("cond2", options.get("cond2"));
|
info.put("sampleCode", sample.getCode());
|
|
|
//1.1 根据batch查询技术标准
|
String standardId = batch.getStandardId();
|
LimsTestingStandard standard = standardService.getById(standardId);
|
//1.2通过批次和技术标准查询
|
QueryWrapper<LimsItemTarget> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(LimsItemTarget::getStandardId,standard.getId());
|
List<LimsItemTarget> targetList = targetService.list(queryWrapper);
|
//itemid valType
|
Map<String, String> tarMap = targetList.stream().filter(item->item.getItemId()!=null && item.getValType()!=null).collect(Collectors.toMap(LimsItemTarget::getItemId, LimsItemTarget::getValType));
|
//2.查询batch_detail
|
QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getBatchId, options.get("batch"));
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getResultId, options.get("result"));
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getSampleId, options.get("sample"));
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getCond, options.get("cond1"));
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getCond2, options.get("cond2"));
|
detailQueryWrapper.lambda().isNull(LimsBatchDetail::getDestroy);
|
List<LimsBatchDetail> batchDetailList = detailService.list(detailQueryWrapper);
|
|
//破坏性
|
QueryWrapper<LimsBatchDetail> detailQueryWrapper2 = new QueryWrapper<>();
|
detailQueryWrapper2.lambda().eq(LimsBatchDetail::getBatchId, options.get("batch"));
|
detailQueryWrapper2.lambda().eq(LimsBatchDetail::getResultId, options.get("result"));
|
detailQueryWrapper2.lambda().eq(LimsBatchDetail::getSampleId, options.get("sample"));
|
detailQueryWrapper2.lambda().isNotNull(LimsBatchDetail::getDestroy);
|
List<LimsBatchDetail> batchDetailList2 = detailService.list(detailQueryWrapper2);
|
batchDetailList.addAll(batchDetailList2);
|
|
List<LimsBatchDetailVo> collect = batchDetailList.stream().map(item -> {
|
LimsBatchDetailVo vo = new LimsBatchDetailVo();
|
BeanUtils.copyProperties(item, vo);
|
LimsTestingItem testingItem = itemService.getById(item.getItemId());
|
vo.setItemName(testingItem.getName());
|
if(tarMap.containsKey(testingItem.getId())){
|
vo.setValType(tarMap.get(testingItem.getId()));
|
}
|
|
return vo;
|
}).collect(Collectors.toList());
|
result.put("info", JSON.toJSON(info));
|
result.put("model", JSON.toJSON(collect));
|
return Result.OK(result);
|
}
|
|
|
@AutoLog(value = "小程序-根据条件查询样本列表")
|
@ApiOperation(value = "小程序-根据条件查询样本列表", notes = "小程序-根据条件查询样本列表")
|
@GetMapping(value = "/condSample")
|
public Result<?> querySampleByCond(@RequestParam(required = false) Map<String, String> options) {
|
String batchId = options.get("batchId");
|
String catId = options.get("catId");
|
String typeId = options.get("typeId");
|
String cond = options.get("cond");
|
String cond2 = options.get("cond2");
|
|
//0.查询batch_result
|
QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, batchId);
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getTestingCat, catId);
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getTestingType, typeId);
|
LimsBatchResult batchResult = resultService.getOne(resultQueryWrapper);
|
|
//1.1 查询检验明细
|
QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getBatchId, batchId);
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getCond, cond);
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getCond2, cond2);
|
detailQueryWrapper.lambda().isNull(LimsBatchDetail::getDestroy);
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getResultId, batchResult.getId());
|
List<LimsBatchDetail> detailList = detailService.list(detailQueryWrapper);
|
|
//1.2 查询破坏性
|
QueryWrapper<LimsBatchDetail> detailQueryWrapper2 = new QueryWrapper<>();
|
detailQueryWrapper2.lambda().eq(LimsBatchDetail::getBatchId, batchId);
|
detailQueryWrapper2.lambda().isNotNull(LimsBatchDetail::getDestroy);
|
detailQueryWrapper2.lambda().eq(LimsBatchDetail::getResultId, batchResult.getId());
|
List<LimsBatchDetail> detailList2 = detailService.list(detailQueryWrapper2);
|
detailList.addAll(detailList2);
|
|
//2.根据明细,得到样本
|
Map<String, List<LimsBatchDetail>> sampleMap = detailList.stream().collect(Collectors.groupingBy(item -> item.getSampleId()));
|
List<String> sampleIds = new ArrayList<>(sampleMap.keySet());
|
sampleIds.add("empty");
|
QueryWrapper<LimsBatchSample> sampleQueryWrapper = new QueryWrapper<>();
|
sampleQueryWrapper.lambda().in(LimsBatchSample::getId, sampleIds);
|
|
List<LimsBatchSample> batchSample = sampleService.list(sampleQueryWrapper);
|
|
AtomicInteger index = new AtomicInteger(1);
|
List<LimsBatchSampleVo> collect = batchSample.stream().map(item -> {
|
LimsBatchSampleVo vo = new LimsBatchSampleVo();
|
BeanUtils.copyProperties(item, vo);
|
if (sampleMap.containsKey(item.getId())) {
|
List<LimsBatchDetail> finish = sampleMap.get(item.getId()).stream().filter(i -> i.getValue() != null).collect(Collectors.toList());
|
vo.setInspectCount(sampleMap.get(item.getId()).size());
|
vo.setInspectFinish(finish.size());
|
} else {
|
vo.setInspectCount(0);
|
vo.setInspectFinish(0);
|
}
|
vo.setModelName("m"+index + vo.getCode().substring(vo.getCode().indexOf("-")) );
|
index.getAndIncrement();
|
|
return vo;
|
}).collect(Collectors.toList());
|
return Result.OK(collect);
|
|
}
|
|
|
}
|
