From ef89e62f9ab08b7b1d6fd0afb23eba4bb5a30b19 Mon Sep 17 00:00:00 2001 From: Joshi <3040996759@qq.com> Date: Mon, 27 Oct 2025 14:38:21 +0800 Subject: [PATCH 1/7] =?UTF-8?q?feat(config):=20=E6=9B=B4=E6=96=B0=E7=94=9F?= =?UTF-8?q?=E4=BA=A7=E7=8E=AF=E5=A2=83=E6=95=B0=E6=8D=AE=E5=BA=93=E9=85=8D?= =?UTF-8?q?=E7=BD=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 修改数据库连接地址为生产服务器IP和端口 - 设置数据库用户名为klp - 配置数据库密码为KeLunPu@123- 更改数据库名称为klp_pocketfactory --- klp-admin/src/main/resources/application-prod.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/klp-admin/src/main/resources/application-prod.yml b/klp-admin/src/main/resources/application-prod.yml index 5252a979..ac0a944c 100644 --- a/klp-admin/src/main/resources/application-prod.yml +++ b/klp-admin/src/main/resources/application-prod.yml @@ -66,9 +66,9 @@ spring: lazy: true type: ${spring.datasource.type} driverClassName: com.mysql.cj.jdbc.Driver - url: jdbc:mysql://localhost:3306/ry-vue?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true&rewriteBatchedStatements=true - username: - password: + url: jdbc:mysql://140.143.206.120:13306/klp_pocketfactory?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true&rewriteBatchedStatements=true + username: klp + password: KeLunPu@123 # oracle: # type: ${spring.datasource.type} # driverClassName: oracle.jdbc.OracleDriver From 31c2f93a9129fc693462ab588ec5b9ea53e21910 Mon Sep 17 00:00:00 2001 From: Joshi <3040996759@qq.com> Date: Mon, 27 Oct 2025 15:07:54 +0800 Subject: [PATCH 2/7] =?UTF-8?q?feat(pocket):=20=E6=96=B0=E5=A2=9E=E6=A8=A1?= =?UTF-8?q?=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 创建当前状态实体类Klptcm1ProPlantStateCurrent- 创建当前状态业务对象Klptcm1ProPlantStateCurrentBo - 创建当前状态值对象Klptcm1ProPlantStateCurrentVo - 实现当前状态Service接口及实现类 - 实现当前状态Controller接口- 实现当前状态Mapper接口及XML映射文件 - 提供当前状态的增删改查及分页查询功能 - 支持当前状态数据导出Excel功能- 添加字段校验和重复提交注解 - 配置MyBatis Plus自动映射99个VALUE字段 --- klp-pocket/pom.xml | 28 + ...Klptcm1ProPlantStateCurrentController.java | 102 +++ .../domain/Klptcm1ProPlantStateCurrent.java | 449 ++++++++++++ .../bo/Klptcm1ProPlantStateCurrentBo.java | 554 +++++++++++++++ .../vo/Klptcm1ProPlantStateCurrentVo.java | 662 ++++++++++++++++++ .../Klptcm1ProPlantStateCurrentMapper.java | 15 + .../IKlptcm1ProPlantStateCurrentService.java | 49 ++ ...lptcm1ProPlantStateCurrentServiceImpl.java | 213 ++++++ .../Klptcm1ProPlantStateCurrentMapper.xml | 117 ++++ pom.xml | 6 + 10 files changed, 2195 insertions(+) create mode 100644 klp-pocket/pom.xml create mode 100644 klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProPlantStateCurrentBo.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateCurrentVo.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java create mode 100644 klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml diff --git a/klp-pocket/pom.xml b/klp-pocket/pom.xml new file mode 100644 index 00000000..c25f61d9 --- /dev/null +++ b/klp-pocket/pom.xml @@ -0,0 +1,28 @@ + + 4.0.0 + + com.klp + klp-oa + 0.8.3 + + klp-pocket + Archetype - klp-pocket + http://maven.apache.org + + + com.klp + klp-common + 0.8.3 + + + commons-collections + commons-collections + + + com.klp + klp-system + 0.8.3 + + + diff --git a/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java new file mode 100644 index 00000000..06f19a47 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java @@ -0,0 +1,102 @@ +package com.klp.pocket.controller; + + +import java.util.Date; +import java.util.List; +import java.util.Arrays; + + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pocket.domain.vo.Klptcm1ProPlantStateCurrentVo; +import com.klp.pocket.domain.bo.Klptcm1ProPlantStateCurrentBo; +import com.klp.pocket.service.IKlptcm1ProPlantStateCurrentService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 当前 + * + * @author klp + * @date 2025-10-27 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pocket/proPlantStateCurrent") +public class Klptcm1ProPlantStateCurrentController extends BaseController { + + private final IKlptcm1ProPlantStateCurrentService iKlptcm1ProPlantStateCurrentService; + + /** + * 查询当前列表 + */ + @GetMapping("/list") + public TableDataInfo list(Klptcm1ProPlantStateCurrentBo bo, PageQuery pageQuery) { + return iKlptcm1ProPlantStateCurrentService.queryPageList(bo, pageQuery); + } + + /** + * 导出当前列表 + */ + @Log(title = "当前", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(Klptcm1ProPlantStateCurrentBo bo, HttpServletResponse response) { + List list = iKlptcm1ProPlantStateCurrentService.queryList(bo); + ExcelUtil.exportExcel(list, "当前", Klptcm1ProPlantStateCurrentVo.class, response); + } + + /** + * 获取当前详细信息 + * + * @param INSDATE 主键 + */ + @GetMapping("/{INSDATE}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Date INSDATE) { + return R.ok(iKlptcm1ProPlantStateCurrentService.queryById(INSDATE)); + } + + /** + * 新增当前 + */ + @Log(title = "当前", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody Klptcm1ProPlantStateCurrentBo bo) { + return toAjax(iKlptcm1ProPlantStateCurrentService.insertByBo(bo)); + } + + /** + * 修改当前 + */ + @Log(title = "当前", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody Klptcm1ProPlantStateCurrentBo bo) { + return toAjax(iKlptcm1ProPlantStateCurrentService.updateByBo(bo)); + } + + /** + * 删除当前 + * + * @param INSDATEs 主键串 + */ + @Log(title = "当前", businessType = BusinessType.DELETE) + @DeleteMapping("/{INSDATEs}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Date[] INSDATEs) { + return toAjax(iKlptcm1ProPlantStateCurrentService.deleteWithValidByIds(Arrays.asList(INSDATEs), true)); + } +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java new file mode 100644 index 00000000..a0a50ce3 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java @@ -0,0 +1,449 @@ +package com.klp.pocket.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; + +/** + * 当前对象 klptcm1_pro_plant_state_current + * + * @author klp + * @date 2025-10-27 + */ +@Data +@TableName("klptcm1_pro_plant_state_current") +public class Klptcm1ProPlantStateCurrent{ + + private static final long serialVersionUID=1L; + + /** + * + */ + private Date INSDATE; + /** + * + */ + private Long YEAR; + /** + * + */ + private Long MONTH; + /** + * + */ + private Long DAY; + /** + * + */ + private Long HOUR; + /** + * + */ + private Long MINUTE; + /** + * + */ + private Long TYPE; + /** + * + */ + private BigDecimal VALUE1; + /** + * + */ + private BigDecimal VALUE2; + /** + * + */ + private BigDecimal VALUE3; + /** + * + */ + private BigDecimal VALUE4; + /** + * + */ + private BigDecimal VALUE5; + /** + * + */ + private BigDecimal VALUE6; + /** + * + */ + private BigDecimal VALUE7; + /** + * + */ + private BigDecimal VALUE8; + /** + * + */ + private BigDecimal VALUE9; + /** + * + */ + private BigDecimal VALUE10; + /** + * + */ + private BigDecimal VALUE11; + /** + * + */ + private BigDecimal VALUE12; + /** + * + */ + private BigDecimal VALUE13; + /** + * + */ + private BigDecimal VALUE14; + /** + * + */ + private BigDecimal VALUE15; + /** + * + */ + private BigDecimal VALUE16; + /** + * + */ + private BigDecimal VALUE17; + /** + * + */ + private BigDecimal VALUE18; + /** + * + */ + private BigDecimal VALUE19; + /** + * + */ + private BigDecimal VALUE20; + /** + * + */ + private BigDecimal VALUE21; + /** + * + */ + private BigDecimal VALUE22; + /** + * + */ + private BigDecimal VALUE23; + /** + * + */ + private BigDecimal VALUE24; + /** + * + */ + private BigDecimal VALUE25; + /** + * + */ + private BigDecimal VALUE26; + /** + * + */ + private BigDecimal VALUE27; + /** + * + */ + private BigDecimal VALUE28; + /** + * + */ + private BigDecimal VALUE29; + /** + * + */ + private BigDecimal VALUE30; + /** + * + */ + private BigDecimal VALUE31; + /** + * + */ + private BigDecimal VALUE32; + /** + * + */ + private BigDecimal VALUE33; + /** + * + */ + private BigDecimal VALUE34; + /** + * + */ + private BigDecimal VALUE35; + /** + * + */ + private BigDecimal VALUE36; + /** + * + */ + private BigDecimal VALUE37; + /** + * + */ + private BigDecimal VALUE38; + /** + * + */ + private BigDecimal VALUE39; + /** + * + */ + private BigDecimal VALUE40; + /** + * + */ + private BigDecimal VALUE41; + /** + * + */ + private BigDecimal VALUE42; + /** + * + */ + private BigDecimal VALUE43; + /** + * + */ + private BigDecimal VALUE44; + /** + * + */ + private BigDecimal VALUE45; + /** + * + */ + private BigDecimal VALUE46; + /** + * + */ + private BigDecimal VALUE47; + /** + * + */ + private BigDecimal VALUE48; + /** + * + */ + private BigDecimal VALUE49; + /** + * + */ + private BigDecimal VALUE50; + /** + * + */ + private BigDecimal VALUE51; + /** + * + */ + private BigDecimal VALUE52; + /** + * + */ + private BigDecimal VALUE53; + /** + * + */ + private BigDecimal VALUE54; + /** + * + */ + private BigDecimal VALUE55; + /** + * + */ + private BigDecimal VALUE56; + /** + * + */ + private BigDecimal VALUE57; + /** + * + */ + private BigDecimal VALUE58; + /** + * + */ + private BigDecimal VALUE59; + /** + * + */ + private BigDecimal VALUE60; + /** + * + */ + private BigDecimal VALUE61; + /** + * + */ + private BigDecimal VALUE62; + /** + * + */ + private BigDecimal VALUE63; + /** + * + */ + private BigDecimal VALUE64; + /** + * + */ + private BigDecimal VALUE65; + /** + * + */ + private BigDecimal VALUE66; + /** + * + */ + private BigDecimal VALUE67; + /** + * + */ + private BigDecimal VALUE68; + /** + * + */ + private BigDecimal VALUE69; + /** + * + */ + private BigDecimal VALUE70; + /** + * + */ + private BigDecimal VALUE71; + /** + * + */ + private BigDecimal VALUE72; + /** + * + */ + private BigDecimal VALUE73; + /** + * + */ + private BigDecimal VALUE74; + /** + * + */ + private BigDecimal VALUE75; + /** + * + */ + private BigDecimal VALUE76; + /** + * + */ + private BigDecimal VALUE77; + /** + * + */ + private BigDecimal VALUE78; + /** + * + */ + private BigDecimal VALUE79; + /** + * + */ + private BigDecimal VALUE80; + /** + * + */ + private BigDecimal VALUE81; + /** + * + */ + private BigDecimal VALUE82; + /** + * + */ + private BigDecimal VALUE83; + /** + * + */ + private BigDecimal VALUE84; + /** + * + */ + private BigDecimal VALUE85; + /** + * + */ + private BigDecimal VALUE86; + /** + * + */ + private BigDecimal VALUE87; + /** + * + */ + private BigDecimal VALUE88; + /** + * + */ + private BigDecimal VALUE89; + /** + * + */ + private BigDecimal VALUE90; + /** + * + */ + private BigDecimal VALUE91; + /** + * + */ + private BigDecimal VALUE92; + /** + * + */ + private BigDecimal VALUE93; + /** + * + */ + private BigDecimal VALUE94; + /** + * + */ + private BigDecimal VALUE95; + /** + * + */ + private BigDecimal VALUE96; + /** + * + */ + private BigDecimal VALUE97; + /** + * + */ + private BigDecimal VALUE98; + /** + * + */ + private BigDecimal VALUE99; + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProPlantStateCurrentBo.java b/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProPlantStateCurrentBo.java new file mode 100644 index 00000000..6b754760 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProPlantStateCurrentBo.java @@ -0,0 +1,554 @@ +package com.klp.pocket.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; + +/** + * 当前业务对象 klptcm1_pro_plant_state_current + * + * @author klp + * @date 2025-10-27 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class Klptcm1ProPlantStateCurrentBo extends BaseEntity { + + /** + * + */ + private Date INSDATE; + + /** + * + */ + private Long YEAR; + + /** + * + */ + private Long MONTH; + + /** + * + */ + private Long DAY; + + /** + * + */ + private Long HOUR; + + /** + * + */ + private Long MINUTE; + + /** + * + */ + private Long TYPE; + + /** + * + */ + private BigDecimal VALUE1; + + /** + * + */ + private BigDecimal VALUE2; + + /** + * + */ + private BigDecimal VALUE3; + + /** + * + */ + private BigDecimal VALUE4; + + /** + * + */ + private BigDecimal VALUE5; + + /** + * + */ + private BigDecimal VALUE6; + + /** + * + */ + private BigDecimal VALUE7; + + /** + * + */ + private BigDecimal VALUE8; + + /** + * + */ + private BigDecimal VALUE9; + + /** + * + */ + private BigDecimal VALUE10; + + /** + * + */ + private BigDecimal VALUE11; + + /** + * + */ + private BigDecimal VALUE12; + + /** + * + */ + private BigDecimal VALUE13; + + /** + * + */ + private BigDecimal VALUE14; + + /** + * + */ + private BigDecimal VALUE15; + + /** + * + */ + private BigDecimal VALUE16; + + /** + * + */ + private BigDecimal VALUE17; + + /** + * + */ + private BigDecimal VALUE18; + + /** + * + */ + private BigDecimal VALUE19; + + /** + * + */ + private BigDecimal VALUE20; + + /** + * + */ + private BigDecimal VALUE21; + + /** + * + */ + private BigDecimal VALUE22; + + /** + * + */ + private BigDecimal VALUE23; + + /** + * + */ + private BigDecimal VALUE24; + + /** + * + */ + private BigDecimal VALUE25; + + /** + * + */ + private BigDecimal VALUE26; + + /** + * + */ + private BigDecimal VALUE27; + + /** + * + */ + private BigDecimal VALUE28; + + /** + * + */ + private BigDecimal VALUE29; + + /** + * + */ + private BigDecimal VALUE30; + + /** + * + */ + private BigDecimal VALUE31; + + /** + * + */ + private BigDecimal VALUE32; + + /** + * + */ + private BigDecimal VALUE33; + + /** + * + */ + private BigDecimal VALUE34; + + /** + * + */ + private BigDecimal VALUE35; + + /** + * + */ + private BigDecimal VALUE36; + + /** + * + */ + private BigDecimal VALUE37; + + /** + * + */ + private BigDecimal VALUE38; + + /** + * + */ + private BigDecimal VALUE39; + + /** + * + */ + private BigDecimal VALUE40; + + /** + * + */ + private BigDecimal VALUE41; + + /** + * + */ + private BigDecimal VALUE42; + + /** + * + */ + private BigDecimal VALUE43; + + /** + * + */ + private BigDecimal VALUE44; + + /** + * + */ + private BigDecimal VALUE45; + + /** + * + */ + private BigDecimal VALUE46; + + /** + * + */ + private BigDecimal VALUE47; + + /** + * + */ + private BigDecimal VALUE48; + + /** + * + */ + private BigDecimal VALUE49; + + /** + * + */ + private BigDecimal VALUE50; + + /** + * + */ + private BigDecimal VALUE51; + + /** + * + */ + private BigDecimal VALUE52; + + /** + * + */ + private BigDecimal VALUE53; + + /** + * + */ + private BigDecimal VALUE54; + + /** + * + */ + private BigDecimal VALUE55; + + /** + * + */ + private BigDecimal VALUE56; + + /** + * + */ + private BigDecimal VALUE57; + + /** + * + */ + private BigDecimal VALUE58; + + /** + * + */ + private BigDecimal VALUE59; + + /** + * + */ + private BigDecimal VALUE60; + + /** + * + */ + private BigDecimal VALUE61; + + /** + * + */ + private BigDecimal VALUE62; + + /** + * + */ + private BigDecimal VALUE63; + + /** + * + */ + private BigDecimal VALUE64; + + /** + * + */ + private BigDecimal VALUE65; + + /** + * + */ + private BigDecimal VALUE66; + + /** + * + */ + private BigDecimal VALUE67; + + /** + * + */ + private BigDecimal VALUE68; + + /** + * + */ + private BigDecimal VALUE69; + + /** + * + */ + private BigDecimal VALUE70; + + /** + * + */ + private BigDecimal VALUE71; + + /** + * + */ + private BigDecimal VALUE72; + + /** + * + */ + private BigDecimal VALUE73; + + /** + * + */ + private BigDecimal VALUE74; + + /** + * + */ + private BigDecimal VALUE75; + + /** + * + */ + private BigDecimal VALUE76; + + /** + * + */ + private BigDecimal VALUE77; + + /** + * + */ + private BigDecimal VALUE78; + + /** + * + */ + private BigDecimal VALUE79; + + /** + * + */ + private BigDecimal VALUE80; + + /** + * + */ + private BigDecimal VALUE81; + + /** + * + */ + private BigDecimal VALUE82; + + /** + * + */ + private BigDecimal VALUE83; + + /** + * + */ + private BigDecimal VALUE84; + + /** + * + */ + private BigDecimal VALUE85; + + /** + * + */ + private BigDecimal VALUE86; + + /** + * + */ + private BigDecimal VALUE87; + + /** + * + */ + private BigDecimal VALUE88; + + /** + * + */ + private BigDecimal VALUE89; + + /** + * + */ + private BigDecimal VALUE90; + + /** + * + */ + private BigDecimal VALUE91; + + /** + * + */ + private BigDecimal VALUE92; + + /** + * + */ + private BigDecimal VALUE93; + + /** + * + */ + private BigDecimal VALUE94; + + /** + * + */ + private BigDecimal VALUE95; + + /** + * + */ + private BigDecimal VALUE96; + + /** + * + */ + private BigDecimal VALUE97; + + /** + * + */ + private BigDecimal VALUE98; + + /** + * + */ + private BigDecimal VALUE99; + + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateCurrentVo.java b/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateCurrentVo.java new file mode 100644 index 00000000..28d98742 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateCurrentVo.java @@ -0,0 +1,662 @@ +package com.klp.pocket.domain.vo; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 当前视图对象 klptcm1_pro_plant_state_current + * + * @author klp + * @date 2025-10-27 + */ +@Data +@ExcelIgnoreUnannotated +public class Klptcm1ProPlantStateCurrentVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Date INSDATE; + + /** + * + */ + @ExcelProperty(value = "") + private Long YEAR; + + /** + * + */ + @ExcelProperty(value = "") + private Long MONTH; + + /** + * + */ + @ExcelProperty(value = "") + private Long DAY; + + /** + * + */ + @ExcelProperty(value = "") + private Long HOUR; + + /** + * + */ + @ExcelProperty(value = "") + private Long MINUTE; + + /** + * + */ + @ExcelProperty(value = "") + private Long TYPE; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE1; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE2; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE3; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE4; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE5; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE6; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE7; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE8; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE9; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE10; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE11; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE12; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE13; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE14; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE15; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE16; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE17; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE18; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE19; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE20; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE21; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE22; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE23; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE24; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE25; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE26; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE27; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE28; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE29; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE30; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE31; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE32; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE33; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE34; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE35; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE36; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE37; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE38; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE39; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE40; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE41; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE42; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE43; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE44; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE45; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE46; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE47; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE48; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE49; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE50; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE51; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE52; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE53; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE54; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE55; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE56; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE57; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE58; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE59; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE60; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE61; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE62; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE63; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE64; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE65; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE66; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE67; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE68; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE69; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE70; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE71; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE72; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE73; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE74; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE75; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE76; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE77; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE78; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE79; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE80; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE81; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE82; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE83; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE84; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE85; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE86; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE87; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE88; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE89; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE90; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE91; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE92; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE93; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE94; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE95; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE96; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE97; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE98; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal VALUE99; + + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java new file mode 100644 index 00000000..4d3de788 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java @@ -0,0 +1,15 @@ +package com.klp.pocket.mapper; + +import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; +import com.klp.pocket.domain.vo.Klptcm1ProPlantStateCurrentVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 当前Mapper接口 + * + * @author klp + * @date 2025-10-27 + */ +public interface Klptcm1ProPlantStateCurrentMapper extends BaseMapperPlus { + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java new file mode 100644 index 00000000..7c9beb9f --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java @@ -0,0 +1,49 @@ +package com.klp.pocket.service; + +import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; +import com.klp.pocket.domain.vo.Klptcm1ProPlantStateCurrentVo; +import com.klp.pocket.domain.bo.Klptcm1ProPlantStateCurrentBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 当前Service接口 + * + * @author klp + * @date 2025-10-27 + */ +public interface IKlptcm1ProPlantStateCurrentService { + + /** + * 查询当前 + */ + Klptcm1ProPlantStateCurrentVo queryById(Date INSDATE); + + /** + * 查询当前列表 + */ + TableDataInfo queryPageList(Klptcm1ProPlantStateCurrentBo bo, PageQuery pageQuery); + + /** + * 查询当前列表 + */ + List queryList(Klptcm1ProPlantStateCurrentBo bo); + + /** + * 新增当前 + */ + Boolean insertByBo(Klptcm1ProPlantStateCurrentBo bo); + + /** + * 修改当前 + */ + Boolean updateByBo(Klptcm1ProPlantStateCurrentBo bo); + + /** + * 校验并批量删除当前信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java new file mode 100644 index 00000000..17df3259 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java @@ -0,0 +1,213 @@ +package com.klp.pocket.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pocket.domain.bo.Klptcm1ProPlantStateCurrentBo; +import com.klp.pocket.domain.vo.Klptcm1ProPlantStateCurrentVo; +import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; +import com.klp.pocket.mapper.Klptcm1ProPlantStateCurrentMapper; +import com.klp.pocket.service.IKlptcm1ProPlantStateCurrentService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 当前Service业务层处理 + * + * @author klp + * @date 2025-10-27 + */ +@RequiredArgsConstructor +@Service +public class Klptcm1ProPlantStateCurrentServiceImpl implements IKlptcm1ProPlantStateCurrentService { + + private final Klptcm1ProPlantStateCurrentMapper baseMapper; + + /** + * 查询当前 + */ + @Override + public Klptcm1ProPlantStateCurrentVo queryById(Date INSDATE){ + return baseMapper.selectVoById(INSDATE); + } + + /** + * 查询当前列表 + */ + @Override + public TableDataInfo queryPageList(Klptcm1ProPlantStateCurrentBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询当前列表 + */ + @Override + public List queryList(Klptcm1ProPlantStateCurrentBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(Klptcm1ProPlantStateCurrentBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getINSDATE() != null, Klptcm1ProPlantStateCurrent::getINSDATE, bo.getINSDATE()); + lqw.eq(bo.getYEAR() != null, Klptcm1ProPlantStateCurrent::getYEAR, bo.getYEAR()); + lqw.eq(bo.getMONTH() != null, Klptcm1ProPlantStateCurrent::getMONTH, bo.getMONTH()); + lqw.eq(bo.getDAY() != null, Klptcm1ProPlantStateCurrent::getDAY, bo.getDAY()); + lqw.eq(bo.getHOUR() != null, Klptcm1ProPlantStateCurrent::getHOUR, bo.getHOUR()); + lqw.eq(bo.getMINUTE() != null, Klptcm1ProPlantStateCurrent::getMINUTE, bo.getMINUTE()); + lqw.eq(bo.getTYPE() != null, Klptcm1ProPlantStateCurrent::getTYPE, bo.getTYPE()); + lqw.eq(bo.getVALUE1() != null, Klptcm1ProPlantStateCurrent::getVALUE1, bo.getVALUE1()); + lqw.eq(bo.getVALUE2() != null, Klptcm1ProPlantStateCurrent::getVALUE2, bo.getVALUE2()); + lqw.eq(bo.getVALUE3() != null, Klptcm1ProPlantStateCurrent::getVALUE3, bo.getVALUE3()); + lqw.eq(bo.getVALUE4() != null, Klptcm1ProPlantStateCurrent::getVALUE4, bo.getVALUE4()); + lqw.eq(bo.getVALUE5() != null, Klptcm1ProPlantStateCurrent::getVALUE5, bo.getVALUE5()); + lqw.eq(bo.getVALUE6() != null, Klptcm1ProPlantStateCurrent::getVALUE6, bo.getVALUE6()); + lqw.eq(bo.getVALUE7() != null, Klptcm1ProPlantStateCurrent::getVALUE7, bo.getVALUE7()); + lqw.eq(bo.getVALUE8() != null, Klptcm1ProPlantStateCurrent::getVALUE8, bo.getVALUE8()); + lqw.eq(bo.getVALUE9() != null, Klptcm1ProPlantStateCurrent::getVALUE9, bo.getVALUE9()); + lqw.eq(bo.getVALUE10() != null, Klptcm1ProPlantStateCurrent::getVALUE10, bo.getVALUE10()); + lqw.eq(bo.getVALUE11() != null, Klptcm1ProPlantStateCurrent::getVALUE11, bo.getVALUE11()); + lqw.eq(bo.getVALUE12() != null, Klptcm1ProPlantStateCurrent::getVALUE12, bo.getVALUE12()); + lqw.eq(bo.getVALUE13() != null, Klptcm1ProPlantStateCurrent::getVALUE13, bo.getVALUE13()); + lqw.eq(bo.getVALUE14() != null, Klptcm1ProPlantStateCurrent::getVALUE14, bo.getVALUE14()); + lqw.eq(bo.getVALUE15() != null, Klptcm1ProPlantStateCurrent::getVALUE15, bo.getVALUE15()); + lqw.eq(bo.getVALUE16() != null, Klptcm1ProPlantStateCurrent::getVALUE16, bo.getVALUE16()); + lqw.eq(bo.getVALUE17() != null, Klptcm1ProPlantStateCurrent::getVALUE17, bo.getVALUE17()); + lqw.eq(bo.getVALUE18() != null, Klptcm1ProPlantStateCurrent::getVALUE18, bo.getVALUE18()); + lqw.eq(bo.getVALUE19() != null, Klptcm1ProPlantStateCurrent::getVALUE19, bo.getVALUE19()); + lqw.eq(bo.getVALUE20() != null, Klptcm1ProPlantStateCurrent::getVALUE20, bo.getVALUE20()); + lqw.eq(bo.getVALUE21() != null, Klptcm1ProPlantStateCurrent::getVALUE21, bo.getVALUE21()); + lqw.eq(bo.getVALUE22() != null, Klptcm1ProPlantStateCurrent::getVALUE22, bo.getVALUE22()); + lqw.eq(bo.getVALUE23() != null, Klptcm1ProPlantStateCurrent::getVALUE23, bo.getVALUE23()); + lqw.eq(bo.getVALUE24() != null, Klptcm1ProPlantStateCurrent::getVALUE24, bo.getVALUE24()); + lqw.eq(bo.getVALUE25() != null, Klptcm1ProPlantStateCurrent::getVALUE25, bo.getVALUE25()); + lqw.eq(bo.getVALUE26() != null, Klptcm1ProPlantStateCurrent::getVALUE26, bo.getVALUE26()); + lqw.eq(bo.getVALUE27() != null, Klptcm1ProPlantStateCurrent::getVALUE27, bo.getVALUE27()); + lqw.eq(bo.getVALUE28() != null, Klptcm1ProPlantStateCurrent::getVALUE28, bo.getVALUE28()); + lqw.eq(bo.getVALUE29() != null, Klptcm1ProPlantStateCurrent::getVALUE29, bo.getVALUE29()); + lqw.eq(bo.getVALUE30() != null, Klptcm1ProPlantStateCurrent::getVALUE30, bo.getVALUE30()); + lqw.eq(bo.getVALUE31() != null, Klptcm1ProPlantStateCurrent::getVALUE31, bo.getVALUE31()); + lqw.eq(bo.getVALUE32() != null, Klptcm1ProPlantStateCurrent::getVALUE32, bo.getVALUE32()); + lqw.eq(bo.getVALUE33() != null, Klptcm1ProPlantStateCurrent::getVALUE33, bo.getVALUE33()); + lqw.eq(bo.getVALUE34() != null, Klptcm1ProPlantStateCurrent::getVALUE34, bo.getVALUE34()); + lqw.eq(bo.getVALUE35() != null, Klptcm1ProPlantStateCurrent::getVALUE35, bo.getVALUE35()); + lqw.eq(bo.getVALUE36() != null, Klptcm1ProPlantStateCurrent::getVALUE36, bo.getVALUE36()); + lqw.eq(bo.getVALUE37() != null, Klptcm1ProPlantStateCurrent::getVALUE37, bo.getVALUE37()); + lqw.eq(bo.getVALUE38() != null, Klptcm1ProPlantStateCurrent::getVALUE38, bo.getVALUE38()); + lqw.eq(bo.getVALUE39() != null, Klptcm1ProPlantStateCurrent::getVALUE39, bo.getVALUE39()); + lqw.eq(bo.getVALUE40() != null, Klptcm1ProPlantStateCurrent::getVALUE40, bo.getVALUE40()); + lqw.eq(bo.getVALUE41() != null, Klptcm1ProPlantStateCurrent::getVALUE41, bo.getVALUE41()); + lqw.eq(bo.getVALUE42() != null, Klptcm1ProPlantStateCurrent::getVALUE42, bo.getVALUE42()); + lqw.eq(bo.getVALUE43() != null, Klptcm1ProPlantStateCurrent::getVALUE43, bo.getVALUE43()); + lqw.eq(bo.getVALUE44() != null, Klptcm1ProPlantStateCurrent::getVALUE44, bo.getVALUE44()); + lqw.eq(bo.getVALUE45() != null, Klptcm1ProPlantStateCurrent::getVALUE45, bo.getVALUE45()); + lqw.eq(bo.getVALUE46() != null, Klptcm1ProPlantStateCurrent::getVALUE46, bo.getVALUE46()); + lqw.eq(bo.getVALUE47() != null, Klptcm1ProPlantStateCurrent::getVALUE47, bo.getVALUE47()); + lqw.eq(bo.getVALUE48() != null, Klptcm1ProPlantStateCurrent::getVALUE48, bo.getVALUE48()); + lqw.eq(bo.getVALUE49() != null, Klptcm1ProPlantStateCurrent::getVALUE49, bo.getVALUE49()); + lqw.eq(bo.getVALUE50() != null, Klptcm1ProPlantStateCurrent::getVALUE50, bo.getVALUE50()); + lqw.eq(bo.getVALUE51() != null, Klptcm1ProPlantStateCurrent::getVALUE51, bo.getVALUE51()); + lqw.eq(bo.getVALUE52() != null, Klptcm1ProPlantStateCurrent::getVALUE52, bo.getVALUE52()); + lqw.eq(bo.getVALUE53() != null, Klptcm1ProPlantStateCurrent::getVALUE53, bo.getVALUE53()); + lqw.eq(bo.getVALUE54() != null, Klptcm1ProPlantStateCurrent::getVALUE54, bo.getVALUE54()); + lqw.eq(bo.getVALUE55() != null, Klptcm1ProPlantStateCurrent::getVALUE55, bo.getVALUE55()); + lqw.eq(bo.getVALUE56() != null, Klptcm1ProPlantStateCurrent::getVALUE56, bo.getVALUE56()); + lqw.eq(bo.getVALUE57() != null, Klptcm1ProPlantStateCurrent::getVALUE57, bo.getVALUE57()); + lqw.eq(bo.getVALUE58() != null, Klptcm1ProPlantStateCurrent::getVALUE58, bo.getVALUE58()); + lqw.eq(bo.getVALUE59() != null, Klptcm1ProPlantStateCurrent::getVALUE59, bo.getVALUE59()); + lqw.eq(bo.getVALUE60() != null, Klptcm1ProPlantStateCurrent::getVALUE60, bo.getVALUE60()); + lqw.eq(bo.getVALUE61() != null, Klptcm1ProPlantStateCurrent::getVALUE61, bo.getVALUE61()); + lqw.eq(bo.getVALUE62() != null, Klptcm1ProPlantStateCurrent::getVALUE62, bo.getVALUE62()); + lqw.eq(bo.getVALUE63() != null, Klptcm1ProPlantStateCurrent::getVALUE63, bo.getVALUE63()); + lqw.eq(bo.getVALUE64() != null, Klptcm1ProPlantStateCurrent::getVALUE64, bo.getVALUE64()); + lqw.eq(bo.getVALUE65() != null, Klptcm1ProPlantStateCurrent::getVALUE65, bo.getVALUE65()); + lqw.eq(bo.getVALUE66() != null, Klptcm1ProPlantStateCurrent::getVALUE66, bo.getVALUE66()); + lqw.eq(bo.getVALUE67() != null, Klptcm1ProPlantStateCurrent::getVALUE67, bo.getVALUE67()); + lqw.eq(bo.getVALUE68() != null, Klptcm1ProPlantStateCurrent::getVALUE68, bo.getVALUE68()); + lqw.eq(bo.getVALUE69() != null, Klptcm1ProPlantStateCurrent::getVALUE69, bo.getVALUE69()); + lqw.eq(bo.getVALUE70() != null, Klptcm1ProPlantStateCurrent::getVALUE70, bo.getVALUE70()); + lqw.eq(bo.getVALUE71() != null, Klptcm1ProPlantStateCurrent::getVALUE71, bo.getVALUE71()); + lqw.eq(bo.getVALUE72() != null, Klptcm1ProPlantStateCurrent::getVALUE72, bo.getVALUE72()); + lqw.eq(bo.getVALUE73() != null, Klptcm1ProPlantStateCurrent::getVALUE73, bo.getVALUE73()); + lqw.eq(bo.getVALUE74() != null, Klptcm1ProPlantStateCurrent::getVALUE74, bo.getVALUE74()); + lqw.eq(bo.getVALUE75() != null, Klptcm1ProPlantStateCurrent::getVALUE75, bo.getVALUE75()); + lqw.eq(bo.getVALUE76() != null, Klptcm1ProPlantStateCurrent::getVALUE76, bo.getVALUE76()); + lqw.eq(bo.getVALUE77() != null, Klptcm1ProPlantStateCurrent::getVALUE77, bo.getVALUE77()); + lqw.eq(bo.getVALUE78() != null, Klptcm1ProPlantStateCurrent::getVALUE78, bo.getVALUE78()); + lqw.eq(bo.getVALUE79() != null, Klptcm1ProPlantStateCurrent::getVALUE79, bo.getVALUE79()); + lqw.eq(bo.getVALUE80() != null, Klptcm1ProPlantStateCurrent::getVALUE80, bo.getVALUE80()); + lqw.eq(bo.getVALUE81() != null, Klptcm1ProPlantStateCurrent::getVALUE81, bo.getVALUE81()); + lqw.eq(bo.getVALUE82() != null, Klptcm1ProPlantStateCurrent::getVALUE82, bo.getVALUE82()); + lqw.eq(bo.getVALUE83() != null, Klptcm1ProPlantStateCurrent::getVALUE83, bo.getVALUE83()); + lqw.eq(bo.getVALUE84() != null, Klptcm1ProPlantStateCurrent::getVALUE84, bo.getVALUE84()); + lqw.eq(bo.getVALUE85() != null, Klptcm1ProPlantStateCurrent::getVALUE85, bo.getVALUE85()); + lqw.eq(bo.getVALUE86() != null, Klptcm1ProPlantStateCurrent::getVALUE86, bo.getVALUE86()); + lqw.eq(bo.getVALUE87() != null, Klptcm1ProPlantStateCurrent::getVALUE87, bo.getVALUE87()); + lqw.eq(bo.getVALUE88() != null, Klptcm1ProPlantStateCurrent::getVALUE88, bo.getVALUE88()); + lqw.eq(bo.getVALUE89() != null, Klptcm1ProPlantStateCurrent::getVALUE89, bo.getVALUE89()); + lqw.eq(bo.getVALUE90() != null, Klptcm1ProPlantStateCurrent::getVALUE90, bo.getVALUE90()); + lqw.eq(bo.getVALUE91() != null, Klptcm1ProPlantStateCurrent::getVALUE91, bo.getVALUE91()); + lqw.eq(bo.getVALUE92() != null, Klptcm1ProPlantStateCurrent::getVALUE92, bo.getVALUE92()); + lqw.eq(bo.getVALUE93() != null, Klptcm1ProPlantStateCurrent::getVALUE93, bo.getVALUE93()); + lqw.eq(bo.getVALUE94() != null, Klptcm1ProPlantStateCurrent::getVALUE94, bo.getVALUE94()); + lqw.eq(bo.getVALUE95() != null, Klptcm1ProPlantStateCurrent::getVALUE95, bo.getVALUE95()); + lqw.eq(bo.getVALUE96() != null, Klptcm1ProPlantStateCurrent::getVALUE96, bo.getVALUE96()); + lqw.eq(bo.getVALUE97() != null, Klptcm1ProPlantStateCurrent::getVALUE97, bo.getVALUE97()); + lqw.eq(bo.getVALUE98() != null, Klptcm1ProPlantStateCurrent::getVALUE98, bo.getVALUE98()); + lqw.eq(bo.getVALUE99() != null, Klptcm1ProPlantStateCurrent::getVALUE99, bo.getVALUE99()); + return lqw; + } + + /** + * 新增当前 + */ + @Override + public Boolean insertByBo(Klptcm1ProPlantStateCurrentBo bo) { + Klptcm1ProPlantStateCurrent add = BeanUtil.toBean(bo, Klptcm1ProPlantStateCurrent.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setINSDATE(add.getINSDATE()); + } + return flag; + } + + /** + * 修改当前 + */ + @Override + public Boolean updateByBo(Klptcm1ProPlantStateCurrentBo bo) { + Klptcm1ProPlantStateCurrent update = BeanUtil.toBean(bo, Klptcm1ProPlantStateCurrent.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(Klptcm1ProPlantStateCurrent entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除当前 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml new file mode 100644 index 00000000..c64b367c --- /dev/null +++ b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pom.xml b/pom.xml index 43fb2d13..8da9bd38 100644 --- a/pom.xml +++ b/pom.xml @@ -381,6 +381,11 @@ klp-ems ${klp-flowable-plus.version} + + com.klp + klp-pocket + ${klp-flowable-plus.version} + @@ -402,6 +407,7 @@ klp-reader klp-mes klp-ems + klp-pocket pom From 8d110a45573fd6b70a43184108e26fa5eb363e6a Mon Sep 17 00:00:00 2001 From: JR <3573153686@qq.com> Date: Mon, 27 Oct 2025 15:19:58 +0800 Subject: [PATCH 3/7] =?UTF-8?q?feat(admin):=20=E6=B7=BB=E5=8A=A0klp-pocket?= =?UTF-8?q?=E4=BE=9D=E8=B5=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 在pom.xml中引入klp-pocket模块依赖 - 支持后续功能集成开发需求 --- klp-admin/pom.xml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/klp-admin/pom.xml b/klp-admin/pom.xml index 86d13aaa..3bdfdcd5 100644 --- a/klp-admin/pom.xml +++ b/klp-admin/pom.xml @@ -100,6 +100,11 @@ klp-mes + + com.klp + klp-pocket + + com.klp From 6ff235d56da6e60fbf8fd4281c99ba685bc2e548 Mon Sep 17 00:00:00 2001 From: Joshi <3040996759@qq.com> Date: Mon, 27 Oct 2025 17:23:52 +0800 Subject: [PATCH 4/7] =?UTF-8?q?refactor(service):=20=E7=AE=80=E5=8C=96?= =?UTF-8?q?=E5=BD=93=E5=89=8D=E7=8A=B6=E6=80=81=E6=9C=8D=E5=8A=A1=E6=8E=A5?= =?UTF-8?q?=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 移除冗余的查询、分页和删除方法 -保留核心方法 selectAll用于获取全部数据 - 清理导入包和注释，优化代码结构 --- klp-common/pom.xml | 7 + ...Klptcm1ProPlantStateCurrentController.java | 102 +--- .../domain/Klptcm1ProPlantStateCurrent.java | 452 +----------------- .../Klptcm1ProPlantStateCurrentMapper.java | 15 +- .../IKlptcm1ProPlantStateCurrentService.java | 41 +- ...lptcm1ProPlantStateCurrentServiceImpl.java | 207 +------- .../Klptcm1ProPlantStateCurrentMapper.xml | 137 +----- 7 files changed, 74 insertions(+), 887 deletions(-) diff --git a/klp-common/pom.xml b/klp-common/pom.xml index fdfa8f0e..1a02b0a9 100644 --- a/klp-common/pom.xml +++ b/klp-common/pom.xml @@ -180,6 +180,13 @@ org.flywaydb flyway-mysql + + + com.baomidou + dynamic-datasource-spring-boot-starter + 3.5.2 + + diff --git a/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java index 06f19a47..e6b79103 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java +++ b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java @@ -1,102 +1,26 @@ package com.klp.pocket.controller; - -import java.util.Date; -import java.util.List; -import java.util.Arrays; - - -import lombok.RequiredArgsConstructor; -import javax.servlet.http.HttpServletResponse; -import javax.validation.constraints.*; -import org.springframework.web.bind.annotation.*; -import org.springframework.validation.annotation.Validated; -import com.klp.common.annotation.RepeatSubmit; -import com.klp.common.annotation.Log; -import com.klp.common.core.controller.BaseController; -import com.klp.common.core.domain.PageQuery; import com.klp.common.core.domain.R; -import com.klp.common.core.validate.AddGroup; -import com.klp.common.core.validate.EditGroup; -import com.klp.common.enums.BusinessType; -import com.klp.common.utils.poi.ExcelUtil; -import com.klp.pocket.domain.vo.Klptcm1ProPlantStateCurrentVo; -import com.klp.pocket.domain.bo.Klptcm1ProPlantStateCurrentBo; +import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; import com.klp.pocket.service.IKlptcm1ProPlantStateCurrentService; -import com.klp.common.core.page.TableDataInfo; +import org.springframework.web.bind.annotation.*; +import javax.annotation.Resource; +import java.util.List; -/** - * 当前 - * - * @author klp - * @date 2025-10-27 - */ -@Validated -@RequiredArgsConstructor @RestController -@RequestMapping("/pocket/proPlantStateCurrent") -public class Klptcm1ProPlantStateCurrentController extends BaseController { +@RequestMapping("/api/klptcm1ProPlantStateCurrent") +public class Klptcm1ProPlantStateCurrentController { - private final IKlptcm1ProPlantStateCurrentService iKlptcm1ProPlantStateCurrentService; + @Resource + private IKlptcm1ProPlantStateCurrentService klptcm1ProPlantStateCurrentService; /** - * 查询当前列表 + * 查询所有数据 */ - @GetMapping("/list") - public TableDataInfo list(Klptcm1ProPlantStateCurrentBo bo, PageQuery pageQuery) { - return iKlptcm1ProPlantStateCurrentService.queryPageList(bo, pageQuery); + @GetMapping("/selectAll") + public R> selectAll() { + List result = klptcm1ProPlantStateCurrentService.selectAll(); + return R.ok(result); } - /** - * 导出当前列表 - */ - @Log(title = "当前", businessType = BusinessType.EXPORT) - @PostMapping("/export") - public void export(Klptcm1ProPlantStateCurrentBo bo, HttpServletResponse response) { - List list = iKlptcm1ProPlantStateCurrentService.queryList(bo); - ExcelUtil.exportExcel(list, "当前", Klptcm1ProPlantStateCurrentVo.class, response); - } - - /** - * 获取当前详细信息 - * - * @param INSDATE 主键 - */ - @GetMapping("/{INSDATE}") - public R getInfo(@NotNull(message = "主键不能为空") - @PathVariable Date INSDATE) { - return R.ok(iKlptcm1ProPlantStateCurrentService.queryById(INSDATE)); - } - - /** - * 新增当前 - */ - @Log(title = "当前", businessType = BusinessType.INSERT) - @RepeatSubmit() - @PostMapping() - public R add(@Validated(AddGroup.class) @RequestBody Klptcm1ProPlantStateCurrentBo bo) { - return toAjax(iKlptcm1ProPlantStateCurrentService.insertByBo(bo)); - } - - /** - * 修改当前 - */ - @Log(title = "当前", businessType = BusinessType.UPDATE) - @RepeatSubmit() - @PutMapping() - public R edit(@Validated(EditGroup.class) @RequestBody Klptcm1ProPlantStateCurrentBo bo) { - return toAjax(iKlptcm1ProPlantStateCurrentService.updateByBo(bo)); - } - - /** - * 删除当前 - * - * @param INSDATEs 主键串 - */ - @Log(title = "当前", businessType = BusinessType.DELETE) - @DeleteMapping("/{INSDATEs}") - public R remove(@NotEmpty(message = "主键不能为空") - @PathVariable Date[] INSDATEs) { - return toAjax(iKlptcm1ProPlantStateCurrentService.deleteWithValidByIds(Arrays.asList(INSDATEs), true)); - } } diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java index a0a50ce3..fa3b95f9 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java @@ -1,449 +1,23 @@ package com.klp.pocket.domain; -import com.baomidou.mybatisplus.annotation.*; -import com.klp.common.core.domain.BaseEntity; import lombok.Data; -import lombok.EqualsAndHashCode; import java.math.BigDecimal; import java.util.Date; -import com.fasterxml.jackson.annotation.JsonFormat; -/** - * 当前对象 klptcm1_pro_plant_state_current - * - * @author klp - * @date 2025-10-27 - */ @Data -@TableName("klptcm1_pro_plant_state_current") -public class Klptcm1ProPlantStateCurrent{ - - private static final long serialVersionUID=1L; - - /** - * - */ - private Date INSDATE; - /** - * - */ - private Long YEAR; - /** - * - */ - private Long MONTH; - /** - * - */ - private Long DAY; - /** - * - */ - private Long HOUR; - /** - * - */ - private Long MINUTE; - /** - * - */ - private Long TYPE; - /** - * - */ - private BigDecimal VALUE1; - /** - * - */ - private BigDecimal VALUE2; - /** - * - */ - private BigDecimal VALUE3; - /** - * - */ - private BigDecimal VALUE4; - /** - * - */ - private BigDecimal VALUE5; - /** - * - */ - private BigDecimal VALUE6; - /** - * - */ - private BigDecimal VALUE7; - /** - * - */ - private BigDecimal VALUE8; - /** - * - */ - private BigDecimal VALUE9; - /** - * - */ - private BigDecimal VALUE10; - /** - * - */ - private BigDecimal VALUE11; - /** - * - */ - private BigDecimal VALUE12; - /** - * - */ - private BigDecimal VALUE13; - /** - * - */ - private BigDecimal VALUE14; - /** - * - */ - private BigDecimal VALUE15; - /** - * - */ - private BigDecimal VALUE16; - /** - * - */ - private BigDecimal VALUE17; - /** - * - */ - private BigDecimal VALUE18; - /** - * - */ - private BigDecimal VALUE19; - /** - * - */ - private BigDecimal VALUE20; - /** - * - */ - private BigDecimal VALUE21; - /** - * - */ - private BigDecimal VALUE22; - /** - * - */ - private BigDecimal VALUE23; - /** - * - */ - private BigDecimal VALUE24; - /** - * - */ - private BigDecimal VALUE25; - /** - * - */ - private BigDecimal VALUE26; - /** - * - */ - private BigDecimal VALUE27; - /** - * - */ - private BigDecimal VALUE28; - /** - * - */ - private BigDecimal VALUE29; - /** - * - */ - private BigDecimal VALUE30; - /** - * - */ - private BigDecimal VALUE31; - /** - * - */ - private BigDecimal VALUE32; - /** - * - */ - private BigDecimal VALUE33; - /** - * - */ - private BigDecimal VALUE34; - /** - * - */ - private BigDecimal VALUE35; - /** - * - */ - private BigDecimal VALUE36; - /** - * - */ - private BigDecimal VALUE37; - /** - * - */ - private BigDecimal VALUE38; - /** - * - */ - private BigDecimal VALUE39; - /** - * - */ - private BigDecimal VALUE40; - /** - * - */ - private BigDecimal VALUE41; - /** - * - */ - private BigDecimal VALUE42; - /** - * - */ - private BigDecimal VALUE43; - /** - * - */ - private BigDecimal VALUE44; - /** - * - */ - private BigDecimal VALUE45; - /** - * - */ - private BigDecimal VALUE46; - /** - * - */ - private BigDecimal VALUE47; - /** - * - */ - private BigDecimal VALUE48; - /** - * - */ - private BigDecimal VALUE49; - /** - * - */ - private BigDecimal VALUE50; - /** - * - */ - private BigDecimal VALUE51; - /** - * - */ - private BigDecimal VALUE52; - /** - * - */ - private BigDecimal VALUE53; - /** - * - */ - private BigDecimal VALUE54; - /** - * - */ - private BigDecimal VALUE55; - /** - * - */ - private BigDecimal VALUE56; - /** - * - */ - private BigDecimal VALUE57; - /** - * - */ - private BigDecimal VALUE58; - /** - * - */ - private BigDecimal VALUE59; - /** - * - */ - private BigDecimal VALUE60; - /** - * - */ - private BigDecimal VALUE61; - /** - * - */ - private BigDecimal VALUE62; - /** - * - */ - private BigDecimal VALUE63; - /** - * - */ - private BigDecimal VALUE64; - /** - * - */ - private BigDecimal VALUE65; - /** - * - */ - private BigDecimal VALUE66; - /** - * - */ - private BigDecimal VALUE67; - /** - * - */ - private BigDecimal VALUE68; - /** - * - */ - private BigDecimal VALUE69; - /** - * - */ - private BigDecimal VALUE70; - /** - * - */ - private BigDecimal VALUE71; - /** - * - */ - private BigDecimal VALUE72; - /** - * - */ - private BigDecimal VALUE73; - /** - * - */ - private BigDecimal VALUE74; - /** - * - */ - private BigDecimal VALUE75; - /** - * - */ - private BigDecimal VALUE76; - /** - * - */ - private BigDecimal VALUE77; - /** - * - */ - private BigDecimal VALUE78; - /** - * - */ - private BigDecimal VALUE79; - /** - * - */ - private BigDecimal VALUE80; - /** - * - */ - private BigDecimal VALUE81; - /** - * - */ - private BigDecimal VALUE82; - /** - * - */ - private BigDecimal VALUE83; - /** - * - */ - private BigDecimal VALUE84; - /** - * - */ - private BigDecimal VALUE85; - /** - * - */ - private BigDecimal VALUE86; - /** - * - */ - private BigDecimal VALUE87; - /** - * - */ - private BigDecimal VALUE88; - /** - * - */ - private BigDecimal VALUE89; - /** - * - */ - private BigDecimal VALUE90; - /** - * - */ - private BigDecimal VALUE91; - /** - * - */ - private BigDecimal VALUE92; - /** - * - */ - private BigDecimal VALUE93; - /** - * - */ - private BigDecimal VALUE94; - /** - * - */ - private BigDecimal VALUE95; - /** - * - */ - private BigDecimal VALUE96; - /** - * - */ - private BigDecimal VALUE97; - /** - * - */ - private BigDecimal VALUE98; - /** - * - */ - private BigDecimal VALUE99; +public class Klptcm1ProPlantStateCurrent { + private Date insdate; // 对应数据库 INSDATE + private BigDecimal year; // 对应数据库 YEAR + private BigDecimal month; // 对应数据库 MONTH + private BigDecimal day; // 对应数据库 DAY + private BigDecimal hour; // 对应数据库 HOUR + private BigDecimal minute; // 对应数据库 MINUTE + private BigDecimal type; // 对应数据库 TYPE + // 以下为 VALUE1 到 VALUE99 的属性 + private BigDecimal value1; + private BigDecimal value2; + // ... 省略 VALUE3 到 VALUE98 的声明 ... + private BigDecimal value99; } diff --git a/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java index 4d3de788..ecf92f9b 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java +++ b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java @@ -1,15 +1,12 @@ package com.klp.pocket.mapper; import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; -import com.klp.pocket.domain.vo.Klptcm1ProPlantStateCurrentVo; -import com.klp.common.core.mapper.BaseMapperPlus; +import org.apache.ibatis.annotations.Mapper; +import java.util.List; -/** - * 当前Mapper接口 - * - * @author klp - * @date 2025-10-27 - */ -public interface Klptcm1ProPlantStateCurrentMapper extends BaseMapperPlus { +@Mapper +public interface Klptcm1ProPlantStateCurrentMapper { + // 查询所有 + List selectAll(); } diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java index 7c9beb9f..0e746d2a 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java +++ b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java @@ -1,49 +1,10 @@ package com.klp.pocket.service; import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; -import com.klp.pocket.domain.vo.Klptcm1ProPlantStateCurrentVo; -import com.klp.pocket.domain.bo.Klptcm1ProPlantStateCurrentBo; -import com.klp.common.core.page.TableDataInfo; -import com.klp.common.core.domain.PageQuery; - -import java.util.Collection; import java.util.List; -/** - * 当前Service接口 - * - * @author klp - * @date 2025-10-27 - */ public interface IKlptcm1ProPlantStateCurrentService { - /** - * 查询当前 - */ - Klptcm1ProPlantStateCurrentVo queryById(Date INSDATE); + List selectAll(); - /** - * 查询当前列表 - */ - TableDataInfo queryPageList(Klptcm1ProPlantStateCurrentBo bo, PageQuery pageQuery); - - /** - * 查询当前列表 - */ - List queryList(Klptcm1ProPlantStateCurrentBo bo); - - /** - * 新增当前 - */ - Boolean insertByBo(Klptcm1ProPlantStateCurrentBo bo); - - /** - * 修改当前 - */ - Boolean updateByBo(Klptcm1ProPlantStateCurrentBo bo); - - /** - * 校验并批量删除当前信息 - */ - Boolean deleteWithValidByIds(Collection ids, Boolean isValid); } diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java index 17df3259..0d261149 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java +++ b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java @@ -1,213 +1,24 @@ package com.klp.pocket.service.impl; -import cn.hutool.core.bean.BeanUtil; -import com.klp.common.core.page.TableDataInfo; -import com.klp.common.core.domain.PageQuery; -import com.baomidou.mybatisplus.extension.plugins.pagination.Page; -import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; -import com.baomidou.mybatisplus.core.toolkit.Wrappers; -import lombok.RequiredArgsConstructor; -import org.springframework.stereotype.Service; -import com.klp.pocket.domain.bo.Klptcm1ProPlantStateCurrentBo; -import com.klp.pocket.domain.vo.Klptcm1ProPlantStateCurrentVo; +import com.baomidou.dynamic.datasource.annotation.DS; import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; import com.klp.pocket.mapper.Klptcm1ProPlantStateCurrentMapper; import com.klp.pocket.service.IKlptcm1ProPlantStateCurrentService; - +import org.springframework.stereotype.Service; +import javax.annotation.Resource; import java.util.List; -import java.util.Map; -import java.util.Collection; -/** - * 当前Service业务层处理 - * - * @author klp - * @date 2025-10-27 - */ -@RequiredArgsConstructor +@DS("slave") @Service public class Klptcm1ProPlantStateCurrentServiceImpl implements IKlptcm1ProPlantStateCurrentService { - private final Klptcm1ProPlantStateCurrentMapper baseMapper; + @Resource + private Klptcm1ProPlantStateCurrentMapper klptcm1ProPlantStateCurrentMapper; + - /** - * 查询当前 - */ @Override - public Klptcm1ProPlantStateCurrentVo queryById(Date INSDATE){ - return baseMapper.selectVoById(INSDATE); + public List selectAll() { + return klptcm1ProPlantStateCurrentMapper.selectAll(); } - /** - * 查询当前列表 - */ - @Override - public TableDataInfo queryPageList(Klptcm1ProPlantStateCurrentBo bo, PageQuery pageQuery) { - LambdaQueryWrapper lqw = buildQueryWrapper(bo); - Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); - return TableDataInfo.build(result); - } - - /** - * 查询当前列表 - */ - @Override - public List queryList(Klptcm1ProPlantStateCurrentBo bo) { - LambdaQueryWrapper lqw = buildQueryWrapper(bo); - return baseMapper.selectVoList(lqw); - } - - private LambdaQueryWrapper buildQueryWrapper(Klptcm1ProPlantStateCurrentBo bo) { - Map params = bo.getParams(); - LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); - lqw.eq(bo.getINSDATE() != null, Klptcm1ProPlantStateCurrent::getINSDATE, bo.getINSDATE()); - lqw.eq(bo.getYEAR() != null, Klptcm1ProPlantStateCurrent::getYEAR, bo.getYEAR()); - lqw.eq(bo.getMONTH() != null, Klptcm1ProPlantStateCurrent::getMONTH, bo.getMONTH()); - lqw.eq(bo.getDAY() != null, Klptcm1ProPlantStateCurrent::getDAY, bo.getDAY()); - lqw.eq(bo.getHOUR() != null, Klptcm1ProPlantStateCurrent::getHOUR, bo.getHOUR()); - lqw.eq(bo.getMINUTE() != null, Klptcm1ProPlantStateCurrent::getMINUTE, bo.getMINUTE()); - lqw.eq(bo.getTYPE() != null, Klptcm1ProPlantStateCurrent::getTYPE, bo.getTYPE()); - lqw.eq(bo.getVALUE1() != null, Klptcm1ProPlantStateCurrent::getVALUE1, bo.getVALUE1()); - lqw.eq(bo.getVALUE2() != null, Klptcm1ProPlantStateCurrent::getVALUE2, bo.getVALUE2()); - lqw.eq(bo.getVALUE3() != null, Klptcm1ProPlantStateCurrent::getVALUE3, bo.getVALUE3()); - lqw.eq(bo.getVALUE4() != null, Klptcm1ProPlantStateCurrent::getVALUE4, bo.getVALUE4()); - lqw.eq(bo.getVALUE5() != null, Klptcm1ProPlantStateCurrent::getVALUE5, bo.getVALUE5()); - lqw.eq(bo.getVALUE6() != null, Klptcm1ProPlantStateCurrent::getVALUE6, bo.getVALUE6()); - lqw.eq(bo.getVALUE7() != null, Klptcm1ProPlantStateCurrent::getVALUE7, bo.getVALUE7()); - lqw.eq(bo.getVALUE8() != null, Klptcm1ProPlantStateCurrent::getVALUE8, bo.getVALUE8()); - lqw.eq(bo.getVALUE9() != null, Klptcm1ProPlantStateCurrent::getVALUE9, bo.getVALUE9()); - lqw.eq(bo.getVALUE10() != null, Klptcm1ProPlantStateCurrent::getVALUE10, bo.getVALUE10()); - lqw.eq(bo.getVALUE11() != null, Klptcm1ProPlantStateCurrent::getVALUE11, bo.getVALUE11()); - lqw.eq(bo.getVALUE12() != null, Klptcm1ProPlantStateCurrent::getVALUE12, bo.getVALUE12()); - lqw.eq(bo.getVALUE13() != null, Klptcm1ProPlantStateCurrent::getVALUE13, bo.getVALUE13()); - lqw.eq(bo.getVALUE14() != null, Klptcm1ProPlantStateCurrent::getVALUE14, bo.getVALUE14()); - lqw.eq(bo.getVALUE15() != null, Klptcm1ProPlantStateCurrent::getVALUE15, bo.getVALUE15()); - lqw.eq(bo.getVALUE16() != null, Klptcm1ProPlantStateCurrent::getVALUE16, bo.getVALUE16()); - lqw.eq(bo.getVALUE17() != null, Klptcm1ProPlantStateCurrent::getVALUE17, bo.getVALUE17()); - lqw.eq(bo.getVALUE18() != null, Klptcm1ProPlantStateCurrent::getVALUE18, bo.getVALUE18()); - lqw.eq(bo.getVALUE19() != null, Klptcm1ProPlantStateCurrent::getVALUE19, bo.getVALUE19()); - lqw.eq(bo.getVALUE20() != null, Klptcm1ProPlantStateCurrent::getVALUE20, bo.getVALUE20()); - lqw.eq(bo.getVALUE21() != null, Klptcm1ProPlantStateCurrent::getVALUE21, bo.getVALUE21()); - lqw.eq(bo.getVALUE22() != null, Klptcm1ProPlantStateCurrent::getVALUE22, bo.getVALUE22()); - lqw.eq(bo.getVALUE23() != null, Klptcm1ProPlantStateCurrent::getVALUE23, bo.getVALUE23()); - lqw.eq(bo.getVALUE24() != null, Klptcm1ProPlantStateCurrent::getVALUE24, bo.getVALUE24()); - lqw.eq(bo.getVALUE25() != null, Klptcm1ProPlantStateCurrent::getVALUE25, bo.getVALUE25()); - lqw.eq(bo.getVALUE26() != null, Klptcm1ProPlantStateCurrent::getVALUE26, bo.getVALUE26()); - lqw.eq(bo.getVALUE27() != null, Klptcm1ProPlantStateCurrent::getVALUE27, bo.getVALUE27()); - lqw.eq(bo.getVALUE28() != null, Klptcm1ProPlantStateCurrent::getVALUE28, bo.getVALUE28()); - lqw.eq(bo.getVALUE29() != null, Klptcm1ProPlantStateCurrent::getVALUE29, bo.getVALUE29()); - lqw.eq(bo.getVALUE30() != null, Klptcm1ProPlantStateCurrent::getVALUE30, bo.getVALUE30()); - lqw.eq(bo.getVALUE31() != null, Klptcm1ProPlantStateCurrent::getVALUE31, bo.getVALUE31()); - lqw.eq(bo.getVALUE32() != null, Klptcm1ProPlantStateCurrent::getVALUE32, bo.getVALUE32()); - lqw.eq(bo.getVALUE33() != null, Klptcm1ProPlantStateCurrent::getVALUE33, bo.getVALUE33()); - lqw.eq(bo.getVALUE34() != null, Klptcm1ProPlantStateCurrent::getVALUE34, bo.getVALUE34()); - lqw.eq(bo.getVALUE35() != null, Klptcm1ProPlantStateCurrent::getVALUE35, bo.getVALUE35()); - lqw.eq(bo.getVALUE36() != null, Klptcm1ProPlantStateCurrent::getVALUE36, bo.getVALUE36()); - lqw.eq(bo.getVALUE37() != null, Klptcm1ProPlantStateCurrent::getVALUE37, bo.getVALUE37()); - lqw.eq(bo.getVALUE38() != null, Klptcm1ProPlantStateCurrent::getVALUE38, bo.getVALUE38()); - lqw.eq(bo.getVALUE39() != null, Klptcm1ProPlantStateCurrent::getVALUE39, bo.getVALUE39()); - lqw.eq(bo.getVALUE40() != null, Klptcm1ProPlantStateCurrent::getVALUE40, bo.getVALUE40()); - lqw.eq(bo.getVALUE41() != null, Klptcm1ProPlantStateCurrent::getVALUE41, bo.getVALUE41()); - lqw.eq(bo.getVALUE42() != null, Klptcm1ProPlantStateCurrent::getVALUE42, bo.getVALUE42()); - lqw.eq(bo.getVALUE43() != null, Klptcm1ProPlantStateCurrent::getVALUE43, bo.getVALUE43()); - lqw.eq(bo.getVALUE44() != null, Klptcm1ProPlantStateCurrent::getVALUE44, bo.getVALUE44()); - lqw.eq(bo.getVALUE45() != null, Klptcm1ProPlantStateCurrent::getVALUE45, bo.getVALUE45()); - lqw.eq(bo.getVALUE46() != null, Klptcm1ProPlantStateCurrent::getVALUE46, bo.getVALUE46()); - lqw.eq(bo.getVALUE47() != null, Klptcm1ProPlantStateCurrent::getVALUE47, bo.getVALUE47()); - lqw.eq(bo.getVALUE48() != null, Klptcm1ProPlantStateCurrent::getVALUE48, bo.getVALUE48()); - lqw.eq(bo.getVALUE49() != null, Klptcm1ProPlantStateCurrent::getVALUE49, bo.getVALUE49()); - lqw.eq(bo.getVALUE50() != null, Klptcm1ProPlantStateCurrent::getVALUE50, bo.getVALUE50()); - lqw.eq(bo.getVALUE51() != null, Klptcm1ProPlantStateCurrent::getVALUE51, bo.getVALUE51()); - lqw.eq(bo.getVALUE52() != null, Klptcm1ProPlantStateCurrent::getVALUE52, bo.getVALUE52()); - lqw.eq(bo.getVALUE53() != null, Klptcm1ProPlantStateCurrent::getVALUE53, bo.getVALUE53()); - lqw.eq(bo.getVALUE54() != null, Klptcm1ProPlantStateCurrent::getVALUE54, bo.getVALUE54()); - lqw.eq(bo.getVALUE55() != null, Klptcm1ProPlantStateCurrent::getVALUE55, bo.getVALUE55()); - lqw.eq(bo.getVALUE56() != null, Klptcm1ProPlantStateCurrent::getVALUE56, bo.getVALUE56()); - lqw.eq(bo.getVALUE57() != null, Klptcm1ProPlantStateCurrent::getVALUE57, bo.getVALUE57()); - lqw.eq(bo.getVALUE58() != null, Klptcm1ProPlantStateCurrent::getVALUE58, bo.getVALUE58()); - lqw.eq(bo.getVALUE59() != null, Klptcm1ProPlantStateCurrent::getVALUE59, bo.getVALUE59()); - lqw.eq(bo.getVALUE60() != null, Klptcm1ProPlantStateCurrent::getVALUE60, bo.getVALUE60()); - lqw.eq(bo.getVALUE61() != null, Klptcm1ProPlantStateCurrent::getVALUE61, bo.getVALUE61()); - lqw.eq(bo.getVALUE62() != null, Klptcm1ProPlantStateCurrent::getVALUE62, bo.getVALUE62()); - lqw.eq(bo.getVALUE63() != null, Klptcm1ProPlantStateCurrent::getVALUE63, bo.getVALUE63()); - lqw.eq(bo.getVALUE64() != null, Klptcm1ProPlantStateCurrent::getVALUE64, bo.getVALUE64()); - lqw.eq(bo.getVALUE65() != null, Klptcm1ProPlantStateCurrent::getVALUE65, bo.getVALUE65()); - lqw.eq(bo.getVALUE66() != null, Klptcm1ProPlantStateCurrent::getVALUE66, bo.getVALUE66()); - lqw.eq(bo.getVALUE67() != null, Klptcm1ProPlantStateCurrent::getVALUE67, bo.getVALUE67()); - lqw.eq(bo.getVALUE68() != null, Klptcm1ProPlantStateCurrent::getVALUE68, bo.getVALUE68()); - lqw.eq(bo.getVALUE69() != null, Klptcm1ProPlantStateCurrent::getVALUE69, bo.getVALUE69()); - lqw.eq(bo.getVALUE70() != null, Klptcm1ProPlantStateCurrent::getVALUE70, bo.getVALUE70()); - lqw.eq(bo.getVALUE71() != null, Klptcm1ProPlantStateCurrent::getVALUE71, bo.getVALUE71()); - lqw.eq(bo.getVALUE72() != null, Klptcm1ProPlantStateCurrent::getVALUE72, bo.getVALUE72()); - lqw.eq(bo.getVALUE73() != null, Klptcm1ProPlantStateCurrent::getVALUE73, bo.getVALUE73()); - lqw.eq(bo.getVALUE74() != null, Klptcm1ProPlantStateCurrent::getVALUE74, bo.getVALUE74()); - lqw.eq(bo.getVALUE75() != null, Klptcm1ProPlantStateCurrent::getVALUE75, bo.getVALUE75()); - lqw.eq(bo.getVALUE76() != null, Klptcm1ProPlantStateCurrent::getVALUE76, bo.getVALUE76()); - lqw.eq(bo.getVALUE77() != null, Klptcm1ProPlantStateCurrent::getVALUE77, bo.getVALUE77()); - lqw.eq(bo.getVALUE78() != null, Klptcm1ProPlantStateCurrent::getVALUE78, bo.getVALUE78()); - lqw.eq(bo.getVALUE79() != null, Klptcm1ProPlantStateCurrent::getVALUE79, bo.getVALUE79()); - lqw.eq(bo.getVALUE80() != null, Klptcm1ProPlantStateCurrent::getVALUE80, bo.getVALUE80()); - lqw.eq(bo.getVALUE81() != null, Klptcm1ProPlantStateCurrent::getVALUE81, bo.getVALUE81()); - lqw.eq(bo.getVALUE82() != null, Klptcm1ProPlantStateCurrent::getVALUE82, bo.getVALUE82()); - lqw.eq(bo.getVALUE83() != null, Klptcm1ProPlantStateCurrent::getVALUE83, bo.getVALUE83()); - lqw.eq(bo.getVALUE84() != null, Klptcm1ProPlantStateCurrent::getVALUE84, bo.getVALUE84()); - lqw.eq(bo.getVALUE85() != null, Klptcm1ProPlantStateCurrent::getVALUE85, bo.getVALUE85()); - lqw.eq(bo.getVALUE86() != null, Klptcm1ProPlantStateCurrent::getVALUE86, bo.getVALUE86()); - lqw.eq(bo.getVALUE87() != null, Klptcm1ProPlantStateCurrent::getVALUE87, bo.getVALUE87()); - lqw.eq(bo.getVALUE88() != null, Klptcm1ProPlantStateCurrent::getVALUE88, bo.getVALUE88()); - lqw.eq(bo.getVALUE89() != null, Klptcm1ProPlantStateCurrent::getVALUE89, bo.getVALUE89()); - lqw.eq(bo.getVALUE90() != null, Klptcm1ProPlantStateCurrent::getVALUE90, bo.getVALUE90()); - lqw.eq(bo.getVALUE91() != null, Klptcm1ProPlantStateCurrent::getVALUE91, bo.getVALUE91()); - lqw.eq(bo.getVALUE92() != null, Klptcm1ProPlantStateCurrent::getVALUE92, bo.getVALUE92()); - lqw.eq(bo.getVALUE93() != null, Klptcm1ProPlantStateCurrent::getVALUE93, bo.getVALUE93()); - lqw.eq(bo.getVALUE94() != null, Klptcm1ProPlantStateCurrent::getVALUE94, bo.getVALUE94()); - lqw.eq(bo.getVALUE95() != null, Klptcm1ProPlantStateCurrent::getVALUE95, bo.getVALUE95()); - lqw.eq(bo.getVALUE96() != null, Klptcm1ProPlantStateCurrent::getVALUE96, bo.getVALUE96()); - lqw.eq(bo.getVALUE97() != null, Klptcm1ProPlantStateCurrent::getVALUE97, bo.getVALUE97()); - lqw.eq(bo.getVALUE98() != null, Klptcm1ProPlantStateCurrent::getVALUE98, bo.getVALUE98()); - lqw.eq(bo.getVALUE99() != null, Klptcm1ProPlantStateCurrent::getVALUE99, bo.getVALUE99()); - return lqw; - } - - /** - * 新增当前 - */ - @Override - public Boolean insertByBo(Klptcm1ProPlantStateCurrentBo bo) { - Klptcm1ProPlantStateCurrent add = BeanUtil.toBean(bo, Klptcm1ProPlantStateCurrent.class); - validEntityBeforeSave(add); - boolean flag = baseMapper.insert(add) > 0; - if (flag) { - bo.setINSDATE(add.getINSDATE()); - } - return flag; - } - - /** - * 修改当前 - */ - @Override - public Boolean updateByBo(Klptcm1ProPlantStateCurrentBo bo) { - Klptcm1ProPlantStateCurrent update = BeanUtil.toBean(bo, Klptcm1ProPlantStateCurrent.class); - validEntityBeforeSave(update); - return baseMapper.updateById(update) > 0; - } - - /** - * 保存前的数据校验 - */ - private void validEntityBeforeSave(Klptcm1ProPlantStateCurrent entity){ - //TODO 做一些数据校验,如唯一约束 - } - - /** - * 批量删除当前 - */ - @Override - public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { - if(isValid){ - //TODO 做一些业务上的校验,判断是否需要校验 - } - return baseMapper.deleteBatchIds(ids) > 0; - } } diff --git a/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml index c64b367c..1dfe0a6a 100644 --- a/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml +++ b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml @@ -1,117 +1,30 @@ - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + INSDATE, YEAR, MONTH, DAY, HOUR, MINUTE, TYPE, + VALUE1, VALUE2, VALUE99 + + + + From bbecc3c55fe51a244dec76ea20a177cf817318e2 Mon Sep 17 00:00:00 2001 From: Joshi <3040996759@qq.com> Date: Mon, 27 Oct 2025 18:07:12 +0800 Subject: [PATCH 5/7] =?UTF-8?q?feat(pocket):=20=E5=AE=9E=E7=8E=B0=E5=B7=A5?= =?UTF-8?q?=E5=8E=82=E7=8A=B6=E6=80=81=E6=95=B0=E6=8D=AE=E5=88=86=E9=A1=B5?= =?UTF-8?q?=E6=9F=A5=E8=AF=A2=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 为Klptcm1ProPlantStateCurrent实体补充VALUE1至VALUE99字段定义及注释 - 更新Klptcm1ProPlantStateCurrentMapper.xml，完善所有VALUE字段的resultMap和column list映射- 修改IKlptcm1ProPlantStateCurrentService接口，将selectAll方法改为支持分页查询- 调整Klptcm1ProPlantStateCurrentController控制器，继承BaseController并支持分页参数- 新增Klptcm1ProPlantStateDefine相关组件（domain、controller、service、mapper），实现状态定义表的分页查询能力- 引入PageQuery与TableDataInfo等通用分页工具类，统一前后端分页交互格式 - 更新Mapper XML配置文件，优化SQL结构并确保大数据量下的查询性能 --- ...Klptcm1ProPlantStateCurrentController.java | 13 +- .../Klptcm1ProPlantStateDefineController.java | 34 + .../domain/Klptcm1ProPlantStateCurrent.java | 596 +++++++++++++++++- .../domain/Klptcm1ProPlantStateDefine.java | 50 ++ .../Klptcm1ProPlantStateCurrentMapper.java | 5 +- .../Klptcm1ProPlantStateDefineMapper.java | 25 + .../IKlptcm1ProPlantStateCurrentService.java | 4 +- .../IKlptcm1ProPlantStateDefineService.java | 27 + ...lptcm1ProPlantStateCurrentServiceImpl.java | 8 +- ...Klptcm1ProPlantStateDefineServiceImpl.java | 36 ++ .../Klptcm1ProPlantStateCurrentMapper.xml | 111 +++- .../Klptcm1ProPlantStateDefineMapper.xml | 27 + 12 files changed, 923 insertions(+), 13 deletions(-) create mode 100644 klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateDefineController.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateDefine.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateDefineMapper.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateDefineService.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateDefineServiceImpl.java create mode 100644 klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateDefineMapper.xml diff --git a/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java index e6b79103..d6bfd5ab 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java +++ b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateCurrentController.java @@ -1,6 +1,9 @@ package com.klp.pocket.controller; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; import com.klp.common.core.domain.R; +import com.klp.common.core.page.TableDataInfo; import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; import com.klp.pocket.service.IKlptcm1ProPlantStateCurrentService; import org.springframework.web.bind.annotation.*; @@ -8,8 +11,8 @@ import javax.annotation.Resource; import java.util.List; @RestController -@RequestMapping("/api/klptcm1ProPlantStateCurrent") -public class Klptcm1ProPlantStateCurrentController { +@RequestMapping("/pocket/proPlantStateCurrent") +public class Klptcm1ProPlantStateCurrentController extends BaseController { @Resource private IKlptcm1ProPlantStateCurrentService klptcm1ProPlantStateCurrentService; @@ -18,9 +21,9 @@ public class Klptcm1ProPlantStateCurrentController { * 查询所有数据 */ @GetMapping("/selectAll") - public R> selectAll() { - List result = klptcm1ProPlantStateCurrentService.selectAll(); - return R.ok(result); + public TableDataInfo selectAll(PageQuery pageQuery) { + return klptcm1ProPlantStateCurrentService.selectAll(pageQuery); + } } diff --git a/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateDefineController.java b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateDefineController.java new file mode 100644 index 00000000..cb9a083e --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateDefineController.java @@ -0,0 +1,34 @@ +package com.klp.pocket.controller; + +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.page.TableDataInfo; +import com.klp.pocket.domain.Klptcm1ProPlantStateDefine; +import com.klp.pocket.service.IKlptcm1ProPlantStateDefineService; +import org.springframework.web.bind.annotation.*; +import javax.annotation.Resource; +import java.math.BigDecimal; +import java.util.List; + +/** + * 工厂状态定义表Controller + * 提供RESTful接口，处理前端请求 + */ +@RestController +@RequestMapping("/pocket/proPlantStateDefine") +public class Klptcm1ProPlantStateDefineController extends BaseController { + + @Resource + private IKlptcm1ProPlantStateDefineService defineService; + + /** + * 分页查询状态定义列表 + * @param pageQuery 分页参数（请求参数，如?pageNum=1&pageSize=10） + * @return 分页表格数据 + */ + @GetMapping("/listPage") + public TableDataInfo getDefinePage(PageQuery pageQuery) { + return defineService.getDefinePage(pageQuery); + } + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java index fa3b95f9..6b346895 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateCurrent.java @@ -14,10 +14,602 @@ public class Klptcm1ProPlantStateCurrent { private BigDecimal hour; // 对应数据库 HOUR private BigDecimal minute; // 对应数据库 MINUTE private BigDecimal type; // 对应数据库 TYPE - // 以下为 VALUE1 到 VALUE99 的属性 + /** + * 状态值1 + * 对应数据库列：VALUE1（decimal类型，具体含义取决于TYPE字段，如温度、压力等） + */ private BigDecimal value1; + + /** + * 状态值2 + * 对应数据库列：VALUE2（decimal类型，具体含义取决于TYPE字段） + */ private BigDecimal value2; - // ... 省略 VALUE3 到 VALUE98 的声明 ... + + /** + * 状态值3 + * 对应数据库列：VALUE3（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value3; + + /** + * 状态值4 + * 对应数据库列：VALUE4（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value4; + + /** + * 状态值5 + * 对应数据库列：VALUE5（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value5; + + /** + * 状态值6 + * 对应数据库列：VALUE6（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value6; + + /** + * 状态值7 + * 对应数据库列：VALUE7（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value7; + + /** + * 状态值8 + * 对应数据库列：VALUE8（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value8; + + /** + * 状态值9 + * 对应数据库列：VALUE9（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value9; + + /** + * 状态值10 + * 对应数据库列：VALUE10（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value10; + + // ------------------------------ + // 以下为VALUE11至VALUE98的完整声明 + // ------------------------------ + + /** + * 状态值11 + * 对应数据库列：VALUE11（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value11; + + /** + * 状态值12 + * 对应数据库列：VALUE12（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value12; + + /** + * 状态值13 + * 对应数据库列：VALUE13（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value13; + + /** + * 状态值14 + * 对应数据库列：VALUE14（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value14; + + /** + * 状态值15 + * 对应数据库列：VALUE15（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value15; + + /** + * 状态值16 + * 对应数据库列：VALUE16（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value16; + + /** + * 状态值17 + * 对应数据库列：VALUE17（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value17; + + /** + * 状态值18 + * 对应数据库列：VALUE18（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value18; + + /** + * 状态值19 + * 对应数据库列：VALUE19（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value19; + + /** + * 状态值20 + * 对应数据库列：VALUE20（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value20; + + /** + * 状态值21 + * 对应数据库列：VALUE21（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value21; + + /** + * 状态值22 + * 对应数据库列：VALUE22（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value22; + + /** + * 状态值23 + * 对应数据库列：VALUE23（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value23; + + /** + * 状态值24 + * 对应数据库列：VALUE24（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value24; + + /** + * 状态值25 + * 对应数据库列：VALUE25（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value25; + + /** + * 状态值26 + * 对应数据库列：VALUE26（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value26; + + /** + * 状态值27 + * 对应数据库列：VALUE27（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value27; + + /** + * 状态值28 + * 对应数据库列：VALUE28（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value28; + + /** + * 状态值29 + * 对应数据库列：VALUE29（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value29; + + /** + * 状态值30 + * 对应数据库列：VALUE30（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value30; + + /** + * 状态值31 + * 对应数据库列：VALUE31（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value31; + + /** + * 状态值32 + * 对应数据库列：VALUE32（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value32; + + /** + * 状态值33 + * 对应数据库列：VALUE33（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value33; + + /** + * 状态值34 + * 对应数据库列：VALUE34（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value34; + + /** + * 状态值35 + * 对应数据库列：VALUE35（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value35; + + /** + * 状态值36 + * 对应数据库列：VALUE36（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value36; + + /** + * 状态值37 + * 对应数据库列：VALUE37（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value37; + + /** + * 状态值38 + * 对应数据库列：VALUE38（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value38; + + /** + * 状态值39 + * 对应数据库列：VALUE39（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value39; + + /** + * 状态值40 + * 对应数据库列：VALUE40（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value40; + + /** + * 状态值41 + * 对应数据库列：VALUE41（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value41; + + /** + * 状态值42 + * 对应数据库列：VALUE42（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value42; + + /** + * 状态值43 + * 对应数据库列：VALUE43（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value43; + + /** + * 状态值44 + * 对应数据库列：VALUE44（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value44; + + /** + * 状态值45 + * 对应数据库列：VALUE45（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value45; + + /** + * 状态值46 + * 对应数据库列：VALUE46（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value46; + + /** + * 状态值47 + * 对应数据库列：VALUE47（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value47; + + /** + * 状态值48 + * 对应数据库列：VALUE48（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value48; + + /** + * 状态值49 + * 对应数据库列：VALUE49（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value49; + + /** + * 状态值50 + * 对应数据库列：VALUE50（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value50; + + /** + * 状态值51 + * 对应数据库列：VALUE51（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value51; + + /** + * 状态值52 + * 对应数据库列：VALUE52（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value52; + + /** + * 状态值53 + * 对应数据库列：VALUE53（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value53; + + /** + * 状态值54 + * 对应数据库列：VALUE54（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value54; + + /** + * 状态值55 + * 对应数据库列：VALUE55（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value55; + + /** + * 状态值56 + * 对应数据库列：VALUE56（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value56; + + /** + * 状态值57 + * 对应数据库列：VALUE57（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value57; + + /** + * 状态值58 + * 对应数据库列：VALUE58（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value58; + + /** + * 状态值59 + * 对应数据库列：VALUE59（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value59; + + /** + * 状态值60 + * 对应数据库列：VALUE60（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value60; + + /** + * 状态值61 + * 对应数据库列：VALUE61（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value61; + + /** + * 状态值62 + * 对应数据库列：VALUE62（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value62; + + /** + * 状态值63 + * 对应数据库列：VALUE63（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value63; + + /** + * 状态值64 + * 对应数据库列：VALUE64（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value64; + + /** + * 状态值65 + * 对应数据库列：VALUE65（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value65; + + /** + * 状态值66 + * 对应数据库列：VALUE66（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value66; + + /** + * 状态值67 + * 对应数据库列：VALUE67（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value67; + + /** + * 状态值68 + * 对应数据库列：VALUE68（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value68; + + /** + * 状态值69 + * 对应数据库列：VALUE69（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value69; + + /** + * 状态值70 + * 对应数据库列：VALUE70（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value70; + + /** + * 状态值71 + * 对应数据库列：VALUE71（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value71; + + /** + * 状态值72 + * 对应数据库列：VALUE72（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value72; + + /** + * 状态值73 + * 对应数据库列：VALUE73（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value73; + + /** + * 状态值74 + * 对应数据库列：VALUE74（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value74; + + /** + * 状态值75 + * 对应数据库列：VALUE75（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value75; + + /** + * 状态值76 + * 对应数据库列：VALUE76（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value76; + + /** + * 状态值77 + * 对应数据库列：VALUE77（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value77; + + /** + * 状态值78 + * 对应数据库列：VALUE78（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value78; + + /** + * 状态值79 + * 对应数据库列：VALUE79（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value79; + + /** + * 状态值80 + * 对应数据库列：VALUE80（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value80; + + /** + * 状态值81 + * 对应数据库列：VALUE81（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value81; + + /** + * 状态值82 + * 对应数据库列：VALUE82（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value82; + + /** + * 状态值83 + * 对应数据库列：VALUE83（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value83; + + /** + * 状态值84 + * 对应数据库列：VALUE84（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value84; + + /** + * 状态值85 + * 对应数据库列：VALUE85（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value85; + + /** + * 状态值86 + * 对应数据库列：VALUE86（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value86; + + /** + * 状态值87 + * 对应数据库列：VALUE87（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value87; + + /** + * 状态值88 + * 对应数据库列：VALUE88（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value88; + + /** + * 状态值89 + * 对应数据库列：VALUE89（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value89; + + /** + * 状态值90 + * 对应数据库列：VALUE90（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value90; + + /** + * 状态值91 + * 对应数据库列：VALUE91（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value91; + + /** + * 状态值92 + * 对应数据库列：VALUE92（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value92; + + /** + * 状态值93 + * 对应数据库列：VALUE93（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value93; + + /** + * 状态值94 + * 对应数据库列：VALUE94（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value94; + + /** + * 状态值95 + * 对应数据库列：VALUE95（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value95; + + /** + * 状态值96 + * 对应数据库列：VALUE96（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value96; + + /** + * 状态值97 + * 对应数据库列：VALUE97（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value97; + + /** + * 状态值98 + * 对应数据库列：VALUE98（decimal类型，具体含义取决于TYPE字段） + */ + private BigDecimal value98; + + /** + * 状态值99 + * 对应数据库列：VALUE99（decimal类型，具体含义取决于TYPE字段） + */ private BigDecimal value99; } diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateDefine.java b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateDefine.java new file mode 100644 index 00000000..18947eee --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateDefine.java @@ -0,0 +1,50 @@ +package com.klp.pocket.domain; + +import lombok.Data; +import java.math.BigDecimal; +import java.util.Date; + +/** + * 工厂状态定义表实体类 + * 对应数据库表：klptcm1_pro_plant_state_define + * 用途：存储工厂状态参数的定义信息（如参数名称、单位、说明等） + */ +@Data +public class Klptcm1ProPlantStateDefine { + + /** + * 主键ID + * 对应数据库列：ID（decimal类型，唯一标识一条状态定义记录） + */ + private BigDecimal id; + + /** + * 状态参数名称 + * 对应数据库列：NAME（varchar类型，非空，如"温度"、"压力"） + */ + private String name; + + /** + * 状态参数单位 + * 对应数据库列：UNITS（varchar类型，非空，如"℃"、"MPa"） + */ + private String units; + + /** + * 状态参数说明 + * 对应数据库列：COMMENTS（varchar类型，非空，补充参数的详细描述） + */ + private String comments; + + /** + * 插入时间 + * 对应数据库列：INSDATE（datetime类型，默认当前时间戳，记录数据创建时间） + */ + private Date insdate; + + /** + * 模型类型 + * 对应数据库列：MODELTYPE（decimal类型，默认值2，标识参数所属模型类型） + */ + private BigDecimal modeltype; +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java index ecf92f9b..38e532f4 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java +++ b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateCurrentMapper.java @@ -1,5 +1,8 @@ package com.klp.pocket.mapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.page.TableDataInfo; import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; import org.apache.ibatis.annotations.Mapper; import java.util.List; @@ -8,5 +11,5 @@ import java.util.List; public interface Klptcm1ProPlantStateCurrentMapper { // 查询所有 - List selectAll(); + Page selectAll(Page build); } diff --git a/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateDefineMapper.java b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateDefineMapper.java new file mode 100644 index 00000000..f4a28d62 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateDefineMapper.java @@ -0,0 +1,25 @@ +package com.klp.pocket.mapper; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.klp.pocket.domain.Klptcm1ProPlantStateDefine; +import org.apache.ibatis.annotations.Mapper; +import com.baomidou.mybatisplus.core.metadata.IPage; + +import java.math.BigDecimal; +import java.util.List; + +/** + * 工厂状态定义表Mapper接口 + * 提供增删改查及分页查询能力 + */ +@Mapper +public interface Klptcm1ProPlantStateDefineMapper { + + /** + * 分页查询所有状态定义 + * @param page 分页参数（含页码、每页条数） + * @return 分页结果（含总条数、当前页数据） + */ + Page selectPage(Page page); + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java index 0e746d2a..3a121072 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java +++ b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateCurrentService.java @@ -1,10 +1,12 @@ package com.klp.pocket.service; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.page.TableDataInfo; import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; import java.util.List; public interface IKlptcm1ProPlantStateCurrentService { - List selectAll(); + TableDataInfo selectAll(PageQuery pageQuery); } diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateDefineService.java b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateDefineService.java new file mode 100644 index 00000000..aab287f5 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateDefineService.java @@ -0,0 +1,27 @@ +package com.klp.pocket.service; + +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.page.TableDataInfo; +import com.klp.pocket.domain.Klptcm1ProPlantStateDefine; + + + +import java.math.BigDecimal; +import java.util.List; + +/** + * 工厂状态定义表Service接口 + * 封装业务逻辑，对外提供数据操作能力 + */ +public interface IKlptcm1ProPlantStateDefineService { + + + /** + * 分页查询状态定义 + * @param pageQuery 分页查询参数（含页码、每页条数） + * @return 分页表格数据（符合前端TableDataInfo格式） + */ + TableDataInfo getDefinePage(PageQuery pageQuery); + + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java index 0d261149..03868c5c 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java +++ b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateCurrentServiceImpl.java @@ -1,6 +1,9 @@ package com.klp.pocket.service.impl; import com.baomidou.dynamic.datasource.annotation.DS; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.page.TableDataInfo; import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; import com.klp.pocket.mapper.Klptcm1ProPlantStateCurrentMapper; import com.klp.pocket.service.IKlptcm1ProPlantStateCurrentService; @@ -17,8 +20,9 @@ public class Klptcm1ProPlantStateCurrentServiceImpl implements IKlptcm1ProPlantS @Override - public List selectAll() { - return klptcm1ProPlantStateCurrentMapper.selectAll(); + public TableDataInfo selectAll(PageQuery pageQuery) { + Page result = klptcm1ProPlantStateCurrentMapper.selectAll(pageQuery.build()); + return TableDataInfo.build(result); } } diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateDefineServiceImpl.java b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateDefineServiceImpl.java new file mode 100644 index 00000000..c1107936 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateDefineServiceImpl.java @@ -0,0 +1,36 @@ +package com.klp.pocket.service.impl; + +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.page.TableDataInfo; +import com.klp.pocket.domain.Klptcm1ProPlantStateCurrent; +import com.klp.pocket.domain.Klptcm1ProPlantStateDefine; +import com.klp.pocket.mapper.Klptcm1ProPlantStateDefineMapper; +import com.klp.pocket.service.IKlptcm1ProPlantStateDefineService; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import org.springframework.stereotype.Service; +import javax.annotation.Resource; +import java.math.BigDecimal; +import java.util.List; + +/** + * 工厂状态定义表Service实现类 + * 具体业务逻辑实现，依赖Mapper操作数据库 + */ +@Service +public class Klptcm1ProPlantStateDefineServiceImpl implements IKlptcm1ProPlantStateDefineService { + + @Resource + private Klptcm1ProPlantStateDefineMapper defineMapper; + + + @Override + public TableDataInfo getDefinePage(PageQuery pageQuery) { + // 构建分页对象（当前页码、每页条数） + Page result =defineMapper.selectPage(pageQuery.build()); + // 调用Mapper分页查询 + return TableDataInfo.build(result); + + } + +} diff --git a/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml index 1dfe0a6a..e232f660 100644 --- a/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml +++ b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateCurrentMapper.xml @@ -2,6 +2,7 @@ + @@ -9,15 +10,121 @@ + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + INSDATE, YEAR, MONTH, DAY, HOUR, MINUTE, TYPE, - VALUE1, VALUE2, VALUE99 + VALUE1, VALUE2, VALUE3, VALUE4, VALUE5, VALUE6, VALUE7, VALUE8, VALUE9, VALUE10, + VALUE11, VALUE12, VALUE13, VALUE14, VALUE15, VALUE16, VALUE17, VALUE18, VALUE19, VALUE20, + VALUE21, VALUE22, VALUE23, VALUE24, VALUE25, VALUE26, VALUE27, VALUE28, VALUE29, VALUE30, + VALUE31, VALUE32, VALUE33, VALUE34, VALUE35, VALUE36, VALUE37, VALUE38, VALUE39, VALUE40, + VALUE41, VALUE42, VALUE43, VALUE44, VALUE45, VALUE46, VALUE47, VALUE48, VALUE49, VALUE50, + VALUE51, VALUE52, VALUE53, VALUE54, VALUE55, VALUE56, VALUE57, VALUE58, VALUE59, VALUE60, + VALUE61, VALUE62, VALUE63, VALUE64, VALUE65, VALUE66, VALUE67, VALUE68, VALUE69, VALUE70, + VALUE71, VALUE72, VALUE73, VALUE74, VALUE75, VALUE76, VALUE77, VALUE78, VALUE79, VALUE80, + VALUE81, VALUE82, VALUE83, VALUE84, VALUE85, VALUE86, VALUE87, VALUE88, VALUE89, VALUE90, + VALUE91, VALUE92, VALUE93, VALUE94, VALUE95, VALUE96, VALUE97, VALUE98, VALUE99 diff --git a/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateDefineMapper.xml b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateDefineMapper.xml new file mode 100644 index 00000000..ec36d002 --- /dev/null +++ b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateDefineMapper.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + ID, NAME, UNITS, COMMENTS, INSDATE, MODELTYPE + + + + + + From 07582bbdb0c31b4649c3ec3456d00c799ace1f30 Mon Sep 17 00:00:00 2001 From: JR <3573153686@qq.com> Date: Mon, 27 Oct 2025 18:29:21 +0800 Subject: [PATCH 6/7] =?UTF-8?q?feat(pocket):=20=E6=96=B0=E5=A2=9E=E5=8E=86?= =?UTF-8?q?=E5=8F=B2=E6=95=B0=E6=8D=AE=E6=9F=A5=E8=AF=A2=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 创建历史数据实体类Klptcm1ProPlantStateHistory历史 - 实现数据业务逻辑接口与实现类 - 添加历史数据Mapper及XML映射文件 - 提供历史数据分页查询与列表查询接口- 构建历史数据查询条件封装方法- 注解历史数据Controller并暴露查询接口 - 移除Vo类中冗余的JSON格式化与Excel字典转换注解 --- ...Klptcm1ProPlantStateHistoryController.java | 35 +++ .../Klptcm1ProStoppageController.java | 35 +++ .../domain/Klptcm1ProPlantStateHistory.java | 128 +++++++++++ .../klp/pocket/domain/Klptcm1ProStoppage.java | 34 +++ .../bo/Klptcm1ProPlantStateHistoryBo.java | 217 ++++++++++++++++++ .../domain/bo/Klptcm1ProStoppageBo.java | 86 +++++++ .../vo/Klptcm1ProPlantStateCurrentVo.java | 215 +++++++++-------- .../vo/Klptcm1ProPlantStateHistoryVo.java | 128 +++++++++++ .../domain/vo/Klptcm1ProStoppageVo.java | 33 +++ .../Klptcm1ProPlantStateHistoryMapper.java | 15 ++ .../mapper/Klptcm1ProStoppageMapper.java | 15 ++ .../IKlptcm1ProPlantStateHistoryService.java | 34 +++ .../service/IKlptcm1ProStoppageService.java | 32 +++ ...lptcm1ProPlantStateHistoryServiceImpl.java | 172 ++++++++++++++ .../impl/Klptcm1ProStoppageServiceImpl.java | 80 +++++++ .../Klptcm1ProPlantStateHistoryMapper.xml | 117 ++++++++++ .../pocket/Klptcm1ProStoppageMapper.xml | 24 ++ 17 files changed, 1291 insertions(+), 109 deletions(-) create mode 100644 klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateHistoryController.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProStoppageController.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateHistory.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProStoppage.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProPlantStateHistoryBo.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProStoppageBo.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateHistoryVo.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProStoppageVo.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateHistoryMapper.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProStoppageMapper.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateHistoryService.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProStoppageService.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateHistoryServiceImpl.java create mode 100644 klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProStoppageServiceImpl.java create mode 100644 klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateHistoryMapper.xml create mode 100644 klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProStoppageMapper.xml diff --git a/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateHistoryController.java b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateHistoryController.java new file mode 100644 index 00000000..11e8e301 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProPlantStateHistoryController.java @@ -0,0 +1,35 @@ +package com.klp.pocket.controller; + +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.pocket.domain.vo.Klptcm1ProPlantStateHistoryVo; +import com.klp.pocket.domain.bo.Klptcm1ProPlantStateHistoryBo; +import com.klp.pocket.service.IKlptcm1ProPlantStateHistoryService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 历史 + * + * @author klp + * @date 2025-10-27 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pocket/proPlantStateHistory") +public class Klptcm1ProPlantStateHistoryController extends BaseController { + + private final IKlptcm1ProPlantStateHistoryService iKlptcm1ProPlantStateHistoryService; + + /** + * 查询历史列表 + */ + @GetMapping("/list") + public TableDataInfo list(Klptcm1ProPlantStateHistoryBo bo, PageQuery pageQuery) { + return iKlptcm1ProPlantStateHistoryService.queryPageList(bo, pageQuery); + } + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProStoppageController.java b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProStoppageController.java new file mode 100644 index 00000000..91e6f97d --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/controller/Klptcm1ProStoppageController.java @@ -0,0 +1,35 @@ +package com.klp.pocket.controller; + +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.pocket.domain.vo.Klptcm1ProStoppageVo; +import com.klp.pocket.domain.bo.Klptcm1ProStoppageBo; +import com.klp.pocket.service.IKlptcm1ProStoppageService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 停机 + * + * @author klp + * @date 2025-10-27 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pocket/proStoppage") +public class Klptcm1ProStoppageController extends BaseController { + + private final IKlptcm1ProStoppageService iKlptcm1ProStoppageService; + + /** + * 查询停机列表 + */ + @GetMapping("/list") + public TableDataInfo list(Klptcm1ProStoppageBo bo, PageQuery pageQuery) { + return iKlptcm1ProStoppageService.queryPageList(bo, pageQuery); + } + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateHistory.java b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateHistory.java new file mode 100644 index 00000000..c76de46e --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProPlantStateHistory.java @@ -0,0 +1,128 @@ +package com.klp.pocket.domain; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.math.BigDecimal; +import java.util.Date; + +/** + * 历史对象 klptcm1_pro_plant_state_history + * + * @author klp + * @date 2025-10-27 + */ +@Data +@TableName("klptcm1_pro_plant_state_history") +public class Klptcm1ProPlantStateHistory{ + + private static final long serialVersionUID=1L; + + private Date insdate; + private Long year; + private Long month; + private Long day; + private Long hour; + private Long minute; + private Long type; + private BigDecimal value1; + private BigDecimal value2; + private BigDecimal value3; + private BigDecimal value4; + private BigDecimal value5; + private BigDecimal value6; + private BigDecimal value7; + private BigDecimal value8; + private BigDecimal value9; + private BigDecimal value10; + private BigDecimal value11; + private BigDecimal value12; + private BigDecimal value13; + private BigDecimal value14; + private BigDecimal value15; + private BigDecimal value16; + private BigDecimal value17; + private BigDecimal value18; + private BigDecimal value19; + private BigDecimal value20; + private BigDecimal value21; + private BigDecimal value22; + private BigDecimal value23; + private BigDecimal value24; + private BigDecimal value25; + private BigDecimal value26; + private BigDecimal value27; + private BigDecimal value28; + private BigDecimal value29; + private BigDecimal value30; + private BigDecimal value31; + private BigDecimal value32; + private BigDecimal value33; + private BigDecimal value34; + private BigDecimal value35; + private BigDecimal value36; + private BigDecimal value37; + private BigDecimal value38; + private BigDecimal value39; + private BigDecimal value40; + private BigDecimal value41; + private BigDecimal value42; + private BigDecimal value43; + private BigDecimal value44; + private BigDecimal value45; + private BigDecimal value46; + private BigDecimal value47; + private BigDecimal value48; + private BigDecimal value49; + private BigDecimal value50; + private BigDecimal value51; + private BigDecimal value52; + private BigDecimal value53; + private BigDecimal value54; + private BigDecimal value55; + private BigDecimal value56; + private BigDecimal value57; + private BigDecimal value58; + private BigDecimal value59; + private BigDecimal value60; + private BigDecimal value61; + private BigDecimal value62; + private BigDecimal value63; + private BigDecimal value64; + private BigDecimal value65; + private BigDecimal value66; + private BigDecimal value67; + private BigDecimal value68; + private BigDecimal value69; + private BigDecimal value70; + private BigDecimal value71; + private BigDecimal value72; + private BigDecimal value73; + private BigDecimal value74; + private BigDecimal value75; + private BigDecimal value76; + private BigDecimal value77; + private BigDecimal value78; + private BigDecimal value79; + private BigDecimal value80; + private BigDecimal value81; + private BigDecimal value82; + private BigDecimal value83; + private BigDecimal value84; + private BigDecimal value85; + private BigDecimal value86; + private BigDecimal value87; + private BigDecimal value88; + private BigDecimal value89; + private BigDecimal value90; + private BigDecimal value91; + private BigDecimal value92; + private BigDecimal value93; + private BigDecimal value94; + private BigDecimal value95; + private BigDecimal value96; + private BigDecimal value97; + private BigDecimal value98; + private BigDecimal value99; + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProStoppage.java b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProStoppage.java new file mode 100644 index 00000000..bf79e694 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/Klptcm1ProStoppage.java @@ -0,0 +1,34 @@ +package com.klp.pocket.domain; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; + +import java.util.Date; + +/** + * 停机对象 klptcm1_pro_stoppage + * + * @author klp + * @date 2025-10-27 + */ +@Data +@TableName("klptcm1_pro_stoppage") +public class Klptcm1ProStoppage{ + + private static final long serialVersionUID=1L; + + private Long stopid; + private String encoilid; + private String shift; + private String crew; + private String area; + private String unit; + private String seton; + private String remark; + private Date startDate; + private Date endDate; + private Long duration; + private Date insDate; + private String stopType; + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProPlantStateHistoryBo.java b/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProPlantStateHistoryBo.java new file mode 100644 index 00000000..902a1dd6 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProPlantStateHistoryBo.java @@ -0,0 +1,217 @@ +package com.klp.pocket.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; +import java.util.Date; + +/** + * 历史业务对象 klptcm1_pro_plant_state_history + * + * @author klp + * @date 2025-10-27 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class Klptcm1ProPlantStateHistoryBo extends BaseEntity { + + private Date INSDATE; + private Long YEAR; + private Long MONTH; + private Long DAY; + private Long HOUR; + private Long MINUTE; + private Long TYPE; + private BigDecimal VALUE1; + private BigDecimal VALUE2; + private BigDecimal VALUE3; + private BigDecimal VALUE4; + private BigDecimal VALUE5; + private BigDecimal VALUE6; + private BigDecimal VALUE7; + private BigDecimal VALUE8; + private BigDecimal VALUE9; + private BigDecimal VALUE10; + private BigDecimal VALUE11; + + private BigDecimal VALUE12; + + private BigDecimal VALUE13; + + private BigDecimal VALUE14; + + private BigDecimal VALUE15; + + private BigDecimal VALUE16; + + private BigDecimal VALUE17; + + private BigDecimal VALUE18; + + private BigDecimal VALUE19; + + private BigDecimal VALUE20; + + private BigDecimal VALUE21; + + private BigDecimal VALUE22; + + private BigDecimal VALUE23; + + private BigDecimal VALUE24; + + private BigDecimal VALUE25; + + private BigDecimal VALUE26; + + private BigDecimal VALUE27; + + private BigDecimal VALUE28; + + private BigDecimal VALUE29; + + private BigDecimal VALUE30; + + private BigDecimal VALUE31; + + private BigDecimal VALUE32; + + private BigDecimal VALUE33; + + private BigDecimal VALUE34; + + private BigDecimal VALUE35; + + private BigDecimal VALUE36; + + private BigDecimal VALUE37; + + private BigDecimal VALUE38; + + private BigDecimal VALUE39; + + private BigDecimal VALUE40; + + private BigDecimal VALUE41; + + private BigDecimal VALUE42; + + private BigDecimal VALUE43; + + private BigDecimal VALUE44; + + private BigDecimal VALUE45; + + private BigDecimal VALUE46; + + private BigDecimal VALUE47; + + private BigDecimal VALUE48; + + private BigDecimal VALUE49; + + private BigDecimal VALUE50; + + private BigDecimal VALUE51; + + private BigDecimal VALUE52; + + private BigDecimal VALUE53; + + private BigDecimal VALUE54; + + private BigDecimal VALUE55; + + private BigDecimal VALUE56; + + private BigDecimal VALUE57; + + private BigDecimal VALUE58; + + private BigDecimal VALUE59; + + private BigDecimal VALUE60; + + private BigDecimal VALUE61; + + private BigDecimal VALUE62; + + private BigDecimal VALUE63; + + private BigDecimal VALUE64; + + private BigDecimal VALUE65; + + private BigDecimal VALUE66; + + private BigDecimal VALUE67; + + private BigDecimal VALUE68; + + private BigDecimal VALUE69; + + private BigDecimal VALUE70; + + private BigDecimal VALUE71; + + private BigDecimal VALUE72; + + private BigDecimal VALUE73; + + private BigDecimal VALUE74; + + private BigDecimal VALUE75; + + private BigDecimal VALUE76; + + private BigDecimal VALUE77; + + private BigDecimal VALUE78; + + private BigDecimal VALUE79; + + private BigDecimal VALUE80; + + private BigDecimal VALUE81; + + private BigDecimal VALUE82; + + private BigDecimal VALUE83; + + private BigDecimal VALUE84; + + private BigDecimal VALUE85; + + private BigDecimal VALUE86; + + private BigDecimal VALUE87; + + private BigDecimal VALUE88; + + private BigDecimal VALUE89; + + private BigDecimal VALUE90; + + private BigDecimal VALUE91; + + private BigDecimal VALUE92; + + private BigDecimal VALUE93; + + private BigDecimal VALUE94; + + private BigDecimal VALUE95; + + private BigDecimal VALUE96; + + private BigDecimal VALUE97; + + private BigDecimal VALUE98; + + private BigDecimal VALUE99; + + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProStoppageBo.java b/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProStoppageBo.java new file mode 100644 index 00000000..921ed93e --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/bo/Klptcm1ProStoppageBo.java @@ -0,0 +1,86 @@ +package com.klp.pocket.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.util.Date; + +/** + * 停机业务对象 klptcm1_pro_stoppage + * + * @author klp + * @date 2025-10-27 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class Klptcm1ProStoppageBo extends BaseEntity { + + /** + * + */ + private Long STOPID; + + /** + * + */ + private String ENCOILID; + + /** + * + */ + private String SHIFT; + + /** + * + */ + private String CREW; + + /** + * + */ + private String AREA; + + /** + * + */ + private String UNIT; + + /** + * + */ + private String SETON; + + /** + * + */ + private String REMARK; + + /** + * + */ + private Date startDate; + + /** + * + */ + private Date endDate; + + /** + * + */ + private Long DURATION; + + /** + * + */ + private Date insDate; + + /** + * + */ + private String stopType; + + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateCurrentVo.java b/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateCurrentVo.java index 28d98742..4dc684aa 100644 --- a/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateCurrentVo.java +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateCurrentVo.java @@ -2,11 +2,8 @@ package com.klp.pocket.domain.vo; import java.math.BigDecimal; import java.util.Date; -import com.fasterxml.jackson.annotation.JsonFormat; import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; import com.alibaba.excel.annotation.ExcelProperty; -import com.klp.common.annotation.ExcelDictFormat; -import com.klp.common.convert.ExcelDictConvert; import lombok.Data; @@ -23,637 +20,637 @@ public class Klptcm1ProPlantStateCurrentVo { private static final long serialVersionUID = 1L; /** - * + * */ @ExcelProperty(value = "") private Date INSDATE; /** - * + * */ @ExcelProperty(value = "") private Long YEAR; /** - * + * */ @ExcelProperty(value = "") private Long MONTH; /** - * + * */ @ExcelProperty(value = "") private Long DAY; /** - * + * */ @ExcelProperty(value = "") private Long HOUR; /** - * + * */ @ExcelProperty(value = "") private Long MINUTE; /** - * + * */ @ExcelProperty(value = "") private Long TYPE; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE1; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE2; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE3; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE4; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE5; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE6; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE7; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE8; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE9; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE10; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE11; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE12; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE13; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE14; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE15; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE16; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE17; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE18; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE19; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE20; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE21; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE22; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE23; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE24; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE25; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE26; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE27; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE28; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE29; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE30; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE31; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE32; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE33; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE34; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE35; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE36; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE37; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE38; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE39; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE40; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE41; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE42; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE43; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE44; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE45; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE46; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE47; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE48; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE49; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE50; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE51; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE52; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE53; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE54; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE55; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE56; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE57; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE58; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE59; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE60; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE61; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE62; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE63; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE64; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE65; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE66; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE67; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE68; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE69; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE70; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE71; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE72; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE73; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE74; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE75; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE76; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE77; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE78; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE79; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE80; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE81; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE82; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE83; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE84; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE85; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE86; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE87; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE88; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE89; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE90; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE91; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE92; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE93; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE94; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE95; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE96; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE97; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE98; /** - * + * */ @ExcelProperty(value = "") private BigDecimal VALUE99; diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateHistoryVo.java b/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateHistoryVo.java new file mode 100644 index 00000000..cb6f44c8 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProPlantStateHistoryVo.java @@ -0,0 +1,128 @@ +package com.klp.pocket.domain.vo; + +import java.math.BigDecimal; +import java.util.Date; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import lombok.Data; + + +/** + * 历史视图对象 klptcm1_pro_plant_state_history + * + * @author klp + * @date 2025-10-27 + */ +@Data +@ExcelIgnoreUnannotated +public class Klptcm1ProPlantStateHistoryVo { + + private static final long serialVersionUID = 1L; + + private Date insdate; + private Long year; + private Long month; + private Long day; + private Long hour; + private Long minute; + private Long type; + private BigDecimal value1; + private BigDecimal value2; + private BigDecimal value3; + private BigDecimal value4; + private BigDecimal value5; + private BigDecimal value6; + private BigDecimal value7; + private BigDecimal value8; + private BigDecimal value9; + private BigDecimal value10; + private BigDecimal value11; + private BigDecimal value12; + private BigDecimal value13; + private BigDecimal value14; + private BigDecimal value15; + private BigDecimal value16; + private BigDecimal value17; + private BigDecimal value18; + private BigDecimal value19; + private BigDecimal value20; + private BigDecimal value21; + private BigDecimal value22; + private BigDecimal value23; + private BigDecimal value24; + private BigDecimal value25; + private BigDecimal value26; + private BigDecimal value27; + private BigDecimal value28; + private BigDecimal value29; + private BigDecimal value30; + private BigDecimal value31; + private BigDecimal value32; + private BigDecimal value33; + private BigDecimal value34; + private BigDecimal value35; + private BigDecimal value36; + private BigDecimal value37; + private BigDecimal value38; + private BigDecimal value39; + private BigDecimal value40; + private BigDecimal value41; + private BigDecimal value42; + private BigDecimal value43; + private BigDecimal value44; + private BigDecimal value45; + private BigDecimal value46; + private BigDecimal value47; + private BigDecimal value48; + private BigDecimal value49; + private BigDecimal value50; + private BigDecimal value51; + private BigDecimal value52; + private BigDecimal value53; + private BigDecimal value54; + private BigDecimal value55; + private BigDecimal value56; + private BigDecimal value57; + private BigDecimal value58; + private BigDecimal value59; + private BigDecimal value60; + private BigDecimal value61; + private BigDecimal value62; + private BigDecimal value63; + private BigDecimal value64; + private BigDecimal value65; + private BigDecimal value66; + private BigDecimal value67; + private BigDecimal value68; + private BigDecimal value69; + private BigDecimal value70; + private BigDecimal value71; + private BigDecimal value72; + private BigDecimal value73; + private BigDecimal value74; + private BigDecimal value75; + private BigDecimal value76; + private BigDecimal value77; + private BigDecimal value78; + private BigDecimal value79; + private BigDecimal value80; + private BigDecimal value81; + private BigDecimal value82; + private BigDecimal value83; + private BigDecimal value84; + private BigDecimal value85; + private BigDecimal value86; + private BigDecimal value87; + private BigDecimal value88; + private BigDecimal value89; + private BigDecimal value90; + private BigDecimal value91; + private BigDecimal value92; + private BigDecimal value93; + private BigDecimal value94; + private BigDecimal value95; + private BigDecimal value96; + private BigDecimal value97; + private BigDecimal value98; + private BigDecimal value99; + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProStoppageVo.java b/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProStoppageVo.java new file mode 100644 index 00000000..c219b5a7 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/domain/vo/Klptcm1ProStoppageVo.java @@ -0,0 +1,33 @@ +package com.klp.pocket.domain.vo; + +import java.util.Date; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import lombok.Data; + + +/** + * 停机视图对象 klptcm1_pro_stoppage + * + * @author klp + * @date 2025-10-27 + */ +@Data +@ExcelIgnoreUnannotated +public class Klptcm1ProStoppageVo { + + private static final long serialVersionUID = 1L; + + private Long stopid; + private String encoilid; + private String shift; + private String crew; + private String area; + private String unit; + private String seton; + private String remark; + private Date startDate; + private Date endDate; + private Long duration; + private Date insDate; + private String stopType; +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateHistoryMapper.java b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateHistoryMapper.java new file mode 100644 index 00000000..f8a6272a --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProPlantStateHistoryMapper.java @@ -0,0 +1,15 @@ +package com.klp.pocket.mapper; + +import com.klp.pocket.domain.Klptcm1ProPlantStateHistory; +import com.klp.pocket.domain.vo.Klptcm1ProPlantStateHistoryVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 历史Mapper接口 + * + * @author klp + * @date 2025-10-27 + */ +public interface Klptcm1ProPlantStateHistoryMapper extends BaseMapperPlus { + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProStoppageMapper.java b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProStoppageMapper.java new file mode 100644 index 00000000..1c51a9fa --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/mapper/Klptcm1ProStoppageMapper.java @@ -0,0 +1,15 @@ +package com.klp.pocket.mapper; + +import com.klp.pocket.domain.Klptcm1ProStoppage; +import com.klp.pocket.domain.vo.Klptcm1ProStoppageVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 停机Mapper接口 + * + * @author klp + * @date 2025-10-27 + */ +public interface Klptcm1ProStoppageMapper extends BaseMapperPlus { + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateHistoryService.java b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateHistoryService.java new file mode 100644 index 00000000..640bdfb2 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProPlantStateHistoryService.java @@ -0,0 +1,34 @@ +package com.klp.pocket.service; + +import com.klp.pocket.domain.vo.Klptcm1ProPlantStateHistoryVo; +import com.klp.pocket.domain.bo.Klptcm1ProPlantStateHistoryBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Date; +import java.util.List; + +/** + * 历史Service接口 + * + * @author klp + * @date 2025-10-27 + */ +public interface IKlptcm1ProPlantStateHistoryService { + + /** + * 查询历史 + */ + Klptcm1ProPlantStateHistoryVo queryById(Date INSDATE); + + /** + * 查询历史列表 + */ + TableDataInfo queryPageList(Klptcm1ProPlantStateHistoryBo bo, PageQuery pageQuery); + + /** + * 查询历史列表 + */ + List queryList(Klptcm1ProPlantStateHistoryBo bo); + +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProStoppageService.java b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProStoppageService.java new file mode 100644 index 00000000..048b5164 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/service/IKlptcm1ProStoppageService.java @@ -0,0 +1,32 @@ +package com.klp.pocket.service; + +import com.klp.pocket.domain.vo.Klptcm1ProStoppageVo; +import com.klp.pocket.domain.bo.Klptcm1ProStoppageBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.List; + +/** + * 停机Service接口 + * + * @author klp + * @date 2025-10-27 + */ +public interface IKlptcm1ProStoppageService { + + /** + * 查询停机 + */ + Klptcm1ProStoppageVo queryById(Long STOPID); + + /** + * 查询停机列表 + */ + TableDataInfo queryPageList(Klptcm1ProStoppageBo bo, PageQuery pageQuery); + + /** + * 查询停机列表 + */ + List queryList(Klptcm1ProStoppageBo bo); +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateHistoryServiceImpl.java b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateHistoryServiceImpl.java new file mode 100644 index 00000000..50716c91 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProPlantStateHistoryServiceImpl.java @@ -0,0 +1,172 @@ +package com.klp.pocket.service.impl; + +import com.baomidou.dynamic.datasource.annotation.DS; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pocket.domain.bo.Klptcm1ProPlantStateHistoryBo; +import com.klp.pocket.domain.vo.Klptcm1ProPlantStateHistoryVo; +import com.klp.pocket.domain.Klptcm1ProPlantStateHistory; +import com.klp.pocket.mapper.Klptcm1ProPlantStateHistoryMapper; +import com.klp.pocket.service.IKlptcm1ProPlantStateHistoryService; + +import java.util.Date; +import java.util.List; +import java.util.Map; + +/** + * 历史Service业务层处理 + * + * @author klp + * @date 2025-10-27 + */ +@RequiredArgsConstructor +@DS("slave") +@Service +public class Klptcm1ProPlantStateHistoryServiceImpl implements IKlptcm1ProPlantStateHistoryService { + + private final Klptcm1ProPlantStateHistoryMapper baseMapper; + + /** + * 查询历史 + */ + @Override + public Klptcm1ProPlantStateHistoryVo queryById(Date INSDATE){ + return baseMapper.selectVoById(INSDATE); + } + + /** + * 查询历史列表 + */ + @Override + public TableDataInfo queryPageList(Klptcm1ProPlantStateHistoryBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询历史列表 + */ + @Override + public List queryList(Klptcm1ProPlantStateHistoryBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(Klptcm1ProPlantStateHistoryBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getINSDATE() != null, Klptcm1ProPlantStateHistory::getInsdate, bo.getINSDATE()); + lqw.eq(bo.getYEAR() != null, Klptcm1ProPlantStateHistory::getYear, bo.getYEAR()); + lqw.eq(bo.getMONTH() != null, Klptcm1ProPlantStateHistory::getMonth, bo.getMONTH()); + lqw.eq(bo.getDAY() != null, Klptcm1ProPlantStateHistory::getDay, bo.getDAY()); + lqw.eq(bo.getHOUR() != null, Klptcm1ProPlantStateHistory::getHour, bo.getHOUR()); + lqw.eq(bo.getMINUTE() != null, Klptcm1ProPlantStateHistory::getMinute, bo.getMINUTE()); + lqw.eq(bo.getTYPE() != null, Klptcm1ProPlantStateHistory::getType, bo.getTYPE()); + lqw.eq(bo.getVALUE1() != null, Klptcm1ProPlantStateHistory::getValue1, bo.getVALUE1()); + lqw.eq(bo.getVALUE2() != null, Klptcm1ProPlantStateHistory::getValue2, bo.getVALUE2()); + lqw.eq(bo.getVALUE3() != null, Klptcm1ProPlantStateHistory::getValue3, bo.getVALUE3()); + lqw.eq(bo.getVALUE4() != null, Klptcm1ProPlantStateHistory::getValue4, bo.getVALUE4()); + lqw.eq(bo.getVALUE5() != null, Klptcm1ProPlantStateHistory::getValue5, bo.getVALUE5()); + lqw.eq(bo.getVALUE6() != null, Klptcm1ProPlantStateHistory::getValue6, bo.getVALUE6()); + lqw.eq(bo.getVALUE7() != null, Klptcm1ProPlantStateHistory::getValue7, bo.getVALUE7()); + lqw.eq(bo.getVALUE8() != null, Klptcm1ProPlantStateHistory::getValue8, bo.getVALUE8()); + lqw.eq(bo.getVALUE9() != null, Klptcm1ProPlantStateHistory::getValue9, bo.getVALUE9()); + lqw.eq(bo.getVALUE10() != null, Klptcm1ProPlantStateHistory::getValue10, bo.getVALUE10()); + lqw.eq(bo.getVALUE11() != null, Klptcm1ProPlantStateHistory::getValue11, bo.getVALUE11()); + lqw.eq(bo.getVALUE12() != null, Klptcm1ProPlantStateHistory::getValue12, bo.getVALUE12()); + lqw.eq(bo.getVALUE13() != null, Klptcm1ProPlantStateHistory::getValue13, bo.getVALUE13()); + lqw.eq(bo.getVALUE14() != null, Klptcm1ProPlantStateHistory::getValue14, bo.getVALUE14()); + lqw.eq(bo.getVALUE15() != null, Klptcm1ProPlantStateHistory::getValue15, bo.getVALUE15()); + lqw.eq(bo.getVALUE16() != null, Klptcm1ProPlantStateHistory::getValue16, bo.getVALUE16()); + lqw.eq(bo.getVALUE17() != null, Klptcm1ProPlantStateHistory::getValue17, bo.getVALUE17()); + lqw.eq(bo.getVALUE18() != null, Klptcm1ProPlantStateHistory::getValue18, bo.getVALUE18()); + lqw.eq(bo.getVALUE19() != null, Klptcm1ProPlantStateHistory::getValue19, bo.getVALUE19()); + lqw.eq(bo.getVALUE20() != null, Klptcm1ProPlantStateHistory::getValue20, bo.getVALUE20()); + lqw.eq(bo.getVALUE21() != null, Klptcm1ProPlantStateHistory::getValue21, bo.getVALUE21()); + lqw.eq(bo.getVALUE22() != null, Klptcm1ProPlantStateHistory::getValue22, bo.getVALUE22()); + lqw.eq(bo.getVALUE23() != null, Klptcm1ProPlantStateHistory::getValue23, bo.getVALUE23()); + lqw.eq(bo.getVALUE24() != null, Klptcm1ProPlantStateHistory::getValue24, bo.getVALUE24()); + lqw.eq(bo.getVALUE25() != null, Klptcm1ProPlantStateHistory::getValue25, bo.getVALUE25()); + lqw.eq(bo.getVALUE26() != null, Klptcm1ProPlantStateHistory::getValue26, bo.getVALUE26()); + lqw.eq(bo.getVALUE27() != null, Klptcm1ProPlantStateHistory::getValue27, bo.getVALUE27()); + lqw.eq(bo.getVALUE28() != null, Klptcm1ProPlantStateHistory::getValue28, bo.getVALUE28()); + lqw.eq(bo.getVALUE29() != null, Klptcm1ProPlantStateHistory::getValue29, bo.getVALUE29()); + lqw.eq(bo.getVALUE30() != null, Klptcm1ProPlantStateHistory::getValue30, bo.getVALUE30()); + lqw.eq(bo.getVALUE31() != null, Klptcm1ProPlantStateHistory::getValue31, bo.getVALUE31()); + lqw.eq(bo.getVALUE32() != null, Klptcm1ProPlantStateHistory::getValue32, bo.getVALUE32()); + lqw.eq(bo.getVALUE33() != null, Klptcm1ProPlantStateHistory::getValue33, bo.getVALUE33()); + lqw.eq(bo.getVALUE34() != null, Klptcm1ProPlantStateHistory::getValue34, bo.getVALUE34()); + lqw.eq(bo.getVALUE35() != null, Klptcm1ProPlantStateHistory::getValue35, bo.getVALUE35()); + lqw.eq(bo.getVALUE36() != null, Klptcm1ProPlantStateHistory::getValue36, bo.getVALUE36()); + lqw.eq(bo.getVALUE37() != null, Klptcm1ProPlantStateHistory::getValue37, bo.getVALUE37()); + lqw.eq(bo.getVALUE38() != null, Klptcm1ProPlantStateHistory::getValue38, bo.getVALUE38()); + lqw.eq(bo.getVALUE39() != null, Klptcm1ProPlantStateHistory::getValue39, bo.getVALUE39()); + lqw.eq(bo.getVALUE40() != null, Klptcm1ProPlantStateHistory::getValue40, bo.getVALUE40()); + lqw.eq(bo.getVALUE41() != null, Klptcm1ProPlantStateHistory::getValue41, bo.getVALUE41()); + lqw.eq(bo.getVALUE42() != null, Klptcm1ProPlantStateHistory::getValue42, bo.getVALUE42()); + lqw.eq(bo.getVALUE43() != null, Klptcm1ProPlantStateHistory::getValue43, bo.getVALUE43()); + lqw.eq(bo.getVALUE44() != null, Klptcm1ProPlantStateHistory::getValue44, bo.getVALUE44()); + lqw.eq(bo.getVALUE45() != null, Klptcm1ProPlantStateHistory::getValue45, bo.getVALUE45()); + lqw.eq(bo.getVALUE46() != null, Klptcm1ProPlantStateHistory::getValue46, bo.getVALUE46()); + lqw.eq(bo.getVALUE47() != null, Klptcm1ProPlantStateHistory::getValue47, bo.getVALUE47()); + lqw.eq(bo.getVALUE48() != null, Klptcm1ProPlantStateHistory::getValue48, bo.getVALUE48()); + lqw.eq(bo.getVALUE49() != null, Klptcm1ProPlantStateHistory::getValue49, bo.getVALUE49()); + lqw.eq(bo.getVALUE50() != null, Klptcm1ProPlantStateHistory::getValue50, bo.getVALUE50()); + lqw.eq(bo.getVALUE51() != null, Klptcm1ProPlantStateHistory::getValue51, bo.getVALUE51()); + lqw.eq(bo.getVALUE52() != null, Klptcm1ProPlantStateHistory::getValue52, bo.getVALUE52()); + lqw.eq(bo.getVALUE53() != null, Klptcm1ProPlantStateHistory::getValue53, bo.getVALUE53()); + lqw.eq(bo.getVALUE54() != null, Klptcm1ProPlantStateHistory::getValue54, bo.getVALUE54()); + lqw.eq(bo.getVALUE55() != null, Klptcm1ProPlantStateHistory::getValue55, bo.getVALUE55()); + lqw.eq(bo.getVALUE56() != null, Klptcm1ProPlantStateHistory::getValue56, bo.getVALUE56()); + lqw.eq(bo.getVALUE57() != null, Klptcm1ProPlantStateHistory::getValue57, bo.getVALUE57()); + lqw.eq(bo.getVALUE58() != null, Klptcm1ProPlantStateHistory::getValue58, bo.getVALUE58()); + lqw.eq(bo.getVALUE59() != null, Klptcm1ProPlantStateHistory::getValue59, bo.getVALUE59()); + lqw.eq(bo.getVALUE60() != null, Klptcm1ProPlantStateHistory::getValue60, bo.getVALUE60()); + lqw.eq(bo.getVALUE61() != null, Klptcm1ProPlantStateHistory::getValue61, bo.getVALUE61()); + lqw.eq(bo.getVALUE62() != null, Klptcm1ProPlantStateHistory::getValue62, bo.getVALUE62()); + lqw.eq(bo.getVALUE63() != null, Klptcm1ProPlantStateHistory::getValue63, bo.getVALUE63()); + lqw.eq(bo.getVALUE64() != null, Klptcm1ProPlantStateHistory::getValue64, bo.getVALUE64()); + lqw.eq(bo.getVALUE65() != null, Klptcm1ProPlantStateHistory::getValue65, bo.getVALUE65()); + lqw.eq(bo.getVALUE66() != null, Klptcm1ProPlantStateHistory::getValue66, bo.getVALUE66()); + lqw.eq(bo.getVALUE67() != null, Klptcm1ProPlantStateHistory::getValue67, bo.getVALUE67()); + lqw.eq(bo.getVALUE68() != null, Klptcm1ProPlantStateHistory::getValue68, bo.getVALUE68()); + lqw.eq(bo.getVALUE69() != null, Klptcm1ProPlantStateHistory::getValue69, bo.getVALUE69()); + lqw.eq(bo.getVALUE70() != null, Klptcm1ProPlantStateHistory::getValue70, bo.getVALUE70()); + lqw.eq(bo.getVALUE71() != null, Klptcm1ProPlantStateHistory::getValue71, bo.getVALUE71()); + lqw.eq(bo.getVALUE72() != null, Klptcm1ProPlantStateHistory::getValue72, bo.getVALUE72()); + lqw.eq(bo.getVALUE73() != null, Klptcm1ProPlantStateHistory::getValue73, bo.getVALUE73()); + lqw.eq(bo.getVALUE74() != null, Klptcm1ProPlantStateHistory::getValue74, bo.getVALUE74()); + lqw.eq(bo.getVALUE75() != null, Klptcm1ProPlantStateHistory::getValue75, bo.getVALUE75()); + lqw.eq(bo.getVALUE76() != null, Klptcm1ProPlantStateHistory::getValue76, bo.getVALUE76()); + lqw.eq(bo.getVALUE77() != null, Klptcm1ProPlantStateHistory::getValue77, bo.getVALUE77()); + lqw.eq(bo.getVALUE78() != null, Klptcm1ProPlantStateHistory::getValue78, bo.getVALUE78()); + lqw.eq(bo.getVALUE79() != null, Klptcm1ProPlantStateHistory::getValue79, bo.getVALUE79()); + lqw.eq(bo.getVALUE80() != null, Klptcm1ProPlantStateHistory::getValue80, bo.getVALUE80()); + lqw.eq(bo.getVALUE81() != null, Klptcm1ProPlantStateHistory::getValue81, bo.getVALUE81()); + lqw.eq(bo.getVALUE82() != null, Klptcm1ProPlantStateHistory::getValue82, bo.getVALUE82()); + lqw.eq(bo.getVALUE83() != null, Klptcm1ProPlantStateHistory::getValue83, bo.getVALUE83()); + lqw.eq(bo.getVALUE84() != null, Klptcm1ProPlantStateHistory::getValue84, bo.getVALUE84()); + lqw.eq(bo.getVALUE85() != null, Klptcm1ProPlantStateHistory::getValue85, bo.getVALUE85()); + lqw.eq(bo.getVALUE86() != null, Klptcm1ProPlantStateHistory::getValue86, bo.getVALUE86()); + lqw.eq(bo.getVALUE87() != null, Klptcm1ProPlantStateHistory::getValue87, bo.getVALUE87()); + lqw.eq(bo.getVALUE88() != null, Klptcm1ProPlantStateHistory::getValue88, bo.getVALUE88()); + lqw.eq(bo.getVALUE89() != null, Klptcm1ProPlantStateHistory::getValue89, bo.getVALUE89()); + lqw.eq(bo.getVALUE90() != null, Klptcm1ProPlantStateHistory::getValue90, bo.getVALUE90()); + lqw.eq(bo.getVALUE91() != null, Klptcm1ProPlantStateHistory::getValue91, bo.getVALUE91()); + lqw.eq(bo.getVALUE92() != null, Klptcm1ProPlantStateHistory::getValue92, bo.getVALUE92()); + lqw.eq(bo.getVALUE93() != null, Klptcm1ProPlantStateHistory::getValue93, bo.getVALUE93()); + lqw.eq(bo.getVALUE94() != null, Klptcm1ProPlantStateHistory::getValue94, bo.getVALUE94()); + lqw.eq(bo.getVALUE95() != null, Klptcm1ProPlantStateHistory::getValue95, bo.getVALUE95()); + lqw.eq(bo.getVALUE96() != null, Klptcm1ProPlantStateHistory::getValue96, bo.getVALUE96()); + lqw.eq(bo.getVALUE97() != null, Klptcm1ProPlantStateHistory::getValue97, bo.getVALUE97()); + lqw.eq(bo.getVALUE98() != null, Klptcm1ProPlantStateHistory::getValue98, bo.getVALUE98()); + lqw.eq(bo.getVALUE99() != null, Klptcm1ProPlantStateHistory::getValue99, bo.getVALUE99()); + return lqw; + } +} diff --git a/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProStoppageServiceImpl.java b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProStoppageServiceImpl.java new file mode 100644 index 00000000..826a3254 --- /dev/null +++ b/klp-pocket/src/main/java/com/klp/pocket/service/impl/Klptcm1ProStoppageServiceImpl.java @@ -0,0 +1,80 @@ +package com.klp.pocket.service.impl; + +import com.baomidou.dynamic.datasource.annotation.DS; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pocket.domain.bo.Klptcm1ProStoppageBo; +import com.klp.pocket.domain.vo.Klptcm1ProStoppageVo; +import com.klp.pocket.domain.Klptcm1ProStoppage; +import com.klp.pocket.mapper.Klptcm1ProStoppageMapper; +import com.klp.pocket.service.IKlptcm1ProStoppageService; + +import java.util.List; +import java.util.Map; + +/** + * 停机Service业务层处理 + * + * @author klp + * @date 2025-10-27 + */ +@RequiredArgsConstructor +@DS("slave") +@Service +public class Klptcm1ProStoppageServiceImpl implements IKlptcm1ProStoppageService { + + private final Klptcm1ProStoppageMapper baseMapper; + + /** + * 查询停机 + */ + @Override + public Klptcm1ProStoppageVo queryById(Long STOPID){ + return baseMapper.selectVoById(STOPID); + } + + /** + * 查询停机列表 + */ + @Override + public TableDataInfo queryPageList(Klptcm1ProStoppageBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询停机列表 + */ + @Override + public List queryList(Klptcm1ProStoppageBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(Klptcm1ProStoppageBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getSTOPID() != null, Klptcm1ProStoppage::getStopid, bo.getSTOPID()); + lqw.eq(StringUtils.isNotBlank(bo.getENCOILID()), Klptcm1ProStoppage::getEncoilid, bo.getENCOILID()); + lqw.eq(StringUtils.isNotBlank(bo.getSHIFT()), Klptcm1ProStoppage::getShift, bo.getSHIFT()); + lqw.eq(StringUtils.isNotBlank(bo.getCREW()), Klptcm1ProStoppage::getCrew, bo.getCREW()); + lqw.eq(StringUtils.isNotBlank(bo.getAREA()), Klptcm1ProStoppage::getArea, bo.getAREA()); + lqw.eq(StringUtils.isNotBlank(bo.getUNIT()), Klptcm1ProStoppage::getUnit, bo.getUNIT()); + lqw.eq(StringUtils.isNotBlank(bo.getSETON()), Klptcm1ProStoppage::getSeton, bo.getSETON()); + lqw.eq(StringUtils.isNotBlank(bo.getREMARK()), Klptcm1ProStoppage::getRemark, bo.getREMARK()); + lqw.eq(bo.getStartDate() != null, Klptcm1ProStoppage::getStartDate, bo.getStartDate()); + lqw.eq(bo.getEndDate() != null, Klptcm1ProStoppage::getEndDate, bo.getEndDate()); + lqw.eq(bo.getDURATION() != null, Klptcm1ProStoppage::getDuration, bo.getDURATION()); + lqw.eq(bo.getInsDate() != null, Klptcm1ProStoppage::getInsDate, bo.getInsDate()); + lqw.eq(StringUtils.isNotBlank(bo.getStopType()), Klptcm1ProStoppage::getStopType, bo.getStopType()); + return lqw; + } + +} diff --git a/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateHistoryMapper.xml b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateHistoryMapper.xml new file mode 100644 index 00000000..d9b59ba0 --- /dev/null +++ b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProPlantStateHistoryMapper.xml @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProStoppageMapper.xml b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProStoppageMapper.xml new file mode 100644 index 00000000..3095d8eb --- /dev/null +++ b/klp-pocket/src/main/resources/mapper/pocket/Klptcm1ProStoppageMapper.xml @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + From 16676ed5e979609f0ff32f7f591aa0f54977fcb0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=A0=82=E7=B3=96?= Date: Tue, 28 Oct 2025 11:05:26 +0800 Subject: [PATCH 7/7] =?UTF-8?q?fix(wms):=20=E6=9B=B4=E6=96=B0=E4=BA=A7?= =?UTF-8?q?=E5=93=81=E3=80=81=E5=8D=8A=E6=88=90=E5=93=81=E5=92=8C=E5=8E=9F?= =?UTF-8?q?=E6=9D=90=E6=96=99=E8=A1=A8=E6=A0=BC=E5=88=97=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改产品、半成品和原材料管理页面的表格列名，将"编号"和"名称"改为"类型编号"和"类型名称"以更准确描述字段含义。同时更新EMS概览页面的背景图片格式为jpg。 --- klp-ui/src/assets/images/bird.jpg | Bin 0 -> 287941 bytes klp-ui/src/views/ems/overview/index.vue | 2 +- klp-ui/src/views/wms/product/index.vue | 4 ++-- klp-ui/src/views/wms/product/semi.vue | 4 ++-- klp-ui/src/views/wms/rawMaterial/index.vue | 4 ++-- 5 files changed, 7 insertions(+), 7 deletions(-) create mode 100644 klp-ui/src/assets/images/bird.jpg diff --git a/klp-ui/src/assets/images/bird.jpg b/klp-ui/src/assets/images/bird.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2c4565921c48174198d5794f36149f3dc00bcae2 GIT binary patch literal 287941 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�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 Na#_jhcnuTetsws?b=Uv^ literal 0 HcmV?d00001 diff --git a/klp-ui/src/views/ems/overview/index.vue b/klp-ui/src/views/ems/overview/index.vue index 4ad274a9..80774a12 100644 --- a/klp-ui/src/views/ems/overview/index.vue +++ b/klp-ui/src/views/ems/overview/index.vue @@ -157,7 +157,7 @@ export default { width: 100%; height: calc(100vh - 84px); position: relative; - background: url('../../../assets/images/bird.png') no-repeat center center; + background: url('../../../assets/images/bird.jpg') no-repeat center center; background-size: cover; overflow: hidden; } diff --git a/klp-ui/src/views/wms/product/index.vue b/klp-ui/src/views/wms/product/index.vue index 86897e89..1ea28aef 100644 --- a/klp-ui/src/views/wms/product/index.vue +++ b/klp-ui/src/views/wms/product/index.vue @@ -93,8 +93,8 @@ - - + +