Merge remote-tracking branch 'origin/dev_business' into dev_business

云

9 天以前 106aaa378126774a2547b6c0d559c62114579f4c

Merge remote-tracking branch 'origin/dev_business' into dev_business

 docs/process_param.md

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,438 @@
# å·¥è‰ºå‚数与工艺参数模板

## æ¶‰åŠé¡µé¢

- å·¥è‰ºå‚数列表页（新增）
- å·¥è‰ºå‚数模板列表页（新增）

## API

### å·¥è‰ºå‚æ•°

| æ–¹æ³• | è·¯å¾„ | è¯´æ˜Ž |
|------|------|------|
| POST | /mes/pd/process-param/create | åˆ›å»ºå·¥è‰ºå‚æ•° |
| PUT | /mes/pd/process-param/update | æ›´æ–°å·¥è‰ºå‚æ•° |
| DELETE | /mes/pd/process-param/delete?id= | åˆ é™¤å·¥è‰ºå‚æ•° |
| GET | /mes/pd/process-param/get?id= | èŽ·å–工艺参数详情 |
| GET | /mes/pd/process-param/page | åˆ†é¡µæŸ¥è¯¢å·¥è‰ºå‚æ•° |
| GET | /mes/pd/process-param/export-excel | å¯¼å‡ºå·¥è‰ºå‚æ•° |

**创建请求参数：**

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| paramName | String | æ˜¯ | å‚数名称 |
| paramType | Integer | å¦ | å‚数类型（字典 mes_pd_process_param_type：1=文本 2=数值 3=布尔 4=日期） |
| unitMeasureId | Long | å¦ | è®¡é‡å•ä½ID |
| required | Boolean | å¦ | æ˜¯å¦å¿…填，默认false |
| remark | String | å¦ | å¤‡æ³¨ |

注意：参数编码（paramCode）由后端自动生成，前端无需传入。

**响应：**

```json
{ "code": 200, "data": 1, "msg": "操作成功" }
```

**分页查询参数：**

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| pageNo | Integer | æ˜¯ | é¡µç  |
| pageSize | Integer | æ˜¯ | æ¯é¡µæ¡æ•° |
| paramCode | String | å¦ | å‚数编码（模糊搜索） |
| paramName | String | å¦ | å‚数名称（模糊搜索） |
| paramType | Integer | å¦ | å‚数类型（精确匹配） |

**响应结构：**

```json
{
  "code": 200,
  "data": {
    "list": [
      {
        "id": 1,
        "paramCode": "PP20240001",
        "paramName": "注塑温度",
        "paramType": 2,
        "unitMeasureId": 1,
        "unitMeasureName": "℃",
        "required": true,
        "remark": "",
        "createTime": "2024-01-01 00:00:00"
      }
    ],
    "total": 1
  }
}
```

### å·¥è‰ºå‚数模板

| æ–¹æ³• | è·¯å¾„ | è¯´æ˜Ž |
|------|------|------|
| POST | /mes/pd/process-param-template/create | åˆ›å»ºå·¥è‰ºå‚数模板 |
| PUT | /mes/pd/process-param-template/update | æ›´æ–°å·¥è‰ºå‚数模板 |
| DELETE | /mes/pd/process-param-template/delete?id= | åˆ é™¤å·¥è‰ºå‚数模板 |
| GET | /mes/pd/process-param-template/get?id= | èŽ·å–工艺参数模板详情 |
| GET | /mes/pd/process-param-template/page | åˆ†é¡µæŸ¥è¯¢å·¥è‰ºå‚数模板 |
| GET | /mes/pd/process-param-template/export-excel | å¯¼å‡ºå·¥è‰ºå‚数模板 |

**创建/更新请求参数：**

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| id | Long | å¦ | ç¼–号（更新时必填） |
| templateName | String | æ˜¯ | æ¨¡æ¿åç§° |
| templateType | Integer | å¦ | æ¨¡æ¿ç±»åž‹ï¼ˆå­—å…¸ mes_pd_process_param_template_type：1=通用 2=工序 3=产品） |
| remark | String | å¦ | å¤‡æ³¨ |
| details | List\<Detail\> | æ˜¯ | æ¨¡æ¿æ˜Žç»†åˆ—表 |

**Detail ç»“构：**

| å‚æ•° | ç±»åž‹ | å¿…å¡« | è¯´æ˜Ž |
|------|------|------|------|
| processParamId | Long | æ˜¯ | å·¥è‰ºå‚æ•°ID |
| required | Boolean | å¦ | æ˜¯å¦å¿…填（可覆盖参数默认值） |
| remark | String | å¦ | å¤‡æ³¨ï¼ˆå¯è¦†ç›–参数默认值） |

注意：模板编码（templateCode）由后端自动生成，前端无需传入。模板明细采用快照机制——关联时复制参数值，改变工艺参数列表的值不影响模板。

**响应结构：**

```json
{
  "code": 200,
  "data": {
    "id": 1,
    "templateCode": "PPT20240001",
    "templateName": "注塑工艺参数模板",
    "templateType": 2,
    "remark": "",
    "createTime": "2024-01-01 00:00:00",
    "details": [
      {
        "id": 1,
        "templateId": 1,
        "processParamId": 1,
        "paramCode": "PP20240001",
        "paramName": "注塑温度",
        "paramType": 2,
        "unitMeasureId": 1,
        "unitMeasureName": "℃",
        "required": true,
        "remark": ""
      }
    ]
  }
}
```

## å‰ç«¯ä¿®æ”¹ç‚¹

### 1. å·¥è‰ºå‚数列表页 - æ–°å¢žé¡µé¢

文件路径：`src/views/mes/pd/processparam/index.vue`

```html
<!-- æœç´¢æ  -->
<el-form :model="queryParams" ref="queryFormRef" :inline="true">
  <el-form-item label="参数编码" prop="paramCode">
    <el-input v-model="queryParams.paramCode" placeholder="请输入参数编码" clearable />
  </el-form-item>
  <el-form-item label="参数名称" prop="paramName">
    <el-input v-model="queryParams.paramName" placeholder="请输入参数名称" clearable />
  </el-form-item>
  <el-form-item label="参数类型" prop="paramType">
    <el-select v-model="queryParams.paramType" placeholder="请选择参数类型" clearable>
      <el-option v-for="dict in getIntDictOptions(DICT_TYPE.MES_PD_PROCESS_PARAM_TYPE)"
        :key="dict.value" :label="dict.label" :value="dict.value" />
    </el-select>
  </el-form-item>
  <el-form-item>
    <el-button type="primary" @click="handleQuery"><Icon icon="ep:search" />搜索</el-button>
    <el-button @click="resetQuery"><Icon icon="ep:refresh" />重置</el-button>
  </el-form-item>
</el-form>

<!-- æ“ä½œæ  -->
<el-row :gutter="10" class="mb8">
  <el-col :span="1.5">
    <el-button type="primary" @click="openForm('create')"
      v-hasPermi="['mes:pd-process-param:create']"><Icon icon="ep:plus" />新增</el-button>
  </el-col>
  <el-col :span="1.5">
    <el-button type="warning" @click="handleExport"
      v-hasPermi="['mes:pd-process-param:export']"><Icon icon="ep:download" />导出</el-button>
  </el-col>
</el-row>

<!-- åˆ—表 -->
<el-table v-loading="loading" :data="list">
  <el-table-column label="编号" align="center" prop="id" />
  <el-table-column label="参数编码" align="center" prop="paramCode" />
  <el-table-column label="参数名称" align="center" prop="paramName" />
  <el-table-column label="参数类型" align="center" prop="paramType">
    <template #default="scope">
      <dict-tag :type="DICT_TYPE.MES_PD_PROCESS_PARAM_TYPE" :value="scope.row.paramType" />
    </template>
  </el-table-column>
  <el-table-column label="单位" align="center" prop="unitMeasureName" />
  <el-table-column label="是否必填" align="center" prop="required">
    <template #default="scope">
      <el-tag :type="scope.row.required ? 'danger' : 'info'">{{ scope.row.required ? '是' : '否' }}</el-tag>
    </template>
  </el-table-column>
  <el-table-column label="备注" align="center" prop="remark" show-overflow-tooltip />
  <el-table-column label="创建时间" align="center" prop="createTime" width="180" />
  <el-table-column label="操作" align="center" width="150">
    <template #default="scope">
      <el-button link type="primary" @click="openForm('update', scope.row.id)"
        v-hasPermi="['mes:pd-process-param:update']">编辑</el-button>
      <el-button link type="danger" @click="handleDelete(scope.row.id)"
        v-hasPermi="['mes:pd-process-param:delete']">删除</el-button>
    </template>
  </el-table-column>
</el-table>
```

