REPORT-57892 公式编辑器优化：实时计算返回结果为日期格式时不正确

1.修改了一些bug；
2.根据产品调整了一些需求。

designer-base/src/main/java/com/fr/design/formula/FormulaPane.java

@@ -5,6 +5,7 @@ import com.fr.base.BaseUtils;
 import com.fr.base.Parameter;
 import com.fr.base.ParameterMapNameSpace;
 import com.fr.base.TableDataNameSpace;
+import com.fr.base.io.IOFile;
 import com.fr.data.TableDataSource;
 import com.fr.design.actions.UpdateAction;
 import com.fr.design.border.UIRoundedBorder;
@@ -27,13 +28,19 @@ import com.fr.design.gui.syntax.ui.rsyntaxtextarea.SyntaxConstants;
 import com.fr.design.i18n.Toolkit;
 import com.fr.design.layout.FRGUIPaneFactory;
 import com.fr.design.mainframe.DesignerContext;
+import com.fr.design.mainframe.JTemplate;
 import com.fr.design.parameter.ParameterInputPane;
 import com.fr.design.utils.gui.GUICoreUtils;
 import com.fr.general.ComparatorUtils;
+import com.fr.general.FArray;
 import com.fr.log.FineLoggerFactory;
-import com.fr.main.impl.WorkBook;
+import com.fr.parser.ArrayExpression;
+import com.fr.parser.BlockIntervalLiteral;
+import com.fr.parser.ColumnRowRangeInPage;
 import com.fr.parser.FRLexer;
 import com.fr.parser.FRParser;
+import com.fr.parser.FunctionCall;
+import com.fr.parser.SheetIntervalLiteral;
 import com.fr.report.core.namespace.SimpleCellValueNameSpace;
 import com.fr.script.Calculator;
 import com.fr.script.ScriptConstants;
