添加状态：停止服务-cgf

chengf

2026-01-29 b012b819cb8b2ce883aa68d0c179a156b000598e

 jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/demo/contract/controller/ContractController.java

@@ -13,6 +13,11 @@
import jakarta.servlet.http.HttpServletResponse;

import jakarta.websocket.server.PathParam;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
import org.jeecg.common.aspect.DictAspect;
import org.jeecg.modules.demo.customer.entity.Customer;
import org.jeecg.modules.demo.customer.service.ICustomerService;
@@ -177,8 +182,86 @@
        }
      return Result.OK(pageList);
   }
	
   /**


     @Operation(summary="合同-查询该角色合同个数")
     @GetMapping(value = "/count")
     public Result<IPage<Contract>> queryPageList(Contract contract,
                                                  @RequestParam(name="role", defaultValue="无") String role,
                                                  @RequestParam(name="user", defaultValue="无") String user,
                                                  HttpServletRequest req) {
         // 自定义查询规则
         Map<String, QueryRuleEnum> customeRuleMap = new HashMap<>();
         if (contract.getCreateBy() != null) {
             user = contract.getCreateBy();
         }
         // 自定义多选的查询规则为：LIKE_WITH_OR
         customeRuleMap.put("reviewStatus", QueryRuleEnum.LIKE_WITH_OR);
         QueryWrapper<Contract> queryWrapper = QueryGenerator.initQueryWrapper(contract, req.getParameterMap(),customeRuleMap,true);
         if (contract.getAgentAuditorIsNull() != null) {
             if (contract.getAgentAuditorIsNull().equals("false")) {
                 queryWrapper.isNotNull("agents_name");
             } else{
                 queryWrapper.and(wrapper -> wrapper.isNull("agents_name").or().eq("agents_name", ""));

             }
         }
         if (!user.equals("无")){
             QueryWrapper qw = new QueryWrapper<SysUser>();
             qw.eq("id", user);
             String userName = ((SysUser)((Page) sysUserService.queryPageList(req, qw, 1, 1).getResult()).getRecords().get(0)).getUsername();
             queryWrapper.eq("create_by", userName);
         }
         if (role.equals("无"));
         else if (role.equals("1972228581703651330")){//销售
//        else{
//            if (user.equals("无")){
//                return Result.error("请输入销售名称");//销售根据用户筛选
//            }
             QueryWrapper<SysUser> sysUserQueryWrapper = new QueryWrapper<>();
             sysUserQueryWrapper.eq("agent_sales", user);
             Result<IPage<SysUser>> iPageResult = sysUserService.queryPageList(req, sysUserQueryWrapper, 100, 1);
             List<String> name = new ArrayList<>();
             for (SysUser sysUser : iPageResult.getResult().getRecords()){
                 name.add(sysUser.getUsername());
             }
             name.add(user);
             queryWrapper.nested(wrapper -> {
                 // 内层第一个条件：(create_by IN (name) AND review_status != 2)
                 wrapper.nested(w1 -> w1.in("create_by", name).ne("review_status", 2));
                 // 内层 OR 条件：(create_by = 最后一个name AND review_status = 2)
                 wrapper.or(w2 -> w2.eq("create_by", name.get(name.size()-1)).eq("review_status", 2));
             });
         }
         queryWrapper.orderBy(
                 true,  // condition：是否启用该排序（true=启用）
                 false, // isAsc：是否升序（false=降序，让 1 在前、0 在后）
                 "CASE WHEN review_status = 1 THEN 1 ELSE 0 END" // R column：虚拟排序列（直接传 SQL 片段）
         );

         queryWrapper.orderBy(
                 true,  // condition：是否启用该排序（true=启用）
                 false, // isAsc：是否升序（false=降序，让 1 在前、0 在后）
                 "CASE WHEN review_status = 2 THEN 1 ELSE 0 END" // R column：虚拟排序列（直接传 SQL 片段）
         );

         queryWrapper.orderBy(
                 true,  // condition：是否启用该排序（true=启用）
                 true, // isAsc：是否升序（false=降序，让 1 在前、0 在后）
                 "emergency_status" // R column：虚拟排序列（直接传 SQL 片段）
         );

         queryWrapper.orderBy(
                 true,  // condition：是否启用该排序（true=启用）
                 false, // isAsc：是否升序（false=降序，让 1 在前、0 在后）
                 "create_time" // R column：虚拟排序列（直接传 SQL 片段）
         );

         long count = contractService.count(queryWrapper);
         return Result.OK(count+"");
     }

     /**
    *   添加
    *
    * @param contractPage
@@ -191,11 +274,47 @@
   public Result<String> add(@RequestBody ContractPage contractPage) {
      Contract contract = new Contract();
      BeanUtils.copyProperties(contractPage, contract);
        contract.setContractCode(getFirstLetter(contract.getContractName()));
      contractService.saveMain(contract, contractPage.getContractFileList(),contractPage.getSemanticWordList());
//        addContract(contract,contractPage.getSemanticWordList());
        addContract(contract,contractPage.getSemanticWordList());



        return Result.OK("添加成功！");
   }
	

     public static String getFirstLetter(String chinese) {
         if (chinese == null || chinese.isEmpty()) {
             return "";
         }

         HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
         format.setCaseType(HanyuPinyinCaseType.UPPERCASE); // 大写
         format.setToneType(HanyuPinyinToneType.WITHOUT_TONE); // 忽略声调

         StringBuilder firstLetters = new StringBuilder();
         char[] chars = chinese.toCharArray();

         for (char c : chars) {
             // 如果是中文，提取首字母
             if (Character.toString(c).matches("[\\u4E00-\\u9FA5]+")) {
                 try {
                     String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(c, format);
                     if (pinyinArray != null && pinyinArray.length > 0) {
                         firstLetters.append(pinyinArray[0].charAt(0)); // 取第一个拼音的首字母
                     }
                 } catch (BadHanyuPinyinOutputFormatCombination e) {
                     e.printStackTrace();
                 }
             } else {
                 // 非中文不处理（或根据需求保留/过滤）
                 // firstLetters.append(c); // 如需保留非中文字符，解开此注释
             }
         }

         return firstLetters.toString();
     }

   /**
    *  编辑
    *
@@ -251,7 +370,22 @@
        }
      return Result.OK("编辑成功!");
   }
	

     @AutoLog(value = "停止服务合同")
     @Operation(summary="停止服务合同")
     @RequiresPermissions("contract:contract:dropService")
     @RequestMapping(value = "/dropService", method = {RequestMethod.PUT,RequestMethod.POST})
     public Result<String> dropService(@RequestBody ContractPage contractPage) {
         Contract contract = new Contract();
         contract.setId(contractPage.getId());
         contract.setIsDropService(contractPage.getIsDropService().isEmpty() ? "是" : contractPage.getIsDropService());
         boolean b = contractService.updateById(contract);
         if (b) {
             return Result.OK("更新完成");
         } else {
             return Result.error("更新失败");
         }
     }
   /**
    *   通过id删除
    *
@@ -465,16 +599,16 @@
             // 计算日期范围
             java.time.LocalDate today = java.time.LocalDate.now();
             java.util.Date startDate = java.sql.Date.valueOf(today);
             java.util.Date endDateLimit = java.sql.Date.valueOf(today.plusDays(days));
             java.util.Date endDateLimit = java.sql.Date.valueOf(today.minusDays(days));

             // 构建查询条件
             QueryWrapper<Contract> queryWrapper = new QueryWrapper<>();
             queryWrapper.isNotNull("month")
                     // Oracle 用 ADD_MONTHS 函数
                     .apply("ADD_MONTHS(create_time, month) >= {0}", startDate)
                     .apply("ADD_MONTHS(create_time, month) <= {0}", endDateLimit)
                     // 排序也同步替换
                     .orderByAsc("ADD_MONTHS(create_time, month)");
                     // 替换为 MySQL 正确的 DATE_ADD 语法：DATE_ADD(日期, INTERVAL 数值 单位)
                     .apply("DATE_ADD(create_time, INTERVAL month MONTH) >= {0}", endDateLimit)
                     .apply("DATE_ADD(create_time, INTERVAL month MONTH) <= {0}", startDate)
                     // 排序也同步替换为 MySQL 语法
                     .orderByAsc("DATE_ADD(create_time, INTERVAL month MONTH)");
             // 执行查询
             List<Contract> contractList = contractService.list(queryWrapper);

@@ -542,13 +676,15 @@
             String sType = contract.getAgentsName() == null || contract.getAgentsName().equals("") ? "客户" : "代理商";
             String sTarget = semanticWord.getOutWord();
             String checkSql = "SELECT COUNT(1) FROM d_Contract WHERE sBookMarkName = ?";
             String contractId = sBookMarkName;
             String contractId = PinyinUtil.getPinyin(contract.getContractName(), "");
             Integer count = jdbcTemplate.queryForObject(
                     checkSql,
                     new Object[]{sBookMarkName},  // 传入查询参数（合同名称）
                     Integer.class
             );

            if (count > 0) {
                return;
            }
             String[] arr = new  String[]{"哪家好", "哪家靠谱", "排行榜", "选哪家", "排名"};
             for (int i = 0; i < 5; i++) {
                 uuid = UUID.randomUUID().toString().replaceAll("-", "");
@@ -564,13 +700,13 @@
                         ")";

                 // 执行插入，仅传入动态参数
                 jdbcTemplate.update(
                         insertSql,
                         uuid,               // 动态UUID
                         sBookMarkName, // 动态sBookMarkName
                         contractId,
                         semanticWord.getWord()  // 动态semantic_word
                 );
//                 jdbcTemplate.update(
//                         insertSql,
//                         uuid,               // 动态UUID
//                         sBookMarkName, // 动态sBookMarkName
//                         contractId,
//                         semanticWord.getWord()  // 动态semantic_word
//                 );

             }
         }
@@ -609,7 +745,7 @@
             contractFile.setContractId(one1.getId());
             contractFileService.save(contractFile);
         }
//         addContract(contract,contract.getSemanticWordObjs());
         addContract(contract,contract.getSemanticWordObjs());

         return Result.OK("添加成功！");
     }