### 2. å·¥è‰ºå‚数表单弹窗 - æ–°å¢ž/编辑

文件路径：`src/views/mes/pd/processparam/ProcessParamForm.vue`

```html
<el-dialog :title="dialogTitle" v-model="dialogVisible" width="500px">
  <el-form ref="formRef" :model="formData" :rules="formRules" label-width="100px">
    <el-form-item label="参数名称" prop="paramName">
      <el-input v-model="formData.paramName" placeholder="请输入参数名称" />
    </el-form-item>
    <el-form-item label="参数类型" prop="paramType">
      <el-select v-model="formData.paramType" placeholder="请选择参数类型">
        <el-option v-for="dict in getIntDictOptions(DICT_TYPE.MES_PD_PROCESS_PARAM_TYPE)"
          :key="dict.value" :label="dict.label" :value="dict.value" />
      </el-select>
    </el-form-item>
    <el-form-item label="计量单位" prop="unitMeasureId">
      <el-select v-model="formData.unitMeasureId" placeholder="请选择计量单位" clearable filterable>
        <!-- ä»Žè®¡é‡å•ä½æŽ¥å£èŽ·å–列表 -->
      </el-select>
    </el-form-item>
    <el-form-item label="是否必填" prop="required">
      <el-switch v-model="formData.required" />
    </el-form-item>
    <el-form-item label="备注" prop="remark">
      <el-input v-model="formData.remark" type="textarea" placeholder="请输入备注" />
    </el-form-item>
  </el-form>
</el-dialog>
```

### 3. data æ•°æ®

```js
const queryParams = reactive({
  pageNo: 1,
  pageSize: 10,
  paramCode: undefined,
  paramName: undefined,
  paramType: undefined,
})
const formData = reactive({
  id: undefined,
  paramName: undefined,
  paramType: undefined,
  unitMeasureId: undefined,
  required: false,
  remark: undefined,
})
```

### 4. å·¥è‰ºå‚数模板列表页 - æ–°å¢žé¡µé¢

文件路径：`src/views/mes/pd/processparamtemplate/index.vue`

```html
<!-- æœç´¢æ  -->
<el-form :model="queryParams" ref="queryFormRef" :inline="true">
  <el-form-item label="模板编码" prop="templateCode">
    <el-input v-model="queryParams.templateCode" placeholder="请输入模板编码" clearable />
  </el-form-item>
  <el-form-item label="模板名称" prop="templateName">
    <el-input v-model="queryParams.templateName" placeholder="请输入模板名称" clearable />
  </el-form-item>
  <el-form-item label="模板类型" prop="templateType">
    <el-select v-model="queryParams.templateType" placeholder="请选择模板类型" clearable>
      <el-option v-for="dict in getIntDictOptions(DICT_TYPE.MES_PD_PROCESS_PARAM_TEMPLATE_TYPE)"
        :key="dict.value" :label="dict.label" :value="dict.value" />
    </el-select>
  </el-form-item>
  <el-form-item>
    <el-button type="primary" @click="handleQuery"><Icon icon="ep:search" />搜索</el-button>
    <el-button @click="resetQuery"><Icon icon="ep:refresh" />重置</el-button>
  </el-form-item>
</el-form>

<!-- åˆ—表 -->
<el-table v-loading="loading" :data="list">
  <el-table-column label="编号" align="center" prop="id" />
  <el-table-column label="模板编码" align="center" prop="templateCode" />
  <el-table-column label="模板名称" align="center" prop="templateName" />
  <el-table-column label="模板类型" align="center" prop="templateType">
    <template #default="scope">
      <dict-tag :type="DICT_TYPE.MES_PD_PROCESS_PARAM_TEMPLATE_TYPE" :value="scope.row.templateType" />
    </template>
  </el-table-column>
  <el-table-column label="备注" align="center" prop="remark" show-overflow-tooltip />
  <el-table-column label="创建时间" align="center" prop="createTime" width="180" />
  <el-table-column label="操作" align="center" width="150">
    <template #default="scope">
      <el-button link type="primary" @click="openForm('update', scope.row.id)"
        v-hasPermi="['mes:pd-process-param-template:update']">编辑</el-button>
      <el-button link type="danger" @click="handleDelete(scope.row.id)"
        v-hasPermi="['mes:pd-process-param-template:delete']">删除</el-button>
    </template>
  </el-table-column>
</el-table>
```

### 5. å·¥è‰ºå‚数模板表单弹窗（含明细）

文件路径：`src/views/mes/pd/processparamtemplate/ProcessParamTemplateForm.vue`

```html
<el-dialog :title="dialogTitle" v-model="dialogVisible" width="800px">
  <el-form ref="formRef" :model="formData" :rules="formRules" label-width="100px">
    <el-form-item label="模板名称" prop="templateName">
      <el-input v-model="formData.templateName" placeholder="请输入模板名称" />
    </el-form-item>
    <el-form-item label="模板类型" prop="templateType">
      <el-select v-model="formData.templateType" placeholder="请选择模板类型">
        <el-option v-for="dict in getIntDictOptions(DICT_TYPE.MES_PD_PROCESS_PARAM_TEMPLATE_TYPE)"
          :key="dict.value" :label="dict.label" :value="dict.value" />
      </el-select>
    </el-form-item>
    <el-form-item label="备注" prop="remark">
      <el-input v-model="formData.remark" type="textarea" placeholder="请输入备注" />
    </el-form-item>

    <!-- æ¨¡æ¿æ˜Žç»†åˆ—表 -->
    <el-form-item label="工艺参数" prop="details">
      <el-button type="primary" size="small" @click="addDetail"><Icon icon="ep:plus" />添加参数</el-button>
      <el-table :data="formData.details" border style="width: 100%; margin-top: 10px">
        <el-table-column label="工艺参数" align="center" min-width="200">
          <template #default="scope">
            <el-select v-model="scope.row.processParamId" placeholder="请选择工艺参数" filterable
              @change="onParamChange(scope.row)">
              <!-- ä»Žå·¥è‰ºå‚数列表接口获取 -->
            </el-select>
          </template>
        </el-table-column>
        <el-table-column label="参数编码" align="center" prop="paramCode" width="120" />
        <el-table-column label="参数类型" align="center" prop="paramTypeName" width="100" />
        <el-table-column label="单位" align="center" prop="unitMeasureName" width="80" />
        <el-table-column label="是否必填" align="center" width="100">
          <template #default="scope">
            <el-switch v-model="scope.row.required" />
          </template>
        </el-table-column>
        <el-table-column label="备注" align="center" min-width="120">
          <template #default="scope">
            <el-input v-model="scope.row.remark" placeholder="备注" />
          </template>
        </el-table-column>
        <el-table-column label="操作" align="center" width="60">
          <template #default="scope">
            <el-button link type="danger" @click="removeDetail(scope.$index)">删除</el-button>
          </template>
        </el-table-column>
      </el-table>
    </el-form-item>
  </el-form>
</el-dialog>
```

### 6. API æŽ¥å£å®šä¹‰

文件路径：`src/api/mes/pd/processparam/index.ts`

```ts
import request from '@/config/axios'

// åˆ›å»ºå·¥è‰ºå‚æ•°
export const createProcessParam = (data) => {
  return request.post({ url: '/mes/pd/process-param/create', data })
}

// æ›´æ–°å·¥è‰ºå‚æ•°
export const updateProcessParam = (data) => {
  return request.put({ url: '/mes/pd/process-param/update', data })
}

// åˆ é™¤å·¥è‰ºå‚æ•°
export const deleteProcessParam = (id: number) => {
  return request.delete({ url: '/mes/pd/process-param/delete?id=' + id })
}

// èŽ·å–工艺参数
export const getProcessParam = (id: number) => {
  return request.get({ url: '/mes/pd/process-param/get?id=' + id })
}

// èŽ·å–工艺参数分页
export const getProcessParamPage = (params) => {
  return request.get({ url: '/mes/pd/process-param/page', params })
}

// å¯¼å‡ºå·¥è‰ºå‚æ•° Excel
export const exportProcessParamExcel = (params) => {
  return request.download({ url: '/mes/pd/process-param/export-excel', params })
}
```

文件路径：`src/api/mes/pd/processparamtemplate/index.ts`

