若有固定值，则指标条件加上固定值

guoshilong

2024-01-25 91fff6d21fcec11fca3097cd7641d9ea9ebfda8d

 skjcmanager/skjcmanager-service/skjcmanager-sm/src/main/java/cn/gistack/sm/resDataCheck/feign/RulesClient.java

@@ -2,12 +2,18 @@

import cn.gistack.sm.resDataCheck.entity.Rules;
import cn.gistack.sm.resDataCheck.entity.RulesCondition;
import cn.gistack.sm.resDataCheck.service.IQualityManageService;
import cn.gistack.sm.resDataCheck.service.IRulesConditionService;
import cn.gistack.sm.resDataCheck.service.IRulesService;
import cn.gistack.system.feign.IDictBizClient;
import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.tenant.annotation.NonDS;
import org.springblade.core.tool.api.R;
import org.springblade.core.tool.utils.ObjectUtil;
import org.springblade.core.tool.utils.StringUtil;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

@@ -23,14 +29,195 @@
@ApiIgnore
@RestController
@AllArgsConstructor
@Slf4j
public class RulesClient implements IRulesClient {

   private IRulesService rulesService;

   private IRulesConditionService rulesConditionService;

   private IQualityManageService qualityManageService;

   private IDictBizClient dictBizClient;

   /**
    * 指标匹配空值
    *
    * @param key condition
    * @return
    */
   private String getConditionSqlStrByNullVal(String key) {
      String retStr = "-1";
      switch (key) {
         case "EQUAL": //等于
            retStr = " is null OR = '' ";
            break;
         case "UNEQUAL": //不等于
            retStr = " is not null ";
            break;
      }
      return retStr;
   }

   /**
    * 指标对指标匹配
    *
    * @param key    condition
    * @param target 指标
    * @param val    值
    * @return
    */
   private String getConditionSqlStrByTarget(String key, String target, String val) {
      String retStr = "-1";
      switch (key) {
         case "GREATER": //大于
            retStr = " > " + target;
            break;
         case "GREATER_EQUAL": //大于等于
            retStr = " >= " + target;
            break;
         case "EQUAL": //等于
            retStr = " = " + target;
            break;
         case "LESS_EQUAL": //小于等于
            retStr = " <= " + target;
            break;
         case "LESS":  //小于
            retStr = " < " + target;
            break;
         case "UNEQUAL": //不等于
            retStr = " <> " + target;
            break;
         case "DIFFER_GRATER": //差值大于
            retStr = " - " + target + " > " + val;
            break;
         case "DIFFER_GRATER_EQUAL": //差值大于等于
            retStr = " - " + target + " >= " + val;
            break;
         case "DIFFER_EQUAL": //差值等于
            retStr = " - " + target + " = " + val;
            break;
         case "DIFFER_LESS_EQUAL": //差值小于等于
            retStr = " - " + target + " < " + val;
            break;
         case "DIFFER_LESS": //差值小于
            retStr = " - " + target + " <= " + val;
            break;
         case "DIFFER_UNEQUAL": //差值不等于
            retStr = " - " + target + " <> " + val;
            break;
      }
      return retStr;
   }

   /**
    * 指标对值匹配
    *
    * @param key condition
    * @param val 值
    * @return
    */
   private String getConditionSqlStrByVal(String key, String val) {
      String retStr = "-1";
      switch (key) {
         case "GREATER": //大于
            retStr = " > " + val;
            break;
         case "GREATER_EQUAL": //大于等于
            retStr = " >= " + val;
            break;
         case "EQUAL": //等于
            retStr = " = " + val;
            break;
         case "LESS_EQUAL": //小于等于
            retStr = " <= " + val;
            break;
         case "LESS":  //小于
            retStr = " < " + val;
            break;
         case "UNEQUAL": //不等于
            retStr = " <> " + val;
            break;
      }
      return retStr;
   }

