机台授权部分接口更改

cf-module-system/cf-module-system-biz/src/main/java/com/cf/imes/module/system/controller/admin/machine/MachineAuthController.java

@@ -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")
+    @PutMapping("insert-organ-auth")
-    @Operation(summary = "组织机台授权")
+    @Operation(summary = "组织机台授权新增")
     @PreAuthorize("@ss.hasPermission('machine-auth::update')")
     public CommonResult<Boolean> auth(@RequestBody MachineOrgAuthReq vo) {
         return success(machineService.auth(vo));

cf-module-system/cf-module-system-biz/src/main/java/com/cf/imes/module/system/controller/admin/machine/MachineTemplateAuthController.java

@@ -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.controller.admin.machine.vo.MachineOrgAuthReq;
-import com.cf.imes.module.system.dal.dataobject.machinetemplate.MachineTemplateDO;
+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")
+    @PutMapping("insert-organ-auth-template")
-    @Operation(summary = "组织模板授权")
+    @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")
+    @GetMapping("organ-template-machine-auth")
-    @Operation(summary = "授权机台模板分页")
+    @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) {
+    public CommonResult<TemplateAutoResp> getTemplateAuth(@RequestParam(required = false) Long organId ) {
-        PageResult<MachineTemplateDO> page = machineTemplateService.page(pageParam);
+        return success(machineTemplateService.getTemplateAuth(organId));
-        List<TemplateAutoResp> list = page.getList().stream().map(e->TemplateAutoResp.builder()
+//        List<TemplateAutoResp> list = page.getList().stream().map(e->TemplateAutoResp.builder()
-                .id(e.getId())
+//                .id(e.getId())
-                .machineType(e.getMachineType())
+//                .machineType(e.getMachineType())
-                .templateName(e.getName())
+//                .templateName(e.getName())
-                .build()
+//                .build()
-        ).collect(Collectors.toList());
+//        ).collect(Collectors.toList());
 
-        return success(new PageResult<TemplateAutoResp>(list, page.getTotal()));
     }
 }

cf-module-system/cf-module-system-biz/src/main/java/com/cf/imes/module/system/dal/dataobject/machinetemplate/MachineTemplateLimitDO.java

@@ -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;
+
 }

cf-module-system/cf-module-system-biz/src/main/java/com/cf/imes/module/system/dal/mysql/machinetemplate/MachineTemplateLimitMapper.java

@@ -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));
+    }
+
 }

cf-module-system/cf-module-system-biz/src/main/java/com/cf/imes/module/system/service/machine/MachineTemplateService.java

@@ -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);
 }

cf-module-system/cf-module-system-biz/src/main/java/com/cf/imes/module/system/service/machine/MachineTemplateServiceImpl.java

@@ -1,23 +1,13 @@
 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.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.*;
@@ -62,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;
@@ -81,90 +69,10 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
     @Resource
     private MachineBrandMapper machineBrandMapper;
 
-    @Override
+    @Resource
-    @Transactional(rollbackFor = Exception.class)
+    private OrganMapper organMapper;
-    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();
-    }
 
-    @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)
@@ -288,18 +196,61 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
 
     }
 
-    @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
@@ -341,29 +292,111 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
 
     }
 
-//    @Override
+    @Override
-//    @Transactional
+    public TemplateAutoResp getTemplateAuth(Long organId) {
-//    public Boolean setDefaultTemplate(Long id) {
+
-//        MachineTemplateDO templateDO = machineTemplateMapper.selectById(id);
+        // todo 逻辑增强已完成，已完成如果按照组织查询，只查询当前组织下没有进行授权的机台，数据正确性待确认
-//        if (Objects.isNull(templateDO)) {
+
-//            throw exception(MACHINE_TEMPLATE_NOT_EXISTS);
+        TemplateAutoResp templateAutoResp = new TemplateAutoResp();
-//        }
+
-//        List<MachineTemplateDO> machineTemplateDOS = machineTemplateMapper.selectList(MachineTemplateDO::getMachineType, templateDO.getMachineType(), MachineTemplateDO::getIsDefault, Boolean.TRUE);
+
-//        if(CollectionUtil.isEmpty(machineTemplateDOS) || machineTemplateDOS.size()>1) {
+        List<Long> machineIds;
-//            throw exception(DEFAULT_TEMPLATE_COUNT);
+
-//        }
+        if(organId != null){
-//
+
-//        if(!machineTemplateDOS.isEmpty()){
+            List<MachineTemplateLimitDO> machineTemplateLimitDOS = machineTemplateLimitMapper.selectListByOrganId(organId);
-//            MachineTemplateDO machineTemplateDO = new MachineTemplateDO();
+
-//            machineTemplateDO.setId(machineTemplateDOS.get(0).getId());
+            machineIds = machineTemplateLimitDOS.stream().map(MachineTemplateLimitDO::getMachineId).distinct().toList();
-//            machineTemplateDO.setIsDefault(Boolean.FALSE);
+
-//            machineTemplateMapper.updateById(machineTemplateDO);
+        } else {
-//        }
+            machineIds = new ArrayList<>();
-//
+        }
-//        templateDO.setIsDefault(Boolean.TRUE);
+
-//        machineTemplateMapper.updateById(templateDO);
+        List<OrganizationDO> organizationDOS = organMapper.selectOrganList(CommonStatusEnum.ENABLE.getStatus());
-//        return Boolean.TRUE;
+
-//    }
+
+        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
@@ -377,25 +410,6 @@ public class MachineTemplateServiceImpl implements MachineTemplateService {
         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)
@@ -417,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();
 

cf-module-system/cf-module-system-biz/src/main/resources/mapper/machinetemplate/MachineTemplateLimitMapper.xml

@@ -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>