【工艺路线】 DB脚本设计

dev
siontion 5 months ago
parent acaa14b6a1
commit 2aed6b216f

@ -51,6 +51,8 @@ public interface ErrorCodeConstants {
ErrorCode EQUIP_MAINTENANCE_RECORD_NOT_EXISTS = new ErrorCode(1_001_014, "设备维保记录不存在");
ErrorCode SC_EQUIPMENT_NOT_EXISTS = new ErrorCode(1_001_015, "数采设备表不存在");
ErrorCode SYSTEM_PARAMETERS_NOT_EXISTS = new ErrorCode(1_001_016, "系统参数设置不存在");
ErrorCode PROCESS_NOT_EXISTS = new ErrorCode(1_001_017, "工艺路线不存在");
ErrorCode PROCESS_DETAIL_NOT_EXISTS = new ErrorCode(1_001_018, "工艺路线明细不存在");
/*********组织架构************/
ErrorCode WORKSHOP_NOT_EXISTS = new ErrorCode(1_002_001, "车间不存在");

@ -0,0 +1,95 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.process;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.CommonResult;
import com.chanko.yunxi.mes.framework.common.util.object.BeanUtils;
import static com.chanko.yunxi.mes.framework.common.pojo.CommonResult.success;
import com.chanko.yunxi.mes.framework.excel.core.util.ExcelUtils;
import com.chanko.yunxi.mes.framework.operatelog.core.annotations.OperateLog;
import static com.chanko.yunxi.mes.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.chanko.yunxi.mes.module.biz.controller.admin.process.vo.*;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.process.ProcessDO;
import com.chanko.yunxi.mes.module.biz.service.process.ProcessService;
@Tag(name = "管理后台 - 工艺路线")
@RestController
@RequestMapping("/biz/process")
@Validated
public class ProcessController {
@Resource
private ProcessService processService;
@PostMapping("/create")
@Operation(summary = "创建工艺路线")
@PreAuthorize("@ss.hasPermission('biz:process:create')")
public CommonResult<Long> createProcess(@Valid @RequestBody ProcessSaveReqVO createReqVO) {
return success(processService.createProcess(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新工艺路线")
@PreAuthorize("@ss.hasPermission('biz:process:update')")
public CommonResult<Boolean> updateProcess(@Valid @RequestBody ProcessSaveReqVO updateReqVO) {
processService.updateProcess(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除工艺路线")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('biz:process:delete')")
public CommonResult<Boolean> deleteProcess(@RequestParam("id") Long id) {
processService.deleteProcess(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得工艺路线")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('biz:process:query')")
public CommonResult<ProcessRespVO> getProcess(@RequestParam("id") Long id) {
ProcessDO process = processService.getProcess(id);
return success(BeanUtils.toBean(process, ProcessRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得工艺路线分页")
@PreAuthorize("@ss.hasPermission('biz:process:query')")
public CommonResult<PageResult<ProcessRespVO>> getProcessPage(@Valid ProcessPageReqVO pageReqVO) {
PageResult<ProcessDO> pageResult = processService.getProcessPage(pageReqVO);
return success(BeanUtils.toBean(pageResult, ProcessRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出工艺路线 Excel")
@PreAuthorize("@ss.hasPermission('biz:process:export')")
@OperateLog(type = EXPORT)
public void exportProcessExcel(@Valid ProcessPageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<ProcessDO> list = processService.getProcessPage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "工艺路线.xls", "数据", ProcessRespVO.class,
BeanUtils.toBean(list, ProcessRespVO.class));
}
}

@ -0,0 +1,34 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.process.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.chanko.yunxi.mes.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 工艺路线分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProcessPageReqVO extends PageParam {
@Schema(description = "自增字段,唯一")
private Long id;
@Schema(description = "工艺路线编号")
private String code;
@Schema(description = "工艺路线名称,唯一")
private String name;
@Schema(description = "状态,1表示正常2表示禁用")
private Integer status;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,39 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.process.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.util.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
import com.chanko.yunxi.mes.framework.excel.core.annotations.DictFormat;
import com.chanko.yunxi.mes.framework.excel.core.convert.DictConvert;
@Schema(description = "管理后台 - 工艺路线 Response VO")
@Data
@ExcelIgnoreUnannotated
public class ProcessRespVO {
@Schema(description = "自增字段,唯一", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("自增字段,唯一")
private Long id;
@Schema(description = "工艺路线编号")
@ExcelProperty("工艺路线编号")
private String code;
@Schema(description = "工艺路线名称,唯一", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("工艺路线名称,唯一")
private String name;
@Schema(description = "状态,1表示正常2表示禁用", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty(value = "状态,1表示正常2表示禁用", converter = DictConvert.class)
@DictFormat("infra_boolean_string") // TODO 代码优化:建议设置到对应的 DictTypeConstants 枚举类中
private Integer status;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,27 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.process.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
import java.util.*;
@Schema(description = "管理后台 - 工艺路线新增/修改 Request VO")
@Data
public class ProcessSaveReqVO {
@Schema(description = "自增字段,唯一", requiredMode = Schema.RequiredMode.REQUIRED)
private Long id;
@Schema(description = "工艺路线编号")
private String code;
@Schema(description = "工艺路线名称,唯一", requiredMode = Schema.RequiredMode.REQUIRED)
@NotEmpty(message = "工艺路线名称,唯一不能为空")
private String name;
@Schema(description = "状态,1表示正常2表示禁用", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "状态,1表示正常2表示禁用不能为空")
private Integer status;
}

@ -0,0 +1,95 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.processdetail;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.CommonResult;
import com.chanko.yunxi.mes.framework.common.util.object.BeanUtils;
import static com.chanko.yunxi.mes.framework.common.pojo.CommonResult.success;
import com.chanko.yunxi.mes.framework.excel.core.util.ExcelUtils;
import com.chanko.yunxi.mes.framework.operatelog.core.annotations.OperateLog;
import static com.chanko.yunxi.mes.framework.operatelog.core.enums.OperateTypeEnum.*;
import com.chanko.yunxi.mes.module.biz.controller.admin.processdetail.vo.*;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.processdetail.ProcessDetailDO;
import com.chanko.yunxi.mes.module.biz.service.processdetail.ProcessDetailService;
@Tag(name = "管理后台 - 工艺路线明细")
@RestController
@RequestMapping("/biz/process-detail")
@Validated
public class ProcessDetailController {
@Resource
private ProcessDetailService processDetailService;
@PostMapping("/create")
@Operation(summary = "创建工艺路线明细")
@PreAuthorize("@ss.hasPermission('biz:process-detail:create')")
public CommonResult<Long> createProcessDetail(@Valid @RequestBody ProcessDetailSaveReqVO createReqVO) {
return success(processDetailService.createProcessDetail(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新工艺路线明细")
@PreAuthorize("@ss.hasPermission('biz:process-detail:update')")
public CommonResult<Boolean> updateProcessDetail(@Valid @RequestBody ProcessDetailSaveReqVO updateReqVO) {
processDetailService.updateProcessDetail(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除工艺路线明细")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('biz:process-detail:delete')")
public CommonResult<Boolean> deleteProcessDetail(@RequestParam("id") Long id) {
processDetailService.deleteProcessDetail(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得工艺路线明细")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('biz:process-detail:query')")
public CommonResult<ProcessDetailRespVO> getProcessDetail(@RequestParam("id") Long id) {
ProcessDetailDO processDetail = processDetailService.getProcessDetail(id);
return success(BeanUtils.toBean(processDetail, ProcessDetailRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得工艺路线明细分页")
@PreAuthorize("@ss.hasPermission('biz:process-detail:query')")
public CommonResult<PageResult<ProcessDetailRespVO>> getProcessDetailPage(@Valid ProcessDetailPageReqVO pageReqVO) {
PageResult<ProcessDetailDO> pageResult = processDetailService.getProcessDetailPage(pageReqVO);
return success(BeanUtils.toBean(pageResult, ProcessDetailRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出工艺路线明细 Excel")
@PreAuthorize("@ss.hasPermission('biz:process-detail:export')")
@OperateLog(type = EXPORT)
public void exportProcessDetailExcel(@Valid ProcessDetailPageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<ProcessDetailDO> list = processDetailService.getProcessDetailPage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "工艺路线明细.xls", "数据", ProcessDetailRespVO.class,
BeanUtils.toBean(list, ProcessDetailRespVO.class));
}
}

@ -0,0 +1,40 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.processdetail.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.chanko.yunxi.mes.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 工艺路线明细分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class ProcessDetailPageReqVO extends PageParam {
@Schema(description = "自增字段,唯一")
private Long id;
@Schema(description = "工序id")
private Long procedureId;
@Schema(description = "工序顺序号")
private Integer procedureSort;
@Schema(description = "生产设备id")
private Long procedureEquipId;
@Schema(description = "明细类型1为工序2为产品")
private Integer type;
@Schema(description = "产品id物料")
private Long materialId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,44 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.processdetail.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.util.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 工艺路线明细 Response VO")
@Data
@ExcelIgnoreUnannotated
public class ProcessDetailRespVO {
@Schema(description = "自增字段,唯一", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("自增字段,唯一")
private Long id;
@Schema(description = "工序id")
@ExcelProperty("工序id")
private Long procedureId;
@Schema(description = "工序顺序号")
@ExcelProperty("工序顺序号")
private Integer procedureSort;
@Schema(description = "生产设备id")
@ExcelProperty("生产设备id")
private Long procedureEquipId;
@Schema(description = "明细类型1为工序2为产品")
@ExcelProperty("明细类型1为工序2为产品")
private Integer type;
@Schema(description = "产品id物料")
@ExcelProperty("产品id物料")
private Long materialId;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,31 @@
package com.chanko.yunxi.mes.module.biz.controller.admin.processdetail.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
import java.util.*;
@Schema(description = "管理后台 - 工艺路线明细新增/修改 Request VO")
@Data
public class ProcessDetailSaveReqVO {
@Schema(description = "自增字段,唯一", requiredMode = Schema.RequiredMode.REQUIRED)
private Long id;
@Schema(description = "工序id")
private Long procedureId;
@Schema(description = "工序顺序号")
private Integer procedureSort;
@Schema(description = "生产设备id")
private Long procedureEquipId;
@Schema(description = "明细类型1为工序2为产品")
private Integer type;
@Schema(description = "产品id物料")
private Long materialId;
}

@ -0,0 +1,45 @@
package com.chanko.yunxi.mes.module.biz.dal.dataobject.process;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.chanko.yunxi.mes.framework.mybatis.core.dataobject.BaseDO;
/**
* 线 DO
*
* @author
*/
@TableName("base_process")
@KeySequence("base_process_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ProcessDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
* 线
*/
private String code;
/**
* 线,
*/
private String name;
/**
* ,12
*
* {@link TODO infra_boolean_string }
*/
private Integer status;
}

@ -0,0 +1,51 @@
package com.chanko.yunxi.mes.module.biz.dal.dataobject.processdetail;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import com.chanko.yunxi.mes.framework.mybatis.core.dataobject.BaseDO;
/**
* 线 DO
*
* @author
*/
@TableName("base_process_detail")
@KeySequence("base_process_detail_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ProcessDetailDO extends BaseDO {
/**
*
*/
@TableId
private Long id;
/**
* id
*/
private Long procedureId;
/**
*
*/
private Integer procedureSort;
/**
* id
*/
private Long procedureEquipId;
/**
* 12
*/
private Integer type;
/**
* id
*/
private Long materialId;
}

@ -0,0 +1,30 @@
package com.chanko.yunxi.mes.module.biz.dal.mysql.process;
import java.util.*;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.chanko.yunxi.mes.framework.mybatis.core.mapper.BaseMapperX;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.process.ProcessDO;
import org.apache.ibatis.annotations.Mapper;
import com.chanko.yunxi.mes.module.biz.controller.admin.process.vo.*;
/**
* 线 Mapper
*
* @author
*/
@Mapper
public interface ProcessMapper extends BaseMapperX<ProcessDO> {
default PageResult<ProcessDO> selectPage(ProcessPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ProcessDO>()
.eqIfPresent(ProcessDO::getId, reqVO.getId())
.eqIfPresent(ProcessDO::getCode, reqVO.getCode())
.likeIfPresent(ProcessDO::getName, reqVO.getName())
.eqIfPresent(ProcessDO::getStatus, reqVO.getStatus())
.betweenIfPresent(ProcessDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProcessDO::getId));
}
}

@ -0,0 +1,32 @@
package com.chanko.yunxi.mes.module.biz.dal.mysql.processdetail;
import java.util.*;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.chanko.yunxi.mes.framework.mybatis.core.mapper.BaseMapperX;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.processdetail.ProcessDetailDO;
import org.apache.ibatis.annotations.Mapper;
import com.chanko.yunxi.mes.module.biz.controller.admin.processdetail.vo.*;
/**
* 线 Mapper
*
* @author
*/
@Mapper
public interface ProcessDetailMapper extends BaseMapperX<ProcessDetailDO> {
default PageResult<ProcessDetailDO> selectPage(ProcessDetailPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<ProcessDetailDO>()
.eqIfPresent(ProcessDetailDO::getId, reqVO.getId())
.eqIfPresent(ProcessDetailDO::getProcedureId, reqVO.getProcedureId())
.eqIfPresent(ProcessDetailDO::getProcedureSort, reqVO.getProcedureSort())
.eqIfPresent(ProcessDetailDO::getProcedureEquipId, reqVO.getProcedureEquipId())
.eqIfPresent(ProcessDetailDO::getType, reqVO.getType())
.eqIfPresent(ProcessDetailDO::getMaterialId, reqVO.getMaterialId())
.betweenIfPresent(ProcessDetailDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(ProcessDetailDO::getId));
}
}

@ -0,0 +1,55 @@
package com.chanko.yunxi.mes.module.biz.service.process;
import java.util.*;
import javax.validation.*;
import com.chanko.yunxi.mes.module.biz.controller.admin.process.vo.*;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.process.ProcessDO;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
/**
* 线 Service
*
* @author
*/
public interface ProcessService {
/**
* 线
*
* @param createReqVO
* @return
*/
Long createProcess(@Valid ProcessSaveReqVO createReqVO);
/**
* 线
*
* @param updateReqVO
*/
void updateProcess(@Valid ProcessSaveReqVO updateReqVO);
/**
* 线
*
* @param id
*/
void deleteProcess(Long id);
/**
* 线
*
* @param id
* @return 线
*/
ProcessDO getProcess(Long id);
/**
* 线
*
* @param pageReqVO
* @return 线
*/
PageResult<ProcessDO> getProcessPage(ProcessPageReqVO pageReqVO);
}

@ -0,0 +1,74 @@
package com.chanko.yunxi.mes.module.biz.service.process;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import com.chanko.yunxi.mes.module.biz.controller.admin.process.vo.*;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.process.ProcessDO;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import com.chanko.yunxi.mes.framework.common.util.object.BeanUtils;
import com.chanko.yunxi.mes.module.biz.dal.mysql.process.ProcessMapper;
import static com.chanko.yunxi.mes.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.chanko.yunxi.mes.module.biz.enums.ErrorCodeConstants.*;
/**
* 线 Service
*
* @author
*/
@Service
@Validated
public class ProcessServiceImpl implements ProcessService {
@Resource
private ProcessMapper processMapper;
@Override
public Long createProcess(ProcessSaveReqVO createReqVO) {
// 插入
ProcessDO process = BeanUtils.toBean(createReqVO, ProcessDO.class);
processMapper.insert(process);
// 返回
return process.getId();
}
@Override
public void updateProcess(ProcessSaveReqVO updateReqVO) {
// 校验存在
validateProcessExists(updateReqVO.getId());
// 更新
ProcessDO updateObj = BeanUtils.toBean(updateReqVO, ProcessDO.class);
processMapper.updateById(updateObj);
}
@Override
public void deleteProcess(Long id) {
// 校验存在
validateProcessExists(id);
// 删除
processMapper.deleteById(id);
}
private void validateProcessExists(Long id) {
if (processMapper.selectById(id) == null) {
throw exception(PROCESS_NOT_EXISTS);
}
}
@Override
public ProcessDO getProcess(Long id) {
return processMapper.selectById(id);
}
@Override
public PageResult<ProcessDO> getProcessPage(ProcessPageReqVO pageReqVO) {
return processMapper.selectPage(pageReqVO);
}
}

@ -0,0 +1,55 @@
package com.chanko.yunxi.mes.module.biz.service.processdetail;
import java.util.*;
import javax.validation.*;
import com.chanko.yunxi.mes.module.biz.controller.admin.processdetail.vo.*;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.processdetail.ProcessDetailDO;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
/**
* 线 Service
*
* @author
*/
public interface ProcessDetailService {
/**
* 线
*
* @param createReqVO
* @return
*/
Long createProcessDetail(@Valid ProcessDetailSaveReqVO createReqVO);
/**
* 线
*
* @param updateReqVO
*/
void updateProcessDetail(@Valid ProcessDetailSaveReqVO updateReqVO);
/**
* 线
*
* @param id
*/
void deleteProcessDetail(Long id);
/**
* 线
*
* @param id
* @return 线
*/
ProcessDetailDO getProcessDetail(Long id);
/**
* 线
*
* @param pageReqVO
* @return 线
*/
PageResult<ProcessDetailDO> getProcessDetailPage(ProcessDetailPageReqVO pageReqVO);
}

@ -0,0 +1,74 @@
package com.chanko.yunxi.mes.module.biz.service.processdetail;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import com.chanko.yunxi.mes.module.biz.controller.admin.processdetail.vo.*;
import com.chanko.yunxi.mes.module.biz.dal.dataobject.processdetail.ProcessDetailDO;
import com.chanko.yunxi.mes.framework.common.pojo.PageResult;
import com.chanko.yunxi.mes.framework.common.pojo.PageParam;
import com.chanko.yunxi.mes.framework.common.util.object.BeanUtils;
import com.chanko.yunxi.mes.module.biz.dal.mysql.processdetail.ProcessDetailMapper;
import static com.chanko.yunxi.mes.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.chanko.yunxi.mes.module.biz.enums.ErrorCodeConstants.*;
/**
* 线 Service
*
* @author
*/
@Service
@Validated
public class ProcessDetailServiceImpl implements ProcessDetailService {
@Resource
private ProcessDetailMapper processDetailMapper;
@Override
public Long createProcessDetail(ProcessDetailSaveReqVO createReqVO) {
// 插入
ProcessDetailDO processDetail = BeanUtils.toBean(createReqVO, ProcessDetailDO.class);
processDetailMapper.insert(processDetail);
// 返回
return processDetail.getId();
}
@Override
public void updateProcessDetail(ProcessDetailSaveReqVO updateReqVO) {
// 校验存在
validateProcessDetailExists(updateReqVO.getId());
// 更新
ProcessDetailDO updateObj = BeanUtils.toBean(updateReqVO, ProcessDetailDO.class);
processDetailMapper.updateById(updateObj);
}
@Override
public void deleteProcessDetail(Long id) {
// 校验存在
validateProcessDetailExists(id);
// 删除
processDetailMapper.deleteById(id);
}
private void validateProcessDetailExists(Long id) {
if (processDetailMapper.selectById(id) == null) {
throw exception(PROCESS_DETAIL_NOT_EXISTS);
}
}
@Override
public ProcessDetailDO getProcessDetail(Long id) {
return processDetailMapper.selectById(id);
}
@Override
public PageResult<ProcessDetailDO> getProcessDetailPage(ProcessDetailPageReqVO pageReqVO) {
return processDetailMapper.selectPage(pageReqVO);
}
}

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.chanko.yunxi.mes.module.biz.dal.mysql.process.ProcessMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.chanko.yunxi.mes.module.biz.dal.mysql.processdetail.ProcessDetailMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -0,0 +1,38 @@
import request from '@/config/axios'
export interface ProcessVO {
id: number
code: string
name: string
status: number
}
// 查询工艺路线分页
export const getProcessPage = async (params) => {
return await request.get({ url: `/biz/process/page`, params })
}
// 查询工艺路线详情
export const getProcess = async (id: number) => {
return await request.get({ url: `/biz/process/get?id=` + id })
}
// 新增工艺路线
export const createProcess = async (data: ProcessVO) => {
return await request.post({ url: `/biz/process/create`, data })
}
// 修改工艺路线
export const updateProcess = async (data: ProcessVO) => {
return await request.put({ url: `/biz/process/update`, data })
}
// 删除工艺路线
export const deleteProcess = async (id: number) => {
return await request.delete({ url: `/biz/process/delete?id=` + id })
}
// 导出工艺路线 Excel
export const exportProcess = async (params) => {
return await request.download({ url: `/biz/process/export-excel`, params })
}

@ -192,3 +192,35 @@ CREATE TABLE `base_system_parameters` (
PRIMARY KEY (`id`)
) ENGINE=InnoDB COMMENT='系统参数设置表';
drop table if exists `base_process`;
CREATE TABLE `base_process` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增字段,唯一',
`code` varchar(64) COLLATE DEFAULT NULL COMMENT '工艺路线编号',
`name` varchar(64) COLLATE NOT NULL COMMENT '工艺路线名称,唯一',
`status` tinyint(1) NOT NULL COMMENT '状态,1表示正常2表示禁用',
`creator` varchar(64) COLLATE DEFAULT '' COMMENT '创建者',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updater` varchar(64) COLLATE 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(20) NOT NULL DEFAULT '0' COMMENT '租户编号',
PRIMARY KEY (`id`)
) ENGINE=InnoDB COMMENT='工艺路线表';
drop table if exists `base_process_detail`;
CREATE TABLE `base_process_detail` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增字段,唯一',
`procedure_id` bigint(20) DEFAULT NULL COMMENT '工序id',
`procedure_sort` int(11) DEFAULT NULL COMMENT '工序顺序号',
`procedure_equip_id` bigint(20) DEFAULT NULL COMMENT '生产设备id',
`type` int(11) DEFAULT NULL COMMENT '明细类型1为工序2为产品',
`material_id` bigint(20) DEFAULT NULL COMMENT '产品id物料',
`creator` varchar(64) COLLATE DEFAULT '' COMMENT '创建者',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`updater` varchar(64) COLLATE 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(20) NOT NULL DEFAULT '0' COMMENT '租户编号',
PRIMARY KEY (`id`)
) ENGINE=InnoDB COMMENT='工艺路线明细表';

Loading…
Cancel
Save