超管统计接口50%

2026-08-13 05:12:07 +08:00 · 2024-08-16 18:13:37 +08:00
parent 47c9332a4a 696b363b1f
commit c027651b28
26 changed files with 766 additions and 333 deletions
@@ -0,0 +1,35 @@
+package com.cf.imes.framework.common.enums;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@AllArgsConstructor
+@Getter
+public enum MachineTypeEnum {
+
+
+    CUTTING(1, "开料设备"),
+
+    DRILL(2, "钻孔机设备"),
+
+    PANELSAW(3, "裁板锯"),
+
+    LABELING(4, "贴标机"),
+
+    BANDING(5, "封边机");
+
+    private Integer type;
+    private String machineName;
+
+
+    public boolean equals(Integer status) {
+        return this.type .equals(status) ;
+    }
+
+    public boolean equals(MachineTypeEnum enableStatusEnum) {
+        return enableStatusEnum != null && enableStatusEnum.type .equals(this.getType()) ;
+    }
+
+
+}
@@ -11,11 +11,11 @@ public interface ErrorCodeConstants {
    // ========== 生产单开料排单
    ErrorCode PLAN_NOT_EXISTS = new ErrorCode(1_001_107_000, "生产单开料排单不存在");

-    ErrorCode PLAN_NOT_ALLOW_DELETE = new ErrorCode(1_001_107_001, "排单 开料中 已开料 不予许删除");
+    ErrorCode PLAN_NOT_ALLOW_DELETE = new ErrorCode(1_001_107_001, "当前排单已开料不予许删除");

    ErrorCode PLAN_NOT_ALLOW_CANCEL = new ErrorCode(1_001_107_002, "排单 新单 不予许作废");

-    ErrorCode LIST_CHANGES_ARE_PROHIBITED = new ErrorCode(1_001_107_003, "当前排单已开料，禁止更改");
+    ErrorCode LIST_CHANGES_ARE_PROHIBITED = new ErrorCode(1_001_107_003, "当前排单有板材已开料，禁止更改");

    // ========== 生产单商品 TODO 补充编号 ==========
    ErrorCode GOODS_NOT_EXISTS = new ErrorCode(1_001_108_000, "生产单商品不存在");
@@ -2,7 +2,6 @@ package com.cf.imes.module.manage.service.pack;


 import cn.hutool.core.collection.CollectionUtil;
-import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.PageDTO;
 import com.cf.imes.framework.common.enums.OrderPackageStatusEnum;
@@ -12,7 +11,6 @@ import com.cf.imes.framework.common.pojo.PageResult;
 import com.cf.imes.framework.common.util.json.JsonUtils;
 import com.cf.imes.framework.common.util.object.BeanUtils;
 import com.cf.imes.module.manage.controller.admin.pack.prePack.PackPlateList;
-import com.cf.imes.module.manage.controller.admin.pack.prePack.PrePackData;
 import com.cf.imes.module.manage.controller.admin.pack.prePack.PrePackOptimizeInfo;
 import com.cf.imes.module.manage.controller.admin.pack.prePack.PrePackReqVO;
 import com.cf.imes.module.manage.controller.admin.pack.vo.*;
@@ -20,13 +18,12 @@ import com.cf.imes.module.manage.controller.admin.query.vo.pack.OrderPackageVO;
 import com.cf.imes.module.manage.dal.dataobject.pack.OrderPrepackagedDO;
 import com.cf.imes.module.manage.dal.dataobject.plate.OrderPlateDO;
 import com.cf.imes.module.manage.dal.dataobject.process.OrderDO;
-import com.cf.imes.module.manage.dal.dataobject.process.OrderProcessStepNDO;
 import com.cf.imes.module.manage.dal.dataobject.query.OrderItemDO;
 import com.cf.imes.module.manage.dal.dataobject.query.OrderPackageDO;
 import com.cf.imes.module.manage.dal.dataobject.query.OrderPartsNDO;
 import com.cf.imes.module.manage.dal.mysql.pack.OrderBodyMapper;
-import com.cf.imes.module.manage.dal.mysql.pack.OrderPrepackagedMapper;
 import com.cf.imes.module.manage.dal.mysql.pack.OrderPackageMapper;
+import com.cf.imes.module.manage.dal.mysql.pack.OrderPrepackagedMapper;
 import com.cf.imes.module.manage.dal.mysql.plate.OrderPlateMapper;
 import com.cf.imes.module.manage.dal.mysql.process.ProcessStepItemMapper;
 import com.cf.imes.module.manage.dal.mysql.process.ProcessStepMapper;
@@ -34,29 +31,28 @@ import com.cf.imes.module.manage.dal.mysql.process.ProductionProcessMapper;
 import com.cf.imes.module.manage.dal.mysql.query.OrderItemMapper;
 import com.cf.imes.module.manage.dal.mysql.query.OrderPartsMapper;
 import com.cf.imes.module.manage.dal.mysql.query.ProductionStatusMapper;
-import com.cf.imes.module.manage.enums.OrderPackStatusEnums;
 import com.cf.imes.module.manage.service.process.ProductionProcessServiceImpl;
 import com.cf.imes.module.manage.util.SnowflakeIdWorker3rd;
 import com.cf.imes.module.system.api.setting.SettingApi;
 import com.cf.imes.module.system.api.setting.dto.PackageConfigDTO;
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.validation.annotation.Validated;

 import javax.annotation.Resource;
-import java.text.SimpleDateFormat;
-import java.time.LocalDateTime;
-import java.util.*;
-import java.util.stream.Collectors;
-
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.ObjectMapper;
 import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;

 import static com.cf.imes.framework.common.exception.util.ServiceExceptionUtil.exception;
 import static com.cf.imes.framework.common.util.string.SearchUtil.insertSeparator;
-import static com.cf.imes.framework.security.core.util.SecurityFrameworkUtils.getLoginUser;
 import static com.cf.imes.framework.security.core.util.SecurityFrameworkUtils.getUserOrganId;
 import static com.cf.imes.module.system.enums.ErrorCodeConstants.*;

@@ -125,7 +121,7 @@ public class PackServiceImpl implements PackService {
                    productionProcessMapper.selectOrderIdsFalse(order.getCreateTime().toString(), getUserOrganId(),order.getId());

            if(orderDO == null){
-                throw exception(NO_PRODUCTION_ORDER_INFORMATION_AVAILABLE, pageReqVO.getIsUp() ?"第" : "最后",pageReqVO.getIsUp()?"上" : "下" );
+                throw exception(NO_PRODUCTION_ORDER_INFORMATION_AVAILABLE, pageReqVO.getIsUp() ?"第" : "最后");
            }

            orderIds.add(orderDO.getId());
@@ -755,7 +751,6 @@ public class PackServiceImpl implements PackService {

        boolean autoPack = settingParse.get("autoPack").asBoolean();

-        System.out.println(autoPack);

        String optimizeInfo = reqVO.getOptimizeInfo();

@@ -786,7 +781,7 @@ public class PackServiceImpl implements PackService {
                            .status(OrderPackageStatusEnum.PACKAGED.getStatus())
                            .build());
                    prePackOptimizeInfo.getList().forEach(plate ->{
-                        List<String> list = plate.getList().stream().map(m -> m.getPlateNo()).toList();
+                        List<String> list = plate.getList().stream().map(PrePackOptimizeInfo.PrerPlateData::getPlateNo).toList();
                        list.forEach(a -> packPlateNoLists.add(PackPlateList.builder()
                                .packNo(packageNo)
                                .plateNo(a)
@@ -234,6 +234,7 @@ public interface ErrorCodeConstants {
    ErrorCode PLATE_IMPORT_LIST_IS_EMPTY = new ErrorCode(1_002_032_001, "导入板材数据不能为空！");
    ErrorCode PLATE_EXISTS = new ErrorCode(1_002_032_002, "板材存在");
    ErrorCode THE_CURRENT_BOARD_IS_NOT_SELECTED = new ErrorCode(1_002_032_003, "当前板材没有选择房间和柜体，请选择");
+    ErrorCode THE_BOARD_HAS_BEEN_CUT_INTO_PIECES = new ErrorCode(1_002_032_004, "当前排单已有板材开料，禁止修改");

    //=========== 板材信息 1-002-033-000 ============
    ErrorCode REMAIN_PLATE_NOT_EXISTS = new ErrorCode(1_002_032_002, "板材不存在");
@@ -272,7 +273,7 @@ public interface ErrorCodeConstants {
    ErrorCode THE_CURRENT_PACKAGE_TYPE_IS_INCORRECT = new ErrorCode(1_002_038_777, "当前包裹类型错误");
    ErrorCode FAILED_TO_MODIFY_THE_STATUS_OF_THE_CURRENT_PRODUCTION_ORDER = new ErrorCode(1_002_038_778, "修改当前生产单的工序状态和生产单的状态失败");
    ErrorCode NO_OPTIMIZATION_INFORMATION_AVAILABLE = new ErrorCode(1_002_038_779, "当前订单无优化信息");
-    ErrorCode NO_PRODUCTION_ORDER_INFORMATION_AVAILABLE = new ErrorCode(1_002_038_780, "已经是{}一条了，无{}一页信息");
+    ErrorCode NO_PRODUCTION_ORDER_INFORMATION_AVAILABLE = new ErrorCode(1_002_038_780, "已经是{}一条了");


    //=========== 应用信息 1-002-037-000 ============
@@ -280,6 +281,7 @@ public interface ErrorCodeConstants {
    ErrorCode APPLICATION_LOGIN_USER_DISABLED = new ErrorCode(1_002_037_001, "应用登陆失败");

    ErrorCode ERR = new ErrorCode(1_002_038_001, "未知错误");
+    ErrorCode DATA_ERR = new ErrorCode(1_002_038_002, "数据错误，需要清除数据重新导入");

    ErrorCode REMAIN_PLATE_STATUS_USED = new ErrorCode(1_002_038_001, "余料板正在使用中，禁止修改");
    ErrorCode REMAIN_PLATE_STATUS_NO_USED = new ErrorCode(1_002_038_002, "余料板未使用");
@@ -4,7 +4,6 @@ import com.cf.imes.framework.common.pojo.CommonResult;
 import com.cf.imes.framework.common.pojo.PageResult;
 import com.cf.imes.module.system.controller.admin.machine.vo.*;
 import com.cf.imes.module.system.dal.dataobject.machine.MachineDO;
-import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateDO;
 import com.cf.imes.module.system.service.machine.MachineService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
@@ -29,8 +28,8 @@ public class MachineAuthController {
    @Resource
    private MachineService machineService;

-    @PostMapping("organ-auth")
-    @Operation(summary = "组织机台授权")
+    @PutMapping("insert-organ-auth")
+    @Operation(summary = "组织机台授权新增")
    @PreAuthorize("@ss.hasPermission('machine-auth::update')")
    public CommonResult<Boolean> auth(@RequestBody MachineOrgAuthReq vo) {
        return success(machineService.auth(vo));
@@ -2,8 +2,10 @@ package com.cf.imes.module.system.controller.admin.machine;

 import com.cf.imes.framework.common.pojo.CommonResult;
 import com.cf.imes.framework.common.pojo.PageResult;
-import com.cf.imes.module.system.controller.admin.machine.vo.*;
-import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateDO;
+import com.cf.imes.module.system.controller.admin.machine.vo.MachineOrgAuthReq;
+import com.cf.imes.module.system.controller.admin.machine.vo.OrganTemplatePage;
+import com.cf.imes.module.system.controller.admin.machine.vo.OrganTemplateResp;
+import com.cf.imes.module.system.controller.admin.machine.vo.TemplateAutoResp;
 import com.cf.imes.module.system.service.machine.MachineTemplateService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
@@ -12,8 +14,6 @@ import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.*;

 import javax.annotation.Resource;
-import java.util.List;
-import java.util.stream.Collectors;

 import static com.cf.imes.framework.common.pojo.CommonResult.success;

@@ -28,13 +28,23 @@ public class MachineTemplateAuthController {
    @Resource
    private MachineTemplateService machineTemplateService;

-    @PostMapping("organ-auth-template")
-    @Operation(summary = "组织模板授权")
+    @PutMapping("insert-organ-auth-template")
+    @Operation(summary = "组织模板授权新增")
    @PreAuthorize("@ss.hasPermission('machine-template-auth::update')")
    public CommonResult<Boolean> auth(@RequestBody MachineOrgAuthReq vo) {
        return success(machineTemplateService.auth(vo));
    }

+
+    @PostMapping("update-organ-auth-template")
+    @Operation(summary = "组织模板授权修改")
+    @PreAuthorize("@ss.hasPermission('machine-template-auth::update')")
+    public CommonResult<Boolean> updateTemplateAuth(@RequestBody MachineOrgAuthReq vo) {
+        return success(machineTemplateService.updateTemplateAuth(vo));
+    }
+
+
+
    @GetMapping("organ-template-page")
    @Operation(summary = "组织模板授权分页列表")
    @PreAuthorize("@ss.hasPermission('machine-template-auth::query')")
@@ -50,18 +60,18 @@ public class MachineTemplateAuthController {
        return success(machineTemplateService.organTemplateByOrganId(organId));
    }

-    @GetMapping("page-template-machine-auth")
-    @Operation(summary = "授权机台模板分页")
+    @GetMapping("organ-template-machine-auth")
+    @Operation(summary = "查询机台模板授权信息")
+    @Parameter(name = "organId", description = "组织id", required = true, example = "1")
    @PreAuthorize("@ss.hasPermission('machine-template-auth::query')")
-    public CommonResult<PageResult<TemplateAutoResp>> pageTemplateAuth(MachinePageReqVO pageParam) {
-        PageResult<MachineTemplateDO> page = machineTemplateService.page(pageParam);
-        List<TemplateAutoResp> list = page.getList().stream().map(e->TemplateAutoResp.builder()
-                .id(e.getId())
-                .machineType(e.getMachineType())
-                .templateName(e.getName())
-                .build()
-        ).collect(Collectors.toList());
+    public CommonResult<TemplateAutoResp> getTemplateAuth(@RequestParam(required = false) Long organId ) {
+        return success(machineTemplateService.getTemplateAuth(organId));
+//        List<TemplateAutoResp> list = page.getList().stream().map(e->TemplateAutoResp.builder()
+//                .id(e.getId())
+//                .machineType(e.getMachineType())
+//                .templateName(e.getName())
+//                .build()
+//        ).collect(Collectors.toList());

-        return success(new PageResult<TemplateAutoResp>(list, page.getTotal()));
    }
 }
@@ -1,10 +1,9 @@
 package com.cf.imes.module.system.controller.admin.machine.vo;

 import com.alibaba.fastjson.JSONObject;
-import com.cf.imes.framework.es.core.valid.CreateGroup;
 import com.cf.imes.framework.es.core.valid.UpdateGroup;
 import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.*;
+import lombok.Data;

 import javax.validation.constraints.NotEmpty;
 import javax.validation.constraints.NotNull;
@@ -43,8 +42,13 @@ public class CuttingSaveReqVO {
 //    @Schema(description = "品牌", requiredMode = Schema.RequiredMode.REQUIRED)
 //    private String brand;

-    @Schema(description = "型号", requiredMode = Schema.RequiredMode.REQUIRED)
-    private String model;
+//    @Schema(description = "型号", requiredMode = Schema.RequiredMode.REQUIRED)
+//    private String model;
+
+
+    @Schema(description = "机台的型号-机台的ID")
+    private Long machineId;
+

    @Schema(description = "机台配置")
    private JSONObject machineSettingDO;
@@ -2,7 +2,6 @@ package com.cf.imes.module.system.controller.admin.machine.vo;

 import com.alibaba.fastjson.JSONObject;
 import com.cf.imes.framework.es.core.valid.UpdateGroup;
-import com.cf.imes.module.system.dal.dataobject.machinetemplate.CuttingTemplateMachineDO;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;

@@ -41,8 +40,12 @@ public class CuttingTemplateSaveReqVO {
 //    private String brand;


-    @Schema(description = "机台的型号", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
-    private String model;
+//    @Schema(description = "机台的型号", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
+//    private String model;
+
+
+    @Schema(description = "机台的型号-机台ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
+    private Long machineId;


    @Schema(description = "管理理后台 - 机台模板新增/修改 Request VO")
@@ -12,14 +12,17 @@ public class MachineBrandModelRespVO {


    @Schema(description = "机台的品牌ID")
-    private Long id;
+    private Long brandId;


    @Schema(description = "机台的品牌")
    private String brand;


+//    @Schema(description = "机台的型号-即机台的名称")
+//    private List<String> name;
+
    @Schema(description = "机台的型号-即机台的名称")
-    private List<String> name;
+    private List<MachineSimpleRespVO> machineSimpleRespVOS;

 }
@@ -5,21 +5,29 @@ import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;

 import javax.validation.constraints.NotNull;
+import java.util.List;

@Data
 public class MachineTemplateBrandReqVO {


+    @Schema(description = "组织ID")
+    private Long organId;
+
    @Schema(description = "1开料机台设备 2钻孔机台设备", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
    @NotNull(message = "1开料机台设备 2钻孔机台设备 不能为空")
    private Integer machineType;

    @Schema(description = "机台的品牌ID")
-    private Integer id;
+    private Long id;


    @Schema(description = "机台的品牌", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
    @NotNull(message = "品牌名称不能为空")
    private String brand;

+
+    @Schema(description = "机台模板的授权信息")
+    private List<OrganTemplateVO> organMachineVOS;
+
 }
@@ -9,8 +9,12 @@ import lombok.Data;
 */
@Data
 public class OrganTemplatePage extends PageParam {
-    @Schema(description = "组织id")
-    private Long organId;
+//    @Schema(description = "组织id")
+//    private Long organId;
+
+    @Schema(description = "组织名称")
+    private String organName;
+
    @Schema(description = "机台模板名称")
    private String templateName;

@@ -28,6 +28,9 @@ public class OrganTemplateResp {
    @Schema(description = "更新时间")
    @JsonFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND, timezone = TIME_ZONE_DEFAULT)
    private Date updateTime;
+
    @Schema(description = "机台模板列表")
-    private List<OrganTemplateVO> authTemplateList;
+    private List<MachineTemplateBrandReqVO> machineTemplateBrandReqVOS;
+//    @Schema(description = "机台模板列表")
+//    private List<OrganTemplateVO> authTemplateList;
 }
@@ -11,6 +11,8 @@ import lombok.Data;
 public class OrganTemplateVO {
    @Schema(description = "机台模板id")
    private Long templateId;
+    @Schema(description = "机台模板品牌id")
+    private Long brandId;
    @Schema(description = "机台模板名称")
    private String templateName;
    @Schema(description = "机台模板类型")
@@ -1,12 +1,15 @@
 package com.cf.imes.module.system.controller.admin.machine.vo;

-import com.baomidou.mybatisplus.annotation.TableId;
+import com.cf.imes.module.system.controller.admin.organ.vo.organ.OrganSimpleRespVO;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;

+import javax.validation.Valid;
+import java.util.List;
+
 /**
 * @author Beal
 */
@@ -15,26 +18,76 @@ import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
 public class TemplateAutoResp {
-    @Schema(description = "机台模板id")
-    private Long id;
-    /**
-     * 名称
-     */
-    @Schema(description = "机台模板名称")
-    private String templateName;
-    /**
-     * 1机台设备 2CNC设备
-     */
-    @Schema(description = "机台模板类别")
-    private Integer machineType;
-    /**
-     * 是否默认模板
-     */
-    private Boolean isDefault;
-    @Schema(description ="加工模式 开料机加工模式 默认true，显示开料机工作模式(是否排钻/造型，sc)配置")
-    private Boolean showPriorFacing = false;
-    @Schema(description = "双工位")
-    private Boolean showDualWorkstation = false;
-    @Schema(description = "自动贴标")
-    private Boolean showAutoNotePrinter = false;
+
+
+    @Schema(description = "组织信息")
+    private List<OrganSimpleRespVO> organSimpleRespVOS;
+
+
+    @Schema(description = "机台模板的品牌信息")
+    private List<MachineBrand> machineBrand;
+
+
+    @Valid
+    @Data
+    public static class MachineBrand {
+
+        @Schema(description = "品牌ID")
+        private Long id;
+
+        @Schema(description = "品牌名称")
+        private String brand;
+
+        @Schema(description = "机台类别")
+        private Integer machineType;
+
+        @Schema(description = "机台模板的权限信息")
+        private List<MachineTemplate> machineTemplates;
+
+    }
+
+
+    @Valid
+    @Data
+    public static class MachineTemplate {
+
+        @Schema(description = "机台模板ID")
+        private Long id;
+
+
+        @Schema(description = "机台模板品牌ID")
+        private Long brandId;
+
+
+        @Schema(description = "机台模板名称")
+        private String name;
+
+
+    }
+
+
+
+
+//    @Schema(description = "机台模板id")
+//    private Long id;
+//
+//
+//    @Schema(description = "机台模板名称")
+//    private String templateName;
+//
+//
+//    @Schema(description = "机台模板类别")
+//    private Integer machineType;
+//
+//
+////    private Boolean isDefault;
+//
+//    @Schema(description ="加工模式 开料机加工模式 默认true，显示开料机工作模式(是否排钻/造型，sc)配置")
+//    private Boolean showPriorFacing = false;
+//
+//    @Schema(description = "双工位")
+//    private Boolean showDualWorkstation = false;
+//
+//    @Schema(description = "自动贴标")
+//    private Boolean showAutoNotePrinter = false;
 }
@@ -28,7 +28,7 @@ public class MachineTemplateConvert {
                .id(reqVO.getId())
                .name(reqVO.getName())
 //                .brand(reqVO.getBrand())
-                .brandId(reqVO.getBrandId())
+                .brandId(reqVO.getNowBrandId())
                .setting(reqVO.getSetting().toJSONString())
                .build();
    }
@@ -1,6 +1,7 @@
 package com.cf.imes.module.system.dal.dataobject.machinetemplate;

 import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableLogic;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -41,4 +42,10 @@ public class MachineTemplateLimitDO {
     * 自动贴标
     */
    private Boolean showAutoNotePrinter;
+    /**
+     * 是否删除
+     */
+    @TableLogic
+    private Boolean deleted;
+
 }
@@ -3,9 +3,8 @@ package com.cf.imes.module.system.dal.mysql.machine;

 import com.cf.imes.framework.mybatis.core.mapper.BaseMapperX;
 import com.cf.imes.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.cf.imes.module.system.controller.admin.machine.vo.MachineBrandModelRespVO;
 import com.cf.imes.module.system.dal.dataobject.machine.MachineBrandDO;
-import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateDO;
-import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;

@@ -31,4 +30,6 @@ public interface MachineBrandMapper extends BaseMapperX<MachineBrandDO> {
    }


+    List<MachineBrandModelRespVO> selectMachineList(@Param("type")  Integer type);
+
 }
@@ -1,10 +1,33 @@
 package com.cf.imes.module.system.dal.mysql.machinetemplate;

+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.cf.imes.framework.mybatis.core.mapper.BaseMapperX;
+import com.cf.imes.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.cf.imes.module.system.controller.admin.machine.vo.MachineTemplateBrandReqVO;
+import com.cf.imes.module.system.controller.admin.machine.vo.OrganTemplatePage;
+import com.cf.imes.module.system.controller.admin.machine.vo.OrganTemplateResp;
 import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateLimitDO;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;

@Mapper
 public interface MachineTemplateLimitMapper extends BaseMapperX<MachineTemplateLimitDO> {

+
+    Page<OrganTemplateResp> selectMachinePage(@Param("respPage") Page<OrganTemplateResp> respPage, @Param("page") OrganTemplatePage page);
+
+
+    List<MachineTemplateBrandReqVO> selectMachineList(@Param("organIds") List<Long> organIds,@Param("templateName") String templateName);
+
+
+
+
+    default List<MachineTemplateLimitDO> selectListByOrganId(Long organId) {
+        return selectList(new LambdaQueryWrapperX<MachineTemplateLimitDO>()
+                .eqIfPresent(MachineTemplateLimitDO::getDeleted,false)
+                .eqIfPresent(MachineTemplateLimitDO::getOrganId,organId));
+    }
+
 }
@@ -49,16 +49,23 @@ public interface MachineTemplateMapper extends BaseMapperX<MachineTemplateDO> {



-    default List<MachineTemplateDO> selectByBrand(Integer id) {
+    default List<MachineTemplateDO> selectByBrand(Long id) {
        return selectList(new LambdaQueryWrapperX<MachineTemplateDO>()
                .eqIfPresent(MachineTemplateDO::getBrandId,id));
    }



-    default MachineTemplateDO selectMachine(Long brandId, String model) {
+    default MachineTemplateDO selectMachine(Long brandId, Long machineId) {
        return selectOne(new LambdaQueryWrapperX<MachineTemplateDO>()
                .eqIfPresent(MachineTemplateDO::getBrandId,brandId)
-                .eqIfPresent(MachineTemplateDO::getName,model));
+                .eqIfPresent(MachineTemplateDO::getId,machineId));
+    }
+
+
+
+    default List<MachineTemplateDO> selectMachineTemplate(String templateName) {
+        return selectList(new LambdaQueryWrapperX<MachineTemplateDO>()
+                .likeIfPresent(MachineTemplateDO::getName,templateName));
    }
 }
@@ -58,6 +58,7 @@ public interface OrganMapper extends BaseMapperX<OrganizationDO> {
        return selectList(OrganizationDO::getPackageId, packageId);
    }

+
    default Integer selectOrgCount() {
        return Math.toIntExact(selectCount(new LambdaQueryWrapperX<OrganizationDO>()
                .eq(OrganizationDO::getUpdateTime, OrderDeletedEnum.NOT_DELETED.getStatus())));
@@ -78,4 +79,18 @@ public interface OrganMapper extends BaseMapperX<OrganizationDO> {
    }

    Integer selectOrgSilentCount(@Param("dateTime")LocalDateTime dateTime);
+
+
+    default List<OrganizationDO> selectOrganList(Integer status) {
+        return selectList(new LambdaQueryWrapperX<OrganizationDO>()
+                .eqIfPresent(OrganizationDO::getDeleted,false)
+                .eqIfPresent(OrganizationDO::getStatus,status));
+    }
+
+
+    List<OrganizationDO> selectTestSQL(@Param("sql") String sql);
+
+
+
+
 }
@@ -3,15 +3,15 @@ package com.cf.imes.module.system.service.machine;
 import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.convert.Convert;
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
-import co.elastic.clients.elasticsearch._types.FieldValue;
 import co.elastic.clients.elasticsearch._types.query_dsl.TermQuery;
-import co.elastic.clients.elasticsearch._types.query_dsl.TermsQuery;
-import co.elastic.clients.elasticsearch.core.DeleteByQueryRequest;
 import co.elastic.clients.elasticsearch.core.SearchRequest;
 import co.elastic.clients.elasticsearch.core.SearchResponse;
 import co.elastic.clients.elasticsearch.core.search.Hit;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.cf.imes.framework.common.enums.MachineTypeEnum;
+import com.cf.imes.framework.common.pojo.PageResult;
 import com.cf.imes.framework.common.util.json.JsonUtils;
+import com.cf.imes.framework.common.util.object.BeanUtils;
 import com.cf.imes.framework.es.core.dal.ESDocument;
 import com.cf.imes.framework.es.core.service.ESDocumentService;
 import com.cf.imes.framework.mybatis.core.query.LambdaQueryWrapperX;
@@ -23,29 +23,26 @@ import com.cf.imes.module.system.controller.admin.machine.vo.*;
 import com.cf.imes.module.system.convert.machine.MachineConvert;
 import com.cf.imes.module.system.dal.dataobject.machine.*;
 import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateDO;
-import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateLimitDO;
 import com.cf.imes.module.system.dal.mysql.machine.MachineBrandMapper;
-import com.cf.imes.module.system.dal.mysql.machine.MachineMapper;
 import com.cf.imes.module.system.dal.mysql.machine.MachineLimitMapper;
+import com.cf.imes.module.system.dal.mysql.machine.MachineMapper;
 import com.cf.imes.module.system.dal.mysql.machinetemplate.MachineTemplateLimitMapper;
 import com.cf.imes.module.system.dal.mysql.machinetemplate.MachineTemplateMapper;
+import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
-import org.springframework.validation.annotation.Validated;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;

+import javax.annotation.Resource;
 import java.io.IOException;
 import java.time.LocalDateTime;
 import java.util.*;
 import java.util.stream.Collectors;

-import com.cf.imes.framework.common.pojo.PageResult;
-import com.cf.imes.framework.common.util.object.BeanUtils;
-
-import javax.annotation.Resource;
-
 import static com.cf.imes.framework.common.exception.enums.GlobalErrorCodeConstants.INTERNAL_SERVER_ERROR;
 import static com.cf.imes.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static com.cf.imes.framework.common.util.json.JsonUtils.unzipString;
 import static com.cf.imes.framework.security.core.util.SecurityFrameworkUtils.getUserOrganId;
 import static com.cf.imes.module.system.enums.ErrorCodeConstants.*;

@@ -111,26 +108,91 @@ public class MachineServiceImpl implements MachineService {

        }

-        MachineTemplateDO machineTemplateDO = machineTemplateMapper.selectMachine(createReqVO.getBrandId(), createReqVO.getModel());
+        MachineTemplateDO machineTemplateDO = machineTemplateMapper.selectMachine(createReqVO.getBrandId(), createReqVO.getMachineId());

        if(machineTemplateDO == null){
            throw exception(THE_MODEL_OF_THE_MACHINE_DOES_NOT_EXIST);
        }
-//        MachineTemplateLimitDO organMachineTemplateDO = machineTemplateLimitMapper.selectOne(new LambdaQueryWrapperX<MachineTemplateLimitDO>()
-////                .eq(MachineTemplateLimitDO::getMachineId, createReqVO.getTemplateId())
-//                .eq(MachineTemplateLimitDO::getOrganId, loginUser.getOrganId())
-//        );

        // 插入
        MachineDO machineDO = MachineConvert.convert(createReqVO);
-//        if(createReqVO.getMachineSettingDO().isEmpty()) {
-//            machineDO.setSetting(machineTemplateDO.getSetting());
-//        }

        machineDO.setSetting(machineTemplateDO.getSetting());

        machineMapper.insert(machineDO);

+
+
+        if(machineTemplateDO.getMachineType().equals(MachineTypeEnum.CUTTING.getType())) {
+
+            // 将配置进行解压，判断该类型的机台的贴标配置是否开启
+            JsonNode cuttingSetting = JsonUtils.parseTree(unzipString(machineTemplateDO.getSetting()));
+
+            JsonNode advancedConfigsRef = cuttingSetting.get("advancedConfigsRef");
+
+            boolean isAutoLabelEnabled = advancedConfigsRef.get("isAutoLabelEnabled").asBoolean();
+
+
+            if(isAutoLabelEnabled && advancedConfigsRef.get("autoLabelBrand") != null && advancedConfigsRef.get("autoLabelModel") != null){
+
+//                    Integer autoLabelBrand = advancedConfigsRef.get("autoLabelBrand").asInt();
+
+                Integer autoLabelModel = advancedConfigsRef.get("autoLabelModel").asInt();
+
+                //  根据型号ID查询贴标的配置信息
+                MachineTemplateDO labelingMachineTemplateDO = machineTemplateMapper.selectById(autoLabelModel);
+
+                MachineDO labelingMachineDO = MachineDO.builder()
+                        .labelId(machineDO.getLabelId())
+                        .machineType(labelingMachineTemplateDO.getMachineType())
+                        .brandId(labelingMachineTemplateDO.getBrandId())
+                        .setting(labelingMachineTemplateDO.getSetting())
+                        .name("开料"+machineDO.getName()+ "-贴标机")
+                        .build();
+
+                machineMapper.insert(labelingMachineDO);
+
+            }
+
+        }
+
+
+        if(machineTemplateDO.getMachineType().equals(MachineTypeEnum.BANDING.getType())) {
+
+            // 将配置进行解压，判断该类型的机台的钻孔配置是否开启
+            JsonNode drillSetting = JsonUtils.parseTree(unzipString(machineTemplateDO.getSetting()));
+
+            JsonNode cuttingModuleRef = drillSetting.get("cuttingModuleRef");
+
+            boolean isDrillEnabled = cuttingModuleRef.get("isDrillEnabled").asBoolean();
+
+
+            if(isDrillEnabled && cuttingModuleRef.get("drillBrand") != null && cuttingModuleRef.get("drillModel") != null){
+
+//                    Integer drillBrand = cuttingModuleRef.get("drillBrand").asInt();
+
+                Integer autoLabelModel = cuttingModuleRef.get("drillModel").asInt();
+
+                //  根据型号ID查询钻孔机的配置信息
+                MachineTemplateDO drillMachineTemplateDO = machineTemplateMapper.selectById(autoLabelModel);
+
+                MachineDO drillMachineDO = MachineDO.builder()
+                        .labelId(machineDO.getLabelId())
+                        .machineType(drillMachineTemplateDO.getMachineType())
+                        .brandId(drillMachineTemplateDO.getBrandId())
+                        .setting(drillMachineTemplateDO.getSetting())
+                        .name("开料"+machineDO.getName()+"钻孔机")
+                        .build();
+
+                machineMapper.insert(drillMachineDO);
+
+            }
+
+        }
+
+
+
+
 //        MachineLimitDO machineLimitDO = MachineLimitDO.builder()
 //                .organId(loginUser.getOrganId())
 //                .machineId(machineDO.getId())
@@ -309,18 +371,20 @@ public class MachineServiceImpl implements MachineService {
    @Override
    public List<MachineBrandModelRespVO> getBrandAndModel(Integer type) {

-        List<MachineBrandDO> machineBrandDOS = machineBrandMapper.selectListByType(type);
+//        List<MachineBrandDO> machineBrandDOS = machineBrandMapper.selectListByType(type);

+        return machineBrandMapper.selectMachineList(type);

-        List<MachineBrandModelRespVO> machineBrandModelRespVOS = BeanUtils.toBean(machineBrandDOS, MachineBrandModelRespVO.class);
-
-
-        List<MachineTemplateDO> machineDOS = machineTemplateMapper.selectList(new LambdaQueryWrapperX<MachineTemplateDO>()
-                .eqIfPresent(MachineTemplateDO::getMachineType, type));
-
-        machineBrandModelRespVOS.forEach(v->
-                v.setName(machineDOS.stream().filter(f->f.getBrandId().equals(v.getId())).map(MachineTemplateDO::getName).toList())
-                );
+//        List<MachineBrandModelRespVO> machineBrandModelRespVOS = BeanUtils.toBean(machineBrandDOS, MachineBrandModelRespVO.class);
+//
+//
+//        List<MachineTemplateDO> machineDOS = machineTemplateMapper.selectList(new LambdaQueryWrapperX<MachineTemplateDO>()
+//                .eq(MachineTemplateDO::getDeleted,false)
+//                .eqIfPresent(MachineTemplateDO::getMachineType, type));
+//
+//        machineBrandModelRespVOS.forEach(v->
+//                v.setName(machineDOS.stream().filter(f->f.getBrandId().equals(v.getId())).map(MachineTemplateDO::getName).toList())
+//                );


 //        List<MachineBrandModelRespVO> machineVOS = BeanUtils.toBean(machineDOS, MachineBrandModelRespVO.class);
@@ -329,7 +393,7 @@ public class MachineServiceImpl implements MachineService {
 //        Map<String, List<MachineBrandModelRespVO>> map = machineVOS.stream().collect(Collectors.groupingBy(MachineBrandModelRespVO::getBrand));


-        return machineBrandModelRespVOS;
+//        return machineBrandModelRespVOS;
    }


@@ -1,6 +1,5 @@
 package com.cf.imes.module.system.service.machine;

-import com.cf.imes.framework.common.pojo.PageParam;
 import com.cf.imes.framework.common.pojo.PageResult;
 import com.cf.imes.module.system.controller.admin.machine.vo.*;
 import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateDO;
@@ -19,15 +18,6 @@ public interface MachineTemplateService {

    PageResult<MachineTemplateDO> page(MachinePageReqVO pageParam);

-    Long createDrillTemplate(DrillTemplateSaveReqVO reqVO);
-
-    Boolean updateDrillTemplate(DrillTemplateSaveReqVO reqVO);
-
-    DrillTemplateRespVO getDirllTemplateById(Long id);
-
-    Boolean deleteDrillTemplate(Long id);
-
-    Boolean batchDeleteDrillTemplate(List<Long> ids);

    Long createCuttingTemplate(CuttingTemplateSaveReqVO reqVO);

@@ -42,7 +32,6 @@ public interface MachineTemplateService {

    Map<Integer, List<MachineTemplateRespVO>> getMachineTemplateTree();

-    PageResult<AuthTemplateResp> authTemplatePage(AuthTemplatePage page);

    Boolean auth(MachineOrgAuthReq vo);

@@ -55,6 +44,8 @@ public interface MachineTemplateService {

    void updateMachineTemplateBrand(MachineTemplateBrandReqVO reqVO);

+    TemplateAutoResp getTemplateAuth(Long organId);
+
+    Boolean updateTemplateAuth(MachineOrgAuthReq vo);

-//    Boolean setDefaultTemplate(Long id);
 }
@@ -1,47 +1,43 @@
 package com.cf.imes.module.system.service.machine;

-import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollectionUtil;
-import cn.hutool.core.convert.Convert;
 import co.elastic.clients.elasticsearch.ElasticsearchClient;
-import co.elastic.clients.elasticsearch._types.FieldValue;
-import co.elastic.clients.elasticsearch._types.query_dsl.*;
-import co.elastic.clients.elasticsearch.core.DeleteByQueryRequest;
-import co.elastic.clients.elasticsearch.core.SearchRequest;
-import co.elastic.clients.elasticsearch.core.SearchResponse;
-import co.elastic.clients.elasticsearch.core.search.Hit;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.cf.imes.framework.common.exception.ServiceException;
+import com.cf.imes.framework.common.enums.CommonStatusEnum;
+import com.cf.imes.framework.common.enums.MachineTypeEnum;
 import com.cf.imes.framework.common.pojo.PageResult;
 import com.cf.imes.framework.common.util.json.JsonUtils;
 import com.cf.imes.framework.common.util.object.BeanUtils;
-import com.cf.imes.framework.es.core.dal.ESDocument;
-import com.cf.imes.framework.es.core.service.ESDocumentService;
 import com.cf.imes.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.cf.imes.framework.mybatis.core.query.MPJLambdaWrapperX;
 import com.cf.imes.module.system.controller.admin.machine.vo.*;
+import com.cf.imes.module.system.controller.admin.organ.vo.organ.OrganSimpleRespVO;
 import com.cf.imes.module.system.convert.machine.MachineTemplateConvert;
-import com.cf.imes.module.system.dal.dataobject.machine.CuttingSettingDO;
 import com.cf.imes.module.system.dal.dataobject.machine.MachineBrandDO;
 import com.cf.imes.module.system.dal.dataobject.machine.UserMachineDO;
-import com.cf.imes.module.system.dal.dataobject.machinetemplate.DrillTemplateMachineDO;
 import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateDO;
 import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateLimitDO;
+import com.cf.imes.module.system.dal.dataobject.organ.OrganizationDO;
 import com.cf.imes.module.system.dal.mysql.machine.MachineBrandMapper;
 import com.cf.imes.module.system.dal.mysql.machine.UserMachineMapper;
-import com.cf.imes.module.system.dal.mysql.machinetemplate.MachineTemplateMapper;
 import com.cf.imes.module.system.dal.mysql.machinetemplate.MachineTemplateLimitMapper;
+import com.cf.imes.module.system.dal.mysql.machinetemplate.MachineTemplateMapper;
+import com.cf.imes.module.system.dal.mysql.organ.OrganMapper;
+import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

 import javax.annotation.Resource;
-import java.io.IOException;
 import java.time.LocalDateTime;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import java.util.stream.Collectors;

-import static com.cf.imes.framework.common.exception.enums.GlobalErrorCodeConstants.INTERNAL_SERVER_ERROR;
 import static com.cf.imes.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static com.cf.imes.framework.common.util.json.JsonUtils.unzipString;
 import static com.cf.imes.module.system.enums.ErrorCodeConstants.*;

 /**
@@ -56,8 +52,6 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
    //钻孔机台模板配置索引
    private static final String DRILL_MACHINE_INX = "drill_machine_template";

-    @Resource
-    private ESDocumentService esDocumentService;

    @Resource
    private UserMachineMapper userMachineMapper;
@@ -75,90 +69,10 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
    @Resource
    private MachineBrandMapper machineBrandMapper;

-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public Long createDrillTemplate(DrillTemplateSaveReqVO reqVO) {
-        MachineTemplateDO templateDO = Convert.convert(MachineTemplateDO.class, reqVO);
-        machineTemplateMapper.insert(templateDO);
-        DrillTemplateMachineDO setting = reqVO.getSetting();
-        setting.setTemplateId(templateDO.getId());
-        try {
-            esDocumentService.createByFluentDSL(DRILL_MACHINE_INX, setting.getId(), setting);
-        } catch (Exception e) {
-            log.error(e.getMessage());
-            throw new ServiceException(INTERNAL_SERVER_ERROR);
-        }
-        return templateDO.getId();
-    }
+    @Resource
+    private OrganMapper organMapper;

-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public Boolean updateDrillTemplate(DrillTemplateSaveReqVO reqVO) {
-        MachineTemplateDO templateDO = Convert.convert(MachineTemplateDO.class, reqVO);
-        machineTemplateMapper.updateById(templateDO);
-        DrillTemplateMachineDO machineDO = reqVO.getSetting();
-        Map<String, Object> map = BeanUtil.beanToMap(machineDO);
-        try {
-            esDocumentService.updateById(DRILL_MACHINE_INX, machineDO.getId(), DrillTemplateMachineDO.class, map);
-        } catch (IOException e) {
-            log.error(e.getMessage());
-            throw new ServiceException(INTERNAL_SERVER_ERROR);
-        }
-        return Boolean.TRUE;
-    }

-    @Override
-    public DrillTemplateRespVO getDirllTemplateById(Long id) {
-        MachineTemplateDO templateDO = machineTemplateMapper.selectById(id);
-        if (Objects.isNull(templateDO)) {
-            throw exception(MACHINE_TEMPLATE_NOT_EXISTS);
-        }
-        DrillTemplateRespVO respVO = Convert.convert(DrillTemplateRespVO.class, templateDO);
-        Object o = buildResp(templateDO.getId(), DRILL_MACHINE_INX, DrillTemplateMachineDO.class);
-        respVO.setDrillTemplateMachineDO((DrillTemplateMachineDO) o);
-        return respVO;
-    }
-
-    @Override
-    public Boolean deleteDrillTemplate(Long id) {
-        MachineTemplateDO templateDO = machineTemplateMapper.selectById(id);
-        if (Objects.isNull(templateDO)) {
-            throw exception(MACHINE_TEMPLATE_NOT_EXISTS);
-        }
-        // 删除
-        DeleteByQueryRequest.Builder builder = new DeleteByQueryRequest.Builder()
-                .index(DRILL_MACHINE_INX)
-                .query(b -> b.term(t -> t.field("templateId").value(templateDO.getId())));
-        try {
-            elasticsearchClient.deleteByQuery(builder.build());
-        } catch (IOException e) {
-            log.error(e.getMessage());
-            throw new ServiceException(INTERNAL_SERVER_ERROR);
-        }
-        machineTemplateMapper.deleteById(id);
-        return Boolean.TRUE;
-    }
-
-    @Override
-    public Boolean batchDeleteDrillTemplate(List<Long> ids) {
-        List<MachineTemplateDO> machineTemplateDOS = machineTemplateMapper.selectBatchIds(ids);
-        if (CollectionUtil.isEmpty(machineTemplateDOS)) {
-            throw exception(MACHINE_TEMPLATE_NOT_EXISTS);
-        }
-
-        List<FieldValue> fieldValues = machineTemplateDOS.stream().map(e -> FieldValue.of(e.getId())).collect(Collectors.toList());
-        DeleteByQueryRequest.Builder builder = new DeleteByQueryRequest.Builder()
-                .index(DRILL_MACHINE_INX)
-                .query(TermsQuery.of(e -> e.field("templateId").terms(b -> b.value(fieldValues)))._toQuery());
-        try {
-            elasticsearchClient.deleteByQuery(builder.build());
-        } catch (IOException e) {
-            log.error(e.getMessage());
-            throw new ServiceException(INTERNAL_SERVER_ERROR);
-        }
-        machineTemplateMapper.deleteBatchIds(ids);
-        return Boolean.TRUE;
-    }

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -172,18 +86,17 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {

        MachineTemplateDO templateDO = MachineTemplateConvert.convert(reqVO);

-//        MachineBrandDO machineBrandDO = machineBrandMapper.selectBrand(reqVO.getBrand(),reqVO.getMachineType());

+        if(reqVO.getMachineId()!=null) {

-//        List<MachineTemplateDO> machineTemplateDOS = machineTemplateMapper.selectByBrand(machineBrandDO.getId());
-
-        if(reqVO.getModel()!=null) {
-
-            MachineTemplateDO machineTemplateDO = machineTemplateMapper.selectMachine(reqVO.getNowBrandId(), reqVO.getModel());
+            MachineTemplateDO machineTemplateDO = machineTemplateMapper.selectMachine(reqVO.getBrandId(), reqVO.getMachineId());

            templateDO.setSetting(machineTemplateDO.getSetting());

            machineTemplateMapper.insert(templateDO);
+
+            handleMachineType(machineTemplateDO, templateDO);
+
            return templateDO.getId();
        }

@@ -191,11 +104,13 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {

        machineTemplateMapper.insert(templateDO);

+
        return templateDO.getId();


    }

+
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateCuttingTemplate(CuttingTemplateSaveReqVO reqVO) {
@@ -222,9 +137,9 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
        if (Objects.isNull(templateDO)) {
            throw exception(MACHINE_TEMPLATE_NOT_EXISTS);
        }
-        templateDO.setSetting(JsonUtils.unzipString(templateDO.getSetting()));
-        CuttingTemplateRespVO respVO  = MachineTemplateConvert.convert1(templateDO);
-        return respVO;
+        templateDO.setSetting(unzipString(templateDO.getSetting()));
+        return MachineTemplateConvert.convert1(templateDO);
+
    }

    @Override
@@ -242,6 +157,7 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
            List<Long> ids = machineTemplateDOS.stream().map(MachineTemplateDO::getId).toList();

            machineTemplateMapper.deleteBatchIds(ids);
+
        }


@@ -267,7 +183,7 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
                .stream()
                // todo 目前需要写上，等数据清一波后，应该不需要了
                .filter(m -> !Objects.equals(m.getBrandId(),null))
-                .map(m -> m.setSetting(JsonUtils.unzipString(m.getSetting()))).toList();
+                .map(m -> m.setSetting(unzipString(m.getSetting()))).toList();

        for (MachineTemplateRespVO machineTemplateRespVO : machineTemplateRespVOS) {
            machineTemplateRespVO.setMachineTemplateDOS(machineTemplateDOS.stream()
@@ -275,23 +191,66 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
                    .toList());
        }

-        Map<Integer, List<MachineTemplateRespVO>> map = machineTemplateRespVOS.stream().collect(Collectors.groupingBy(MachineTemplateRespVO::getMachineType));
+        return machineTemplateRespVOS.stream().collect(Collectors.groupingBy(MachineTemplateRespVO::getMachineType));
+

-        return map;
    }

-    @Override
-    public PageResult<AuthTemplateResp> authTemplatePage(AuthTemplatePage page) {
-        Page<AuthTemplateResp> respPage = new Page<>(page.getPageNo(), page.getPageSize());
-        Page<AuthTemplateResp> pageRes = machineTemplateMapper.selectAuthTemplatePage(respPage, page);
-        return new PageResult<>(pageRes.getRecords(), pageRes.getTotal());
-    }

    @Override
    public PageResult<OrganTemplateResp> organTemplatePage(OrganTemplatePage page) {
        Page<OrganTemplateResp> respPage = new Page<>(page.getPageNo(), page.getPageSize());
-        Page<OrganTemplateResp> pageRes = machineTemplateMapper.selectOrganTemplatePage(respPage, page);
-        return new PageResult<>(pageRes.getRecords(), pageRes.getTotal());
+
+//        List<MachineTemplateDO> machineTemplateDOS = machineTemplateMapper.selectMachineTemplate(page.getTemplateName());
+//
+//        List<Long> machineTemplateIds = machineTemplateDOS.stream().map(m -> m.getId()).toList();
+//
+//        MPJLambdaWrapperX<OrganizationDO> lambdaWrapperX = new MPJLambdaWrapperX<>();
+//        lambdaWrapperX.leftJoin(MachineTemplateLimitDO.class, MachineTemplateLimitDO::getMachineId, OrganizationDO::getId)
+//                .eqIfExists(OrganizationDO::getName,page.getOrganId())
+//                .in(MachineTemplateLimitDO::getMachineId, machineTemplateIds)
+//                .distinct();
+//
+//        PageResult<OrganizationDO> pageResult = organMapper.selectJoinPage(page, OrganizationDO.class, lambdaWrapperX);
+//
+//
+//        List<Long> organIds = pageResult.getList().stream().map(OrganizationDO::getId).toList();
+
+        Page<OrganTemplateResp> organTemplateRespPage = machineTemplateLimitMapper.selectMachinePage(respPage, page);
+
+        // 分页查询出的组织信息
+        List<OrganTemplateResp> organTemplateRespPageRecords = organTemplateRespPage.getRecords();
+
+        List<Long> organIds = organTemplateRespPageRecords.stream().map(OrganTemplateResp::getOrganId).toList();
+
+
+        if(organIds.isEmpty()){
+            return null;
+        }
+
+        List<MachineTemplateBrandReqVO> machineTemplateBrandReqVOS = machineTemplateLimitMapper.selectMachineList(organIds,page.getTemplateName());
+
+
+        // 查询品牌名称
+        List<Long> brandIds = machineTemplateBrandReqVOS.stream().map(MachineTemplateBrandReqVO::getId).toList();
+
+        List<MachineBrandDO> machineBrandDOS = machineBrandMapper.selectBatchIds(brandIds);
+
+        for (MachineTemplateBrandReqVO machineTemplateBrandReqVO : machineTemplateBrandReqVOS) {
+            machineTemplateBrandReqVO.setBrand(machineBrandDOS.stream()
+                    .filter(f->f.getId().equals(machineTemplateBrandReqVO.getId()))
+                    .map(MachineBrandDO::getBrand)
+                    .findAny().orElse(null));
+        }
+
+        for (OrganTemplateResp organTemplateRespPageRecord : organTemplateRespPageRecords) {
+            organTemplateRespPageRecord.setMachineTemplateBrandReqVOS(machineTemplateBrandReqVOS.stream()
+                    .filter(f->f.getOrganId().equals(organTemplateRespPageRecord.getOrganId()))
+                    .toList());
+        }
+
+        return new PageResult<>(organTemplateRespPage.getRecords(), organTemplateRespPage.getTotal());
+
    }

    @Override
@@ -333,29 +292,111 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {

    }

-//    @Override
-//    @Transactional
-//    public Boolean setDefaultTemplate(Long id) {
-//        MachineTemplateDO templateDO = machineTemplateMapper.selectById(id);
-//        if (Objects.isNull(templateDO)) {
-//            throw exception(MACHINE_TEMPLATE_NOT_EXISTS);
-//        }
-//        List<MachineTemplateDO> machineTemplateDOS = machineTemplateMapper.selectList(MachineTemplateDO::getMachineType, templateDO.getMachineType(), MachineTemplateDO::getIsDefault, Boolean.TRUE);
-//        if(CollectionUtil.isEmpty(machineTemplateDOS) || machineTemplateDOS.size()>1) {
-//            throw exception(DEFAULT_TEMPLATE_COUNT);
-//        }
-//
-//        if(!machineTemplateDOS.isEmpty()){
-//            MachineTemplateDO machineTemplateDO = new MachineTemplateDO();
-//            machineTemplateDO.setId(machineTemplateDOS.get(0).getId());
-//            machineTemplateDO.setIsDefault(Boolean.FALSE);
-//            machineTemplateMapper.updateById(machineTemplateDO);
-//        }
-//
-//        templateDO.setIsDefault(Boolean.TRUE);
-//        machineTemplateMapper.updateById(templateDO);
-//        return Boolean.TRUE;
-//    }
+    @Override
+    public TemplateAutoResp getTemplateAuth(Long organId) {
+
+        // todo 逻辑增强已完成，已完成如果按照组织查询，只查询当前组织下没有进行授权的机台，数据正确性待确认
+
+        TemplateAutoResp templateAutoResp = new TemplateAutoResp();
+
+
+        List<Long> machineIds;
+
+        if(organId != null){
+
+            List<MachineTemplateLimitDO> machineTemplateLimitDOS = machineTemplateLimitMapper.selectListByOrganId(organId);
+
+            machineIds = machineTemplateLimitDOS.stream().map(MachineTemplateLimitDO::getMachineId).distinct().toList();
+
+        } else {
+            machineIds = new ArrayList<>();
+        }
+
+        List<OrganizationDO> organizationDOS = organMapper.selectOrganList(CommonStatusEnum.ENABLE.getStatus());
+
+
+        templateAutoResp.setOrganSimpleRespVOS(BeanUtils.toBean(organizationDOS, OrganSimpleRespVO.class));
+
+
+        List<MachineBrandDO> machineBrandDOS = machineBrandMapper.selectListByType(MachineTypeEnum.CUTTING.getType());
+
+
+        templateAutoResp.setMachineBrand(BeanUtils.toBean(machineBrandDOS, TemplateAutoResp.MachineBrand.class));
+
+
+        List<Long> brandIds = machineBrandDOS.stream().map(MachineBrandDO::getId).toList();
+
+
+        List<MachineTemplateDO> machineTemplateDoS = machineTemplateMapper
+                .selectList( new MPJLambdaWrapperX<MachineTemplateDO>()
+                .in(MachineTemplateDO::getBrandId, brandIds)
+                .select(MachineTemplateDO::getId, MachineTemplateDO::getBrandId, MachineTemplateDO::getName));
+
+
+        List<TemplateAutoResp.MachineTemplate> machineTemplates = BeanUtils.toBean(machineTemplateDoS, TemplateAutoResp.MachineTemplate.class);
+
+
+        if(!machineIds.isEmpty()) {
+
+            for (TemplateAutoResp.MachineBrand machineBrand : templateAutoResp.getMachineBrand()) {
+
+                machineBrand.setMachineTemplates(machineTemplates.stream().filter(f -> f.getBrandId().equals(machineBrand.getId())).toList());
+
+
+                List<TemplateAutoResp.MachineTemplate> machineTemplate = new ArrayList<>(machineBrand.getMachineTemplates().stream()
+
+                        .filter(f -> !machineIds.contains(f.getId()))
+
+                        .toList());
+
+
+                machineBrand.setMachineTemplates(machineTemplate.stream().distinct().toList());
+
+            }
+
+            return templateAutoResp;
+
+        }
+
+
+        for (TemplateAutoResp.MachineBrand machineBrand : templateAutoResp.getMachineBrand()) {
+
+            machineBrand.setMachineTemplates(machineTemplates.stream().filter(f -> f.getBrandId().equals(machineBrand.getId())).toList());
+
+        }
+
+
+        return templateAutoResp;
+
+
+    }
+
+
+
+    @Override
+    public Boolean updateTemplateAuth(MachineOrgAuthReq vo) {
+
+        List<MachineAuth> machineAuthList = vo.getMachineAuthList();
+
+        if(!machineAuthList.isEmpty()) {
+            List<MachineTemplateLimitDO> machineTemplateLimitDOS = new ArrayList<>();
+
+            for (MachineAuth machineAuth : machineAuthList) {
+
+                machineTemplateLimitDOS.add(MachineTemplateLimitDO.builder()
+                        .id(machineAuth.getMachineId())
+                        .showAutoNotePrinter(machineAuth.getShowAutoNotePrinter())
+                        .showDualWorkstation(machineAuth.getShowDualWorkstation())
+                        .showPriorFacing(machineAuth.getShowPriorFacing())
+                        .build());
+            }
+
+            machineTemplateLimitMapper.updateBatch(machineTemplateLimitDOS);
+        }
+
+        return true;
+
+    }


    @Override
@@ -364,32 +405,11 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
        if (Objects.isNull(templateDO)) {
            throw exception(MACHINE_TEMPLATE_NOT_EXISTS);
        }
-//        if(templateDO.getIsDefault()) {
-//            throw exception(DEFAULT_TEMPLATE_NOT_DELETED);
-//        }
+
        machineTemplateMapper.deleteById(id);
        return Boolean.TRUE;
    }

-    private Object buildResp(Long machineTemplateId, String index, Class<? extends ESDocument> clazz) {
-        SearchRequest.Builder builder = new SearchRequest.Builder();
-        builder.index(index);
-        builder.query(q -> q.term(TermQuery.of(e -> e.field("templateId").value(machineTemplateId))));
-        SearchResponse<CuttingSettingDO> searchSetting = null;
-        try {
-            SearchResponse<?> search = elasticsearchClient.search(builder.build(), clazz);
-            List<? extends Hit<?>> hits = search.hits().hits();
-            if (CollectionUtil.isNotEmpty(hits)) {
-                Hit<?> hit = hits.get(0);
-                return hit.source();
-            }
-            return null;
-        } catch (IOException e) {
-            log.error(e.getMessage());
-            throw new ServiceException(INTERNAL_SERVER_ERROR);
-        }
-    }
-

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -411,7 +431,9 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean auth(MachineOrgAuthReq vo) {
-        machineTemplateLimitMapper.delete(new LambdaQueryWrapperX<MachineTemplateLimitDO>().eq(MachineTemplateLimitDO::getOrganId, vo.getOrganId()));
+
+        // 去掉授权删除
+//        machineTemplateLimitMapper.delete(new LambdaQueryWrapperX<MachineTemplateLimitDO>().eq(MachineTemplateLimitDO::getOrganId, vo.getOrganId()));

        List<MachineAuth> machineAuthList = vo.getMachineAuthList();

@@ -438,56 +460,78 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
    }


- /*   @Override
-    public PageResult<CuttingMachineDO> pageCutting(PageParam pageParam) {
-        LoginUser loginUser = SecurityFrameworkUtils.getLoginUser();
-        List<String> machineIds = userMachineMapper.selectList(new LambdaQueryWrapperX<UserMachineDO>().eq(UserMachineDO::getUserId, 1L*//*loginUser.getId()*//*))
-                .stream()
-                .map(e -> e.getMachineId())
-                .collect(Collectors.toList());
-        List<CuttingMachineDO> cuttingMachineDOS = new ArrayList<>();
-        List<Query> queryList = new ArrayList<>();
-        List<FieldValue> fieldValues = new ArrayList<>();
-        for (String machineId : machineIds) {
-            fieldValues.add(FieldValue.of(machineId));
-        }
-        queryList.add(TermsQuery.of(e-> e.field("_id").terms(b->b.value(fieldValues)))._toQuery());
-        queryList.add(TermQuery.of(e->e.field("organId").value( loginUser.getOrganId()))._toQuery());
-        SearchResponse<CuttingMachineDO> response = null;
-        try {
-            response = elasticsearchClient.search(s-> s.index(CUTTING_MACHINE_INX)
-                            .from((pageParam.getPageNo() - 1) * pageParam.getPageSize())
-                            .size(pageParam.getPageSize())
-                            .query(b -> b.bool( builder -> builder.must(queryList))),
-                    CuttingMachineDO.class);
-        } catch (IOException e) {
-            log.error(e.getMessage());
-            throw new ServiceException(500, "服务器异常");
-        }
-        long value = response.hits().total().value();
-        for (Hit<CuttingMachineDO> hit : response.hits().hits()) {
-            cuttingMachineDOS.add(hit.source());
-        }
-        return new PageResult<CuttingMachineDO>(cuttingMachineDOS, value);
-    }*/
-
    @Override
    public PageResult<MachineTemplateDO> page(MachinePageReqVO pageParam) {
-       /* LoginUser loginUser = SecurityFrameworkUtils.getLoginUser();
-        List<Long> machineIds = userMachineMapper.selectList(new LambdaQueryWrapperX<UserMachineDO>().eq(UserMachineDO::getUserId, loginUser.getId()))
-                .stream()
-                .map(e -> e.getMachineId())
-                .collect(Collectors.toList());
-        if(CollectionUtil.isEmpty(machineIds)) {
-            return new PageResult<>();
-        }*/

        PageResult<MachineTemplateDO> machineTemplateDOPageResult = machineTemplateMapper.selectPage(pageParam, new ArrayList<>());
        // 将机台模板的配置进行解压
-        machineTemplateDOPageResult.setList(machineTemplateDOPageResult.getList().stream().map(m -> m.setSetting(JsonUtils.unzipString(m.getSetting()))).collect(Collectors.toList()));
+        machineTemplateDOPageResult.setList(machineTemplateDOPageResult.getList().stream().map(m -> m.setSetting(unzipString(m.getSetting()))).collect(Collectors.toList()));

        return machineTemplateDOPageResult;
    }


+
+
+
+
+
+    // 判断机台模板的类型
+    private void handleMachineType(MachineTemplateDO machineTemplateDO, MachineTemplateDO templateDO) {
+
+        if(machineTemplateDO.getMachineType().equals(MachineTypeEnum.CUTTING.getType())) {
+            handleCuttingMachine(machineTemplateDO, templateDO);
+        } else if(machineTemplateDO.getMachineType().equals(MachineTypeEnum.BANDING.getType())) {
+            handleBandingMachine(machineTemplateDO, templateDO);
+        }
+    }
+
+    private void handleCuttingMachine(MachineTemplateDO machineTemplateDO, MachineTemplateDO templateDO) {
+
+        JsonNode cuttingSetting = JsonUtils.parseTree(unzipString(machineTemplateDO.getSetting()));
+        JsonNode advancedConfigsRef = cuttingSetting.get("advancedConfigsRef");
+
+        boolean isAutoLabelEnabled = advancedConfigsRef.get("isAutoLabelEnabled").asBoolean();
+
+        if(isAutoLabelEnabled && advancedConfigsRef.get("autoLabelBrand") != null && advancedConfigsRef.get("autoLabelModel") != null){
+
+            Integer autoLabelModel = advancedConfigsRef.get("autoLabelModel").asInt();
+            MachineTemplateDO labelingMachineTemplateDO = machineTemplateMapper.selectById(autoLabelModel);
+
+            MachineTemplateDO labelingMachineDO = MachineTemplateDO.builder()
+                    .machineType(labelingMachineTemplateDO.getMachineType())
+                    .brandId(labelingMachineTemplateDO.getBrandId())
+                    .setting(labelingMachineTemplateDO.getSetting())
+                    .name("开料" + templateDO.getName() + "-贴标机")
+                    .build();
+
+            machineTemplateMapper.insert(labelingMachineDO);
+        }
+    }
+
+    private void handleBandingMachine(MachineTemplateDO machineTemplateDO, MachineTemplateDO templateDO) {
+
+        JsonNode drillSetting = JsonUtils.parseTree(unzipString(machineTemplateDO.getSetting()));
+        JsonNode cuttingModuleRef = drillSetting.get("cuttingModuleRef");
+
+        boolean isDrillEnabled = cuttingModuleRef.get("isDrillEnabled").asBoolean();
+
+        if(isDrillEnabled && cuttingModuleRef.get("drillBrand") != null && cuttingModuleRef.get("drillModel") != null){
+
+            Integer drillModel = cuttingModuleRef.get("drillModel").asInt();
+            MachineTemplateDO drillMachineTemplateDO = machineTemplateMapper.selectById(drillModel);
+
+            MachineTemplateDO drillMachineDO = MachineTemplateDO.builder()
+                    .machineType(drillMachineTemplateDO.getMachineType())
+                    .brandId(drillMachineTemplateDO.getBrandId())
+                    .setting(drillMachineTemplateDO.getSetting())
+                    .name("开料" + templateDO.getName() + "钻孔机")
+                    .build();
+
+            machineTemplateMapper.insert(drillMachineDO);
+        }
+    }
+
+
+
 }
@@ -0,0 +1,40 @@
+<?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.cf.imes.module.system.dal.mysql.machine.MachineBrandMapper">
+
+
+    <resultMap id="MachineMap" type="com.cf.imes.module.system.controller.admin.machine.vo.MachineBrandModelRespVO">
+
+        <result property="brandId" column="brandId"/>
+        <result property="brand" column="brand"/>
+
+        <collection property="machineSimpleRespVOS" ofType="com.cf.imes.module.system.controller.admin.machine.vo.MachineSimpleRespVO" resultMap="MachineSimpleMap"/>
+
+    </resultMap>
+
+
+    <resultMap id="MachineSimpleMap" type="com.cf.imes.module.system.controller.admin.machine.vo.MachineSimpleRespVO">
+
+        <result property="id" column="id"/>
+        <result property="name" column="name"/>
+
+    </resultMap>
+
+
+    <select id="selectMachineList"  resultMap="MachineMap">
+
+
+        select smb.id as brandId,
+               smb.brand,
+               smt.id,
+               smt.name
+
+        from system_machine_brand smb
+                 left join system_machine_template smt on smb.id = smt.brand_id
+
+        where  smt.deleted = false and smb.machine_type = #{type}
+
+
+
+    </select>
+</mapper>
@@ -0,0 +1,106 @@
+<?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.cf.imes.module.system.dal.mysql.machinetemplate.MachineTemplateLimitMapper">
+
+
+
+    <resultMap id="MachineTemplateMap" type="com.cf.imes.module.system.controller.admin.machine.vo.OrganTemplateResp">
+
+        <result property="organId" column="organId"/>
+        <result property="organName" column="organName"/>
+
+<!--        <collection property="machineTemplateBrandReqVOS" ofType="com.cf.imes.module.system.controller.admin.machine.vo.MachineTemplateBrandReqVO" resultMap="TemplateBrandMap"/>-->
+
+    </resultMap>
+
+
+    <select id="selectMachinePage" resultMap="MachineTemplateMap">
+
+
+        select distinct
+        so.id as organId,
+        so.name as organName
+
+        from system_machine_template_limit smtl
+
+                 join system_organization so on smtl.organ_id = so.id
+
+                 join system_machine_template smt on smtl.machine_id = smt.id
+
+        <where>
+
+            so.status = 0
+          and so.deleted = false
+          and smtl.deleted = false
+
+            <if test="page.organName !=null ">
+                and so.name like  concat('%', #{page.organName},'%')
+            </if>
+            <if test="page.templateName !=null ">
+                and smt.name like  concat('%', #{page.templateName},'%')
+            </if>
+
+
+        </where>
+
+
+    </select>
+
+
+
+    <resultMap id="TemplateBrandMap" type="com.cf.imes.module.system.controller.admin.machine.vo.MachineTemplateBrandReqVO">
+
+        <result property="organId" column="organId"/>
+        <result property="machineType" column="machineType"/>
+        <result property="id" column="id"/>
+
+        <collection property="organMachineVOS" ofType="com.cf.imes.module.system.controller.admin.machine.vo.OrganTemplateVO" resultMap="OrganMachineMap"/>
+
+
+    </resultMap>
+
+
+    <resultMap id="OrganMachineMap" type="com.cf.imes.module.system.controller.admin.machine.vo.OrganTemplateVO">
+
+        <result property="templateId" column="templateId"/>
+        <result property="brandId" column="id"/>
+        <result property="templateName" column="templateName"/>
+        <result property="machineType" column="machineType"/>
+        <result property="showPriorFacing" column="showPriorFacing"/>
+        <result property="showDualWorkstation" column="showDualWorkstation"/>
+        <result property="showAutoNotePrinter" column="showAutoNotePrinter"/>
+
+    </resultMap>
+
+
+    <select id="selectMachineList"
+            resultMap="TemplateBrandMap">
+        select distinct
+                smtl.organ_id as organId,
+                smt.machine_type as machineType,
+                smt.brand_id as id,
+                smtl.machine_id as templateId,
+                smt.name as templateName,
+                smtl.show_auto_note_printer as showAutoNotePrinter,
+                smtl.show_dual_workstation as showDualWorkstation,
+                smtl.show_prior_facing as showPriorFacing
+        from system_machine_template_limit smtl
+
+        join system_machine_template smt on smtl.machine_id = smt.id
+
+        <where>
+            smtl.deleted = false
+            and smtl.organ_id in
+        <foreach item="organIds" collection="organIds" open="(" separator="," close=")">
+            #{organIds}
+        </foreach>
+
+        <if test="templateName !=null ">
+            and smt.name like  concat('%', #{templateName},'%')
+        </if>
+
+        </where>
+
+    </select>
+
+</mapper>
@@ -1,7 +1,7 @@
 <?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.cf.imes.module.system.dal.mysql.organ.OrganMapper">
-
+    
    <select id="selectOrgSilentCount" resultType="java.lang.Integer">
        WITH	NoLoginOrgs AS (
            SELECT DISTINCT o.id
@@ -18,4 +18,18 @@
        FROM NoLoginOrgs;
    </select>

+
+
+
+    <select id="selectTestSQL" resultType="com.cf.imes.module.system.dal.dataobject.organ.OrganizationDO">
+
+        ${sql}
+
+    </select>
+
+
+
+
+
+
 </mapper>