package org.jeecg.modules.lims.testing.controller;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
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.common.system.base.controller.JeecgController;
|
import org.jeecg.common.system.query.QueryGenerator;
|
import org.jeecg.common.system.vo.DictModel;
|
import org.jeecg.modules.lims.testing.dto.LimsTestingBatchDTO;
|
import org.jeecg.modules.lims.testing.entity.*;
|
import org.jeecg.modules.lims.testing.service.*;
|
import org.jeecg.modules.lims.testing.vo.LimsTestingBatchVo;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.bind.annotation.*;
|
import org.springframework.web.servlet.ModelAndView;
|
|
import javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpServletResponse;
|
import java.text.DecimalFormat;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicInteger;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Description: lims_testing_batch
|
* @Author: jeecg-boot
|
* @Date: 2023-05-11
|
* @Version: V1.0
|
*/
|
@Api(tags = "lims_testing_batch")
|
@RestController
|
@RequestMapping("/lims/testing/batch")
|
@Slf4j
|
public class LimsTestingBatchController extends JeecgController<LimsTestingBatch, ILimsTestingBatchService> {
|
@Autowired
|
private ILimsTestingBatchService limsTestingBatchService;
|
@Autowired
|
private ILimsBatchSampleService limsBatchSampleService;
|
@Autowired
|
private ILimsTestingProductService limsTestingProductService;
|
@Autowired
|
private ILimsTestingStandardService limsTestingStandardService;
|
@Autowired
|
private ILimsItemTargetService limsItemTargetService;
|
@Autowired
|
private ILimsBatchResultService limsBatchResultService;
|
@Autowired
|
private ILimsTestingStandCondService limsTestingStandCondService;
|
@Autowired
|
private ILimsBatchDetailService limsBatchDetailService;
|
@Autowired
|
private ILimsTestingItemService itemService;
|
@Autowired
|
private ILimsTestingTypeService typService;
|
@Autowired
|
private ILimsTestingCategoryService categoryService;
|
|
/**
|
* 分页列表查询
|
*
|
* @param limsTestingBatch
|
* @param pageNo
|
* @param pageSize
|
* @param req
|
* @return
|
*/
|
@AutoLog(value = "lims_testing_batch-分页列表查询")
|
@ApiOperation(value = "lims_testing_batch-分页列表查询", notes = "lims_testing_batch-分页列表查询")
|
@GetMapping(value = "/list")
|
public Result<?> queryPageList(LimsTestingBatch limsTestingBatch,
|
@RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
|
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
|
HttpServletRequest req) {
|
QueryWrapper<LimsTestingBatch> queryWrapper = QueryGenerator.initQueryWrapper(limsTestingBatch, req.getParameterMap());
|
Page<LimsTestingBatch> page = new Page<LimsTestingBatch>(pageNo, pageSize);
|
Page<LimsTestingBatchVo> page2 = new Page<LimsTestingBatchVo>(pageNo, pageSize);
|
IPage<LimsTestingBatch> pageList = limsTestingBatchService.page(page, queryWrapper);
|
comp(pageList, page2);
|
return Result.OK(page2);
|
}
|
|
private void comp(IPage<LimsTestingBatch> pageList, Page<LimsTestingBatchVo> page) {
|
List<LimsTestingBatchVo> collect = pageList.getRecords().stream().map(item -> {
|
LimsTestingBatchVo vo = new LimsTestingBatchVo();
|
BeanUtils.copyProperties(item, vo);
|
//产品名称
|
LimsTestingProduct product = limsTestingProductService.getById(item.getProdId());
|
if (product != null) {
|
vo.setProdName(product.getName());
|
}
|
LimsTestingStandard stand = limsTestingStandardService.getById(item.getStandardId());
|
if (stand != null) {
|
vo.setStandName(stand.getName());
|
}
|
//计算每个批次的完成进度
|
QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getBatchId, item.getId());
|
List<LimsBatchDetail> detailList = limsBatchDetailService.list(detailQueryWrapper);
|
vo.setProgress(0d);
|
if (detailList.size() > 0) {
|
//已完成检验数据
|
List<LimsBatchDetail> finishDetailList = detailList.stream().filter(detail -> detail.getValue() != null).collect(Collectors.toList());
|
vo.setBatchDetailTotal(detailList.size());
|
vo.setBatchDetailFinish(finishDetailList.size());
|
if (finishDetailList.size() > 0) {
|
double progress = finishDetailList.size() / 1.0 / detailList.size();
|
progress = progress * 100;
|
DecimalFormat decimalFormat = new DecimalFormat("#.0");
|
String pro = decimalFormat.format(progress);
|
vo.setProgress(Double.parseDouble(pro));
|
}
|
}
|
|
return vo;
|
}).collect(Collectors.toList());
|
BeanUtils.copyProperties(pageList, page);
|
page.setRecords(collect);
|
|
|
}
|
|
/**
|
* 添加
|
*
|
* @param limsTestingBatch
|
* @return
|
*/
|
@AutoLog(value = "lims_testing_batch-添加")
|
@ApiOperation(value = "lims_testing_batch-添加", notes = "lims_testing_batch-添加")
|
@PostMapping(value = "/add")
|
@Transactional
|
public Result<?> add(@RequestBody LimsTestingBatchDTO limsTestingBatch) {
|
|
//添加批次后需要生成样本信息
|
limsTestingBatch.setBatchDate(new Date());
|
QueryWrapper<LimsTestingStandard> queryWrapper = new QueryWrapper<>();
|
//查询产品发布技术标准发布的
|
queryWrapper.lambda().eq(LimsTestingStandard::getProdId, limsTestingBatch.getProdId())
|
.eq(LimsTestingStandard::getStatus, 1).orderByDesc(LimsTestingStandard::getCreateTime);
|
//查询产品的技术标准
|
List<LimsTestingStandard> standList = limsTestingStandardService.list(queryWrapper);
|
if (!standList.isEmpty() && standList.size() > 0) {
|
String standId = standList.get(0).getId();
|
limsTestingBatch.setStandardId(standId);
|
} else {
|
return Result.error("当前产品没有发布技术标准，请维护后重试!");
|
}
|
//1.生成批次
|
limsTestingBatchService.save(limsTestingBatch);
|
|
//2.生成样本数据
|
generateSimpleData(limsTestingBatch);
|
//3.生成检测记录汇总结果
|
Integer integer = generateInspectRecord(limsTestingBatch);
|
if (integer == -1) {
|
return Result.error("当前产品未设置鉴定项目，请维护技术标准后重试!");
|
}
|
//4.生成检测明细
|
generateInspectDetail(limsTestingBatch);
|
|
return Result.OK("添加成功！");
|
}
|
|
//生成样本数据
|
private void generateSimpleData(LimsTestingBatchDTO limsTestingBatch) {
|
List<LimsTestingBatchDTO.ChannelInfo> channelInfoList = limsTestingBatch.getChannelInfoList();
|
if (channelInfoList.isEmpty()) return;
|
AtomicInteger sampleSum = new AtomicInteger();
|
channelInfoList.stream().forEach(item -> {
|
String channels = item.getChannels();
|
Integer sampleNum = item.getSampleNum();
|
//通道 和 样本数 为空时跳过
|
if (StringUtils.isEmpty(channels) || sampleNum == null) {
|
return;
|
}
|
String[] channelArray = channels.split(",");
|
//通道数
|
for (int i = 0; i < channelArray.length; i++) {
|
String channel = channelArray[i];
|
//样本数
|
for (int j = 0; j < sampleNum; j++) {
|
sampleSum.getAndIncrement();
|
LimsBatchSample sample = new LimsBatchSample();
|
sample.setBatchId(limsTestingBatch.getId());
|
sample.setModelId(item.getModelId());
|
sample.setChannel(channel);
|
sample.setProdId(limsTestingBatch.getProdId());
|
sample.setCode(item.getModelCode() + "-s" + (j + 1) + "-c" + channel);
|
|
limsBatchSampleService.save(sample);
|
}
|
}
|
|
|
});
|
//生成样本后更新统计数据
|
limsTestingBatch.setSampleNum(sampleSum.get());
|
limsTestingBatchService.updateById(limsTestingBatch);
|
}
|
|
//生成检验记录
|
private Integer generateInspectRecord(LimsTestingBatchDTO limsTestingBatch) {
|
String standardId = limsTestingBatch.getStandardId();
|
QueryWrapper<LimsItemTarget> itemTargetQueryWrapper = new QueryWrapper<>();
|
itemTargetQueryWrapper.lambda().eq(LimsItemTarget::getStandardId, standardId);
|
itemTargetQueryWrapper.lambda().eq(LimsItemTarget::getEnabled,1);
|
List<LimsItemTarget> targetList = limsItemTargetService.list(itemTargetQueryWrapper);
|
Map<String, List<LimsItemTarget>> typGroupMap = targetList.stream().collect(Collectors.groupingBy(LimsItemTarget::getTypeId));
|
Map<String, List<LimsItemTarget>> itmGroupMap = targetList.stream().collect(Collectors.groupingBy(LimsItemTarget::getItemId));
|
if (itmGroupMap.isEmpty()) {
|
return -1;
|
}
|
//根据typ分组
|
typGroupMap.forEach((typ, value) -> {
|
LimsBatchResult result = new LimsBatchResult();
|
result.setBatchId(limsTestingBatch.getId());
|
result.setTestingCat(value.get(0).getCategoryId());
|
result.setTestingType(typ);
|
|
LimsTestingCategory category = categoryService.getById(result.getTestingCat());
|
LimsTestingType t = typService.getById(result.getTestingType());
|
double sort = category.getSort() * 100 + t.getSort() * 1;
|
result.setSort(sort);
|
limsBatchResultService.save(result);
|
});
|
|
return 1;
|
|
}
|
|
/**
|
* 生成检验明细
|
*/
|
private void generateInspectDetail(LimsTestingBatchDTO limsTestingBatch) {
|
/* //1.查询批次检测项目
|
String standardId = limsTestingBatch.getStandardId();
|
QueryWrapper<LimsItemTarget> itemTargetQueryWrapper = new QueryWrapper<>();
|
itemTargetQueryWrapper.lambda().eq(LimsItemTarget::getStandardId, standardId);
|
List<LimsItemTarget> targetList = limsItemTargetService.list(itemTargetQueryWrapper);
|
Map<String, List<LimsItemTarget>> typGroupMap = targetList.stream().collect(Collectors.groupingBy(LimsItemTarget::getTypeId));
|
|
//2.查询批次所有样本
|
QueryWrapper<LimsBatchSample> sampleQueryWrapper = new QueryWrapper<>();
|
sampleQueryWrapper.lambda().eq(LimsBatchSample::getBatchId,limsTestingBatch.getId());
|
List<LimsBatchSample> sampleList = limsBatchSampleService.list(sampleQueryWrapper);
|
|
|
//遍历技术标准下鉴定类别-type（查询各type的检测条件）
|
typGroupMap.forEach((type,list)->{
|
//查询批次下技术标准所有检测条件
|
QueryWrapper<LimsTestingStandCond> condQueryWrapper = new QueryWrapper<>();
|
condQueryWrapper.lambda().eq(LimsTestingStandCond::getTypeId,type);
|
List<LimsTestingStandCond> conds = limsTestingStandCondService.list(condQueryWrapper);
|
//如果没有检验条件，则添加一行检验数据
|
if(conds ==null || conds.size() < 1) {
|
LimsTestingStandCond cond = new LimsTestingStandCond();
|
cond.setCond("-");
|
conds.add(cond);
|
}
|
|
for (int i = 0; i <conds.size() ; i++) {
|
LimsTestingStandCond cond = conds.get(i);
|
|
for (int j = 0; j < sampleList.size(); j++) {
|
|
}
|
|
}
|
|
});
|
*/
|
|
//1.查询 批次检验结果记录
|
QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, limsTestingBatch.getId());
|
List<LimsBatchResult> resultList = limsBatchResultService.list(resultQueryWrapper);
|
Map<String, String> resultMap = resultList.stream().collect(Collectors.toMap(LimsBatchResult::getTestingType, LimsBatchResult::getId));
|
|
|
//2.通过type 查询item
|
List<String> typList = resultList.stream().map(LimsBatchResult::getTestingType).collect(Collectors.toList());
|
|
//3.根据typ查询需检验的所有鉴定项
|
QueryWrapper<LimsItemTarget> targetQueryWrapper = new QueryWrapper<>();
|
targetQueryWrapper.lambda().eq(LimsItemTarget::getStandardId, limsTestingBatch.getStandardId());
|
targetQueryWrapper.lambda().in(LimsItemTarget::getTypeId, typList.toArray());
|
targetQueryWrapper.lambda().eq(LimsItemTarget::getEnabled, 1);
|
List<LimsItemTarget> targetList = limsItemTargetService.list(targetQueryWrapper);
|
List<String> typeIds = new ArrayList<>();
|
List<String> itemIds = new ArrayList<>();
|
|
//4.根据type分类item
|
Map<String, List<LimsItemTarget>> typGroupMap = targetList.stream().collect(Collectors.groupingBy(LimsItemTarget::getTypeId));
|
|
//5.查询type的测试条件
|
Map<String, List<LimsTestingStandCond>> typCondMap1 = new HashMap<>();
|
Map<String, List<LimsTestingStandCond>> typCondMap2 = new HashMap<>();
|
typGroupMap.forEach((typ, itmList) -> {
|
//保存typid和itemid 供生成破坏性使用
|
typeIds.add(typ);
|
List<String> itmIds = itmList.stream().filter(item->item.getEnabled()!=null && item.getEnabled()==1).map(LimsItemTarget::getItemId).collect(Collectors.toList());
|
itemIds.addAll(itmIds);
|
//保存typid和itemid 供生成破坏性使用
|
QueryWrapper<LimsTestingStandCond> condQueryWrapper1 = new QueryWrapper<>();
|
condQueryWrapper1.lambda().eq(LimsTestingStandCond::getStandardId, limsTestingBatch.getStandardId());
|
condQueryWrapper1.lambda().eq(LimsTestingStandCond::getTypeId, typ);
|
//测试电压
|
condQueryWrapper1.lambda().eq(LimsTestingStandCond::getType, 1);
|
List<LimsTestingStandCond> typCondList1 = limsTestingStandCondService.list(condQueryWrapper1);
|
if (typCondList1 == null || typCondList1.size() < 1) {
|
LimsTestingStandCond cond = new LimsTestingStandCond();
|
cond.setCond("-");
|
typCondList1.add(cond);
|
}
|
typCondMap1.put(typ, typCondList1);
|
//测试温度
|
QueryWrapper<LimsTestingStandCond> condQueryWrapper2 = new QueryWrapper<>();
|
condQueryWrapper2.lambda().eq(LimsTestingStandCond::getStandardId, limsTestingBatch.getStandardId());
|
condQueryWrapper2.lambda().eq(LimsTestingStandCond::getTypeId, typ);
|
condQueryWrapper2.lambda().eq(LimsTestingStandCond::getType, 2);
|
List<LimsTestingStandCond> typCondList2 = limsTestingStandCondService.list(condQueryWrapper2);
|
if (typCondList2 == null || typCondList2.size() < 1) {
|
LimsTestingStandCond cond = new LimsTestingStandCond();
|
cond.setCond("-");
|
typCondList2.add(cond);
|
}
|
typCondMap2.put(typ, typCondList2);
|
|
|
});
|
//6.查询批次所有样本
|
QueryWrapper<LimsBatchSample> sampleQueryWrapper = new QueryWrapper<>();
|
sampleQueryWrapper.lambda().eq(LimsBatchSample::getBatchId, limsTestingBatch.getId());
|
List<LimsBatchSample> sampleList = limsBatchSampleService.list(sampleQueryWrapper);
|
|
List<LimsBatchDetail> saveList = new ArrayList<>();
|
//组装数据
|
targetList.stream().forEach(itm -> {
|
String typeId = itm.getTypeId();
|
//查询typ是否破坏性实验
|
LimsTestingType typ = typService.getById(typeId);
|
sampleList.forEach(sample -> {
|
|
//测试电压
|
List<LimsTestingStandCond> conds1 = typCondMap1.get(typeId);
|
//测试温度
|
List<LimsTestingStandCond> conds2 = typCondMap2.get(typeId);
|
|
conds1.forEach(cond1 -> {
|
conds2.forEach(cond2 -> {
|
LimsBatchDetail detail = new LimsBatchDetail();
|
detail.setResultId(resultMap.get(typeId));
|
detail.setSampleId(sample.getId());
|
detail.setItemId(itm.getItemId());
|
detail.setCond(cond1.getCond());
|
detail.setCond2(cond2.getCond());
|
detail.setBatchId(limsTestingBatch.getId());
|
//limsBatchDetailService.save(detail);
|
saveList.add(detail);
|
|
});
|
});
|
|
});
|
});
|
//10 补充破坏性实验需要数据
|
//10.1 查询所有typ项
|
QueryWrapper<LimsTestingType> typeQueryWrapper = new QueryWrapper<>();
|
typeQueryWrapper.lambda().in(LimsTestingType::getId,typeIds);
|
List<LimsTestingType> tList = typService.list(typeQueryWrapper);
|
|
//10.2 根据typ查询所有itm并筛选出常规项
|
QueryWrapper<LimsTestingItem> itemQueryWrapper = new QueryWrapper<>();
|
itemQueryWrapper.lambda().in(LimsTestingItem::getId,itemIds);
|
itemQueryWrapper.lambda().eq(LimsTestingItem::getGengeral,1);
|
itemQueryWrapper.lambda().eq(LimsTestingItem::getEnabled,1);
|
List<LimsTestingItem> itmGengeralList = itemService.list(itemQueryWrapper);
|
|
tList.forEach(typ->{
|
if(typ.getDestructive()==null || typ.getDestructive()==0) return;
|
sampleList.forEach(sample -> {
|
itmGengeralList.forEach(itm->{
|
//fix 破坏性实验不需要添加条件
|
// //测试电压
|
// List<LimsTestingStandCond> conds1 = typCondMap1.get(itm.getTypeId());
|
// //测试温度
|
// List<LimsTestingStandCond> conds2 = typCondMap2.get(itm.getTypeId());
|
//
|
// conds1.forEach(cond1 -> {
|
// conds2.forEach(cond2 -> {
|
|
LimsBatchDetail detail2 = new LimsBatchDetail();
|
detail2.setResultId(resultMap.get(typ.getId()));
|
detail2.setSampleId(sample.getId());
|
detail2.setItemId(itm.getId());
|
detail2.setCond("-");
|
detail2.setCond2("-");
|
detail2.setBatchId(limsTestingBatch.getId());
|
detail2.setDestroy(1);
|
detail2.setRemark(typ.getName()+"破坏性实验检测项");
|
detail2.setTid(typ.getId());
|
saveList.add(detail2);
|
//limsBatchDetailService.save(detail2);
|
|
LimsBatchDetail detail3 = new LimsBatchDetail();
|
detail3.setResultId(resultMap.get(typ.getId()));
|
detail3.setSampleId(sample.getId());
|
detail3.setItemId(itm.getId());
|
detail3.setCond("-");
|
detail3.setCond2("-");
|
detail3.setDestroy(2);
|
detail3.setRemark(typ.getName()+"破坏性实验检测项");
|
detail3.setBatchId(limsTestingBatch.getId());
|
detail3.setTid(typ.getId());
|
//limsBatchDetailService.save(detail3);
|
saveList.add(detail3);
|
});
|
|
// });
|
// });
|
});
|
|
|
});
|
limsBatchDetailService.saveBatch(saveList);
|
}
|
|
/**
|
* 编辑
|
*
|
* @param limsTestingBatch
|
* @return
|
*/
|
@AutoLog(value = "lims_testing_batch-编辑")
|
@ApiOperation(value = "lims_testing_batch-编辑", notes = "lims_testing_batch-编辑")
|
@PutMapping(value = "/edit")
|
|
public Result<?> edit(@RequestBody LimsTestingBatch limsTestingBatch) {
|
limsTestingBatchService.updateById(limsTestingBatch);
|
return Result.OK("编辑成功!");
|
}
|
|
/**
|
* 通过id删除
|
*
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "lims_testing_batch-通过id删除")
|
@ApiOperation(value = "lims_testing_batch-通过id删除", notes = "lims_testing_batch-通过id删除")
|
@DeleteMapping(value = "/delete")
|
@Transactional
|
public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
|
limsTestingBatchService.removeById(id);
|
//删除批次时还需删除批次下生成的数据
|
//1.删除批次检验结果记录
|
QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
|
resultQueryWrapper.lambda().eq(LimsBatchResult::getBatchId, id);
|
limsBatchResultService.remove(resultQueryWrapper);
|
//2.删除批次检验结果记录明细
|
QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
|
detailQueryWrapper.lambda().eq(LimsBatchDetail::getBatchId, id);
|
limsBatchDetailService.remove(detailQueryWrapper);
|
//3.删除批次下生成样本数据
|
QueryWrapper<LimsBatchSample> sampleQueryWrapper = new QueryWrapper<>();
|
sampleQueryWrapper.lambda().eq(LimsBatchSample::getBatchId, id);
|
limsBatchSampleService.remove(sampleQueryWrapper);
|
return Result.OK("删除成功!");
|
}
|
|
/**
|
* 批量删除
|
*
|
* @param ids
|
* @return
|
*/
|
@AutoLog(value = "lims_testing_batch-批量删除")
|
@ApiOperation(value = "lims_testing_batch-批量删除", notes = "lims_testing_batch-批量删除")
|
@DeleteMapping(value = "/deleteBatch")
|
@Transactional
|
public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
|
List<String> idList = Arrays.asList(ids.split(","));
|
this.limsTestingBatchService.removeByIds(idList);
|
//删除批次时还需删除批次下生成的数据
|
//1.删除批次检验结果记录
|
QueryWrapper<LimsBatchResult> resultQueryWrapper = new QueryWrapper<>();
|
resultQueryWrapper.lambda().in(LimsBatchResult::getBatchId, idList);
|
limsBatchResultService.remove(resultQueryWrapper);
|
//2.删除批次检验结果记录明细
|
QueryWrapper<LimsBatchDetail> detailQueryWrapper = new QueryWrapper<>();
|
detailQueryWrapper.lambda().in(LimsBatchDetail::getBatchId, idList);
|
limsBatchDetailService.remove(detailQueryWrapper);
|
//3.删除批次下生成样本数据
|
QueryWrapper<LimsBatchSample> sampleQueryWrapper = new QueryWrapper<>();
|
sampleQueryWrapper.lambda().in(LimsBatchSample::getBatchId, idList);
|
limsBatchSampleService.remove(sampleQueryWrapper);
|
return Result.OK("批量删除成功!");
|
}
|
|
/**
|
* 通过id查询
|
*
|
* @param id
|
* @return
|
*/
|
@AutoLog(value = "lims_testing_batch-通过id查询")
|
@ApiOperation(value = "lims_testing_batch-通过id查询", notes = "lims_testing_batch-通过id查询")
|
@GetMapping(value = "/queryById")
|
public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
|
LimsTestingBatch limsTestingBatch = limsTestingBatchService.getById(id);
|
if (limsTestingBatch == null) {
|
return Result.error("未找到对应数据");
|
}
|
return Result.OK(limsTestingBatch);
|
}
|
|
/**
|
* 导出excel
|
*
|
* @param request
|
* @param limsTestingBatch
|
*/
|
@RequestMapping(value = "/exportXls")
|
public ModelAndView exportXls(HttpServletRequest request, LimsTestingBatch limsTestingBatch) {
|
return super.exportXls(request, limsTestingBatch, LimsTestingBatch.class, "lims_testing_batch");
|
}
|
|
/**
|
* 通过excel导入数据
|
*
|
* @param request
|
* @param response
|
* @return
|
*/
|
@RequestMapping(value = "/importExcel", method = RequestMethod.POST)
|
public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
|
return super.importExcel(request, response, LimsTestingBatch.class);
|
}
|
|
}
|
