finekit/src/main/java/com/fanruan/api/cal/ParameterKit.java

package com.fanruan.api.cal;

import com.fanruan.api.util.ArrayKit;
import com.fanruan.api.util.AssistKit;
import com.fr.base.DataSetFunctionParameterMapNameSpace;
import com.fr.base.Parameter;
import com.fr.base.ParameterHelper;
import com.fr.base.ParameterMapNameSpace;
import com.fr.base.ParameterTypeHandler;
import com.fr.base.TemplateUtils;
import com.fr.data.impl.TableColumn;
import com.fr.general.DateUtils;
import com.fr.json.JSON;
import com.fr.json.JSONArray;
import com.fr.json.JSONFactory;
import com.fr.json.JSONObject;
import com.fr.script.Calculator;
import com.fr.stable.ArrayUtils;
import com.fr.stable.ParameterProvider;
import com.fr.stable.script.NameSpace;
import org.jetbrains.annotations.NotNull;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @author richie
 * @version 10.0
 * Created by richie on 2019-08-16
 * 参数相关的工具类
 */
public class ParameterKit {

    /**
     * 创建一个参数对象实例
     *
     * @return 参数对象
     */
    public static ParameterProvider newParameter() {
        return new Parameter();
    }

    /**
     * 创建一个参数对象实例
     *
     * @param name  参数名
     * @param value 参数值
     * @return 参数对象
     */
    public static ParameterProvider newParameter(String name, Object value) {
        return new Parameter(name, value);
    }

    /**
     * 根据参数名创建新的参数对象
     *
     * @param name 参数名
     * @return 参数对象
     */
    public static @NotNull ParameterProvider newParameter(String name) {
        return new Parameter(name);
    }

    /**
     * 从字符串中分析中有哪些需要的参数
     *
     * @param text         字符串
     * @param hasColumnRow 是否需要分析格子类型的参数
     * @return 字符串中包含的参数集合
     */
    public static ParameterProvider[] analyze4Parameters(String text, boolean hasColumnRow) {
        return ParameterHelper.analyze4Parameters(text, hasColumnRow);
    }

    /**
     * 分析公式中所携带的参数
     *
     * @param text 公式内容
     * @return 参数数组
     */
    public static @NotNull ParameterProvider[] analyze4ParametersFromFormula(String text) {
        return ParameterHelper.analyze4ParametersFromFormula(text);
    }

    /**
     * 分析一组字符串中的参数
     *
     * @param paramTexts 字符串组
     * @param isFormula  是否是公式类型的字符串数组
     * @return 参数集合
     */
    public static @NotNull ParameterProvider[] analyze4Parameters(String[] paramTexts, boolean isFormula) {
        return ParameterHelper.analyze4Parameters(paramTexts, isFormula);
    }

    /**
     * 创建一个用于计算的参数对名字空间
     *
     * @param map 参数键值对
     * @return 名字空间，用于传递给算子做计算
     */
    public static @NotNull NameSpace createParameterMapNameSpace(Map<String, Object> map) {
        return ParameterMapNameSpace.create(map);
    }

    /**
     * 创建一个用于计算的参数对名字空间
     *
     * @param ps 参数数组数组
     * @return 名字空间，用于传递给算子做计算
     */

    public static @NotNull NameSpace createParameterMapNameSpace(ParameterProvider[] ps) {
        return ParameterMapNameSpace.create(ps);
    }

    /**
     * 获得新的参数集数组，新的参数结合中参数的值是通过设定的同名参数传递进去的
     *
     * @param paramTexts sql语句
     * @param ps         用于传值的参数数组
     * @return 新参数素组
     */
    public static ParameterProvider[] analyzeAndUnionSameParameters(String[] paramTexts, ParameterProvider[] ps) {

        ParameterProvider[] parameters = ParameterKit.analyze4Parameters(paramTexts, false);

        if (ArrayUtils.isEmpty(parameters)) {
            return parameters;
        }

        if (ArrayKit.isNotEmpty(ps)) {
            for (ParameterProvider newParameter : parameters) {
                ParameterProvider existParameter = null;
                for (ParameterProvider p : ps) {
                    if (AssistKit.equals(p.getName(), newParameter.getName())) {
                        existParameter = p;
                        break;
                    }
                }
                if (existParameter != null) {
                    newParameter.setValue(existParameter.getValue());
                }
            }
        }

        return parameters;
    }

