admin/wisdomisite-java
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

包头 0921

Browse Source
This commit is contained in:
guoshengxiong 2024-09-21 19:11:54 +08:00
parent a35a4dd060
commit e9ef2e94e4
53 changed files with 2780 additions and 645 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/com/zhgd/xmgl/modules/baotou/controller/GreenConstructionSchemeController.java
View File

@ -25,7 +25,7 @@ import org.springframework.web.bind.annotation.*;
/**
* @Title: Controller
* @Description: 绿色施工方案管理
* @Description: 绿色施工方案管理修改为危大工程清单
* @author： pds
* @date： 2024-08-24
* @version： V1.0

362
src/main/java/com/zhgd/xmgl/modules/baotou/controller/NondestructiveTestOrderTicketController.java
View File

@ -1,37 +1,35 @@
package com.zhgd.xmgl.modules.baotou.controller;
import java.util.Date;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.gexin.fastjson.JSON;
import com.zhgd.annotation.OperLog;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.xmgl.modules.baotou.entity.NondestructiveTestOrderTicket;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingRecord;
import com.zhgd.xmgl.modules.baotou.service.INondestructiveTestOrderTicketService;
import com.zhgd.xmgl.modules.baotou.service.IPipelineWeldingRecordService;
import com.zhgd.xmgl.util.FlowUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiImplicitParams;
import java.util.HashMap;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.simpleframework.xml.core.Validate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;
import java.util.List;
import java.util.Map;
import com.zhgd.jeecg.common.api.vo.Result;
import org.apache.commons.collections.MapUtils;
import com.zhgd.xmgl.modules.baotou.entity.NondestructiveTestOrderTicket;
import com.zhgd.xmgl.modules.baotou.service.INondestructiveTestOrderTicketService;
import org.simpleframework.xml.core.Validate;
import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
/**
* @Title: Controller
* @Description: 无损检测委托单
* @author： pds
* @date： 2024-08-26
* @date： 2024-08-26
* @version： V1.0
*/
@RestController
@ -39,163 +37,193 @@ import org.springframework.web.bind.annotation.*;
@Slf4j
@Api(tags = "无损检测委托单相关Api")
public class NondestructiveTestOrderTicketController {
@Autowired
private INondestructiveTestOrderTicketService nondestructiveTestOrderTicketService;
@Autowired
@Lazy
IPipelineWeldingRecordService pipelineWeldingRecordService;
@Autowired
private INondestructiveTestOrderTicketService nondestructiveTestOrderTicketService;
/**
* 分页列表查询
* @return
*/
/**
* 分页列表查询
*
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "分页查询", operDesc = "分页列表查询无损检测委托单信息")
@ApiOperation(value = "分页列表查询无损检测委托单信息", notes = "分页列表查询无损检测委托单信息", httpMethod="GET")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNo", value = "第几页", paramType = "query", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示条数", paramType = "query", required = true, dataType = "Integer"),
})
@GetMapping(value = "/page")
public Result<IPage<NondestructiveTestOrderTicket>> queryPageList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(nondestructiveTestOrderTicketService.queryPageList(param));
}
@ApiOperation(value = "分页列表查询无损检测委托单信息", notes = "分页列表查询无损检测委托单信息", httpMethod = "GET")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNo", value = "第几页", paramType = "query", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示条数", paramType = "query", required = true, dataType = "Integer"),
})
@GetMapping(value = "/page")
public Result<IPage<NondestructiveTestOrderTicket>> queryPageList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(nondestructiveTestOrderTicketService.queryPageList(param));
}
/**
* 列表查询
* @return
*/
/**
* 列表查询
*
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "列表查询", operDesc = "列表查询无损检测委托单信息")
@ApiOperation(value = "列表查询无损检测委托单信息", notes = "列表查询无损检测委托单信息", httpMethod="GET")
@GetMapping(value = "/list")
public Result<List<NondestructiveTestOrderTicket>> queryList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(nondestructiveTestOrderTicketService.queryList(param));
}
@ApiOperation(value = "列表查询无损检测委托单信息", notes = "列表查询无损检测委托单信息", httpMethod = "GET")
@GetMapping(value = "/list")
public Result<List<NondestructiveTestOrderTicket>> queryList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(nondestructiveTestOrderTicketService.queryList(param));
}
/**
* 添加
* @param nondestructiveTestOrderTicket
* @return
*/
/**
* 添加
*
* @param nondestructiveTestOrderTicket
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "添加", operDesc = "添加无损检测委托单信息")
@ApiOperation(value = "添加无损检测委托单信息", notes = "添加无损检测委托单信息" , httpMethod="POST")
@PostMapping(value = "/add")
public Result<NondestructiveTestOrderTicket> add(@RequestBody @Validate NondestructiveTestOrderTicket nondestructiveTestOrderTicket) {
nondestructiveTestOrderTicketService.add(nondestructiveTestOrderTicket);
return Result.ok();
}
@OperLog(operModul = "无损检测委托单管理", operType = "添加", operDesc = "工作流添加无损检测委托单信息")
@ApiOperation(value = "工作流添加无损检测委托单信息", notes = "工作流添加无损检测委托单信息" , httpMethod="POST")
@PostMapping(value = "/flow/add")
public Result<NondestructiveTestOrderTicket> addFromFlow(@RequestBody @Validate Map<String, Object> map) {
log.info("工作流添加无损检测委托单信息:{}", JSON.toJSONString(map));
String num = FlowUtil.getString(map, "num");
String projectName = FlowUtil.getString(map, "projectName");
String testPieceName = FlowUtil.getString(map, "testPieceName");
String pipelineNumber = FlowUtil.getString(map, "pipelineNumber");
Long commissioningUnit = FlowUtil.getPullDownLong(map, "commissioningUnit");
String weldingMethod = FlowUtil.getString(map, "weldingMethod");
String medium = FlowUtil.getString(map, "medium");
String grooveForm = FlowUtil.getString(map, "grooveForm");
String testingRatio = FlowUtil.getString(map, "testingRatio");
String temperature = FlowUtil.getString(map, "temperature");
String weldNumber = FlowUtil.getString(map, "weldNumber");
String testingStandard = FlowUtil.getString(map, "testingStandard");
String pressure = FlowUtil.getString(map, "pressure");
String testNumber = FlowUtil.getString(map, "testNumber");
String mainDescriptionAttachedPicture = FlowUtil.getString(map, "mainDescriptionAttachedPicture");
String testingReportAttachment = FlowUtil.getJSONString(map, "testingReportAttachment");
String projectSn = FlowUtil.getString(map, "projectSn");
String craterList = FlowUtil.getJSONString(map,"craterList");
Long deviceUnitId = FlowUtil.getPullDownLong(map, "deviceUnitId");
Long constructionUnit = FlowUtil.getPullDownLong(map, "constructionUnit");
Long qualityChargePersonSignature = FlowUtil.getPullDownLong(map, "qualityChargePersonSignature");
Long epcContractor = FlowUtil.getPullDownLong(map, "epcContractor");
Long professionalEngineerSignature = FlowUtil.getPullDownLong(map, "professionalEngineerSignature");
Long supervisingUnit = FlowUtil.getPullDownLong(map, "supervisingUnit");
Long supervisingEngineerSignature = FlowUtil.getPullDownLong(map, "supervisingEngineerSignature");
Long testingUnit = FlowUtil.getPullDownLong(map, "testingUnit");
Long testingUnitChargePersonSignature = FlowUtil.getPullDownLong(map, "testingUnitChargePersonSignature");
Integer testingMethod = FlowUtil.getPullDownInteger(map, "testingMethod");
Integer qualifiedLevel = FlowUtil.getPullDownInteger(map, "qualifiedLevel");
Date testingDate = FlowUtil.getDate(map, "testingDate");
Date qualityChargePersonSignatureDate = FlowUtil.getDate(map, "qualityChargePersonSignatureDate");
Date professionalEngineerSignatureDate = FlowUtil.getDate(map, "professionalEngineerSignatureDate");
Date supervisingEngineerSignatureDate = FlowUtil.getDate(map, "supervisingEngineerSignatureDate");
Date testingUnitChargePersonSignatureDate = FlowUtil.getDate(map, "testingUnitChargePersonSignatureDate");
NondestructiveTestOrderTicket ticket = new NondestructiveTestOrderTicket();
ticket.setNum(num);
ticket.setProjectName(projectName);
ticket.setDeviceUnitId(deviceUnitId);
ticket.setTestPieceName(testPieceName);
ticket.setPipelineNumber(pipelineNumber);
ticket.setCommissioningUnit(commissioningUnit);
ticket.setWeldingMethod(weldingMethod);
ticket.setMedium(medium);
ticket.setGrooveForm(grooveForm);
ticket.setTestingRatio(testingRatio);
ticket.setTestingMethod(testingMethod);
ticket.setTemperature(temperature);
ticket.setWeldNumber(weldNumber);
ticket.setQualifiedLevel(qualifiedLevel);
ticket.setTestingStandard(testingStandard);
ticket.setPressure(pressure);
ticket.setTestNumber(testNumber);
ticket.setTestingDate(testingDate);
ticket.setCraterList(craterList);
ticket.setMainDescriptionAttachedPicture(mainDescriptionAttachedPicture);
ticket.setTestingReportAttachment(testingReportAttachment);
ticket.setConstructionUnit(constructionUnit);
ticket.setQualityChargePersonSignature(qualityChargePersonSignature);
ticket.setQualityChargePersonSignatureDate(qualityChargePersonSignatureDate);
ticket.setEpcContractor(epcContractor);
ticket.setProfessionalEngineerSignature(professionalEngineerSignature);
ticket.setProfessionalEngineerSignatureDate(professionalEngineerSignatureDate);
ticket.setSupervisingUnit(supervisingUnit);
ticket.setSupervisingEngineerSignature(supervisingEngineerSignature);
ticket.setSupervisingEngineerSignatureDate(supervisingEngineerSignatureDate);
ticket.setTestingUnit(testingUnit);
ticket.setTestingUnitChargePersonSignature(testingUnitChargePersonSignature);
ticket.setTestingUnitChargePersonSignatureDate(testingUnitChargePersonSignatureDate);
ticket.setProjectSn(projectSn);
nondestructiveTestOrderTicketService.add(ticket);
return Result.ok();
}
/**
* 编辑
* @param nondestructiveTestOrderTicket
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "编辑", operDesc = "编辑无损检测委托单信息")
@ApiOperation(value = "编辑无损检测委托单信息", notes = "编辑无损检测委托单信息" , httpMethod="POST")
@PostMapping(value = "/edit")
public Result<NondestructiveTestOrderTicket> edit(@RequestBody NondestructiveTestOrderTicket nondestructiveTestOrderTicket) {
nondestructiveTestOrderTicketService.edit(nondestructiveTestOrderTicket);
return Result.ok();
}
/**
* 通过id删除
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "删除", operDesc = "删除无损检测委托单信息")
@ApiOperation(value = "删除无损检测委托单信息", notes = "删除无损检测委托单信息" , httpMethod="POST")
@ApiImplicitParam(name = "id", value = "无损检测委托单ID", paramType = "body", required = true, dataType = "String", example = "{\"id\":\"1\"}")
@PostMapping(value = "/delete")
public Result<NondestructiveTestOrderTicket> delete(@ApiIgnore @RequestBody HashMap<String ,Object> map) {
nondestructiveTestOrderTicketService.delete(MapUtils.getString(map, "id"));
@ApiOperation(value = "添加无损检测委托单信息", notes = "添加无损检测委托单信息", httpMethod = "POST")
@PostMapping(value = "/add")
public Result<NondestructiveTestOrderTicket> add(@RequestBody @Validate NondestructiveTestOrderTicket nondestructiveTestOrderTicket) {
nondestructiveTestOrderTicketService.add(nondestructiveTestOrderTicket);
return Result.ok();
}
}
/**
* 通过id查询
* @param id
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "添加", operDesc = "工作流添加无损检测委托单信息")
@ApiOperation(value = "工作流添加无损检测委托单信息", notes = "工作流添加无损检测委托单信息", httpMethod = "POST")
@PostMapping(value = "/flow/add")
public Result<NondestructiveTestOrderTicket> addFromFlow(@RequestBody @Validate Map<String, Object> map) {
log.info("工作流添加无损检测委托单信息:{}", JSON.toJSONString(map));
String num = FlowUtil.getString(map, "num");
String projectName = FlowUtil.getString(map, "projectName");
String testPieceName = FlowUtil.getString(map, "testPieceName");
Long pipelineInformationId = FlowUtil.getPullDownLong(map, "pipelineInformationId");
Long commissioningUnit = FlowUtil.getPullDownLong(map, "commissioningUnit");
String weldingMethod = FlowUtil.getString(map, "weldingMethod");
String medium = FlowUtil.getString(map, "medium");
String grooveForm = FlowUtil.getString(map, "grooveForm");
String testingRatio = FlowUtil.getString(map, "testingRatio");
String temperature = FlowUtil.getString(map, "temperature");
String weldNumber = FlowUtil.getString(map, "weldNumber");
String testingStandard = FlowUtil.getString(map, "testingStandard");
String pressure = FlowUtil.getString(map, "pressure");
String testNumber = FlowUtil.getString(map, "testNumber");
String mainDescriptionAttachedPicture = FlowUtil.getString(map, "mainDescriptionAttachedPicture");
String testingReportAttachment = FlowUtil.getJSONString(map, "testingReportAttachment");
String projectSn = FlowUtil.getString(map, "projectSn");
String craterList = FlowUtil.getJSONString(map, "craterList");
Long deviceUnitId = FlowUtil.getPullDownLong(map, "deviceUnitId");
Long constructionUnit = FlowUtil.getPullDownLong(map, "constructionUnit");
Long qualityChargePersonSignature = FlowUtil.getPullDownLong(map, "qualityChargePersonSignature");
Long epcContractor = FlowUtil.getPullDownLong(map, "epcContractor");
Long professionalEngineerSignature = FlowUtil.getPullDownLong(map, "professionalEngineerSignature");
Long supervisingUnit = FlowUtil.getPullDownLong(map, "supervisingUnit");
Long supervisingEngineerSignature = FlowUtil.getPullDownLong(map, "supervisingEngineerSignature");
Long testingUnit = FlowUtil.getPullDownLong(map, "testingUnit");
Long testingUnitChargePersonSignature = FlowUtil.getPullDownLong(map, "testingUnitChargePersonSignature");
Integer testingMethod = FlowUtil.getPullDownInteger(map, "testingMethod");
Integer qualifiedLevel = FlowUtil.getPullDownInteger(map, "qualifiedLevel");
Date testingDate = FlowUtil.getDate(map, "testingDate");
Date qualityChargePersonSignatureDate = FlowUtil.getDate(map, "qualityChargePersonSignatureDate");
Date professionalEngineerSignatureDate = FlowUtil.getDate(map, "professionalEngineerSignatureDate");
Date supervisingEngineerSignatureDate = FlowUtil.getDate(map, "supervisingEngineerSignatureDate");
Date testingUnitChargePersonSignatureDate = FlowUtil.getDate(map, "testingUnitChargePersonSignatureDate");
List<PipelineWeldingRecord> records = new ArrayList<>();
Object craterList1 = map.get("craterList");
if (craterList1 instanceof List) {
List cl = (List) craterList1;
if (CollUtil.isNotEmpty(cl)) {
for (Object o : cl) {
Map m = (Map) o;
Long id = FlowUtil.getPullDownLong(m, "field5496713710010");
Integer qualified = FlowUtil.getPullDownInteger(m, "field8817951200764");
PipelineWeldingRecord weldingRecord = new PipelineWeldingRecord();
weldingRecord.setId(id);
weldingRecord.setTestingQualified(Objects.equals(qualified, 1) ? 1 : 0);
records.add(weldingRecord);
}
}
}
NondestructiveTestOrderTicket ticket = new NondestructiveTestOrderTicket();
ticket.setNum(num);
ticket.setProjectName(projectName);
ticket.setDeviceUnitId(deviceUnitId);
ticket.setTestPieceName(testPieceName);
ticket.setPipelineInformationId(pipelineInformationId);
ticket.setCommissioningUnit(commissioningUnit);
ticket.setWeldingMethod(weldingMethod);
ticket.setMedium(medium);
ticket.setGrooveForm(grooveForm);
ticket.setTestingRatio(testingRatio);
ticket.setTestingMethod(testingMethod);
ticket.setTemperature(temperature);
ticket.setWeldNumber(weldNumber);
ticket.setQualifiedLevel(qualifiedLevel);
ticket.setTestingStandard(testingStandard);
ticket.setPressure(pressure);
ticket.setTestNumber(testNumber);
ticket.setTestingDate(testingDate);
ticket.setCraterList(craterList);
ticket.setMainDescriptionAttachedPicture(mainDescriptionAttachedPicture);
ticket.setTestingReportAttachment(testingReportAttachment);
ticket.setConstructionUnit(constructionUnit);
ticket.setQualityChargePersonSignature(qualityChargePersonSignature);
ticket.setQualityChargePersonSignatureDate(qualityChargePersonSignatureDate);
ticket.setEpcContractor(epcContractor);
ticket.setProfessionalEngineerSignature(professionalEngineerSignature);
ticket.setProfessionalEngineerSignatureDate(professionalEngineerSignatureDate);
ticket.setSupervisingUnit(supervisingUnit);
ticket.setSupervisingEngineerSignature(supervisingEngineerSignature);
ticket.setSupervisingEngineerSignatureDate(supervisingEngineerSignatureDate);
ticket.setTestingUnit(testingUnit);
ticket.setTestingUnitChargePersonSignature(testingUnitChargePersonSignature);
ticket.setTestingUnitChargePersonSignatureDate(testingUnitChargePersonSignatureDate);
ticket.setProjectSn(projectSn);
nondestructiveTestOrderTicketService.add(ticket);
if (CollUtil.isNotEmpty(records)) {
for (PipelineWeldingRecord record : records) {
pipelineWeldingRecordService.updateById(record);
}
}
return Result.ok();
}
/**
* 编辑
*
* @param nondestructiveTestOrderTicket
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "编辑", operDesc = "编辑无损检测委托单信息")
@ApiOperation(value = "编辑无损检测委托单信息", notes = "编辑无损检测委托单信息", httpMethod = "POST")
@PostMapping(value = "/edit")
public Result<NondestructiveTestOrderTicket> edit(@RequestBody NondestructiveTestOrderTicket nondestructiveTestOrderTicket) {
nondestructiveTestOrderTicketService.edit(nondestructiveTestOrderTicket);
return Result.ok();
}
/**
* 通过id删除
*
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "删除", operDesc = "删除无损检测委托单信息")
@ApiOperation(value = "删除无损检测委托单信息", notes = "删除无损检测委托单信息", httpMethod = "POST")
@ApiImplicitParam(name = "id", value = "无损检测委托单ID", paramType = "body", required = true, dataType = "String", example = "{\"id\":\"1\"}")
@PostMapping(value = "/delete")
public Result<NondestructiveTestOrderTicket> delete(@ApiIgnore @RequestBody HashMap<String, Object> map) {
nondestructiveTestOrderTicketService.delete(MapUtils.getString(map, "id"));
return Result.ok();
}
/**
* 通过id查询
*
* @param id
* @return
*/
@OperLog(operModul = "无损检测委托单管理", operType = "通过id查询", operDesc = "通过id查询无损检测委托单信息")
@ApiOperation(value = "通过id查询无损检测委托单信息", notes = "通过id查询无损检测委托单信息" , httpMethod="GET")
@ApiImplicitParam(name = "id", value = "无损检测委托单ID", paramType = "query", required = true, dataType = "Integer")
@GetMapping(value = "/queryById")
public Result<NondestructiveTestOrderTicket> queryById(@RequestParam(name="id",required=true) String id) {
return Result.success(nondestructiveTestOrderTicketService.queryById(id));
}
@ApiOperation(value = "通过id查询无损检测委托单信息", notes = "通过id查询无损检测委托单信息", httpMethod = "GET")
@ApiImplicitParam(name = "id", value = "无损检测委托单ID", paramType = "query", required = true, dataType = "Integer")
@GetMapping(value = "/queryById")
public Result<NondestructiveTestOrderTicket> queryById(@RequestParam(name = "id", required = true) String id) {
return Result.success(nondestructiveTestOrderTicketService.queryById(id));
}
}

