12 changed files with 823 additions and 32 deletions
@ -0,0 +1,25 @@
|
||||
package com.fr.design.data.datapane; |
||||
|
||||
import com.fr.stable.fun.mark.API; |
||||
|
||||
/** |
||||
* 数据集Tree工具栏面板注入接口 |
||||
* |
||||
* @author Destiny.Lin |
||||
* @since 11.0 |
||||
* Created on 2024/11/1 |
||||
*/ |
||||
@API(level = TableDataTreeToolBarActionProvider.CURRENT_LEVEL) |
||||
public abstract class AbstractTableDataTreeToolBarActionProvider implements TableDataTreeToolBarActionProvider { |
||||
|
||||
|
||||
@Override |
||||
public int currentAPILevel() { |
||||
return CURRENT_LEVEL; |
||||
} |
||||
|
||||
@Override |
||||
public String mark4Provider() { |
||||
return getClass().getName(); |
||||
} |
||||
} |
||||
@ -0,0 +1,25 @@
|
||||
package com.fr.design.data.datapane; |
||||
|
||||
import com.fr.stable.fun.mark.Mutable; |
||||
|
||||
|
||||
/** |
||||
* 数据集Tree工具栏面板注入接口 |
||||
* |
||||
* @author Destiny.Lin |
||||
* @since 11.0 |
||||
* Created on 2024/11/1 |
||||
*/ |
||||
public interface TableDataTreeToolBarActionProvider extends Mutable { |
||||
|
||||
String XML_TAG = "TableDataTreeToolBarActionProvider"; |
||||
|
||||
int CURRENT_LEVEL = 1; |
||||
|
||||
/** |
||||
* 创建Action对象,用于提供针对数据集的额外操作 |
||||
* |
||||
* @return 创建出来的Action对象 |
||||
*/ |
||||
TableDataTreePane.ExtraAction createAction(); |
||||
} |
||||
@ -0,0 +1,223 @@
|
||||
package com.fr.design.actions.replace.action.content.tabledata; |
||||
|
||||
import com.fr.data.TableReplacementEntity; |
||||
import com.fr.invoke.Reflect; |
||||
import com.fr.log.FineLoggerFactory; |
||||
import com.fr.parser.BinaryExpression; |
||||
import com.fr.parser.FunctionCall; |
||||
import com.fr.parser.StringLiteral; |
||||
import com.fr.script.Calculator; |
||||
import com.fr.stable.StringUtils; |
||||
import com.fr.stable.script.Expression; |
||||
import com.fr.stable.script.Node; |
||||
|
||||
import java.util.ArrayList; |
||||
import java.util.HashSet; |
||||
import java.util.List; |
||||
import java.util.Set; |
||||
|
||||
/** |
||||
* 公式工具 |
||||
* |
||||
* @author Destiny.Lin |
||||
* @since 11.0 |
||||
* Created on 2024/11/5 |
||||
*/ |
||||
public class FormulaUtils { |
||||
|
||||
|
||||
private static final String LEFT_BRACKET = "${"; |
||||
private static final String RIGHT_BRACKET = "}"; |
||||
private static final String FORMULA_MARK = "="; |
||||
private static final String STATEMENT = "statement"; |
||||
|
||||
/** |
||||
* 从公式中寻找数据集名称 |
||||
*/ |
||||
public static Set<String> search(String formula) { |
||||
Set<String> result = new HashSet<>(); |
||||
for (TableDataFormulaType tableDataFormulaType : TableDataFormulaType.values()) { |
||||
result.addAll(FormulaUtils.fetchArgument(formula, tableDataFormulaType.name(), tableDataFormulaType.getArgumentIndex())); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* 获取替换后的公式全文 |
||||
*/ |
||||
public static String replace(String formula, List<TableReplacementEntity> entities) { |
||||
try { |
||||
Expression expression = Calculator.createCalculator().parse(formula); |
||||
FormulaUtils.replace0(expression, entities); |
||||
String ans = expression.toString(); |
||||
if (formula.startsWith(FORMULA_MARK) && !ans.startsWith(FORMULA_MARK)) { |
||||
return FORMULA_MARK + ans; |
||||
} else { |
||||
if (ans.startsWith(FORMULA_MARK)) { |
||||
return ans.substring(1); |
||||
} |
||||
} |
||||
return ans; |
||||
} catch (Exception e) { |
||||
FineLoggerFactory.getLogger().error(e.getMessage(), e); |
||||
return formula; |
||||
} |
||||
} |
||||
|
||||
private static void replace0(Expression expression, List<TableReplacementEntity> entities) { |
||||
if (expression != null) { |
||||
Node node = expression.getConditionalExpression(); |
||||
if (node instanceof BinaryExpression) { |
||||
BinaryExpression binaryExpression = (BinaryExpression) node; |
||||
Node[] nodes = binaryExpression.getNodes(); |
||||
if (nodes != null) { |
||||
for (Node subNode : nodes) { |
||||
if (subNode instanceof FunctionCall) { |
||||
FunctionCall functionCall = (FunctionCall) subNode; |
||||
FormulaUtils.replaceArgument(functionCall, entities); |
||||
} |
||||
} |
||||
} |
||||
} else if (node instanceof FunctionCall) { |
||||
FunctionCall functionCall = (FunctionCall) node; |
||||
FormulaUtils.replaceArgument(functionCall, entities); |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
/** |
||||
* 从公式（可能存在嵌套）中解析出某类型函数的第几个参数 |
||||
* |
||||
* @param formula 公式 |
||||
* @param functionName 函数名 |
||||
* @param argumentIndex 参数位置 |
||||
* @return 对应参数位置的值 |
||||
*/ |
||||
public static List<String> fetchArgument(String formula, String functionName, int argumentIndex) { |
||||
List<String> result = new ArrayList<>(); |
||||
try { |
||||
Expression expression = Calculator.createCalculator().parse(formula); |
||||
if (expression != null) { |
||||
Node node = expression.getConditionalExpression(); |
||||
if (node instanceof BinaryExpression) { |
||||
BinaryExpression binaryExpression = (BinaryExpression) node; |
||||
Node[] nodes = binaryExpression.getNodes(); |
||||
if (nodes != null) { |
||||
for (Node subNode : nodes) { |
||||
if (subNode instanceof FunctionCall) { |
||||
FunctionCall functionCall = (FunctionCall) subNode; |
||||
result.addAll(FormulaUtils.fetchArgument(functionCall, functionName, argumentIndex)); |
||||
} |
||||
} |
||||
} |
||||
} else if (node instanceof FunctionCall) { |
||||
FunctionCall functionCall = (FunctionCall) node; |
||||
result.addAll(FormulaUtils.fetchArgument(functionCall, functionName, argumentIndex)); |
||||
} |
||||
} |
||||
|
||||
} catch (Exception e) { |
||||
FineLoggerFactory.getLogger().error(e, e.getMessage()); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
private static void replaceArgument(FunctionCall functionCall, List<TableReplacementEntity> entities) { |
||||
Node[] subNodes = functionCall.getArguments(); |
||||
if (subNodes != null) { |
||||
StringBuilder parent = new StringBuilder(StringUtils.EMPTY); |
||||
for (int i = 0; i < subNodes.length; i++) { |
||||
Node subNode = subNodes[i]; |
||||
if (subNode instanceof FunctionCall) { |
||||
replaceArgument((FunctionCall) subNode, entities); |
||||
} |
||||
if (subNode instanceof StringLiteral) { |
||||
StringLiteral stringLiteral = (StringLiteral) subNode; |
||||
replaceArgument0(i, stringLiteral, functionCall, entities, parent); |
||||
|
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
private static void replaceArgument0(int i, StringLiteral stringLiteral, FunctionCall functionCall, List<TableReplacementEntity> entities, StringBuilder parent) { |
||||
try { |
||||
TableDataFormulaType type = TableDataFormulaType.get(functionCall.getName()); |
||||
if (type != null) { |
||||
String name = stringLiteral.eval(Calculator.createCalculator()).toString(); |
||||
for (TableReplacementEntity entity : entities) { |
||||
// 数据集名
|
||||
if (i == type.getArgumentIndex()) { |
||||
if (StringUtils.equals(name, entity.getOldName())) { |
||||
// 替换数据集名
|
||||
parent.append(name); |
||||
Reflect.on(stringLiteral).set(STATEMENT, entity.getNewName()); |
||||
break; |
||||
} |
||||
} else { |
||||
String field = entity.getTargetField(name); |
||||
// 如果是需要匹配的字段
|
||||
// 要走到字段匹配，就必须先经过数据集名匹配，目前所有公式都是数据集在前，字段在后
|
||||
if (StringUtils.isNotEmpty(field) && StringUtils.equals(parent.toString(), name)) { |
||||
// 替换成匹配后的字段
|
||||
Reflect.on(stringLiteral).set(STATEMENT, field); |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} catch (Exception e) { |
||||
FineLoggerFactory.getLogger().debug(e, e.getMessage()); |
||||
} |
||||
} |
||||
|
||||
|
||||
/** |
||||
* 从公式（可能存在嵌套）中解析出某类型函数的第几个参数 |
||||
* |
||||
* @param functionCall 公式 |
||||
* @param functionName 函数名 |
||||
* @param argumentIndex 参数位置 |
||||
* @return 对应参数位置的值 |
||||
*/ |
||||
public static List<String> fetchArgument(FunctionCall functionCall, String functionName, int argumentIndex) { |
||||
List<String> result = new ArrayList<>(); |
||||
Node[] subNodes = functionCall.getArguments(); |
||||
if (subNodes != null) { |
||||
// 遍历子公式
|
||||
for (int i = 0; i < subNodes.length; i++) { |
||||
Object subNode = subNodes[i]; |
||||
if (i == argumentIndex && subNode instanceof StringLiteral && StringUtils.equalsIgnoreCase(functionCall.getName(), functionName)) { |
||||
StringLiteral stringLiteral = (StringLiteral) subNode; |
||||
try { |
||||
result.add(stringLiteral.eval(Calculator.createCalculator()).toString()); |
||||
} catch (Exception e) { |
||||
FineLoggerFactory.getLogger().debug(e, e.getMessage()); |
||||
} |
||||
continue; |
||||
} |
||||
if (subNode instanceof FunctionCall) { |
||||
for (TableDataFormulaType tableDataFormulaType : TableDataFormulaType.values()) { |
||||
result.addAll(FormulaUtils.fetchArgument((FunctionCall) subNode, tableDataFormulaType.name(), tableDataFormulaType.getArgumentIndex())); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* 通过${content}格式获取公式内容 |
||||
* |
||||
* @param formula 原公式值 |
||||
* @return 最终公式值 |
||||
*/ |
||||
public static String getFormulaPureContent(String formula) { |
||||
if (formula.startsWith(LEFT_BRACKET) && formula.endsWith(RIGHT_BRACKET)) { |
||||
return formula.substring(LEFT_BRACKET.length() + 1, formula.length() - 1); |
||||
} else { |
||||
return formula; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,75 @@
|
||||
package com.fr.design.actions.replace.action.content.tabledata; |
||||
|
||||
import com.fr.stable.StringUtils; |
||||
|
||||
/** |
||||
* 涉及数据集的公式类型枚举 |
||||
* |
||||
* @author Destiny.Lin |
||||
* @since 11.0 |
||||
* Created on 2024/11/5 |
||||
*/ |
||||
public enum TableDataFormulaType { |
||||
/** |
||||
* COLCOUNT公式 |
||||
*/ |
||||
COLCOUNT("COLCOUNT", 0), |
||||
/** |
||||
* CLONAME公式 |
||||
*/ |
||||
COLNAME("COLNAME", 0), |
||||
/** |
||||
* MAP公式 |
||||
*/ |
||||
MAP("MAP", 1), |
||||
/** |
||||
* ROWCOUNT公式 |
||||
*/ |
||||
ROWCOUNT("ROWCOUNT", 0), |
||||
/** |
||||
* TABLEDATAFILEDS公式 |
||||
*/ |
||||
TABLEDATAFIELDS("TABLEDATAFIELDS", 0), |
||||
/** |
||||
* VALUE公式 |
||||
*/ |
||||
VALUE("VALUE", 0); |
||||
|
||||
private int argumentIndex; |
||||
private String name; |
||||
|
||||
TableDataFormulaType(String name, int argumentIndex) { |
||||
this.argumentIndex = argumentIndex; |
||||
this.name = name; |
||||
} |
||||
|
||||
public int getArgumentIndex() { |
||||
return argumentIndex; |
||||
} |
||||
|
||||
/** |
||||
* 公式content是否需要替换处理 |
||||
*/ |
||||
public static boolean needReplace(String value) { |
||||
for (TableDataFormulaType type : TableDataFormulaType.values()) { |
||||
if (value.contains(type.name())) { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* 获取对应的公式类型 |
||||
*/ |
||||
public static TableDataFormulaType get(String functionName) { |
||||
for (TableDataFormulaType type : TableDataFormulaType.values()) { |
||||
if (StringUtils.equalsIgnoreCase(functionName, type.name())) { |
||||
return type; |
||||
} |
||||
} |
||||
return null; |
||||
} |
||||
} |
||||
|
||||
@ -0,0 +1,240 @@
|
||||
package com.fr.design.actions.replace.utils; |
||||
|
||||
import com.fr.base.Formula; |
||||
import com.fr.chart.chartattr.ChartCollection; |
||||
import com.fr.data.TableReplacementEntity; |
||||
import com.fr.design.actions.replace.action.content.cell.SearchCellAction; |
||||
import com.fr.design.actions.replace.action.content.formula.SearchFormulaManager; |
||||
import com.fr.design.actions.replace.action.content.formula.cell.SearchCellFormulaAction; |
||||
import com.fr.design.actions.replace.action.content.formula.chart.SearchChartCollectionFormulaAction; |
||||
import com.fr.design.actions.replace.action.content.formula.widget.SearchWidgetFormulaAction; |
||||
import com.fr.design.actions.replace.action.content.tabledata.FormulaUtils; |
||||
import com.fr.design.actions.replace.action.content.tabledata.TableDataFormulaType; |
||||
import com.fr.design.actions.replace.action.content.widget.SearchWidgetAction; |
||||
import com.fr.design.actions.replace.info.CellInfo; |
||||
import com.fr.design.actions.replace.info.FormulaInfo; |
||||
import com.fr.design.actions.replace.info.WidgetInfo; |
||||
import com.fr.design.actions.replace.info.base.ITContent; |
||||
import com.fr.design.mainframe.JTemplate; |
||||
import com.fr.form.FormElementCaseProvider; |
||||
import com.fr.form.ui.ElementCaseEditor; |
||||
import com.fr.main.impl.WorkBook; |
||||
import com.fr.report.elementcase.ElementCase; |
||||
import com.fr.report.utils.ElementCaseHelper; |
||||
import java.util.ArrayList; |
||||
|
||||
import java.util.HashSet; |
||||
import java.util.Iterator; |
||||
import java.util.List; |
||||
import java.util.Set; |
||||
|
||||
/** |
||||
* 数据集查找替换工具 |
||||
* |
||||
* @author Destiny.Lin |
||||
* @since 11.0 |
||||
* Created on 2024/11/4 |
||||
*/ |
||||
public class ReplaceUtils { |
||||
/** |
||||
* ----------------------------------------------查找部分-------------------------------------------------- |
||||
*/ |
||||
|
||||
/** |
||||
* 获取公式里使用的数据集 |
||||
* |
||||
* @param formula 公式内容 |
||||
* @return 返回公式中使用的数据集名称 |
||||
*/ |
||||
public static Set<String> getFormulaDependenceTables(String formula) { |
||||
return FormulaUtils.search(formula); |
||||
} |
||||
|
||||
|
||||
/** |
||||
* 获取图表块里使用的数据集(不包含公式里的) |
||||
* |
||||
* @param chartCollection 图表对象 |
||||
* @return 使用的数据集名称 |
||||
*/ |
||||
public static Set<String> getChartDependenceTables(ChartCollection chartCollection) { |
||||
return chartCollection.getDataSetNames(); |
||||
} |
||||
|
||||
/** |
||||
* 获取图表里使用的公式 |
||||
* |
||||
* @param chartCollection 图表对象 |
||||
* @return 图表公式集合 |
||||
*/ |
||||
public static Set<String> getChartDependenceFormulas(ChartCollection chartCollection) { |
||||
List<FormulaInfo> formulaInfos = new ArrayList<>(); |
||||
SearchChartCollectionFormulaAction.getInstance().searchChartCollectionFormula(formulaInfos, new ITContent(), chartCollection); |
||||
Set<String> ans = new HashSet<>(); |
||||
for (FormulaInfo formulaInfo : formulaInfos) { |
||||
ans.add(formulaInfo.getContent().getReplaceObject().toString()); |
||||
} |
||||
return ans; |
||||
} |
||||
|
||||
/** |
||||
* 获取报表块里使用的数据集(不包含公式里的) |
||||
* |
||||
* @param elementCaseEditor 报表块 |
||||
* @return 报表块使用的数据集 |
||||
*/ |
||||
public static Set<String> getElementCaseDependenceTables(ElementCaseEditor elementCaseEditor) { |
||||
FormElementCaseProvider elementCase = elementCaseEditor.getElementCase(); |
||||
return elementCase.getCellTableDataSet(); |
||||
} |
||||
|
||||
/** |
||||
* 获取报表块里使用的公式 |
||||
* |
||||
* @param elementCase 报表块 |
||||
* @return 公式集合 |
||||
*/ |
||||
public static Set<String> getElementCaseDependenceFormulas(ElementCase elementCase) { |
||||
List<FormulaInfo> formulaInfos = getElementCaseFormulas(elementCase); |
||||
Set<String> ans = new HashSet<>(); |
||||
for (FormulaInfo formulaInfo : formulaInfos) { |
||||
ans.add(formulaInfo.getContent().getReplaceObject().toString()); |
||||
} |
||||
return ans; |
||||
} |
||||
|
||||
/** |
||||
* 获取CPT里使用的数据集(不包含公式里的) |
||||
* |
||||
* @param template 模板 |
||||
* @return 数据集名字集合 |
||||
*/ |
||||
public static Set<String> getCptDependenceTables(JTemplate template) { |
||||
Set<String> ans = new HashSet<>(); |
||||
if (template.getTarget() instanceof WorkBook) { |
||||
WorkBook workBook = (WorkBook) template.getTarget(); |
||||
Iterator<String> iterator = workBook.getTableDataNameIterator(); |
||||
while (iterator.hasNext()) { |
||||
String tableName = iterator.next(); |
||||
ans.add(tableName); |
||||
} |
||||
} |
||||
return ans; |
||||
} |
||||
|
||||
/** |
||||
* 获取CPT里使用的公式 |
||||
* |
||||
* @param template 包含workbook的Jtemplate |
||||
* @return 公式集合 |
||||
*/ |
||||
public static Set<String> getCptDependenceFormulas(JTemplate template) { |
||||
SearchFormulaManager.getInstance().search4Infos(template); |
||||
List<FormulaInfo> formulaInfos = SearchFormulaManager.getInstance().getFormulaInfos(); |
||||
Set<String> ans = new HashSet<>(); |
||||
for (FormulaInfo formulaInfo : formulaInfos) { |
||||
ans.add(formulaInfo.getContent().getReplaceObject().toString()); |
||||
} |
||||
return ans; |
||||
} |
||||
|
||||
|
||||
/** |
||||
* ----------------------------------------------替换部分-------------------------------------------------- |
||||
*/ |
||||
|
||||
/** |
||||
* 替换公式里的数据集 |
||||
* |
||||
* @param formula 公式 |
||||
* @param entity 替换信息 |
||||
* @return 替换后的公式内容 |
||||
*/ |
||||
public static String replaceFormula(String formula, List<TableReplacementEntity> entity) { |
||||
return FormulaUtils.replace(formula, entity); |
||||
} |
||||
|
||||
/** |
||||
* 替换公式里的数据集 |
||||
* |
||||
* @param formula 公式 |
||||
* @param entity 替换信息 |
||||
*/ |
||||
public static void replaceFormula(Formula formula, List<TableReplacementEntity> entity) { |
||||
String content = formula.getContent(); |
||||
formula.setContent(FormulaUtils.replace(content, entity)); |
||||
} |
||||
|
||||
/** |
||||
* 替换图表里使用的数据集(包含公式里的) |
||||
* |
||||
* @param chartCollection 图表对象 |
||||
* @param entities 替换信息 |
||||
*/ |
||||
public static void replaceChart(ChartCollection chartCollection, List<TableReplacementEntity> entities) { |
||||
// 非公式部分
|
||||
chartCollection.replaceTableData(entities); |
||||
// 公式部分
|
||||
List<FormulaInfo> formulaInfos = new ArrayList<>(); |
||||
SearchChartCollectionFormulaAction.getInstance().searchChartCollectionFormula(formulaInfos, new ITContent(), chartCollection); |
||||
replaceFormulaInfos(formulaInfos, entities); |
||||
} |
||||
|
||||
/** |
||||
* 替换报表块里使用的数据集(包含公式里的) |
||||
* |
||||
* @param elementCase 报表块控件 |
||||
* @param entities 替换信息 |
||||
*/ |
||||
public static void replaceElementCase(ElementCase elementCase, List<TableReplacementEntity> entities) { |
||||
// 非公式部分
|
||||
ElementCaseHelper.replaceTableDataWithOutFormula(elementCase, entities); |
||||
// 公式部分——理论上就只有单元格和控件（超链那些都包含）
|
||||
List<FormulaInfo> formulaInfos = getElementCaseFormulas(elementCase); |
||||
replaceFormulaInfos(formulaInfos, entities); |
||||
|
||||
} |
||||
|
||||
/** |
||||
* 替换CPT使用的数据集(包含公式里的) |
||||
* |
||||
* @param template cpt对应的JTemplate |
||||
* @param entity 替换信息 |
||||
*/ |
||||
public static void replaceCpt(JTemplate template, List<TableReplacementEntity> entity) { |
||||
if (template.getTarget() instanceof WorkBook) { |
||||
WorkBook workBook = (WorkBook) template.getTarget(); |
||||
|
||||
// 非公式部分替换
|
||||
workBook.replaceTableData(entity); |
||||
// 公式部分
|
||||
SearchFormulaManager.getInstance().search4Infos(template); |
||||
List<FormulaInfo> formulaInfos = SearchFormulaManager.getInstance().getFormulaInfos(); |
||||
replaceFormulaInfos(formulaInfos, entity); |
||||
} |
||||
} |
||||
|
||||
private static void replaceFormulaInfos(List<FormulaInfo> formulaInfos, List<TableReplacementEntity> entity) { |
||||
for (FormulaInfo formulaInfo : formulaInfos) { |
||||
if (TableDataFormulaType.needReplace(formulaInfo.getPureValue())) { |
||||
formulaInfo.setValue(formulaInfo, |
||||
formulaInfo.getPureValue(), |
||||
FormulaUtils.replace(formulaInfo.getPureValue(), entity), |
||||
new ArrayList<>()); |
||||
} |
||||
} |
||||
} |
||||
|
||||
private static List<FormulaInfo> getElementCaseFormulas(ElementCase elementCase) { |
||||
List<CellInfo> cellInfos = new ArrayList<>(); |
||||
List<FormulaInfo> formulaInfos = new ArrayList<>(); |
||||
List<WidgetInfo> widgetInfos = new ArrayList<>(); |
||||
SearchCellAction.getInstance().getCellInfoFromElementCase(elementCase, cellInfos, new ITContent()); |
||||
SearchCellFormulaAction.getInstance().searchFormulaFromCellInfos(cellInfos, formulaInfos); |
||||
SearchWidgetAction.getInstance().searchCellWidget(widgetInfos, cellInfos); |
||||
for (WidgetInfo widgetInfo : widgetInfos) { |
||||
SearchWidgetFormulaAction.getInstance().searchFormulaFromWidgetInfos(widgetInfo, formulaInfos); |
||||
} |
||||
return formulaInfos; |
||||
} |
||||
} |
||||
@ -0,0 +1,110 @@
|
||||
package com.fr.design.actions.replace.action.content.tabledata; |
||||
|
||||
import com.fr.data.TableReplacementEntity; |
||||
import junit.framework.TestCase; |
||||
import org.junit.Assert; |
||||
|
||||
import java.util.ArrayList; |
||||
import java.util.HashSet; |
||||
import java.util.List; |
||||
import java.util.Set; |
||||
|
||||
/** |
||||
* 公式工具类的单测 |
||||
* |
||||
* @author Destiny.Lin |
||||
* @since 11.0 |
||||
* Created on 2024/11/5 |
||||
*/ |
||||
public class FormulaUtilsTest extends TestCase { |
||||
|
||||
public void testSearch() { |
||||
String rowcount = "=ROWCOUNT(\"123\")"; |
||||
Set<String> strings = new HashSet<>(); |
||||
strings.add("123"); |
||||
Assert.assertEquals(FormulaUtils.search(rowcount), strings); |
||||
Set<String> errorSet = new HashSet<>(); |
||||
errorSet.add("1223"); |
||||
Assert.assertNotEquals(FormulaUtils.search(rowcount), errorSet); |
||||
String str = "=COLNAME(\"test-测试\",COLCOUNT(\"列数嵌套123\"))"; |
||||
Set<String> qiantao = new HashSet<>(); |
||||
qiantao.add("test-测试"); |
||||
qiantao.add("列数嵌套123"); |
||||
Assert.assertEquals(FormulaUtils.search(str), qiantao); |
||||
String str2 = "=sum(len(MAP(value(\"test-测试1\",COLNAME(\"test-测试2\",2),COLCOUNT(\"test-测试3\")),\"test-测试4\",COLNAME(\"test-测试5\",2),COLNAME(\"test-测试6\",4))),ROWCOUNT(\"test-测试7\"),len(TABLEDATAFIELDS(\"test-测试8\")))"; |
||||
Set<String> qiantao2 = FormulaUtils.search(str2); |
||||
Assert.assertTrue(qiantao2.contains("test-测试1")); |
||||
Assert.assertTrue(qiantao2.contains("test-测试2")); |
||||
Assert.assertTrue(qiantao2.contains("test-测试3")); |
||||
Assert.assertTrue(qiantao2.contains("test-测试4")); |
||||
Assert.assertTrue(qiantao2.contains("test-测试5")); |
||||
Assert.assertTrue(qiantao2.contains("test-测试6")); |
||||
Assert.assertTrue(qiantao2.contains("test-测试7")); |
||||
Assert.assertTrue(qiantao2.contains("test-测试8")); |
||||
|
||||
} |
||||
|
||||
public void testReplace() { |
||||
String rowcount = "=ROWCOUNT(\"123\")"; |
||||
TableReplacementEntity entity = new TableReplacementEntity(); |
||||
entity.setOldName("123"); |
||||
entity.setNewName("222"); |
||||
List<TableReplacementEntity> entities = new ArrayList<>(); |
||||
entities.add(entity); |
||||
Assert.assertEquals(FormulaUtils.replace(rowcount, entities), "=ROWCOUNT(\"222\")"); |
||||
|
||||
String colcount = "=COLCOUNT(\"test测试\")"; |
||||
TableReplacementEntity entity1 = new TableReplacementEntity(); |
||||
entity1.setOldName("test测试"); |
||||
entity1.setNewName("替换"); |
||||
List<TableReplacementEntity> entities1 = new ArrayList<>(); |
||||
entities1.add(entity1); |
||||
Assert.assertEquals(FormulaUtils.replace(colcount, entities1), "=COLCOUNT(\"替换\")"); |
||||
|
||||
String colname = "=COLNAME(\"test测试\")"; |
||||
TableReplacementEntity entity2 = new TableReplacementEntity(); |
||||
entity2.setOldName("test测试"); |
||||
entity2.setNewName("替换123"); |
||||
List<TableReplacementEntity> entities2 = new ArrayList<>(); |
||||
entities2.add(entity2); |
||||
Assert.assertEquals(FormulaUtils.replace(colname, entities2), "=COLNAME(\"替换123\")"); |
||||
|
||||
String TABLEDATAFIELDS = "=TABLEDATAFIELDS(\"test测试\")"; |
||||
TableReplacementEntity entity3 = new TableReplacementEntity(); |
||||
entity3.setOldName("test测试"); |
||||
entity3.setNewName("替换111"); |
||||
List<TableReplacementEntity> entities3 = new ArrayList<>(); |
||||
entities3.add(entity3); |
||||
Assert.assertEquals(FormulaUtils.replace(TABLEDATAFIELDS, entities3), "=TABLEDATAFIELDS(\"替换111\")"); |
||||
|
||||
String test = "=sum(len(MAP(value(\"test-测试\",COLNAME(\"test-测试\",len(MAP(value(\"test-测试\",COLNAME(\"test-测试\",len(MAP(value(\"test-测试\",COLNAME(\"test-测试\",2),COLCOUNT(\"test-测试\")),\"test-测试\",COLNAME(\"test-测试\",2),COLNAME(\"test-测试\",4)))),COLCOUNT(\"test-测试\")),\"test-测试\",COLNAME(\"test-测试\",2),COLNAME(\"test-测试\",4)))),COLCOUNT(\"test-测试\")),\"test-测试\",COLNAME(\"test-测试\",2),COLNAME(\"test-测试\",4))),ROWCOUNT(\"test-测试\"),len(TABLEDATAFIELDS(\"test-测试\")))"; |
||||
TableReplacementEntity entity4 = new TableReplacementEntity(); |
||||
entity4.setOldName("test-测试"); |
||||
entity4.setNewName("test-测试的副本"); |
||||
List<TableReplacementEntity> entities4 = new ArrayList<>(); |
||||
entities4.add(entity4); |
||||
Assert.assertEquals(FormulaUtils.replace(test, entities4), "=sum(len(MAP(value(\"test-测试的副本\",COLNAME(\"test-测试的副本\",len(MAP(value(\"test-测试的副本\",COLNAME(\"test-测试的副本\",len(MAP(value(\"test-测试的副本\",COLNAME(\"test-测试的副本\",2),COLCOUNT(\"test-测试的副本\")),\"test-测试的副本\",COLNAME(\"test-测试的副本\",2),COLNAME(\"test-测试的副本\",4)))),COLCOUNT(\"test-测试的副本\")),\"test-测试的副本\",COLNAME(\"test-测试的副本\",2),COLNAME(\"test-测试的副本\",4)))),COLCOUNT(\"test-测试的副本\")),\"test-测试的副本\",COLNAME(\"test-测试的副本\",2),COLNAME(\"test-测试的副本\",4))),ROWCOUNT(\"test-测试的副本\"),len(TABLEDATAFIELDS(\"test-测试的副本\")))"); |
||||
|
||||
|
||||
String testCircle = "=sum(len(MAP(value(\"test-测试1\",COLNAME(\"test-测试2\",len(MAP(value(\"test-测试3\",COLNAME(\"test-测试4\",len(MAP(value(\"test-测试\",COLNAME(\"test-测试\",2),COLCOUNT(\"test-测试\")),\"test-测试\",COLNAME(\"test-测试\",2),COLNAME(\"test-测试\",4)))),COLCOUNT(\"test-测试\")),\"test-测试\",COLNAME(\"test-测试\",2),COLNAME(\"test-测试\",4)))),COLCOUNT(\"test-测试\")),\"test-测试\",COLNAME(\"test-测试\",2),COLNAME(\"test-测试\",4))),ROWCOUNT(\"test-测试\"),len(TABLEDATAFIELDS(\"test-测试\")))"; |
||||
TableReplacementEntity entity5 = new TableReplacementEntity(); |
||||
entity5.setOldName("test-测试"); |
||||
entity5.setNewName("test-测试的副本"); |
||||
TableReplacementEntity entity6 = new TableReplacementEntity(); |
||||
entity6.setOldName("test-测试1"); |
||||
entity6.setNewName("test-测试2"); |
||||
TableReplacementEntity entity7 = new TableReplacementEntity(); |
||||
entity7.setOldName("test-测试2"); |
||||
entity7.setNewName("test-测试3"); |
||||
TableReplacementEntity entity8 = new TableReplacementEntity(); |
||||
entity8.setOldName("test-测试3"); |
||||
entity8.setNewName("test-测试4"); |
||||
List<TableReplacementEntity> entities5 = new ArrayList<>(); |
||||
entities5.add(entity5); |
||||
entities5.add(entity6); |
||||
entities5.add(entity7); |
||||
entities5.add(entity8); |
||||
Assert.assertEquals(FormulaUtils.replace(testCircle, entities5), "=sum(len(MAP(value(\"test-测试2\",COLNAME(\"test-测试3\",len(MAP(value(\"test-测试4\",COLNAME(\"test-测试4\",len(MAP(value(\"test-测试的副本\",COLNAME(\"test-测试的副本\",2),COLCOUNT(\"test-测试的副本\")),\"test-测试的副本\",COLNAME(\"test-测试的副本\",2),COLNAME(\"test-测试的副本\",4)))),COLCOUNT(\"test-测试的副本\")),\"test-测试的副本\",COLNAME(\"test-测试的副本\",2),COLNAME(\"test-测试的副本\",4)))),COLCOUNT(\"test-测试的副本\")),\"test-测试的副本\",COLNAME(\"test-测试的副本\",2),COLNAME(\"test-测试的副本\",4))),ROWCOUNT(\"test-测试的副本\"),len(TABLEDATAFIELDS(\"test-测试的副本\")))"); |
||||
|
||||
} |
||||
} |
||||
Loading…
Reference in new issue