```ts
import request from '@/config/axios'

// åˆ›å»ºå·¥è‰ºå‚数模板
export const createProcessParamTemplate = (data) => {
  return request.post({ url: '/mes/pd/process-param-template/create', data })
}

// æ›´æ–°å·¥è‰ºå‚数模板
export const updateProcessParamTemplate = (data) => {
  return request.put({ url: '/mes/pd/process-param-template/update', data })
}

// åˆ é™¤å·¥è‰ºå‚数模板
export const deleteProcessParamTemplate = (id: number) => {
  return request.delete({ url: '/mes/pd/process-param-template/delete?id=' + id })
}

// èŽ·å–工艺参数模板
export const getProcessParamTemplate = (id: number) => {
  return request.get({ url: '/mes/pd/process-param-template/get?id=' + id })
}

// èŽ·å–工艺参数模板分页
export const getProcessParamTemplatePage = (params) => {
  return request.get({ url: '/mes/pd/process-param-template/page', params })
}

// å¯¼å‡ºå·¥è‰ºå‚数模板 Excel
export const exportProcessParamTemplateExcel = (params) => {
  return request.download({ url: '/mes/pd/process-param-template/export-excel', params })
}
```

## æ³¨æ„äº‹é¡¹

- **快照机制**：模板关联工艺参数时，后端会复制参数的当前值到模板明细中。之后修改工艺参数的名称、类型、单位等，不会影响已关联的模板。这是设计上要求的"改变工艺参数列表的值不能影响模板的变化"。
- **参数编码和模板编码**由后端自动生成，前端创建时不需要传入。
- å·¥è‰ºå‚数类型字典：`mes_pd_process_param_type`（1=文本、2=数值、3=布尔、4=日期）
- å·¥è‰ºå‚数模板类型字典：`mes_pd_process_param_template_type`（1=通用、2=工序、3=产品）
- è®¡é‡å•ä½ä¸‹æ‹‰æ¡†éœ€è¦è°ƒç”¨ MDM æ¨¡å—的计量单位列表接口获取数据
- æ¨¡æ¿è¡¨å•ä¸­çš„明细行，选择工艺参数后会自动带出参数编码、名称、类型、单位等信息

 docs/sql/mes_pd_process_param_init.sql

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,119 @@
-- =============================================
-- MES å·¥è‰ºå‚数与工艺参数模板 - åˆå§‹åŒ–脚本
-- =============================================