153
src/main/java/com/zhgd/xmgl/modules/baotou/controller/PipelineMaterialInspectionController.java Normal file
View File

@ -0,0 +1,153 @@
package com.zhgd.xmgl.modules.baotou.controller;
import java.util.Date;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.zhgd.annotation.OperLog;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialInspection;
import com.zhgd.xmgl.modules.baotou.service.IPipelineMaterialInspectionService;
import com.zhgd.xmgl.util.FlowUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.intellij.lang.annotations.Flow;
import org.simpleframework.xml.core.Validate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @Title: Controller
* @Description: 管道材料报验
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@RestController
@RequestMapping("/xmgl/pipelineMaterialInspection")
@Slf4j
@Api(tags = "管道材料报验相关Api")
public class PipelineMaterialInspectionController {
@Autowired
private IPipelineMaterialInspectionService pipelineMaterialInspectionService;
/**
* 分页列表查询
*
* @return
*/
@OperLog(operModul = "管道材料报验管理", operType = "分页查询", operDesc = "分页列表查询管道材料报验信息")
@ApiOperation(value = "分页列表查询管道材料报验信息", notes = "分页列表查询管道材料报验信息", httpMethod = "GET")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNo", value = "第几页", paramType = "query", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示条数", paramType = "query", required = true, dataType = "Integer"),
})
@GetMapping(value = "/page")
public Result<IPage<PipelineMaterialInspection>> queryPageList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineMaterialInspectionService.queryPageList(param));
}
/**
* 列表查询
*
* @return
*/
@OperLog(operModul = "管道材料报验管理", operType = "列表查询", operDesc = "列表查询管道材料报验信息")
@ApiOperation(value = "列表查询管道材料报验信息", notes = "列表查询管道材料报验信息", httpMethod = "GET")
@GetMapping(value = "/list")
public Result<List<PipelineMaterialInspection>> queryList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineMaterialInspectionService.queryList(param));
}
/**
* 添加
*
* @param pipelineMaterialInspection
* @return
*/
@OperLog(operModul = "管道材料报验管理", operType = "添加", operDesc = "添加管道材料报验信息")
@ApiOperation(value = "添加管道材料报验信息", notes = "添加管道材料报验信息", httpMethod = "POST")
@PostMapping(value = "/add")
public Result<PipelineMaterialInspection> add(@RequestBody @Validate PipelineMaterialInspection pipelineMaterialInspection) {
pipelineMaterialInspectionService.add(pipelineMaterialInspection);
return Result.ok();
}
@OperLog(operModul = "管道材料报验管理", operType = "添加", operDesc = "工作流添加管道材料报验信息")
@ApiOperation(value = "工作流添加管道材料报验信息", notes = "工作流添加管道材料报验信息", httpMethod = "POST")
@PostMapping(value = "/flow/add")
public Result addFromFlow(@RequestBody @Validate Map<String, Object> param) {
log.info("工作流添加管道材料报验信息:{}", JSON.toJSONString(param));
Long deviceUnitId = FlowUtil.getPullDownLong(param, "deviceUnitId");
Long projectGroupId = FlowUtil.getPullDownLong(param, "projectGroupId");
Long supervisingUnitId = FlowUtil.getPullDownLong(param, "supervisingUnitId");
Long epcContractorId = FlowUtil.getPullDownLong(param, "epcContractorId");
Long constructionUnitId = FlowUtil.getPullDownLong(param, "constructionUnitId");
String attachment = FlowUtil.getJSONString(param, "attachment");
String materialType = FlowUtil.getPullDownManyStr(param, "materialType");
String projectSn = FlowUtil.getString(param, "projectSn");
PipelineMaterialInspection inspection = new PipelineMaterialInspection();
inspection.setDeviceUnitId(deviceUnitId);
inspection.setProjectGroupId(projectGroupId);
inspection.setSupervisingUnitId(supervisingUnitId);
inspection.setEpcContractorId(epcContractorId);
inspection.setConstructionUnitId(constructionUnitId);
inspection.setMaterialType(materialType);
inspection.setAttachment(attachment);
inspection.setProjectSn(projectSn);
pipelineMaterialInspectionService.add(inspection);
return Result.ok();
}
/**
* 编辑
*
* @param pipelineMaterialInspection
* @return
*/
@OperLog(operModul = "管道材料报验管理", operType = "编辑", operDesc = "编辑管道材料报验信息")
@ApiOperation(value = "编辑管道材料报验信息", notes = "编辑管道材料报验信息", httpMethod = "POST")
@PostMapping(value = "/edit")
public Result<PipelineMaterialInspection> edit(@RequestBody PipelineMaterialInspection pipelineMaterialInspection) {
pipelineMaterialInspectionService.edit(pipelineMaterialInspection);
return Result.ok();
}
/**
* 通过id删除
*
* @return
*/
@OperLog(operModul = "管道材料报验管理", operType = "删除", operDesc = "删除管道材料报验信息")
@ApiOperation(value = "删除管道材料报验信息", notes = "删除管道材料报验信息", httpMethod = "POST")
@ApiImplicitParam(name = "id", value = "管道材料报验ID", paramType = "body", required = true, dataType = "String", example = "{\"id\":\"1\"}")
@PostMapping(value = "/delete")
public Result<PipelineMaterialInspection> delete(@ApiIgnore @RequestBody HashMap<String, Object> map) {
pipelineMaterialInspectionService.delete(MapUtils.getString(map, "id"));
return Result.ok();
}
/**
* 通过id查询
*
* @param id
* @return
*/
@OperLog(operModul = "管道材料报验管理", operType = "通过id查询", operDesc = "通过id查询管道材料报验信息")
@ApiOperation(value = "通过id查询管道材料报验信息", notes = "通过id查询管道材料报验信息", httpMethod = "GET")
@ApiImplicitParam(name = "id", value = "管道材料报验ID", paramType = "query", required = true, dataType = "Integer")
@GetMapping(value = "/queryById")
public Result<PipelineMaterialInspection> queryById(@RequestParam(name = "id", required = true) String id) {
return Result.success(pipelineMaterialInspectionService.queryById(id));
}
}

139
src/main/java/com/zhgd/xmgl/modules/baotou/controller/PipelineMaterialManagementController.java
View File

@ -1,139 +0,0 @@
package com.zhgd.xmgl.modules.baotou.controller;
import com.alibaba.fastjson.JSONObject;
import com.zhgd.annotation.OperLog;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiImplicitParams;
import java.util.HashMap;
import springfox.documentation.annotations.ApiIgnore;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.jeecg.common.util.oConvertUtils;
import org.apache.commons.collections.MapUtils;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialManagement;
import com.zhgd.xmgl.modules.baotou.service.IPipelineMaterialManagementService;
import org.simpleframework.xml.core.Validate;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
/**
* @Title: Controller
* @Description: 管道的材料管理
* @author： pds
* @date： 2024-09-03
* @version： V1.0
*/
@RestController
@RequestMapping("/xmgl/pipelineMaterialManagement")
@Slf4j
@Api(tags = "管道的材料管理相关Api")
public class PipelineMaterialManagementController {
@Autowired
private IPipelineMaterialManagementService pipelineMaterialManagementService;
/**
* 分页列表查询
* @return
*/
@OperLog(operModul = "管道的材料管理管理", operType = "分页查询", operDesc = "分页列表查询管道的材料管理信息")
@ApiOperation(value = "分页列表查询管道的材料管理信息", notes = "分页列表查询管道的材料管理信息", httpMethod="GET")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNo", value = "第几页", paramType = "query", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示条数", paramType = "query", required = true, dataType = "Integer"),
})
@GetMapping(value = "/page")
public Result<IPage<PipelineMaterialManagement>> queryPageList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineMaterialManagementService.queryPageList(param));
}
/**
* 列表查询
* @return
*/
@OperLog(operModul = "管道的材料管理管理", operType = "列表查询", operDesc = "列表查询管道的材料管理信息")
@ApiOperation(value = "列表查询管道的材料管理信息", notes = "列表查询管道的材料管理信息", httpMethod="GET")
@GetMapping(value = "/list")
public Result<List<PipelineMaterialManagement>> queryList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineMaterialManagementService.queryList(param));
}
/**
* 添加
* @param pipelineMaterialManagement
* @return
*/
@OperLog(operModul = "管道的材料管理管理", operType = "添加", operDesc = "添加管道的材料管理信息")
@ApiOperation(value = "添加管道的材料管理信息", notes = "添加管道的材料管理信息" , httpMethod="POST")
@PostMapping(value = "/add")
public Result<PipelineMaterialManagement> add(@RequestBody @Validate PipelineMaterialManagement pipelineMaterialManagement) {
pipelineMaterialManagementService.add(pipelineMaterialManagement);
return Result.ok();
}
/**
* 编辑
* @param pipelineMaterialManagement
* @return
*/
@OperLog(operModul = "管道的材料管理管理", operType = "编辑", operDesc = "编辑管道的材料管理信息")
@ApiOperation(value = "编辑管道的材料管理信息", notes = "编辑管道的材料管理信息" , httpMethod="POST")
@PostMapping(value = "/edit")
public Result<PipelineMaterialManagement> edit(@RequestBody PipelineMaterialManagement pipelineMaterialManagement) {
pipelineMaterialManagementService.edit(pipelineMaterialManagement);
return Result.ok();
}
/**
* 通过id删除
* @return
*/
@OperLog(operModul = "管道的材料管理管理", operType = "删除", operDesc = "删除管道的材料管理信息")
@ApiOperation(value = "删除管道的材料管理信息", notes = "删除管道的材料管理信息" , httpMethod="POST")
@ApiImplicitParam(name = "id", value = "管道的材料管理ID", paramType = "body", required = true, dataType = "String", example = "{\"id\":\"1\"}")
@PostMapping(value = "/delete")
public Result<PipelineMaterialManagement> delete(@ApiIgnore @RequestBody HashMap<String ,Object> map) {
pipelineMaterialManagementService.delete(MapUtils.getString(map, "id"));
return Result.ok();
}
/**
* 通过id查询
* @param id
* @return
*/
@OperLog(operModul = "管道的材料管理管理", operType = "通过id查询", operDesc = "通过id查询管道的材料管理信息")
@ApiOperation(value = "通过id查询管道的材料管理信息", notes = "通过id查询管道的材料管理信息" , httpMethod="GET")
@ApiImplicitParam(name = "id", value = "管道的材料管理ID", paramType = "query", required = true, dataType = "Integer")
@GetMapping(value = "/queryById")
public Result<PipelineMaterialManagement> queryById(@RequestParam(name="id",required=true) String id) {
return Result.success(pipelineMaterialManagementService.queryById(id));
}
}

168
src/main/java/com/zhgd/xmgl/modules/baotou/controller/PipelinePressureTestBagController.java Normal file
View File

