content: package com.taobao.qa.ruleengine.rules.primitives;
  
  import com.alibaba.fastjson.JSON;
  //import org.json.JSONArray;
  import com.alibaba.fastjson.JSONArray;
  //import com.alibaba.fastjson.JSONObject;
  import org.json.JSONObject;
  
  import java.net.URLDecoder;
  import java.net.URLEncoder;
  import java.util.LinkedHashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  import java.io.UnsupportedEncodingException;
  
  public class CommonClassMethods {
  
      /**
       * 比较两个字符串是否相等，对应自定义函数"字符串比较"，例如 if(字符串比较(expectedRefPid, actualRefPid) != 0)
       * @param str1 字符串1
       * @param str2 字符串2
       * @return 如果str1=str2，则返回0，否则返回非0
       */
      public static int strCompare(String str1,String str2) {
          return str1.compareTo(str2);
      }
  
      /**
       * 将整数转换为字符串，对应自定义函数"整数转为字符串"，例如 exptpos = 整数转为字符串(j+1);
       * @param val 被转换的整数
       * @return val对应的字符串
       */
      public static String intToString(Integer val){
           return Integer.toString(val);
      }
  
      /**
       * 获取字符数组中指定位置的值，对应自定义函数"getByIndex"，例如 minVal = getByIndex(arr,0)
       * @param arr 字符数组
       * @param index 位置
       * @return arr[index]值
       */
      public static String getByIndex(String[] arr,Integer index){
          String val = null;
          if(arr.length > index){
              val = arr[index];
          }
          return val;
      }
  
      /**
       * 字符串按照指定的分隔符做切分，对应自定义函数"字符串切分"，例如 exptArr = 字符串切分(titleStr,",")
       * @param str 被切分字符串
       * @param splits 切分字符
       * @return 切分后的字符串数组
       */
      public static String[] strSplit(String str,String splits){
          String[] arr = str.split(splits);
          return arr;
      }
  
      /**
       * 去除字符串左侧指定的字符，对应自定义函数"ltrim"，例如 pid = ltrim(pid,",")
       * @param str 被处理字符串
       * @param substr 被删除字符串
       * @return 删除str左侧substr后的新字符串
       */
      public static String ltrim(String str,String substr){
          int i=0;
          for(;i<str.length();i++){
              if(substr.indexOf(str.charAt(i))==-1){
                  break;
              }
          }
          return str.substring(i);
      }
  
      /**
       * 去除字符串右侧指定的字符，对应自定义函数"rtrim"，例如 pid = rtrim(pid,",")
       * @param str 被处理字符串
       * @param substr 被删除字符串
       * @return 删除str右侧substr后的新字符串
       */
      public static String rtrim(String str,String substr){
          int j=str.length()-1;
          for(;j>-1;j--){
              if(substr.indexOf(str.charAt(j))==-1){
                  break;
              }
          }
          return str.substring(0, j+1);
      }
  
      /**
       * 等同于java URLDecoder.decode，对应自定义函数"urldecode"，例如 ac = urldecode(ac,"GBK");
       * @param str 被处理字符串
       * @param code 编码方式，例如utf-8
       * @return 解码后的值
       */
      public static String urldecode(String str,String code){
          String res = "";
          try {
              res = URLDecoder.decode(str,code);
          }catch (UnsupportedEncodingException e){
              System.out.print(e.getCause());
          }
          return res;
      }
  
      /**
       * 等同于URLEncoder.encode，对应自定义函数"urlencode"，例如 ac = urleecode(ac,"GBK");
       * @param str 被处理字符串
       * @param code 编码方式，例如utf-8
       * @return 编码后的值
       */
      public static String urlencode(String str,String code){
          String res = "";
          try {
              res = URLEncoder.encode(str,code);
          }catch (UnsupportedEncodingException e){
              System.out.print(e.getCause());
          }
          return res;
      }
  
      /**
       * 获取json串指定key的值，目前只能获取一层json的key，对应自定义函数"json串key获取"，例如 ratio = json串key获取(mtStr,"101");
       * @param jsonString json字符串，取值类似 ：{"0":1508,"1":1687,"ratio":8}
       * @param k 需要获取值的key
       * @return k在jsonString中对应的取值
       */
      public static String executeJson(String jsonString, String k){
          JSONObject jsonObject = new JSONObject(jsonString);
          Iterator iterator = jsonObject.keys();
          while(iterator.hasNext()){
              String key = (String) iterator.next();
              Object value = (Object)jsonObject.get(key);
              if(key.equals(k)) {
                  return value.toString();
              }
          }
          return "";
      }
  
      /**
       * 验证字符数组是否包含指定的元素，对应自定义函数"数组A是否包含元素B"
       * @param strArr 字符数组
       * @param val  字符元素
       * @return  strArr为空，则返回false；否则strArr包含val元素，则返回true；否则返回false
       */
      public static boolean contains(String[] strArr,String val){
          if(strArr.length == 0){
              return false;
          }
          for(String one:strArr){
              if(one.equals(val)){
                  return true;
              }
          }
          return false;
      }
  
      /**
       * 验证数组A不包含数组B中的任何元素,对应自定义函数"数组A是否不包含数组B的任何元素"
       * @param A 数组A
       * @param B 数组B
       * @return A或B为空，返回false；否则A包含B的任何元素，返回false；否则返回true
       */
      public static boolean containsNon(String[] A,String[] B){
          if(A.length == 0 || B.length == 0){
              return false;
          }
          for(String oneB:B){
              for(String oneA:A){
                  if(oneB.equals(oneA)){
                      return false;
                  }
              }
          }
          return true;
      }
  
      /**
       * 验证两个数组的交集，对应自定义函数"数组A和B是否有交集"
       * @param A 字符串数组
       * @param B 字符串数组
       * @return A&B都为空，则返回false；否则如果两个数组交集非空，则返回true，否则返回false
       */
      public static boolean containsAny(String[] A,String[] B){
          if(A.length == 0 || B.length == 0){
              return false;
          }
         for(String oneA:A){
             for(String oneB:B){
                 if(oneA.equals(oneB)){
                     return true;
                 }
             }
         }
         return false;
      }
  
      /**
       * 验证数组A是否包含数组B中的所有元素，即数组B是否是数组A的子集，对应自定义函数"数组B是否是数组A的子集"
       * @param A 字符数组A
       * @param B 字符数组B
       * @return A&B都为空，返回false；否则A包含B的所有元素，则返回true；否则返回false
       */
      public static boolean containsAll(String[] A,String[] B){
          if(A.length == 0 || B.length == 0){
              return false;
          }
          for(String oneB:B){
              for(String oneA:A){
                  if(!oneA.equals(oneB)){
                      return false;
                  }
              }
          }
          return true;
      }
  
      /**
       * 获取指定jsonArr或jsonObj中指定的key。该查找方式是有损查找，被找到的叶子节点数据会被删除
       * @param srcObj  待查找jsonArr或jsonObj
       * @param keyStr  查找字段的路径key，多级key用逗号连接
       * @param keypos  keyStr中的第几个key，keypos初始值为0
       * @return 查找的结果，若找到则返回对应的string，否则返回null
       */
      private static String getFieldFromJsonSingle(Object srcObj, String keyStr,Integer keypos){
          String res = null;
          String[] keyArr = keyStr.split(",");
          if( keypos >= keyArr.length){
              return null;
          }
          String currKey = keyArr[keypos];
          if(srcObj instanceof com.alibaba.fastjson.JSONArray){
              for(int i = 0; i < ((com.alibaba.fastjson.JSONArray) srcObj).size(); i++){
                  Object subobj = ((com.alibaba.fastjson.JSONArray) srcObj).get(i);
                  res = getFieldFromJsonSingle(subobj,keyStr,keypos);
                  if( res != null){
                      return res;
                  }
              }
          }
          else if( srcObj instanceof com.alibaba.fastjson.JSONObject){
              Set<String> keySet = ((com.alibaba.fastjson.JSONObject) srcObj).keySet();
              if(keySet.contains(currKey)){
                  if((keypos +1) == keyArr.length){ // 待查询字段的最后一个字段，查找结束，返回查询结果
                      Object obj =  ((com.alibaba.fastjson.JSONObject) srcObj).get(currKey);
                      if(obj instanceof com.alibaba.fastjson.JSONObject){
                          res =  JSONObject.valueToString(obj);
                      }
                      res = ((com.alibaba.fastjson.JSONObject) srcObj).getString(currKey);
                      ((com.alibaba.fastjson.JSONObject) srcObj).remove(currKey);// 删除已找到的key
                      return res;
                  }else{
                      Object subobj = ((com.alibaba.fastjson.JSONObject) srcObj).get(currKey);
                      res = getFieldFromJsonSingle(subobj,keyStr,keypos+1);
                      if(res != null){
                          return res;
                      }
                  }
              }
          }
          return res;
      }
  
      /**
       * 递归查找srcobj中keyStr字段
       * @param srcObj  原始待查找jonsarry
       * @param keyStr 待查找递归字符串，例如app,deals,id的含义是查找arr中app.deals.id字段
       * @return
       */
      public static com.alibaba.fastjson.JSONArray getMultiFieldFromJson(JSONArray srcObj, String keyStr){
          JSONArray arr = new JSONArray();
          String res = "";
          // 保证查找对原始数据无影响
          String midStr = srcObj.toJSONString();
          JSONArray midArr = JSONArray.parseArray(midStr);
          while(res != null){
              res = getFieldFromJsonSingle(midArr,keyStr,0);
              if(res != null){
                  arr.add(res);
              }
          }
          return arr;
      }
      
      /**
       * jsonarray中是否存在指定的值
       * @param A
       * @param value
       * @return
       */
      public static boolean containsValue(com.alibaba.fastjson.JSONArray A,String value){
      	if(A==null||A.size()<1){
      		return false;
      	}
      	
      	for(Object a :A){
      		if(a.toString().equals(value)){
      			return true;
      		}
      	}
      	return false;
      }
      
      /**
       * 两个整数字符串对比，str1>str2时返回1，str1==str2时返回0，str1<str2时返回-1
       * @param str1
       * @param str2
       * @return
       */
      public static int stringIntCompare(String str1,String str2){
          if(str1.equals(str2)){
              return 0;
          }
  
          if(str1.length()>str2.length()){
              return 1;
          }
  
          if(isNumeric(str1)&&isNumeric(str2)){
              int int1 = Integer.parseInt(str1);
              int int2 = Integer.parseInt(str2);
              if(int1>int2){
                  return 1;
              }else if(int1==int2){
                  return 0;
              }else{
                  return -1;
              }
          }
  
  
          return str1.compareTo(str2);
      }
  
      /**
       * 判断字符串是否为正整数
       * @param str
       * @return
       */
      public static boolean isNumeric(String str){
          for (int i = 0; i < str.length(); i++){
  //		   System.out.println(str.charAt(i));
              if (!Character.isDigit(str.charAt(i))){
                  return false;
              }
          }
          return true;
      }
  
      public static String getProductFromTable(String tableName) {
          String product = "";
          switch (tableName){
              case "t_rule":{
                  product = "steed_data";
                  break;
              }
          }
          return product;
      }
  }
  