-- ----------------------------
-- å·¥è‰ºå‚æ•°
-- ----------------------------
CREATE TABLE IF NOT EXISTS `mes_pd_process_param` (
    `id` bigint NOT NULL AUTO_INCREMENT COMMENT '编号',
    `param_code` varchar(64) DEFAULT NULL COMMENT '参数编码',
    `param_name` varchar(255) NOT NULL COMMENT '参数名称',
    `param_type` tinyint DEFAULT NULL COMMENT '参数类型（字典 mes_pd_process_param_type）',
    `unit_measure_id` bigint DEFAULT NULL COMMENT '计量单位ID（关联 mes_md_unit_measure）',
    `required` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否必填',
    `remark` varchar(500) DEFAULT NULL COMMENT '备注',
    `creator` varchar(64) DEFAULT '' COMMENT '创建者',
    `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `updater` varchar(64) DEFAULT '' COMMENT '更新者',
    `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
    `tenant_id` bigint NOT NULL DEFAULT 0 COMMENT '租户编号',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB COMMENT='MES å·¥è‰ºå‚æ•°';

-- ----------------------------
-- å·¥è‰ºå‚数模板
-- ----------------------------
CREATE TABLE IF NOT EXISTS `mes_pd_process_param_template` (
    `id` bigint NOT NULL AUTO_INCREMENT COMMENT '编号',
    `template_code` varchar(64) DEFAULT NULL COMMENT '模板编码',
    `template_name` varchar(255) NOT NULL COMMENT '模板名称',
    `template_type` tinyint DEFAULT NULL COMMENT '模板类型（字典 mes_pd_process_param_template_type）',
    `remark` varchar(500) DEFAULT NULL COMMENT '备注',
    `creator` varchar(64) DEFAULT '' COMMENT '创建者',
    `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `updater` varchar(64) DEFAULT '' COMMENT '更新者',
    `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
    `tenant_id` bigint NOT NULL DEFAULT 0 COMMENT '租户编号',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB COMMENT='MES å·¥è‰ºå‚数模板';

-- ----------------------------
-- å·¥è‰ºå‚数模板明细（快照表）
-- ----------------------------
CREATE TABLE IF NOT EXISTS `mes_pd_process_param_template_detail` (
    `id` bigint NOT NULL AUTO_INCREMENT COMMENT '编号',
    `template_id` bigint NOT NULL COMMENT '模板ID（关联 mes_pd_process_param_template）',
    `process_param_id` bigint DEFAULT NULL COMMENT '工艺参数ID（仅作溯源，不影响快照值）',
    `param_code` varchar(64) DEFAULT NULL COMMENT '参数编码（快照）',
    `param_name` varchar(255) DEFAULT NULL COMMENT '参数名称（快照）',
    `param_type` tinyint DEFAULT NULL COMMENT '参数类型（快照）',
    `unit_measure_id` bigint DEFAULT NULL COMMENT '计量单位ID（快照）',
    `required` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否必填（快照）',
    `remark` varchar(500) DEFAULT NULL COMMENT '备注（快照）',
    `creator` varchar(64) DEFAULT '' COMMENT '创建者',
    `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `updater` varchar(64) DEFAULT '' COMMENT '更新者',
    `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    `deleted` bit(1) NOT NULL DEFAULT b'0' COMMENT '是否删除',
    `tenant_id` bigint NOT NULL DEFAULT 0 COMMENT '租户编号',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB COMMENT='MES å·¥è‰ºå‚数模板明细';

-- ----------------------------
-- å­—典类型
-- ----------------------------
INSERT INTO `system_dict_type` (`name`, `type`, `status`, `remark`, `creator`, `create_time`, `updater`, `update_time`, `deleted`) VALUES
('工艺参数类型', 'mes_pd_process_param_type', 0, '工艺参数类型', '1', NOW(), '1', NOW(), b'0'),
('工艺参数模板类型', 'mes_pd_process_param_template_type', 0, '工艺参数模板类型', '1', NOW(), '1', NOW(), b'0');

-- ----------------------------
-- å­—典数据 - å·¥è‰ºå‚数类型
-- ----------------------------
INSERT INTO `system_dict_data` (`sort`, `label`, `value`, `dict_type`, `status`, `color_type`, `css_class`, `remark`, `creator`, `create_time`, `updater`, `update_time`, `deleted`) VALUES
(0, '文本', '1', 'mes_pd_process_param_type', 0, 'default', '', '', '1', NOW(), '1', NOW(), b'0'),
(1, '数值', '2', 'mes_pd_process_param_type', 0, 'primary', '', '', '1', NOW(), '1', NOW(), b'0'),
(2, '布尔', '3', 'mes_pd_process_param_type', 0, 'success', '', '', '1', NOW(), '1', NOW(), b'0'),
(3, '日期', '4', 'mes_pd_process_param_type', 0, 'warning', '', '', '1', NOW(), '1', NOW(), b'0');

-- ----------------------------
-- å­—典数据 - å·¥è‰ºå‚数模板类型
-- ----------------------------
INSERT INTO `system_dict_data` (`sort`, `label`, `value`, `dict_type`, `status`, `color_type`, `css_class`, `remark`, `creator`, `create_time`, `updater`, `update_time`, `deleted`) VALUES
(0, '通用', '1', 'mes_pd_process_param_template_type', 0, 'default', '', '', '1', NOW(), '1', NOW(), b'0'),
(1, '工序', '2', 'mes_pd_process_param_template_type', 0, 'primary', '', '', '1', NOW(), '1', NOW(), b'0'),
(2, '产品', '3', 'mes_pd_process_param_template_type', 0, 'success', '', '', '1', NOW(), '1', NOW(), b'0');

-- ----------------------------
-- èœå• - å·¥è‰ºå‚数（二级菜单，挂在产品设计下）
-- æ³¨æ„ï¼šparent_id ä½¿ç”¨å˜é‡ @pd_menu_id，需与 mes_pd_init.sql ä¸­çš„产品设计一级菜单配合
-- å¦‚果产品设计菜单已存在，请先设置 @pd_menu_id ä¸ºå®žé™…的菜单ID
-- ----------------------------

-- äºŒçº§èœå•ï¼šå·¥è‰ºå‚æ•°
INSERT INTO `system_menu` (`name`, `permission`, `type`, `sort`, `parent_id`, `path`, `icon`, `component`, `status`, `creator`, `create_time`, `updater`, `update_time`, `deleted`) VALUES
('工艺参数', '', 2, 3, @pd_menu_id, 'process-param', '', 'mes/pd/processparam/index', 0, '1', NOW(), '1', NOW(), b'0');
SET @process_param_menu_id = LAST_INSERT_ID();

-- å·¥è‰ºå‚数按钮权限
INSERT INTO `system_menu` (`name`, `permission`, `type`, `sort`, `parent_id`, `path`, `icon`, `component`, `status`, `creator`, `create_time`, `updater`, `update_time`, `deleted`) VALUES
('工艺参数查询', 'mes:pd-process-param:query', 3, 1, @process_param_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0'),
('工艺参数创建', 'mes:pd-process-param:create', 3, 2, @process_param_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0'),
('工艺参数更新', 'mes:pd-process-param:update', 3, 3, @process_param_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0'),
('工艺参数删除', 'mes:pd-process-param:delete', 3, 4, @process_param_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0'),
('工艺参数导出', 'mes:pd-process-param:export', 3, 5, @process_param_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0');

-- äºŒçº§èœå•ï¼šå·¥è‰ºå‚数模板
INSERT INTO `system_menu` (`name`, `permission`, `type`, `sort`, `parent_id`, `path`, `icon`, `component`, `status`, `creator`, `create_time`, `updater`, `update_time`, `deleted`) VALUES
('工艺参数模板', '', 2, 4, @pd_menu_id, 'process-param-template', '', 'mes/pd/processparamtemplate/index', 0, '1', NOW(), '1', NOW(), b'0');
SET @template_menu_id = LAST_INSERT_ID();

-- å·¥è‰ºå‚数模板按钮权限
INSERT INTO `system_menu` (`name`, `permission`, `type`, `sort`, `parent_id`, `path`, `icon`, `component`, `status`, `creator`, `create_time`, `updater`, `update_time`, `deleted`) VALUES
('工艺参数模板查询', 'mes:pd-process-param-template:query', 3, 1, @template_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0'),
('工艺参数模板创建', 'mes:pd-process-param-template:create', 3, 2, @template_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0'),
('工艺参数模板更新', 'mes:pd-process-param-template:update', 3, 3, @template_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0'),
('工艺参数模板删除', 'mes:pd-process-param-template:delete', 3, 4, @template_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0'),
('工艺参数模板导出', 'mes:pd-process-param-template:export', 3, 5, @template_menu_id, '', '', '', 0, '1', NOW(), '1', NOW(), b'0');

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/pd/processparam/MesPdProcessParamController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,122 @@
package cn.iocoder.yudao.module.mes.controller.admin.pd.processparam;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.collection.MapUtils;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo.MesPdProcessParamPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo.MesPdProcessParamRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo.MesPdProcessParamSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.unitmeasure.MesMdUnitMeasureDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparam.MesPdProcessParamDO;
import cn.iocoder.yudao.module.mes.service.md.unitmeasure.MesMdUnitMeasureService;
import cn.iocoder.yudao.module.mes.service.pd.processparam.MesPdProcessParamService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.EXPORT;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;

@Tag(name = "管理后台 - MES å·¥è‰ºå‚æ•°")
@RestController
@RequestMapping("/mes/pd/process-param")
@Validated
public class MesPdProcessParamController {

    @Resource
    private MesPdProcessParamService processParamService;

    @Resource
    private MesMdUnitMeasureService unitMeasureService;

    @PostMapping("/create")
    @Operation(summary = "创建工艺参数")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param:create')")
    public CommonResult<Long> createProcessParam(@Valid @RequestBody MesPdProcessParamSaveReqVO createReqVO) {
        return success(processParamService.createProcessParam(createReqVO));
    }

    @PutMapping("/update")
    @Operation(summary = "更新工艺参数")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param:update')")
    public CommonResult<Boolean> updateProcessParam(@Valid @RequestBody MesPdProcessParamSaveReqVO updateReqVO) {
        processParamService.updateProcessParam(updateReqVO);
        return success(true);
    }

    @DeleteMapping("/delete")
    @Operation(summary = "删除工艺参数")
    @Parameter(name = "id", description = "编号", required = true)
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param:delete')")
    public CommonResult<Boolean> deleteProcessParam(@RequestParam("id") Long id) {
        processParamService.deleteProcessParam(id);
        return success(true);
    }

    @GetMapping("/get")
    @Operation(summary = "获得工艺参数")
    @Parameter(name = "id", description = "编号", required = true, example = "1024")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param:query')")
    public CommonResult<MesPdProcessParamRespVO> getProcessParam(@RequestParam("id") Long id) {
        MesPdProcessParamDO processParam = processParamService.getProcessParam(id);
        if (processParam == null) {
            return success(null);
        }
        return success(buildProcessParamRespVOList(Collections.singletonList(processParam)).get(0));
    }

    @GetMapping("/page")
    @Operation(summary = "获得工艺参数分页")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param:query')")
    public CommonResult<PageResult<MesPdProcessParamRespVO>> getProcessParamPage(@Valid MesPdProcessParamPageReqVO pageReqVO) {
        PageResult<MesPdProcessParamDO> pageResult = processParamService.getProcessParamPage(pageReqVO);
        return success(new PageResult<>(buildProcessParamRespVOList(pageResult.getList()), pageResult.getTotal()));
    }

    @GetMapping("/export-excel")
    @Operation(summary = "导出工艺参数 Excel")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param:export')")
    @ApiAccessLog(operateType = EXPORT)
    public void exportProcessParamExcel(@Valid MesPdProcessParamPageReqVO pageReqVO,
                                        HttpServletResponse response) throws IOException {
        pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
        List<MesPdProcessParamDO> list = processParamService.getProcessParamPage(pageReqVO).getList();
        // å¯¼å‡º Excel
        ExcelUtils.write(response, "工艺参数.xls", "数据", MesPdProcessParamRespVO.class,
                buildProcessParamRespVOList(list));
    }

    // ==================== æ‹¼æŽ¥ VO ====================

    private List<MesPdProcessParamRespVO> buildProcessParamRespVOList(List<MesPdProcessParamDO> list) {
        if (CollUtil.isEmpty(list)) {
            return Collections.emptyList();
        }
        // 1. æ‰¹é‡èŽ·å–关联数据（计量单位）
        Map<Long, MesMdUnitMeasureDO> unitMeasureMap = unitMeasureService.getUnitMeasureMap(
                convertSet(list, MesPdProcessParamDO::getUnitMeasureId));
        // 2. æ‹¼æŽ¥ VO
        return BeanUtils.toBean(list, MesPdProcessParamRespVO.class, vo ->
                MapUtils.findAndThen(unitMeasureMap, vo.getUnitMeasureId(),
                        unitMeasure -> vo.setUnitMeasureName(unitMeasure.getName()))
        );
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/pd/processparam/vo/MesPdProcessParamPageReqVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,24 @@
package cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo;

import cn.iocoder.yudao.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;

@Schema(description = "管理后台 - MES å·¥è‰ºå‚数分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MesPdProcessParamPageReqVO extends PageParam {

    @Schema(description = "参数编码", example = "PP2024001")
    private String paramCode;

    @Schema(description = "参数名称", example = "温度")
    private String paramName;

    @Schema(description = "参数类型", example = "1")
    private Integer paramType;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/pd/processparam/vo/MesPdProcessParamRespVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,54 @@
package cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo;

import cn.iocoder.yudao.framework.excel.core.annotations.DictFormat;
import cn.iocoder.yudao.framework.excel.core.convert.DictConvert;
import cn.iocoder.yudao.module.mes.enums.DictTypeConstants;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.time.LocalDateTime;

@Schema(description = "管理后台 - MES å·¥è‰ºå‚æ•° Response VO")
@Data
@ExcelIgnoreUnannotated
public class MesPdProcessParamRespVO {

    @Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
    @ExcelProperty("编号")
    private Long id;

    @Schema(description = "参数编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "PP2024001")
    @ExcelProperty("参数编码")
    private String paramCode;

    @Schema(description = "参数名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "温度")
    @ExcelProperty("参数名称")
    private String paramName;

    @Schema(description = "参数类型", example = "1")
    @ExcelProperty(value = "参数类型", converter = DictConvert.class)
    @DictFormat(DictTypeConstants.MES_PD_PROCESS_PARAM_TYPE)
    private Integer paramType;

    @Schema(description = "计量单位ID", example = "1")
    private Long unitMeasureId;

    @Schema(description = "计量单位名称", example = "℃")
    @ExcelProperty("单位")
    private String unitMeasureName;

    @Schema(description = "是否必填", example = "true")
    @ExcelProperty("是否必填")
    private Boolean required;

    @Schema(description = "备注", example = "测试备注")
    @ExcelProperty("备注")
    private String remark;

    @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
    @ExcelProperty("创建时间")
    private LocalDateTime createTime;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/pd/processparam/vo/MesPdProcessParamSaveReqVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,31 @@
package cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import jakarta.validation.constraints.NotBlank;

@Schema(description = "管理后台 - MES å·¥è‰ºå‚数新增/修改 Request VO")
@Data
public class MesPdProcessParamSaveReqVO {

    @Schema(description = "编号", requiredMode = Schema.RequiredMode.NOT_REQUIRED, example = "1024")
    private Long id;

    @Schema(description = "参数名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "温度")
    @NotBlank(message = "参数名称不能为空")
    private String paramName;

    @Schema(description = "参数类型", example = "1")
    private Integer paramType;

    @Schema(description = "计量单位ID", example = "1")
    private Long unitMeasureId;

    @Schema(description = "是否必填", example = "true")
    private Boolean required;

    @Schema(description = "备注", example = "测试备注")
    private String remark;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/pd/processparamtemplate/MesPdProcessParamTemplateController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,146 @@
package cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate;

import cn.hutool.core.collection.CollUtil;
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.collection.MapUtils;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo.MesPdProcessParamTemplatePageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo.MesPdProcessParamTemplateRespVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo.MesPdProcessParamTemplateSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.md.unitmeasure.MesMdUnitMeasureDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate.MesPdProcessParamTemplateDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate.MesPdProcessParamTemplateDetailDO;
import cn.iocoder.yudao.module.mes.service.md.unitmeasure.MesMdUnitMeasureService;
import cn.iocoder.yudao.module.mes.service.pd.processparamtemplate.MesPdProcessParamTemplateService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.EXPORT;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet;

@Tag(name = "管理后台 - MES å·¥è‰ºå‚数模板")
@RestController
@RequestMapping("/mes/pd/process-param-template")
@Validated
public class MesPdProcessParamTemplateController {

    @Resource
    private MesPdProcessParamTemplateService templateService;

    @Resource
    private MesMdUnitMeasureService unitMeasureService;

    @PostMapping("/create")
    @Operation(summary = "创建工艺参数模板")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param-template:create')")
    public CommonResult<Long> createProcessParamTemplate(@Valid @RequestBody MesPdProcessParamTemplateSaveReqVO createReqVO) {
        return success(templateService.createProcessParamTemplate(createReqVO));
    }

    @PutMapping("/update")
    @Operation(summary = "更新工艺参数模板")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param-template:update')")
    public CommonResult<Boolean> updateProcessParamTemplate(@Valid @RequestBody MesPdProcessParamTemplateSaveReqVO updateReqVO) {
        templateService.updateProcessParamTemplate(updateReqVO);
        return success(true);
    }

    @DeleteMapping("/delete")
    @Operation(summary = "删除工艺参数模板")
    @Parameter(name = "id", description = "编号", required = true)
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param-template:delete')")
    public CommonResult<Boolean> deleteProcessParamTemplate(@RequestParam("id") Long id) {
        templateService.deleteProcessParamTemplate(id);
        return success(true);
    }

    @GetMapping("/get")
    @Operation(summary = "获得工艺参数模板")
    @Parameter(name = "id", description = "编号", required = true, example = "1024")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param-template:query')")
    public CommonResult<MesPdProcessParamTemplateRespVO> getProcessParamTemplate(@RequestParam("id") Long id) {
        MesPdProcessParamTemplateDO template = templateService.getProcessParamTemplate(id);
        if (template == null) {
            return success(null);
        }
        return success(buildTemplateRespVO(template));
    }

    @GetMapping("/page")
    @Operation(summary = "获得工艺参数模板分页")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param-template:query')")
    public CommonResult<PageResult<MesPdProcessParamTemplateRespVO>> getProcessParamTemplatePage(@Valid MesPdProcessParamTemplatePageReqVO pageReqVO) {
        PageResult<MesPdProcessParamTemplateDO> pageResult = templateService.getProcessParamTemplatePage(pageReqVO);
        List<MesPdProcessParamTemplateRespVO> voList = buildTemplateRespVOList(pageResult.getList());
        return success(new PageResult<>(voList, pageResult.getTotal()));
    }

    @GetMapping("/export-excel")
    @Operation(summary = "导出工艺参数模板 Excel")
    @PreAuthorize("@ss.hasPermission('mes:pd-process-param-template:export')")
    @ApiAccessLog(operateType = EXPORT)
    public void exportProcessParamTemplateExcel(@Valid MesPdProcessParamTemplatePageReqVO pageReqVO,
                                                 HttpServletResponse response) throws IOException {
        pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
        List<MesPdProcessParamTemplateDO> list = templateService.getProcessParamTemplatePage(pageReqVO).getList();
        // å¯¼å‡º Excel
        ExcelUtils.write(response, "工艺参数模板.xls", "数据", MesPdProcessParamTemplateRespVO.class,
                buildTemplateRespVOList(list));
    }

    // ==================== æ‹¼æŽ¥ VO ====================

    private MesPdProcessParamTemplateRespVO buildTemplateRespVO(MesPdProcessParamTemplateDO template) {
        return buildTemplateRespVOList(Collections.singletonList(template)).get(0);
    }

    private List<MesPdProcessParamTemplateRespVO> buildTemplateRespVOList(List<MesPdProcessParamTemplateDO> list) {
        if (CollUtil.isEmpty(list)) {
            return Collections.emptyList();
        }
        // 1. æ‰¹é‡èŽ·å–所有模板的明细
        Map<Long, List<MesPdProcessParamTemplateDetailDO>> detailMap = new HashMap<>();
        Set<Long> allUnitMeasureIds = new HashSet<>();
        for (MesPdProcessParamTemplateDO template : list) {
            List<MesPdProcessParamTemplateDetailDO> details =
                    templateService.getProcessParamTemplateDetailListByTemplateId(template.getId());
            detailMap.put(template.getId(), details);
            for (MesPdProcessParamTemplateDetailDO detail : details) {
                if (detail.getUnitMeasureId() != null) {
                    allUnitMeasureIds.add(detail.getUnitMeasureId());
                }
            }
        }
        // 2. æ‰¹é‡èŽ·å–计量单位
        Map<Long, MesMdUnitMeasureDO> unitMeasureMap = unitMeasureService.getUnitMeasureMap(allUnitMeasureIds);
        // 3. æ‹¼æŽ¥ VO
        return BeanUtils.toBean(list, MesPdProcessParamTemplateRespVO.class, vo -> {
            List<MesPdProcessParamTemplateDetailDO> details = detailMap.get(vo.getId());
            if (CollUtil.isNotEmpty(details)) {
                List<MesPdProcessParamTemplateRespVO.DetailResp> detailResps = BeanUtils.toBean(
                        details, MesPdProcessParamTemplateRespVO.DetailResp.class, detailResp ->
                                MapUtils.findAndThen(unitMeasureMap, detailResp.getUnitMeasureId(),
                                        unitMeasure -> detailResp.setUnitMeasureName(unitMeasure.getName()))
                );
                vo.setDetails(detailResps);
            }
        });
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/pd/processparamtemplate/vo/MesPdProcessParamTemplatePageReqVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,24 @@
package cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo;

import cn.iocoder.yudao.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;

@Schema(description = "管理后台 - MES å·¥è‰ºå‚数模板分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class MesPdProcessParamTemplatePageReqVO extends PageParam {

    @Schema(description = "模板编码", example = "PPT2024001")
    private String templateCode;

    @Schema(description = "模板名称", example = "注塑工艺参数模板")
    private String templateName;

    @Schema(description = "模板类型", example = "1")
    private Integer templateType;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/pd/processparamtemplate/vo/MesPdProcessParamTemplateRespVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,83 @@
package cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo;

import cn.iocoder.yudao.framework.excel.core.annotations.DictFormat;
import cn.iocoder.yudao.framework.excel.core.convert.DictConvert;
import cn.iocoder.yudao.module.mes.enums.DictTypeConstants;
import cn.idev.excel.annotation.ExcelIgnoreUnannotated;
import cn.idev.excel.annotation.ExcelProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.time.LocalDateTime;
import java.util.List;

@Schema(description = "管理后台 - MES å·¥è‰ºå‚数模板 Response VO")
@Data
@ExcelIgnoreUnannotated
public class MesPdProcessParamTemplateRespVO {

    @Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
    @ExcelProperty("编号")
    private Long id;

    @Schema(description = "模板编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "PPT2024001")
    @ExcelProperty("模板编码")
    private String templateCode;

    @Schema(description = "模板名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "注塑工艺参数模板")
    @ExcelProperty("模板名称")
    private String templateName;

    @Schema(description = "模板类型", example = "1")
    @ExcelProperty(value = "模板类型", converter = DictConvert.class)
    @DictFormat(DictTypeConstants.MES_PD_PROCESS_PARAM_TEMPLATE_TYPE)
    private Integer templateType;

    @Schema(description = "备注", example = "测试备注")
    @ExcelProperty("备注")
    private String remark;

    @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
    @ExcelProperty("创建时间")
    private LocalDateTime createTime;

    @Schema(description = "模板明细列表")
    private List<DetailResp> details;

    @Schema(description = "模板明细")
    @Data
    public static class DetailResp {

        @Schema(description = "明细编号", example = "1")
        private Long id;

        @Schema(description = "模板ID", example = "1")
        private Long templateId;

        @Schema(description = "工艺参数ID", example = "1")
        private Long processParamId;

        @Schema(description = "参数编码", example = "PP2024001")
        private String paramCode;

        @Schema(description = "参数名称", example = "温度")
        private String paramName;

        @Schema(description = "参数类型", example = "1")
        private Integer paramType;

        @Schema(description = "计量单位ID", example = "1")
        private Long unitMeasureId;

        @Schema(description = "计量单位名称", example = "℃")
        private String unitMeasureName;

        @Schema(description = "是否必填", example = "true")
        private Boolean required;

        @Schema(description = "备注", example = "测试备注")
        private String remark;

    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/pd/processparamtemplate/vo/MesPdProcessParamTemplateSaveReqVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,50 @@
package cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import java.util.List;

@Schema(description = "管理后台 - MES å·¥è‰ºå‚数模板新增/修改 Request VO")
@Data
public class MesPdProcessParamTemplateSaveReqVO {

    @Schema(description = "编号", requiredMode = Schema.RequiredMode.NOT_REQUIRED, example = "1024")
    private Long id;

    @Schema(description = "模板名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "注塑工艺参数模板")
    @NotBlank(message = "模板名称不能为空")
    private String templateName;

    @Schema(description = "模板类型", example = "1")
    private Integer templateType;

    @Schema(description = "备注", example = "测试备注")
    private String remark;

    @Schema(description = "模板明细列表", requiredMode = Schema.RequiredMode.REQUIRED)
    @NotEmpty(message = "模板明细不能为空")
    @Valid
    private List<Detail> details;

    @Schema(description = "模板明细")
    @Data
    public static class Detail {

        @Schema(description = "工艺参数ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
        @NotNull(message = "工艺参数ID不能为空")
        private Long processParamId;

        @Schema(description = "是否必填（可覆盖参数默认值）", example = "true")
        private Boolean required;

        @Schema(description = "备注（可覆盖参数默认值）", example = "自定义备注")
        private String remark;

    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/pd/processparam/MesPdProcessParamDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,59 @@
package cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparam;

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import cn.iocoder.yudao.module.mes.enums.DictTypeConstants;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

/**
 * MES å·¥è‰ºå‚æ•° DO
 *
 * @author èŠ‹é“源码
 */
@TableName("mes_pd_process_param")
@KeySequence("mes_pd_process_param_seq") // ç”¨äºŽ Oracle、PostgreSQL、Kingbase、DB2、H2 æ•°æ®åº“的主键自增。如果是 MySQL ç­‰æ•°æ®åº“，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MesPdProcessParamDO extends BaseDO {

    /**
     * ç¼–号
     */
    @TableId
    private Long id;
    /**
     * å‚数编码
     */
    private String paramCode;
    /**
     * å‚数名称
     */
    private String paramName;
    /**
     * å‚数类型
     *
     * å­—å…¸ {@link DictTypeConstants#MES_PD_PROCESS_PARAM_TYPE}
     */
    private Integer paramType;
    /**
     * è®¡é‡å•ä½ID
     *
     * å…³è” mes_md_unit_measure çš„ id
     */
    private Long unitMeasureId;
    /**
     * æ˜¯å¦å¿…å¡«
     */
    private Boolean required;
    /**
     * å¤‡æ³¨
     */
    private String remark;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/pd/processparamtemplate/MesPdProcessParamTemplateDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,49 @@
package cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate;

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import cn.iocoder.yudao.module.mes.enums.DictTypeConstants;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

/**
 * MES å·¥è‰ºå‚数模板 DO
 *
 * @author èŠ‹é“源码
 */
@TableName("mes_pd_process_param_template")
@KeySequence("mes_pd_process_param_template_seq") // ç”¨äºŽ Oracle、PostgreSQL、Kingbase、DB2、H2 æ•°æ®åº“的主键自增。如果是 MySQL ç­‰æ•°æ®åº“，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MesPdProcessParamTemplateDO extends BaseDO {

    /**
     * ç¼–号
     */
    @TableId
    private Long id;
    /**
     * æ¨¡æ¿ç¼–码
     */
    private String templateCode;
    /**
     * æ¨¡æ¿åç§°
     */
    private String templateName;
    /**
     * æ¨¡æ¿ç±»åž‹
     *
     * å­—å…¸ {@link DictTypeConstants#MES_PD_PROCESS_PARAM_TEMPLATE_TYPE}
     */
    private Integer templateType;
    /**
     * å¤‡æ³¨
     */
    private String remark;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/pd/processparamtemplate/MesPdProcessParamTemplateDetailDO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,69 @@
package cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate;

import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
import com.baomidou.mybatisplus.annotation.KeySequence;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;

/**
 * MES å·¥è‰ºå‚数模板明细 DO
 * <p>
 * å¿«ç…§è¡¨ï¼šå­˜å‚¨å…³è”时工艺参数的副本值，改变工艺参数列表的值不影响模板明细。
 * process_param_id ä»…作溯源，模板不从参数主表读取显示值。
 *
 * @author èŠ‹é“源码
 */
@TableName("mes_pd_process_param_template_detail")
@KeySequence("mes_pd_process_param_template_detail_seq") // ç”¨äºŽ Oracle、PostgreSQL、Kingbase、DB2、H2 æ•°æ®åº“的主键自增。如果是 MySQL ç­‰æ•°æ®åº“，可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class MesPdProcessParamTemplateDetailDO extends BaseDO {

    /**
     * ç¼–号
     */
    @TableId
    private Long id;
    /**
     * æ¨¡æ¿ID
     *
     * å…³è” {@link MesPdProcessParamTemplateDO#getId()}
     */
    private Long templateId;
    /**
     * å·¥è‰ºå‚æ•°ID（仅作溯源，不影响快照值）
     *
     * å…³è” mes_pd_process_param çš„ id
     */
    private Long processParamId;
    /**
     * å‚数编码（快照）
     */
    private String paramCode;
    /**
     * å‚数名称（快照）
     */
    private String paramName;
    /**
     * å‚数类型（快照）
     */
    private Integer paramType;
    /**
     * è®¡é‡å•ä½ID（快照）
     */
    private Long unitMeasureId;
    /**
     * æ˜¯å¦å¿…填（快照）
     */
    private Boolean required;
    /**
     * å¤‡æ³¨ï¼ˆå¿«ç…§ï¼‰
     */
    private String remark;

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/pd/processparam/MesPdProcessParamMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,25 @@
package cn.iocoder.yudao.module.mes.dal.mysql.pd.processparam;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo.MesPdProcessParamPageReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparam.MesPdProcessParamDO;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface MesPdProcessParamMapper extends BaseMapperX<MesPdProcessParamDO> {

    default PageResult<MesPdProcessParamDO> selectPage(MesPdProcessParamPageReqVO reqVO) {
        return selectPage(reqVO, new LambdaQueryWrapperX<MesPdProcessParamDO>()
                .likeIfPresent(MesPdProcessParamDO::getParamCode, reqVO.getParamCode())
                .likeIfPresent(MesPdProcessParamDO::getParamName, reqVO.getParamName())
                .eqIfPresent(MesPdProcessParamDO::getParamType, reqVO.getParamType())
                .orderByDesc(MesPdProcessParamDO::getId));
    }

    default MesPdProcessParamDO selectByParamCode(String paramCode) {
        return selectOne(MesPdProcessParamDO::getParamCode, paramCode);
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/pd/processparamtemplate/MesPdProcessParamTemplateDetailMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.mes.dal.mysql.pd.processparamtemplate;

import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate.MesPdProcessParamTemplateDetailDO;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface MesPdProcessParamTemplateDetailMapper extends BaseMapperX<MesPdProcessParamTemplateDetailDO> {

    default List<MesPdProcessParamTemplateDetailDO> selectListByTemplateId(Long templateId) {
        return selectList(MesPdProcessParamTemplateDetailDO::getTemplateId, templateId);
    }

    default int deleteByTemplateId(Long templateId) {
        return delete(MesPdProcessParamTemplateDetailDO::getTemplateId, templateId);
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/pd/processparamtemplate/MesPdProcessParamTemplateMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,25 @@
package cn.iocoder.yudao.module.mes.dal.mysql.pd.processparamtemplate;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo.MesPdProcessParamTemplatePageReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate.MesPdProcessParamTemplateDO;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface MesPdProcessParamTemplateMapper extends BaseMapperX<MesPdProcessParamTemplateDO> {

    default PageResult<MesPdProcessParamTemplateDO> selectPage(MesPdProcessParamTemplatePageReqVO reqVO) {
        return selectPage(reqVO, new LambdaQueryWrapperX<MesPdProcessParamTemplateDO>()
                .likeIfPresent(MesPdProcessParamTemplateDO::getTemplateCode, reqVO.getTemplateCode())
                .likeIfPresent(MesPdProcessParamTemplateDO::getTemplateName, reqVO.getTemplateName())
                .eqIfPresent(MesPdProcessParamTemplateDO::getTemplateType, reqVO.getTemplateType())
                .orderByDesc(MesPdProcessParamTemplateDO::getId));
    }

    default MesPdProcessParamTemplateDO selectByTemplateCode(String templateCode) {
        return selectOne(MesPdProcessParamTemplateDO::getTemplateCode, templateCode);
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/pd/processparam/MesPdProcessParamService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,85 @@
package cn.iocoder.yudao.module.mes.service.pd.processparam;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo.MesPdProcessParamPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo.MesPdProcessParamSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparam.MesPdProcessParamDO;
import jakarta.validation.Valid;

import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * MES å·¥è‰ºå‚æ•° Service æŽ¥å£
 *
 * @author èŠ‹é“源码
 */
public interface MesPdProcessParamService {

    /**
     * åˆ›å»ºå·¥è‰ºå‚æ•°
     *
     * @param createReqVO åˆ›å»ºä¿¡æ¯
     * @return ç¼–号
     */
    Long createProcessParam(@Valid MesPdProcessParamSaveReqVO createReqVO);

    /**
     * æ›´æ–°å·¥è‰ºå‚æ•°
     *
     * @param updateReqVO æ›´æ–°ä¿¡æ¯
     */
    void updateProcessParam(@Valid MesPdProcessParamSaveReqVO updateReqVO);

    /**
     * åˆ é™¤å·¥è‰ºå‚æ•°
     *
     * @param id ç¼–号
     */
    void deleteProcessParam(Long id);

    /**
     * æ ¡éªŒå·¥è‰ºå‚数存在
     *
     * @param id ç¼–号
     * @return å·¥è‰ºå‚æ•°
     */
    MesPdProcessParamDO validateProcessParamExists(Long id);

    /**
     * èŽ·å¾—工艺参数
     *
     * @param id ç¼–号
     * @return å·¥è‰ºå‚æ•°
     */
    MesPdProcessParamDO getProcessParam(Long id);

    /**
     * èŽ·å¾—工艺参数分页
     *
     * @param pageReqVO åˆ†é¡µæŸ¥è¯¢
     * @return å·¥è‰ºå‚数分页
     */
    PageResult<MesPdProcessParamDO> getProcessParamPage(MesPdProcessParamPageReqVO pageReqVO);

    /**
     * èŽ·å¾—工艺参数列表
     *
     * @param ids ç¼–号集合
     * @return å·¥è‰ºå‚数列表
     */
    List<MesPdProcessParamDO> getProcessParamList(Collection<Long> ids);

    /**
     * èŽ·å¾—工艺参数 Map
     *
     * @param ids ç¼–号集合
     * @return å·¥è‰ºå‚æ•° Map
     */
    default Map<Long, MesPdProcessParamDO> getProcessParamMap(Collection<Long> ids) {
        List<MesPdProcessParamDO> list = getProcessParamList(ids);
        return cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertMap(list, MesPdProcessParamDO::getId);
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/pd/processparam/MesPdProcessParamServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,91 @@
package cn.iocoder.yudao.module.mes.service.pd.processparam;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo.MesPdProcessParamPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparam.vo.MesPdProcessParamSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparam.MesPdProcessParamDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pd.processparam.MesPdProcessParamMapper;
import cn.iocoder.yudao.module.mes.enums.md.autocode.MesMdAutoCodeRuleCodeEnum;
import cn.iocoder.yudao.module.mes.service.md.autocode.MesMdAutoCodeRecordService;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

import java.util.Collection;
import java.util.List;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;

/**
 * MES å·¥è‰ºå‚æ•° Service å®žçŽ°ç±»
 *
 * @author èŠ‹é“源码
 */
@Service
@Validated
public class MesPdProcessParamServiceImpl implements MesPdProcessParamService {

    @Resource
    private MesPdProcessParamMapper processParamMapper;

    @Resource
    @Lazy
    private MesMdAutoCodeRecordService autoCodeRecordService;

    @Override
    public Long createProcessParam(MesPdProcessParamSaveReqVO createReqVO) {
        // ç”Ÿæˆå‚数编码
        String paramCode = autoCodeRecordService.generateAutoCode(
                MesMdAutoCodeRuleCodeEnum.PD_PROCESS_PARAM_CODE.getCode());
        // æ’å…¥
        MesPdProcessParamDO processParam = BeanUtils.toBean(createReqVO, MesPdProcessParamDO.class);
        processParam.setParamCode(paramCode);
        processParamMapper.insert(processParam);
        return processParam.getId();
    }

    @Override
    public void updateProcessParam(MesPdProcessParamSaveReqVO updateReqVO) {
        // æ ¡éªŒå­˜åœ¨
        validateProcessParamExists(updateReqVO.getId());
        // æ›´æ–°
        MesPdProcessParamDO updateObj = BeanUtils.toBean(updateReqVO, MesPdProcessParamDO.class);
        processParamMapper.updateById(updateObj);
    }

    @Override
    public void deleteProcessParam(Long id) {
        // æ ¡éªŒå­˜åœ¨
        validateProcessParamExists(id);
        // åˆ é™¤
        processParamMapper.deleteById(id);
    }

    @Override
    public MesPdProcessParamDO validateProcessParamExists(Long id) {
        MesPdProcessParamDO processParam = processParamMapper.selectById(id);
        if (processParam == null) {
            throw exception(PD_PROCESS_PARAM_NOT_EXISTS);
        }
        return processParam;
    }

    @Override
    public MesPdProcessParamDO getProcessParam(Long id) {
        return processParamMapper.selectById(id);
    }

    @Override
    public PageResult<MesPdProcessParamDO> getProcessParamPage(MesPdProcessParamPageReqVO pageReqVO) {
        return processParamMapper.selectPage(pageReqVO);
    }

    @Override
    public List<MesPdProcessParamDO> getProcessParamList(Collection<Long> ids) {
        return processParamMapper.selectBatchIds(ids);
    }

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/pd/processparamtemplate/MesPdProcessParamTemplateService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,73 @@
package cn.iocoder.yudao.module.mes.service.pd.processparamtemplate;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo.MesPdProcessParamTemplatePageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo.MesPdProcessParamTemplateSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate.MesPdProcessParamTemplateDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate.MesPdProcessParamTemplateDetailDO;
import jakarta.validation.Valid;

import java.util.List;

/**
 * MES å·¥è‰ºå‚数模板 Service æŽ¥å£
 *
 * @author èŠ‹é“源码
 */
public interface MesPdProcessParamTemplateService {

    /**
     * åˆ›å»ºå·¥è‰ºå‚数模板
     *
     * @param createReqVO åˆ›å»ºä¿¡æ¯
     * @return ç¼–号
     */
    Long createProcessParamTemplate(@Valid MesPdProcessParamTemplateSaveReqVO createReqVO);

    /**
     * æ›´æ–°å·¥è‰ºå‚数模板
     *
     * @param updateReqVO æ›´æ–°ä¿¡æ¯
     */
    void updateProcessParamTemplate(@Valid MesPdProcessParamTemplateSaveReqVO updateReqVO);

    /**
     * åˆ é™¤å·¥è‰ºå‚数模板
     *
     * @param id ç¼–号
     */
    void deleteProcessParamTemplate(Long id);

    /**
     * æ ¡éªŒå·¥è‰ºå‚数模板存在
     *
     * @param id ç¼–号
     * @return å·¥è‰ºå‚数模板
     */
    MesPdProcessParamTemplateDO validateProcessParamTemplateExists(Long id);

    /**
     * èŽ·å¾—工艺参数模板
     *
     * @param id ç¼–号
     * @return å·¥è‰ºå‚数模板
     */
    MesPdProcessParamTemplateDO getProcessParamTemplate(Long id);

    /**
     * èŽ·å¾—工艺参数模板分页
     *
     * @param pageReqVO åˆ†é¡µæŸ¥è¯¢
     * @return å·¥è‰ºå‚数模板分页
     */
    PageResult<MesPdProcessParamTemplateDO> getProcessParamTemplatePage(MesPdProcessParamTemplatePageReqVO pageReqVO);

    /**
     * èŽ·å¾—工艺参数模板明细列表
     *
     * @param templateId æ¨¡æ¿ID
     * @return æ¨¡æ¿æ˜Žç»†åˆ—表
     */
    List<MesPdProcessParamTemplateDetailDO> getProcessParamTemplateDetailListByTemplateId(Long templateId);

}

 yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/pd/processparamtemplate/MesPdProcessParamTemplateServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,146 @@
package cn.iocoder.yudao.module.mes.service.pd.processparamtemplate;

import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo.MesPdProcessParamTemplatePageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.pd.processparamtemplate.vo.MesPdProcessParamTemplateSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparam.MesPdProcessParamDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate.MesPdProcessParamTemplateDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.pd.processparamtemplate.MesPdProcessParamTemplateDetailDO;
import cn.iocoder.yudao.module.mes.dal.mysql.pd.processparamtemplate.MesPdProcessParamTemplateDetailMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.pd.processparamtemplate.MesPdProcessParamTemplateMapper;
import cn.iocoder.yudao.module.mes.enums.md.autocode.MesMdAutoCodeRuleCodeEnum;
import cn.iocoder.yudao.module.mes.service.md.autocode.MesMdAutoCodeRecordService;
import cn.iocoder.yudao.module.mes.service.pd.processparam.MesPdProcessParamService;
import jakarta.annotation.Resource;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;

import java.util.ArrayList;
import java.util.List;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;

/**
 * MES å·¥è‰ºå‚数模板 Service å®žçŽ°ç±»
 *
 * @author èŠ‹é“源码
 */
@Service
@Validated
public class MesPdProcessParamTemplateServiceImpl implements MesPdProcessParamTemplateService {

    @Resource
    private MesPdProcessParamTemplateMapper templateMapper;

    @Resource
    private MesPdProcessParamTemplateDetailMapper detailMapper;

    @Resource
    @Lazy
    private MesPdProcessParamService processParamService;

    @Resource
    @Lazy
    private MesMdAutoCodeRecordService autoCodeRecordService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createProcessParamTemplate(MesPdProcessParamTemplateSaveReqVO createReqVO) {
        // 1. ç”Ÿæˆæ¨¡æ¿ç¼–码
        String templateCode = autoCodeRecordService.generateAutoCode(
                MesMdAutoCodeRuleCodeEnum.PD_PROCESS_PARAM_TEMPLATE_CODE.getCode());
        // 2. æ’入模板主表
        MesPdProcessParamTemplateDO template = BeanUtils.toBean(createReqVO, MesPdProcessParamTemplateDO.class);
        template.setTemplateCode(templateCode);
        templateMapper.insert(template);
        // 3. å¿«ç…§å·¥è‰ºå‚数值到明细中
        createTemplateDetails(template.getId(), createReqVO.getDetails());
        return template.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateProcessParamTemplate(MesPdProcessParamTemplateSaveReqVO updateReqVO) {
        // 1. æ ¡éªŒå­˜åœ¨
        validateProcessParamTemplateExists(updateReqVO.getId());
        // 2. æ›´æ–°æ¨¡æ¿ä¸»è¡¨
        MesPdProcessParamTemplateDO updateObj = BeanUtils.toBean(updateReqVO, MesPdProcessParamTemplateDO.class);
        templateMapper.updateById(updateObj);
        // 3. åˆ é™¤æ—§æ˜Žç»†å¹¶é‡æ–°æ’入（快照模式：先删后插）
        detailMapper.deleteByTemplateId(updateReqVO.getId());
        createTemplateDetails(updateReqVO.getId(), updateReqVO.getDetails());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteProcessParamTemplate(Long id) {
        // 1. æ ¡éªŒå­˜åœ¨
        validateProcessParamTemplateExists(id);
        // 2. åˆ é™¤æ˜Žç»†
        detailMapper.deleteByTemplateId(id);
        // 3. åˆ é™¤æ¨¡æ¿ä¸»è¡¨
        templateMapper.deleteById(id);
    }

    @Override
    public MesPdProcessParamTemplateDO validateProcessParamTemplateExists(Long id) {
        MesPdProcessParamTemplateDO template = templateMapper.selectById(id);
        if (template == null) {
            throw exception(PD_PROCESS_PARAM_TEMPLATE_NOT_EXISTS);
        }
        return template;
    }

    @Override
    public MesPdProcessParamTemplateDO getProcessParamTemplate(Long id) {
        return templateMapper.selectById(id);
    }

    @Override
    public PageResult<MesPdProcessParamTemplateDO> getProcessParamTemplatePage(MesPdProcessParamTemplatePageReqVO pageReqVO) {
        return templateMapper.selectPage(pageReqVO);
    }

    @Override
    public List<MesPdProcessParamTemplateDetailDO> getProcessParamTemplateDetailListByTemplateId(Long templateId) {
        return detailMapper.selectListByTemplateId(templateId);
    }

    /**
     * åˆ›å»ºæ¨¡æ¿æ˜Žç»†ï¼ˆå¿«ç…§é€»è¾‘：从工艺参数主表复制值到明细）
     *
     * @param templateId æ¨¡æ¿ID
     * @param detailVOs  æ˜Žç»†VO列表
     */
    private void createTemplateDetails(Long templateId, List<MesPdProcessParamTemplateSaveReqVO.Detail> detailVOs) {
        if (detailVOs == null || detailVOs.isEmpty()) {
            return;
        }
        List<MesPdProcessParamTemplateDetailDO> detailDOs = new ArrayList<>();
        for (MesPdProcessParamTemplateSaveReqVO.Detail detailVO : detailVOs) {
            // æŸ¥æ‰¾æºå·¥è‰ºå‚æ•°
            MesPdProcessParamDO param = processParamService.getProcessParam(detailVO.getProcessParamId());
            if (param == null) {
                throw exception(PD_PROCESS_PARAM_NOT_EXISTS);
            }
            // å°†å€¼ä»Žå‚数复制到明细（快照！）
            MesPdProcessParamTemplateDetailDO detail = MesPdProcessParamTemplateDetailDO.builder()
                    .templateId(templateId)
                    .processParamId(param.getId())  // ä»…作溯源
                    .paramCode(param.getParamCode())         // å¤åˆ¶
                    .paramName(param.getParamName())         // å¤åˆ¶
                    .paramType(param.getParamType())         // å¤åˆ¶
                    .unitMeasureId(param.getUnitMeasureId()) // å¤åˆ¶
                    .required(detailVO.getRequired() != null ? detailVO.getRequired() : param.getRequired()) // å…è®¸è¦†ç›–
                    .remark(detailVO.getRemark() != null ? detailVO.getRemark() : param.getRemark())         // å…è®¸è¦†ç›–
                    .build();
            detailDOs.add(detail);
        }
        detailDOs.forEach(detailMapper::insert);
    }

}