@ -0,0 +1,168 @@
package com.zhgd.xmgl.modules.baotou.controller;
import java.util.Date;
import com.alibaba.fastjson.JSONObject;
import com.zhgd.annotation.OperLog;
import com.zhgd.xmgl.util.FlowUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiImplicitParams;
import java.util.HashMap;
import springfox.documentation.annotations.ApiIgnore;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.jeecg.common.util.oConvertUtils;
import org.apache.commons.collections.MapUtils;
import com.zhgd.xmgl.modules.baotou.entity.PipelinePressureTestBag;
import com.zhgd.xmgl.modules.baotou.service.IPipelinePressureTestBagService;
import org.simpleframework.xml.core.Validate;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
/**
* @Title: Controller
* @Description: 管道试压包
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@RestController
@RequestMapping("/xmgl/pipelinePressureTestBag")
@Slf4j
@Api(tags = "管道试压包相关Api")
public class PipelinePressureTestBagController {
@Autowired
private IPipelinePressureTestBagService pipelinePressureTestBagService;
/**
* 分页列表查询
* @return
*/
@OperLog(operModul = "管道试压包管理", operType = "分页查询", operDesc = "分页列表查询管道试压包信息")
@ApiOperation(value = "分页列表查询管道试压包信息", notes = "分页列表查询管道试压包信息", httpMethod="GET")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNo", value = "第几页", paramType = "query", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示条数", paramType = "query", required = true, dataType = "Integer"),
})
@GetMapping(value = "/page")
public Result<IPage<PipelinePressureTestBag>> queryPageList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelinePressureTestBagService.queryPageList(param));
}
/**
* 列表查询
* @return
*/
@OperLog(operModul = "管道试压包管理", operType = "列表查询", operDesc = "列表查询管道试压包信息")
@ApiOperation(value = "列表查询管道试压包信息", notes = "列表查询管道试压包信息", httpMethod="GET")
@GetMapping(value = "/list")
public Result<List<PipelinePressureTestBag>> queryList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelinePressureTestBagService.queryList(param));
}
/**
* 添加
* @param pipelinePressureTestBag
* @return
*/
@OperLog(operModul = "管道试压包管理", operType = "添加", operDesc = "添加管道试压包信息")
@ApiOperation(value = "添加管道试压包信息", notes = "添加管道试压包信息" , httpMethod="POST")
@PostMapping(value = "/add")
public Result<PipelinePressureTestBag> add(@RequestBody @Validate PipelinePressureTestBag pipelinePressureTestBag) {
pipelinePressureTestBagService.add(pipelinePressureTestBag);
return Result.ok();
}
@OperLog(operModul = "管道试压包管理", operType = "添加", operDesc = "工作流添加管道试压包信息")
@ApiOperation(value = "工作流添加管道试压包信息", notes = "工作流添加管道试压包信息" , httpMethod="POST")
@PostMapping(value = "/flow/add")
public Result addFromFlow(@RequestBody @Validate Map<String, Object> param) {
log.info("工作流添加管道试压包信息:{}", JSON.toJSONString(param));
Long deviceUnitId = FlowUtil.getPullDownLong(param, "deviceUnitId");
String pipelineInformationIds = FlowUtil.getPullDownManyStr(param, "pipelineInformationIds");
String testPressurePackageName = FlowUtil.getString(param, "testPressurePackageName");
String testPressurePackageNumber = FlowUtil.getString(param, "testPressurePackageNumber");
String testPressure = FlowUtil.getString(param, "testPressure");
String designPressure = FlowUtil.getString(param, "designPressure");
String attachment = FlowUtil.getJSONString(param, "attachment");
String projectSn = FlowUtil.getString(param, "projectSn");
Date pressureApplicationTime = FlowUtil.getDate(param, "pressureApplicationTime");
PipelinePressureTestBag bag = new PipelinePressureTestBag();
bag.setDeviceUnitId(deviceUnitId);
bag.setPipelineInformationIds(pipelineInformationIds);
bag.setTestPressurePackageName(testPressurePackageName);
bag.setTestPressurePackageNumber(testPressurePackageNumber);
bag.setTestPressure(testPressure);
bag.setDesignPressure(designPressure);
bag.setPressureApplicationTime(pressureApplicationTime);
bag.setAttachment(attachment);
bag.setProjectSn(projectSn);
pipelinePressureTestBagService.add(bag);
return Result.ok();
}
/**
* 编辑
* @param pipelinePressureTestBag
* @return
*/
@OperLog(operModul = "管道试压包管理", operType = "编辑", operDesc = "编辑管道试压包信息")
@ApiOperation(value = "编辑管道试压包信息", notes = "编辑管道试压包信息" , httpMethod="POST")
@PostMapping(value = "/edit")
public Result<PipelinePressureTestBag> edit(@RequestBody PipelinePressureTestBag pipelinePressureTestBag) {
pipelinePressureTestBagService.edit(pipelinePressureTestBag);
return Result.ok();
}
/**
* 通过id删除
* @return
*/
@OperLog(operModul = "管道试压包管理", operType = "删除", operDesc = "删除管道试压包信息")
@ApiOperation(value = "删除管道试压包信息", notes = "删除管道试压包信息" , httpMethod="POST")
@ApiImplicitParam(name = "id", value = "管道试压包ID", paramType = "body", required = true, dataType = "String", example = "{\"id\":\"1\"}")
@PostMapping(value = "/delete")
public Result<PipelinePressureTestBag> delete(@ApiIgnore @RequestBody HashMap<String ,Object> map) {
pipelinePressureTestBagService.delete(MapUtils.getString(map, "id"));
return Result.ok();
}
/**
* 通过id查询
* @param id
* @return
*/
@OperLog(operModul = "管道试压包管理", operType = "通过id查询", operDesc = "通过id查询管道试压包信息")
@ApiOperation(value = "通过id查询管道试压包信息", notes = "通过id查询管道试压包信息" , httpMethod="GET")
@ApiImplicitParam(name = "id", value = "管道试压包ID", paramType = "query", required = true, dataType = "Integer")
@GetMapping(value = "/queryById")
public Result<PipelinePressureTestBag> queryById(@RequestParam(name="id",required=true) String id) {
return Result.success(pipelinePressureTestBagService.queryById(id));
}
}

139
src/main/java/com/zhgd/xmgl/modules/baotou/controller/PipelineWelderController.java Normal file
View File

@ -0,0 +1,139 @@
package com.zhgd.xmgl.modules.baotou.controller;
import com.alibaba.fastjson.JSONObject;
import com.zhgd.annotation.OperLog;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiImplicitParams;
import java.util.HashMap;
import springfox.documentation.annotations.ApiIgnore;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.jeecg.common.util.oConvertUtils;
import org.apache.commons.collections.MapUtils;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWelder;
import com.zhgd.xmgl.modules.baotou.service.IPipelineWelderService;
import org.simpleframework.xml.core.Validate;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
/**
* @Title: Controller
* @Description: 管道焊工
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@RestController
@RequestMapping("/xmgl/pipelineWelder")
@Slf4j
@Api(tags = "管道焊工相关Api")
public class PipelineWelderController {
@Autowired
private IPipelineWelderService pipelineWelderService;
/**
* 分页列表查询
* @return
*/
@OperLog(operModul = "管道焊工管理", operType = "分页查询", operDesc = "分页列表查询管道焊工信息")
@ApiOperation(value = "分页列表查询管道焊工信息", notes = "分页列表查询管道焊工信息", httpMethod="GET")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNo", value = "第几页", paramType = "query", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示条数", paramType = "query", required = true, dataType = "Integer"),
})
@GetMapping(value = "/page")
public Result<IPage<PipelineWelder>> queryPageList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineWelderService.queryPageList(param));
}
/**
* 列表查询
* @return
*/
@OperLog(operModul = "管道焊工管理", operType = "列表查询", operDesc = "列表查询管道焊工信息")
@ApiOperation(value = "列表查询管道焊工信息", notes = "列表查询管道焊工信息", httpMethod="GET")
@GetMapping(value = "/list")
public Result<List<PipelineWelder>> queryList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineWelderService.queryList(param));
}
/**
* 添加
* @param pipelineWelder
* @return
*/
@OperLog(operModul = "管道焊工管理", operType = "添加", operDesc = "添加管道焊工信息")
@ApiOperation(value = "添加管道焊工信息", notes = "添加管道焊工信息" , httpMethod="POST")
@PostMapping(value = "/add")
public Result<PipelineWelder> add(@RequestBody @Validate PipelineWelder pipelineWelder) {
pipelineWelderService.add(pipelineWelder);
return Result.ok();
}
/**
* 编辑
* @param pipelineWelder
* @return
*/
@OperLog(operModul = "管道焊工管理", operType = "编辑", operDesc = "编辑管道焊工信息")
@ApiOperation(value = "编辑管道焊工信息", notes = "编辑管道焊工信息" , httpMethod="POST")
@PostMapping(value = "/edit")
public Result<PipelineWelder> edit(@RequestBody PipelineWelder pipelineWelder) {
pipelineWelderService.edit(pipelineWelder);
return Result.ok();
}
/**
* 通过id删除
* @return
*/
@OperLog(operModul = "管道焊工管理", operType = "删除", operDesc = "删除管道焊工信息")
@ApiOperation(value = "删除管道焊工信息", notes = "删除管道焊工信息" , httpMethod="POST")
@ApiImplicitParam(name = "id", value = "管道焊工ID", paramType = "body", required = true, dataType = "String", example = "{\"id\":\"1\"}")
@PostMapping(value = "/delete")
public Result<PipelineWelder> delete(@ApiIgnore @RequestBody HashMap<String ,Object> map) {
pipelineWelderService.delete(MapUtils.getString(map, "id"));
return Result.ok();
}
/**
* 通过id查询
* @param id
* @return
*/
@OperLog(operModul = "管道焊工管理", operType = "通过id查询", operDesc = "通过id查询管道焊工信息")
@ApiOperation(value = "通过id查询管道焊工信息", notes = "通过id查询管道焊工信息" , httpMethod="GET")
@ApiImplicitParam(name = "id", value = "管道焊工ID", paramType = "query", required = true, dataType = "Integer")
@GetMapping(value = "/queryById")
public Result<PipelineWelder> queryById(@RequestParam(name="id",required=true) String id) {
return Result.success(pipelineWelderService.queryById(id));
}
}

190
src/main/java/com/zhgd/xmgl/modules/baotou/controller/PipelineWeldingProcedureQualificationController.java Normal file
View File

@ -0,0 +1,190 @@
package com.zhgd.xmgl.modules.baotou.controller;
import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.zhgd.annotation.OperLog;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingProcedureQualification;
import com.zhgd.xmgl.modules.baotou.service.IPipelineWeldingProcedureQualificationService;
import com.zhgd.xmgl.util.FlowUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.simpleframework.xml.core.Validate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @Title: Controller
* @Description: 管道焊接工艺评定
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@RestController
@RequestMapping("/xmgl/pipelineWeldingProcedureQualification")
@Slf4j
@Api(tags = "管道焊接工艺评定相关Api")
public class PipelineWeldingProcedureQualificationController {
@Autowired
private IPipelineWeldingProcedureQualificationService pipelineWeldingProcedureQualificationService;
/**
* 分页列表查询
*
* @return
*/
@OperLog(operModul = "管道焊接工艺评定管理", operType = "分页查询", operDesc = "分页列表查询管道焊接工艺评定信息")
@ApiOperation(value = "分页列表查询管道焊接工艺评定信息", notes = "分页列表查询管道焊接工艺评定信息", httpMethod = "GET")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNo", value = "第几页", paramType = "query", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示条数", paramType = "query", required = true, dataType = "Integer"),
})
@GetMapping(value = "/page")
public Result<IPage<PipelineWeldingProcedureQualification>> queryPageList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineWeldingProcedureQualificationService.queryPageList(param));
}
/**
* 列表查询
*
* @return
*/
@OperLog(operModul = "管道焊接工艺评定管理", operType = "列表查询", operDesc = "列表查询管道焊接工艺评定信息")
@ApiOperation(value = "列表查询管道焊接工艺评定信息", notes = "列表查询管道焊接工艺评定信息", httpMethod = "GET")
@GetMapping(value = "/list")
public Result<List<PipelineWeldingProcedureQualification>> queryList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineWeldingProcedureQualificationService.queryList(param));
}
/**
* 添加
*
* @param pipelineWeldingProcedureQualification
* @return
*/
@OperLog(operModul = "管道焊接工艺评定管理", operType = "添加", operDesc = "添加管道焊接工艺评定信息")
@ApiOperation(value = "添加管道焊接工艺评定信息", notes = "添加管道焊接工艺评定信息", httpMethod = "POST")
@PostMapping(value = "/add")
public Result<PipelineWeldingProcedureQualification> add(@RequestBody @Validate PipelineWeldingProcedureQualification pipelineWeldingProcedureQualification) {
pipelineWeldingProcedureQualificationService.add(pipelineWeldingProcedureQualification);
return Result.ok();
}
@OperLog(operModul = "管道焊接工艺评定管理", operType = "添加", operDesc = "工作流添加管道焊接工艺评定信息")
@ApiOperation(value = "工作流添加管道焊接工艺评定信息", notes = "工作流添加管道焊接工艺评定信息", httpMethod = "POST")
@PostMapping(value = "/flow/add")
public Result addFromFlow(@RequestBody @Validate Map<String, Object> param) {
log.info("工作流添加管道焊接工艺评定信息:{}", JSON.toJSONString(param));
Long deviceUnitId = FlowUtil.getPullDownLong(param, "deviceUnitId");
Long projectGroupId = FlowUtil.getPullDownLong(param, "projectGroupId");
Long supervisingUnitId = FlowUtil.getPullDownLong(param, "supervisingUnitId");
Long epcContractorId = FlowUtil.getPullDownLong(param, "epcContractorId");
Long constructionUnitId = FlowUtil.getPullDownLong(param, "constructionUnitId");
String projectSn = FlowUtil.getString(param, "projectSn");
List<PipelineWeldingProcedureQualification> qualifications = new ArrayList<>();
Object detail = param.get("detail");
if (detail instanceof List) {
List details = (List) detail;
if (CollUtil.isNotEmpty(details)) {
for (Object o : details) {
PipelineWeldingProcedureQualification qualification = new PipelineWeldingProcedureQualification();
qualification.setDeviceUnitId(deviceUnitId);
qualification.setProjectGroupId(projectGroupId);
qualification.setSupervisingUnitId(supervisingUnitId);
qualification.setEpcContractorId(epcContractorId);
qualification.setConstructionUnitId(constructionUnitId);
qualification.setProjectSn(projectSn);
Map m = (Map) o;
String parentMaterial = FlowUtil.getString(m, "field6589810489310");
String maximumWallThickness = FlowUtil.getString(m, "field9141010496709");
String minimumWallThickness = FlowUtil.getString(m, "field4443810502760");
String weldingMethod = FlowUtil.getString(m, "field8897910507043");
String weldingMaterialRod = FlowUtil.getString(m, "field6409110512543");
String weldingMaterialWireFlux = FlowUtil.getString(m, "field4740410517143");
String weldingPosition = FlowUtil.getString(m, "field5473210520844");
String impactRequirement = FlowUtil.getString(m, "field3204110524193");
String heatTreatment = FlowUtil.getString(m, "field5723110527444");
String assessmentAttachment = FlowUtil.getJSONString(m, "field9594410775709");
String technologyProcessCardAttachment = FlowUtil.getJSONString(m, "field4024010784496");
// String assessmentAttachmentQrCode = FlowUtil.getString(m, "assessmentAttachmentQrCode");
// String technologyProcessCardAttachmentQrCode = FlowUtil.getString(m, "technologyProcessCardAttachmentQrCode");
String remark = FlowUtil.getString(m, "field6910010546472");
qualification.setParentMaterial(parentMaterial);
qualification.setMaximumWallThickness(maximumWallThickness);
qualification.setMinimumWallThickness(minimumWallThickness);
qualification.setWeldingMethod(weldingMethod);
qualification.setWeldingMaterialRod(weldingMaterialRod);
qualification.setWeldingMaterialWireFlux(weldingMaterialWireFlux);
qualification.setWeldingPosition(weldingPosition);
qualification.setImpactRequirement(impactRequirement);
qualification.setHeatTreatment(heatTreatment);
qualification.setAssessmentAttachment(assessmentAttachment);
qualification.setTechnologyProcessCardAttachment(technologyProcessCardAttachment);
// qualification.setAssessmentAttachmentQrCode(assessmentAttachmentQrCode);
// qualification.setTechnologyProcessCardAttachmentQrCode(technologyProcessCardAttachmentQrCode);
qualification.setRemark(remark);
qualifications.add(qualification);
}
}
}
for (PipelineWeldingProcedureQualification qualification : qualifications) {
pipelineWeldingProcedureQualificationService.add(qualification);
}
return Result.ok();
}
/**
* 编辑
*
* @param pipelineWeldingProcedureQualification
* @return
*/
@OperLog(operModul = "管道焊接工艺评定管理", operType = "编辑", operDesc = "编辑管道焊接工艺评定信息")
@ApiOperation(value = "编辑管道焊接工艺评定信息", notes = "编辑管道焊接工艺评定信息", httpMethod = "POST")
@PostMapping(value = "/edit")
public Result<PipelineWeldingProcedureQualification> edit(@RequestBody PipelineWeldingProcedureQualification pipelineWeldingProcedureQualification) {
pipelineWeldingProcedureQualificationService.edit(pipelineWeldingProcedureQualification);
return Result.ok();
}
/**
* 通过id删除
*
* @return
*/
@OperLog(operModul = "管道焊接工艺评定管理", operType = "删除", operDesc = "删除管道焊接工艺评定信息")
@ApiOperation(value = "删除管道焊接工艺评定信息", notes = "删除管道焊接工艺评定信息", httpMethod = "POST")
@ApiImplicitParam(name = "id", value = "管道焊接工艺评定ID", paramType = "body", required = true, dataType = "String", example = "{\"id\":\"1\"}")
@PostMapping(value = "/delete")
public Result<PipelineWeldingProcedureQualification> delete(@ApiIgnore @RequestBody HashMap<String, Object> map) {
pipelineWeldingProcedureQualificationService.delete(MapUtils.getString(map, "id"));
return Result.ok();
}
/**
* 通过id查询
*
* @param id
* @return
*/
@OperLog(operModul = "管道焊接工艺评定管理", operType = "通过id查询", operDesc = "通过id查询管道焊接工艺评定信息")
@ApiOperation(value = "通过id查询管道焊接工艺评定信息", notes = "通过id查询管道焊接工艺评定信息", httpMethod = "GET")
@ApiImplicitParam(name = "id", value = "管道焊接工艺评定ID", paramType = "query", required = true, dataType = "Integer")
@GetMapping(value = "/queryById")
public Result<PipelineWeldingProcedureQualification> queryById(@RequestParam(name = "id", required = true) String id) {
return Result.success(pipelineWeldingProcedureQualificationService.queryById(id));
}
}

187
src/main/java/com/zhgd/xmgl/modules/baotou/controller/PipelineWeldingRecordController.java Normal file
View File