    /**
     * 获得参数并集，将新的参数拼接在后面
     *
     * @param paramTexts sql语句
     * @param ps         旧的参数集合
     * @return 新参数集合
     */
    public static ParameterProvider[] analyzeAndMergeParameters(String[] paramTexts, ParameterProvider[] ps) {
        ParameterProvider[] parameters = ParameterKit.analyze4Parameters(paramTexts, false);

        if (ArrayKit.isEmpty(parameters) || ArrayKit.isEmpty(ps)) {
            return ArrayUtils.addAll(ps, parameters);
        }

        List<ParameterProvider> psList = ArrayKit.toList(ps);

        // 检查ps中是否有parameter，如果没有就加进去
        for (ParameterProvider parameter : parameters) {
            for (int i = 0; i < ps.length; i ++) {
                if (AssistKit.equals(ps[i].getName(), parameter.getName())) {
                    break;
                }
                else if (i >= ps.length - 1) {
                    psList.add(parameter);
                }
            }
        }

        return psList.toArray(new ParameterProvider[0]);
    }

    /**
     * 增加处理数据集间联系，例如：select * from t where time=${today()}
     *
     * @param text       原文本字符串
     * @param parameters 参数集合
     * @return 新的文本字符串
     */
    public static String analyzeCurrentContextTableData4Template(String text, ParameterProvider[] parameters) {
        Calculator c = Calculator.createCalculator();
        NameSpace ns = DataSetFunctionParameterMapNameSpace.creat(parameters);
        c.pushNameSpace(ns);
        String str = TemplateUtils.renderTpl(c, text);
        c.removeNameSpace(ns);
        return str;
    }

    /**
     * 从JSON中解析出来参数信息
     *
     * @param jsonObject JSON文本
     * @return 参数信息
     */
    public static ParameterProvider json2Parameter(JSONObject jsonObject) {
        Parameter parameter = new Parameter();
        parameter.setName(jsonObject.getString("name"));
        String type = jsonObject.getString("type");
        if (jsonObject.has("value")) {
            ParameterTypeHandler handler = ParameterTypeHandler.valueOf(type);
            return handler.parseJson(jsonObject, parameter);
        }
        return parameter;
    }

    /**
     * 将多个参数转化为JSON数组
     *
     * @param parameters 参数数组
     * @return JSON数组
     */
    public static JSONArray parameters2Json(ParameterProvider[] parameters) {
        JSONArray jsonArray = JSONFactory.createJSON(JSON.ARRAY);
        for (int i = 0; i < parameters.length; i++) {
            JSONObject jsonObject = JSONFactory.createJSON(JSON.OBJECT);
            ParameterProvider parameter = parameters[i];

            jsonObject.put("name", parameter.getName());

            if (parameter.getValue() instanceof Date) {
                String dateString = DateUtils.DATEFORMAT2.format(parameter.getValue());
                jsonObject.put("value", dateString);
            } else if (parameter.getValue() instanceof TableColumn) {
                jsonObject.put("value", JSONFactory.createJSON(JSON.OBJECT, parameter.valueToString()));
            } else {
                jsonObject.put("value", parameter.getValue());
            }

            String type = parameter.getValue().getClass().getName();
            int firstChar = type.lastIndexOf('.') + 1;
            if (firstChar > 0) {
                type = type.substring(firstChar);
            }
            jsonObject.put("type", type);

            jsonArray.put(jsonObject);
        }

        return jsonArray;
    }

    /**
     * 参数类型
     */
    public static final class Type {

        private Type(){}

        /**
         * 文本类型的参数
         */
        public static final String TYPE_STRING = ParameterTypeHandler.String.name();

        /**
         * 整数类型的参数
         */
        public static final String TYPE_INTEGER = ParameterTypeHandler.Integer.name();

        /**
         * 小数类型的参数
         */
        public static final String TYPE_DOUBLE = ParameterTypeHandler.Double.name();

        /**
         * 日期类型的参数
         */
        public static final String TYPE_DATE = ParameterTypeHandler.Date.name();

        /**
         * 布尔类型的参数
         */
        public static final String TYPE_BOOLEAN = ParameterTypeHandler.Boolean.name();

        /**
         * 公式类型的参数
         */
        public static final String TYPE_FORMULA = ParameterTypeHandler.Formula.name();

        /**
         * 长整形类型的参数
         */
        public static final String TYPE_LONG = ParameterTypeHandler.Long.name();

    }
}