   /**
    * 指标封装数据库字段
    *
    * @param key 指标值
    * @return 数据库str
    */
   private String getPropSqlStr(String key) {
      String retStr = "";
      switch (key) {
         case "BASIC_1": // 水库名称
            retStr = "a.\"name\"";
            break;
         case "BASIC_2": // 管理行政区
            retStr = "a.\"interior_ad_guid\"";
            break;
         case "BASIC_3": // 注册登记号
            retStr = "a.\"res_reg_code\"";
            break;
         case "RESERVOIR_1": // 总库容(万m³)
            retStr = "c.\"tb_tot_cap\"";
            break;
         case "RESERVOIR_2": // 死库容(万m³)
            retStr = "c.\"tb_dead_cap\"";
            break;
         case "RESERVOIR_3": // 校核洪水位(m)
            retStr = "c.\"tb_chec_fl_stag\"";
            break;
         case "RESERVOIR_4": // 设计洪水位(m)
            retStr = "c.\"tb_des_fl_stag\"";
            break;
         case "RESERVOIR_5": // 正常蓄水位(m)
            retStr = "c.\"tb_norm_pool_stag\"";
            break;
         case "RESERVOIR_6": // 防洪高水位(m)
            retStr = "c.\"tb_flpr_high_stag\"";
            break;
         case "RESERVOIR_7": // 死水位(m)
            retStr = "c.\"tb_dead_stag\"";
            break;
         case "RESERVOIR_8": // 控制运行水位(m)
            retStr = "b.\"tb_control_z\"";
            break;
         case "RESERVOIR_9": // 集雨面积
            retStr = "c.\"wat_shed_area\"";
            break;
         case "RESERVOIR_10": // 实时水位(m)
            retStr = "f.\"rz\"";
            break;
         case "DRAINAGE_1": // 堰顶高程(m)
            retStr = "g.\"tb_weir_top_elevation\"";
            break;
         case "RETAINING_3": // 坝顶高程(m)
            retStr = "h.\"tb_dam_top_elevation\"";
            break;
         case "FLOOD_1": // 前汛期(m)
            retStr = "d1.\"tb_flse_lim_stag\"";
            break;
         case "FLOOD_2": // 主汛期(m)
            retStr = "d2.\"tb_flse_lim_stag\"";
            break;
         case "FLOOD_3": // 后汛期(m)
            retStr = "d3.\"tb_flse_lim_stag\"";
            break;
         default:
            retStr = "";
      }
      return retStr;
   }

   private String getDictValue(String key) {
      return dictBizClient.getValue("CON_BASIC", key).getData();
   }

   @Override
   public R createDataRules(Long id) {
      log.info("规则匹配中......");
      // 获取规则对象  返回值有关联水库，只匹配关联水库，为空表示匹配所有水库
      Rules rules = rulesService.getById(id);

@@ -40,13 +227,72 @@
      List<RulesCondition> rcList = rulesConditionService.list(Condition.getQueryWrapper(rulesCondition));

      // 开始拼接条件 where
      String sqlStr = "";
      String relation = "";
      String varStr = "";
      for (RulesCondition rc : rcList) {

      // 判断规则操作数据表
      if (rules.getType().equals("BASIC")) { // 水库基本类型
         // 指标1
         if (rc.getRelation().equals("AND")) {
            relation = " AND ";
         } else if (rc.getRelation().equals("OR")) {
            relation = " OR ";
         } else {
            relation = " WHERE ";
         }

         sqlStr += relation + getPropSqlStr(rc.getBasic());

         // 判断
         if (rc.getProp().equals("NULLVAL")) { // 空值
            sqlStr += getConditionSqlStrByNullVal(rc.getCondition());
         } else if (rc.getProp().equals("TARGET")) { // 指标
            sqlStr += ObjectUtil.isNotEmpty(rc.getFixValue())?
               getConditionSqlStrByTarget(rc.getCondition(), getPropSqlStr(rc.getTarget()), rc.getValue())+"-"+rc.getFixValue() :
               getConditionSqlStrByTarget(rc.getCondition(), getPropSqlStr(rc.getTarget()), rc.getValue());
         } else {
            sqlStr += getConditionSqlStrByVal(rc.getCondition(), rc.getValue());
         }

         // 获取对应规则的值  concat('水库名称：',a."name",'\n','水库注册码：',a."interior_ad_guid")
         if (varStr.indexOf(getPropSqlStr(rc.getBasic())) < 0) {
            if (StringUtil.isBlank(varStr)) {
               varStr =  "'" + getDictValue(rc.getBasic()) + ": " + "'" + "," + getPropSqlStr(rc.getBasic());
            } else {
               varStr += "," + "'\n'" + ",'" + getDictValue(rc.getBasic()) + ": " + "'" + "," + getPropSqlStr(rc.getBasic());
            }

         }
         if (rc.getProp().equals("TARGET")) {
            varStr += "," + "'\n'" + ",'" + getDictValue(rc.getTarget()) + ": " + "'" + "," + getPropSqlStr(rc.getTarget());
         }


      }

      varStr = "concat(" + varStr +") AS val";

      if (StringUtil.isNotBlank(rules.getIsGate())) {
         sqlStr += " and a.\"is_gate\" = " + rules.getIsGate();
      }

      // 拼接条件有问题，不操作
      if (sqlStr.indexOf("-1") > 0) {
         log.info("查询条件错误，请检查规则设置......：", sqlStr);
         return R.fail(-1, sqlStr + "\\n 查询条件错误，请检查规则设置");
      }

      Integer ret = 0;
      try {
         ret = qualityManageService.addQualityManage(id, varStr, sqlStr);
      } catch (Exception e) {
         e.printStackTrace();
         log.info("查询条件错误，请检查规则设置......：", sqlStr);
      } finally {
         log.info("执行完成......：");
      }

      // 执行sql
      return null;
      return R.data(ret);
   }
}