@ -0,0 +1,187 @@
package com.zhgd.xmgl.modules.baotou.controller;
import java.util.Date;
import com.alibaba.fastjson.JSONObject;
import com.zhgd.annotation.OperLog;
import com.zhgd.xmgl.util.FlowUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiImplicitParams;
import java.util.HashMap;
import springfox.documentation.annotations.ApiIgnore;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.jeecg.common.util.oConvertUtils;
import org.apache.commons.collections.MapUtils;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingRecord;
import com.zhgd.xmgl.modules.baotou.service.IPipelineWeldingRecordService;
import org.simpleframework.xml.core.Validate;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.servlet.ModelAndView;
import com.alibaba.fastjson.JSON;
/**
* @Title: Controller
* @Description: 管道焊接记录
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@RestController
@RequestMapping("/xmgl/pipelineWeldingRecord")
@Slf4j
@Api(tags = "管道焊接记录相关Api")
public class PipelineWeldingRecordController {
@Autowired
private IPipelineWeldingRecordService pipelineWeldingRecordService;
/**
* 分页列表查询
* @return
*/
@OperLog(operModul = "管道焊接记录管理", operType = "分页查询", operDesc = "分页列表查询管道焊接记录信息")
@ApiOperation(value = "分页列表查询管道焊接记录信息", notes = "分页列表查询管道焊接记录信息", httpMethod="GET")
@ApiImplicitParams({
@ApiImplicitParam(name = "pageNo", value = "第几页", paramType = "query", required = true, dataType = "Integer"),
@ApiImplicitParam(name = "pageSize", value = "每页显示条数", paramType = "query", required = true, dataType = "Integer"),
})
@GetMapping(value = "/page")
public Result<IPage<PipelineWeldingRecord>> queryPageList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineWeldingRecordService.queryPageList(param));
}
/**
* 列表查询
* @return
*/
@OperLog(operModul = "管道焊接记录管理", operType = "列表查询", operDesc = "列表查询管道焊接记录信息")
@ApiOperation(value = "列表查询管道焊接记录信息", notes = "列表查询管道焊接记录信息", httpMethod="GET")
@GetMapping(value = "/list")
public Result<List<PipelineWeldingRecord>> queryList(@ApiIgnore @RequestParam HashMap<String, Object> param) {
return Result.success(pipelineWeldingRecordService.queryList(param));
}
/**
* 添加
* @param pipelineWeldingRecord
* @return
*/
@OperLog(operModul = "管道焊接记录管理", operType = "添加", operDesc = "添加管道焊接记录信息")
@ApiOperation(value = "添加管道焊接记录信息", notes = "添加管道焊接记录信息" , httpMethod="POST")
@PostMapping(value = "/add")
public Result<PipelineWeldingRecord> add(@RequestBody @Validate PipelineWeldingRecord pipelineWeldingRecord) {
pipelineWeldingRecordService.add(pipelineWeldingRecord);
return Result.ok();
}
@OperLog(operModul = "管道焊接记录管理", operType = "添加", operDesc = "工作流添加管道焊接记录信息")
@ApiOperation(value = "工作流添加管道焊接记录信息", notes = "工作流添加管道焊接记录信息" , httpMethod="POST")
@PostMapping(value = "/flow/add")
public Result addFromFlow(@RequestBody @Validate Map<String, Object> param) {
log.info("添加管道焊接记录信息:{}", JSON.toJSONString(param));
Long deviceUnitId = FlowUtil.getPullDownLong(param, "deviceUnitId");
Long pipelineInformationId = FlowUtil.getPullDownLong(param, "pipelineInformationId");
Long projectGroupId = FlowUtil.getPullDownLong(param, "projectGroupId");
Long supervisingUnitId = FlowUtil.getPullDownLong(param, "supervisingUnitId");
Long epcContractorId = FlowUtil.getPullDownLong(param, "epcContractorId");
Long constructionUnitId = FlowUtil.getPullDownLong(param, "constructionUnitId");
Long pipelineWeldingJointManagementId = FlowUtil.getPullDownLong(param, "pipelineWeldingJointManagementId");
Long pipelineWelderId = FlowUtil.getPullDownLong(param, "pipelineWelderId");
String specification = FlowUtil.getString(param, "specification");
String material = FlowUtil.getString(param, "material");
String weldingPosition = FlowUtil.getString(param, "weldingPosition");
String weldingMethod = FlowUtil.getString(param, "weldingMethod");
String weldingMaterialBrand = FlowUtil.getString(param, "weldingMaterialBrand");
String actualPreheatingTemperature = FlowUtil.getString(param, "actualPreheatingTemperature");
String weldingSurfaceQuality = FlowUtil.getString(param, "weldingSurfaceQuality");
String pipelineInternalConnectionInspection = FlowUtil.getString(param, "pipelineInternalConnectionInspection");
String projectSn = FlowUtil.getString(param, "projectSn");
Date weldingDate = FlowUtil.getDate(param, "weldingDate");
PipelineWeldingRecord record = new PipelineWeldingRecord();
record.setDeviceUnitId(deviceUnitId);
record.setPipelineInformationId(pipelineInformationId);
record.setProjectGroupId(projectGroupId);
record.setSupervisingUnitId(supervisingUnitId);
record.setEpcContractorId(epcContractorId);
record.setConstructionUnitId(constructionUnitId);
record.setPipelineWeldingJointManagementId(pipelineWeldingJointManagementId);
record.setPipelineWelderId(pipelineWelderId);
record.setSpecification(specification);
record.setMaterial(material);
record.setWeldingPosition(weldingPosition);
record.setWeldingMethod(weldingMethod);
record.setWeldingMaterialBrand(weldingMaterialBrand);
record.setActualPreheatingTemperature(actualPreheatingTemperature);
record.setWeldingDate(weldingDate);
record.setWeldingSurfaceQuality(weldingSurfaceQuality);
record.setPipelineInternalConnectionInspection(pipelineInternalConnectionInspection);
// record.setTestingQualified(0);
record.setProjectSn(projectSn);
pipelineWeldingRecordService.add(record);
return Result.ok();
}
/**
* 编辑
* @param pipelineWeldingRecord
* @return
*/
@OperLog(operModul = "管道焊接记录管理", operType = "编辑", operDesc = "编辑管道焊接记录信息")
@ApiOperation(value = "编辑管道焊接记录信息", notes = "编辑管道焊接记录信息" , httpMethod="POST")
@PostMapping(value = "/edit")
public Result<PipelineWeldingRecord> edit(@RequestBody PipelineWeldingRecord pipelineWeldingRecord) {
pipelineWeldingRecordService.edit(pipelineWeldingRecord);
return Result.ok();
}
/**
* 通过id删除
* @return
*/
@OperLog(operModul = "管道焊接记录管理", operType = "删除", operDesc = "删除管道焊接记录信息")
@ApiOperation(value = "删除管道焊接记录信息", notes = "删除管道焊接记录信息" , httpMethod="POST")
@ApiImplicitParam(name = "id", value = "管道焊接记录ID", paramType = "body", required = true, dataType = "String", example = "{\"id\":\"1\"}")
@PostMapping(value = "/delete")
public Result<PipelineWeldingRecord> delete(@ApiIgnore @RequestBody HashMap<String ,Object> map) {
pipelineWeldingRecordService.delete(MapUtils.getString(map, "id"));
return Result.ok();
}
/**
* 通过id查询
* @param id
* @return
*/
@OperLog(operModul = "管道焊接记录管理", operType = "通过id查询", operDesc = "通过id查询管道焊接记录信息")
@ApiOperation(value = "通过id查询管道焊接记录信息", notes = "通过id查询管道焊接记录信息" , httpMethod="GET")
@ApiImplicitParam(name = "id", value = "管道焊接记录ID", paramType = "query", required = true, dataType = "Integer")
@GetMapping(value = "/queryById")
public Result<PipelineWeldingRecord> queryById(@RequestParam(name="id",required=true) String id) {
return Result.success(pipelineWeldingRecordService.queryById(id));
}
}

3
src/main/java/com/zhgd/xmgl/modules/baotou/entity/DeviceUnit.java
View File

@ -57,6 +57,9 @@ public class DeviceUnit implements Serializable {
@ApiModelProperty(value="EPC承包商ids")
private java.lang.String epcContractorIds;
@TableField(exist = false)
@ApiModelProperty(value="监理单位ids")
private java.lang.String supervisingUnitIds;
/**监理单位名称*/
@TableField(exist = false)
@ApiModelProperty(value="监理单位名称")

10
src/main/java/com/zhgd/xmgl/modules/baotou/entity/NondestructiveTestOrderTicket.java
View File

@ -44,10 +44,8 @@ public class NondestructiveTestOrderTicket implements Serializable {
@Excel(name = "检件名称", width = 15)
@ApiModelProperty(value="检件名称")
private java.lang.String testPieceName ;
/**管线号*/
@Excel(name = "管线号", width = 15)
@ApiModelProperty(value="管线号")
private java.lang.String pipelineNumber ;
@ApiModelProperty(value="管道基本信息id")
private java.lang.Long pipelineInformationId ;
/**委托单位*/
@Excel(name = "委托单位", width = 15)
@ApiModelProperty(value="委托单位")
@ -215,4 +213,8 @@ public class NondestructiveTestOrderTicket implements Serializable {
@TableField(exist = false)
@ApiModelProperty(value="检测单位负责人签字名称")
private java.lang.String testingUnitChargePersonSignatureName ;
/**管线号*/
@TableField(exist = false)
@ApiModelProperty(value="管线号")
private java.lang.String pipelineNumber ;
}

64
src/main/java/com/zhgd/xmgl/modules/baotou/entity/PipelineInformation.java
View File

@ -6,7 +6,6 @@ import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.jeecgframework.poi.excel.annotation.Excel;
import java.io.Serializable;
@ -31,55 +30,16 @@ public class PipelineInformation implements Serializable {
/**
* 管线编号
*/
@Excel(name = "管线编号", width = 15)
@ApiModelProperty(value = "管线编号")
private java.lang.String pipelineNumber;
/**
* 管线壁厚
*/
@Excel(name = "管线壁厚", width = 15)
@ApiModelProperty(value = "管线壁厚")
private java.lang.String pipelineWallThickness;
/**
* 压力等级
*/
@Excel(name = "压力等级", width = 15)
@ApiModelProperty(value = "压力等级")
private java.lang.String pressureLevel;
/**
* 介质类型
*/
@Excel(name = "介质类型", width = 15)
@ApiModelProperty(value = "介质类型")
private java.lang.String mediaType;
/**
* 管道分级
*/
@Excel(name = "管道分级", width = 15)
@ApiModelProperty(value = "管道分级")
private java.lang.String pipelineClassification;
/**
* 材质类型
*/
@Excel(name = "材质类型", width = 15)
@ApiModelProperty(value = "材质类型")
private java.lang.String materialType;
/**
* 产品标准号
*/
@Excel(name = "产品标准号", width = 15)
@ApiModelProperty(value = "产品标准号")
private java.lang.String productStandardNumber;
/**
* 单线图
*/
@Excel(name = "单线图", width = 15)
@ApiModelProperty(value = "单线图")
private java.lang.String singleLineDiagram;
/**
* 所属项目SN
*/
@Excel(name = "所属项目SN", width = 15)
@ApiModelProperty(value = "所属项目SN")
private java.lang.String projectSn;
/**
@ -95,7 +55,29 @@ public class PipelineInformation implements Serializable {
/**
* 焊口点位
*/
@Excel(name = "焊口点位", width = 15)
@ApiModelProperty(value = "焊口点位")
private java.lang.String weldingPointPosition;
@ApiModelProperty(value = "装置管理id")
private java.lang.Long deviceUnitId;
/**
* 管线名称
*/
@ApiModelProperty(value = "管线名称")
private java.lang.String pipelineName;
/**
* 规格(mm)
*/
@ApiModelProperty(value = "规格(mm)")
private java.lang.String specification;
/**
* 材质
*/
@ApiModelProperty(value = "材质")
private java.lang.String material;
/**
* 检测比例
*/
@ApiModelProperty(value = "检测比例")
private java.lang.String detectionRatio;
}

80
src/main/java/com/zhgd/xmgl/modules/baotou/entity/PipelineMaterialInspection.java Normal file
View File

@ -0,0 +1,80 @@
package com.zhgd.xmgl.modules.baotou.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
/**
* @Description: 管道材料报验
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Data
@TableName("pipeline_material_inspection")
@ApiModel(value="PipelineMaterialInspection实体类",description="PipelineMaterialInspection")
public class PipelineMaterialInspection implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value="id")
private java.lang.Long id ;
/**装置管理id*/
@ApiModelProperty(value="装置管理id")
private java.lang.Long deviceUnitId ;
/**项目组id*/
@ApiModelProperty(value="项目组id")
private java.lang.Long projectGroupId ;
/**监理单位id*/
@ApiModelProperty(value="监理单位id")
private java.lang.Long supervisingUnitId ;
/**EPC承包商id*/
@ApiModelProperty(value="EPC承包商id")
private java.lang.Long epcContractorId ;
/**施工单位id*/
@ApiModelProperty(value="施工单位id")
private java.lang.Long constructionUnitId ;
/**材料类型（多个,分割）（1:管子;2:管件;3:阀门;4:法兰、法兰盖及翻边短节;5:紧固件;6:垫片;7:金属波纹管膨胀节;8:爆破片安全装置;9:阻火器;10:管道支承件;）*/
@ApiModelProperty(value="材料类型（多个,分割）（1:管子;2:管件;3:阀门;4:法兰、法兰盖及翻边短节;5:紧固件;6:垫片;7:金属波纹管膨胀节;8:爆破片安全装置;9:阻火器;10:管道支承件;）")
private java.lang.String materialType ;
/**附件*/
@ApiModelProperty(value="附件")
private java.lang.String attachment ;
/**所属项目SN*/
@ApiModelProperty(value="所属项目SN")
private java.lang.String projectSn ;
/**创建时间*/
@ApiModelProperty(value="创建时间")
private java.util.Date createDate ;
/**更新时间*/
@ApiModelProperty(value="更新时间")
private java.util.Date updateDate ;
@TableField(exist = false)
@ApiModelProperty(value="装置管理名称")
private java.lang.String deviceUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="项目组名称")
private java.lang.String projectGroupName ;
@TableField(exist = false)
@ApiModelProperty(value="监理单位名称")
private java.lang.String supervisingUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="EPC承包商名称")
private java.lang.String epcContractorName ;
@TableField(exist = false)
@ApiModelProperty(value="施工单位名称")
private java.lang.String constructionUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="材料类型名称（多个,分割）（1:管子;2:管件;3:阀门;4:法兰、法兰盖及翻边短节;5:紧固件;6:垫片;7:金属波纹管膨胀节;8:爆破片安全装置;9:阻火器;10:管道支承件;）")
private java.lang.String materialTypeName ;
}

64
src/main/java/com/zhgd/xmgl/modules/baotou/entity/PipelineMaterialManagement.java
View File

@ -1,64 +0,0 @@
package com.zhgd.xmgl.modules.baotou.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
/**
* @Description: 管道的材料管理
* @author： pds
* @date： 2024-09-03
* @version： V1.0
*/
@Data
@TableName("pipeline_material_management")
@ApiModel(value="PipelineMaterialManagement实体类",description="PipelineMaterialManagement")
public class PipelineMaterialManagement implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value="id")
private java.lang.Long id ;
/**管道基本信息id*/
@Excel(name = "管道基本信息id", width = 15)
@ApiModelProperty(value="管道基本信息id")
private java.lang.Long pipelineInformationId ;
/**材料类型：1:法兰;2:垫片;3:阀门;*/
@Excel(name = "材料类型：1:法兰;2:垫片;3:阀门;", width = 15)
@ApiModelProperty(value="材料类型：1:法兰;2:垫片;3:阀门;")
private java.lang.Integer materialType ;
/**钢的排号*/
@Excel(name = "钢的排号", width = 15)
@ApiModelProperty(value="钢的排号")
private java.lang.String steelNumber ;
/**材料管理*/
@Excel(name = "材料管理", width = 15)
@ApiModelProperty(value="材料管理")
private java.lang.String materialManagement ;
/**上传附件*/
@Excel(name = "上传附件", width = 15)
@ApiModelProperty(value="上传附件")
private java.lang.String uploadAttachment ;
/**阀内试验记录附件*/
@Excel(name = "阀内试验记录附件", width = 15)
@ApiModelProperty(value="阀内试验记录附件")
private java.lang.String internalTestRecordAttachment ;
/**所属项目SN*/
@Excel(name = "所属项目SN", width = 15)
@ApiModelProperty(value="所属项目SN")
private java.lang.String projectSn ;
/**创建时间*/
@ApiModelProperty(value="创建时间")
private java.util.Date createDate ;
/**更新时间*/
@ApiModelProperty(value="更新时间")
private java.util.Date updateDate ;
}

75
src/main/java/com/zhgd/xmgl/modules/baotou/entity/PipelinePressureTestBag.java Normal file
View File