@@ -93,6 +100,7 @@ import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.StringReader;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -111,6 +119,8 @@ public class FormulaPane extends BasicPane implements KeyListener, UIFormula {
 
     public static final String VALID_FORMULA = Toolkit.i18nText("Fine-Design_Basic_FormulaD_Valid_Formula");
     public static final String INVALID_FORMULA = Toolkit.i18nText("Fine-Design_Basic_FormulaD_Invalid_Formula");
+    public static final int DEFUAL_FOMULA_LENGTH = 103;
+    public static final String ELLIPSIS = "...";
     private VariableTreeAndDescriptionArea variableTreeAndDescriptionArea;
     private RSyntaxTextArea formulaTextArea;
     private UITextField keyWordTextField = new UITextField(18);
@@ -675,6 +685,9 @@ public class FormulaPane extends BasicPane implements KeyListener, UIFormula {
             StringBuilder errorMsg = new StringBuilder(functionName + com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Formula_Check_Error_Tips") + ":");
             for (int i = 0; i < rules.size(); i++) {
                 errorMsg.append("(");
+                if (rules.get(i).getParameterList().isEmpty()) {
+                    errorMsg.append(com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Formula_No_Param"));
+                }
                 for (FunctionParameterType functionParameterType : rules.get(i).getParameterList()) {
                     errorMsg.append(getTypeString(functionParameterType)).append(",");
                 }
@@ -716,46 +729,75 @@ public class FormulaPane extends BasicPane implements KeyListener, UIFormula {
         @Override
         public void actionPerformed(ActionEvent e) {
             String formulaText = formulaTextArea.getText().trim();
-            String formulaValidMessage = getFormulaValidMessage(formulaText);
+            if (containsUnsupportedSimulationFormulas(formulaText)) {
-            if (formulaValidMessage.equals(INVALID_FORMULA)) {
                 FineJOptionPane.showMessageDialog(
                         FormulaPane.this,
-                        formulaValidMessage,
+                        com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Formula_Unsupported_Formulas"),
                         com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Tool_Tips"),
                         JOptionPane.INFORMATION_MESSAGE);
+                return;
+            }
+            String formulaValidMessage = getFormulaValidMessage(formulaText);
+            String messageTips;
+            if (formulaValidMessage.equals(INVALID_FORMULA)) {
+                messageTips = INVALID_FORMULA;
             } else {
-                String messageTips = formulaValidMessage.equals(VALID_FORMULA) ? "" : formulaValidMessage + "\n";
+                messageTips = formulaValidMessage.equals(VALID_FORMULA) ? "" : formulaValidMessage + "\n";
                 Map<String, Object> paramsMap = setParamsIfExist(formulaText);
                 Calculator calculator = Calculator.createCalculator();
                 ParameterMapNameSpace parameterMapNameSpace = ParameterMapNameSpace.create(paramsMap);
                 calculator.pushNameSpace(parameterMapNameSpace);
 
-                WorkBook workBook = (WorkBook) HistoryTemplateListCache.getInstance().getCurrentEditingTemplate().getTarget();
+                JTemplate<?, ?> currentEditingTemplate = HistoryTemplateListCache.getInstance().getCurrentEditingTemplate();
-                calculator.pushNameSpace(SimpleCellValueNameSpace.getInstance());
+                if (currentEditingTemplate != null) {
-                TableDataSource tableDataSource = workBook.getReport(0).getTableDataSource();
+                    IOFile file = (IOFile) currentEditingTemplate.getTarget();
-                calculator.setAttribute(TableDataSource.KEY, tableDataSource);
+                    calculator.setAttribute(TableDataSource.KEY, file);
-                calculator.pushNameSpace(TableDataNameSpace.getInstance());
+                    calculator.pushNameSpace(TableDataNameSpace.getInstance());
+                    calculator.pushNameSpace(SimpleCellValueNameSpace.getInstance());
+                }
+
                 BaseFormula baseFormula = BaseFormula.createFormulaBuilder().build(formulaText);
                 try {
                     Object value = calculator.evalValue(baseFormula);
-                    messageTips = messageTips + com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Formula_Cal_Result") + ":" + EssentialUtils.objectToString(value);
+                    String objectToString = EssentialUtils.objectToString(value);
+                    String result = objectToString.length() > DEFUAL_FOMULA_LENGTH ?
+                            objectToString.substring(0, DEFUAL_FOMULA_LENGTH - ELLIPSIS.length()) + ELLIPSIS : objectToString;
+                    messageTips = messageTips +
+                            com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Formula_Cal_Result") + ":" + result;
                     FineLoggerFactory.getLogger().info("value:{}", value);
                 } catch (UtilEvalError utilEvalError) {
                     FineLoggerFactory.getLogger().error("", utilEvalError);
                 }
-                FineJOptionPane.showMessageDialog(
-                        FormulaPane.this,
-                        messageTips,
-                        com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Tool_Tips"),
-                        JOptionPane.INFORMATION_MESSAGE);
             }
+            FineJOptionPane.showMessageDialog(
+                    FormulaPane.this,
+                    messageTips,
+                    com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Tool_Tips"),
+                    JOptionPane.INFORMATION_MESSAGE);
         }
     };
 
+    private boolean containsUnsupportedSimulationFormulas(String formulaText) {
+        try {
+            Expression expression = Calculator.createCalculator().parse(formulaText);
+            String name = ((FunctionCall) expression.getConditionalExpression()).getName();
+            if (UnsupportedSimulationFormulaHunter.isUnsupportedFomula(name)) {
+                return true;
+            }
+            UnsupportedSimulationFormulaHunter unsupportedSimulationFormulaHunter = new UnsupportedSimulationFormulaHunter();
+            expression.traversal4Tiny(unsupportedSimulationFormulaHunter);
+            return !unsupportedSimulationFormulaHunter.isSupported();
+        } catch (Exception e) {
+            FineLoggerFactory.getLogger().error("", e);
+        }
+        return true;
+    }
+
     private Map<String, Object> setParamsIfExist(String formulaText) {
         Map<String, Object> parameterMap = new HashMap<>();
         try {
-            Expression expression = Calculator.createCalculator().parse(formulaText);
+            Calculator calculator = Calculator.createCalculator();
+            Expression expression = calculator.parse(formulaText);
             ParameterCellHunter parameterCellHunter = new ParameterCellHunter();
             expression.traversal4Tiny(parameterCellHunter);
             Parameter[] parameters = parameterCellHunter.getParameterBooty();
@@ -770,10 +812,18 @@ public class FormulaPane extends BasicPane implements KeyListener, UIFormula {
                     parameterMap.putAll(pPane.update());
                 }
             }).setVisible(true);
+            //过滤出数组参数，如：[1,2]
+            for (Map.Entry<String, Object> entry : parameterMap.entrySet()) {
+                if (entry.getValue().toString().startsWith("[") && entry.getValue().toString().startsWith("]")) {
+                    Expression parse = calculator.parse(entry.getValue());
+                    ArrayExpression arrayExpression = (ArrayExpression) parse.getConditionalExpression();
+                    FArray<Node> fArray = new FArray<>(arrayExpression.getArrays());
+                    parameterMap.put(entry.getKey(), fArray);
+                }
+            }
         } catch (Exception e) {
             FineLoggerFactory.getLogger().error("", e);
         }
-
         return parameterMap;
     }
 
@@ -782,7 +832,6 @@ public class FormulaPane extends BasicPane implements KeyListener, UIFormula {
         private final Set<Parameter> parameterList = new HashSet<>();
 
         Parameter[] getParameterBooty() {
-
             return parameterList.toArray(new Parameter[0]);
         }
 
@@ -790,12 +839,35 @@ public class FormulaPane extends BasicPane implements KeyListener, UIFormula {
             String statement = tiny.getStatement();
             if (StringUtils.isNotBlank(statement) && statement.startsWith(ScriptConstants.DETAIL_TAG)) {
                 parameterList.add(new Parameter(statement.substring(1)));
-            } else if (tiny.getClass().equals(ColumnRowRange.class)) {
+            } else if (tiny.getClass() == ColumnRowRange.class || tiny.getClass() == ColumnRowRangeInPage.class ||
+                    tiny.getClass() == SheetIntervalLiteral.class || tiny.getClass() == BlockIntervalLiteral.class) {
                 parameterList.add(new Parameter(tiny.toString()));
             }
         }
     }
 
+    private static class UnsupportedSimulationFormulaHunter extends TinyHunter {
+        public final static String[] UNSUPPORTED_FORMULAS = new String[]{"PROPORTION", "TOIMAGE",
+                "WEBIMAGE", "SORT", "CROSSLAYERTOTAL", "CIRCULAR", "LAYERTOTAL", "MOM", "HIERARCHY"};
+
+        private boolean supported = true;
+
+        public boolean isSupported() {
+            return supported;
+        }
+
+        public void hunter4Tiny(Tiny tiny) {
+            String statement = tiny.getStatement().toUpperCase();
+            if (Arrays.asList(UNSUPPORTED_FORMULAS).contains(statement)) {
+                supported = false;
+            }
+        }
+
+        public static boolean isUnsupportedFomula(String formula) {
+            return Arrays.asList(UNSUPPORTED_FORMULAS).contains(formula);
+        }
+    }
+
     public class VariableTreeAndDescriptionArea extends JPanel {
 
         private JTree variablesTree;