@ -0,0 +1,75 @@
package com.zhgd.xmgl.modules.baotou.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
/**
* @Description: 管道试压包
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Data
@TableName("pipeline_pressure_test_bag")
@ApiModel(value="PipelinePressureTestBag实体类",description="PipelinePressureTestBag")
public class PipelinePressureTestBag implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value="id")
private java.lang.Long id ;
/**装置管理id*/
@ApiModelProperty(value="装置管理id")
private java.lang.Long deviceUnitId ;
/**管道基本信息ids*/
@ApiModelProperty(value="管道基本信息ids")
private java.lang.String pipelineInformationIds ;
/**试压包名称*/
@ApiModelProperty(value="试压包名称")
private java.lang.String testPressurePackageName ;
/**试压包编号*/
@ApiModelProperty(value="试压包编号")
private java.lang.String testPressurePackageNumber ;
/**试验压力*/
@ApiModelProperty(value="试验压力")
private java.lang.String testPressure ;
/**设计压力*/
@ApiModelProperty(value="设计压力")
private java.lang.String designPressure ;
/**试压时间*/
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value="试压时间")
private java.util.Date pressureApplicationTime ;
/**附件*/
@ApiModelProperty(value="附件")
private java.lang.String attachment ;
/**所属项目SN*/
@ApiModelProperty(value="所属项目SN")
private java.lang.String projectSn ;
/**创建时间*/
@ApiModelProperty(value="创建时间")
private java.util.Date createDate ;
/**更新时间*/
@ApiModelProperty(value="更新时间")
private java.util.Date updateDate ;
@TableField(exist = false)
@ApiModelProperty(value="装置管理名称")
private java.lang.String deviceUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="管道名称s")
private java.lang.String pipelineNames ;
@TableField(exist = false)
@ApiModelProperty(value="管道编号/单线号s")
private java.lang.String pipelineNumbers ;
}

73
src/main/java/com/zhgd/xmgl/modules/baotou/entity/PipelineWelder.java Normal file
View File

@ -0,0 +1,73 @@
package com.zhgd.xmgl.modules.baotou.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
/**
* @Description: 管道焊工
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Data
@TableName("pipeline_welder")
@ApiModel(value="PipelineWelder实体类",description="PipelineWelder")
public class PipelineWelder implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value="id")
private java.lang.Long id ;
/**装置管理id*/
@ApiModelProperty(value="装置管理id")
private java.lang.Long deviceUnitId ;
/**劳务人员id*/
@ApiModelProperty(value="劳务人员id")
private java.lang.Long workerId ;
/**焊工代号*/
@ApiModelProperty(value="焊工代号")
private java.lang.String welderCode ;
/**合格项目代号*/
@ApiModelProperty(value="合格项目代号")
private java.lang.String qualifiedProjectCode ;
/**有效期限*/
@ApiModelProperty(value="有效期限")
private java.lang.String validityPeriod ;
/**所属项目SN*/
@ApiModelProperty(value="所属项目SN")
private java.lang.String projectSn ;
/**创建时间*/
@ApiModelProperty(value="创建时间")
private java.util.Date createDate ;
/**更新时间*/
@ApiModelProperty(value="更新时间")
private java.util.Date updateDate ;
@ApiModelProperty(value="长期焊接合格率低告警（0正常1告警）")
private java.lang.Integer longTermLowWeldingPassRateAlarm ;
@TableField(exist = false)
@ApiModelProperty(value="装置管理名称")
private java.lang.String deviceUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="焊工姓名")
private java.lang.String welderName ;
@TableField(exist = false)
@ApiModelProperty(value="性别，1男，2女")
private java.lang.Integer sex ;
@TableField(exist = false)
@ApiModelProperty(value="焊工证号")
private java.lang.String welderCertificateNumber ;
@TableField(exist = false)
@ApiModelProperty(value="焊接合格率")
private java.lang.String weldingPassRate ;
}

42
src/main/java/com/zhgd/xmgl/modules/baotou/entity/PipelineWeldingJointManagement.java
View File

@ -32,44 +32,10 @@ public class PipelineWeldingJointManagement implements Serializable {
@Excel(name = "管道基本信息id", width = 15)
@ApiModelProperty(value="管道基本信息id")
private java.lang.Long pipelineInformationId ;
/**焊口名称*/
@Excel(name = "焊口名称", width = 15)
@ApiModelProperty(value="焊口名称")
private java.lang.String weldName ;
/**直径*/
@Excel(name = "直径", width = 15)
@ApiModelProperty(value="直径")
private java.lang.String diameter ;
/**壁厚*/
@Excel(name = "壁厚", width = 15)
@ApiModelProperty(value="壁厚")
private java.lang.String wallThickness ;
/**焊工*/
@Excel(name = "焊工", width = 15)
@ApiModelProperty(value="焊工")
private java.lang.String welder ;
/**检查人*/
@Excel(name = "检查人", width = 15)
@ApiModelProperty(value="检查人")
private java.lang.String inspector ;
/**日期*/
@Excel(name = "日期", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
@ApiModelProperty(value="日期")
private java.util.Date date ;
/**目测验收结果*/
@Excel(name = "目测验收结果", width = 15)
@ApiModelProperty(value="目测验收结果")
private java.lang.String visualInspectionAcceptanceResult ;
/**无损验收结果*/
@Excel(name = "无损验收结果", width = 15)
@ApiModelProperty(value="无损验收结果")
private java.lang.String nonDestructiveInspectionResult ;
/**无损检测结果附件*/
@Excel(name = "无损检测结果附件", width = 15)
@ApiModelProperty(value="无损检测结果附件")
private java.lang.String nonDestructiveInspectionResultAttachment ;
/**焊口编号*/
@Excel(name = "焊口编号", width = 15)
@ApiModelProperty(value="焊口编号")
private java.lang.String weldNumber ;
/**所属项目SN*/
@Excel(name = "所属项目SN", width = 15)
@ApiModelProperty(value="所属项目SN")

112
src/main/java/com/zhgd/xmgl/modules/baotou/entity/PipelineWeldingProcedureQualification.java Normal file
View File

@ -0,0 +1,112 @@
package com.zhgd.xmgl.modules.baotou.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
/**
* @Description: 管道焊接工艺评定
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Data
@TableName("pipeline_welding_procedure_qualification")
@ApiModel(value="PipelineWeldingProcedureQualification实体类",description="PipelineWeldingProcedureQualification")
public class PipelineWeldingProcedureQualification implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value="id")
private java.lang.Long id ;
/**装置管理id*/
@ApiModelProperty(value="装置管理id")
private java.lang.Long deviceUnitId ;
/**项目组id*/
@ApiModelProperty(value="项目组id")
private java.lang.Long projectGroupId ;
/**监理单位id*/
@ApiModelProperty(value="监理单位id")
private java.lang.Long supervisingUnitId ;
/**EPC承包商id*/
@ApiModelProperty(value="EPC承包商id")
private java.lang.Long epcContractorId ;
/**施工单位id*/
@ApiModelProperty(value="施工单位id")
private java.lang.Long constructionUnitId ;
/**母材*/
@ApiModelProperty(value="母材")
private java.lang.String parentMaterial ;
/**最大壁厚(mm)*/
@ApiModelProperty(value="最大壁厚(mm)")
private java.lang.String maximumWallThickness ;
/**最小壁厚(mm)*/
@ApiModelProperty(value="最小壁厚(mm)")
private java.lang.String minimumWallThickness ;
/**焊接方法*/
@ApiModelProperty(value="焊接方法")
private java.lang.String weldingMethod ;
/**焊接材料(焊条)*/
@ApiModelProperty(value="焊接材料(焊条)")
private java.lang.String weldingMaterialRod ;
/**焊接材料(焊丝/焊剂)*/
@ApiModelProperty(value="焊接材料(焊丝/焊剂)")
private java.lang.String weldingMaterialWireFlux ;
/**焊接位置*/
@ApiModelProperty(value="焊接位置")
private java.lang.String weldingPosition ;
/**冲击要求*/
@ApiModelProperty(value="冲击要求")
private java.lang.String impactRequirement ;
/**热处理*/
@ApiModelProperty(value="热处理")
private java.lang.String heatTreatment ;
/**焊接工艺评定附件*/
@ApiModelProperty(value="焊接工艺评定附件")
private java.lang.String assessmentAttachment ;
/**焊接技术交底工艺卡附件*/
@ApiModelProperty(value="焊接技术交底工艺卡附件")
private java.lang.String technologyProcessCardAttachment ;
/**焊接工艺评定附件二维码*/
@ApiModelProperty(value="焊接工艺评定附件二维码")
private java.lang.String assessmentAttachmentQrCode ;
/**焊接技术交底工艺卡附件二维码*/
@ApiModelProperty(value="焊接技术交底工艺卡附件二维码")
private java.lang.String technologyProcessCardAttachmentQrCode ;
/**备注*/
@ApiModelProperty(value="备注")
private java.lang.String remark ;
/**所属项目SN*/
@ApiModelProperty(value="所属项目SN")
private java.lang.String projectSn ;
/**创建时间*/
@ApiModelProperty(value="创建时间")
private java.util.Date createDate ;
/**更新时间*/
@ApiModelProperty(value="更新时间")
private java.util.Date updateDate ;
@TableField(exist = false)
@ApiModelProperty(value="装置管理名称")
private java.lang.String deviceUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="项目组名称")
private java.lang.String projectGroupName ;
@TableField(exist = false)
@ApiModelProperty(value="监理单位名称")
private java.lang.String supervisingUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="EPC承包商名称")
private java.lang.String epcContractorName ;
@TableField(exist = false)
@ApiModelProperty(value="施工单位名称")
private java.lang.String constructionUnitName ;
}

126
src/main/java/com/zhgd/xmgl/modules/baotou/entity/PipelineWeldingRecord.java Normal file
View File

@ -0,0 +1,126 @@
package com.zhgd.xmgl.modules.baotou.entity;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.springframework.format.annotation.DateTimeFormat;
import org.jeecgframework.poi.excel.annotation.Excel;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
/**
* @Description: 管道焊接记录
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Data
@TableName("pipeline_welding_record")
@ApiModel(value="PipelineWeldingRecord实体类",description="PipelineWeldingRecord")
public class PipelineWeldingRecord implements Serializable {
private static final long serialVersionUID = 1L;
/**id*/
@TableId(type = IdType.ASSIGN_ID)
@ApiModelProperty(value="id")
private java.lang.Long id ;
/**装置管理id*/
@ApiModelProperty(value="装置管理id")
private java.lang.Long deviceUnitId ;
/**管道基本信息id*/
@ApiModelProperty(value="管道基本信息id")
private java.lang.Long pipelineInformationId ;
/**项目组id*/
@ApiModelProperty(value="项目组id")
private java.lang.Long projectGroupId ;
/**监理单位id*/
@ApiModelProperty(value="监理单位id")
private java.lang.Long supervisingUnitId ;
/**EPC承包商id*/
@ApiModelProperty(value="EPC承包商id")
private java.lang.Long epcContractorId ;
/**施工单位id*/
@ApiModelProperty(value="施工单位id")
private java.lang.Long constructionUnitId ;
/**管道的焊口管理id*/
@ApiModelProperty(value="管道的焊口管理id")
private java.lang.Long pipelineWeldingJointManagementId ;
/**管道焊工id*/
@ApiModelProperty(value="管道焊工id")
private java.lang.Long pipelineWelderId ;
/**规格*/
@ApiModelProperty(value="规格")
private java.lang.String specification ;
/**材质*/
@ApiModelProperty(value="材质")
private java.lang.String material ;
/**焊接位置*/
@ApiModelProperty(value="焊接位置")
private java.lang.String weldingPosition ;
/**焊接方法*/
@ApiModelProperty(value="焊接方法")
private java.lang.String weldingMethod ;
/**焊材牌号*/
@ApiModelProperty(value="焊材牌号")
private java.lang.String weldingMaterialBrand ;
/**实际预热温度*/
@ApiModelProperty(value="实际预热温度")
private java.lang.String actualPreheatingTemperature ;
/**焊接日期*/
@ApiModelProperty(value="焊接日期")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
private Date weldingDate ;
/**焊接表面质量*/
@ApiModelProperty(value="焊接表面质量")
private java.lang.String weldingSurfaceQuality ;
/**管道内接检查*/
@ApiModelProperty(value="管道内接检查")
private java.lang.String pipelineInternalConnectionInspection ;
/**无损检测是否合格(-1未知0不合格1合格)*/
@ApiModelProperty(value="无损检测是否合格(-1未知0不合格1合格)")
private java.lang.Integer testingQualified ;
/**所属项目SN*/
@ApiModelProperty(value="所属项目SN")
private java.lang.String projectSn ;
/**创建时间*/
@ApiModelProperty(value="创建时间")
private java.util.Date createDate ;
/**更新时间*/
@ApiModelProperty(value="更新时间")
private java.util.Date updateDate ;
@TableField(exist = false)
@ApiModelProperty(value="装置管理名称")
private java.lang.String deviceUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="项目组名称")
private java.lang.String projectGroupName ;
@TableField(exist = false)
@ApiModelProperty(value="监理单位名称")
private java.lang.String supervisingUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="EPC承包商名称")
private java.lang.String epcContractorName ;
@TableField(exist = false)
@ApiModelProperty(value="施工单位名称")
private java.lang.String constructionUnitName ;
@TableField(exist = false)
@ApiModelProperty(value="管道名称")
private java.lang.String pipelineName ;
@TableField(exist = false)
@ApiModelProperty(value="管道焊工名称")
private java.lang.String welderName ;
@TableField(exist = false)
@ApiModelProperty(value="焊工代号")
private java.lang.String welderCode ;
@TableField(exist = false)
@ApiModelProperty(value="管道编号/单线号")
private java.lang.String pipelineNumberLineNumber ;
@TableField(exist = false)
@ApiModelProperty(value="焊口编号")
private java.lang.String weldingNumber ;
}

50
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/PipelineMaterialInspectionMapper.java Normal file
View File

@ -0,0 +1,50 @@
package com.zhgd.xmgl.modules.baotou.mapper;
import java.util.List;
import java.util.HashMap;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialInspection;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 管道材料报验
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Mapper
public interface PipelineMaterialInspectionMapper extends BaseMapper<PipelineMaterialInspection> {
/**
* 分页列表查询管道材料报验信息
*
* @param page
* @param queryWrapper
* @param param
* @return
*/
IPage<PipelineMaterialInspection> queryList(Page<PipelineMaterialInspection> page, @Param(Constants.WRAPPER) QueryWrapper<PipelineMaterialInspection> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 列表查询管道材料报验信息
*
* @param queryWrapper
* @param param
* @return
*/
List<PipelineMaterialInspection> queryList(@Param(Constants.WRAPPER) QueryWrapper<PipelineMaterialInspection> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 通过id查询管道材料报验信息
*
* @param id
* @return
*/
PipelineMaterialInspection queryById(String id);
}

19
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/PipelineMaterialManagementMapper.java
View File

@ -1,19 +0,0 @@
package com.zhgd.xmgl.modules.baotou.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialManagement;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 管道的材料管理
* @author： pds
* @date： 2024-09-03
* @version： V1.0
*/
@Mapper
public interface PipelineMaterialManagementMapper extends BaseMapper<PipelineMaterialManagement> {
}

50
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/PipelinePressureTestBagMapper.java Normal file
View File

@ -0,0 +1,50 @@
package com.zhgd.xmgl.modules.baotou.mapper;
import java.util.List;
import java.util.HashMap;
import com.zhgd.xmgl.modules.baotou.entity.PipelinePressureTestBag;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 管道试压包
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Mapper
public interface PipelinePressureTestBagMapper extends BaseMapper<PipelinePressureTestBag> {
/**
* 分页列表查询管道试压包信息
*
* @param page
* @param queryWrapper
* @param param
* @return
*/
IPage<PipelinePressureTestBag> queryList(Page<PipelinePressureTestBag> page, @Param(Constants.WRAPPER) QueryWrapper<PipelinePressureTestBag> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 列表查询管道试压包信息
*
* @param queryWrapper
* @param param
* @return
*/
List<PipelinePressureTestBag> queryList(@Param(Constants.WRAPPER) QueryWrapper<PipelinePressureTestBag> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 通过id查询管道试压包信息
*
* @param id
* @return
*/
PipelinePressureTestBag queryById(String id);
}

50
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/PipelineWelderMapper.java Normal file
View File

@ -0,0 +1,50 @@
package com.zhgd.xmgl.modules.baotou.mapper;
import java.util.List;
import java.util.HashMap;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWelder;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 管道焊工
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Mapper
public interface PipelineWelderMapper extends BaseMapper<PipelineWelder> {
/**
* 分页列表查询管道焊工信息
*
* @param page
* @param queryWrapper
* @param param
* @return
*/
IPage<PipelineWelder> queryList(Page<PipelineWelder> page, @Param(Constants.WRAPPER) QueryWrapper<PipelineWelder> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 列表查询管道焊工信息
*
* @param queryWrapper
* @param param
* @return
*/
List<PipelineWelder> queryList(@Param(Constants.WRAPPER) QueryWrapper<PipelineWelder> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 通过id查询管道焊工信息
*
* @param id
* @return
*/
PipelineWelder queryById(String id);
}

50
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/PipelineWeldingProcedureQualificationMapper.java Normal file
View File

@ -0,0 +1,50 @@
package com.zhgd.xmgl.modules.baotou.mapper;
import java.util.List;
import java.util.HashMap;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingProcedureQualification;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* @Description: 管道焊接工艺评定
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Mapper
public interface PipelineWeldingProcedureQualificationMapper extends BaseMapper<PipelineWeldingProcedureQualification> {
/**
* 分页列表查询管道焊接工艺评定信息
*
* @param page
* @param queryWrapper
* @param param
* @return
*/
IPage<PipelineWeldingProcedureQualification> queryList(Page<PipelineWeldingProcedureQualification> page, @Param(Constants.WRAPPER) QueryWrapper<PipelineWeldingProcedureQualification> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 列表查询管道焊接工艺评定信息
*
* @param queryWrapper
* @param param
* @return
*/
List<PipelineWeldingProcedureQualification> queryList(@Param(Constants.WRAPPER) QueryWrapper<PipelineWeldingProcedureQualification> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 通过id查询管道焊接工艺评定信息
*
* @param id
* @return
*/
PipelineWeldingProcedureQualification queryById(String id);
}

49
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/PipelineWeldingRecordMapper.java Normal file
View File

@ -0,0 +1,49 @@
package com.zhgd.xmgl.modules.baotou.mapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingRecord;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.HashMap;
import java.util.List;
/**
* @Description: 管道焊接记录
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Mapper
public interface PipelineWeldingRecordMapper extends BaseMapper<PipelineWeldingRecord> {
/**
* 分页列表查询管道焊接记录信息
*
* @param page
* @param queryWrapper
* @param param
* @return
*/
IPage<PipelineWeldingRecord> queryList(Page<PipelineWeldingRecord> page, @Param(Constants.WRAPPER) QueryWrapper<PipelineWeldingRecord> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 列表查询管道焊接记录信息
*
* @param queryWrapper
* @param param
* @return
*/
List<PipelineWeldingRecord> queryList(@Param(Constants.WRAPPER) QueryWrapper<PipelineWeldingRecord> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 通过id查询管道焊接记录信息
*
* @param id
* @return
*/
PipelineWeldingRecord queryById(String id);
}

4
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/xml/DeviceUnitMapper.xml
View File

@ -6,10 +6,12 @@
select t.*,
group_concat(distinct pg.project_group_name) as project_group_name,
group_concat(distinct ei.enterprise_name) as epc_contractor_name,
group_concat(distinct ei3.enterprise_name) as construction_unit_name
group_concat(distinct ei3.enterprise_name) as construction_unit_name,
group_concat(distinct pgu.supervising_unit_id) as supervising_unit_ids
from
device_unit t
join project_group pg on find_in_set(pg.id,t.project_group_ids)
left join project_group_unit pgu on pg.id = pgu.project_group_id
left join enterprise_info ei on find_in_set(ei.id,t.epc_contractor_ids)
left join enterprise_info ei3 on find_in_set(ei3.id,t.construction_unit_ids)
${ew.customSqlSegment}

38
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/xml/PipelineMaterialInspectionMapper.xml Normal file
View File

@ -0,0 +1,38 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhgd.xmgl.modules.baotou.mapper.PipelineMaterialInspectionMapper">
<select id="queryList" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialInspection">
select * from (
select t.*,
du.device_unit_name as device_unit_name,
pg.project_group_name as project_group_name,
ei1.enterprise_name as supervising_unit_name,
ei2.enterprise_name as epc_contractor_name,
ei3.enterprise_name as construction_unit_name
from pipeline_material_inspection t
left join device_unit du on t.device_unit_id = du.id
left join project_group pg on pg.id = t.project_group_id
left join enterprise_info ei1 on ei1.id=t.supervising_unit_id
left join enterprise_info ei2 on ei2.id=t.epc_contractor_id
left join enterprise_info ei3 on ei3.id=t.construction_unit_id
)t
${ew.customSqlSegment}
</select>
<select id="queryById" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialInspection">
select * from (
select t.*,
du.device_unit_name as device_unit_name,
pg.project_group_name as project_group_name,
ei1.enterprise_name as supervising_unit_name,
ei2.enterprise_name as epc_contractor_name,
ei3.enterprise_name as construction_unit_name
from pipeline_material_inspection t
left join device_unit du on t.device_unit_id = du.id
left join project_group pg on pg.id = t.project_group_id
left join enterprise_info ei1 on ei1.id=t.supervising_unit_id
left join enterprise_info ei2 on ei2.id=t.epc_contractor_id
left join enterprise_info ei3 on ei3.id=t.construction_unit_id
)t
where t.id = #{id}
</select>
</mapper>

30
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/xml/PipelinePressureTestBagMapper.xml Normal file
View File

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhgd.xmgl.modules.baotou.mapper.PipelinePressureTestBagMapper">
<select id="queryList" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelinePressureTestBag">
select * from (
select t.*,
du.device_unit_name as device_unit_name,
group_concat(distinct pi.pipeline_name) as pipeline_names,
group_concat(distinct pi.pipeline_number) as pipeline_numbers
from pipeline_pressure_test_bag t
left join device_unit du on du.id = t.device_unit_id
left join pipeline_information pi on find_in_set(pi.id,t.pipeline_information_ids)
group by t.id
)t
${ew.customSqlSegment}
</select>
<select id="queryById" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelinePressureTestBag">
select * from (
select t.*,
du.device_unit_name as device_unit_name,
group_concat(distinct pi.pipeline_name) as pipeline_names,
group_concat(distinct pi.pipeline_number) as pipeline_numbers
from pipeline_pressure_test_bag t
left join device_unit du on du.id = t.device_unit_id
left join pipeline_information pi on find_in_set(pi.id,t.pipeline_information_ids)
group by t.id
)t
where t.id = #{id}
</select>
</mapper>

43
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/xml/PipelineWelderMapper.xml Normal file
View File

@ -0,0 +1,43 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhgd.xmgl.modules.baotou.mapper.PipelineWelderMapper">
<select id="queryList" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelineWelder">
select * from (
select t.*,
du.device_unit_name,
wi.worker_name as welder_name,
wi.sex,
wc.certificate_number as welder_certificate_number,
pwr.welding_pass_rate
from pipeline_welder t
left join device_unit du on du.id = t.device_unit_id
left join worker_info wi on wi.id = t.worker_id
left join (select * from worker_certificate where project_sn = #{param.projectSn}
group by worker_id) wc on wc.id = t.worker_id
left join (select ifnull(round(ifnull(sum(if(testing_qualified=1,1,0)),0)/count(*)*100,2),0) as welding_pass_rate,pipeline_welder_id
from pipeline_welding_record where project_sn = #{param.projectSn} and testing_qualified != -1
group by pipeline_welder_id) pwr on t.id = pwr.pipeline_welder_id
)t
${ew.customSqlSegment}
</select>
<select id="queryById" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelineWelder">
select * from (
select t.*,
du.device_unit_name,
wi.worker_name as welder_name,
wi.sex,
wc.certificate_number as welder_certificate_number,
pwr.welding_pass_rate
from pipeline_welder t
left join device_unit du on du.id = t.device_unit_id
left join worker_info wi on wi.id = t.worker_id
left join (select * from worker_certificate where worker_id = (select worker_id from pipeline_welder where id = #{id})
group by worker_id) wc on wc.id = t.worker_id
left join (select ifnull(round(ifnull(sum(if(testing_qualified=1,1,0)),0)/count(*)*100,2),0) as welding_pass_rate,pipeline_welder_id
from pipeline_welding_record where project_sn = (select project_sn from pipeline_welder where id = #{id}) and testing_qualified != -1
group by pipeline_welder_id) pwr on t.id = pwr.pipeline_welder_id
)t
where t.id = #{id}
</select>
</mapper>

38
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/xml/PipelineWeldingProcedureQualificationMapper.xml Normal file
View File

@ -0,0 +1,38 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhgd.xmgl.modules.baotou.mapper.PipelineWeldingProcedureQualificationMapper">
<select id="queryList" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingProcedureQualification">
select * from (
select t.*,
du.device_unit_name as device_unit_name,
pg.project_group_name as project_group_name,
ei1.enterprise_name as supervising_unit_name,
ei2.enterprise_name as epc_contractor_name,
ei3.enterprise_name as construction_unit_name
from pipeline_welding_procedure_qualification t
left join device_unit du on t.device_unit_id = du.id
left join project_group pg on pg.id = t.project_group_id
left join enterprise_info ei1 on ei1.id=t.supervising_unit_id
left join enterprise_info ei2 on ei2.id=t.epc_contractor_id
left join enterprise_info ei3 on ei3.id=t.construction_unit_id
)t
${ew.customSqlSegment}
</select>
<select id="queryById" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingProcedureQualification">
select * from (
select t.*,
du.device_unit_name as device_unit_name,
pg.project_group_name as project_group_name,
ei1.enterprise_name as supervising_unit_name,
ei2.enterprise_name as epc_contractor_name,
ei3.enterprise_name as construction_unit_name
from pipeline_welding_procedure_qualification t
left join device_unit du on t.device_unit_id = du.id
left join project_group pg on pg.id = t.project_group_id
left join enterprise_info ei1 on ei1.id=t.supervising_unit_id
left join enterprise_info ei2 on ei2.id=t.epc_contractor_id
left join enterprise_info ei3 on ei3.id=t.construction_unit_id
)t
where t.id = #{id}
</select>
</mapper>

57
src/main/java/com/zhgd/xmgl/modules/baotou/mapper/xml/PipelineWeldingRecordMapper.xml Normal file
View File

@ -0,0 +1,57 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhgd.xmgl.modules.baotou.mapper.PipelineWeldingRecordMapper">
<select id="queryList" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingRecord">
select * from (
select t.*,
du.device_unit_name as device_unit_name,
pg.project_group_name as project_group_name,
ei1.enterprise_name as supervising_unit_name,
ei2.enterprise_name as epc_contractor_name,
ei3.enterprise_name as construction_unit_name,
pi.pipeline_name,
wi.worker_name as welder_name,
pw.welder_code,
pi.pipeline_number as pipeline_number_line_number,
pwjm.weld_number as welding_number
from pipeline_welding_record t
left join device_unit du on t.device_unit_id = du.id
left join project_group pg on pg.id = t.project_group_id
left join enterprise_info ei1 on ei1.id=t.supervising_unit_id
left join enterprise_info ei2 on ei2.id=t.epc_contractor_id
left join enterprise_info ei3 on ei3.id=t.construction_unit_id
left join pipeline_information pi on pi.id=t.pipeline_information_id
left join pipeline_welder pw on pw.id=t.pipeline_welder_id
left join worker_info wi on wi.id=pw.worker_id
left join pipeline_welding_joint_management pwjm on t.pipeline_welding_joint_management_id = pwjm.id
)t
${ew.customSqlSegment}
</select>
<select id="queryById" resultType="com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingRecord">
select * from (
select t.*,
du.device_unit_name as device_unit_name,
pg.project_group_name as project_group_name,
ei1.enterprise_name as supervising_unit_name,
ei2.enterprise_name as epc_contractor_name,
ei3.enterprise_name as construction_unit_name,
pi.pipeline_name,
wi.worker_name as welder_name,
pw.welder_code,
pi.pipeline_number as pipeline_number_line_number,
pwjm.weld_number as welding_number
from pipeline_welding_record t
left join device_unit du on t.device_unit_id = du.id
left join project_group pg on pg.id = t.project_group_id
left join enterprise_info ei1 on ei1.id=t.supervising_unit_id
left join enterprise_info ei2 on ei2.id=t.epc_contractor_id
left join enterprise_info ei3 on ei3.id=t.construction_unit_id
left join pipeline_information pi on pi.id=t.pipeline_information_id
left join pipeline_welder pw on pw.id=t.pipeline_welder_id
left join worker_info wi on wi.id=pw.worker_id
left join pipeline_welding_joint_management pwjm on t.pipeline_welding_joint_management_id = pwjm.id
)t
where t.id = #{id}
</select>
</mapper>

53
src/main/java/com/zhgd/xmgl/modules/baotou/service/IPipelineMaterialInspectionService.java Normal file
View File

@ -0,0 +1,53 @@
package com.zhgd.xmgl.modules.baotou.service;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialInspection;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.HashMap;
import java.util.List;
/**
* @Description: 管道材料报验
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
public interface IPipelineMaterialInspectionService extends IService<PipelineMaterialInspection> {
/**
* 分页列表查询管道材料报验信息
* @param param 参数map
* @return
*/
IPage<PipelineMaterialInspection> queryPageList(HashMap<String, Object> param);
/**
* 列表查询管道材料报验信息
* @param param 参数map
* @return
*/
List<PipelineMaterialInspection> queryList(HashMap<String, Object> param);
/**
* 添加管道材料报验信息
* @param pipelineMaterialInspection 管道材料报验
* @return
*/
void add(PipelineMaterialInspection pipelineMaterialInspection);
/**
* 编辑管道材料报验信息
* @param pipelineMaterialInspection 管道材料报验
* @return
*/
void edit(PipelineMaterialInspection pipelineMaterialInspection);
/**
* 根据id删除管道材料报验信息
* @param id 管道材料报验的id
* @return
*/
void delete(String id);
/**
* 根据id查询管道材料报验信息
* @param id 管道材料报验的id
* @return
*/
PipelineMaterialInspection queryById(String id);
}

53
src/main/java/com/zhgd/xmgl/modules/baotou/service/IPipelineMaterialManagementService.java
View File

@ -1,53 +0,0 @@
package com.zhgd.xmgl.modules.baotou.service;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialManagement;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.HashMap;
import java.util.List;
/**
* @Description: 管道的材料管理
* @author： pds
* @date： 2024-09-03
* @version： V1.0
*/
public interface IPipelineMaterialManagementService extends IService<PipelineMaterialManagement> {
/**
* 分页列表查询管道的材料管理信息
* @param param 参数map
* @return
*/
IPage<PipelineMaterialManagement> queryPageList(HashMap<String, Object> param);
/**
* 列表查询管道的材料管理信息
* @param param 参数map
* @return
*/
List<PipelineMaterialManagement> queryList(HashMap<String, Object> param);
/**
* 添加管道的材料管理信息
* @param pipelineMaterialManagement 管道的材料管理
* @return
*/
void add(PipelineMaterialManagement pipelineMaterialManagement);
/**
* 编辑管道的材料管理信息
* @param pipelineMaterialManagement 管道的材料管理
* @return
*/
void edit(PipelineMaterialManagement pipelineMaterialManagement);
/**
* 根据id删除管道的材料管理信息
* @param id 管道的材料管理的id
* @return
*/
void delete(String id);
/**
* 根据id查询管道的材料管理信息
* @param id 管道的材料管理的id
* @return
*/
PipelineMaterialManagement queryById(String id);
}

53
src/main/java/com/zhgd/xmgl/modules/baotou/service/IPipelinePressureTestBagService.java Normal file
View File

@ -0,0 +1,53 @@
package com.zhgd.xmgl.modules.baotou.service;
import com.zhgd.xmgl.modules.baotou.entity.PipelinePressureTestBag;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.HashMap;
import java.util.List;
/**
* @Description: 管道试压包
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
public interface IPipelinePressureTestBagService extends IService<PipelinePressureTestBag> {
/**
* 分页列表查询管道试压包信息
* @param param 参数map
* @return
*/
IPage<PipelinePressureTestBag> queryPageList(HashMap<String, Object> param);
/**
* 列表查询管道试压包信息
* @param param 参数map
* @return
*/
List<PipelinePressureTestBag> queryList(HashMap<String, Object> param);
/**
* 添加管道试压包信息
* @param pipelinePressureTestBag 管道试压包
* @return
*/
void add(PipelinePressureTestBag pipelinePressureTestBag);
/**
* 编辑管道试压包信息
* @param pipelinePressureTestBag 管道试压包
* @return
*/
void edit(PipelinePressureTestBag pipelinePressureTestBag);
/**
* 根据id删除管道试压包信息
* @param id 管道试压包的id
* @return
*/
void delete(String id);
/**
* 根据id查询管道试压包信息
* @param id 管道试压包的id
* @return
*/
PipelinePressureTestBag queryById(String id);
}

53
src/main/java/com/zhgd/xmgl/modules/baotou/service/IPipelineWelderService.java Normal file
View File

@ -0,0 +1,53 @@
package com.zhgd.xmgl.modules.baotou.service;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWelder;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.HashMap;
import java.util.List;
/**
* @Description: 管道焊工
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
public interface IPipelineWelderService extends IService<PipelineWelder> {
/**
* 分页列表查询管道焊工信息
* @param param 参数map
* @return
*/
IPage<PipelineWelder> queryPageList(HashMap<String, Object> param);
/**
* 列表查询管道焊工信息
* @param param 参数map
* @return
*/
List<PipelineWelder> queryList(HashMap<String, Object> param);
/**
* 添加管道焊工信息
* @param pipelineWelder 管道焊工
* @return
*/
void add(PipelineWelder pipelineWelder);
/**
* 编辑管道焊工信息
* @param pipelineWelder 管道焊工
* @return
*/
void edit(PipelineWelder pipelineWelder);
/**
* 根据id删除管道焊工信息
* @param id 管道焊工的id
* @return
*/
void delete(String id);
/**
* 根据id查询管道焊工信息
* @param id 管道焊工的id
* @return
*/
PipelineWelder queryById(String id);
}

53
src/main/java/com/zhgd/xmgl/modules/baotou/service/IPipelineWeldingProcedureQualificationService.java Normal file
View File

@ -0,0 +1,53 @@
package com.zhgd.xmgl.modules.baotou.service;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingProcedureQualification;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.HashMap;
import java.util.List;
/**
* @Description: 管道焊接工艺评定
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
public interface IPipelineWeldingProcedureQualificationService extends IService<PipelineWeldingProcedureQualification> {
/**
* 分页列表查询管道焊接工艺评定信息
* @param param 参数map
* @return
*/
IPage<PipelineWeldingProcedureQualification> queryPageList(HashMap<String, Object> param);
/**
* 列表查询管道焊接工艺评定信息
* @param param 参数map
* @return
*/
List<PipelineWeldingProcedureQualification> queryList(HashMap<String, Object> param);
/**
* 添加管道焊接工艺评定信息
* @param pipelineWeldingProcedureQualification 管道焊接工艺评定
* @return
*/
void add(PipelineWeldingProcedureQualification pipelineWeldingProcedureQualification);
/**
* 编辑管道焊接工艺评定信息
* @param pipelineWeldingProcedureQualification 管道焊接工艺评定
* @return
*/
void edit(PipelineWeldingProcedureQualification pipelineWeldingProcedureQualification);
/**
* 根据id删除管道焊接工艺评定信息
* @param id 管道焊接工艺评定的id
* @return
*/
void delete(String id);
/**
* 根据id查询管道焊接工艺评定信息
* @param id 管道焊接工艺评定的id
* @return
*/
PipelineWeldingProcedureQualification queryById(String id);
}

53
src/main/java/com/zhgd/xmgl/modules/baotou/service/IPipelineWeldingRecordService.java Normal file
View File

@ -0,0 +1,53 @@
package com.zhgd.xmgl.modules.baotou.service;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingRecord;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import java.util.HashMap;
import java.util.List;
/**
* @Description: 管道焊接记录
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
public interface IPipelineWeldingRecordService extends IService<PipelineWeldingRecord> {
/**
* 分页列表查询管道焊接记录信息
* @param param 参数map
* @return
*/
IPage<PipelineWeldingRecord> queryPageList(HashMap<String, Object> param);
/**
* 列表查询管道焊接记录信息
* @param param 参数map
* @return
*/
List<PipelineWeldingRecord> queryList(HashMap<String, Object> param);
/**
* 添加管道焊接记录信息
* @param pipelineWeldingRecord 管道焊接记录
* @return
*/
void add(PipelineWeldingRecord pipelineWeldingRecord);
/**
* 编辑管道焊接记录信息
* @param pipelineWeldingRecord 管道焊接记录
* @return
*/
void edit(PipelineWeldingRecord pipelineWeldingRecord);
/**
* 根据id删除管道焊接记录信息
* @param id 管道焊接记录的id
* @return
*/
void delete(String id);
/**
* 根据id查询管道焊接记录信息
* @param id 管道焊接记录的id
* @return
*/
PipelineWeldingRecord queryById(String id);
}

6
src/main/java/com/zhgd/xmgl/modules/baotou/service/impl/PipelineInformationServiceImpl.java
View File

@ -3,7 +3,6 @@ package com.zhgd.xmgl.modules.baotou.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.xmgl.modules.baotou.entity.PipelineInformation;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialManagement;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingJointManagement;
import com.zhgd.xmgl.modules.baotou.mapper.PipelineInformationMapper;
import com.zhgd.xmgl.modules.baotou.service.IPipelineInformationService;
@ -18,7 +17,6 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.HashMap;
import java.util.List;
import com.zhgd.xmgl.util.RefUtil;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
/**
@ -33,9 +31,6 @@ public class PipelineInformationServiceImpl extends ServiceImpl<PipelineInformat
private PipelineInformationMapper pipelineInformationMapper;
@Lazy
@Autowired
private PipelineMaterialManagementServiceImpl pipelineMaterialManagementService;
@Lazy
@Autowired
private PipelineWeldingJointManagementServiceImpl pipelineWeldingJointManagementService;
@Override
public IPage<PipelineInformation> queryPageList(HashMap<String, Object> param) {
@ -85,7 +80,6 @@ public class PipelineInformationServiceImpl extends ServiceImpl<PipelineInformat
}
baseMapper.deleteById(id);
pipelineMaterialManagementService.remove(new LambdaQueryWrapper<PipelineMaterialManagement>().eq(PipelineMaterialManagement::getPipelineInformationId, id));
pipelineWeldingJointManagementService.remove(new LambdaQueryWrapper<PipelineWeldingJointManagement>().eq(PipelineWeldingJointManagement::getPipelineInformationId, id));
}

88
src/main/java/com/zhgd/xmgl/modules/baotou/service/impl/PipelineMaterialInspectionServiceImpl.java Normal file
View File

@ -0,0 +1,88 @@
package com.zhgd.xmgl.modules.baotou.service.impl;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialInspection;
import com.zhgd.xmgl.modules.baotou.mapper.PipelineMaterialInspectionMapper;
import com.zhgd.xmgl.modules.baotou.service.IPipelineMaterialInspectionService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.xmgl.util.PageUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.HashMap;
import java.util.List;
import com.zhgd.xmgl.util.RefUtil;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description: 管道材料报验
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Service
public class PipelineMaterialInspectionServiceImpl extends ServiceImpl<PipelineMaterialInspectionMapper, PipelineMaterialInspection> implements IPipelineMaterialInspectionService {
@Autowired
private PipelineMaterialInspectionMapper pipelineMaterialInspectionMapper;
@Override
public IPage<PipelineMaterialInspection> queryPageList(HashMap<String, Object> param) {
QueryWrapper<PipelineMaterialInspection> queryWrapper = this.getQueryWrapper(param);
Page<PipelineMaterialInspection> page = PageUtil.getPage(param);
IPage<PipelineMaterialInspection> pageList = baseMapper.queryList(page, queryWrapper,param);
pageList.setRecords(this.dealList(pageList.getRecords()));
return pageList;
}
@Override
public List<PipelineMaterialInspection> queryList(HashMap<String, Object> param) {
QueryWrapper<PipelineMaterialInspection> queryWrapper = getQueryWrapper(param);
return dealList(baseMapper.queryList(queryWrapper,param));
}
private QueryWrapper<PipelineMaterialInspection> getQueryWrapper(HashMap<String, Object> param) {
QueryWrapper<PipelineMaterialInspection> queryWrapper = QueryGenerator.initPageQueryWrapper(PipelineMaterialInspection.class, param, true);
queryWrapper.orderByDesc(RefUtil.fieldNameUlc(PipelineMaterialInspection::getId));
return queryWrapper;
}
private List<PipelineMaterialInspection> dealList(List<PipelineMaterialInspection> list) {
return list;
}
@Override
public void add(PipelineMaterialInspection pipelineMaterialInspection) {
pipelineMaterialInspection.setId(null);
baseMapper.insert(pipelineMaterialInspection);
}
@Override
public void edit(PipelineMaterialInspection pipelineMaterialInspection) {
PipelineMaterialInspection oldPipelineMaterialInspection = baseMapper.selectById(pipelineMaterialInspection.getId());
if(oldPipelineMaterialInspection==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.updateById(pipelineMaterialInspection);
}
@Override
public void delete(String id) {
PipelineMaterialInspection pipelineMaterialInspection = baseMapper.selectById(id);
if(pipelineMaterialInspection==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.deleteById(id);
}
@Override
public PipelineMaterialInspection queryById(String id) {
PipelineMaterialInspection entity = baseMapper.queryById(id);
if (entity == null) {
throw new OpenAlertException("未找到对应实体");
}
return entity;
}
}

88
src/main/java/com/zhgd/xmgl/modules/baotou/service/impl/PipelineMaterialManagementServiceImpl.java
View File

@ -1,88 +0,0 @@
package com.zhgd.xmgl.modules.baotou.service.impl;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.xmgl.modules.baotou.entity.PipelineMaterialManagement;
import com.zhgd.xmgl.modules.baotou.mapper.PipelineMaterialManagementMapper;
import com.zhgd.xmgl.modules.baotou.service.IPipelineMaterialManagementService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.xmgl.util.PageUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.HashMap;
import java.util.List;
import com.zhgd.xmgl.util.RefUtil;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description: 管道的材料管理
* @author： pds
* @date： 2024-09-03
* @version： V1.0
*/
@Service
public class PipelineMaterialManagementServiceImpl extends ServiceImpl<PipelineMaterialManagementMapper, PipelineMaterialManagement> implements IPipelineMaterialManagementService {
@Autowired
private PipelineMaterialManagementMapper pipelineMaterialManagementMapper;
@Override
public IPage<PipelineMaterialManagement> queryPageList(HashMap<String, Object> param) {
QueryWrapper<PipelineMaterialManagement> queryWrapper = this.getQueryWrapper(param);
Page<PipelineMaterialManagement> page = PageUtil.getPage(param);
IPage<PipelineMaterialManagement> pageList = this.page(page, queryWrapper);
pageList.setRecords(this.dealList(pageList.getRecords()));
return pageList;
}
@Override
public List<PipelineMaterialManagement> queryList(HashMap<String, Object> param) {
QueryWrapper<PipelineMaterialManagement> queryWrapper = getQueryWrapper(param);
return dealList(this.list(queryWrapper));
}
private QueryWrapper<PipelineMaterialManagement> getQueryWrapper(HashMap<String, Object> param) {
QueryWrapper<PipelineMaterialManagement> queryWrapper = QueryGenerator.initPageQueryWrapper(PipelineMaterialManagement.class, param, true);
queryWrapper.orderByDesc(RefUtil.fieldNameUlc(PipelineMaterialManagement::getId));
return queryWrapper;
}
private List<PipelineMaterialManagement> dealList(List<PipelineMaterialManagement> list) {
return list;
}
@Override
public void add(PipelineMaterialManagement pipelineMaterialManagement) {
pipelineMaterialManagement.setId(null);
baseMapper.insert(pipelineMaterialManagement);
}
@Override
public void edit(PipelineMaterialManagement pipelineMaterialManagement) {
PipelineMaterialManagement oldPipelineMaterialManagement = baseMapper.selectById(pipelineMaterialManagement.getId());
if(oldPipelineMaterialManagement==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.updateById(pipelineMaterialManagement);
}
@Override
public void delete(String id) {
PipelineMaterialManagement pipelineMaterialManagement = baseMapper.selectById(id);
if(pipelineMaterialManagement==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.deleteById(id);
}
@Override
public PipelineMaterialManagement queryById(String id) {
PipelineMaterialManagement entity = getById(id);
if (entity == null) {
throw new OpenAlertException("未找到对应实体");
}
return entity;
}
}

88
src/main/java/com/zhgd/xmgl/modules/baotou/service/impl/PipelinePressureTestBagServiceImpl.java Normal file
View File

@ -0,0 +1,88 @@
package com.zhgd.xmgl.modules.baotou.service.impl;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.xmgl.modules.baotou.entity.PipelinePressureTestBag;
import com.zhgd.xmgl.modules.baotou.mapper.PipelinePressureTestBagMapper;
import com.zhgd.xmgl.modules.baotou.service.IPipelinePressureTestBagService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.xmgl.util.PageUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.HashMap;
import java.util.List;
import com.zhgd.xmgl.util.RefUtil;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description: 管道试压包
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Service
public class PipelinePressureTestBagServiceImpl extends ServiceImpl<PipelinePressureTestBagMapper, PipelinePressureTestBag> implements IPipelinePressureTestBagService {
@Autowired
private PipelinePressureTestBagMapper pipelinePressureTestBagMapper;
@Override
public IPage<PipelinePressureTestBag> queryPageList(HashMap<String, Object> param) {
QueryWrapper<PipelinePressureTestBag> queryWrapper = this.getQueryWrapper(param);
Page<PipelinePressureTestBag> page = PageUtil.getPage(param);
IPage<PipelinePressureTestBag> pageList = baseMapper.queryList(page, queryWrapper,param);
pageList.setRecords(this.dealList(pageList.getRecords()));
return pageList;
}
@Override
public List<PipelinePressureTestBag> queryList(HashMap<String, Object> param) {
QueryWrapper<PipelinePressureTestBag> queryWrapper = getQueryWrapper(param);
return dealList(baseMapper.queryList(queryWrapper,param));
}
private QueryWrapper<PipelinePressureTestBag> getQueryWrapper(HashMap<String, Object> param) {
QueryWrapper<PipelinePressureTestBag> queryWrapper = QueryGenerator.initPageQueryWrapper(PipelinePressureTestBag.class, param, true);
queryWrapper.orderByDesc(RefUtil.fieldNameUlc(PipelinePressureTestBag::getId));
return queryWrapper;
}
private List<PipelinePressureTestBag> dealList(List<PipelinePressureTestBag> list) {
return list;
}
@Override
public void add(PipelinePressureTestBag pipelinePressureTestBag) {
pipelinePressureTestBag.setId(null);
baseMapper.insert(pipelinePressureTestBag);
}
@Override
public void edit(PipelinePressureTestBag pipelinePressureTestBag) {
PipelinePressureTestBag oldPipelinePressureTestBag = baseMapper.selectById(pipelinePressureTestBag.getId());
if(oldPipelinePressureTestBag==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.updateById(pipelinePressureTestBag);
}
@Override
public void delete(String id) {
PipelinePressureTestBag pipelinePressureTestBag = baseMapper.selectById(id);
if(pipelinePressureTestBag==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.deleteById(id);
}
@Override
public PipelinePressureTestBag queryById(String id) {
PipelinePressureTestBag entity = baseMapper.queryById(id);
if (entity == null) {
throw new OpenAlertException("未找到对应实体");
}
return entity;
}
}

88
src/main/java/com/zhgd/xmgl/modules/baotou/service/impl/PipelineWelderServiceImpl.java Normal file
View File

@ -0,0 +1,88 @@
package com.zhgd.xmgl.modules.baotou.service.impl;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWelder;
import com.zhgd.xmgl.modules.baotou.mapper.PipelineWelderMapper;
import com.zhgd.xmgl.modules.baotou.service.IPipelineWelderService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.xmgl.util.PageUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.HashMap;
import java.util.List;
import com.zhgd.xmgl.util.RefUtil;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description: 管道焊工
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Service
public class PipelineWelderServiceImpl extends ServiceImpl<PipelineWelderMapper, PipelineWelder> implements IPipelineWelderService {
@Autowired
private PipelineWelderMapper pipelineWelderMapper;
@Override
public IPage<PipelineWelder> queryPageList(HashMap<String, Object> param) {
QueryWrapper<PipelineWelder> queryWrapper = this.getQueryWrapper(param);
Page<PipelineWelder> page = PageUtil.getPage(param);
IPage<PipelineWelder> pageList = baseMapper.queryList(page, queryWrapper,param);
pageList.setRecords(this.dealList(pageList.getRecords()));
return pageList;
}
@Override
public List<PipelineWelder> queryList(HashMap<String, Object> param) {
QueryWrapper<PipelineWelder> queryWrapper = getQueryWrapper(param);
return dealList(baseMapper.queryList(queryWrapper,param));
}
private QueryWrapper<PipelineWelder> getQueryWrapper(HashMap<String, Object> param) {
QueryWrapper<PipelineWelder> queryWrapper = QueryGenerator.initPageQueryWrapper(PipelineWelder.class, param, true);
queryWrapper.orderByDesc(RefUtil.fieldNameUlc(PipelineWelder::getId));
return queryWrapper;
}
private List<PipelineWelder> dealList(List<PipelineWelder> list) {
return list;
}
@Override
public void add(PipelineWelder pipelineWelder) {
pipelineWelder.setId(null);
baseMapper.insert(pipelineWelder);
}
@Override
public void edit(PipelineWelder pipelineWelder) {
PipelineWelder oldPipelineWelder = baseMapper.selectById(pipelineWelder.getId());
if(oldPipelineWelder==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.updateById(pipelineWelder);
}
@Override
public void delete(String id) {
PipelineWelder pipelineWelder = baseMapper.selectById(id);
if(pipelineWelder==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.deleteById(id);
}
@Override
public PipelineWelder queryById(String id) {
PipelineWelder entity = baseMapper.queryById(id);
if (entity == null) {
throw new OpenAlertException("未找到对应实体");
}
return entity;
}
}

88
src/main/java/com/zhgd/xmgl/modules/baotou/service/impl/PipelineWeldingProcedureQualificationServiceImpl.java Normal file
View File

@ -0,0 +1,88 @@
package com.zhgd.xmgl.modules.baotou.service.impl;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingProcedureQualification;
import com.zhgd.xmgl.modules.baotou.mapper.PipelineWeldingProcedureQualificationMapper;
import com.zhgd.xmgl.modules.baotou.service.IPipelineWeldingProcedureQualificationService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.xmgl.util.PageUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.HashMap;
import java.util.List;
import com.zhgd.xmgl.util.RefUtil;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description: 管道焊接工艺评定
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Service
public class PipelineWeldingProcedureQualificationServiceImpl extends ServiceImpl<PipelineWeldingProcedureQualificationMapper, PipelineWeldingProcedureQualification> implements IPipelineWeldingProcedureQualificationService {
@Autowired
private PipelineWeldingProcedureQualificationMapper pipelineWeldingProcedureQualificationMapper;
@Override
public IPage<PipelineWeldingProcedureQualification> queryPageList(HashMap<String, Object> param) {
QueryWrapper<PipelineWeldingProcedureQualification> queryWrapper = this.getQueryWrapper(param);
Page<PipelineWeldingProcedureQualification> page = PageUtil.getPage(param);
IPage<PipelineWeldingProcedureQualification> pageList = baseMapper.queryList(page, queryWrapper,param);
pageList.setRecords(this.dealList(pageList.getRecords()));
return pageList;
}
@Override
public List<PipelineWeldingProcedureQualification> queryList(HashMap<String, Object> param) {
QueryWrapper<PipelineWeldingProcedureQualification> queryWrapper = getQueryWrapper(param);
return dealList(baseMapper.queryList(queryWrapper,param));
}
private QueryWrapper<PipelineWeldingProcedureQualification> getQueryWrapper(HashMap<String, Object> param) {
QueryWrapper<PipelineWeldingProcedureQualification> queryWrapper = QueryGenerator.initPageQueryWrapper(PipelineWeldingProcedureQualification.class, param, true);
queryWrapper.orderByDesc(RefUtil.fieldNameUlc(PipelineWeldingProcedureQualification::getId));
return queryWrapper;
}
private List<PipelineWeldingProcedureQualification> dealList(List<PipelineWeldingProcedureQualification> list) {
return list;
}
@Override
public void add(PipelineWeldingProcedureQualification pipelineWeldingProcedureQualification) {
pipelineWeldingProcedureQualification.setId(null);
baseMapper.insert(pipelineWeldingProcedureQualification);
}
@Override
public void edit(PipelineWeldingProcedureQualification pipelineWeldingProcedureQualification) {
PipelineWeldingProcedureQualification oldPipelineWeldingProcedureQualification = baseMapper.selectById(pipelineWeldingProcedureQualification.getId());
if(oldPipelineWeldingProcedureQualification==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.updateById(pipelineWeldingProcedureQualification);
}
@Override
public void delete(String id) {
PipelineWeldingProcedureQualification pipelineWeldingProcedureQualification = baseMapper.selectById(id);
if(pipelineWeldingProcedureQualification==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.deleteById(id);
}
@Override
public PipelineWeldingProcedureQualification queryById(String id) {
PipelineWeldingProcedureQualification entity = baseMapper.queryById(id);
if (entity == null) {
throw new OpenAlertException("未找到对应实体");
}
return entity;
}
}

88
src/main/java/com/zhgd/xmgl/modules/baotou/service/impl/PipelineWeldingRecordServiceImpl.java Normal file
View File

@ -0,0 +1,88 @@
package com.zhgd.xmgl.modules.baotou.service.impl;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.xmgl.modules.baotou.entity.PipelineWeldingRecord;
import com.zhgd.xmgl.modules.baotou.mapper.PipelineWeldingRecordMapper;
import com.zhgd.xmgl.modules.baotou.service.IPipelineWeldingRecordService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhgd.jeecg.common.system.query.QueryGenerator;
import com.zhgd.xmgl.util.PageUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.HashMap;
import java.util.List;
import com.zhgd.xmgl.util.RefUtil;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
/**
* @Description: 管道焊接记录
* @author： pds
* @date： 2024-09-20
* @version： V1.0
*/
@Service
public class PipelineWeldingRecordServiceImpl extends ServiceImpl<PipelineWeldingRecordMapper, PipelineWeldingRecord> implements IPipelineWeldingRecordService {
@Autowired
private PipelineWeldingRecordMapper pipelineWeldingRecordMapper;
@Override
public IPage<PipelineWeldingRecord> queryPageList(HashMap<String, Object> param) {
QueryWrapper<PipelineWeldingRecord> queryWrapper = this.getQueryWrapper(param);
Page<PipelineWeldingRecord> page = PageUtil.getPage(param);
IPage<PipelineWeldingRecord> pageList = baseMapper.queryList(page, queryWrapper,param);
pageList.setRecords(this.dealList(pageList.getRecords()));
return pageList;
}
@Override
public List<PipelineWeldingRecord> queryList(HashMap<String, Object> param) {
QueryWrapper<PipelineWeldingRecord> queryWrapper = getQueryWrapper(param);
return dealList(baseMapper.queryList(queryWrapper,param));
}
private QueryWrapper<PipelineWeldingRecord> getQueryWrapper(HashMap<String, Object> param) {
QueryWrapper<PipelineWeldingRecord> queryWrapper = QueryGenerator.initPageQueryWrapper(PipelineWeldingRecord.class, param, true);
queryWrapper.orderByDesc(RefUtil.fieldNameUlc(PipelineWeldingRecord::getId));
return queryWrapper;
}
private List<PipelineWeldingRecord> dealList(List<PipelineWeldingRecord> list) {
return list;
}
@Override
public void add(PipelineWeldingRecord pipelineWeldingRecord) {
pipelineWeldingRecord.setId(null);
baseMapper.insert(pipelineWeldingRecord);
}
@Override
public void edit(PipelineWeldingRecord pipelineWeldingRecord) {
PipelineWeldingRecord oldPipelineWeldingRecord = baseMapper.selectById(pipelineWeldingRecord.getId());
if(oldPipelineWeldingRecord==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.updateById(pipelineWeldingRecord);
}
@Override
public void delete(String id) {
PipelineWeldingRecord pipelineWeldingRecord = baseMapper.selectById(id);
if(pipelineWeldingRecord==null) {
throw new OpenAlertException("未找到对应实体");
}
baseMapper.deleteById(id);
}
@Override
public PipelineWeldingRecord queryById(String id) {
PipelineWeldingRecord entity = baseMapper.queryById(id);
if (entity == null) {
throw new OpenAlertException("未找到对应实体");
}
return entity;
}
}

29
src/main/java/com/zhgd/xmgl/modules/dangerous/entity/DangerousEngineeringRecord.java
View File

@ -108,25 +108,25 @@ public class DangerousEngineeringRecord implements Serializable {
@Excel(name = "技术交底文件", width = 15)
@ApiModelProperty(value="技术交底文件")
private java.lang.String technicalDisclosureFile ;
/**是否完成安全专项施工方案交底，1未完成，2完成*/
@Excel(name = "是否完成安全专项施工方案交底，1未完成，2完成", width = 15)
@ApiModelProperty(value="是否完成安全专项施工方案交底，1未完成，2完成")
/**是否完成方案，1未完成，2完成*/
@Excel(name = "是否完成方案，1未完成，2完成", width = 15)
@ApiModelProperty(value="是否完成方案，1未完成，2完成")
private java.lang.Integer securityConstructionSchemeType ;
/**安全专项施工方案附件*/
@Excel(name = "安全专项施工方案附件", width = 15)
@ApiModelProperty(value = "安全专项施工方案附件")
/**方案附件*/
@Excel(name = "方案附件", width = 15)
@ApiModelProperty(value = "方案附件")
private java.lang.String securityConstructionSchemeFile;
/**
* 是否完成专项施工方案交底，1未完成，2完成
* 是否完成方案交底，1未完成，2完成
*/
@Excel(name = "是否完成专项施工方案交底，1未完成，2完成", width = 15)
@ApiModelProperty(value = "是否完成专项施工方案交底，1未完成，2完成")
@Excel(name = "是否完成方案交底，1未完成，2完成", width = 15)
@ApiModelProperty(value = "是否完成方案交底，1未完成，2完成")
private java.lang.Integer specialConstructionSchemeType;
/**
* 专项施工方案附件
* 方案交底附件
*/
@Excel(name = "专项施工方案附件", width = 15)
@ApiModelProperty(value = "专项施工方案附件")
@Excel(name = "方案交底附件", width = 15)
@ApiModelProperty(value = "方案交底附件")
private java.lang.String specialConstructionSchemeFile;
@ApiModelProperty(value = "责任人id")
private java.lang.Long personLiableId;
@ -134,9 +134,12 @@ public class DangerousEngineeringRecord implements Serializable {
private java.lang.Integer isEnd;
@ApiModelProperty(value = "分包单位id")
private java.lang.Long responsibilityCompanyId;
@ApiModelProperty(value = "施工状态：1未开始、2进行中、3已完成")
private java.lang.Integer constructionState;
@ApiModelProperty(value = "最终验收状态1进行中2已闭合")
private Integer finalAcceptanceStatus;
@ApiModelProperty(value = "监控点编号（多个,分割）")
private String videoItemIds;
@TableField(exist = false)
@ApiModelProperty(value = "类别描述列表")

2
src/main/java/com/zhgd/xmgl/modules/dangerous/mapper/DangerousEngineeringRecordMapper.java
View File

@ -19,7 +19,7 @@ import java.util.Map;
* @version： V1.0
*/
@Mapper
@DataScope(includeTable = "dangerous_engineering_record")
//@DataScope(includeTable = "dangerous_engineering_record")
public interface DangerousEngineeringRecordMapper extends BaseMapper<DangerousEngineeringRecord> {
/**
* 分页列表查询现场危大工程信息

1
src/main/java/com/zhgd/xmgl/modules/video/controller/VideoItemController.java
View File

@ -140,6 +140,7 @@ public class VideoItemController {
@ApiOperation(value = "根据项目sn查询启用的的视频列表", notes = "根据项目sn查询启用的的视频列表", httpMethod = "POST")
@ApiImplicitParams({
@ApiImplicitParam(name = "projectSn", value = "项目SN", paramType = "body", required = true, dataType = "String"),
@ApiImplicitParam(name = "itemIds", value = "视频ids(多个,分割)", paramType = "body", required = true, dataType = "String"),
})
@PostMapping("/selectEnableVideoItemList")
public Result<Map<String, Object>> selectEnableVideoItemList(@RequestBody Map<String, Object> map) {

3
src/main/java/com/zhgd/xmgl/modules/video/mapper/xml/VideoItemMapper.xml
View File

@ -32,6 +32,9 @@
#{item}
</foreach>
</if>
<if test="itemIds != null and itemIds != ''">
and find_in_set(vi.item_id,#{itemIds})
</if>
group by vi.item_id
order by vi.sort_num
</select>

4
src/main/java/com/zhgd/xmgl/security/WebSecurityConfig.java
View File

@ -80,6 +80,10 @@ public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
http.authorizeRequests()
//请求路径允许访问
.antMatchers("/xmgl/pipelineMaterialInspection/flow/add").permitAll()
.antMatchers("/xmgl/pipelinePressureTestBag/flow/add").permitAll()
.antMatchers("/xmgl/pipelineWeldingProcedureQualification/flow/add").permitAll()
.antMatchers("/xmgl/pipelineWeldingRecord/flow/add").permitAll()
.antMatchers("/exam/paper/queryById").permitAll()
.antMatchers("/xmgl/workerAdmission/flow/add").permitAll()
.antMatchers("/xmgl/videoItem/camera/search").permitAll()

5
src/main/java/com/zhgd/xmgl/util/FlowUtil.java
View File

@ -2,6 +2,7 @@ package com.zhgd.xmgl.util;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
@ -58,6 +59,10 @@ public class FlowUtil {
return Optional.ofNullable(map.get(key)).map(o -> "".equals(o) ? null : Convert.toLong(((List) o).get(0))).orElse(null);
}
public static String getPullDownManyStr(Map map, String key) {
return Optional.ofNullable(map.get(key)).map(o -> "".equals(o) ? null : StrUtil.join(",", o)).orElse(null);
}
public static Date getDate(Map<String, Object> map, String key) {
return Optional.ofNullable(map.get(key)).map(o -> "".equals(o) ? null : DateUtil.parse(o.toString())).orElse(null);
}

5
src/main/resources/jeecg/code-template/one/java/${bussiPackage}/${entityPackage}/entity/${entityName}.javai
View File

@ -22,7 +22,7 @@ import io.swagger.annotations.ApiModelProperty;
@ApiModel(value="${entityName}实体类",description="${entityName}")
public class ${entityName} implements Serializable {
private static final long serialVersionUID = 1L;
<#list originalColumns as po>
/**${po.filedComment}*/
<#if po.fieldName == primaryKeyField>
@ -30,16 +30,13 @@ public class ${entityName} implements Serializable {
<#else>
<#if po.fieldType =='java.util.Date'>
<#if po.fieldDbType =='date'>
@Excel(name = "${po.filedComment}", width = 15, format = "yyyy-MM-dd")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern="yyyy-MM-dd")
<#elseif po.fieldDbType =='datetime'>
@Excel(name = "${po.filedComment}", width = 20, format = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
</#if>
<#else>
@Excel(name = "${po.filedComment}", width = 15)
</#if>
</#if>
@ApiModelProperty(value="${po.filedComment}")

35
src/main/resources/jeecg/code-template/one/java/${bussiPackage}/${entityPackage}/mapper/${entityName}Mapper.javai
View File

@ -1,10 +1,14 @@
package ${bussiPackage}.${entityPackage}.mapper;
import java.util.List;
import java.util.HashMap;
import ${bussiPackage}.${entityPackage}.entity.${entityName};
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import ${bussiPackage}.${entityPackage}.entity.${entityName};
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
@ -16,4 +20,31 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@Mapper
public interface ${entityName}Mapper extends BaseMapper<${entityName}> {
/**
* 分页列表查询${tableVo.ftlDescription}信息
*
* @param page
* @param queryWrapper
* @param param
* @return
*/
IPage<${entityName}> queryList(Page<${entityName}> page, @Param(Constants.WRAPPER) QueryWrapper<${entityName}> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 列表查询${tableVo.ftlDescription}信息
*
* @param queryWrapper
* @param param
* @return
*/
List<${entityName}> queryList(@Param(Constants.WRAPPER) QueryWrapper<${entityName}> queryWrapper, @Param("param") HashMap<String, Object> param);
/**
* 通过id查询${tableVo.ftlDescription}信息
*
* @param id
* @return
*/
${entityName} queryById(String id);
}

16
src/main/resources/jeecg/code-template/one/java/${bussiPackage}/${entityPackage}/mapper/xml/${entityName}Mapper.xml
View File

@ -2,4 +2,18 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="${bussiPackage}.${entityPackage}.mapper.${entityName}Mapper">
</mapper>
<select id="queryList" resultType="${bussiPackage}.${entityPackage}.entity.${entityName}">
select * from (
select t.*
from ${tableName} t
)t
${r"${ew.customSqlSegment}"}
</select>
<select id="queryById" resultType="${bussiPackage}.${entityPackage}.entity.${entityName}">
select * from (
select t.*
from pipeline_welding_record t
)t
where t.id = ${r"#{id}"}
</select>
</mapper>

6
src/main/resources/jeecg/code-template/one/java/${bussiPackage}/${entityPackage}/service/impl/${entityName}ServiceImpl.javai
View File

@ -31,7 +31,7 @@ public class ${entityName}ServiceImpl extends ServiceImpl<${entityName}Mapper, $
public IPage<${entityName}> queryPageList(HashMap<String, Object> param) {
QueryWrapper<${entityName}> queryWrapper = this.getQueryWrapper(param);
Page<${entityName}> page = PageUtil.getPage(param);
IPage<${entityName}> pageList = this.page(page, queryWrapper);
IPage<${entityName}> pageList = baseMapper.queryList(page, queryWrapper,param);
pageList.setRecords(this.dealList(pageList.getRecords()));
return pageList;
}
@ -39,7 +39,7 @@ public class ${entityName}ServiceImpl extends ServiceImpl<${entityName}Mapper, $
@Override
public List<${entityName}> queryList(HashMap<String, Object> param) {
QueryWrapper<${entityName}> queryWrapper = getQueryWrapper(param);
return dealList(this.list(queryWrapper));
return dealList(baseMapper.queryList(queryWrapper,param));
}
private QueryWrapper<${entityName}> getQueryWrapper(HashMap<String, Object> param) {
@ -78,7 +78,7 @@ public class ${entityName}ServiceImpl extends ServiceImpl<${entityName}Mapper, $
@Override
public ${entityName} queryById(String id) {
${entityName} entity = getById(id);
${entityName} entity = baseMapper.queryById(id);
if (entity == null) {
throw new OpenAlertException("未找到对应实体");
}