qt
/
weaver-hrm-salary
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'feature/公式' into release/2.8.2.2305.02

This commit is contained in:
钱涛 2023-05-12 09:16:54 +08:00
parent 53f2c1ebb6 3840f26464
commit eaaf6359af
96 changed files with 19899 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
resource/WEB-INF/config/MyBatis.xml Normal file
View File

@ -0,0 +1,42 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"></setting>
<setting name="jdbcTypeForNull" value="NULL"/>
</settings>
<plugins>
<plugin interceptor="weaver.conn.mybatis.MyBatisCachePlugin"></plugin>
</plugins>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="weaver.conn.mybatis.MyBatisDataSourceFactory">
</dataSource>
</environment>
</environments>
<databaseIdProvider type="weaver.conn.mybatis.DatabaseIdProvider">
</databaseIdProvider>
<mappers>
<!--mapper resource="MyBatis/mapper/WorkflowBaseMapper.xml"/-->
<!--package name="*.mapper"></package 不可行，Mybatis不支持通配符，这是spring的ant匹配模式提供的-->
<package name="weaver.conn.mybatis.mapper"></package><!-- 示例Mapper -->
<!-- 项目Mapper -->
<package name="com.weaver.mapper"></package>
<package name="weaver.general.mapper"></package>
<package name="weaver.hrm.mapper"></package>
<package name="weaver.workflow.mapper"></package>
<package name="weaver.interfaces.mapper"></package>
<package name="weaver.portal.mapper"></package>
<package name="com.api.formmode.mybatis.mapper"></package>
<package name="com.cloudstore.dev.api.mapper"></package>
<package name="com.engine.integration.mapper"></package>
<package name="com.engine.salary.mapper"></package>
<package name="com.engine.organization.mapper"></package>
<!-- 需要把现在的配置文件都调整到WEB-INF/config/mapper目录下 -->
<!-- 在WEB-INF/config/mapper目录下配置的xml文件也不必加入这里的package -->
</mappers>
</configuration>

BIN
resource/WEB-INF/lib/QLExpress-3.2.0.jar Normal file
View File

Binary file not shown.

BIN
resource/WEB-INF/lib/pagehelper-5.0.0.jar Normal file
View File

Binary file not shown.

5
resource/WEB-INF/prop/hrmSalary.properties Normal file
View File

@ -0,0 +1,5 @@
log=false
defaultCloseNonStandard149=true
AESEncryptScrect=990EB004A1C862721C1513AE90038C9E
version=2.7.3.2304.01
openFormulaForcedEditing=false

1528
src/com/engine/salary/constant/des.json Normal file
View File

File diff suppressed because it is too large Load Diff

6
src/com/engine/salary/entity/datacollection/bo/AttendQuoteDataBO.java
View File

@ -47,10 +47,10 @@ public class AttendQuoteDataBO {
});
}
// public static SimpleEmployee getCurrentUser4Remote() {
// SimpleEmployee se = UserContext.getCurrentUser();
// public static DataCollectionEmployee getCurrentUser4Remote() {
// DataCollectionEmployee se = UserContext.getCurrentUser();
// if(se != null){
// SimpleEmployee simple = new SimpleEmployee();
// DataCollectionEmployee simple = new DataCollectionEmployee();
// simple.setId(se.getId());
// simple.setUserId(se.getUserId());
// simple.setUsername(se.getUsername());

22
src/com/engine/salary/entity/salaryacct/bo/CalculateFormulaVarBO.java
View File

@ -38,6 +38,8 @@ import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;
import static com.engine.salary.util.SalaryDateUtil.DATE_TIME_FORMATTER_PATTERN;
/**
* 薪资核算-将数据转换成公式中的变量
* <p>Copyright: Copyright (c) 2022</p>
@ -163,7 +165,12 @@ public class CalculateFormulaVarBO {
String fieldId = SalarySQLReferenceEnum.SALARY_CYCLE.getValue()
+ SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR
+ fieldName;
formulaVarValues.add(new FormulaVarValue().setFieldId(fieldId).setFieldValue(map.getOrDefault(fieldName, StringUtils.EMPTY)));
String fieldValue = map.getOrDefault(fieldName, StringUtils.EMPTY);
//日期值取yyyy-MM-dd
if (StringUtils.isNotBlank(fieldValue) && fieldValue.length() > 10 && SalaryDateUtil.parse(fieldValue, DATE_TIME_FORMATTER_PATTERN) != null) {
fieldValue = fieldValue.substring(0, 10);
}
formulaVarValues.add(new FormulaVarValue().setFieldId(fieldId).setFieldValue(fieldValue));
}
}
return formulaVarValues;
@ -210,8 +217,6 @@ public class CalculateFormulaVarBO {
}
/**
* 处理薪资档案（会涉及调薪计薪规则）+处理核算日期
*
@ -228,7 +233,6 @@ public class CalculateFormulaVarBO {
List<FormulaVarValue> formulaVarValues = resultMap.computeIfAbsent(key, k -> Lists.newArrayList());
// 将薪资档案的值转换成公式中的变量，填充到返回结果集中
formulaVarValues.addAll(handleSalaryArchiveItemVal(salaryAcctCalculateBO, salaryArchiveTaxAgentDataDTO.getSalaryItemValues(), salarySobAdjustRulePOMap));
formulaVarValues.addAll(handleSalarySobCycleDTO(salaryAcctCalculateBO));
}
}
}
@ -511,8 +515,16 @@ public class CalculateFormulaVarBO {
String fieldId = SalarySQLReferenceEnum.SALARY_ACCT_EMPLOYEE.getValue()
+ SalaryFormulaFieldConstant.FIELD_ID_SEPARATOR
+ fieldName;
return new FormulaVarValue().setFieldId(fieldId).setFieldValue(map.getOrDefault(fieldName, StringUtils.EMPTY));
String fieldValue = map.getOrDefault(fieldName, StringUtils.EMPTY);
//判断是否是日期，日期值取yyyy-MM-dd
if (StringUtils.isNotBlank(fieldValue) && fieldValue.length() > 10 && SalaryDateUtil.parse(fieldValue, DATE_TIME_FORMATTER_PATTERN) != null) {
fieldValue = fieldValue.substring(0, 10);
}
return new FormulaVarValue().setFieldId(fieldId).setFieldValue(fieldValue);
}).collect(Collectors.toList()));
//将薪资周期转换成公式中的变量，填充到返回结果集中
formulaVarValues.addAll(handleSalarySobCycleDTO(salaryAcctCalculateBO));
});
}

6
src/com/engine/salary/entity/salaryacct/bo/SalaryCheckResultBO.java
View File

@ -8,7 +8,7 @@
//import com.weaver.hrm.salary.entity.salaryacct.po.SalaryCheckResultRecordPO;
//import com.weaver.hrm.salary.entity.salarysob.po.SalarySobCheckRulePO;
//import com.weaver.hrm.salary.util.SalaryEntityUtil;
//import com.weaver.teams.domain.user.SimpleEmployee;
//import com.weaver.teams.domain.user.DataCollectionEmployee;
//import org.apache.commons.collections4.CollectionUtils;
//import org.apache.commons.lang3.StringUtils;
//import org.apache.commons.lang3.math.NumberUtils;
@ -71,13 +71,13 @@
// public static List<SalaryCheckResultRecordListDTO> convert2RecordListDTO(List<SalaryCheckResultRecordPO> salaryCheckResultRecords,
// List<SalarySobCheckRulePO> salarySobCheckRules,
// List<ExpressFormula> expressFormulas,
// List<SimpleEmployee> simpleEmployees) {
// List<DataCollectionEmployee> simpleEmployees) {
// if (CollectionUtils.isEmpty(salaryCheckResultRecords)) {
// return Collections.emptyList();
// }
// Map<Long, String> formulaMap = SalaryEntityUtil.convert2Map(expressFormulas, ExpressFormula::getId, ExpressFormula::getFormula);
// Map<Long, String> checkRuleMap = SalaryEntityUtil.convert2Map(salarySobCheckRules, SalarySobCheckRulePO::getId, SalarySobCheckRulePO::getName);
// Map<Long, String> employeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getEmployeeId, SimpleEmployee::getName);
// Map<Long, String> employeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getEmployeeId, DataCollectionEmployee::getName);
// return salaryCheckResultRecords.stream()
// .map(e -> SalaryCheckResultRecordListDTO.builder()
// .id(e.getId())

6
src/com/engine/salary/enums/salaryformula/SalaryFormulaReferenceEnum.java
View File

@ -24,8 +24,10 @@ public enum SalaryFormulaReferenceEnum implements BaseEnum<String> {
ADD_UP_DEDUCTIONS("addUpDeductions", "累计专项附加扣除", 85380),
WELFARE("welfare", "社保福利", 87522),
OTHER_DEDUCTION("otherDeduction", "其他免税扣除", 93849),
ISSUED("ISSUED", "已发", 0),;
;
SALARY_ACCT_EMPLOYEE("salaryAcctEmployee", "核算基本信息", 85368),
SALARY_CYCLE("SalaryCycle", "核算日期", 85368),
ISSUED("ISSUED", "已发", 0);
private String value;
private String defaultLabel;

18
src/com/engine/salary/formlua/core/QLExpressContext.java Normal file
View File

@ -0,0 +1,18 @@
package com.engine.salary.formlua.core;
import com.ql.util.express.IExpressContext;
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings("serial")
public class QLExpressContext extends HashMap<String, Object> implements
IExpressContext<String, Object> {
public QLExpressContext(Map<String, Object> aProperties) {
super(aProperties);
}
}

276
src/com/engine/salary/formlua/core/QlExpress.java Normal file
View File

@ -0,0 +1,276 @@
package com.engine.salary.formlua.core;
import com.alibaba.fastjson.JSONObject;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.entity.parameter.FuncNames;
import com.engine.salary.formlua.func.compare.*;
import com.engine.salary.formlua.func.date.DateTimeService;
import com.engine.salary.formlua.func.date.DateTimeServiceImpl;
import com.engine.salary.formlua.func.finance.FinanceService;
import com.engine.salary.formlua.func.finance.FinanceServiceImpl;
import com.engine.salary.formlua.func.find.FindFuncsService;
import com.engine.salary.formlua.func.logic.IfOperator;
import com.engine.salary.formlua.func.logic.LogicService;
import com.engine.salary.formlua.func.logic.LogicServiceImpl;
import com.engine.salary.formlua.func.math.MathFuncsService;
import com.engine.salary.formlua.func.math.MathFuncsServiceImpl;
import com.engine.salary.formlua.func.string.StringFormulaService;
import com.engine.salary.formlua.func.string.StringFormulaServiceImpl;
import com.engine.salary.formlua.util.ExpressRegularUtil;
import com.ql.util.express.DynamicParamsUtil;
import com.ql.util.express.ExpressRunner;
import com.ql.util.express.IExpressContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.regex.PatternSyntaxException;
/**
* 执行业务类
*/
public class QlExpress {
public static ExpressRunner runner;
static {
runner = new ExpressRunner(true, false);
}
private static boolean isInitialRunner = false;
// AggregationFunc aggregationFunc;
LogicService logicService = new LogicServiceImpl();
DateTimeService dateTimeService = new DateTimeServiceImpl();
StringFormulaService stringFormulaService = new StringFormulaServiceImpl();
MathFuncsService mathFuncsService = new MathFuncsServiceImpl();
FindFuncsService findFuncsService;
// private ExcelFuncs excelFuncs;
//
// private HrmDbService hrmDbService;
private FinanceService financeService = new FinanceServiceImpl();
// private RemoteExcelformulaService remoteExcelformulaService;
private String errorInfo;
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
/**
* @param statement 执行语句
* @param context 上下文
* @throws Exception
*/
public Object execute(String statement, Map<String, Object> context) {
String expressSql = statement;
initRunner(runner);
DynamicParamsUtil.supportDynamicParams = true;
//初步的语法的格式校验
IExpressContext<String, Object> expressContext = new QLExpressContext(context);
// ThreadLocalData threadLocalData=new ThreadLocalData();
// threadLocalData.setExpressContext(context);
// ParamContext.get().setValue("formulaParam",threadLocalData);
// ParamContext.get().setValue("currentUser",simpleEmployee);
try {
ExpressRegularUtil.checkFuncExpress(expressSql);
expressSql = expressSql.replaceAll("\\{", "");
expressSql = expressSql.replaceAll("\\}", "");
Object obj = runner.execute(expressSql, expressContext, null, true, false);
JSONObject resultObj = new JSONObject();
if (obj != null) {
resultObj.put("excute", true);
if (obj instanceof DataType) {
DataType dataType = (DataType) obj;
resultObj.put("data", dataType.getContent());
resultObj.put("dataType", dataType.getDataType());
resultObj.put("boolData", dataType.getContent());
} else {
resultObj.put("data", obj);
resultObj.put("boolData", obj);
}
} else {
resultObj.put("excute", false);
}
return resultObj;
} catch (Throwable e) {
logger.error("err", e);
while (e != null) {
e = e.getCause();
}
String jsonError = e.getMessage();
if (e instanceof PatternSyntaxException) {
PatternSyntaxException patternSyntaxException = (PatternSyntaxException) e;
jsonError = patternSyntaxException.getDescription();
} else {
if (null != e.getCause()) {
jsonError = e.getCause().getMessage();
if (e.getCause() instanceof InvocationTargetException) {
InvocationTargetException invocationTargetException = (InvocationTargetException) e.getCause();
jsonError = invocationTargetException.getTargetException().getMessage();
}
}
}
JSONObject resultObj = new JSONObject();
resultObj.put("excute", false);
resultObj.put("data", "");
resultObj.put("err", jsonError);
return resultObj;
}
}
private void initRunner(ExpressRunner runner) {
if (isInitialRunner) {
return;
}
synchronized (runner) {
if (isInitialRunner) {
return;
}
try {
//比较函数
runner.replaceOperator("=", new EqOperator("="));
runner.replaceOperator("==", new EqOperator("="));
runner.replaceOperator("!=", new NotEqueOperator("!="));
runner.replaceOperator(">", new GreaterOperator(">"));
runner.replaceOperator("<", new LessOperator("<"));
runner.replaceOperator(">=", new GreaterEqOperator(">="));
runner.replaceOperator("<=", new LessEqOperator("<="));
runner.replaceOperator("+", new WOperatorAdd("+"));
runner.replaceOperator("-", new WOperatorReduce("-"));
runner.replaceOperator("*", new WOperatorMulti("*"));
runner.replaceOperator("/", new WOperatorDiv("/"));
//逻辑函数
runner.replaceOperator("IF", new IfOperator("IF"));
runner.addFunctionOfServiceMethod(FuncNames.AND.toString(), logicService, FuncNames.AND.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.OR.toString(), logicService, FuncNames.OR.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.NOT.toString(), logicService, FuncNames.NOT.getName(), new Class[]{Object[].class}, "");
runner.replaceOperator("IN", new InOperator("in"));
runner.addFunctionOfServiceMethod(FuncNames.LIKE.toString(), logicService, FuncNames.LIKE.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.ISEMPTY.toString(), logicService, FuncNames.ISEMPTY.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.TRUE.toString(), logicService, FuncNames.TRUE.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.FALSE.toString(), logicService, FuncNames.FALSE.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.IFS.toString(), logicService, FuncNames.IFS.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.SWITCH.toString(), logicService, FuncNames.SWITCH.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.FIND.toString(), logicService, FuncNames.FIND.getName(), new Class[]{Object[].class}, "");
//日期函数
runner.addFunctionOfServiceMethod("TODAY", dateTimeService, "today", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("NOW", dateTimeService, "now", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("DATEADD", dateTimeService, "dateAdd", new Class[]{Object[].class}, errorInfo);
runner.addFunctionOfServiceMethod("DATEDIFF", dateTimeService, "dateDiff", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("DATEFORMAT", dateTimeService, "dateFormat", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("YEAR", dateTimeService, "year", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("MONTH", dateTimeService, "month", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("DAY", dateTimeService, "day", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("HOUR", dateTimeService, "hour", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("MINUTE", dateTimeService, "minute", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("SECOND", dateTimeService, "seconds", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("WEEKNUM", dateTimeService, "weekNum", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("WEEKDAY", dateTimeService, "weekDay", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("EOMONTH", dateTimeService, "eoMonth", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod("NETWORKDAYSPI", dateTimeService, "workdayIntl", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("CURRYEAR", dateTimeService, "currYear", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("CURRMONTH", dateTimeService, "currMonth", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("CURRDAY", dateTimeService, "currDay", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("CURRWEEK", dateTimeService, "currWeek", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("CURRHOUR", dateTimeService, "currHour", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("CURRMINUTE", dateTimeService, "currMinute", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("CURRSECOND", dateTimeService, "currSecond", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("MAXDATE", dateTimeService, "maxDate", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("MINDATE", dateTimeService, "minDate", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod("DAYOFMONTH", dateTimeService, "dayOfMonth", new Class[]{Object[].class}, "");
//聚合函数
// runner.addFunctionOfServiceMethod("COUNT", aggregationFunc, "counts", new Class[]{Object[].class}, "COUNT参数错误");
// runner.addFunctionOfServiceMethod("AVG", aggregationFunc, "avgs", new Class[]{Object[].class}, "AVG参数错误");
// runner.addFunctionOfServiceMethod("SUM", aggregationFunc, "sumNumber", new Class[]{Object[].class}, "SUM参数错误");
// runner.addFunctionOfServiceMethod("MAX", aggregationFunc, "maxNumber", new Class[]{Object[].class}, "MAX参数错误");
// runner.addFunctionOfServiceMethod("MIN", aggregationFunc, "minNumber", new Class[]{Object[].class}, "MIN参数错误");
//字符串函数
runner.addFunctionOfServiceMethod("CONCAT", stringFormulaService, "concatString", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("SEARCH", stringFormulaService, "search", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("TEXT", stringFormulaService, "text", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("PAD", stringFormulaService, "pad", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("REPLACE", stringFormulaService, "replace", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("VALUE", stringFormulaService, "value", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("LEN", stringFormulaService, "len", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("LEFT", stringFormulaService, "left", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("RIGHT", stringFormulaService, "right", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("MID", stringFormulaService, "mid", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("REPT", stringFormulaService, "repeat", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("TRIM", stringFormulaService, "trim", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("SCORE", stringFormulaService, "score", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("IDCARD", stringFormulaService, "idCard", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.ISSTRING.toString(), stringFormulaService, FuncNames.ISSTRING.getName(), new Class[]{Object[].class}, "");
//数学函数
runner.addFunctionOfServiceMethod("ROUNDUP", mathFuncsService, "roundUp", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("ROUND", mathFuncsService, "round", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod("ROUNDDOWN", mathFuncsService, "roundDown", new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.AGGREGATION.toString(), mathFuncsService, FuncNames.AGGREGATION.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.MOD.toString(), mathFuncsService, FuncNames.MOD.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.TRUNC.toString(), mathFuncsService, FuncNames.TRUNC.getName(), new Class[]{Object.class, Object.class}, "");
runner.addFunctionOfServiceMethod(FuncNames.ISINT.toString(), mathFuncsService, FuncNames.ISINT.getName(), new Class[]{Object[].class}, "");
runner.addFunctionOfServiceMethod(FuncNames.ISNUMBER.toString(), mathFuncsService, FuncNames.ISNUMBER.getName(), new Class[]{Object[].class}, "");
//查找函数
// runner.addFunctionOfServiceMethod(FuncNames.CHOOSE.toString(), findFuncsService, "chooseOne", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.MATCH.toString(), findFuncsService, "match", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.VLOOKUPS.toString(), findFuncsService, "vlookups", new Class[]{Object[].class}, "");
//数据库函数-hrm
// runner.addFunctionOfServiceMethod(FuncNames.GETHRMNAME.toString(), hrmDbService, FuncNames.GETHRMNAME.getName(), new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETHRMMOBILE.toString(), hrmDbService, FuncNames.GETHRMMOBILE.getName(), new Class[]{Object[].class}, "");
//财务函数
runner.addFunctionOfServiceMethod(FuncNames.GETMONEY.toString(), financeService, FuncNames.GETMONEY.getName(), new Class[]{Object[].class}, "");
//数据库函数-hrm
// runner.addFunctionOfServiceMethod(FuncNames.GETHRMLOGINID.toString(), hrmDbService, "getHrmLoginId", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETHRMWORKCODE.toString(), hrmDbService, "getHrmWorkcode", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETHRMMANAGER.toString(), hrmDbService, "getHrmManager", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETHRMALLMANAGER.toString(), hrmDbService, "getHrmAllManager", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETHRMDEPARTMENT.toString(), hrmDbService, "getHrmDepartment", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETHRMSUBCOMPANY.toString(), hrmDbService, "getHrmSubcompany", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETDEPARTMENTNAME.toString(), hrmDbService, "getDepartmentName", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETDEPARTMENTCODE.toString(), hrmDbService, "getDepartmentCode", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETSUPERDEPARTMENT.toString(), hrmDbService, "getSuperDepartment", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETALLSUPERDEPARTMENT.toString(), hrmDbService, "getAllSuperDepartment", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETSUBCOMPANYNAME.toString(), hrmDbService, "getSubcompanyName", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETSUBCOMPANYCODE.toString(), hrmDbService, "getSubcompanyCode", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETSUPERSUBCOMPANY.toString(), hrmDbService, "getSuperSubcompany", new Class[]{Object[].class}, "");
// runner.addFunctionOfServiceMethod(FuncNames.GETALLSUPERSUBCOMPANY.toString(), hrmDbService, "getAllSuperSubcompany", new Class[]{Object[].class}, "");
//加载模块自定义函数
// try {
// List<ExcelFunc> otherFuncList=excelFuncs.getOtherFuncs();
// if(otherFuncList!=null && otherFuncList.size()>0){
// //为每个方法实例化一个ExcelExtendFuncService
// for (ExcelFunc excelFunc:otherFuncList){
// //每个接口调度类实例化时指定模块和函数名
// ExcelExtendFuncService excelExtendFuncService=new ExcelExtendFuncServiceImpl(excelFunc.getModule(),excelFunc.getName());
// //将自定义函数放入context上下文中
// runner.addFunctionOfServiceMethod(excelFunc.getName(),excelExtendFuncService, RpcMethod.execute.toString(),new Class[]{Object[].class},"");
// }
// }
// } catch (Exception e) {
// logger.error("err",e);
// }
} catch (Exception e) {
logger.error("err", e);
throw new RuntimeException("初始化失败表达式");
}
}
isInitialRunner = true;
}
}

27
src/com/engine/salary/formlua/core/QlExpressTest.java Normal file
View File

@ -0,0 +1,27 @@
package com.engine.salary.formlua.core;
import com.alibaba.fastjson.JSONObject;
import java.util.HashMap;
import java.util.Map;
/**
* 执行业务类
*/
public class QlExpressTest {
public static void main(String[] args) {
QlExpress express = new QlExpress();
Map<String, Object> context = new HashMap<>();
context.put("a", 1);
context.put("b", 2);
context.put("c", 3);
String formula = "IF(1=1,1,2)";
Object execute = express.execute(formula, context);
if(execute instanceof JSONObject){
Object data = ((JSONObject) execute).get("data");
System.out.println(data);
}
}
}

70
src/com/engine/salary/formlua/core/exception/ErrorType.java Normal file
View File

@ -0,0 +1,70 @@
package com.engine.salary.formlua.core.exception;
import com.engine.salary.util.SalaryI18nUtil;
public enum ErrorType {
/**
* 函数参数不能为空
*/
NOT_NULL(SalaryI18nUtil.getI18nLabel(91326, "函数参数不能为空")),
/**
* 参数不能为空
*/
VAR_NOT_NULL(SalaryI18nUtil.getI18nLabel(32804, "参数不能为空")),
/**
* 函数参数错误,参数类型需为数字字段
*/
MUST_NUM(SalaryI18nUtil.getI18nLabel(91327, "函数参数错误,参数类型需为数字字段")),
/**
* 函数参数类型错误,参数需为表格
*/
MUST_FORM(SalaryI18nUtil.getI18nLabel(91330, "函数参数类型错误,参数需为表格")),
/**
*
*/
MUST_FORM_FIELD(SalaryI18nUtil.getI18nLabel(91331, "函数参数错误,参数类型需为表格字段")),
CANT_FORM_FIELD(SalaryI18nUtil.getI18nLabel(91427, "比较操作符参数不能是表格字段")),
/**
*
*/
CND_NOT_NULL(SalaryI18nUtil.getI18nLabel(11575, "条件不能为空")),
/**
*
*/
MIN_VAR_COUNT(SalaryI18nUtil.getI18nLabel(91332, "函数的最少参数个数")),
/**
*
*/
MAX_VAR_COUNT(SalaryI18nUtil.getI18nLabel(91333, "函数的最多参数个数")),
/**
*
*/
CANNOT_HAVE_VAR(SalaryI18nUtil.getI18nLabel(91334, "函数不能有参数")),
/**
*
*/
RETURN_TYPE_DIFF(SalaryI18nUtil.getI18nLabel(91335, "函数多个条件的返回值必须一致")),
/**
*
*/
VAR_COUNT_MUST_Odd(SalaryI18nUtil.getI18nLabel(91336, "函数最后一个参数需为默认返回值")),
/**
*
*/
VAR_TYPE_WRONG(SalaryI18nUtil.getI18nLabel(91337, "函数参数类型错误")),
/**
*
*/
VAR_MUST_HAVE_DATE(SalaryI18nUtil.getI18nLabel(91338, "函数日期参数必须包含年月日")),
/**
*
*/
VAR_TYPE_MUST_BE(SalaryI18nUtil.getI18nLabel(91339, "函数参数类型错误，参数类型需为")),
/**
*
*/
CANNOT_FIND_TEN(SalaryI18nUtil.getI18nLabel(91361, "函数未能获取到租户"));
ErrorType(String name) {
}
}

24
src/com/engine/salary/formlua/core/exception/ExcelRunTimeException.java Normal file
View File

@ -0,0 +1,24 @@
package com.engine.salary.formlua.core.exception;
public class ExcelRunTimeException extends Exception{
private String info;
public ExcelRunTimeException(String info) {
super(info,new Exception(info));
this.info = info;
}
public ExcelRunTimeException() {
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}

17
src/com/engine/salary/formlua/entity/parameter/DataType.java
View File

@ -1,6 +1,7 @@
package com.engine.salary.formlua.entity.parameter;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.formlua.entity.standard.FormulaFilterData;
import java.io.Serializable;
import java.util.ArrayList;
@ -79,7 +80,7 @@ public class DataType implements Serializable {
/**
* 高级搜索条件，由函数的逻辑操作符和逻辑函数构建，模块不需要处理
*/
// List<FormulaFilterData> formulaFilterDataList=null;
List<FormulaFilterData> formulaFilterDataList=null;
private List<String> subLogic=new ArrayList<>();
public static boolean checkType(String dataTypeL,String dataTypeR){
if(returnType(dataTypeL).equalsIgnoreCase(dataTypeR)){
@ -268,11 +269,11 @@ public class DataType implements Serializable {
this.subFormData = subFormData;
}
// public List<FormulaFilterData> getFormulaFilterDataList() {
// return formulaFilterDataList;
// }
//
// public void setFormulaFilterDataList(List<FormulaFilterData> formulaFilterDataList) {
// this.formulaFilterDataList = formulaFilterDataList;
// }
public List<FormulaFilterData> getFormulaFilterDataList() {
return formulaFilterDataList;
}
public void setFormulaFilterDataList(List<FormulaFilterData> formulaFilterDataList) {
this.formulaFilterDataList = formulaFilterDataList;
}
}

5
src/com/engine/salary/formlua/entity/parameter/DateAndString.java Normal file
View File

@ -0,0 +1,5 @@
package com.engine.salary.formlua.entity.parameter;
public class DateAndString {
}

138
src/com/engine/salary/formlua/entity/parameter/ExcelFunc.java Normal file
View File

@ -0,0 +1,138 @@
package com.engine.salary.formlua.entity.parameter;
import com.alibaba.fastjson.JSONObject;
public class ExcelFunc {
private String name;//函数名称
private String chineseName;//中文
private String description;//函数描述
private String formatString;//函数格式
private String[] paramArray;//函数参数列表
private String[] paramData;//参数默认数据
private String returnType;//返回类型
private String type="function";//
private String validForm;//有效的表单类型 current用户当前表单、all 用户所有表单
private JSONObject jsonFormat;
private String module;
public ExcelFunc(){}
/**
*
* @param name 名称
* @param description 描述
* @param formatString 格式
* @param paramArray 参数列表
* @param returnType 返回类型
*/
public ExcelFunc(String name,String chineseName, String description, String formatString, String[] paramArray,String[] paramData, String returnType,JSONObject jsonFormat,String validForm) {
this.name = name;
this.chineseName=chineseName;
this.description = description;
this.formatString = formatString;
this.paramArray = paramArray;
this.returnType = returnType;
this.jsonFormat=jsonFormat;
this.paramData=paramData;
this.validForm=validForm;
}
public ExcelFunc(String name,String chineseName, String description, String formatString, String[] paramArray,String[] paramData, String returnType,String validForm) {
this.name = name;
this.chineseName=chineseName;
this.description = description;
this.formatString = formatString;
this.paramArray = paramArray;
this.returnType = returnType;
this.paramData=paramData;
this.validForm=validForm;
}
public String getModule() {
return module;
}
public void setModule(String module) {
this.module = module;
}
public String getValidForm() {
return validForm;
}
public void setValidForm(String validForm) {
this.validForm = validForm;
}
public String getChineseName() {
return chineseName;
}
public void setChineseName(String chineseName) {
this.chineseName = chineseName;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getFormatString() {
return formatString;
}
public void setFormatString(String formatString) {
this.formatString = formatString;
}
public String[] getParamArray() {
return paramArray;
}
public void setParamArray(String[] paramArray) {
this.paramArray = paramArray;
}
public String getReturnType() {
return returnType;
}
public void setReturnType(String returnType) {
this.returnType = returnType;
}
public JSONObject getJsonFormat() {
return jsonFormat;
}
public void setJsonFormat(JSONObject jsonFormat) {
this.jsonFormat = jsonFormat;
}
public String[] getParamData() {
return paramData;
}
public void setParamData(String[] paramData) {
this.paramData = paramData;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}

467
src/com/engine/salary/formlua/entity/parameter/ExcelFuncs.java Normal file
View File

@ -0,0 +1,467 @@
package com.engine.salary.formlua.entity.parameter;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.engine.salary.util.SalaryI18nUtil;
import org.apache.commons.compress.utils.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.LinkedList;
import java.util.List;
@Component
public class ExcelFuncs {
protected final Logger logger = LoggerFactory.getLogger(getClass());
final static private String ALLFORM="all";
final static private String CURRENTDATA="current_data";
static String normalStr="{\"key\":\"\",\"fieldId\":\"\",\"componentKey\":\"\",\"term\":\"\",\"formId\":\"\",\"content\":\"\",\"fieldType\":\"\"}";
static public JSONObject normalJson= JSON.parseObject(normalStr);
static private String[] nullParamDatas=new String[]{};
static private String[] paramDatas=new String[]{};
static private String[] allParamDatas=new String[]{"{}","[]"};
static private String[] moduleList=new String[]{"biaoge","workflow"};
private FuncDescUtil funcDescUtil;
public List<ExcelFunc> getCompList(){
//比较操作符
List<ExcelFunc> compList=new LinkedList<>();
ExcelFunc excelFunc=null;
String [] paramArray=new String[]{};
excelFunc=new ExcelFunc(">",SalaryI18nUtil.getI18nLabel(12132,"大于"), "","",paramArray,paramDatas,"Boolean",CURRENTDATA);
compList.add(excelFunc);
excelFunc=new ExcelFunc(">=",SalaryI18nUtil.getI18nLabel(27694,"大于等于"), "","",paramArray,paramDatas,"Boolean",CURRENTDATA);
compList.add(excelFunc);
excelFunc=new ExcelFunc("<",SalaryI18nUtil.getI18nLabel(20009,"小于"), "","",paramArray,paramDatas,"Boolean",CURRENTDATA);
compList.add(excelFunc);
excelFunc=new ExcelFunc("<=",SalaryI18nUtil.getI18nLabel(15251,"小于等于"), "","",paramArray,paramDatas,"Boolean",CURRENTDATA);
compList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("=",SalaryI18nUtil.getI18nLabel(15112,"等于"), "","",paramArray,paramDatas,"Boolean",CURRENTDATA);
compList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("!=", SalaryI18nUtil.getI18nLabel(14897,"不等于"), "","",paramArray,paramDatas,"Boolean",CURRENTDATA);
compList.add(excelFunc);
return compList;
}
/**
* 日期函数的列表
* @return
*/
public List<ExcelFunc> getDateList(){
//日期函数
List<ExcelFunc> dateList=new LinkedList<>();
ExcelFunc excelFunc=null;
String [] paramArray=new String[]{};
excelFunc=new ExcelFunc("TODAY",SalaryI18nUtil.getI18nLabel(94924,"当前日期"), funcDescUtil.get("TODAY"),"TODAY()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("NOW",SalaryI18nUtil.getI18nLabel(94925,"当前日期时间"), funcDescUtil.get("NOW"),"NOW()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("DATEADD",SalaryI18nUtil.getI18nLabel(94926,"对日期加减年、月、日"), funcDescUtil.get("DATEADD"),"DATEADD(日期, 数值, ['单位'])",nullParamDatas,paramArray,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("DATEDIFF",SalaryI18nUtil.getI18nLabel(94927,"返回两个日期的差值"), funcDescUtil.get("DATEDIFF"),"DATEDIFF(日期1, 日期2, ['单位'])",nullParamDatas,paramArray,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("DATEFORMAT",SalaryI18nUtil.getI18nLabel(94928,"返回指定格式的日期"), funcDescUtil.get("DATEFORMAT"),"DATEFORMAT(日期, '可选格式')",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("YEAR",SalaryI18nUtil.getI18nLabel(94929,"返回日期中的年"), funcDescUtil.get("YEAR"),"YEAR(日期)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{"String"};
excelFunc=new ExcelFunc("MONTH",SalaryI18nUtil.getI18nLabel(94930,"返回日期中的月"), funcDescUtil.get("MONTH"),"MONTH(日期)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("DAY",SalaryI18nUtil.getI18nLabel(94931,"返回日期中的日"), funcDescUtil.get("DAY"),"DAY(日期)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("HOUR",SalaryI18nUtil.getI18nLabel(94932,"返回日期中的小时"), funcDescUtil.get("HOUR"),"HOUR(日期)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("MINUTE",SalaryI18nUtil.getI18nLabel(94933,"返回日期中的分钟"), funcDescUtil.get("MINUTE"),"MINUTE(日期)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("SECOND",SalaryI18nUtil.getI18nLabel(94934,"返回日期中的秒"), funcDescUtil.get("SECOND"),"SECOND(日期)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("WEEKNUM",SalaryI18nUtil.getI18nLabel(94936,"返回日期为第几周"), funcDescUtil.get("WEEKNUM"),"WEEKNUM(日期)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("WEEKDAY",SalaryI18nUtil.getI18nLabel(94937,"返回日期为星期几"), funcDescUtil.get("WEEKDAY"),"WEEKDAY(日期)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("NETWORKDAYSPI",SalaryI18nUtil.getI18nLabel(94938,"返回指定日期之间包含的工作日天数（仅限的过去时间）"), funcDescUtil.get("NETWORKDAYSPI"),"NETWORKDAYSPI(日期1, 日期2, 成员)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("EOMONTH",SalaryI18nUtil.getI18nLabel(94939,"返回某月最后一天日期"), funcDescUtil.get("EOMONTH"),"EOMONTH(日期，指定日期之前或之后的月数)",paramArray,nullParamDatas,"Number",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("CURRYEAR",SalaryI18nUtil.getI18nLabel(101059,"返回当前年份"), funcDescUtil.get("CURRYEAR"),"CURRYEAR()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("CURRMONTH",SalaryI18nUtil.getI18nLabel(101060,"返回当前月份"), funcDescUtil.get("CURRMONTH"),"CURRMONTH()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("CURRDAY",SalaryI18nUtil.getI18nLabel(101061,"返回当前第几日（当月）"), funcDescUtil.get("CURRDAY"),"CURRDAY()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("CURRWEEK",SalaryI18nUtil.getI18nLabel(101062,"返回当前是周几"), funcDescUtil.get("CURRWEEK"),"CURRWEEK()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("CURRHOUR",SalaryI18nUtil.getI18nLabel(101063,"返回当前小时"), funcDescUtil.get("CURRHOUR"),"CURRHOUR()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("CURRMINUTE",SalaryI18nUtil.getI18nLabel(101064,"返回当前分"), funcDescUtil.get("CURRMINUTE"),"CURRMINUTE()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("CURRSECOND",SalaryI18nUtil.getI18nLabel(101065,"返回当前秒"), funcDescUtil.get("CURRSECOND"),"CURRSECOND()",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("MAXDATE",SalaryI18nUtil.getI18nLabel(100803,"返回一组日期中的最大值"), funcDescUtil.get("MAXDATE"),"MAXDATE(日期1，日期2，……)",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("MINDATE",SalaryI18nUtil.getI18nLabel(100805,"返回一组日期中的最小值"), funcDescUtil.get("MINDATE"),"MINDATE(日期1，日期2，……)",paramArray,nullParamDatas,"String",CURRENTDATA);
dateList.add(excelFunc);
return dateList;
}
/**
* 逻辑函数的列表
* @return
*/
public List<ExcelFunc> getLogicList(){
//逻辑函数
List<ExcelFunc> logicList=new LinkedList<>();
ExcelFunc excelFunc=null;
String [] paramArray=new String[]{};
excelFunc=new ExcelFunc("IF",SalaryI18nUtil.getI18nLabel(94940,"如果条件为真，则...否则..."), funcDescUtil.get("IF"),"IF(条件, 表达式1, 表达式2)",paramArray,nullParamDatas,"Object",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("AND",SalaryI18nUtil.getI18nLabel(51100,"且"), funcDescUtil.get("AND"),"AND(条件1, 条件2, [条件3, …])",paramArray,nullParamDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("OR",SalaryI18nUtil.getI18nLabel(35824,"或"), funcDescUtil.get("OR"),"OR(条件1, 条件2, [条件3, …])",paramArray,nullParamDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("NOT",SalaryI18nUtil.getI18nLabel(94942,"反转真假结果"), funcDescUtil.get("NOT"),"NOT(逻辑结果)",paramArray,nullParamDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("IN",SalaryI18nUtil.getI18nLabel(94943,"变量是否包含在一组结果中"), funcDescUtil.get("IN"),"IN(变量, [变量1, 变量2, …])",paramArray,allParamDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("LIKE",SalaryI18nUtil.getI18nLabel(94944,"文本是否包含任意一个关键字"), funcDescUtil.get("LIKE"),"LIKE(文本, [文本1, 文本2, …])",paramArray,allParamDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("ISEMPTY",SalaryI18nUtil.getI18nLabel(94945,"是否为空"), funcDescUtil.get("ISEMPTY"),"ISEMPTY(变量)",paramArray,paramDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("TRUE",SalaryI18nUtil.getI18nLabel(94946,"返回真"), funcDescUtil.get("TRUE"),"TRUE()",paramArray,nullParamDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("FALSE",SalaryI18nUtil.getI18nLabel(94947,"返回假"), funcDescUtil.get("FALSE"),"FALSE()",paramArray,nullParamDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("IFS",SalaryI18nUtil.getI18nLabel(94948,"多条件"), funcDescUtil.get("IFS"),"IFS({条件1},{结果1},{条件2},{结果2}...{默认结果})",paramArray,nullParamDatas,"Object",CURRENTDATA);
logicList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("FIND",SalaryI18nUtil.getI18nLabel(31835,"查找"), funcDescUtil.get("FIND"),"FIND([{查找值1},{查找值2}...{查找值N}],[{查找目标1},{查找目标2}...{查找目标N}])",paramArray,nullParamDatas,"Boolean",CURRENTDATA);
logicList.add(excelFunc);
return logicList;
}
/**
* 字符函数的列表
* @return
*/
public List<ExcelFunc> getStringList(){
//字符函数
List<ExcelFunc> stringList=new LinkedList<>();
ExcelFunc excelFunc=null;
String [] paramArray=new String[]{};
excelFunc=new ExcelFunc("CONCAT",SalaryI18nUtil.getI18nLabel(94949,"链接多个文本"), funcDescUtil.get("CONCAT"),"CONCAT(文本1, 文本2, [文本3, …])",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("TEXT",SalaryI18nUtil.getI18nLabel(94950,"将变量转为文本"), funcDescUtil.get("TEXT"),"TEXT(变量)",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("VALUE",SalaryI18nUtil.getI18nLabel(94951,"将文本转为数字"), funcDescUtil.get("VALUE"),"VALUE(文本)",paramArray,nullParamDatas,"Number",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("LEN",SalaryI18nUtil.getI18nLabel(94952,"返回文本长度"), funcDescUtil.get("LEN"),"LEN(文本)",paramArray,nullParamDatas,"Number",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("SEARCH",SalaryI18nUtil.getI18nLabel(94953,"在文本中查找关键字"), funcDescUtil.get("SEARCH"),"SEARCH(关键字, 文本, [搜索开始位置])",paramArray,nullParamDatas,"Number",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("REPLACE",SalaryI18nUtil.getI18nLabel(94954,"替换文本中的字"), funcDescUtil.get("REPLACE"),"REPLACE(原文本, 替换开始位置, 替换字符数, 新文本)",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("REPT",SalaryI18nUtil.getI18nLabel(94955,"将文本重复指定次数"), funcDescUtil.get("REPT"),"REPT(文本, 重复次数)",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("PAD",SalaryI18nUtil.getI18nLabel(94956,"将文本填充至指定长度"), funcDescUtil.get("PAD"),"PAD(原文本, 长度, 填充用的文本, ['填充位置'])",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("TRIM",SalaryI18nUtil.getI18nLabel(94957,"清除前后空格"), funcDescUtil.get("TRIM"),"TRIM(文本)",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("LEFT",SalaryI18nUtil.getI18nLabel(94958,"返回文本左侧开始的文字"), funcDescUtil.get("LEFT"),"LEFT(文本, 截取字符数)",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("RIGHT",SalaryI18nUtil.getI18nLabel(94959,"返回文本右侧开始的文字"), funcDescUtil.get("RIGHT"),"RIGHT(文本, 截取字符数)",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("MID",SalaryI18nUtil.getI18nLabel(94960,"返回文本指定位置开始的文字"), funcDescUtil.get("MID"),"MID(文本, 指定位置, 截取字符数)",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("SCORE",SalaryI18nUtil.getI18nLabel(94961,"获取选项型控件分数"), funcDescUtil.get("SCORE"),"SCORE({选项型控件})",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("IDCARD",SalaryI18nUtil.getI18nLabel(94962,"身份证函数"), funcDescUtil.get("IDCARD"),"IDCARD({身份证号码}, {查找类型})",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("ISSTRING",SalaryI18nUtil.getI18nLabel(0,"是否是字符串"), funcDescUtil.get("ISSTRING"),"ISSTRING({任意控件})",paramArray,nullParamDatas,"String",CURRENTDATA);
stringList.add(excelFunc);
// paramArray=new String[]{};
// excelFunc=new ExcelFunc("SUBSTRING",SalaryI18nUtil.getI18nLabel(97524,"字符截取函数"), funcDescUtil.get("SUBSTRING"),"SUBSTRING({源字符}, {截取开始位置},{截取结束位置})",paramArray,nullParamDatas,"String",CURRENTDATA);
// stringList.add(excelFunc);
// paramArray=new String[]{};
// excelFunc=new ExcelFunc("SUBSTITUE",SalaryI18nUtil.getI18nLabel(97525,"字符查找替换函数"), funcDescUtil.get("SUBSTITUE"),"SUBSTITUE({源字符}, {被替换字符},{新字符})",paramArray,nullParamDatas,"String",CURRENTDATA);
// stringList.add(excelFunc);
// paramArray=new String[]{};
// excelFunc=new ExcelFunc("LOWER",SalaryI18nUtil.getI18nLabel(97526,"字符转小写函数"), funcDescUtil.get("LOWER"),"LOWER({源字符})",paramArray,nullParamDatas,"String",CURRENTDATA);
// stringList.add(excelFunc);
// paramArray=new String[]{};
// excelFunc=new ExcelFunc("UPPER",SalaryI18nUtil.getI18nLabel(97527,"字符转大写函数"), funcDescUtil.get("UPPER"),"UPPER({源字符})",paramArray,nullParamDatas,"String",CURRENTDATA);
// stringList.add(excelFunc);
// paramArray=new String[]{};
// excelFunc=new ExcelFunc("EXACT",SalaryI18nUtil.getI18nLabel(97528,"字符比较函数"), funcDescUtil.get("EXACT"),"EXACT({字符1}, {字符2})",paramArray,nullParamDatas,"String",CURRENTDATA);
// stringList.add(excelFunc);
return stringList;
}
/**
* 数学函数的列表
* @return
*/
public List<ExcelFunc> getMathList(){
List<ExcelFunc> mathList=new LinkedList<>();
ExcelFunc excelFunc=null;
String [] paramArray=new String[]{};
excelFunc=new ExcelFunc("ROUNDUP",SalaryI18nUtil.getI18nLabel(94963,"向上舍入"), funcDescUtil.get("ROUNDUP"),"ROUNDUP(数值, [小数位精确度])",paramArray,nullParamDatas,"Number",CURRENTDATA);
mathList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("ROUND",SalaryI18nUtil.getI18nLabel(17392,"四舍五入"), funcDescUtil.get("ROUND"),"ROUND(数值, [小数位精确度])",paramArray,nullParamDatas,"Number",CURRENTDATA);
mathList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("ROUNDDOWN",SalaryI18nUtil.getI18nLabel(94964,"向下舍入"), funcDescUtil.get("ROUNDDOWN"),"ROUNDDOWN(数值, [小数位精确度])",paramArray,nullParamDatas,"Number",CURRENTDATA);
mathList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("AGGREGATION",SalaryI18nUtil.getI18nLabel(94965,"聚合运算"), funcDescUtil.get("AGGREGATION"),"AGGREGATION({数字}...,{聚合运算类型})",paramArray,nullParamDatas,"Number",CURRENTDATA);
mathList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("MOD",SalaryI18nUtil.getI18nLabel(94966,"求余"), funcDescUtil.get("MOD"),"ROUNDDOWN({数字},{数字})",paramArray,nullParamDatas,"Number",CURRENTDATA);
mathList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("TRUNC",SalaryI18nUtil.getI18nLabel(94967,"数字格式化"), funcDescUtil.get("TRUNC"),"ROUNDDOWN({数字},{精度})",paramArray,nullParamDatas,"Number",CURRENTDATA);
mathList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("ISINT",SalaryI18nUtil.getI18nLabel(0,"字符内容是否是整数"), funcDescUtil.get("ISINT"),"ISINT({字符})",paramArray,nullParamDatas,"String",CURRENTDATA);
mathList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("ISNUMBER",SalaryI18nUtil.getI18nLabel(0,"字符内容是否是数字"), funcDescUtil.get("ISNUMBER"),"ISNUMBER({字符})",paramArray,nullParamDatas,"String",CURRENTDATA);
mathList.add(excelFunc);
return mathList;
}
/**
* 查找函数的列表
* @return
*/
public List<ExcelFunc> getFindList(){
List<ExcelFunc> findList=new LinkedList<>();
ExcelFunc excelFunc=null;
String [] paramArray=new String[]{};
excelFunc=new ExcelFunc("CHOOSE",SalaryI18nUtil.getI18nLabel(94968,"返回索引范围内指定的值"), funcDescUtil.get("CHOOSE"),"CHOOSE(数据源，[条件])",paramArray,nullParamDatas,"Array",CURRENTDATA);
findList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("VLOOKUPS",SalaryI18nUtil.getI18nLabel(94969,"按列查找，返回所需值"), funcDescUtil.get("VLOOKUPS"),"VLOOKUPS（表，[条件]，[返回参数]）",paramArray,nullParamDatas,"Array",CURRENTDATA);
findList.add(excelFunc);
paramArray=new String[]{};
excelFunc=new ExcelFunc("MATCH",SalaryI18nUtil.getI18nLabel(94970,"返回指定数值在指定数组区域中的位置"), funcDescUtil.get("MATCH"),"MATCH（值，[数组])",paramArray,nullParamDatas,"Number",CURRENTDATA);
findList.add(excelFunc);
return findList;
}
/**
* 聚合函数 COUNT(表格, [统计条件])
* @return
*/
public List<ExcelFunc> getAggList(){
List<ExcelFunc> aggList=new LinkedList<>();
ExcelFunc excelFunc=null;
String [] paramArray=new String[]{"Form","Number","Boolean"};
excelFunc=new ExcelFunc("COUNT", SalaryI18nUtil.getI18nLabel(16654,"计数"), funcDescUtil.get("COUNT"),"COUNT(表格)",paramArray,paramDatas,"Number",ALLFORM);
aggList.add(excelFunc);
paramArray=new String[]{"Number","Number","Boolean"};
excelFunc=new ExcelFunc("SUM",SalaryI18nUtil.getI18nLabel(95012,"求和") , funcDescUtil.get("SUM"),"SUM(数字字段)",paramArray,paramDatas,"Number",ALLFORM);
aggList.add(excelFunc);
paramArray=new String[]{"Number","Number","Boolean"};
excelFunc=new ExcelFunc("AVG",SalaryI18nUtil.getI18nLabel(19550,"平均值"), funcDescUtil.get("AVG"),"AVG(数字字段)",paramArray,paramDatas,"Number",ALLFORM);
aggList.add(excelFunc);
paramArray=new String[]{"Number","Number","Boolean"};
excelFunc=new ExcelFunc("MIN",SalaryI18nUtil.getI18nLabel(12318,"最小值"), funcDescUtil.get("MIN"),"MIN(表格)",paramArray,paramDatas,"Number",ALLFORM);
aggList.add(excelFunc);
paramArray=new String[]{"Number","Number","Boolean"};
excelFunc=new ExcelFunc("MAX",SalaryI18nUtil.getI18nLabel(66750,"最大值"), funcDescUtil.get("MAX"),"MAX(表格)",paramArray,paramDatas,"Number",ALLFORM);
aggList.add(excelFunc);
return aggList;
}
/**
* 财务类函数列表
* @return
*/
public Object getFinanceList(){
ExcelFunc excelFunc = null;
List<ExcelFunc> funcs = Lists.newArrayList();
excelFunc = new ExcelFunc("GETMONEY",SalaryI18nUtil.getI18nLabel(0,"获取锁给定数字的金额大写"), funcDescUtil.get("GETMONEY"),"GETMONEY({数字})",null,nullParamDatas,"",CURRENTDATA);
funcs.add(excelFunc);
return funcs;
}
/**
* 数据库函数列表
* @return
*/
public Object getDataBaseList() {
ExcelFunc excelFunc = null;
List<ExcelFunc> funcs = Lists.newArrayList();
// excelFunc = new ExcelFunc("GETHRMLOGINID",SalaryI18nUtil.getI18nLabel(100807,"返回指定人员系统账号"), funcDescUtil.get("GETHRMLOGINID"),"GETHRMLOGINID({表单.人员})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETHRMWORKCODE",SalaryI18nUtil.getI18nLabel(100809,"返回指定人员编号"), funcDescUtil.get("GETHRMWORKCODE"),"GETHRMWORKCODE({表单.人员})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETHRMMANAGER",SalaryI18nUtil.getI18nLabel(100811,"返回指定人员直接上级"), funcDescUtil.get("GETHRMMANAGER"),"GETHRMMANAGER({表单.人员})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETHRMALLMANAGER",SalaryI18nUtil.getI18nLabel(100813,"返回指定人员所有上级"), funcDescUtil.get("GETHRMALLMANAGER"),"GETHRMALLMANAGER({表单.人员})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETHRMDEPARTMENT",SalaryI18nUtil.getI18nLabel(100815,"返回指定人员部门"), funcDescUtil.get("GETHRMDEPARTMENT"),"GETHRMDEPARTMENT({表单.人员})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETHRMSUBCOMPANY",SalaryI18nUtil.getI18nLabel(100817,"返回指定人员分部"), funcDescUtil.get("GETHRMSUBCOMPANY"),"GETHRMSUBCOMPANY({表单.人员})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETDEPARTMENTNAME",SalaryI18nUtil.getI18nLabel(100819,"返回指定部门名称"), funcDescUtil.get("GETDEPARTMENTNAME"),"GETDEPARTMENTNAME({表单.部门})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETDEPARTMENTCODE",SalaryI18nUtil.getI18nLabel(100821,"返回指定部门编号"), funcDescUtil.get("GETDEPARTMENTCODE"),"GETDEPARTMENTCODE({表单.部门})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETSUPERDEPARTMENT",SalaryI18nUtil.getI18nLabel(100823,"返回指定部门直接上级部门"), funcDescUtil.get("GETSUPERDEPARTMENT"),"GETSUPERDEPARTMENT({表单.部门})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETALLSUPERDEPARTMENT",SalaryI18nUtil.getI18nLabel(100825,"返回指定部门所有上级部门"), funcDescUtil.get("GETALLSUPERDEPARTMENT"),"GETALLSUPERDEPARTMENT({表单.部门})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETSUBCOMPANYNAME",SalaryI18nUtil.getI18nLabel(100827,"返回指定分部名称"), funcDescUtil.get("GETSUBCOMPANYNAME"),"GETSUBCOMPANYNAME({表单.分部})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETSUBCOMPANYCODE",SalaryI18nUtil.getI18nLabel(100829,"返回指定分部编号"), funcDescUtil.get("GETSUBCOMPANYCODE"),"GETSUBCOMPANYCODE({表单.分部})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETSUPERSUBCOMPANY",SalaryI18nUtil.getI18nLabel(100831,"返回指定分部直接上级分部"), funcDescUtil.get("GETSUPERSUBCOMPANY"),"GETSUPERSUBCOMPANY({表单.分部})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
//
// excelFunc = new ExcelFunc("GETALLSUPERSUBCOMPANY",SalaryI18nUtil.getI18nLabel(100833,"返回指定分部所有上级分部"), funcDescUtil.get("GETALLSUPERSUBCOMPANY"),"GETALLSUPERSUBCOMPANY({表单.分部})",null,nullParamDatas,"",CURRENTDATA);
// funcs.add(excelFunc);
excelFunc = new ExcelFunc("GETHRMNAME",SalaryI18nUtil.getI18nLabel(100833,"获取人员名称"), funcDescUtil.get("GETHRMNAME"),"GETHRMNAME({人员})",null,nullParamDatas,"",CURRENTDATA);
funcs.add(excelFunc);
excelFunc = new ExcelFunc("GETHRMMOBILE",SalaryI18nUtil.getI18nLabel(100833,"获取人员手机号码"), funcDescUtil.get("GETHRMMOBILE"),"GETHRMMOBILE({人员})",null,nullParamDatas,"",CURRENTDATA);
funcs.add(excelFunc);
return funcs;
}
}

35
src/com/engine/salary/formlua/entity/parameter/FormulaContext.java Normal file
View File

@ -0,0 +1,35 @@
package com.engine.salary.formlua.entity.parameter;
import com.alibaba.fastjson.JSONObject;
public class FormulaContext {
public static ThreadLocal<FormulaContext> fmCtx=new ThreadLocal<FormulaContext>();
private JSONObject formulaJson=new JSONObject();
public static FormulaContext get(){
if(null==fmCtx.get()){
fmCtx.set(new FormulaContext());
}
return fmCtx.get();
}
public JSONObject getFormulaJson() {
return formulaJson;
}
public void setValue(String func){
if(formulaJson.getInteger(func)!=null){
int i=formulaJson.getInteger(func)+1;
formulaJson.put(func,i);
}else {
formulaJson.put(func,1);
}
}
public Integer getValue(String func){
return formulaJson.getInteger(func);
}
public void removeContext(){
fmCtx.remove();
}
}

134
src/com/engine/salary/formlua/entity/parameter/FuncDescUtil.java Normal file
View File

@ -0,0 +1,134 @@
package com.engine.salary.formlua.entity.parameter;
import com.engine.salary.util.SalaryI18nUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
@Component
public class FuncDescUtil {
protected final Logger logger = LoggerFactory.getLogger(FuncDescUtil.class);
Map<String, String> funcMap = new HashMap();
public void initData() {
//聚合函数
funcMap.put("COUNT", SalaryI18nUtil.getI18nLabel(94986, "返回指定表格中满足条件的数据条数。示例：COUNT({员工表})"));
funcMap.put("SUM", SalaryI18nUtil.getI18nLabel(94987, "返回指定表格中满足条件的数据，其指定数字字段值的总和。统计条件中不可嵌套使用统计函数。示例：SUM({员工表.工资})"));
funcMap.put("AVG", SalaryI18nUtil.getI18nLabel(94988, "返回指定表格中满足条件的数据，其指定数字字段值的平均值。统计条件中不可嵌套使用统计函数。示例：AVG({员工表.工资})"));
funcMap.put("MIN", SalaryI18nUtil.getI18nLabel(94989, "返回指定表格中满足条件的数据，其指定数字字段值的最小值。统计条件中不可嵌套使用统计函数。示例：MIN({员工表.工资})"));
funcMap.put("MAX", SalaryI18nUtil.getI18nLabel(94990, "返回指定表格中满足条件的数据，其指定数字字段值的最大值。统计条件中不可嵌套使用统计函数。示例：MAX({员工表.工资})"));
//日期函数
funcMap.put("TODAY", SalaryI18nUtil.getI18nLabel(97678, "返回当天日期。示例：TODAY() 结果： '2020-01-01'"));
funcMap.put("NOW", SalaryI18nUtil.getI18nLabel(97689, "返回当天日期+时间。示例：NOW() 结果： '2016-12-24 12:05:38'"));
funcMap.put("DATEADD", SalaryI18nUtil.getI18nLabel(97691, "对日期加减按照单位加减。单位默认为日，可选单位：年Y、月M、日D、时H、分I、秒S。示例：<br> DATEADD('2016-12-21', 3) 结果： '2016-12-24' <br> DATEADD('2016-12-24 20:00:00', 3, 'H') 结果： '2016-12-24 23:00:00'"));
funcMap.put("DATEDIFF", SalaryI18nUtil.getI18nLabel(97692, "根据指定的单位，返回日期2减去日期1的差值。当日期2小于日期1时，差值为负值。单位默认为日，可选单位：年Y、月M、日D、时H、分I、秒S。<br> 示例：<br> DATEDIF('2016-12-21', '2016-12-24') 结果： 3 <br> DATEDIF('2016-12-24 20:00:00', '2016-12-25 20:00:00', 'H') 结果： 24"));
funcMap.put("DATEFORMAT", SalaryI18nUtil.getI18nLabel(97693, "将日期转为指定格式返回。 示例：<br> DATEFORMAT('2016-12-24', 'YY年MM月DD日') 结果： 2016年12月24日 <br> yyyy 将年份显示为1900-9999 <br> yy 将年份显示为00-99 <br> mm 将月份显示为 01–12 <br> dd 将日期显示为 01–31"));
funcMap.put("YEAR", SalaryI18nUtil.getI18nLabel(97694, "返回指定日期中的年。示例：<br> YEAR('2016-12-24') 结果： 2016"));
funcMap.put("MONTH", SalaryI18nUtil.getI18nLabel(97695, "返回指定日期中的月。示例：<br> MONTH('2016-12-24') 结果： 12"));
funcMap.put("DAY", SalaryI18nUtil.getI18nLabel(97696, "返回指定日期中的日。示例：<br> DAY('2016-12-24') 结果： 24"));
funcMap.put("HOUR", SalaryI18nUtil.getI18nLabel(97697, "返回指定日期中的小时。示例：<br> HOUR('2016-12-24 20:30:56') 结果： 20"));
funcMap.put("MINUTE", SalaryI18nUtil.getI18nLabel(97698, "返回指定日期中的分钟。示例：<br> MINUTE('2016-12-24 20:30:56') 结果： 30"));
funcMap.put("SECOND", SalaryI18nUtil.getI18nLabel(97699, "返回指定日期中的秒钟。示例：<br> SECOND('2016-12-24 20:30:56') 结果： 56"));
funcMap.put("WEEKNUM", SalaryI18nUtil.getI18nLabel(97700, "返回指定日期为第几周，从每年第1天开始算第1周。示例：<br> WEEKNUM('2016-12-24') 结果： 52"));
funcMap.put("WEEKDAY", SalaryI18nUtil.getI18nLabel(97701, "返回指定日期为星期几。返回值为0~6，代表周日~周六。示例：<br> WEEKDAY('2016-12-24') 结果： 6"));
funcMap.put("EOMONTH", SalaryI18nUtil.getI18nLabel(97702, "将某月最后一天日期返回。日期可以为指定日期也可以是日期参数，之前的月数用负数表示，之后的月数用正数表示。所输入月数需为整数。<br>示例：EOMONTH('2021-11-07', -2)<br>结果：2021-09-30"));
funcMap.put("NETWORKDAYSPI", SalaryI18nUtil.getI18nLabel(97703, "将指定日期（仅限的过去时间，最大支持跨度为365天）之间包含的工作日天数返回。注意:此函数只能选择过去的时间才可使用，跨度不能超过365天。当日期2小于日期1时，差值为负值。单位默认为日。<br>示例：想知道李四在2021-11-07和2021-11-12之间的工作日天数。<br>NETWORKDAYSPI('2021-11-07', '2021-11-12'，'李四') <br>结果：5"));
funcMap.put("MAXDATE", SalaryI18nUtil.getI18nLabel(100804, "取一组日期中的最大值。示例：<br/> MAXDATE('2016-12-24', '2022-12-24') 结果： 2022-12-24"));
funcMap.put("MINDATE", SalaryI18nUtil.getI18nLabel(100806, "取一组日期中的最小值。示例：<br/> MINDATE('2016-12-24', '2022-12-24') 结果： 2016-12-24"));
//日期中的当前时间操作
funcMap.put("CURRYEAR", SalaryI18nUtil.getI18nLabel(101066, "取当前日期的年份。示例：<br/> 假设当前时间为：2022年2月17日 11:20:30 ，CURRYEAR() 结果： 2022"));
funcMap.put("CURRMONTH", SalaryI18nUtil.getI18nLabel(101067, "取当前日期的月份。示例：<br/> 假设当前时间为：2022年2月17日 11:20:30 ，CURRMONTH() 结果： 2"));
funcMap.put("CURRDAY", SalaryI18nUtil.getI18nLabel(101068, "取当前日期的天。示例：<br/> 假设当前时间为：2022年2月17日 11:20:30 ，CURRDAY() 结果： 17"));
funcMap.put("CURRWEEK", SalaryI18nUtil.getI18nLabel(101069, "取当前日期是周几。示例：<br/> 假设当前时间为：2022年2月17日 11:20:30 ，CURRWEEK() 结果： 4"));
funcMap.put("CURRHOUR", SalaryI18nUtil.getI18nLabel(101070, "取当前日期的小时。示例：<br/> 假设当前时间为：2022年2月17日 11:20:30 ，CURRHOUR() 结果： 11"));
funcMap.put("CURRMINUTE", SalaryI18nUtil.getI18nLabel(101071, "取当前日期的分钟。示例：<br/> 假设当前时间为：2022年2月17日 11:20:30 ，CURRMINUTE() 结果： 20"));
funcMap.put("CURRSECOND", SalaryI18nUtil.getI18nLabel(101072, "取当前日期的秒钟。示例：<br/> 假设当前时间为：2022年2月17日 11:20:30 ，CURRSECOND() 结果： 30"));
//逻辑函数
funcMap.put("IF", SalaryI18nUtil.getI18nLabel(97704, "如果条件为真，则执行表达式1，为假则执行表达式2。条件中不可嵌套使用IF函数。示例：<br> IF({员工表.年龄} > 60, '退休', '在职')、IF({员工表.年龄} > 60, IF({员工表.性别} = {员工表.性别.女}, '退休', '在职'), '在职')"));
funcMap.put("AND", SalaryI18nUtil.getI18nLabel(97705, "所有条件均为真，则返回真，否则返回假。逻辑操作AND的函数模式。示例：<br> AND(2 = 2, 2 < 2)"));
funcMap.put("OR", SalaryI18nUtil.getI18nLabel(97706, "任意一个条件为真，则返回真，否则返回假。逻辑操作OR的函数模式。示例：<br> OR(2 = 2, 2 > 3)"));
funcMap.put("NOT", SalaryI18nUtil.getI18nLabel(97707, "对逻辑结果取反。示例：<br> NOT(2 > 3)"));
funcMap.put("IN", SalaryI18nUtil.getI18nLabel(97708, "任意类型的变量或常量等于一组同类型变量或常量结果中的任意一个，则返回真。示例：<br> IN(2, [2, 3, 4])"));
funcMap.put("LIKE", SalaryI18nUtil.getI18nLabel(97709, "文本类型的变量或常量包含一组文本类型变量或常量结果中的任意一个，则返回真。逻辑操作LIKE的函数模式。示例：<br> LIKE('大家好', ['大家', '好'])"));
funcMap.put("TRUE", SalaryI18nUtil.getI18nLabel(97710, "返回真。示例：TRUE()"));
funcMap.put("FALSE", SalaryI18nUtil.getI18nLabel(97712, "返回假。示例：FALSE()"));
funcMap.put("IFS", SalaryI18nUtil.getI18nLabel(97713, "多个条件判断,位于单数位置的参数设置为条件，位于双数位置的参数设置为结果，最后一个参数为默认返回值，当所有条件都不满足的时候返回默认参数。示例：IFS(1>1,1,1=1,2,0)，结果：2"));
funcMap.put("FIND", SalaryI18nUtil.getI18nLabel(97714, "用指定参数去另一个参数列表中查找匹配项，指定参数时，填写1则去第一个参数列表中查找，2则是第二个参数列表里匹配查找第一个参数，成功则返回true，失败返回false。示例：FIND([1,2,3],[1,2,3,4],1)，结果：true"));
//文本函数
funcMap.put("CONCAT", SalaryI18nUtil.getI18nLabel(97730, "可用于连接多个任意类型的文本、日期、数字变量或常量。示例：<br> CONCAT({总价}/10000, '万元')"));
funcMap.put("TEXT", SalaryI18nUtil.getI18nLabel(97731, "将变量转为文本。示例：<br> TEXT({当前数据.性别}) 结果： '男'"));
funcMap.put("VALUE", SalaryI18nUtil.getI18nLabel(97732, "将文本转为数字。示例：<br> VALUE('23') 结果： 23"));
funcMap.put("LEN", SalaryI18nUtil.getI18nLabel(97733, "返回文本的长度，中文、英文都算1个字符。示例：<br> LEN('大家好dajiahao') 结果： 12"));
funcMap.put("SEARCH", SalaryI18nUtil.getI18nLabel(97734, "在指定文本中查找关键字，返回第一次出现关键字的字符位置，文本的第一个字记为1。未找到，返回0。搜索开始位置，表示从文本的第几个字符开始搜索，默认为1。示例：<br> SEARCH('大家', '大家好大家好', 3) 结果： 4"));
funcMap.put("REPLACE", SalaryI18nUtil.getI18nLabel(97735, "在原文本中，从替换位置开始，往后数指定的替换字符数，将这段文本替换为新文本。示例：<br> REPLACE('大家好大家好', 2, 3, 'dajia') 结果： '大dajia家好'"));
funcMap.put("REPT", SalaryI18nUtil.getI18nLabel(97736, "将文本重复指定次数。示例：<br> REPT('大家', 2) 结果： '大家大家'"));
funcMap.put("PAD", SalaryI18nUtil.getI18nLabel(97737, "将原文本填充到指定长度，如果文本长度大于设置的长度，则不做任何操作。填充位置可用参数：'LEFT'、'RIGHT'。示例：<br> PAD('你好', 4, '你', 'LEFT') 结果： '你你你好'"));
funcMap.put("TRIM", SalaryI18nUtil.getI18nLabel(97738, "删除文本首尾的空格。示例：<br> TRIM(' 大家好 ') 结果： '大家好'"));
funcMap.put("LEFT", SalaryI18nUtil.getI18nLabel(97739, "从文本左侧开始，返回指定字符数的文字。示例：<br> LEFT('大家好', 2) 结果： '大家'"));
funcMap.put("RIGHT", SalaryI18nUtil.getI18nLabel(97740, "从文本右侧开始，返回指定字符数的文字。示例：<br> RIGHT('大家好', 2) 结果： '家好'"));
funcMap.put("MID", SalaryI18nUtil.getI18nLabel(97741, "从文本指定位置之后开始，返回指定字符数的文字。示例：<br> MID('大家好', 2, 1) 结果： '家'"));
funcMap.put("ISEMPTY", SalaryI18nUtil.getI18nLabel(97742, "变量为空或未填写，则返回真。示例：<br> ISEMPTY({员工表.电话})"));
funcMap.put("IDCARD", SalaryI18nUtil.getI18nLabel(97743, "从身份证号码中获取相关信息，比如：生日（BD）、年龄（AGE）、籍贯（NA）、性别（GENDER）。示例：<br> IDCARD( ‘43070319980706334X’ , ‘BD’ ) 结果： '1998-07-06'"));
funcMap.put("SCORE", SalaryI18nUtil.getI18nLabel(97744, "获取选项型控件（单选框、复选框、下拉菜单）分数。示例：SCORE({当前数据.单选框}) 结果：选项分数<br>注：未设置选项分数时，结果为0"));
funcMap.put("SUBSTRING", SalaryI18nUtil.getI18nLabel(97745, "字符截取函数，用于按起始位置截取字符。<br>示例：SUBSTRING('abcdefg'，2，3) <br>结果：bc"));
funcMap.put("SUBSTITUE", SalaryI18nUtil.getI18nLabel(97746, "字符查找替换函数，替换字符中的所有关键词为新字符。<br>示例：SUBSTITUE('泛微移动办公','泛微','eteams') <br>结果：eteams移动办公"));
funcMap.put("LOWER", SalaryI18nUtil.getI18nLabel(97747, "将字符中的字母转为小写。<br>示例：LOWER('abc')<br>结果：ABC"));
funcMap.put("UPPER", SalaryI18nUtil.getI18nLabel(97748, "将字符中的字母转为大写。<br>示例：LOWER('ABC')<br>结果：abc"));
funcMap.put("EXACT", SalaryI18nUtil.getI18nLabel(97749, "比较两个字符是否相等，区分字母的大小写。<br>示例：EXACT('泛微Eteams','泛微eteams') <br> 结果：false"));
funcMap.put("ISSTRING", SalaryI18nUtil.getI18nLabel(0, "判断是否是字符。<br>示例：ISSTRING('泛微Eteams') <br> 结果：true"));
//数学函数
funcMap.put("ROUND", SalaryI18nUtil.getI18nLabel(97750, "根据设置的小数位精确度，返回对数值四舍五入后的值。小数位精确度取值可为正整数，0，负整数。如果小数位精确度为正整数，针对小数点后的数据进行四舍五入；如果小数位精确度等于 0，返回最接近数值的整数；如果小数位精确度为负整数，针对小数点前的数据进行四舍五入，被舍掉的数据用0占位。小数位精确度不支持变量。小数位精确度默认为0，即只保留整数。<br>示例：ROUND(123.456，2)，ROUND(123.456，0)，ROUND(123.456，-2) <br>结果：依次为123.46，123，100"));
funcMap.put("ROUNDUP", SalaryI18nUtil.getI18nLabel(97751, "根据设置的小数位精确度，返回对数值向上舍入后的值。小数位精确度取值可为正整数，0，负整数。如果小数位精确度为正整数，则向上舍入到指定的小数位。如果小数位精确度等于 0，则向上舍入到最接近的整数。如果小数位精确度为负整数，则在小数点左侧向上进行舍入。小数位精确度不支持变量。小数位精确度默认为0，即只保留整数。示例：ROUNDDOWN(76.9,0)结果：77"));
funcMap.put("ROUNDDOWN", SalaryI18nUtil.getI18nLabel(97752, "根据设置的小数位精确度，返回对数值向下舍入后的值。小数位精确度取值可为正整数，0，负整数。如果小数位精确度为正整数，则向下舍入到指定的小数位。如果小数位精确度等于 0，则向下舍入到最接近的整数。如果小数位精确度为负整数，则在小数点左侧向下进行舍入。小数位精确度不支持变量。小数位精确度默认为0，即只保留整数。<br>示例：ROUNDDOWN(76.9,0)<br>结果：76"));
funcMap.put("AGGREGATION", SalaryI18nUtil.getI18nLabel(97753, "将一组数据进行统计计算，支持最大值（MAX）、最小值（MIN）、平均值（AVG）。示例：AGGREGATION(1 , 2,3,'AVG')，结果：2"));
funcMap.put("MOD", SalaryI18nUtil.getI18nLabel(97754, "将两个参数进行除法运算然后得出余数返回。示例：MOD( 7 , 3 )，结果：1"));
funcMap.put("TRUNC", SalaryI18nUtil.getI18nLabel(97755, "将小数点格式化成指定位数。示例：TRUNC( 2.123 , 2 )，结果：2.12"));
funcMap.put("ISINT", SalaryI18nUtil.getI18nLabel(0, "判断字符内容是否是整数。示例：ISINT( 2.123 )，结果：false"));
funcMap.put("ISNUMBER", SalaryI18nUtil.getI18nLabel(0, "判断字符内容是否是数字。示例：ISNUMBER('2.123')，结果：true"));
//查找函数
funcMap.put("CHOOSE", SalaryI18nUtil.getI18nLabel(97756, "根据条件获取指定数据源中的全部数据。数据源支持选表单、表单中的字段。<br>示例：想知道税表中，收入大于15000的数值<br>CHOOSE({税表}, {税表.收入}>15000) <br>结果：返回税表中收入大于15000的集合"));
funcMap.put("MATCH", SalaryI18nUtil.getI18nLabel(97757, "将指定数值在指定数组区域中的位置返回。若数组中无指定值，返回null。<br>示例：MATCH(15000, [1000, 15000, 2000]) <br>结果：1"));
funcMap.put("VLOOKUPS", SalaryI18nUtil.getI18nLabel(97758, "按列查找，返回所需值。常用于薪酬模块。根据条件获取查询参数所在列的返回参数的值。返回参数可填写多个，用英文逗号隔开。若查询不到返回null。<br>示例：VLOOKUPS({税表}，{税表.收入}，AND（{税表.收入}>{税表.应纳税所得额下限}，{税表.收入}<{税表.应纳税所得额上限}），[{税表.税率},{税表.速算扣除数}]) <br>结果：按列查找返回税表中收入所在的收入区间所对应的税率和速算扣除数的数值"));
//数据库函数
funcMap.put("GETHRMLOGINID", SalaryI18nUtil.getI18nLabel(100808, "获取指定人员系统账号。<br/>示例：GETHRMLOGINID({表单.张三}) <br/>结果：zhangsan@qq.com"));
funcMap.put("GETHRMWORKCODE", SalaryI18nUtil.getI18nLabel(100810, "获取指定人员编号。<br/>示例：GETHRMWORKCODE({表单.张三}) <br/>结果：A001"));
funcMap.put("GETHRMMANAGER", SalaryI18nUtil.getI18nLabel(100812, "获取指定人员直接上级。<br/>示例：GETHRMMANAGER({表单.张三}) <br/>结果：返回张三的直接上级"));
funcMap.put("GETHRMALLMANAGER", SalaryI18nUtil.getI18nLabel(100814, "获取指定人员所有上级。<br/>示例：GETHRMMANAGER({表单.张三}) <br/>结果：返回张三的所有上级形成的数组"));
funcMap.put("GETHRMDEPARTMENT", SalaryI18nUtil.getI18nLabel(100816, "获取指定人员部门。<br/>示例：GETHRMDEPARTMENT({表单.张三}) <br/>结果：返回张三的部门"));
funcMap.put("GETHRMSUBCOMPANY", SalaryI18nUtil.getI18nLabel(100818, "获取指定人员分部。<br/>示例：GETHRMSUBCOMPANY({表单.张三}) <br/>结果：返回张三的分部"));
funcMap.put("GETDEPARTMENTNAME", SalaryI18nUtil.getI18nLabel(100820, "获取指定部门名称。<br/>示例：GETDEPARTMENTNAME({表单.A部门}) <br/>结果：A部门"));
funcMap.put("GETDEPARTMENTCODE", SalaryI18nUtil.getI18nLabel(100822, "获取指定部门编号。<br/>示例：GETDEPARTMENTCODE({表单.A部门}) <br/>结果：A001"));
funcMap.put("GETSUPERDEPARTMENT", SalaryI18nUtil.getI18nLabel(100824, "获取指定部门直接上级部门。<br/>示例：GETDEPARTMENTCODE({表单.A部门}) <br/>结果：A部门的直接上级部门"));
funcMap.put("GETALLSUPERDEPARTMENT", SalaryI18nUtil.getI18nLabel(100826, "获取指定部门所有上级部门。<br/>示例：GETALLSUPERDEPARTMENT({表单.A部门}) <br/>结果：A部门的所有上级部门形成的数组"));
funcMap.put("GETSUBCOMPANYNAME", SalaryI18nUtil.getI18nLabel(100828, "获取指定分部名称。<br/>示例：GETSUBCOMPANYNAME({表单.A分部}) <br/>结果：A分部"));
funcMap.put("GETSUBCOMPANYCODE", SalaryI18nUtil.getI18nLabel(100830, "获取指定分部编号。<br/>示例：GETSUBCOMPANYCODE({表单.A分部}) <br/>结果：B001"));
funcMap.put("GETSUPERSUBCOMPANY", SalaryI18nUtil.getI18nLabel(100832, "获取指定分部直接上级分部。<br/>示例：GETSUPERSUBCOMPANY({表单.A分部}) <br/>结果：A分部的直接上级分部"));
funcMap.put("GETALLSUPERSUBCOMPANY", SalaryI18nUtil.getI18nLabel(100834, "获取指定分部所有上级分部。<br/>示例：GETALLSUPERSUBCOMPANY({表单.A分部}) <br/>结果：A分部的所有上级分部形成的数组"));
funcMap.put("GETHRMNAME", SalaryI18nUtil.getI18nLabel(100834, "获取指定人员的姓名。<br/>示例：GETHRMNAME({U:张三}) <br/>结果：张三"));
funcMap.put("GETHRMMOBILE", SalaryI18nUtil.getI18nLabel(100834, "获取指定人员的手机号码。<br/>示例：GETHRMMOBILE({U:张三}) <br/>结果：13123232323"));
//财务函数
funcMap.put("GETMONEY", SalaryI18nUtil.getI18nLabel(0, "将金额转换成中文金额大写。<br/>示例：GETMONEY({1234}) <br/>结果：壹仟贰佰叁拾肆元整"));
}
public String get(String key) {
if (funcMap.size() > 0) {
// logger.info("描述数据存在："+funcMap.size());
} else {
logger.info("初始化函数描述数据");
initData();
}
return funcMap.get(key);
}
}

20
src/com/engine/salary/formlua/entity/parameter/FuncNames.java Normal file
View File

@ -0,0 +1,20 @@
package com.engine.salary.formlua.entity.parameter;
public enum FuncNames {
AND("and"), OR("or"), IF("ifF"), LIKE("likeFunc"), DATEDIFF("dateDiff"), DATEADD("dateAdd"), NOW("now"), DATEFORMAT("dateFormat"), COUNT("counts"), SUM("sumNumber"), MAX("maxNumber"), MIN("minNumber"), CONCAT("concatString"), SEARCH("search"), TEXT("text"), PAD("pad"), REPLACE("replace"), VALUE("value"), LEN("len"), LEFT("left"), RIGHT("right"), MID("mid"), TRUE("isTrue"), FALSE("isFalse"), NOT("not"), ISEMPTY("isEmpty"), TODAY("today"), IFS("ifs"), AGGREGATION("aggregation"), MOD("mod"), FIND("find"), SWITCH("switchs"), TRUNC("Trunc"), IDCARD("idCard"),
RANDOMNUMBER("randomNumber"), ROUNDUP("roundUp"), ROUNDDOWN("roundDown"), ROUND("round"), ADDRESS("addressAnalysis"), EOMONTH("eoMonth"), NETWORKDAYSPI("networkdaysPastIntl"),
CHOOSE("choose"), MATCH("match"), VLOOKUPS("vlookups"), GETHRMLOGINID("getHrmLoginId"), GETHRMWORKCODE("getHrmWorkcode"), GETHRMMANAGER("getHrmManager"), GETHRMALLMANAGER("getHrmAllManager"),
GETHRMDEPARTMENT("getHrmDepartment"), GETHRMSUBCOMPANY("getHrmSubcompany"), GETDEPARTMENTNAME("getDepartmentName"), GETDEPARTMENTCODE("getDepartmentCode"), GETSUPERDEPARTMENT("getSuperDepartment"),
GETALLSUPERDEPARTMENT("getAllSuperDepartment"), GETSUBCOMPANYNAME("getSubcompanyName"), GETSUBCOMPANYCODE("getSubcompanyCode"), GETSUPERSUBCOMPANY("getSuperSubcompany"), GETALLSUPERSUBCOMPANY("getAllSuperSubcompany"),
ISINT("isInt"), ISNUMBER("isNumber"), ISSTRING("isString"), GETMONEY("getMoney"), GETHRMNAME("getHrmName"), GETHRMMOBILE("getHrmMobile");
String name;
FuncNames(String name) {
this.name = name;
}
public String getName() {
return name;
}
}

19
src/com/engine/salary/formlua/entity/parameter/IllegalList.java Normal file
View File

@ -0,0 +1,19 @@
package com.engine.salary.formlua.entity.parameter;
public class IllegalList {
private final String[] operArray=new String[]{"<",">","+","-","*","/","{","}","[","]","(",")","=","!=","'","\"","!",".",">=","<="};
private final String[] nameIllegalArray=new String[]{"<",">","+","-","*","/","{","}","[","]","(",")","=","!=","'","\"","!",".",
"LIKE","like",">=","<=","IN","IF","AND","OR","TRUE","FALSE","NOW","DATEDIFF","DATEADD","Y","M","D","H","I","S","WEEKNUM",
"WEEKDAY","TODAY","DATEFORMAT","COUNT","SUM","MAX","MIN","CONCAT","SEARCH","TEXT","PAD","REPLACE","VALUE","LEN","LEFT","RIGHT","MID"};
private IllegalList(){}
private static IllegalList illegalList=new IllegalList();
public static IllegalList getInstance(){return illegalList;}
public String[] getNameIllegalArray() {
return nameIllegalArray;
}
public String[] getOperArray() {
return operArray;
}
}

30
src/com/engine/salary/formlua/entity/parameter/ParamContext.java Normal file
View File

@ -0,0 +1,30 @@
package com.engine.salary.formlua.entity.parameter;
import com.alibaba.fastjson.JSONObject;
/**
* @className：
* @Description：本地线程存储的Excel函数变量context，线程结束后会清空释放当前线程的变量context
* @Author：
* @date：
*/
public class ParamContext {
public static ThreadLocal<ParamContext> fmCtx=new ThreadLocal<ParamContext>();
private JSONObject jsonObject=new JSONObject();
public static ParamContext get(){
if(null==fmCtx.get()){
fmCtx.set(new ParamContext());
}
return fmCtx.get();
}
public void setValue(String func,Object value){
jsonObject.put(func,value);
}
public Object getValue(String func){
return jsonObject.get(func);
}
public void removeContext(){
fmCtx.remove();
}
}

127
src/com/engine/salary/formlua/entity/parameter/ParamFactory.java Normal file
View File

@ -0,0 +1,127 @@
package com.engine.salary.formlua.entity.parameter;
/**
* @className：默认本地参数
* @Description：注释
* @Author：
* @date：
*/
public class ParamFactory {
private String charValue;
private Double doubleValue;
private Integer integerValue;
private Long longValue;
private Float floatValue;
private Boolean boolValue;
private String dateTimeValue;
private String selectValue;
private String timeValue;
private String textValue;
private ParamFactory(){}
private ParamFactory(String charValue, Double doubleValue, Integer integerValue, Long longValue, Float floatValue, Boolean boolValue,String dateTimeValue,String selectValue,String timeValue,String textValue) {
this.charValue = charValue;
this.doubleValue = doubleValue;
this.integerValue = integerValue;
this.longValue = longValue;
this.floatValue = floatValue;
this.boolValue = boolValue;
this.dateTimeValue=dateTimeValue;
this.selectValue=selectValue;
this.timeValue=timeValue;
this.textValue=textValue;
}
private static ParamFactory paramFactory=new ParamFactory("2020-01-12 12:23:33",5.2,2020,100L,new Float(20.4),true,"2020-01-12 12:23:33","8428149709910469289","12:12:30","abcd");
public static ParamFactory getInstance(){
return paramFactory;
}
public String getTimeValue() {
return timeValue;
}
public void setTimeValue(String timeValue) {
this.timeValue = timeValue;
}
public String getSelectValue() {
return selectValue;
}
public void setSelectValue(String selectValue) {
this.selectValue = selectValue;
}
public String getCharValue() {
return charValue;
}
public void setCharValue(String charValue) {
this.charValue = charValue;
}
public Double getDoubleValue() {
return doubleValue;
}
public String getDateTimeValue() {
return dateTimeValue;
}
public void setDateTimeValue(String dateTimeValue) {
this.dateTimeValue = dateTimeValue;
}
public void setDoubleValue(Double doubleValue) {
this.doubleValue = doubleValue;
}
public Integer getIntegerValue() {
return integerValue;
}
public void setIntegerValue(Integer integerValue) {
this.integerValue = integerValue;
}
public Long getLongValue() {
return longValue;
}
public void setLongValue(Long longValue) {
this.longValue = longValue;
}
public Float getFloatValue() {
return floatValue;
}
public void setFloatValue(Float floatValue) {
this.floatValue = floatValue;
}
public Boolean getBoolValue() {
return boolValue;
}
public void setBoolValue(Boolean boolValue) {
this.boolValue = boolValue;
}
public static ParamFactory getParamFactory() {
return paramFactory;
}
public static void setParamFactory(ParamFactory paramFactory) {
ParamFactory.paramFactory = paramFactory;
}
public String getTextValue() {
return textValue;
}
public void setTextValue(String textValue) {
this.textValue = textValue;
}
}

15
src/com/engine/salary/formlua/entity/parameter/ParamType.java Normal file
View File

@ -0,0 +1,15 @@
package com.engine.salary.formlua.entity.parameter;
public enum ParamType {
STRING("String"),INTEGER("Integer"),DOUBLE("Double"),LONG("Long"),SHORT("Short"),JSONOBJECT("JSONObject"),FLOAT("Float"),BOOLEAN("Boolean");
String name;
ParamType(String name) {
this.name=name;
}
public String getName() {
return name;
}
}

13
src/com/engine/salary/formlua/entity/parameter/ReturnType.java Normal file
View File

@ -0,0 +1,13 @@
package com.engine.salary.formlua.entity.parameter;
public class ReturnType {
public final static int BOOLEAN_VALUE=0;
public final static int NUMBER_VALUE=1;
public final static int STRING_VALUE=2;
public final static String[] NUMBER_TYPE=new String[]{"NumberComponent","Money","Raty","score","Monitor"};
public final static String[] DATETIME_TYPE=new String[]{"DateComponent","DateInterval"};
public final static String[] CHECK_TYPE=new String[]{"RadioBox","CheckBox","Select","ComboSelect"};
public final static String[] DROPDOWN_LIST=new String[]{"Select","ComboSelect"};
public final static String[]CHECKBOX_LIST=new String[]{"RadioBox","CheckBox"};
}

59
src/com/engine/salary/formlua/entity/parameter/ThreadLocalData.java Normal file
View File

@ -0,0 +1,59 @@
package com.engine.salary.formlua.entity.parameter;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import org.mozilla.javascript.commonjs.module.provider.ModuleSource;
import java.util.Iterator;
import java.util.Map;
public class ThreadLocalData {
private Map<String, Object> expressContext;
private ModuleSource moduleSource;
private DataCollectionEmployee employee;
public ModuleSource getModuleSource() {
return moduleSource;
}
public void setModuleSource(ModuleSource moduleSource) {
this.moduleSource = moduleSource;
}
public DataCollectionEmployee getEmployee() {
return employee;
}
public void setEmployee(DataCollectionEmployee employee) {
this.employee = employee;
}
public Map<String, Object> getExpressContext() {
return expressContext;
}
public void setExpressContext(Map<String, Object> expressContext) {
transMap(expressContext);
this.expressContext = expressContext;
}
private void transMap(Map<String, Object> expressContext){
Iterator<String> iterator=expressContext.keySet().iterator();
while (iterator.hasNext()){
String key=iterator.next();
Object obj=expressContext.get(key);
if(obj instanceof DataType){
DataType dataType=(DataType)obj;
if(dataType.getFieldId()!=null){
int idx=key.indexOf(dataType.getFieldId().toString());
if(idx>=0){
String localKey=key.substring(0,idx+dataType.getFieldId().toString().length());
dataType.setAggCndKey(localKey);
}
}
}
}
}
}

8
src/com/engine/salary/formlua/entity/standard/AggFunc.java Normal file
View File

@ -0,0 +1,8 @@
package com.engine.salary.formlua.entity.standard;
public enum AggFunc {
count("计数"),avg("平均数"),min("最小数"),max("最大数"),sum("合计数");
AggFunc(String name) {
}
}

34
src/com/engine/salary/formlua/entity/standard/ExcelModuleFixField.java Normal file
View File

@ -0,0 +1,34 @@
package com.engine.salary.formlua.entity.standard;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ExcelModuleFixField {
/**
* 审批发起人
*/
public static String FLOW_CREATOR="creator";
/**
* 审批请求ID
*/
public static String FLOW_REQUEST_ID="requestid";
/**
* 审批发起人所属部门
*/
public static String FLOW_CREATOR_DEPT="creator_depart";
/**
* 上报收集人
*/
public static String REPORT_CREATOR="creator";
/**
* 上报名称
*/
public static String REPORT_NAME="name";
/**
* 上报提交人
*/
public static String REPORT_REPORTER="reporter";
public static List<String> ALLFIXFIELD = new ArrayList<>(Arrays.asList(FLOW_CREATOR,FLOW_CREATOR_DEPT,FLOW_REQUEST_ID,REPORT_CREATOR,REPORT_NAME,REPORT_REPORTER));
}

56
src/com/engine/salary/formlua/entity/standard/ExcelPage.java Normal file
View File

@ -0,0 +1,56 @@
package com.engine.salary.formlua.entity.standard;
import java.io.Serializable;
import java.util.List;
/**
* @author
*/
public class ExcelPage<T> implements Serializable {
private static final long serialVersionUID = -3149769813337109956L;
private int pageNo;
private int pageSize;
private int count;
private String keywords;
private List<T> pageResult;
public String getKeywords() {
return keywords;
}
public void setKeywords(String keywords) {
this.keywords = keywords;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public int getPageNo() {
return pageNo;
}
public void setPageNo(int pageNo) {
this.pageNo = pageNo;
}
public int getPageSize() {
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public List<T> getPageResult() {
return pageResult;
}
public void setPageResult(List<T> pageResult) {
this.pageResult = pageResult;
}
}

87
src/com/engine/salary/formlua/entity/standard/ExcelResult.java Normal file
View File

@ -0,0 +1,87 @@
package com.engine.salary.formlua.entity.standard;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* @author roy
*/
public class ExcelResult implements Serializable {
private static final long serialVersionUID = 4578033427466119428L;
/**
* 文本、数字、日期从这里取值
*/
private Object data;
/**
* 布尔值从这里取值
*/
private boolean boolData;
private String stringData;
private BigDecimal numberData;
/**
* 执行状态，true为执行成功，false为执行失败
*/
private boolean status;
private String errorMsg;
private String formulaId;
public String getFormulaId() {
return formulaId;
}
public void setFormulaId(String formulaId) {
this.formulaId = formulaId;
}
public boolean isBoolData() {
return boolData;
}
public String getStringData() {
return stringData;
}
public void setStringData(String stringData) {
this.stringData = stringData;
}
public BigDecimal getNumberData() {
return numberData;
}
public void setNumberData(BigDecimal numberData) {
this.numberData = numberData;
}
public String getErrorMsg() {
return errorMsg;
}
public void setErrorMsg(String errorMsg) {
this.errorMsg = errorMsg;
}
public boolean getBoolData() {
return boolData;
}
public void setBoolData(boolean boolData) {
this.boolData = boolData;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}
}

58
src/com/engine/salary/formlua/entity/standard/FormulaCategory.java Normal file
View File

@ -0,0 +1,58 @@
package com.engine.salary.formlua.entity.standard;
import java.io.Serializable;
/**
* @author roy
*/
public class FormulaCategory implements Serializable {
private static final long serialVersionUID = 376155360889274784L;
/**
* 分类ID
*/
private String id;
/**
* 分类名称
*/
private String name;
/**
* 所属模块
*/
private String module;
/**
* 类别，和module保持一致即可，为兼容老数据的保留字段
*/
private String type;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getModule() {
return module;
}
public void setModule(String module) {
this.module = module;
}
}

37
src/com/engine/salary/formlua/entity/standard/FormulaDataSource.java Normal file
View File

@ -0,0 +1,37 @@
package com.engine.salary.formlua.entity.standard;
import java.io.Serializable;
/**
* @author roy
*/
public class FormulaDataSource implements Serializable {
private static final long serialVersionUID = 8657467498740290598L;
private String dataId;
private String title;
private String module;
public String getDataId() {
return dataId;
}
public void setDataId(String dataId) {
this.dataId = dataId;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getModule() {
return module;
}
public void setModule(String module) {
this.module = module;
}
}

299
src/com/engine/salary/formlua/entity/standard/FormulaFilterData.java Normal file
View File

@ -0,0 +1,299 @@
package com.engine.salary.formlua.entity.standard;
import java.io.Serializable;
import java.util.List;
/**
* @author roy
*/
public class FormulaFilterData implements Serializable {
public static final String CONDITION_AND = "and";
public static final String CONDITION_OR = "or";
public static final String TERM_EQ = "eq";
public static final String TERM_NOT_EQ = "neq";
public static final String TERM_NULL = "null";
public static final String TERM_NOT_NULL = "notnull";
public static final String TERM_LIKE = "like";
public static final String TERM_GT = "gt";
public static final String TERM_GE = "ge";
public static final String TERM_LE = "le";
public static final String TERM_LT = "lt";
public static final String TERM_BEQ = "beq";
public static final String TERM_SEQ = "seq";
public static final String SOURCE_TYPE_CONSTANT = "constant";
public static final String SOURCE_TYPE_VARIABLE = "variable";
private static final long serialVersionUID = 2902385161856666369L;
/**
* 字段ID
*/
private String fieldId;
/**
* 明细子表ID
*/
private String subFormId;
/**
* 控件名称
*/
private String componentKey;
/**
* 操作符，具体符号在上面的静态变量中
*/
private String term;
private String tremStr;
/**
* 条件的值
*/
private String content;
/**
* 范围条件的截止范围
*/
private String endContent;
/**
* 选项条件的值
*/
private List<String> ids;
// private List<FilterFormData> children;
private List<String> contents;
private List<Object> idObjects;
private String dateType;
private List<String> allUserIds;
private List<String> allDeptIds;
private String operateId;
private String departmentId;
private List<String> deptFieldIds;
private String subDept;
private List<String> pIds;
private String sourceType;
private String sourceFile;
private String idsStr;
private String sortStr;
private String condition = "and";
private List<String> selectIds;
private String format;
private boolean isFixed;
// private List<FilterFormDataIds> filterFormDataIdsList;
public String getFieldId() {
return fieldId;
}
public void setFieldId(String fieldId) {
this.fieldId = fieldId;
}
public String getSubFormId() {
return subFormId;
}
public void setSubFormId(String subFormId) {
this.subFormId = subFormId;
}
public String getComponentKey() {
return componentKey;
}
public void setComponentKey(String componentKey) {
this.componentKey = componentKey;
}
public String getTerm() {
return term;
}
public void setTerm(String term) {
this.term = term;
}
public String getTremStr() {
return tremStr;
}
public void setTremStr(String tremStr) {
this.tremStr = tremStr;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getEndContent() {
return endContent;
}
public void setEndContent(String endContent) {
this.endContent = endContent;
}
public List<String> getIds() {
return ids;
}
public void setIds(List<String> ids) {
this.ids = ids;
}
// public List<FilterFormData> getChildren() {
// return children;
// }
//
// public void setChildren(List<FilterFormData> children) {
// this.children = children;
// }
public List<String> getContents() {
return contents;
}
public void setContents(List<String> contents) {
this.contents = contents;
}
public List<Object> getIdObjects() {
return idObjects;
}
public void setIdObjects(List<Object> idObjects) {
this.idObjects = idObjects;
}
public String getDateType() {
return dateType;
}
public void setDateType(String dateType) {
this.dateType = dateType;
}
public List<String> getAllUserIds() {
return allUserIds;
}
public void setAllUserIds(List<String> allUserIds) {
this.allUserIds = allUserIds;
}
public List<String> getAllDeptIds() {
return allDeptIds;
}
public void setAllDeptIds(List<String> allDeptIds) {
this.allDeptIds = allDeptIds;
}
public String getOperateId() {
return operateId;
}
public void setOperateId(String operateId) {
this.operateId = operateId;
}
public String getDepartmentId() {
return departmentId;
}
public void setDepartmentId(String departmentId) {
this.departmentId = departmentId;
}
public List<String> getDeptFieldIds() {
return deptFieldIds;
}
public void setDeptFieldIds(List<String> deptFieldIds) {
this.deptFieldIds = deptFieldIds;
}
public String getSubDept() {
return subDept;
}
public void setSubDept(String subDept) {
this.subDept = subDept;
}
public List<String> getpIds() {
return pIds;
}
public void setpIds(List<String> pIds) {
this.pIds = pIds;
}
public String getSourceType() {
return sourceType;
}
public void setSourceType(String sourceType) {
this.sourceType = sourceType;
}
public String getSourceFile() {
return sourceFile;
}
public void setSourceFile(String sourceFile) {
this.sourceFile = sourceFile;
}
public String getIdsStr() {
return idsStr;
}
public void setIdsStr(String idsStr) {
this.idsStr = idsStr;
}
public String getSortStr() {
return sortStr;
}
public void setSortStr(String sortStr) {
this.sortStr = sortStr;
}
public String getCondition() {
return condition;
}
public void setCondition(String condition) {
this.condition = condition;
}
public List<String> getSelectIds() {
return selectIds;
}
public void setSelectIds(List<String> selectIds) {
this.selectIds = selectIds;
}
public String getFormat() {
return format;
}
public void setFormat(String format) {
this.format = format;
}
public boolean isFixed() {
return isFixed;
}
public void setFixed(boolean fixed) {
isFixed = fixed;
}
// public List<FilterFormDataIds> getFilterFormDataIdsList() {
// return filterFormDataIdsList;
// }
//
// public void setFilterFormDataIdsList(List<FilterFormDataIds> filterFormDataIdsList) {
// this.filterFormDataIdsList = filterFormDataIdsList;
// }
}

34
src/com/engine/salary/formlua/entity/standard/FormulaModuleCategory.java Normal file
View File

@ -0,0 +1,34 @@
package com.engine.salary.formlua.entity.standard;
import java.io.Serializable;
/**
* @author
*/
public class FormulaModuleCategory implements Serializable {
private static final long serialVersionUID = 561339364277864462L;
/**
* 分类名称
*/
private String content;
/**
* 分类ID
*/
private String id;
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}

8
src/com/engine/salary/formlua/entity/standard/execute/ExclDataType.java Normal file
View File

@ -0,0 +1,8 @@
package com.engine.salary.formlua.entity.standard.execute;
public enum ExclDataType {
text("文本类型"),integral("整数类型"),decimal("小数类型"),datasource("数据源或选项类型"),bool("布尔类型");
ExclDataType(String name) {
}
}

67
src/com/engine/salary/formlua/entity/standard/execute/ExclFixField.java Normal file
View File

@ -0,0 +1,67 @@
package com.engine.salary.formlua.entity.standard.execute;
/**
* 固定字段标准类
*/
public class ExclFixField {
/**
* 固定字段或系统字段的类属性名
*/
private String properName;
/**
* 数据类型
*/
private ExclDataType exclDataType;
/**
* 固定字段或系统字段的值
*/
private Object value;
/**
* 所属来源数据的ID
*/
private String sourceId;
/**
* 所属模块
*/
private String module;
public String getProperName() {
return properName;
}
public void setProperName(String properName) {
this.properName = properName;
}
public ExclDataType getExclDataType() {
return exclDataType;
}
public void setExclDataType(ExclDataType exclDataType) {
this.exclDataType = exclDataType;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
public String getSourceId() {
return sourceId;
}
public void setSourceId(String sourceId) {
this.sourceId = sourceId;
}
public String getModule() {
return module;
}
public void setModule(String module) {
this.module = module;
}
}

11
src/com/engine/salary/formlua/entity/standard/execute/FixFieldType.java Normal file
View File

@ -0,0 +1,11 @@
package com.engine.salary.formlua.entity.standard.execute;
/**
* 固定字段分类
*/
public enum FixFieldType {
Text("文本型"),Num("数字型"),Relate("关联型"),Select("选项型"),Employee("人员"),Department("部门");
FixFieldType(String name) {
}
}

71
src/com/engine/salary/formlua/func/compare/CommonOper.java Normal file
View File

@ -0,0 +1,71 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.ExcelParamUtil;
import java.util.ArrayList;
import java.util.List;
public class CommonOper {
public static List<Object[]> operDivMultiList(Object obj1,Object obj2,String oper){
List<Object[]> resultList=new ArrayList<>();
if( (obj1 instanceof Object[] && !(obj2 instanceof Object[])) || (obj2 instanceof Object[] && !(obj1 instanceof Object[])) ){
Object[] arrayParam;
Object param;
boolean firstArray=false;
if(obj1 instanceof Object[]){
arrayParam=(Object[])obj1;
param=obj2;
firstArray=true;
}else {
arrayParam=(Object[])obj2;
param=obj1;
}
for (int i=0;i<arrayParam.length;i++){
Object[] excuteArray=new Object[2];
if(firstArray){
excuteArray[0]=arrayParam[i];
excuteArray[1]=param;
}else{
excuteArray[1]=arrayParam[i];
excuteArray[0]=param;
}
resultList.add(excuteArray);
}
}else{
throw new RuntimeException("'"+oper+"'不支持操作两个数组参数");
}
return resultList;
}
public static List<Object[]> operAddReduceList(Object obj1,Object obj2){
List<Object[]> resultList=new ArrayList<>();
Object[] param1=(Object[])obj1;
Object[] param2=(Object[])obj2;
if(param1.length!=param2.length){
throw new RuntimeException("参数列表长度不一致");
}
for (int i=0;i<param1.length;i++){
Object[] excuteArray=new Object[2];
if(param1[i] instanceof DataType){
DataType dataType=(DataType)param1[i];
excuteArray[0]= ExcelParamUtil.getParamContent(dataType,"");
}else{
excuteArray[0]=param1[i];
}
if(param2[i] instanceof DataType){
DataType dataType=(DataType)param2[i];
excuteArray[1]=ExcelParamUtil.getParamContent(dataType,"");
}else{
excuteArray[1]=param2[i];
}
resultList.add(excuteArray);
}
return resultList;
}
}

310
src/com/engine/salary/formlua/func/compare/Compareutils.java Normal file
View File

@ -0,0 +1,310 @@
//package com.engine.salary.formlua.func.compare;
//
//import com.alibaba.fastjson.JSON;
//import com.engine.salary.formlua.entity.parameter.DataType;
//import com.engine.salary.formlua.entity.standard.FormulaFilterData;
//import com.weaver.common.form.component.base.ComponentConfig;
//import com.weaver.common.form.component.base.ComponentType;
//import com.weaver.common.form.excel.validator.Validator;
//import com.weaver.common.form.metadata.field.FormField;
//import com.weaver.common.form.stat.FilterFormData;
//import org.apache.commons.lang3.StringUtils;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//
//import java.util.ArrayList;
//import java.util.List;
//
///**
// * 逻辑操作符的条件构建工具类
// */
//public class Compareutils {
// protected static final Logger logger = LoggerFactory.getLogger(Compareutils.class);
//
// /**
// * 构建不等于操作符的搜索条件
// *
// * @param dataType
// * @param obj1
// * @param obj2
// * @throws Exception
// */
// public static void buildNotEqFilterParam(DataType dataType, Object obj1, Object obj2) throws Exception {
// List<FormulaFilterData> filterFormDataList = new ArrayList<>();
// FormulaFilterData filterData = new FormulaFilterData();
// String content = null;
// try {
// if (obj1 instanceof DataType) {
// DataType dataType1 = (DataType) obj1;
// if (StringUtils.isEmpty(dataType1.getComponentKey())) {
// dataType1.setComponentKey(dataType1.getDataType());
// }
// if (obj2 instanceof DataType) {
//// content = ((DataType) obj2).getContent()+"";
// DataType paramDataType = (DataType) obj2;
// if (paramDataType == null || paramDataType.getContent() == null) {
// content = "";
// } else {
// content = paramDataType.getContent() + "";
// }
// } else {
// content = obj2 + "";
// }
// if (content != null) {
// String componentKey = dataType1.getComponentKey();
// filterData.setFieldId(dataType1.getFieldId());
// if (dataType1.getSubFormId() != null) {
// filterData.setSubFormId(dataType1.getSubFormId() + "");
// }
// filterData.setComponentKey(componentKey);
// if (StringUtils.isEmpty(content)) {
//// filterData.setTerm(FilterFormData.TERM_NOT_NULL);
// } else {
//// //选项控件
//// if (ComponentConfig.isOptionComponent(componentKey)) {
//// filterData.setTerm(FilterFormData.TERM_NOT_EQ);
//// List<String> ids = new ArrayList<>();
//// String[] idsArray = content.split(",");
//// for (String idStr : idsArray) {
//// if (StringUtils.isNotBlank(idStr)) {
//// ids.add(idStr);
//// }
//// }
//// filterData.setIds(ids);
//// //其他
//// } else {
//// filterData.setTerm(FilterFormData.TERM_NOT_EQ);
//// filterData.setContent(content);
////// if(ComponentConfig.isNumberComponent(dataType1.getComponentKey()) || dataType1.getComponentKey().equalsIgnoreCase(DataType.NUMBER)){
////// if(StringUtils.isEmpty(content)){
////// filterData.setContent("0");
////// }
////// }
//// }
// }
// }
// filterFormDataList.add(filterData);
//// dataType.setFormulaFilterDataList(filterFormDataList);
// dataType.setComponentKey(dataType1.getComponentKey());
// dataType.setSubFormId(dataType1.getSubFormId());
// }
// } catch (Exception e) {
// logger.error("err", e);
// }
//
// }
//
// /**
// * 构建大于、小于、大于等于、小于等于的搜索条件
// *
// * @param dataType
// * @param name
// * @param obj1
// * @param obj2
// */
// public static void buildLessMoreFilterParam(DataType dataType, String name, Object obj1, Object obj2) {
// List<FormulaFilterData> filterFormDataList = new ArrayList<>();
// FormulaFilterData filterData = new FormulaFilterData();
// try {
// logger.info(name + "执行结果：" + JSON.toJSONString(dataType));
// if (obj1 instanceof DataType) {
// DataType dataType1 = (DataType) obj1;
// if (StringUtils.isEmpty(dataType1.getComponentKey())) {
// dataType1.setComponentKey(dataType1.getDataType());
// }
// String content = null;
// if (obj2 instanceof DataType) {
//// content = ((DataType) obj2).getContent()+"";
// DataType paramDataType = (DataType) obj2;
// if (paramDataType == null || paramDataType.getContent() == null) {
// content = "";
// } else {
// content = paramDataType.getContent() + "";
// }
// } else {
// content = obj2 + "";
// }
// if (content != null) {
// String componentKey = dataType1.getComponentKey();
// if (ComponentConfig.isNumberComponent(componentKey)
// || componentKey.equals(ComponentType.DateComponent.toString())
// || componentKey.equals(ComponentType.TimeComponent.toString())
// || dataType1.getComponentKey().equalsIgnoreCase(DataType.STRING)
// || dataType1.getComponentKey().equalsIgnoreCase(DataType.NUMBER)
// || dataType1.getComponentKey().equalsIgnoreCase(DataType.STRING)
// || dataType1.getComponentKey().equalsIgnoreCase(DataType.BOOL)) {
//
// filterData.setFieldId(dataType1.getFieldId() + "");
// if (dataType1.getSubFormId() != null) {
// filterData.setSubFormId(dataType1.getSubFormId() + "");
// }
// filterData.setComponentKey(componentKey);
// switch (name) {
// case ">=":
// filterData.setTerm(FilterFormData.TERM_GE);
// break;
// case ">":
// filterData.setTerm(FilterFormData.TERM_GT);
// break;
// case "<=":
// filterData.setTerm(FilterFormData.TERM_LE);
// break;
// case "<":
// filterData.setTerm(FilterFormData.TERM_LT);
// break;
// default:
// break;
// }
// filterData.setContent(content);
// }
// }
// filterFormDataList.add(filterData);
// dataType.setFormulaFilterDataList(filterFormDataList);
// dataType.setComponentKey(dataType1.getComponentKey());
// dataType.setSubFormId(dataType1.getSubFormId());
// }
// } catch (Exception e) {
// logger.error("err", e);
// }
//
// }
//
// /**
// * 校验大于、小于、小于等于、大于等于操作符的入参
// *
// * @param name
// * @param obj1
// * @param obj2
// * @return
// */
// public static boolean checkLessMoreParam(String name, Object obj1, Object obj2) {
// if (obj1 instanceof FormField) {
// String componentKey = ((FormField) obj1).getComponentKey();
// if (ComponentConfig.isNumberComponent(componentKey)) {
// if (obj2 instanceof Number) {
// return true;
// } else if (obj2 instanceof DataType && ((DataType) obj2).getDataType().equalsIgnoreCase(DataType.NUMBER)) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[" + name + "]:数字控件右边必须是数字");
// }
// }
// if (componentKey.equals(ComponentType.DateComponent.toString())) {
// if (obj2 instanceof String && Validator.isDate((String) obj2)) {
// return true;
// } else if (obj2 instanceof DataType && ((DataType) obj2).getDataType().equalsIgnoreCase(DataType.STRING)) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[" + name + "]:日期控件右边必须是日期字符串");
// }
//
// }
// if (componentKey.equals(ComponentType.TimeComponent.toString())) {
// if (obj2 instanceof String && Validator.isTime((String) obj2)) {
// return true;
// } else if (obj2 instanceof DataType && ((DataType) obj2).getDataType().equalsIgnoreCase(DataType.STRING)) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[" + name + "]:时间控件右边必须是时间字符串");
// }
// }
// }
// throw new RuntimeException("筛选条件[" + name + "]:左边必须是数字控件或时间控件");
// }
//
// /**
// * 校验等于号的入参
// *
// * @param obj1
// * @param obj2
// * @return
// */
// public static boolean checkEqParam(Object obj1, Object obj2) {
// if (obj1 instanceof DataType) {
// String componentKey = ((FormField) obj1).getComponentKey();
// if (ComponentConfig.isNumberComponent(componentKey)) {
// if (obj2 instanceof DataType) {
// if (((DataType) obj2).getDataType().equalsIgnoreCase(DataType.NUMBER)) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[=]:数字控件右边必须是数字");
// }
// } else if (StringUtils.isEmpty(obj2 + "") || Validator.isFloat(obj2 + "")) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[=]:数字控件右边必须是数字");
// }
// } else if (ComponentConfig.isOptionComponent(componentKey)) {
// if (StringUtils.isEmpty(obj2 + "") || (obj2 instanceof DataType && ((DataType) obj2).getDataType().equalsIgnoreCase(DataType.OPTION))) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[=]:选项控件右边必须是选项");
// }
// } else {
// if (StringUtils.isEmpty(obj2 + "") || obj2 instanceof String || obj2 instanceof Character) {
// return true;
// } else if (obj2 instanceof DataType) {
// if (((DataType) obj2).getDataType().equalsIgnoreCase(DataType.STRING)) {
// return true;
// } else if (((DataType) obj2).getDataType().equalsIgnoreCase(DataType.STRING)) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[=]:文本控件右边必须是字符");
// }
// } else {
// throw new RuntimeException("筛选条件[=]:文本控件右边必须是字符");
// }
// }
// }
// throw new RuntimeException("筛选条件[=]:左边必须是表单控件");
// }
//
// /**
// * 校验不等于号的入参
// *
// * @param obj1
// * @param obj2
// * @return
// */
// public static boolean checkNotEqParam(Object obj1, Object obj2) {
// if (obj1 instanceof FormField) {
// String componentKey = ((FormField) obj1).getComponentKey();
// if (ComponentConfig.isNumberComponent(componentKey)) {
// if (obj2 instanceof DataType) {
// if (((DataType) obj2).getDataType().equalsIgnoreCase(DataType.NUMBER)) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[!=]:数字控件右边必须是数字");
// }
// } else if (StringUtils.isEmpty(obj2 + "") || Validator.isFloat(obj2 + "")) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[!=]:数字控件右边必须是数字");
// }
// } else if (ComponentConfig.isOptionComponent(componentKey)) {
// if (StringUtils.isEmpty(obj2 + "") || (obj2 instanceof DataType && ((DataType) obj2).getDataType().equalsIgnoreCase(DataType.OPTION))) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[!=]:选项控件右边必须是选项");
// }
// } else {
// if (StringUtils.isEmpty(obj2 + "") || obj2 instanceof String || obj2 instanceof Character) {
// return true;
// } else if (obj2 instanceof DataType) {
// if (((DataType) obj2).getDataType().equalsIgnoreCase(DataType.STRING)) {
// return true;
// } else if (((DataType) obj2).getDataType().equalsIgnoreCase(DataType.STRING)) {
// return true;
// } else if (((DataType) obj2).getDataType().equalsIgnoreCase(DataType.STRING)) {
// return true;
// } else {
// throw new RuntimeException("筛选条件[!=]:文本控件右边必须是字符");
// }
// } else {
// throw new RuntimeException("筛选条件[!=]:文本控件右边必须是字符");
// }
// }
// }
// throw new RuntimeException("筛选条件[!=]:左边必须是表单控件");
// }
//}

243
src/com/engine/salary/formlua/func/compare/EqOperator.java Normal file
View File

@ -0,0 +1,243 @@
package com.engine.salary.formlua.func.compare;
import com.alibaba.fastjson.JSON;
import com.engine.salary.formlua.core.exception.ErrorType;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.CompareUtil;
import com.engine.salary.formlua.util.DateUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.ArraySwap;
import com.ql.util.express.InstructionSetContext;
import com.ql.util.express.OperateData;
import com.ql.util.express.instruction.op.OperatorEqualsLessMore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
public class EqOperator extends OperatorEqualsLessMore {
protected final Logger logger = LoggerFactory.getLogger(getClass());
public EqOperator(String aName) {
super(aName);
}
public EqOperator(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
@Override
public OperateData executeInner(InstructionSetContext context, ArraySwap list) throws Exception {
return super.executeInner(context, list);
}
@Override
public Object executeInner(Object... list) throws Exception {
DataType result=new DataType();
result.setDataType(DataType.BOOL);
logger.info("等于号参数："+JSON.toJSONString(list));
String oper="=";
if(list.length!=2){
throw new RuntimeException("[=]"+ ErrorType.MAX_VAR_COUNT.name());
}
Object op1=list[0];
Object op2=list[1];
//校验参数类型
String datatype= ExcelParamUtil.checkParamType(op1);
String dataType2=ExcelParamUtil.checkParamType(op2);
if(op2 instanceof Object[]){
Object[] objectParams=(Object[])op2;
if(objectParams[0] instanceof DataType){
DataType paramDataType=(DataType)objectParams[0];
dataType2=paramDataType.getDataType();
}else{
dataType2=ExcelParamUtil.checkParamType(objectParams[0]);
}
}
if(datatype.equals(DataType.OPTION)||dataType2.equals(DataType.OPTION)){
//对option的特殊处理，获取option的字符串后根据逗号分割，然后排序数组，数组长度不一致返回false，一致则循环对比直到同样下标的数据不一致返回false，否则为true
try {
String[] firstOptions=new String[]{};
String[] secondOptions=new String[]{};
result.setContent(true);
firstOptions= CompareUtil.genArray(op1,"option");
secondOptions=CompareUtil.genArray(op2,"option");
Arrays.sort(firstOptions);
Arrays.sort(secondOptions);
// logger.info("比较选项："+JSON.toJSONString(firstOptions)+"-->"+JSON.toJSONString(secondOptions));
if(firstOptions.length!=secondOptions.length){
result.setContent(false);
}else{
int i=0;
for (;i<firstOptions.length;i++){
boolean loopresult=OperatorEqualsLessMore.executeInner("=",firstOptions[i],secondOptions[i]);
logger.info("比较选项结果"+loopresult);
if(!loopresult){
result.setContent(false);
break;
}
}
}
} catch (Exception e) {
logger.error("err",e);
result.setContent(false);
}
}else if(op1 instanceof DataType && op2 instanceof DataType && DateUtil.isDateComponent(op1) && DateUtil.isDateComponent(op2)){
DataType dataTypeOne=(DataType)op1;
DataType dataTypeTwo=(DataType)op2;
boolean dateResult=false;
Date firstDate= DateUtil.buildDateByDateChar(dataTypeOne.getContent()==null?"":dataTypeOne.getContent()+"");
Date secondDate=DateUtil.buildDateByDateChar(dataTypeTwo.getContent()==null?"":dataTypeTwo.getContent()+"");
if(firstDate==null || secondDate ==null){
dateResult= false;
}else if (firstDate == null && secondDate == null){
dateResult= true;
}else{
dateResult= firstDate.getTime()==secondDate.getTime();
}
result.setContent(dateResult);
}else {
try {
List<Object> dataList=ExcelParamUtil.converParamValue(op1,op2);
if(ExcelParamUtil.getParamType(op1).toLowerCase().equals("double")||ExcelParamUtil.getParamType(op2).toLowerCase().equals("double")){
boolean r=OperatorEqualsLessMore.executeInner("=",ExcelParamUtil.convertParamValToNumber(dataList.get(0)),ExcelParamUtil.convertParamValToNumber(dataList.get(1)));
result.setContent(r);
}else if(op1 instanceof DataType && op2 instanceof DataType && DateUtil.isDateComponent(op1) && DateUtil.isDateComponent(op2)){
Object dateStringOne=null;
if(op1 instanceof DataType){
DataType dataTypeOne=(DataType)op1;
dateStringOne=dataTypeOne.getContent();
}else{
dateStringOne=op1;
}
Object dateStringTwo=null;
if(op2 instanceof DataType){
DataType dataTypeTwo=(DataType)op2;
dateStringTwo=dataTypeTwo.getContent();
}else{
dateStringTwo=op2;
}
boolean dateResult=false;
Date firstDate=DateUtil.buildDateByDateChar(dateStringOne==null?"":dateStringOne+"");
Date secondDate= DateUtil.buildDateByDateChar(dateStringTwo==null?"":dateStringTwo+"");
if (firstDate == null && secondDate == null){
dateResult= true;
}else if(firstDate==null || secondDate ==null){
dateResult= false;
}else{
dateResult= firstDate.getTime()==secondDate.getTime();
}
result.setContent(dateResult);
}else {
Object firstParam=ExcelParamUtil.getParamContent(dataList.get(0),"");
Object secondParam=ExcelParamUtil.getParamContent(dataList.get(1),"");
logger.info("等于号比较："+firstParam+"-->"+secondParam);
if((firstParam instanceof String || firstParam instanceof Character) && (secondParam instanceof String || secondParam instanceof Character)){
if(firstParam.toString().length()==1&&secondParam.toString().length()==1){
boolean r=firstParam.toString().equals(secondParam.toString());
result.setContent(r);
return result;
}
}
boolean r=OperatorEqualsLessMore.executeInner("=",firstParam,secondParam);
result.setContent(r);
}
} catch (Exception e) {
logger.error("err",e);
}
}
// buildFilterParam(result,op1,op2);
return result;
}
/**
* 构建搜索条件参数
* @param dataType
* @param obj1
* @param obj2
*/
// private void buildFilterParam(DataType dataType,Object obj1,Object obj2){
// List<FormulaFilterData> filterFormDataList=new ArrayList<>();
// FormulaFilterData filterData=new FormulaFilterData();
// String content = null;
// try {
// if(obj1!=null && (obj1 instanceof DataType)){
// DataType dataType1=(DataType)obj1;
// if(StringUtils.isEmpty(dataType1.getComponentKey())){
// dataType1.setComponentKey(dataType1.getDataType());
// }
// if(obj2 instanceof DataType) {
//// content = ((DataType) obj2).getContent()+"";
// DataType paramDataType=(DataType) obj2;
// if(paramDataType==null || paramDataType.getContent() == null){
// content = "";
// }else{
// content = paramDataType.getContent()+"";
// }
// }else {
// content = obj2+"";
// }
// if ( content != null) {
// filterData.setFieldId(dataType1.getFieldId());
// if(dataType1.getSubFormId() != null) {
// filterData.setSubFormId(dataType1.getSubFormId()+"");
// }
//
// filterData.setComponentKey(dataType1.getComponentKey());
// if(StringUtils.isEmpty(content)) {
// filterData.setTerm(FilterFormData.TERM_NULL);
// }else{
// filterData.setTerm(FilterFormData.TERM_EQ);
// if(StringUtils.isNotEmpty(dataType1.getComponentKey())){
// //数字类型
// if(ComponentConfig.isNumberComponent(dataType1.getComponentKey())
// || dataType1.getComponentKey().equals(ComponentType.DateComponent.toString())
// || dataType1.getComponentKey().equals(ComponentType.TimeComponent.toString())
// || dataType1.getComponentKey().equalsIgnoreCase(DataType.STRING)
// || dataType1.getComponentKey().equalsIgnoreCase(DataType.NUMBER)||
// dataType1.getComponentKey().equalsIgnoreCase(DataType.DATE)
// || dataType1.getComponentKey().equalsIgnoreCase(DataType.BOOL)
// ) {
// filterData.setContent(content);
// //选项控件
// }else if(ComponentConfig.isOptionComponent(dataType1.getComponentKey())) {
// List<String> ids = new ArrayList<>();
// String[] idsArray = content.split(",");
// for(String idStr : idsArray) {
// if(StringUtils.isNotBlank(idStr)) {
// ids.add(idStr);
// }
// }
// filterData.setIds(ids);
// //文本型
// }else {
// filterData.setContent(content);
// }
// }
//
// }
// }
// if(filterData!=null){
// filterFormDataList.add(filterData);
// }
//
// logger.info("=号构建过滤参数："+(filterFormDataList!=null? JSON.toJSONString(filterFormDataList):"NULL"));
// dataType.setFormulaFilterDataList(filterFormDataList);
// dataType.setComponentKey(dataType1.getComponentKey());
// dataType.setSubFormId(dataType1.getSubFormId());
// }
// } catch (Exception e) {
// logger.error("err",e);
// }
//
// }
}

104
src/com/engine/salary/formlua/func/compare/GreaterEqOperator.java Normal file
View File

@ -0,0 +1,104 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.CompareUtil;
import com.engine.salary.formlua.util.DateUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorEqualsLessMore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
public class GreaterEqOperator extends OperatorEqualsLessMore {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object op1, Object op2) throws Exception {
DataType result = new DataType();
result.setDataType(DataType.BOOL);
String datatype = ExcelParamUtil.checkParamType(op1);
//对option的特殊处理，获取option的字符串后根据逗号分割，然后排序数组，数组长度不一致返回false，一致则循环对比直到同样下标的数据不一致返回false，否则为true
try {
if (datatype.equals(DataType.OPTION)) {
result.setContent(true);
String[] firstOptions = new String[]{};
String[] secondOptions = new String[]{};
firstOptions = CompareUtil.genArray(op1, "option");
secondOptions = CompareUtil.genArray(op2, "option");
Arrays.sort(firstOptions);
Arrays.sort(secondOptions);
if (firstOptions.length != secondOptions.length) {
result.setContent(false);
} else {
int i = 0;
for (; i < firstOptions.length; i++) {
boolean loopresult = OperatorEqualsLessMore.executeInner(">=", firstOptions[i], secondOptions[i]);
if (!loopresult) {
result.setContent(false);
break;
}
}
}
} else if (op1 instanceof DataType && op2 instanceof DataType && DateUtil.isDateComponent(op1) && DateUtil.isDateComponent(op2)) {
Object dateStringOne = null;
if (op1 instanceof DataType) {
DataType dataTypeOne = (DataType) op1;
dateStringOne = dataTypeOne.getContent();
} else {
dateStringOne = op1;
}
Object dateStringTwo = null;
if (op2 instanceof DataType) {
DataType dataTypeTwo = (DataType) op2;
dateStringTwo = dataTypeTwo.getContent();
} else {
dateStringTwo = op2;
}
boolean dateResult = false;
Date firstDate = DateUtil.buildDateByDateChar(dateStringOne == null ? "" : dateStringOne + "");
Date secondDate = DateUtil.buildDateByDateChar(dateStringTwo == null ? "" : dateStringTwo + "");
if (firstDate == null && secondDate == null) {
dateResult = true;
} else if (firstDate == null && secondDate != null) {
dateResult = false;
} else if (firstDate != null && secondDate == null) {
dateResult = true;
} else {
dateResult = firstDate.getTime() >= secondDate.getTime();
}
result.setContent(dateResult);
} else {
List<Object> dataList = ExcelParamUtil.converParamValue(op1, op2);
boolean r;
if (ExcelParamUtil.getParamType(op1).toLowerCase().equals("double") || ExcelParamUtil.getParamType(op2).toLowerCase().equals("double")) {
r = OperatorEqualsLessMore.executeInner(">=", ExcelParamUtil.convertParamValToNumber(dataList.get(0)), ExcelParamUtil.convertParamValToNumber(dataList.get(1)));
} else {
r = OperatorEqualsLessMore.executeInner(">=", ExcelParamUtil.getParamContent(dataList.get(0), ""), ExcelParamUtil.getParamContent(dataList.get(1), ""));
}
result.setContent(r);
}
} catch (Exception e) {
logger.error("err", e);
result.setContent(false);
}
// Compareutils.buildLessMoreFilterParam(result,this.name,op1,op2);
return result;
}
public GreaterEqOperator(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
public GreaterEqOperator(String aName) {
super(aName);
}
}

105
src/com/engine/salary/formlua/func/compare/GreaterOperator.java Normal file
View File

@ -0,0 +1,105 @@
package com.engine.salary.formlua.func.compare;
import com.alibaba.fastjson.JSON;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.CompareUtil;
import com.engine.salary.formlua.util.DateUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorEqualsLessMore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
import java.util.Date;
public class GreaterOperator extends OperatorEqualsLessMore {
protected final Logger logger = LoggerFactory.getLogger(getClass());
@Override
public Object executeInner(Object op1, Object op2) throws Exception {
DataType result = new DataType();
result.setDataType(DataType.BOOL);
// IgnoreParamFilter.filterCompareFunc(op1,op2,">");
String datatype = ExcelParamUtil.checkParamType(op1);
logger.info("大于号比较：" + JSON.toJSONString(op1) + "-->" + JSON.toJSONString(op2));
//对option的特殊处理，获取option的字符串后根据逗号分割，然后排序数组，数组长度不一致返回false，一致则循环对比直到同样下标的数据不一致返回false，否则为true
try {
if (datatype.equals(DataType.OPTION)) {
result.setContent(true);
String[] firstOptions = new String[]{};
String[] secondOptions = new String[]{};
firstOptions = CompareUtil.genArray(op1, "option");
secondOptions = CompareUtil.genArray(op2, "option");
Arrays.sort(firstOptions);
Arrays.sort(secondOptions);
if (firstOptions.length != secondOptions.length) {
result.setContent(false);
} else {
int i = 0;
for (; i < firstOptions.length; i++) {
boolean loopresult = OperatorEqualsLessMore.executeInner(">", firstOptions[i], secondOptions[i]);
if (!loopresult) {
result.setContent(false);
break;
}
}
}
} else if (op1 instanceof DataType && op2 instanceof DataType && DateUtil.isDateComponent(op1) && DateUtil.isDateComponent(op2)) {
Object dateStringOne = null;
if (op1 instanceof DataType) {
DataType dataTypeOne = (DataType) op1;
dateStringOne = dataTypeOne.getContent();
} else {
dateStringOne = op1;
}
Object dateStringTwo = null;
if (op2 instanceof DataType) {
DataType dataTypeTwo = (DataType) op2;
dateStringTwo = dataTypeTwo.getContent();
} else {
dateStringTwo = op2;
}
boolean dateResult = false;
Date firstDate = DateUtil.buildDateByDateChar(dateStringOne == null ? "" : dateStringOne + "");
Date secondDate = DateUtil.buildDateByDateChar(dateStringTwo == null ? "" : dateStringTwo + "");
if (firstDate == null && secondDate == null) {
dateResult = false;
} else if (firstDate == null && secondDate != null) {
dateResult = false;
} else if (firstDate != null && secondDate == null) {
dateResult = true;
} else {
dateResult = firstDate.getTime() > secondDate.getTime();
}
result.setContent(dateResult);
} else {
logger.info("参数1：" + ExcelParamUtil.convertParamValToNumber(op1) + "");
logger.info("参数2：" + ExcelParamUtil.convertParamValToNumber(op2) + "");
boolean r;
if (ExcelParamUtil.getParamType(op1).toLowerCase().equals("double") || ExcelParamUtil.getParamType(op2).toLowerCase().equals("double")) {
r = OperatorEqualsLessMore.executeInner(">", ExcelParamUtil.convertParamValToNumber(op1), ExcelParamUtil.convertParamValToNumber(op2));
} else {
r = OperatorEqualsLessMore.executeInner(">", ExcelParamUtil.getParamContent(op1, ""), ExcelParamUtil.getParamContent(op2, ""));
}
result.setContent(r);
}
} catch (Exception e) {
logger.error("err", e);
result.setContent(false);
}
// Compareutils.buildLessMoreFilterParam(result, this.name, op1, op2);
return result;
}
public GreaterOperator(String aName) {
super(aName);
}
public GreaterOperator(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
}

97
src/com/engine/salary/formlua/func/compare/InOperator.java Normal file
View File

@ -0,0 +1,97 @@
package com.engine.salary.formlua.func.compare;
import com.alibaba.fastjson.JSON;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.func.logic.LogicUtils;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.engine.salary.formlua.util.IgnoreParamFilter;
import com.ql.util.express.instruction.op.OperatorIn;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
public class InOperator extends OperatorIn {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object[] list) throws Exception {
DataType result=new DataType();
result.setDataType(DataType.BOOL);
if(list.length<1||list[1]==null){
Integer number= IgnoreParamFilter.getSetFuncNumber("IN");
}
List<Object> paramList=new ArrayList<>();
paramList.add(list[0]);
Object[] objectArray=(Object[])list[1];
for (int i=0;i<objectArray.length;i++){
paramList.add(ExcelParamUtil.getParamContent(objectArray[i],"string"));
}
// IgnoreParamFilter.filterInFunc(paramList,"IN");
if(list.length==0){
result.setContent(false);
return result;
}
paramList=new ArrayList<>();
paramList.add(null);
List<Object> dataArray=new ArrayList<>();
if(list[0] instanceof DataType){
DataType dataType=(DataType)list[0];
if(dataType.getDataType().equals(DataType.OPTION)){
if(dataType.getContent()!=null){
String[] arrys=dataType.getContent().toString().split(",");
for (int i=0;i<arrys.length;i++){
dataArray.add(arrys[i]);
}
}
}else {
dataArray.add(ExcelParamUtil.getParamContent(dataType,"string"));
}
}else {
dataArray.add(ExcelParamUtil.getParamContent(list[0],"string"));
}
for (int i=0;i<objectArray.length;i++){
if(objectArray[i] instanceof DataType){
DataType dataType=(DataType)objectArray[i];
if(dataType.getDataType().equalsIgnoreCase(DataType.OPTION)){
paramList.add(ExcelParamUtil.getParamContent(objectArray[i],""));
}else{
paramList.add(ExcelParamUtil.getParamContent(objectArray[i],"string"));
}
}else {
paramList.add(ExcelParamUtil.getParamContent(objectArray[i],"string"));
}
}
for (Object object:dataArray){
if(paramList.get(0)!=null){
paramList.remove(0);
}
paramList.add(0,object);
logger.info("IN函数参数："+ JSON.toJSONString(paramList));
boolean isIn=(boolean)super.executeInner(paramList.toArray());
logger.info("IN函数执行结果："+isIn);
if(!isIn){
result.setContent(false);
break;
}else{
result.setContent(true);
}
}
if(result.getContent() == null){
result.setContent(false);
}
LogicUtils.buildInFilterParam(result,list);
return result;
}
public InOperator(String aName) {
super(aName);
}
public InOperator(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
}

103
src/com/engine/salary/formlua/func/compare/LessEqOperator.java Normal file
View File

@ -0,0 +1,103 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.CompareUtil;
import com.engine.salary.formlua.util.DateUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorEqualsLessMore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
public class LessEqOperator extends OperatorEqualsLessMore {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object op1, Object op2) throws Exception {
DataType result=new DataType();
result.setDataType(DataType.BOOL);
// IgnoreParamFilter.filterCompareFunc(op1,op2,"<=");
String datatype= ExcelParamUtil.checkParamType(op1);
//对option的特殊处理，获取option的字符串后根据逗号分割，然后排序数组，数组长度不一致返回false，一致则循环对比直到同样下标的数据不一致返回false，否则为true
try {
if(datatype.equals(DataType.OPTION)){
result.setContent(true);
String[] firstOptions=new String[]{};
String[] secondOptions=new String[]{};
firstOptions= CompareUtil.genArray(op1,"option");
secondOptions=CompareUtil.genArray(op2,"option");
Arrays.sort(firstOptions);
Arrays.sort(secondOptions);
if(firstOptions.length!=secondOptions.length){
result.setContent(false);
}else{
int i=0;
for (;i<firstOptions.length;i++){
boolean loopresult=OperatorEqualsLessMore.executeInner("<=",firstOptions[i],secondOptions[i]);
if(!loopresult){
result.setContent(false);
break;
}
}
}
}else if(op1 instanceof DataType && op2 instanceof DataType && DateUtil.isDateComponent(op1) && DateUtil.isDateComponent(op2)){
Object dateStringOne=null;
if(op1 instanceof DataType){
DataType dataTypeOne=(DataType)op1;
dateStringOne=dataTypeOne.getContent();
}else{
dateStringOne=op1;
}
Object dateStringTwo=null;
if(op2 instanceof DataType){
DataType dataTypeTwo=(DataType)op2;
dateStringTwo=dataTypeTwo.getContent();
}else{
dateStringTwo=op2;
}
boolean dateResult=false;
Date firstDate=DateUtil.buildDateByDateChar(dateStringOne==null?"":dateStringOne+"");
Date secondDate= DateUtil.buildDateByDateChar(dateStringTwo==null?"":dateStringTwo+"");
if (firstDate == null && secondDate == null){
dateResult= true;
}else if(firstDate==null && secondDate !=null){
dateResult= true;
}else if(firstDate!=null && secondDate ==null){
dateResult= false;
}else{
dateResult= firstDate.getTime()<=secondDate.getTime();
}
result.setContent(dateResult);
}else {
List<Object> dataList=ExcelParamUtil.converParamValue(op1,op2);
boolean r;
if(ExcelParamUtil.getParamType(op1).toLowerCase().equals("double")||ExcelParamUtil.getParamType(op2).toLowerCase().equals("double")){
r=OperatorEqualsLessMore.executeInner("<=",ExcelParamUtil.convertParamValToNumber(dataList.get(0)),ExcelParamUtil.convertParamValToNumber(dataList.get(1)));
}else {
r=OperatorEqualsLessMore.executeInner("<=",ExcelParamUtil.getParamContent(dataList.get(0),""),ExcelParamUtil.getParamContent(dataList.get(1),""));
}
result.setContent(r);
}
} catch (Exception e) {
logger.error("err",e);
result.setContent(false);
}
// Compareutils.buildLessMoreFilterParam(result,this.name,op1,op2);
return result;
}
public LessEqOperator(String aName) {
super(aName);
}
public LessEqOperator(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
}

104
src/com/engine/salary/formlua/func/compare/LessOperator.java Normal file
View File

@ -0,0 +1,104 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.CompareUtil;
import com.engine.salary.formlua.util.DateUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorEqualsLessMore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
public class LessOperator extends OperatorEqualsLessMore {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object op1, Object op2) throws Exception {
DataType result=new DataType();
result.setDataType(DataType.BOOL);
// IgnoreParamFilter.filterCompareFunc(op1,op2,"<");
String datatype= ExcelParamUtil.checkParamType(op1);
//对option的特殊处理，获取option的字符串后根据逗号分割，然后排序数组，数组长度不一致返回false，一致则循环对比直到同样下标的数据不一致返回false，否则为true
try {
if(datatype.equals(DataType.OPTION)){
result.setContent(true);
String[] firstOptions=new String[]{};
String[] secondOptions=new String[]{};
firstOptions= CompareUtil.genArray(op1,"option");
secondOptions=CompareUtil.genArray(op2,"option");
Arrays.sort(firstOptions);
Arrays.sort(secondOptions);
if(firstOptions.length!=secondOptions.length){
result.setContent(false);
}else{
int i=0;
for (;i<firstOptions.length;i++){
boolean loopresult=OperatorEqualsLessMore.executeInner("<",firstOptions[i],secondOptions[i]);
if(!loopresult){
result.setContent(false);
break;
}
}
}
}else if(op1 instanceof DataType && op2 instanceof DataType && DateUtil.isDateComponent(op1) && DateUtil.isDateComponent(op2)){
Object dateStringOne=null;
if(op1 instanceof DataType){
DataType dataTypeOne=(DataType)op1;
dateStringOne=dataTypeOne.getContent();
}else{
dateStringOne=op1;
}
Object dateStringTwo=null;
if(op2 instanceof DataType){
DataType dataTypeTwo=(DataType)op2;
dateStringTwo=dataTypeTwo.getContent();
}else{
dateStringTwo=op2;
}
boolean dateResult=false;
Date firstDate=DateUtil.buildDateByDateChar(dateStringOne==null?"":dateStringOne+"");
Date secondDate= DateUtil.buildDateByDateChar(dateStringTwo==null?"":dateStringTwo+"");
if (firstDate == null && secondDate == null){
dateResult= false;
}else if( (firstDate==null && secondDate !=null) ){
dateResult= true;
}else if( (firstDate!=null && secondDate ==null) ){
dateResult= false;
}else{
dateResult= firstDate.getTime()<secondDate.getTime();
}
result.setContent(dateResult);
}else {
List<Object> dataList=ExcelParamUtil.converParamValue(op1,op2);
boolean r;
if(ExcelParamUtil.getParamType(op1).toLowerCase().equals("double")||ExcelParamUtil.getParamType(op2).toLowerCase().equals("double")){
r=OperatorEqualsLessMore.executeInner("<",ExcelParamUtil.convertParamValToNumber(dataList.get(0)),ExcelParamUtil.convertParamValToNumber(dataList.get(1)));
}else {
r=OperatorEqualsLessMore.executeInner("<",ExcelParamUtil.getParamContent(dataList.get(0),""),ExcelParamUtil.getParamContent(dataList.get(1),""));
}
result.setContent(r);
}
} catch (Exception e) {
logger.error("err",e);
result.setContent(false);
}
// Compareutils.buildLessMoreFilterParam(result,this.name,op1,op2);
return result;
}
public LessOperator(String aName) {
super(aName);
}
public LessOperator(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
}

102
src/com/engine/salary/formlua/func/compare/NotEqueOperator.java Normal file
View File

@ -0,0 +1,102 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.CompareUtil;
import com.engine.salary.formlua.util.DateUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorEqualsLessMore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;
import java.util.List;
public class NotEqueOperator extends OperatorEqualsLessMore {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object op1, Object op2) throws Exception {
DataType result = new DataType();
result.setDataType(DataType.BOOL);
// IgnoreParamFilter.filterCompareFunc(op1,op2,"!=");
String datatype = ExcelParamUtil.checkParamType(op1);
//对option的特殊处理，获取option的字符串后根据逗号分割，然后排序数组，数组长度不一致返回false，一致则循环对比直到同样下标的数据不一致返回false，否则为true
try {
if (datatype.equals(DataType.OPTION)) {
result.setContent(true);
String[] firstOptions = new String[]{};
String[] secondOptions = new String[]{};
firstOptions = CompareUtil.genArray(op1, "option");
secondOptions = CompareUtil.genArray(op2, "option");
if (firstOptions.length != secondOptions.length) {
result.setContent(true);
} else {
int i = 0;
for (; i < firstOptions.length; i++) {
boolean loopresult = OperatorEqualsLessMore.executeInner("!=", firstOptions[i], secondOptions[i]);
if (!loopresult) {
result.setContent(false);
break;
}
}
}
} else if (op1 instanceof DataType && op2 instanceof DataType && DateUtil.isDateComponent(op1) && DateUtil.isDateComponent(op2)) {
Object dateStringOne = null;
if (op1 instanceof DataType) {
DataType dataTypeOne = (DataType) op1;
dateStringOne = dataTypeOne.getContent();
} else {
dateStringOne = op1;
}
Object dateStringTwo = null;
if (op2 instanceof DataType) {
DataType dataTypeTwo = (DataType) op2;
dateStringTwo = dataTypeTwo.getContent();
} else {
dateStringTwo = op2;
}
boolean dateResult = false;
Date firstDate = DateUtil.buildDateByDateChar(dateStringOne == null ? "" : dateStringOne + "");
Date secondDate = DateUtil.buildDateByDateChar(dateStringTwo == null ? "" : dateStringTwo + "");
if (firstDate == null && secondDate == null) {
dateResult = false;
} else if ((firstDate == null && secondDate != null) || (firstDate != null && secondDate == null)) {
dateResult = true;
} else {
dateResult = firstDate.getTime() != secondDate.getTime();
}
result.setContent(dateResult);
} else {
List<Object> dataList = ExcelParamUtil.converParamValue(op1, op2);
Object firstParam = ExcelParamUtil.getParamContent(dataList.get(0), "");
Object secondParam = ExcelParamUtil.getParamContent(dataList.get(1), "");
if ((firstParam instanceof String || firstParam instanceof Character) && (secondParam instanceof String || secondParam instanceof Character)) {
if (firstParam.toString().length() == 1 && secondParam.toString().length() == 1) {
boolean r = !(firstParam.toString().equals(secondParam.toString()));
result.setContent(r);
return result;
}
}
boolean r = OperatorEqualsLessMore.executeInner("!=", firstParam, secondParam);
result.setContent(r);
}
} catch (Exception e) {
logger.error("err", e);
result.setContent(false);
}
// Compareutils.buildNotEqFilterParam(result, op1, op2);
return result;
}
public NotEqueOperator(String aName) {
super(aName);
}
public NotEqueOperator(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
}

38
src/com/engine/salary/formlua/func/compare/OperatorInTest.java Normal file
View File

@ -0,0 +1,38 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.engine.salary.formlua.util.IgnoreParamFilter;
import com.ql.util.express.instruction.op.OperatorIn;
import java.util.ArrayList;
import java.util.List;
public class OperatorInTest extends OperatorIn {
@Override
public Object executeInner(Object[] list) throws Exception {
DataType result=new DataType();
result.setDataType(DataType.BOOL);
result.setContent(true);
if(list.length<2||list[1]==null){
Integer number= IgnoreParamFilter.getSetFuncNumber("IN");
}
List<Object> paramList=new ArrayList<>();
paramList.add(list[0]);
Object[] objectArray=(Object[])list[1];
for (int i=0;i<objectArray.length;i++){
paramList.add(ExcelParamUtil.getParamContent(objectArray[i],"string"));
}
return result;
}
public OperatorInTest(String aName) {
super(aName);
}
public OperatorInTest(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
}

60
src/com/engine/salary/formlua/func/compare/WOperatorAdd.java Normal file
View File

@ -0,0 +1,60 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorAdd;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.math.BigDecimal;
import java.util.List;
public class WOperatorAdd extends OperatorAdd {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object[] list) throws Exception {
DataType dataType=new DataType();
dataType.setDataType(DataType.NUMBER);
Object[] newList=new Object[2];
// IgnoreParamFilter.checkNumberOper(list,"+");
Object firstParam= ExcelParamUtil.getParamContent(list[0],"");
Object secondParam=ExcelParamUtil.getParamContent(list[1],"");
if(firstParam instanceof Object[] && secondParam instanceof Object[]){
Object[] arrayResult= operArray(firstParam,secondParam);
return arrayResult;
}
newList[0]=firstParam;
newList[1]=secondParam;
Object exeResult= null;
try {
Object result = super.executeInner(newList);
exeResult=new BigDecimal(result.toString());
} catch (Exception e) {
logger.error("err",e);
exeResult=0;
}
dataType.setContent(exeResult);
return dataType;
}
public WOperatorAdd(String name) {
super(name);
}
public WOperatorAdd(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
public Object[] operArray(Object obj1, Object obj2) throws Exception{
Object[] param1=(Object[])obj1;
Object[] results=new Object[param1.length];
List<Object[]> operList= CommonOper.operAddReduceList(obj1,obj2);
for (int i=0;i<operList.size();i++){
Object[] excuteArray=operList.get(i);
results[i]=super.executeInner(excuteArray);
}
return results;
}
}

67
src/com/engine/salary/formlua/func/compare/WOperatorDiv.java Normal file
View File

@ -0,0 +1,67 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorMultiDiv;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.math.BigDecimal;
import java.util.List;
/**
* @className：除法重写类
* @Description：注释
* @Author：
* @date：
*/
public class WOperatorDiv extends OperatorMultiDiv {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object[] list) throws Exception {
DataType result = new DataType();
result.setDataType(DataType.NUMBER);
Object[] newList = new Object[2];
// IgnoreParamFilter.checkNumberOper(list,"/");
Object firstParam = ExcelParamUtil.getParamContent(list[0], "");
Object secondParam = ExcelParamUtil.getParamContent(list[1], "");
if (StringUtils.isEmpty(firstParam + "") || StringUtils.isEmpty(secondParam + "")) {
result.setContent(0);
return result;
} else if (firstParam.toString().equalsIgnoreCase("0") || secondParam.toString().equalsIgnoreCase("0")) {
result.setContent(0);
return result;
}
if (firstParam instanceof Object[] || secondParam instanceof Object[]) {
try {
List<Object[]> operList = CommonOper.operDivMultiList(firstParam, secondParam, "/");
Object[] results = new Object[operList.size()];
for (int i = 0; i < operList.size(); i++) {
Object[] excuteArray = operList.get(i);
results[i] = super.executeInner(excuteArray);
}
return results;
} catch (Exception e) {
logger.error("err", e);
return 0;
}
}
newList[0] = firstParam;
newList[1] = secondParam;
try {
Object r = super.executeInner(newList);
logger.info("乘法运算：" + r.toString());
result.setContent(new BigDecimal(r + ""));
} catch (Exception e) {
logger.info("除法计算异常返回0：" + e.getMessage());
result.setContent(0);
}
return result;
}
public WOperatorDiv(String name) {
super(name);
}
}

55
src/com/engine/salary/formlua/func/compare/WOperatorMulti.java Normal file
View File

@ -0,0 +1,55 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorMultiDiv;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.math.BigDecimal;
import java.util.List;
public class WOperatorMulti extends OperatorMultiDiv {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object[] list) throws Exception {
DataType result=new DataType();
result.setDataType(DataType.NUMBER);
Object[] newList=new Object[2];
// IgnoreParamFilter.checkNumberOper(list,"*");
Object firstParam= ExcelParamUtil.getParamContent(list[0],"");
Object secondParam=ExcelParamUtil.getParamContent(list[1],"");
if(StringUtils.isEmpty(firstParam+"") || StringUtils.isEmpty(secondParam+"")){
result.setContent(0);
return result;
}
if(firstParam instanceof Object[] || secondParam instanceof Object[]){
List<Object[]> operList= CommonOper.operDivMultiList(firstParam,secondParam,"*");
Object[] results=new Object[operList.size()];
for (int i=0;i<operList.size();i++){
Object[] excuteArray=operList.get(i);
results[i]=super.executeInner(excuteArray);
}
return results;
}
newList[0]=firstParam;
newList[1]=secondParam;
Object r= null;
try {
Object multiResult = super.executeInner(newList);
r=new BigDecimal(multiResult+"");
} catch (Exception e) {
logger.error("err",e);
result.setContent(0);
return result;
}
result.setContent(r);
return result;
}
public WOperatorMulti(String name) {
super(name);
}
}

59
src/com/engine/salary/formlua/func/compare/WOperatorReduce.java Normal file
View File

@ -0,0 +1,59 @@
package com.engine.salary.formlua.func.compare;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.ql.util.express.instruction.op.OperatorReduce;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.math.BigDecimal;
import java.util.List;
/**
* @className：减法重写类
* @Description：注释
* @Author：
* @date：
*/
public class WOperatorReduce extends OperatorReduce {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public Object executeInner(Object[] list) throws Exception {
DataType result=new DataType();
result.setDataType(DataType.NUMBER);
Object[] newList=new Object[2];
// IgnoreParamFilter.checkNumberOper(list,"-");
Object firstParam= ExcelParamUtil.getParamContent(list[0],"");
Object secondParam=ExcelParamUtil.getParamContent(list[1],"");
if(firstParam instanceof Object[] && secondParam instanceof Object[]){
Object[] arrayResult= operArray(firstParam,secondParam);
return arrayResult;
}
newList[0]=firstParam;
newList[1]=secondParam;
Object r= null;
try {
Object reduceResult = super.executeInner(newList);
r=new BigDecimal(reduceResult+"");
} catch (Exception e) {
logger.error("err",e);
r=0;
}
result.setContent(r);
return result;
}
public WOperatorReduce(String name) {
super(name);
}
public Object[] operArray(Object obj1, Object obj2) throws Exception{
Object[] param1=(Object[])obj1;
Object[] results=new Object[param1.length];
List<Object[]> operList= CommonOper.operAddReduceList(obj1,obj2);
for (int i=0;i<operList.size();i++){
Object[] excuteArray=operList.get(i);
results[i]=super.executeInner(excuteArray);
}
return results;
}
}

92
src/com/engine/salary/formlua/func/date/DateTimeService.java Normal file
View File

@ -0,0 +1,92 @@
package com.engine.salary.formlua.func.date;
import com.engine.salary.formlua.entity.parameter.DataType;
public interface DateTimeService {
DataType now(Object... objects);
DataType today(Object... objects);
DataType dateDiff(Object... objects);
DataType dateAdd(Object... objects);
DataType dateFormat(Object... objects);
DataType year(Object... objects);
DataType month(Object... objects);
DataType day(Object... objects);
DataType hour(Object... objects);
DataType minute(Object... objects);
DataType seconds(Object... objects);
DataType weekNum(Object... objects);
DataType weekDay(Object... objects);
DataType dayOfMonth(Object... objects);
DataType monthOfYear(Object... objects);
DataType maxDate(Object... objects);
DataType minDate(Object... objects);
/**
*
* @param objects
* @return
*/
DataType timeOfDay(Object... objects);
DataType eoMonth(Object... objects);
/**
* 工作日间隔时间
* @param objects
* @return
*/
// DataType workdayIntl(Object... objects);
/**
* 日期比较，返回两个日期指定时间域的差值。
* 可比较的时间域包括"Y"-比较年;"M"-比较月;"D"-比较日;"H"-比较小时;"m"-比较分钟;"S"-比较秒.
* @param objects
* @return
*/
DataType compareDate(Object... objects);
/**
* 当前年
* @return
*/
DataType currYear(Object... objects);
/**
* 当前月
* @return
*/
DataType currMonth(Object... objects);
/**
* 当前天（当前月第几天）
* @return
*/
DataType currDay(Object... objects);
/**
* 当年周（当前月第几周）
* @return
*/
DataType currWeek(Object... objects);
/**
* 当前小时
* @return
*/
DataType currHour(Object... objects);
/**
* 当前分钟
* @return
*/
DataType currMinute(Object... objects);
/**
* 当前秒
* @return
*/
DataType currSecond(Object... objects);
}

1324
src/com/engine/salary/formlua/func/date/DateTimeServiceImpl.java Normal file
View File

File diff suppressed because it is too large Load Diff

15
src/com/engine/salary/formlua/func/finance/FinanceService.java Normal file
View File

@ -0,0 +1,15 @@
package com.engine.salary.formlua.func.finance;
import com.engine.salary.formlua.entity.parameter.DataType;
/**
* 财务函数分类
*/
public interface FinanceService {
/**
* 金额转换
* @param objects
* @return
*/
public DataType getMoney(Object... objects);
}

119
src/com/engine/salary/formlua/func/finance/FinanceServiceImpl.java Normal file
View File

@ -0,0 +1,119 @@
package com.engine.salary.formlua.func.finance;
import com.engine.salary.formlua.entity.parameter.DataType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.math.BigDecimal;
public class FinanceServiceImpl implements FinanceService{
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public DataType getMoney(Object... objects) {
DataType moneyDataType=new DataType();
moneyDataType.setDataType(DataType.STRING);
moneyDataType.setContent("");
if(objects!=null && objects.length>0){
String money=null;
if(objects[0] instanceof DataType){
DataType dataType=(DataType)objects[0];
money=dataType.getContent()==null?null:dataType.getContent().toString();
}else{
if(objects[0]!=null){
money=objects[0].toString();
}
}
moneyDataType=convertCurrency(money);
}
return moneyDataType;
}
public DataType convertCurrency(String param) {
// 汉字的数字
String[] cnNums = new String[]{"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
// 基本单位
String[] cnIntRadice = new String[]{"", "拾", "佰", "仟"};
// 对应整数部分扩展单位
String[] cnIntUnits = new String[]{"", "万", "亿", "兆"};
// 对应小数部分单位
String[] cnDecUnits = new String[]{"角", "分", "毫", "厘"};
// 整数金额时后面跟的字符
String cnInteger = "整";
// 整型完以后的单位
String cnIntLast = "元";
// 最大处理的数字
BigDecimal maxNum = new BigDecimal(999999999999999.9999);
// 金额整数部分
String integerNum;
// 金额小数部分
String decimalNum;
// 输出的中文金额字符串
String chineseStr = "";
// 分离金额后用的数组，预定义
String[] parts;
BigDecimal money=null;
if (param == null || param.equalsIgnoreCase("")) {
return new DataType(DataType.STRING,"");
}
money = new BigDecimal(param);
if (money.compareTo(maxNum)==0) {
// 超出最大处理数字
return new DataType(DataType.STRING,"");
}
if (money.intValue() == 0) {
chineseStr = cnNums[0] + cnIntLast + cnInteger;
return new DataType(DataType.STRING,chineseStr);
}
// 转换为字符串
//如果是整数
if (param.indexOf('.') == -1) {
integerNum = money.intValue()+"";
decimalNum = "";
//如果存在小数
} else {
parts = param.split("\\.");
integerNum = parts[0];
decimalNum = parts[1];
}
// 获取整型部分转换
if (integerNum.length() > 0) {
int zeroCount = 0;
int intLen = integerNum.length();
for (int i = 0; i < intLen; i++) {
String n = integerNum.substring(i, i+1);
logger.info("转换中文："+n);
int p = intLen - i - 1;
int q = p / 4;
int m = p % 4;
if (n.equals("0")) {
zeroCount++;
} else {
if (zeroCount > 0) {
chineseStr += cnNums[0];
}
// 归零
zeroCount = 0;
chineseStr += cnNums[Integer.parseInt(n)] + cnIntRadice[m];
}
if (m == 0 && zeroCount < 4) {
chineseStr += cnIntUnits[q];
}
}
chineseStr += cnIntLast;
}
// 小数部分
if (!decimalNum.equals("")) {
int decLen = decimalNum.length();
for (int i = 0; i < decLen; i++) {
String n = decimalNum.substring(i, i+1);
if (!n.equals("0")) {
chineseStr += cnNums[Integer.parseInt(n)] + cnDecUnits[i];
}
}
}
if (chineseStr.equals("")) {
chineseStr += cnNums[0] + cnIntLast + cnInteger;
} else if (decimalNum.equals("")) {
chineseStr += cnInteger;
}
return new DataType(DataType.STRING,chineseStr);
}
}

31
src/com/engine/salary/formlua/func/find/FindFuncsService.java Normal file
View File

@ -0,0 +1,31 @@
package com.engine.salary.formlua.func.find;
import com.engine.salary.formlua.entity.parameter.DataType;
/**
* 查找函数
*/
public interface FindFuncsService {
Object chooseOne(Object... objects);
/**
* choose函数
* @param objs
* @return
*/
Object choose(Object... objs);
/**
* match函数
* @param objs
* @return
*/
DataType match(Object... objs);
/**
* vlookups函数
* @param objs
* @return
*/
Object vlookups(Object... objs);
}

188
src/com/engine/salary/formlua/func/find/FindFuncsServiceImpl.java Normal file
View File

@ -0,0 +1,188 @@
//package com.engine.salary.formlua.func.find;
//
//import com.alibaba.fastjson.JSON;
//import com.alibaba.fastjson.JSONObject;
//import com.engine.salary.entity.datacollection.DataCollectionEmployee;
//import com.engine.salary.formlua.entity.parameter.DataType;
//import com.engine.salary.formlua.entity.parameter.FuncNames;
//import com.engine.salary.formlua.entity.standard.FormulaFilterData;
//import com.engine.salary.formlua.util.ErrorUtil;
//import com.engine.salary.formlua.util.ExcelParamUtil;
//import com.engine.salary.formlua.util.IgnoreParamFilter;
//import com.weaver.excel.formula.core.rpc.RpcMethod;
//import org.apache.commons.beanutils.BeanUtils;
//import org.apache.commons.compress.utils.Lists;
//import org.apache.commons.lang.ArrayUtils;
//import org.apache.commons.lang.StringUtils;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//
//import java.lang.reflect.Array;
//import java.lang.reflect.InvocationTargetException;
//import java.util.List;
//import java.util.Map;
//
//public class FindFuncsServiceImpl implements FindFuncsService{
// protected final Logger logger = LoggerFactory.getLogger(this.getClass());
// private ExcelDubboInvoker excelDubboInvoker;
//
// @Override
// public Object chooseOne(Object... objects) {
// DataType chooseResult=new DataType();
// if(objects != null && objects.length>=2){
// List<Object> dataList= ExcelParamUtil.getParamContent(objects);
// Object firstData=dataList.get(0);
// for (int i=1;i<dataList.size();i++){
// Object targetCheck=dataList.get(i);
// if( (firstData+"").equals(targetCheck+"") ){
// if(objects[i] instanceof DataType){
// DataType targetDataType=(DataType)objects[i];
// chooseResult=targetDataType;
// }else{
// String localtype=objects[i].getClass().getName();
// String dataType=ExcelParamUtil.getParamType(localtype).toLowerCase();
// chooseResult.setContent(chooseResult);
// chooseResult.setDataType(dataType);
// chooseResult.setText(dataType);
// }
//
// }
// }
// }else {
// chooseResult.setContent("");
// chooseResult.setDataType(DataType.STRING);
// }
// return chooseResult;
// }
//
// @Override
// public Object choose(Object... objects) {
// //参数校验
// String func = FuncNames.CHOOSE.toString();
// IgnoreParamFilter.commonFilter(func,2,2, null, objects);
//
// DataType formObj = (DataType)objects[0];
// DataType conditionObj = objects[1] != null ? (DataType)objects[1]:null;
//
// Long formId = formObj.getFormId();
// List<FormulaFilterData> filterDatas = conditionObj != null ? conditionObj.getFormulaFilterDataList(): Lists.newArrayList();
// DataCollectionEmployee user = formObj.getEmployee();
//
// Object[] params = {formId, filterDatas, user};
// return excelDubboInvoker.invokeCommonDubbo(DataType.class,formObj.getModule()+"", RpcMethod.choose, params);
// }
//
// @Override
// public DataType match(Object... objects) {
// //参数校验
// String func = FuncNames.MATCH.toString();
// IgnoreParamFilter.commonFilter(func,2,2, null, objects);
//
// Object valueObj = objects[0];
// Object[] arrayObj = null;
//
// //将第二个参数转数组
// try{
// arrayObj = (Object[]) objects[1];
// }catch (Exception e){
// Integer number = IgnoreParamFilter.getSetFuncNumber(func);
// JSONObject errorJson = ErrorUtil.buildError(func,number,number,func+"函数第二个参数必须是数组类型");
// throw new RuntimeException(errorJson.getString("msg"));
// }
//
// //所在下标
// int index = ArrayUtils.indexOf(arrayObj, valueObj);
// return new DataType(DataType.NUMBER, index);
// }
//
// @Override
// public Object vlookups(Object... objects) {
// //参数校验
// String func = FuncNames.VLOOKUPS.toString();
// IgnoreParamFilter.commonFilter(func,3,3, null, objects);
//
// DataType formObj = (DataType)objects[0];
// DataType conditionObj = objects[1] != null ? (DataType)objects[1] : null;
// //拿出返回数据
// Object returnObjs=objects[2];
// //初始化数组
// DataType[] rtnCols = null;
// //判断是否是数组
// if(returnObjs!=null && returnObjs.getClass().isArray()){
// logger.info("执行器查找函数返回数据为DataType数组"+JSON.toJSONString(returnObjs));
// //获取数组长度
// int len= Array.getLength(returnObjs);
// rtnCols=new DataType[len];
// //遍历并转换数据后放入rtnCols
// for(int i=0;i<len;i++){
// Object obj=Array.get(returnObjs,i);
// if(obj instanceof DataType){
// rtnCols[i]=(DataType)obj;
// }
// }
//
// }else if(returnObjs!=null && returnObjs instanceof DataType){
// logger.info("执行器查找函数返回数据为DataType"+JSON.toJSONString(returnObjs));
// rtnCols=new DataType[1];
// rtnCols[0]=(DataType)returnObjs;
// }else{
// logger.info("查找函数返回字段参数为空");
// }
//
//
// //解析fieldId
// List<String> fieldIds = Lists.newArrayList();
// if(!ArrayUtils.isEmpty(rtnCols)){
// for (DataType item : rtnCols) {
// if(item != null && StringUtils.isNotEmpty(item.getFieldId())) fieldIds.add(item.getFieldId());
// }
// }
//
// Long formId = formObj.getFormId();
// List<FormulaFilterData> filterDatas = conditionObj != null ? conditionObj.getFormulaFilterDataList() : Lists.newArrayList();
// DataCollectionEmployee user = formObj.getEmployee();
//
// Object[] params = {formId+"", filterDatas, fieldIds, null,user};
//
// DataType[] dataTypes=new DataType[1];
// Object dubboResult=excelDubboInvoker.invokeCommonDubbo(List.class,formObj.getModule()+"", RpcMethod.vlookups, params);
// logger.info("返回结果："+JSON.toJSONString(dubboResult));
//
// if(dubboResult!=null && dubboResult instanceof List){
// try {
// List<Object> resultObjectList=(List)dubboResult;
// dataTypes=new DataType[resultObjectList.size()];
// for(int i =0;i<resultObjectList.size();i++){
// Object resultParam=resultObjectList.get(i);
// if(resultParam instanceof Map){
// Map map=(Map)resultParam;
// Class<?> classa=Class.forName(map.get("class").toString()) ;
// Object typeObject=classa.newInstance();
// BeanUtils.populate(typeObject,map);
// if(typeObject instanceof DataType){
// dataTypes[i]=(DataType) typeObject;
// }
// }else if(resultParam instanceof DataType){
// dataTypes[i]=(DataType) resultParam;
// }else{
// logger.info("Dubbo接口返回异常数据类型："+resultParam.getClass().getName());
// }
// }
// } catch (ClassNotFoundException e) {
// e.printStackTrace();
// } catch (InstantiationException e) {
// e.printStackTrace();
// } catch (IllegalAccessException e) {
// e.printStackTrace();
// } catch (InvocationTargetException e) {
// e.printStackTrace();
// }catch (Exception e){
// e.printStackTrace();
// }
// }else{
// DataType nomalData=new DataType(DataType.NUMBER, 0);
// dataTypes[0]=nomalData;
// }
// return dataTypes.length==1?dataTypes[0]:dataTypes;
// }
//}

97
src/com/engine/salary/formlua/func/logic/IfOperator.java Normal file
View File

@ -0,0 +1,97 @@
package com.engine.salary.formlua.func.logic;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.engine.salary.formlua.core.exception.ExcelRunTimeException;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.util.ErrorUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.engine.salary.formlua.util.IgnoreParamFilter;
import com.ql.util.express.ArraySwap;
import com.ql.util.express.InstructionSetContext;
import com.ql.util.express.OperateData;
import com.ql.util.express.instruction.op.OperatorIf;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class IfOperator extends OperatorIf {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public OperateData executeInner(InstructionSetContext parent, ArraySwap list) throws Exception {
Integer number= IgnoreParamFilter.getSetFuncNumber("IF");
if(list==null ||list.length !=3){
JSONObject errorJson= ErrorUtil.buildError("IF",number,number,"IF函数只允许三个参数");
throw new ExcelRunTimeException("IF函数只允许三个参数");
}
Object obj = list.get(0).getObject(parent);
logger.info("IF参数："+ JSON.toJSONString(obj));
boolean isDataTypeBool=false;
DataType boolDtaType=null;
if(obj!=null && obj instanceof DataType){
boolDtaType=(DataType)obj;
if(boolDtaType.getContent() !=null && ( boolDtaType.getContent() instanceof Boolean )){
isDataTypeBool=true;
obj=boolDtaType.getContent();
}else{
switch (obj+""){
case "true":
obj=true;
isDataTypeBool=true;
break;
case "false":
obj=false;
isDataTypeBool=true;
break;
default:
isDataTypeBool=false;
break;
}
}
}else if(obj instanceof Boolean){
isDataTypeBool=true;
}
if (obj == null) {
JSONObject errorJson=ErrorUtil.buildError("IF",number,number,"IF函数参数不能为空");
throw new RuntimeException(errorJson.getString("msg"));
} else if (!(obj instanceof Boolean) && (! (obj instanceof DataType) )) {
JSONObject errorJson=ErrorUtil.buildError("IF",number,number,"IF函数判断条件必须是真假值");
throw new RuntimeException(errorJson.getString("msg"));
}else if(!isDataTypeBool){
JSONObject errorJson=ErrorUtil.buildError("IF",number,number,"IF函数判断条件必须是真假值");
throw new RuntimeException(errorJson.getString("msg"));
}else {
if (((Boolean)obj).booleanValue() == true){
OperateData operateData=list.get(1);
Object object=operateData.getObject(parent);
// if(object instanceof DataType){
// String type= ExcelParamUtil.getParamType(object);
// if(type.equalsIgnoreCase("date")){
// object=ExcelParamUtil.getParamContent(object,"string");
// }
// }
OperateData operateData1=new OperateData(ExcelParamUtil.getParamContent(object,""),operateData.getType(parent));
return operateData1;
}else{
OperateData operateData=list.get(2);
Object object=operateData.getObject(parent);
// if(object instanceof DataType){
// String type=ExcelParamUtil.getParamType(object);
// if(type.equalsIgnoreCase("date")){
// object=ExcelParamUtil.getParamContent(object,"string");
// }
// }
OperateData operateData1=new OperateData(ExcelParamUtil.getParamContent(object,""),operateData.getType(parent));
return operateData1;
}
}
}
public IfOperator(String aName) {
super(aName);
}
public IfOperator(String aAliasName, String aName, String aErrorInfo) {
super(aAliasName, aName, aErrorInfo);
}
}

26
src/com/engine/salary/formlua/func/logic/LogicService.java Normal file
View File

@ -0,0 +1,26 @@
package com.engine.salary.formlua.func.logic;
import com.engine.salary.formlua.entity.parameter.DataType;
public interface LogicService {
public DataType not(Object... object);
public DataType isEmpty(Object... objs);
public DataType isTrue(Object... objs);
public DataType isFalse(Object... objs);
public DataType and(Object... objs);
public DataType or(Object... objs);
public DataType likeFunc(Object... objects);
public DataType ifs(Object... objects);
public DataType find(Object... objects);
public DataType switchs(Object... objects);
}

495
src/com/engine/salary/formlua/func/logic/LogicServiceImpl.java Normal file
View File

@ -0,0 +1,495 @@
package com.engine.salary.formlua.func.logic;
import com.alibaba.fastjson.JSONObject;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.entity.parameter.FuncNames;
import com.engine.salary.formlua.util.ErrorUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.engine.salary.formlua.util.IgnoreParamFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @className：
* @Description：Excel逻辑函数
* @Author：
* @date：
*/
public class LogicServiceImpl implements LogicService {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
@Override
public DataType not(Object... objects) {
DataType resultdataType=new DataType();
resultdataType.setDataType(DataType.BOOL);
Class[] typeObjects=new Class[]{boolean.class};
IgnoreParamFilter.commonFilter("NOT",1,1,typeObjects,objects);
Object object=objects[0];
if(object == null){
resultdataType.setContent(false);
return resultdataType;
}
Boolean cnd;
if(object instanceof DataType){
DataType dataType=(DataType)object;
cnd=dataType.getContent()!=null?((Boolean) dataType.getContent()):false;
}else{
cnd=(boolean)object;
}
resultdataType.setContent(!cnd);
return resultdataType;
}
@Override
public DataType isEmpty(Object... objs) {
int number=IgnoreParamFilter.getSetFuncNumber(FuncNames.ISEMPTY.toString());
if(objs.length!=1){
throw new RuntimeException("ISEMPTY函数只允许一个参数");
}
boolean result=false;
if(null==objs||objs.length==0){
DataType dataType=new DataType();
dataType.setDataType(DataType.BOOL);
dataType.setContent(true);
return dataType;
}
for(int i=0;i<objs.length;i++){
Object obj=objs[i];
if(obj == null){
DataType dataType=new DataType();
dataType.setDataType(DataType.BOOL);
dataType.setContent(true);
return dataType;
}
if(obj instanceof DataType){
DataType objDataType=(DataType)obj;
if(objDataType.getDataType().equalsIgnoreCase(DataType.NUMBER)){
Object numberContent=objDataType.getContent();
if(numberContent==null||numberContent.toString().equalsIgnoreCase("")){
result= true;
break;
}
}
}
obj= ExcelParamUtil.getParamContent(obj,"");
if(null==obj||null==ExcelParamUtil.getParamContent(obj,"")||ExcelParamUtil.getParamContent(obj,"").equals("")){
result= true;
break;
}
}
DataType dataType=new DataType();
dataType.setDataType(DataType.BOOL);
dataType.setContent(result);
return dataType;
}
@Override
public DataType isTrue(Object... objects){
int number=IgnoreParamFilter.getSetFuncNumber(FuncNames.TRUE.toString());
if(objects.length>0){
throw new RuntimeException("TRUE函数不能有参数");
}
DataType dataType=new DataType();
dataType.setDataType(DataType.BOOL);
dataType.setContent(true);
return dataType;
}
@Override
public DataType isFalse(Object... objects){
int number=IgnoreParamFilter.getSetFuncNumber(FuncNames.FALSE.toString());
if(objects.length>0){
JSONObject errorJson=ErrorUtil.buildError(FuncNames.FALSE.toString(),number,number,"FALSE函数不能有参数");
throw new RuntimeException(errorJson.getString("msg"));
}
DataType dataType=new DataType();
dataType.setDataType(DataType.BOOL);
dataType.setContent(false);
return dataType;
}
@Override
public DataType and(Object... objs) {
IgnoreParamFilter.filterLogicAndORFunc(objs,"AND");
Object result;
int trueCount=0;
int falseCount=0;
DataType dataType=new DataType();
for(int i=0;i<objs.length;i++){
boolean bool;
if(objs[i] instanceof DataType){
DataType paramdataType=(DataType)objs[i];
bool=paramdataType.getContent()!=null?((Boolean) paramdataType.getContent()):false;
//如果参数存在底层Logic运算，把运算记录加入到当前AND函数的运算记录中
if(paramdataType.getSubLogic()!=null && paramdataType.getSubLogic().size()>0){
dataType.getSubLogic().addAll(paramdataType.getSubLogic());
}
}else{
bool=(boolean)objs[i];
}
if(bool){
trueCount++;
}else{
falseCount++;
}
}
if(trueCount==objs.length){
result= true;
}else{
result= false;
}
dataType.setDataType(DataType.BOOL);
dataType.setContent(result);
dataType.getSubLogic().add("and");
LogicUtils.buildAndOrFilterParam("AND",dataType,objs);
return dataType;
}
@Override
public DataType or(Object... objs) {
IgnoreParamFilter.filterLogicAndORFunc(objs,"OR");
Object result;
int trueCount=0;
int falseCount=0;
DataType dataType=new DataType();
for(int i=0;i<objs.length;i++){
boolean bool;
if(objs[i] instanceof DataType){
DataType paramdataType=(DataType)objs[i];
bool=paramdataType.getContent()!=null?((Boolean) paramdataType.getContent()):false;
//如果参数存在底层Logic运算，把运算记录加入到当前AND函数的运算记录中
if(paramdataType.getSubLogic()!=null && paramdataType.getSubLogic().size()>0){
dataType.getSubLogic().addAll(paramdataType.getSubLogic());
}
}else{
bool=(boolean)objs[i];
}
if(bool){
trueCount++;
}else{
falseCount++;
}
}
if(trueCount>0){
result= true;
}else{
result= false;
}
dataType.setDataType(DataType.BOOL);
dataType.setContent(result);
dataType.getSubLogic().add("or");
LogicUtils.buildAndOrFilterParam("OR",dataType,objs);
return dataType;
}
@Override
public DataType likeFunc(Object... objects) {
IgnoreParamFilter.filterLikeFunc(objects);
Object object=objects[0];
Object result=false;
String txtS="";
if(object instanceof DataType){
txtS=ExcelParamUtil.getParamContent(object,"string").toString();
}else {
txtS=object.toString();
}
if(null==txtS||txtS.trim().equals("")){
return new DataType(DataType.BOOL,false);
}
Object[] partamArray=(Object[])objects[1];
for(int i=0;i<partamArray.length;i++){
Object cnd=partamArray[i];
String cndStr="";
if(cnd instanceof DataType){
DataType cndJson=(DataType)cnd;
cndStr=ExcelParamUtil.getParamContent(cndJson,"string").toString();
}else {
cndStr=cnd.toString();
}
int ridx=txtS.indexOf(cndStr);
if(ridx>=0?true:false){
result=ridx>=0?true:false;
break;
}
}
DataType dataType=new DataType(DataType.BOOL,result);
LogicUtils.buildLikeFilterParam(dataType,objects);
return dataType;
}
@Override
public DataType ifs(Object... objects) {
int number=IgnoreParamFilter.getSetFuncNumber(FuncNames.IFS.toString());
if(objects.length==0 || objects.length%2!=1 || objects.length<3){
JSONObject errorJson=ErrorUtil.buildError(FuncNames.IFS.toString(),number,number,"IFS函数的参数必须大于3个且为单数");
throw new RuntimeException(errorJson.getString("msg"));
}
int testI;
for(testI=1;testI<=objects.length;testI++){
if(testI%2>0 && testI!=objects.length){
Object cndObj=objects[testI-1];
if(!(cndObj instanceof Boolean) && !(cndObj instanceof DataType)){
JSONObject errorJson= ErrorUtil.buildError(FuncNames.IFS.toString(),number,number,"IFS函数条件必须为真假值");
throw new RuntimeException(errorJson.getString("msg"));
}else if(cndObj instanceof DataType){
DataType boolDataType=(DataType)cndObj;
if(boolDataType.getContent()!=null && !(boolDataType.getContent() instanceof Boolean)){
JSONObject errorJson=ErrorUtil.buildError(FuncNames.IFS.toString(),number,number,"IFS函数条件必须为真假值");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
}
boolean paramCheck=checkParamType(objects);
if(!paramCheck){
JSONObject errorJson=ErrorUtil.buildError(FuncNames.IFS.toString(),number,number,"IFS函数多个条件的返回值必须一致");
throw new RuntimeException(errorJson.getString("msg"));
}
int i;
for(i=1;i<=objects.length;i++){
if(i%2==0){
Object cndObj=objects[i-2];
if(cndObj instanceof Boolean){
Boolean cnd=(Boolean)cndObj;
if(cnd){
if(objects[i-1] instanceof DataType){
return (DataType) objects[i-1];
}else{
return new DataType(DataType.returnType(ExcelParamUtil.getParamType(objects[i-1].getClass().getName())),objects[i-1]);
}
// return new DataType(DataType.BOOL,objects[i-1]);
}
}else if(cndObj instanceof DataType){
DataType boolData=(DataType)cndObj;
Boolean cnd=boolData.getContent()!=null?( (Boolean)boolData.getContent() ) : false;
if(cnd){
if(objects[i-1] instanceof DataType){
return (DataType) objects[i-1];
}else {
return new DataType(DataType.returnType(ExcelParamUtil.getParamType(objects[i-1].getClass().getName())),objects[i-1]);
}
}
}
}
}
//如果没有条件符合，返回默认值，最后一个参数为默认值
Object result=ExcelParamUtil.getParamContent(objects[objects.length-1],"");
if(result instanceof DataType){
return (DataType)result;
}else{
return new DataType(DataType.returnType(ExcelParamUtil.getParamType(result.getClass().getName())),result);
}
}
@Override
public DataType find(Object... objects) {
return new DataType(DataType.BOOL,finds(objects));
}
@Override
public DataType switchs(Object... objects) {
if(objects.length==0||objects==null){
throw new RuntimeException("参数不能为空");
}
if(objects.length<4){
throw new RuntimeException("switch函数的参数长度必须大于4个");
}
if(objects.length%2!=0){
throw new RuntimeException("switch函数的参数长度必须为双数");
}
Object source=objects[0];
Object defaultValue=objects[objects.length-1];
if(source instanceof DataType){
source=ExcelParamUtil.getParamContent(source,"");
}
if(defaultValue instanceof DataType){
defaultValue=ExcelParamUtil.getParamContent(defaultValue,"");
}
Object result=null;
for (int i=1;i<objects.length-1;i++){
if(i%2!=0){
Object param=objects[i];
Object value=null;
if(param instanceof DataType){
value=ExcelParamUtil.getParamContent(param,"");
}else{
value=param;
}
if(source.equals(value)){
result=objects[i+1];
break;
}
}
}
if(result==null){
result=defaultValue;
}
return new DataType(DataType.BOOL,result);
}
public Boolean finds(Object... objects){
if(null==objects || objects.length<2){
throw new RuntimeException("参数不能为空");
}
//获取查找类型 1：用第二个参数去第一个里面找。2：用第一个参数去第二个里面找
String type=null;
int vali=2;
if(objects.length>=3 ){
if(objects[objects.length-1] instanceof Integer){
vali=Integer.parseInt(objects[objects.length-1].toString());
if(vali!=1&&vali!=2){
throw new RuntimeException("FIND函数第三个参数只允许1和2");
}
}else{
throw new RuntimeException("FIND函数第三个参数只允许1和2");
}
}
//将参数转换成List，要判断参数是数组还是单个对象
List<Object> objs1=null;
List<Object> objs2=null;
if(objects[0] instanceof Object[]){
Object[] transObj=(Object[])objects[0];
objs1=Arrays.asList(transObj);
}else{
objs1=Arrays.asList(objects[0]);
}
if(objects[1] instanceof Object[]){
Object[] transObj=(Object[])objects[1];
objs2=Arrays.asList(transObj);
}else{
objs2=Arrays.asList(objects[1]);
}
if(objs1.size()==0 || objs2.size() == 0 ){
throw new RuntimeException("参数不能为空");
}
//判断参数类型是否一致
List<Object> all=new ArrayList<>();
all.addAll(objs1);
all.addAll(objs2);
for (Object obj:all){
String localType="";
if(obj instanceof DataType){
String paramType=ExcelParamUtil.getParamType(obj);
if(!paramType.toLowerCase().equals("option")){
localType=ExcelParamUtil.checkParamType(paramType);
}else{
localType=paramType;
}
}else{
localType=ExcelParamUtil.checkParamType(ExcelParamUtil.getParamType(obj.getClass().getName()));
}
if(type==null){
type=localType;
}else{
if(!type.equalsIgnoreCase(localType)){
throw new RuntimeException("参数类型不一致");
}
}
}
//根据超找类型判断谁是查找目标，谁是查找依据
List<Object> targetList=new ArrayList<>();
List<Object> keyList=new ArrayList<>();
switch (vali){
case 1:
targetList=transOptionData(objs1);
keyList=transOptionData(objs2);
break;
case 2:
targetList=transOptionData(objs2);
keyList=transOptionData(objs1);
break;
default:
throw new RuntimeException("查找类型错误");
}
for (Object keyO:keyList){
for (Object target:targetList){
if(keyO.equals(target)){
return true;
}
}
}
return false;
}
private List<Object> transOptionData(List<Object> dataList){
List<Object> contentArrays=new ArrayList<>();
for (Object data:dataList){
Object param1=ExcelParamUtil.getParamContent(data,"");
//获取依据数据的类型
String keyType="";
if(data instanceof DataType){
keyType=ExcelParamUtil.getParamType(data);
}else{
keyType=ExcelParamUtil.getParamType(data.getClass().getName());
}
keyType=ExcelParamUtil.checkParamType(keyType);
if(keyType.toLowerCase().equals(DataType.OPTION)){
contentArrays.addAll(Arrays.asList(param1.toString().split(",")));
}else if(data instanceof Character){
contentArrays.add(param1.toString());
}else if(keyType.toLowerCase().equals("number")){
contentArrays.add(Double.parseDouble(param1.toString()));
}else{
contentArrays.add(param1);
}
}
return contentArrays;
}
private boolean checkParamType(Object[] objects){
boolean result=false;
String type=null;
for (int i=1;i<=objects.length;i++){
if(i%2==0){
Object obj=objects[i-1];
String typeStr=ExcelParamUtil.getParamType(obj);
typeStr=ExcelParamUtil.checkParamType(typeStr);
logger.info(typeStr);
if(type==null){
type=typeStr;
}else{
result=typeStr.equalsIgnoreCase(type);
if(!result){
return result;
}
}
}
}
String typeStr=ExcelParamUtil.checkParamType(ExcelParamUtil.getParamType(objects[objects.length-1]));
result=type.equalsIgnoreCase(typeStr);
return result;
}
}

109
src/com/engine/salary/formlua/func/logic/LogicUtils.java Normal file
View File

@ -0,0 +1,109 @@
package com.engine.salary.formlua.func.logic;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.entity.standard.FormulaFilterData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
/**
* 逻辑函数构建条件工具类
*/
public class LogicUtils {
protected static final Logger logger = LoggerFactory.getLogger(LogicUtils.class);
/**
* 构建AND和OR函数的条件
* @param func
* @param dataType
* @param objs
*/
public static void buildAndOrFilterParam(String func,DataType dataType,Object... objs){
List<FormulaFilterData> filterFormDataList=new ArrayList<>();
try {
if(objs != null && objs.length > 0) {
for(int i=0;i<objs.length;i++){
if(objs[i] instanceof DataType) {
DataType paramData=(DataType)objs[i];
List<FormulaFilterData> paramFilterDataList=paramData.getFormulaFilterDataList();
if(paramFilterDataList!=null){
paramFilterDataList.forEach(val->{
if(func.equalsIgnoreCase("AND")){
val.setCondition(FormulaFilterData.CONDITION_AND);
}else if(func.equalsIgnoreCase("OR")){
val.setCondition(FormulaFilterData.CONDITION_OR);
}
});
filterFormDataList.addAll(paramFilterDataList);
}
}
}
// dataType.setFormulaFilterDataList(filterFormDataList);
}
} catch (Exception e) {
logger.error("err",e);
}
}
/**
* 构建Like函数的过滤条件
* @param dataType
* @param objs
*/
public static void buildLikeFilterParam(DataType dataType,Object... objs){
try {
if(dataType != null && objs.length > 0) {
if(dataType.getDataType().equalsIgnoreCase(DataType.DATASOURCE) || dataType.getDataType().equalsIgnoreCase(DataType.OPTION) || dataType.getDataType().equalsIgnoreCase(DataType.FORM)) {
throw new RuntimeException("筛选条件函数[LIKE]:第一个参数不能是选项型");
}
List<FormulaFilterData> formulaFilterDataList=new ArrayList<>();
FormulaFilterData formulaFilterData=new FormulaFilterData();
List<String> contents = new ArrayList<String>();
for(Object str : objs) {
if(str instanceof DataType){
DataType data=(DataType)str;
contents.add(data.getContent()+"");
}else {
contents.add(str+"");
}
}
formulaFilterData.setContents(contents);
// formulaFilterData.setTerm(FilterFormData.TERM_LIKE);
// formulaFilterData.setFieldId(dataType.getFieldId()+"");
// formulaFilterDataList.add(formulaFilterData);
// dataType.setFormulaFilterDataList(formulaFilterDataList);
}
} catch (RuntimeException RuntimeException) {
RuntimeException.printStackTrace();
}
}
public static void buildInFilterParam(DataType dataType, Object... objs){
try {
if(dataType != null && objs.length > 0) {
if(!dataType.getDataType().equalsIgnoreCase(DataType.DATASOURCE) && !dataType.getDataType().equalsIgnoreCase(DataType.OPTION)) {
return;
}
List<FormulaFilterData> formulaFilterDataList=new ArrayList<>();
FormulaFilterData formulaFilterData=new FormulaFilterData();
List<String> ids = new ArrayList<String>();
for(Object option : objs) {
if(option instanceof DataType){
DataType data=(DataType)option;
ids.add(data.getContent()+"");
}
}
formulaFilterData.setIds(ids);
formulaFilterData.setFieldId(dataType.getFieldId()+"");
// formulaFilterData.setTerm(FilterFormData.TERM_EQ);
// formulaFilterDataList.add(formulaFilterData);
// dataType.setFormulaFilterDataList(formulaFilterDataList);
}
} catch (Exception e) {
logger.error("err",e);
}
}
}

79
src/com/engine/salary/formlua/func/math/MathFuncsService.java Normal file
View File

@ -0,0 +1,79 @@
package com.engine.salary.formlua.func.math;
import com.engine.salary.formlua.entity.parameter.DataType;
public interface MathFuncsService {
/**
* 向上取整
* @param object
* @return
*/
public DataType roundUp(Object... object);
/**
* 向下取整
* @param object
* @return
*/
public DataType roundDown(Object... object);
/**
* 四舍五入
* @param object
* @return
*/
public DataType round(Object... object);
/**
* 统计函数
* @param objects
* @return
*/
public DataType aggregation(Object... objects);
/**
* 取余函数
* @param objects
* @return
*/
public DataType mod(Object... objects);
/**
* 精度控制函数
* @param number
* @param numDigits
* @return
*/
public DataType Trunc(Object number,Object numDigits);
/**
* 随机数
* @param length 随机数长度
* @param type 随机数类型，分为纯数字、纯英文字母、英文和数字的组合
* @return
*/
public DataType randomNumber(Object length,Object type);
/**
* 分组函数
* @param objects 分组的数据
* @return 返回一个结果集，这个结果集不能直接使用，要通过其他函数继续运算得出结果，比如aggregation统计函数
*/
public DataType group(Object... objects);
/**
* 是否是整数
* @param objects
* @return
*/
public DataType isInt(Object... objects);
/**
* 是否是数字
* @param objects
* @return
*/
public DataType isNumber(Object... objects);
}

465
src/com/engine/salary/formlua/func/math/MathFuncsServiceImpl.java Normal file
View File

@ -0,0 +1,465 @@
package com.engine.salary.formlua.func.math;
import com.alibaba.fastjson.JSONObject;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.entity.parameter.FuncNames;
import com.engine.salary.formlua.util.ErrorUtil;
import com.engine.salary.formlua.util.ExcelParamUtil;
import com.engine.salary.formlua.util.IgnoreParamFilter;
import com.engine.salary.formlua.util.RegularUtil;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class MathFuncsServiceImpl implements MathFuncsService {
private final String randomNumber = "NUM";
private final String randomChar = "CHAR";
private final String randomNumANDChar = "FIX";
@Override
public DataType roundUp(Object... objects) {
Integer errorNumber = IgnoreParamFilter.getSetFuncNumber(FuncNames.ROUNDUP.getName());
Object number = null;
Object object = objects[0];
//小数位
int numDigits = 0;
Object numDigitsObj = null;
//获取小数点位数参数
if (objects != null && objects.length > 1) {
numDigitsObj = objects[1];
if (numDigitsObj != null && numDigitsObj instanceof DataType) {
numDigitsObj = ExcelParamUtil.getParamContent(numDigitsObj, "");
}
}
//整数校验
if (numDigitsObj != null) {
try {
numDigits = (int) numDigitsObj;
} catch (Exception e) {
throw new RuntimeException("小数点位数必须是整数");
}
}
if (object instanceof DataType) {
DataType dataType = (DataType) object;
if (dataType.getDataType().equalsIgnoreCase(DataType.STRING) || dataType.getDataType().equalsIgnoreCase(DataType.DATE) || dataType.getDataType().equalsIgnoreCase(DataType.OPTION)) {
JSONObject errorJson = ErrorUtil.buildError(FuncNames.ROUNDUP.toString(), errorNumber, errorNumber, "ROUNDUP函数只接受数字参数");
throw new RuntimeException(errorJson.getString("msg"));
}
number = dataType.getContent();
} else {
BigDecimal db = new BigDecimal(object.toString());
number = db;
}
if (!RegularUtil.isNumber(number)) {
JSONObject errorJson = ErrorUtil.buildError(FuncNames.ROUNDUP.toString(), errorNumber, errorNumber, "ROUNDUP函数只接受数字参数");
throw new RuntimeException(errorJson.getString("msg"));
}
BigDecimal bigDecimal = new BigDecimal(number + "");
Double result = bigDecimal.setScale(numDigits, BigDecimal.ROUND_CEILING).doubleValue();
if (numDigits == 0) return new DataType(DataType.NUMBER, result.intValue());
return new DataType(DataType.NUMBER, result, "ComponentType.NumberComponent".toString());
}
@Override
public DataType roundDown(Object... objects) {
Integer errorNumber = IgnoreParamFilter.getSetFuncNumber(FuncNames.ROUNDDOWN.getName());
Object number = null;
Object object = objects[0];
//小数位
int numDigits = 0;
Object numDigitsObj = null;
//获取小数点位数参数
if (objects != null && objects.length > 1) {
numDigitsObj = objects[1];
if (numDigitsObj != null && numDigitsObj instanceof DataType) {
numDigitsObj = ExcelParamUtil.getParamContent(numDigitsObj, "");
}
}
//整数校验
if (numDigitsObj != null) {
try {
numDigits = (int) numDigitsObj;
} catch (Exception e) {
throw new RuntimeException("小数点位数必须是整数");
}
}
if (object instanceof DataType) {
DataType dataType = (DataType) object;
if (dataType.getDataType().equalsIgnoreCase(DataType.STRING) || dataType.getDataType().equalsIgnoreCase(DataType.DATE) || dataType.getDataType().equalsIgnoreCase(DataType.OPTION)) {
return new DataType(DataType.NUMBER, 0, "ComponentType.NumberComponent".toString());
}
number = dataType.getContent();
} else {
BigDecimal db = new BigDecimal(object.toString());
number = db;
}
if (!RegularUtil.isNumber(number)) {
return new DataType(DataType.NUMBER, 0, "ComponentType.NumberComponent".toString());
}
BigDecimal bigDecimal = new BigDecimal(number + "");
Double result = bigDecimal.setScale(numDigits, BigDecimal.ROUND_FLOOR).doubleValue();
if (numDigits == 0) return new DataType(DataType.NUMBER, result.intValue());
return new DataType(DataType.NUMBER, result, "ComponentType.NumberComponent".toString());
}
@Override
public DataType round(Object... objects) {
Integer errorNumber = IgnoreParamFilter.getSetFuncNumber(FuncNames.ROUND.getName());
Object number = null;
Object object = objects[0];
//小数位
int numDigits = 0;
Object numDigitsObj = null;
//获取小数点位数参数
if (objects != null && objects.length > 1) {
numDigitsObj = objects[1];
if (numDigitsObj != null && numDigitsObj instanceof DataType) {
numDigitsObj = ExcelParamUtil.getParamContent(numDigitsObj, "");
}
}
//整数校验
if (numDigitsObj != null) {
try {
numDigits = (int) numDigitsObj;
} catch (Exception e) {
throw new RuntimeException("小数点位数必须是整数");
}
}
if (object instanceof DataType) {
DataType dataType = (DataType) object;
if (dataType.getDataType().equalsIgnoreCase(DataType.STRING) || dataType.getDataType().equalsIgnoreCase(DataType.DATE) || dataType.getDataType().equalsIgnoreCase(DataType.OPTION)) {
return new DataType(DataType.NUMBER, 0, "ComponentType.NumberComponent".toString());
}
number = dataType.getContent();
} else {
BigDecimal db = new BigDecimal(object.toString());
number = db;
}
if (!RegularUtil.isNumber(number)) {
return new DataType(DataType.NUMBER, 0, "ComponentType.NumberComponent".toString());
}
BigDecimal bigDecimal = new BigDecimal(number + "");
Double result = bigDecimal.setScale(numDigits, BigDecimal.ROUND_HALF_UP).doubleValue();
if (numDigits == 0) return new DataType(DataType.NUMBER, result.intValue());
return new DataType(DataType.NUMBER, result, "ComponentType.NumberComponent".toString());
}
@Override
public DataType aggregation(Object... objects) {
Integer errorNumber = IgnoreParamFilter.getSetFuncNumber(FuncNames.AGGREGATION.getName());
Double result = 0d;
if (objects.length == 0 || objects.length < 2) {
return new DataType(DataType.NUMBER, result, "ComponentType.NumberComponent".toString());
}
List<Double> dataList = new ArrayList<Double>();
for (int i = 0; i < objects.length - 1; i++) {
boolean isArray = false;
String paramType;
Object objectData;
if (objects[i] instanceof DataType) {
DataType dataType1 = (DataType) objects[i];
paramType = dataType1.getDataType();
objectData = ExcelParamUtil.getParamContent(dataType1, "string");
} else if (objects[i] instanceof Object[]) {
Object[] arrayObjs = (Object[]) objects[i];
String arrayType = null;
objectData = "";
for (Object arrayObj : arrayObjs) {
String lcoalType = "";
if (arrayObj instanceof DataType) {
lcoalType = ExcelParamUtil.getParamType(arrayObj);
objectData += ExcelParamUtil.getParamContent((DataType) arrayObj, "string") + "#";
} else {
lcoalType = ExcelParamUtil.getParamType(arrayObj.getClass().getName());
objectData += arrayObj + "#";
}
if (arrayType == null) {
arrayType = lcoalType;
} else {
if (!arrayType.equals(lcoalType)) {
JSONObject errorJson = ErrorUtil.buildError(FuncNames.AGGREGATION.toString(), errorNumber, errorNumber, "操作符参数类型不一致");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
paramType = arrayType;
isArray = true;
} else {
paramType = ExcelParamUtil.getParamType(objects[i].getClass().getName());
objectData = objects[i];
}
paramType = ExcelParamUtil.checkParamType(paramType);
if (!paramType.equalsIgnoreCase(DataType.NUMBER)) {
JSONObject errorJson = ErrorUtil.buildError(FuncNames.AGGREGATION.toString(), errorNumber, errorNumber, "统计函数只允许数字");
throw new RuntimeException(errorJson.getString("msg"));
}
if (isArray) {
String[] arrayStrs = objectData.toString().split("#");
for (String arrayStr : arrayStrs) {
Double data = Double.parseDouble(arrayStr);
dataList.add(data);
}
} else {
Double data = Double.parseDouble(objectData.toString());
dataList.add(data);
}
}
String aggType = objects[objects.length - 1].toString().toLowerCase();
Collections.sort(dataList);
switch (aggType) {
case "avg":
for (Double data : dataList) {
result += data;
}
result = result / dataList.size();
break;
case "max":
result = dataList.get(dataList.size() - 1);
break;
case "min":
result = dataList.get(0);
break;
default:
JSONObject errorJson = ErrorUtil.buildError(FuncNames.AGGREGATION.toString(), errorNumber, errorNumber, "统计函数需要类型参数");
throw new RuntimeException(errorJson.getString("msg"));
}
return new DataType(DataType.NUMBER, result, "ComponentType.NumberComponent".toString());
}
@Override
public DataType mod(Object... objects) {
Integer errorNumber = IgnoreParamFilter.getSetFuncNumber(FuncNames.MOD.getName());
if (objects.length != 2) {
return new DataType(DataType.NUMBER, 0, "ComponentType.NumberComponent".toString());
}
Double doubleOne = 0d;
Double doubleTwo = 0d;
for (int i = 0; i < objects.length; i++) {
Object paramObj = objects[i];
String type;
if (paramObj instanceof DataType) {
DataType paramDataType = (DataType) paramObj;
type = paramDataType.getDataType();
} else {
type = ExcelParamUtil.getParamType(paramObj.getClass().getName());
}
if (!type.equalsIgnoreCase(DataType.NUMBER)) {
return new DataType(DataType.NUMBER, 0, "ComponentType.NumberComponent".toString());
}
if (i == 0) {
doubleOne = Double.parseDouble(ExcelParamUtil.getParamContent(paramObj, "string").toString());
} else {
doubleTwo = Double.parseDouble(ExcelParamUtil.getParamContent(paramObj, "string").toString());
}
}
Double value = doubleOne % doubleTwo;
return new DataType(DataType.NUMBER, value, "ComponentType.NumberComponent".toString());
}
@Override
public DataType Trunc(Object number, Object numDigits) {
Integer errorNumber = IgnoreParamFilter.getSetFuncNumber(FuncNames.TRUNC.getName());
Object f1 = 0;
Object numberVal;
Object digitsVal;
if (number instanceof DataType) {
numberVal = ExcelParamUtil.getParamContent(number, "");
} else {
numberVal = number;
}
if (numDigits instanceof DataType) {
digitsVal = ExcelParamUtil.getParamContent(numDigits, "");
} else {
digitsVal = numDigits;
}
if (RegularUtil.isNumber(numberVal) && RegularUtil.isNumber(digitsVal)) {
Double d = Double.parseDouble(digitsVal.toString());
int digitsIntVal = d.intValue();
if (digitsIntVal > 5) {
digitsIntVal = 5;
}
BigDecimal b = new BigDecimal(numberVal.toString());
f1 = b.setScale(digitsIntVal, BigDecimal.ROUND_HALF_UP).doubleValue();
if (digitsIntVal == 0) {
f1 = b.intValue();
}
} else {
JSONObject errorJson = ErrorUtil.buildError(FuncNames.TRUNC.toString(), errorNumber, errorNumber, "小数点格式化只允许数字");
throw new RuntimeException(errorJson.getString("msg"));
}
return new DataType(DataType.NUMBER, f1, "ComponentType.NumberComponent".toString());
}
@Override
public DataType randomNumber(Object length, Object type) {
String value = "";
Integer errorNumber = IgnoreParamFilter.getSetFuncNumber(FuncNames.RANDOMNUMBER.getName());
Double numberLength = 0.0;
Object param = 10;
String dataValueType = "";
if (length != null) {
if (length instanceof DataType) {
DataType dataType = (DataType) length;
dataValueType = ExcelParamUtil.checkParamType(dataType);
param = ExcelParamUtil.getParamContent(length, "");
} else {
dataValueType = ExcelParamUtil.checkParamType(length);
param = length;
}
}
//判断length长度数据类型是否合规
if (!dataValueType.equalsIgnoreCase("number")) {
JSONObject errorJson = ErrorUtil.buildError(FuncNames.RANDOMNUMBER.toString(), errorNumber, errorNumber, "随机数函数只允许数字参数");
throw new RuntimeException(errorJson.getString("msg"));
}
//判断用户设置的length是否大于0，生成的随机数长度必须是大于1的
if (param != null) {
numberLength = Double.parseDouble(param.toString());
if (numberLength <= 0) {
JSONObject errorJson = ErrorUtil.buildError(FuncNames.RANDOMNUMBER.toString(), errorNumber, errorNumber, "随机数函数长度必须大于0");
throw new RuntimeException(errorJson.getString("msg"));
}
}
String typeString = randomNumber;
if (type != null) {
if (type instanceof DataType) {
DataType dataType = (DataType) length;
typeString = ExcelParamUtil.getParamContent(type, "").toString();
} else {
typeString = type.toString();
}
}
switch (typeString) {
case randomNumber:
value = randomFunc(numberLength, randomNumber);
break;
case randomChar:
value = randomFunc(numberLength, randomChar);
break;
case randomNumANDChar:
value = randomFunc(numberLength, randomNumANDChar);
break;
default:
JSONObject errorJson = ErrorUtil.buildError(FuncNames.RANDOMNUMBER.toString(), errorNumber, errorNumber, "随机数的返回值只允许数字、字符以及数字和字符的混合类型");
throw new RuntimeException(errorJson.getString("msg"));
}
return new DataType(DataType.NUMBER, value, "ComponentType.NumberComponent".toString());
}
@Override
public DataType group(Object... objects) {
return null;
}
@Override
public DataType isInt(Object... objects) {
boolean isInt = false;
if (objects[0] instanceof DataType) {
DataType dataType = (DataType) objects[0];
isInt = RegularUtil.isInteger(dataType.getContent());
} else {
isInt = RegularUtil.isInteger(objects[0]);
}
return new DataType(DataType.BOOL, isInt);
}
@Override
public DataType isNumber(Object... objects) {
boolean isInt = false;
if (objects[0] instanceof DataType) {
DataType dataType = (DataType) objects[0];
isInt = RegularUtil.isNumber(dataType.getContent());
} else {
isInt = RegularUtil.isNumber(objects[0]);
}
return new DataType(DataType.BOOL, isInt);
}
private String randomFunc(Double length, String type) {
Random r = new Random();
StringBuffer sbff = new StringBuffer();
//数字类型随机数
if (type.equalsIgnoreCase("number")) {
for (double i = 0; i < length; i++) {
sbff.append(r.nextInt(10));
}
return sbff.toString();
//英文字母类型随机数
} else if (type.equalsIgnoreCase("char")) {
for (double i = 0; i < length; i++) {
int charInt = r.nextInt(26) + 'A';
sbff.append((char) charInt);
}
return sbff.toString();
//组合类型随机数
} else {
//如果长度等于1，就不适合做数字字符随机数组合，将长度改为2
double numloop = 1;
double charloop = 1;
if (length == 1) {
length = 2.0;
} else {
//如果长度是奇数
if (length % 2 > 0) {
charloop = (length - 1) / 2;
numloop = charloop + 1;
} else {
charloop = length / 2;
numloop = charloop;
}
}
for (double i = 0; i < charloop; i++) {
int charInt = r.nextInt(26) + 'a';
sbff.append((char) charInt);
}
String charRandom = sbff.toString();
sbff.setLength(0);
sbff.append(charRandom);
for (double i = 0; i < numloop; i++) {
sbff.append(r.nextInt(10));
}
return sbff.toString();
}
}
}

7
src/com/engine/salary/formlua/func/string/ExtractType.java Normal file
View File

@ -0,0 +1,7 @@
package com.engine.salary.formlua.func.string;
public class ExtractType {
public final static String CITY="CITY";
public final static String PROVINCE="PROVINCE";
public final static String TOWN="TOWN";
}

186
src/com/engine/salary/formlua/func/string/StringFormulaService.java Normal file
View File

@ -0,0 +1,186 @@
package com.engine.salary.formlua.func.string;
import com.engine.salary.formlua.entity.parameter.DataType;
/**
* @className：
* @Description：Excel文本函数
* @Author：
* @date：
*/
public interface StringFormulaService {
/**
* 连接字符串
* @param objs
* @return
*/
public DataType concatString(Object... objs);
/**
* 转为文本
* @param obj
* @return
*/
public DataType text(Object... obj);
/**
* 文本转数字
* @param txt
* @return
*/
public DataType value(Object... txt);
/**
* 文本长度
* @param txt
* @return
*/
public DataType len(Object... txt);
/**
* 检索关键字
* @param objects
* @return
*/
public DataType search(Object... objects);
/**
* 替换文本
* @param objects
* @return
*/
public DataType replace(Object... objects);
/**
* 重复文本拼接返回
* @param objects
* @return
*/
public DataType repeat(Object... objects);
/**
* 填充文本至指定长度
* @param objects
* @return
*/
public DataType pad(Object... objects);
/**
* 去除首尾空格
* @param objects
* @return
*/
public DataType trim(Object... objects);
/**
* 返回文本左侧开始的文字
* @param objects
* @return
*/
public DataType left(Object... objects);
/**
* 返回文本右侧开始的文字
* @param objects
* @return
*/
public DataType right(Object... objects);
/**
* 返回文本指定位置开始的文字
* @param objects
* @return
*/
public DataType mid(Object... objects);
/**
* 返回分数，同value函数逻辑
* @param objects
* @return
*/
public DataType score(Object... objects);
/***
* 操作身份证信息
* @param objects
* @return
*/
public DataType idCard(Object... objects);
public DataType sex(String idCard);
public DataType nativePlace(String idCard);
public DataType age(String idCard);
public DataType bd(String idCard);
/**
* 地址解析函数
* @param address 具体地址
* @param level 想获取的行政级别，省市区
* @return
*/
public DataType addressAnalysis(Object address,Object level);
/**
* 字符截取函数
* @param objects 第一个源字符，第二个是截取开始位置，第二个是截取结束位置
* @return
*/
public DataType subString(Object... objects);
/**
* 字符查找替换函数
* @param objects 第一个参数是源字符串，第二个参数是被替换字符，第三个参数是替换时使用的新字符
* @return
*/
public DataType substitue(Object... objects);
/**
* 字符提取函数，第一个参数是源字符，第二个参数是提取类型
* @param objects
* @return
*/
public DataType extract(Object... objects);
/**
* 字符转小写
* @param objects
* @return
*/
public DataType lower(Object... objects);
/**
* 字符转大写
* @param objects
* @return
*/
public DataType upper(Object... objects);
/**
* 字符比较，是否完全相等，区分大小写
* @param objects
* @return
*/
public DataType exact(Object... objects);
/**
* 是否是字符串
* @param objects
* @return
*/
public DataType isString(Object... objects);
/**
* 是否是JSON字符串
* @param objects
* @return
*/
public DataType isJson(Object... objects);
/**
* 从JSON中获取值
* @param objects
* @return
*/
public DataType getJSONValue(Object... objects);
}

820
src/com/engine/salary/formlua/func/string/StringFormulaServiceImpl.java Normal file
View File

@ -0,0 +1,820 @@
package com.engine.salary.formlua.func.string;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.entity.parameter.FuncNames;
import com.engine.salary.formlua.func.date.DateTimeServiceImpl;
import com.engine.salary.formlua.func.math.MathFuncsService;
import com.engine.salary.formlua.util.*;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* @className：
* @Description：Excel文本函数
* @Author：
* @date：
*/
public class StringFormulaServiceImpl implements StringFormulaService {
protected final Logger logger = LoggerFactory.getLogger(this.getClass());
MathFuncsService mathFuncsService;
private final String[] fillPositonArray=new String[]{"LEFT","RIGHT"};
private final static String PROVINCE="province";
private final static String CITY="city";
private final static String TOWN="town";
private final static String ADDR="addr";
/**
* 连接字符串
* @param objs
* @return
*/
@Override
public DataType concatString(Object... objs) {
List<Object> newObjs=new ArrayList<>();
for (int i=0;i<objs.length;i++){
Object param=objs[i];
if(param.getClass().isArray()){
Object[] subObjs=(Object[])param;
for (int j=0;j<subObjs.length;j++){
newObjs.add(subObjs[j]);
}
}else {
newObjs.add(param);
}
}
IgnoreParamFilter.filterStringConcat(2,-1,newObjs.toArray());
StringBuilder newString=new StringBuilder();
if(null!=objs&&objs.length>0){
for(Object object:newObjs){
if(object instanceof DataType){
DataType dataType=(DataType)object;
if(dataType.getDataType().equalsIgnoreCase(DataType.NUMBER)){
newString.append(dataType.getContent());
}else{
newString.append(ExcelParamUtil.getParamContent(object,"string"));
}
}else {
newString.append(ExcelParamUtil.getParamContent(object,"string"));
}
}
}
return new DataType(DataType.STRING,newString.toString());
}
/**
* 转成String
* @param objs
* @return
*/
@Override
public DataType text(Object... objs) {
String func="TEXT";
Integer number=IgnoreParamFilter.getSetFuncNumber(func);
if(null==objs||objs.length>1){
throw new RuntimeException(func+"函数参数只允许一个参数");
}
Object obj=objs[0];
if(null==obj){
throw new RuntimeException(func+"函数参数为空");
}
Object result;
if(obj instanceof DataType){
DataType dataType=(DataType)obj;
if(dataType.getDataType().equalsIgnoreCase(DataType.NUMBER)){
result=dataType.getContent();
}else if(dataType.getDataType().equalsIgnoreCase(DataType.OPTION)){
result=dataType.getOptionContent();
}else if(dataType.getComponentKey()!=null && dataType.getComponentKey().equalsIgnoreCase("FileComponent")){
result=dataType.getOptionContent();
}else{
result=ExcelParamUtil.getParamContent(dataType,DataType.STRING).toString();
}
}else {
result=obj.toString();
}
return new DataType(DataType.STRING,result);
}
/**
* 转成Int类型
* 提取字符中的数字并返回
* @param objs
* @return
*/
@Override
public DataType value(Object... objs) {
boolean isNumber=false;
Object txt=objs[0];
Object result;
Class[] typeObjects=new Class[]{};
IgnoreParamFilter.commonFilter("VALUE",1,1,typeObjects,objs);
String numberStr;
if(txt instanceof DataType){
DataType dataType=(DataType)txt;
if(dataType.getDataType().toLowerCase().equals(DataType.NUMBER)){
isNumber=true;
if(ExcelParamUtil.getParamContent(txt,"string")==null){
numberStr="0";
}else {
numberStr=ExcelParamUtil.getParamContent(txt,"string").toString();
}
}else {
if(ExcelParamUtil.getParamContent(txt,"string")==null){
numberStr="0";
}else{
numberStr=ExcelParamUtil.getParamContent(txt,"string").toString();
}
if(!RegularUtil.isNumber(numberStr)){
numberStr="0";
}
}
}else {
if(RegularUtil.isNumber(txt.toString())){
isNumber=true;
numberStr=txt.toString();
}else {
numberStr="0";
}
}
if(numberStr.indexOf(".")>0){
if(numberStr.length()>17){
numberStr=numberStr.substring(0,17);
}
result=new BigDecimal(numberStr);
}else {
if(numberStr.length()>16){
numberStr=numberStr.substring(0,16);
}
result=Long.parseLong(numberStr);
}
return new DataType(DataType.NUMBER,result);
}
/**
* 获取字符串长度
* @param txt
* @return
*/
@Override
public DataType len(Object... txt) {
Class[] typeObjects=new Class[]{String.class};
IgnoreParamFilter.commonFilter("LEN",1,1,typeObjects,txt);
int length=ExcelParamUtil.getParamContent(txt[0],"string").toString().length();
return new DataType(DataType.NUMBER,length);
}
/**
*搜索字符返回位置下标
* 第一个参数是搜索字符
* 第二个参数是源字符串
* @param objects
* @return
*/
@Override
public DataType search(Object... objects) {
Class[] typeObjects=new Class[]{String.class,String.class,Integer.class};
int idx=0;
IgnoreParamFilter.commonFilter("SEARCH",2,3,typeObjects,objects);
if(objects.length==3){
Object idxObj=ExcelParamUtil.getParamContent(objects[2],"option");
if(idxObj.toString().indexOf(".")>0){
idx=Integer.parseInt(idxObj.toString().split("\\.")[0]);
}else {
idx=Integer.parseInt(idxObj.toString());
}
idx=idx>=0?idx:0;
idx=idx==0?idx:idx-1;
}
String sourceStr=ExcelParamUtil.getParamContent(objects[1],"string").toString();
String searchWord=ExcelParamUtil.getParamContent(objects[0],"string").toString();
int findIdx=sourceStr.indexOf(searchWord,idx);
findIdx=findIdx<0?0:findIdx+1;
return new DataType(DataType.NUMBER,findIdx);
}
/**
* 替换字符函数
* 第一个参数是源字符串
* 第二个参数是替换开始位置，以0开始
* 第三个参数是替换字符的长度，从替换位置开始到结束的字符，为需要替换的字符串
* 第四个参数作为替换字符
* @param objects
* @return
*/
@Override
public DataType replace(Object... objects) {
Object result;
Class[] typeObjects=new Class[]{String.class,Integer.class,Integer.class,String.class};
IgnoreParamFilter.commonFilter("REPLACE",4,4,typeObjects,objects);
String sourceStr=ExcelParamUtil.getParamContent(objects[0],"string").toString();
Double ridxD=Double.parseDouble(ExcelParamUtil.getParamContent(objects[1],"string").toString());
int repIdx=ridxD.intValue();
Double repD=Double.parseDouble(ExcelParamUtil.getParamContent(objects[2],"string").toString());
int repLenth=repD.intValue();
String repWord=ExcelParamUtil.getParamContent(objects[3],"string").toString();
int replaceLength=(repIdx-1)+repLenth;
if(replaceLength>sourceStr.length()){
// throw new RunTimeException(errorJson.getString("msg"));
logger.info("REPLACE函数替换位置超过了字符长度");
replaceLength=sourceStr.length();
}
String cutStr=sourceStr.substring(repIdx-1,replaceLength);
sourceStr=sourceStr.replaceFirst(cutStr,repWord);
result=sourceStr;
return new DataType(DataType.STRING,result);
}
/**
* 参数重复叠加函数
* 第一个参数为源字符
* 第二个为叠加次数
* @param objects
* @return
*/
@Override
public DataType repeat(Object... objects) {
Object result;
Class[] typeObjects=new Class[]{String.class,Integer.class};
IgnoreParamFilter.commonFilter("REPEAT",2,2,typeObjects,objects);
String str=ExcelParamUtil.getParamContent(objects[0],"string").toString();
Double repeatD=Double.parseDouble(ExcelParamUtil.getParamContent(objects[1],"string").toString());
int repeat=repeatD.intValue();
repeat=repeat>=1?repeat:1;
StringBuffer sbf=new StringBuffer();
sbf.append(str);
for(int i=1;i<repeat;i++){
sbf.append(str);
}
result=sbf.toString();
return new DataType(DataType.STRING,result);
}
/**
* 字符补齐拼接函数
* 第一个参数为源字符串
* 第二个参数为预期字符长度
* 第三个参数为补齐字符，作为源字符串没有达到长度时，函数要去拼接到预期长度的字符
* 第四个参数为补齐位置，RIGHT、LEFT，分别是从左边补齐或者从右边补齐
* @param objects
* @return
*/
@Override
public DataType pad(Object... objects) {
Object result;
Class[] typeObjects=new Class[]{String.class,Integer.class,String.class,String.class};
IgnoreParamFilter.commonFilter("PAD",3,4,typeObjects,objects);
String sourceStr=ExcelParamUtil.getParamContent(objects[0],"string").toString();
Double sourceLengthD=Double.parseDouble(ExcelParamUtil.getParamContent(objects[1],"string").toString());
Integer sourceLength=sourceLengthD.intValue();
sourceLength=sourceLength>=0?sourceLength:0;
String fillStr=ExcelParamUtil.getParamContent(objects[2],"string").toString();
String fillPosition="RIGHT";
if(objects.length==4){
fillPosition=ExcelParamUtil.getParamContent(objects[3],"string").toString();
Arrays.sort(fillPositonArray);
if(Arrays.binarySearch(fillPositonArray,fillPosition)<0){
String func="TEXT";
Integer number=IgnoreParamFilter.getSetFuncNumber(func);
throw new RuntimeException(func+"函数第四个参数值不正确");
}
}
if(sourceStr.length()<sourceLength){
int loopLenth=sourceLength-sourceStr.length();
boolean r=true;
List<Character> chars=new ArrayList<>();
sourceStr=ExcelParamUtil.appendString(fillStr,sourceStr,sourceLength,fillPosition);
}
result=sourceStr;
return new DataType(DataType.STRING,result);
}
/**
* 去首尾空格
* @param objects
* @return
*/
@Override
public DataType trim(Object... objects) {
Object result;
Class[] typeObjects=new Class[]{String.class};
IgnoreParamFilter.commonFilter("TRIM",1,1,typeObjects,objects);
String sourceStr=ExcelParamUtil.getParamContent(objects[0],"string").toString().trim();
result=sourceStr;
return new DataType(DataType.STRING,result);
}
/**
* 字符左截取函数
* 返回从左边开始到指定位置的字符串
* 第一个参数是源字符串
* 第二个参数是截取长度
* @param objects
* @return
*/
@Override
public DataType left(Object... objects) {
Object result;
Class[] typeObjects=new Class[]{String.class,Integer.class};
IgnoreParamFilter.commonFilter("LEFT",2,2,typeObjects,objects);
String sourceStr=ExcelParamUtil.getParamContent(objects[0],"string").toString();
Double cutIdxD=Double.parseDouble(ExcelParamUtil.getParamContent(objects[1],"string").toString());
int cutIdx=cutIdxD.intValue();
cutIdx=cutIdx>=0?cutIdx:1;
if(cutIdx>sourceStr.length()){
cutIdx=sourceStr.length();
}
sourceStr=sourceStr.substring(0,cutIdx);
result=sourceStr;
return new DataType(DataType.STRING,result);
}
/**
* 字符右截取函数
* 返回从右边开始到指定位置的字符串
* 第一个参数是源字符串
* 第二个参数是截取长度
* @param objects
* @return
*/
@Override
public DataType right(Object... objects) {
Object result;
Class[] typeObjects=new Class[]{String.class,Integer.class};
IgnoreParamFilter.commonFilter("RIGHT",2,2,typeObjects,objects);
String sourceStr=ExcelParamUtil.getParamContent(objects[0],"string").toString();
Double cutIdxD=Double.parseDouble(ExcelParamUtil.getParamContent(objects[1],"string").toString());
int cutIdx=cutIdxD.intValue();
cutIdx=cutIdx>=0?cutIdx:1;
if(cutIdx>sourceStr.length()){
cutIdx=sourceStr.length();
}
sourceStr=sourceStr.substring(sourceStr.length()-cutIdx);
result=sourceStr;
return new DataType(DataType.STRING,result);
}
/**
* 字符自由截取函数
* 第一个参数是源字符串
* 第二个参数是截取开始位置
* 第三个参数是截取结束位置
* @param objects
* @return
*/
@Override
public DataType mid(Object... objects) {
Object result;
Class[] typeObjects=new Class[]{String.class,Integer.class,Integer.class};
IgnoreParamFilter.commonFilter("MID",3,3,typeObjects,objects);
String sourceStr=ExcelParamUtil.getParamContent(objects[0],"string").toString();
if(null==sourceStr||sourceStr.trim().equals("")){
return new DataType(DataType.STRING,"");
}
Double cutidxD=Double.parseDouble(ExcelParamUtil.getParamContent(objects[1],"string").toString());
int cutIdx=cutidxD.intValue();
cutIdx=cutIdx>0?cutIdx:1;
Double cutStrLenD=Double.parseDouble(ExcelParamUtil.getParamContent(objects[2],"string").toString());
int cutStrLen=cutStrLenD.intValue();
cutStrLen=cutStrLen>0?cutStrLen:1;
if((cutIdx-1+cutStrLen)>sourceStr.length()){
sourceStr=sourceStr.substring(cutIdx-1,sourceStr.length());
}else {
sourceStr=sourceStr.substring(cutIdx-1,(cutIdx-1)+cutStrLen);
}
result=sourceStr;
return new DataType(DataType.STRING,result);
}
@Override
public DataType score(Object... objs) {
Object result;
DataType fraction=(DataType)objs[0];
result=fraction.getScore();
if(result==null){
result=0;
}
return new DataType(DataType.NUMBER,result);
}
@Override
public DataType idCard(Object... objects) {
Object result="";
// IgnoreParamFilter.checkValiIdCard("IDCARD",objects);
String operType=ExcelParamUtil.getParamContent(objects[1],"string").toString();
String idCard=ExcelParamUtil.getParamContent(objects[0],"string").toString();
RegularUtil.validateIDCard(idCard);
if(idCard.length()!=18&&idCard.length()!=15){
Integer number=IgnoreParamFilter.getSetFuncNumber("IDCARD");
throw new RuntimeException("只能计算中国大陆的身份证");
}
DataType exeResult=new DataType();
if(operType.equalsIgnoreCase("BD")){
exeResult=bd(idCard);
}else if(operType.equalsIgnoreCase("NA")){
exeResult=nativePlace(idCard);
}else if(operType.equalsIgnoreCase("AGE")){
exeResult=age(idCard);
}else if(operType.equalsIgnoreCase("GENDER")){
exeResult=sex(idCard);
}
return exeResult;
}
@Override
public DataType sex(String IDCard){
String sex ="";
//15位身份证号
if (IDCard.length() == 15){
if (Integer.parseInt(IDCard.substring(14, 15)) % 2 == 0) {
sex = "女";
} else {
sex = "男";
}
//18位身份证号
}else if(IDCard.length() == 18){
// 判断性别
if (Integer.parseInt(IDCard.substring(16).substring(0, 1)) % 2 == 0) {
sex = "女";
} else {
sex = "男";
}
}
logger.info(sex);
return new DataType(DataType.STRING,sex);
}
@Override
public DataType nativePlace(String idCard){
int nativePlaceCode=Integer.parseInt(idCard.substring(0, 6));
String nativePlace= NativePlace.getNativePlace(nativePlaceCode);
logger.info("您所在的地区为：\n" + nativePlace);
return new DataType(DataType.STRING,nativePlace);
}
@Override
public DataType age(String idCard){
Object age=0;
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
DataType datatype=bd(idCard);
String birthdayStr=datatype.getContent()!=null?datatype.getContent()+"":"";
try {
if(StringUtils.isNotEmpty(birthdayStr)){
String today=formatter.format(new Date());
Double ageN= DateTimeServiceImpl.getBetween(birthdayStr,today,"Y");//使用日期函数获取日期间隔年数
DataType dataType=mathFuncsService.roundDown(ageN);//做一次向下取整
if(dataType!=null && dataType.getContent()!=null){
age=dataType.getContent();
}
logger.info("年龄："+age);
}
} catch (ParseException e) {
logger.error("err",e);
}
return new DataType(DataType.NUMBER,age);
}
@Override
public DataType bd(String idCard){
String result=null;
Calendar c=Calendar.getInstance();
Integer number=IgnoreParamFilter.getSetFuncNumber("IDCARD");
switch(idCard.length()) {
case 18:
case 15:
String year = idCard.substring(6, 10);
if(Integer.decode(year) <1900 && Integer.decode(year)>c.get(Calendar.YEAR)){
JSONObject errorJson=ErrorUtil.buildError("IDCARD",number,number,"IDCARD函数身份证字符不正确");
throw new RuntimeException(errorJson.getString("msg"));
}
String month = idCard.substring(10,12);
if(Integer.parseInt(month)<1 && Integer.parseInt(month)>12){
JSONObject errorJson= ErrorUtil.buildError("IDCARD",number,number,"IDCARD函数身份证字符不正确");
throw new RuntimeException(errorJson.getString("msg"));
}
String day = idCard.substring(12,14);
c.set(Integer.parseInt(year) ,Integer.parseInt(month), 0);
if(Integer.parseInt(day)>c.get(Calendar.DAY_OF_MONTH)){
JSONObject errorJson=ErrorUtil.buildError("IDCARD",number,number,"IDCARD函数身份证字符不正确");
throw new RuntimeException(errorJson.getString("msg"));
}
String birth=year+"-"+month+"-"+day;
logger.info("生日为："+birth);
result=birth;
break;
}
return new DataType(DataType.STRING,result);
}
@Override
public DataType addressAnalysis(Object obj1, Object obj2) {
Integer number=IgnoreParamFilter.getSetFuncNumber(FuncNames.ADDRESS.getName());
String addressType=ExcelParamUtil.checkParamType(obj1);
String levelType=ExcelParamUtil.checkParamType(obj2);
if(!addressType.equalsIgnoreCase("string") || !levelType.equalsIgnoreCase("string")){
JSONObject errorJson=ErrorUtil.buildError(FuncNames.ADDRESS.toString(),number,number,"地址解析函数的参数只允许字符类型");
throw new RuntimeException(errorJson.getString("msg"));
}
String address="";
String level="";
if(obj1 instanceof DataType){
address=ExcelParamUtil.getParamContent(obj1).toString();
}else{
address=obj1.toString();
}
if(obj2 instanceof DataType){
level=ExcelParamUtil.getParamContent(obj2).toString();
}else {
level=obj2.toString();
}
Map<String,String> placeMap=NativePlace.getAddressInfo(address);
String result="";
switch (level){
case PROVINCE:
result=placeMap.get(PROVINCE);
break;
case CITY:
result=placeMap.get(CITY);
break;
case TOWN:
result=placeMap.get(TOWN);
break;
case ADDR:
result=placeMap.get(ADDR);
default:
JSONObject errorJson=ErrorUtil.buildError(FuncNames.ADDRESS.toString(),number,number,"行政区块只支持省、市、区县");
throw new RuntimeException(errorJson.getString("msg"));
}
return new DataType(DataType.STRING,result);
}
@Override
public DataType subString(Object... objects) {
String newString="";
if(objects!=null && objects.length==3){
String sourceString=null;
BigDecimal subIdx=null;
BigDecimal subEndIdx=null;
if(objects[0] instanceof DataType){
sourceString=ExcelParamUtil.getParamContent(objects[0],"string").toString();
}else{
sourceString=objects[0]+"";
}
//如果字符为空，直接返回
if(sourceString==null || sourceString.length()==0){
return new DataType(DataType.STRING,newString);
}
if(objects[1] instanceof DataType){
subIdx=new BigDecimal(ExcelParamUtil.getParamContent(objects[1],"").toString());
}else{
subIdx=new BigDecimal(objects[1]+"");
}
if(objects[2] instanceof DataType){
subEndIdx=new BigDecimal(ExcelParamUtil.getParamContent(objects[2],"").toString());
}else{
subEndIdx=new BigDecimal(objects[2]+"");
}
//如果截取位置小于0或者大于字符长度，直接返回
if(subIdx.intValue()<0 || subIdx.intValue()>sourceString.length()){
return new DataType(DataType.STRING,newString);
}
//如果截取位置小于0或者大于字符长度，直接返回
if(subEndIdx.intValue()<0 || subEndIdx.intValue()>sourceString.length()){
return new DataType(DataType.STRING,newString);
}
newString=sourceString.substring(subIdx.intValue()-1,subEndIdx.intValue());
}
return new DataType(DataType.STRING,newString);
}
@Override
public DataType substitue(Object... objects) {
String newString="";
if(objects!=null && objects.length==3){
String sourceString=null;
String replaceChar=null;
String newChar=null;
if(objects[0] instanceof DataType){
sourceString=ExcelParamUtil.getParamContent(objects[0],"string").toString();
}else{
sourceString=objects[0]+"";
}
if(objects[1] instanceof DataType){
replaceChar=ExcelParamUtil.getParamContent(objects[1],"string").toString();
}else{
replaceChar=objects[1]+"";
}
if(objects[2] instanceof DataType){
newChar=ExcelParamUtil.getParamContent(objects[2],"string").toString();
}else{
newChar=objects[2]+"";
}
if(sourceString==null || replaceChar.length()>sourceString.length() || newChar.length()>sourceString.length()){
return new DataType(DataType.STRING,newString);
}
newString=sourceString.replaceAll(replaceChar,newChar);
}
return new DataType(DataType.STRING,newString);
}
@Override
public DataType extract(Object... objects) {
return null;
}
@Override
public DataType lower(Object... objects) {
String sourceString="";
if(objects!=null){
if(objects[0]!=null){
if(objects[0] instanceof DataType){
sourceString=ExcelParamUtil.getParamContent(objects[0],"string").toString();
}else {
sourceString=objects[0]+"";
}
}
}
return new DataType(DataType.STRING,sourceString.toLowerCase());
}
@Override
public DataType upper(Object... objects) {
String sourceString="";
if(objects!=null){
if(objects[0]!=null){
if(objects[0] instanceof DataType){
sourceString=ExcelParamUtil.getParamContent(objects[0],"string").toString();
}else {
sourceString=objects[0]+"";
}
}
}
return new DataType(DataType.STRING,sourceString.toUpperCase());
}
@Override
public DataType exact(Object... objects) {
boolean eq=false;
if(objects!=null && objects.length==2){
String sourceOne="";
String sourceTwo="";
if(objects[0] instanceof DataType){
sourceOne=ExcelParamUtil.getParamContent(objects[0],"string").toString();
}else{
sourceOne=objects[0]+"";
}
if(objects[1] instanceof DataType){
sourceTwo=ExcelParamUtil.getParamContent(objects[1],"string").toString();
}else{
sourceTwo=objects[1]+"";
}
if(sourceOne!=null && sourceTwo!=null){
eq=sourceOne.equals(sourceTwo);
return new DataType(DataType.BOOL,eq);
}else if(sourceOne == null && sourceTwo == null){
return new DataType(DataType.BOOL,true);
}else if(sourceOne == null && sourceTwo != null){
return new DataType(DataType.BOOL,false);
}else if(sourceOne != null && sourceTwo == null){
return new DataType(DataType.BOOL,false);
}
}
return new DataType(DataType.BOOL,eq);
}
@Override
public DataType isString(Object... objects) {
Object object=objects[0];
String fieldType="";
DataType resultDataType;
if(object instanceof DataType){
DataType dataType=(DataType)object;
fieldType= ExcelParamUtil.checkParamType(dataType.getDataType());
}else {
fieldType= ExcelParamUtil.getParamType(object.getClass().getName());
}
if(fieldType.equalsIgnoreCase("string")){
resultDataType=new DataType(DataType.BOOL,true);
}else{
resultDataType=new DataType(DataType.BOOL,false);
}
return resultDataType;
}
@Override
public DataType isJson(Object... objects) {
Object object=objects[0];
String fieldType="";
DataType resultDataType;
Object content=null;
if(object instanceof DataType){
DataType dataType=(DataType)object;
content=dataType.getContent();
fieldType= ExcelParamUtil.checkParamType(dataType.getDataType());
}else {
fieldType= ExcelParamUtil.getParamType(object.getClass().getName());
content=object;
}
if(fieldType.equalsIgnoreCase("string")){
if(content!=null){
try {
logger.info("isJson函数的JSON字符转换："+content+"");
JSON.parseObject(content+"");
resultDataType=new DataType(DataType.BOOL,true);
} catch (Exception e) {
logger.info("err",e);
logger.info("不是正常的JSON字符");
resultDataType=new DataType(DataType.BOOL,false);
}
}else{
resultDataType=new DataType(DataType.BOOL,false);
}
}else{
resultDataType=new DataType(DataType.BOOL,false);
}
return resultDataType;
}
@Override
public DataType getJSONValue(Object... objects) {
Object object=objects[0];
Object objectKeyObj=objects[1];
String fieldType="";
DataType resultDataType;
Object content=null;
Object objectKey=null;
if(object instanceof DataType){
DataType dataType=(DataType)object;
content=dataType.getContent();
fieldType= ExcelParamUtil.checkParamType(dataType.getDataType());
}else {
fieldType= ExcelParamUtil.getParamType(object.getClass().getName());
content=object;
}
if(objectKeyObj instanceof DataType){
DataType dataType=(DataType)objectKeyObj;
objectKey=dataType.getContent();
}else{
objectKey=objectKeyObj;
}
if(fieldType.equalsIgnoreCase("string")){
if(content!=null){
try {
logger.info("isJson函数的JSON字符转换："+content+"");
JSONObject jsonObject=JSON.parseObject(content+"");
Object jsonValue=jsonObject.get(objectKey+"");
resultDataType=new DataType(DataType.STRING,jsonValue==null?"":jsonValue.toString());
} catch (Exception e) {
logger.info("err",e);
logger.info("不是正常的JSON字符");
resultDataType=new DataType(DataType.STRING,"");
}
}else{
resultDataType=new DataType(DataType.STRING,"");
}
}else{
resultDataType=new DataType(DataType.STRING,"");
}
return resultDataType;
}
}

24
src/com/engine/salary/formlua/util/CompareUtil.java Normal file
View File

@ -0,0 +1,24 @@
package com.engine.salary.formlua.util;
public class CompareUtil {
public static String[] genArray(Object obj, String type) {
String[] resultArray = new String[]{};
if (obj.getClass().isArray()) {
Object[] op1Array = (Object[]) obj;
resultArray = new String[op1Array.length];
for (int i = 0; i < op1Array.length; i++) {
if (ExcelParamUtil.getParamContent(op1Array[i], type) != null) {
String p = ExcelParamUtil.getParamContent(op1Array[i], type).toString();
resultArray[i] = p;
}
}
} else {
if (ExcelParamUtil.getParamContent(obj, type) != null) {
String opStr = ExcelParamUtil.getParamContent(obj, type).toString();
resultArray = opStr.split(",");
}
}
return resultArray;
}
}

212
src/com/engine/salary/formlua/util/DateUtil.java Normal file
View File

@ -0,0 +1,212 @@
package com.engine.salary.formlua.util;
import com.engine.salary.formlua.entity.parameter.DataType;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.joda.time.DateTime;
import org.joda.time.Days;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class DateUtil {
protected static final Logger logger = LoggerFactory.getLogger(DateUtil.class);
private static String[] parsePatterns = {"yyyy-MM-dd","yyyy年MM月dd日",
"yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd",
"yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyyMMdd","yy-MM","yy/MM"};
private static String[] dateComponentKeyList={"DateComponent","DateInterval","TimeComponent"};
public static void main(String args[]){
}
/**
* 构建日期对象
* @param dateChar
* @return
*/
public static Date buildDateByDateChar(String dateChar){
Date resultDate=null;
if(StringUtils.isEmpty(dateChar)){
return resultDate;
}
String formatString=buildFormat(dateChar);
if(StringUtils.isEmpty(formatString)){
return resultDate;
}
SimpleDateFormat simpleDateFormat=new SimpleDateFormat(formatString);
simpleDateFormat.setLenient(false);
try {
resultDate=simpleDateFormat.parse(dateChar);
} catch (ParseException e) {
logger.error("err",e);
}
return resultDate;
}
/**
* 判断是否是日期控件
* @param data
* @return
*/
public static boolean isDateComponent(Object data){
if(data instanceof DataType){
DataType dataType=(DataType)data;
if(dataType.getComponentKey()!=null){
for (String dateKey:dateComponentKeyList){
if(dateKey.equalsIgnoreCase(dataType.getComponentKey())){
return true;
}
}
}
}else if(data!=null && isValidDate(data+"")){
return true;
}
return false;
}
public static boolean isValidDate(String str) {
boolean convertSuccess=false;
for(String s:parsePatterns){
convertSuccess=parseDateString(str,s);
if(convertSuccess){
break;
}
}
return convertSuccess;
}
public static boolean parseDateString(String dateString,String formatString){
boolean convertSuccess=true;
SimpleDateFormat format = new SimpleDateFormat(formatString);
try {
format.setLenient(false);
format.parse(dateString);
logger.info(dateString);
} catch (ParseException e) {
// logger.error("err",e);
convertSuccess=false;
}
return convertSuccess;
}
/**
* 判断日期时间的格式
* @param dateTimeStr
* @return
*/
public static String buildFormat(String dateTimeStr,String type){
String fmateStr=null;
int len=dateTimeStr.length();
switch (type){
case "Y":
fmateStr="yyyy";
break;
case "M":
fmateStr="yyyy-MM";
break;
case "D":
fmateStr="yyyy-MM-dd";
break;
case "H":
fmateStr="yyyy-MM-dd HH";
break;
case "I":
fmateStr="yyyy-MM-dd HH:mm";
break;
case "S":
fmateStr="yyyy-MM-dd HH:mm:ss";
break;
}
return fmateStr;
}
public static String buildFormat(String dateTimeStr){
String fmateStr=null;
int len=dateTimeStr.length();
switch (len){
case 4:
if(dateTimeStr.indexOf(":")<0){
fmateStr="yyyy";
}else if(dateTimeStr.indexOf("-")<0){
fmateStr="H:mm";
}
break;
case 5:
if(dateTimeStr.indexOf(":")<0){
fmateStr="yy-MM";
}else if(dateTimeStr.indexOf("-")<0){
fmateStr="HH:mm";
}
break;
case 7:
if(dateTimeStr.indexOf(":")<0){
fmateStr="yyyy-MM";
}else if(dateTimeStr.indexOf("-")<0){
fmateStr="H:mm:ss";
}
break;
case 8:
fmateStr="HH:mm:ss";
break;
case 9:
fmateStr="yyyy-MM-dd";
break;
case 10:
fmateStr="yyyy-MM-dd";
break;
case 13:
fmateStr="yyyy-MM-dd HH";
break;
case 16:
fmateStr="yyyy-MM-dd HH:mm";
break;
case 19:
fmateStr="yyyy-MM-dd HH:mm:ss";
break;
default:
fmateStr="";
}
return fmateStr;
}
/**
* 判断参数类型，并且获取content属性的值，或者String类型直接返回
* @param obj
* @return
*/
public static String getContent(Object obj, SimpleDateFormat formatter){
String date="";
if(obj instanceof String || obj instanceof Character){
date=obj.toString();
}else if(obj instanceof Date){
date=formatter.format(obj);
}else{
DataType dataType=(DataType)obj;
Object content=dataType.getText();
if(null!=content){
date=content.toString();
}else {
date = dataType.getContent() == null ? null : dataType.getContent().toString();
}
}
return date;
}
/**
* 计算日期间相隔天数
* @param start
* @param end
* @return
*/
public static int daysBetween(Date start, Date end) {
if(start == null || end == null || start.getTime() >= end.getTime()) return 0;
Date startDate = DateUtils.truncate(start, Calendar.DATE);
return Days.daysBetween(new DateTime(startDate), new DateTime(end)).getDays();
}
}

33
src/com/engine/salary/formlua/util/ErrorUtil.java Normal file
View File

@ -0,0 +1,33 @@
package com.engine.salary.formlua.util;
import com.alibaba.fastjson.JSONObject;
public class ErrorUtil {
private static JSONObject errorJson=new JSONObject();
public static JSONObject buildDataError(String func,int errorIdx,Object errorData,String msg){
errorJson.put("msg",msg);
errorJson.put("func",func);
errorJson.put("errorIdx",errorIdx);
errorJson.put("errorData",errorData);
errorJson.put("excute",false);
return errorJson;
}
public static JSONObject buildError(String func,Integer errorIdx,Integer errorFunc,String msg){
errorJson.put("msg",msg);
errorJson.put("func",func);
errorJson.put("errorIdx",errorIdx);
errorJson.put("errorFunc",errorFunc);
errorJson.put("excute",false);
return errorJson;
}
public static JSONObject buildError(String func,int errorIdx,int endIndex,Object errorData,String msg){
errorJson.put("msg",msg);
errorJson.put("func",func);
errorJson.put("errorIdx",errorIdx);
errorJson.put("errorEndIdx",endIndex);
errorJson.put("errorData",errorData);
errorJson.put("excute",false);
return errorJson;
}
}

1125
src/com/engine/salary/formlua/util/ExcelParamUtil.java Normal file
View File

File diff suppressed because it is too large Load Diff

36
src/com/engine/salary/formlua/util/ExcelResult.java Normal file
View File

@ -0,0 +1,36 @@
package com.engine.salary.formlua.util;
import java.io.Serializable;
/**
* @author
*/
public class ExcelResult implements Serializable {
private Object data;
private int code;
private String errorInfo;
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getErrorInfo() {
return errorInfo;
}
public void setErrorInfo(String errorInfo) {
this.errorInfo = errorInfo;
}
}

492
src/com/engine/salary/formlua/util/ExcelStandardUtil.java Normal file
View File

@ -0,0 +1,492 @@
//package com.engine.salary.formlua.util;
//
//
//import com.alibaba.fastjson.JSON;
//import com.weaver.common.form.component.base.ComponentType;
//import com.weaver.excel.formula.api.entity.DataOption;
//import com.weaver.excel.formula.api.entity.FormulaVar;
//import com.weaver.excel.formula.entity.parameter.DataType;
//import com.weaver.excel.formula.entity.parameter.ParamFactory;
//import com.weaver.excel.formula.entity.standard.front.CurrentVar;
//import com.weaver.teams.domain.user.DataCollectionEmployee;
//import com.weaver.teams.util.StringUtils;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//
//import java.util.HashMap;
//import java.util.List;
//import java.util.Map;
//import java.util.regex.Matcher;
//import java.util.regex.Pattern;
//
//public class ExcelStandardUtil {
// protected static final Logger logger = LoggerFactory.getLogger(ExcelStandardUtil.class);
//
// public static Map<String,Object> replaceAllParam(String sql, List<FormulaVar> localVars,List<FormulaVar> dataVars, DataCollectionEmployee employee){
// if(null!=localVars){
// for (FormulaVar formulaVar:localVars){
// if(StringUtils.isNotEmpty(formulaVar.getDataId()) && StringUtils.isEmpty(formulaVar.getFormId())){
// formulaVar.setFormId(formulaVar.getDataId());
// }
// if(StringUtils.isNotEmpty(formulaVar.getId()) && formulaVar.getId().equalsIgnoreCase("current_department")){
// formulaVar.setType("department");
// formulaVar.setComponentKey(ComponentType.Department.toString());
// }
// if(StringUtils.isNotEmpty(formulaVar.getId()) && formulaVar.getId().equalsIgnoreCase("current_superior")){
// formulaVar.setType("employee");
// formulaVar.setComponentKey(ComponentType.Employee.toString());
// }
// }
// }
//
// Map<String,Object> dataMap=new HashMap<>();
// Map<String,DataType> paramKeyMap=new HashMap<>();
// //正则表达式匹配所有用 { } 括号包起来的变量，然后跟参数列表中的参数一一对应做替换
// String partternStr="\\{.+?\\}{1}?";
// Pattern pt=Pattern.compile(partternStr);
// Matcher matcher=pt.matcher(sql);
//
// int loop=0;
// //替换逻辑
// while (matcher.find()){
// String matherString=matcher.group();
// //替换特殊字符
// matherString=matherString.replace("{","");
// matherString=matherString.replace("}","");
// matherString=matherString.replace("(","\\(");
// matherString=matherString.replace(")","\\)");
// matherString=matherString.replaceAll("\\+","\\\\+");
// matherString=matherString.replaceAll("\\-","\\\\-");
// matherString=matherString.replaceAll("\\*","\\\\*");
// matherString=matherString.replaceAll("\\/","\\\\/");
// if(localVars!=null&&loop<localVars.size()){
// FormulaVar localFormulaVar=localVars.get(loop);
// //如果参数异常，获取Key为空，根据数据中相应的值做判断，判断是什么类型的控件
// String key=null;
// if(localFormulaVar.getOptionId()!=null && StringUtils.isNotEmpty(localFormulaVar.getOptionId())){
// key="key"+localFormulaVar.getOptionId();
// }else if(localFormulaVar.getFieldId()!=null){
// key="key"+localFormulaVar.getFieldId();
// }else if(localFormulaVar.getFormId()!=null){
// key="key"+localFormulaVar.getFormId();
// }else if(localFormulaVar.getId() !=null){
// key="key"+localFormulaVar.getId();
// }else if(localFormulaVar.getId()!=null && localFormulaVar.getId().equalsIgnoreCase(CurrentVar.current_user.toString())){
// key="key"+localFormulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// }else if(localFormulaVar.getId()!=null && localFormulaVar.getId().equalsIgnoreCase(CurrentVar.current_department.toString())){
// key="key"+localFormulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// }else if(localFormulaVar.getId()!=null && localFormulaVar.getId().equalsIgnoreCase(CurrentVar.current_position.toString())){
// key="key"+localFormulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// }else if(localFormulaVar.getId()!=null && localFormulaVar.getId().equalsIgnoreCase(CurrentVar.current_superior.toString())){
// key="key"+localFormulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// }
// if(key!=null){
// sql=sql.replaceFirst(matherString,key);
// DataType dataType=transFormulaVarToDataType(localFormulaVar,dataVars,employee);
// if(dataType!=null){
// if(!paramKeyMap.containsKey(key)){
// paramKeyMap.put(key,dataType);
// }else{
// logger.info("存在同名参数："+key+"-->"+JSON.toJSONString(dataType));
// }
// }else{
// String typeKey=localFormulaVar.getProperKey();
// if(StringUtils.isNotEmpty(localFormulaVar.getFieldType())){
// typeKey=localFormulaVar.getFieldType();
// }else if(StringUtils.isNotEmpty(localFormulaVar.getType())){
// typeKey=localFormulaVar.getType();
// }else if(StringUtils.isNotEmpty(localFormulaVar.getFieldType())){
// typeKey=localFormulaVar.getFieldType();
// localFormulaVar.setComponentKey(localFormulaVar.getFieldType());
// }
// dataType.setDataType(ExcelParamUtil.findDataType(typeKey));
// dataType.setFieldId(localFormulaVar.getFieldId());
// dataType.setFormId(StringUtils.isNotEmpty(localFormulaVar.getFormId())?Long.parseLong(localFormulaVar.getFormId()):null);
// try {
// dataType.setModule(localFormulaVar.getModule());
// } catch (IllegalArgumentException e) {
// logger.error("err",e);
// dataType.setModule(localFormulaVar.getModule());
// }
// dataType.setContent("");
// if(!paramKeyMap.containsKey(key)){
// paramKeyMap.put(key,dataType);
// }else{
// logger.info("存在同名参数："+key+"-->"+JSON.toJSONString(dataType));
// }
// }
// }
// loop++;
// }
// }
//// if(loop!=localVars.size()){
//// throw new RuntimeException("参数列表与执行语句不一致");
//// }
// dataMap.put("param",paramKeyMap);
// dataMap.put("sql",sql);
// return dataMap;
// }
//
// public static Map<String,Object> replaceAllParamForTest(String sql, List<FormulaVar> formulaVars, DataCollectionEmployee employee){
// if(null==formulaVars){
// return null;
// }
// for (FormulaVar formulaVar:formulaVars){
// if(StringUtils.isNotEmpty(formulaVar.getDataId()) && StringUtils.isEmpty(formulaVar.getFormId())){
// formulaVar.setFormId(formulaVar.getDataId());
// if(StringUtils.isNotEmpty(formulaVar.getType()) && StringUtils.isEmpty(formulaVar.getComponentKey())){
// if(formulaVar.getType().equalsIgnoreCase("operator") || formulaVar.getType().equalsIgnoreCase("employee")){
// formulaVar.setComponentKey("");
// }
// }
// }
// if(StringUtils.isNotEmpty(formulaVar.getId()) && formulaVar.getId().equalsIgnoreCase("current_department")){
// formulaVar.setType("department");
// formulaVar.setComponentKey("Department");
// }
// if(StringUtils.isNotEmpty(formulaVar.getId()) && formulaVar.getId().equalsIgnoreCase("current_superior")){
// formulaVar.setType("employee");
// formulaVar.setComponentKey("Employee");
// }
// }
// Map<String,Object> dataMap=new HashMap<>();
// Map<String,DataType> paramKeyMap=new HashMap<>();
// //正则表达式匹配所有用 { } 括号包起来的变量，然后跟参数列表中的参数一一对应做替换
// String partternStr="\\{.+?\\}{1}?";
// Pattern pt=Pattern.compile(partternStr);
// Matcher matcher=pt.matcher(sql);
//
// int loop=0;
// //替换逻辑
// while (matcher.find()){
// String matherString=matcher.group();
// //替换特殊字符
// matherString=matherString.replace("{","");
// matherString=matherString.replace("}","");
// matherString=matherString.replace("(","\\(");
// matherString=matherString.replace(")","\\)");
// matherString=matherString.replaceAll("\\+","\\\\+");
// matherString=matherString.replaceAll("\\-","\\\\-");
// matherString=matherString.replaceAll("\\*","\\\\*");
// matherString=matherString.replaceAll("\\/","\\\\/");
// if(formulaVars!=null&&loop<formulaVars.size()){
// FormulaVar formulaVar=formulaVars.get(loop);
// //如果参数异常，获取Key为空，根据数据中相应的值做判断，判断是什么类型的控件
// String key=null;
// if(formulaVar.getOptionId()!=null && StringUtils.isNotEmpty(formulaVar.getOptionId())){
// key="key"+formulaVar.getOptionId();
// sql=sql.replaceFirst(matherString,key);
// }else if(formulaVar.getFieldId()!=null){
// key="key"+formulaVar.getFieldId();
// sql=sql.replaceFirst(matherString,key);
// }else if(formulaVar.getFormId()!=null){
// key="key"+formulaVar.getFormId()+"";
// sql=sql.replaceFirst(matherString,key);
// }else if(StringUtils.isNotEmpty(formulaVar.getFieldType())){
// if(formulaVar.getFieldType().equalsIgnoreCase("option")){
// key="key"+formulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// }
// }else if(formulaVar.getId()!=null){
// if(formulaVar.getId().equalsIgnoreCase("current_user") || formulaVar.getId().equalsIgnoreCase("current_superior") || formulaVar.getId().equalsIgnoreCase("current_department")){
// key="key"+formulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// }else if(formulaVar.getType()!=null && formulaVar.getType().equalsIgnoreCase("department")){
// key="key"+formulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// //人员选项常量
// }else if(formulaVar.getType()!=null && formulaVar.getType().equalsIgnoreCase("employee")){
// key="key"+formulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// }
//
// }else if(StringUtils.isNotEmpty(formulaVar.getType())){
// /**
// * 部门选项常量
// */
// if(formulaVar.getType().equalsIgnoreCase("department")){
// key="key"+formulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// //人员选项常量
// }else if(formulaVar.getType().equalsIgnoreCase("employee")){
// key="key"+formulaVar.getId()+"";
// sql=sql.replaceFirst(matherString,key);
// }
// }
// if(key!=null){
// if(!paramKeyMap.containsKey(key)){
// paramKeyMap.put(key,transFormulaVarToDataTypeTesy(formulaVar,employee));
// }
// }
// loop++;
// }
// }
// if(loop!=formulaVars.size()){
// throw new RuntimeException("参数列表与执行语句不一致");
// }
// dataMap.put("param",paramKeyMap);
// dataMap.put("sql",sql);
// logger.info("函数校验参数："+JSON.toJSONString(dataMap));
// return dataMap;
// }
//
// private static DataType transFormulaVarToDataTypeTesy(FormulaVar formulaVar,DataCollectionEmployee employee){
// DataType dataType =new DataType();
// ParamFactory paramFactory=ParamFactory.getInstance();
// dataType.setContent(formulaVar.getContent());
// dataType.setText(formulaVar.getContent());
// String typeKey=formulaVar.getProperKey();
// if(StringUtils.isNotEmpty(formulaVar.getFieldType()) && StringUtils.isEmpty(typeKey)){//选项型取值
// typeKey=formulaVar.getFieldType();
// }else if(StringUtils.isNotEmpty(formulaVar.getType()) && StringUtils.isEmpty(typeKey)){//当前操作人取值
// typeKey=formulaVar.getType();
// }else if(StringUtils.isNotEmpty(formulaVar.getFieldType()) && StringUtils.isEmpty(typeKey)){
// typeKey=formulaVar.getFieldType();
// formulaVar.setComponentKey(formulaVar.getFieldType());
// }
// switch (ExcelParamUtil.findDataType(typeKey)){
// case DataType.DATE:
// dataType.setContent(paramFactory.getDateTimeValue());
// dataType.setText(paramFactory.getDateTimeValue());
// dataType.setDataType(DataType.STRING);
// dataType.setComponentKey("DateComponent");
// break;
// case DataType.STRING:
// dataType.setContent(paramFactory.getCharValue());
// dataType.setText(paramFactory.getCharValue());
// dataType.setDataType(DataType.STRING);
// dataType.setComponentKey("Text");
// break;
// case DataType.NUMBER:
// dataType.setContent(paramFactory.getDoubleValue());
// dataType.setText(paramFactory.getDoubleValue()+"");
// dataType.setDataType(DataType.NUMBER);
// dataType.setComponentKey("NumberComponent");
// break;
// case DataType.OPTION:
// dataType.setContent(paramFactory.getSelectValue());
// dataType.setText(paramFactory.getSelectValue());
// dataType.setScore(paramFactory.getDoubleValue());
// dataType.setDataType(DataType.OPTION);
//
// if(formulaVar.getType()!=null && (formulaVar.getType().equalsIgnoreCase("employee") || formulaVar.getType().equalsIgnoreCase("operator")) || (formulaVar.getProperKey()!=null && formulaVar.getProperKey().equalsIgnoreCase("employee"))){
// dataType.setContent(employee.getId());
// dataType.setComponentKey("Employee");
// if(formulaVar.getId()!=null && formulaVar.getId().equalsIgnoreCase("current_superior")){
// dataType.setContent(employee.getSuperiorId());
// }
// }else if(formulaVar.getType()!=null && (formulaVar.getType().equalsIgnoreCase(ComponentType.Department.toString()) || formulaVar.getType().equalsIgnoreCase(ComponentType.Department.toString())) || (formulaVar.getProperKey()!=null && formulaVar.getProperKey().equalsIgnoreCase(ComponentType.Department.toString()))){
// dataType.setContent(employee.getDepartmentId());
// dataType.setComponentKey("Department");
// }else{
// if(formulaVar.getFieldType()!=null && formulaVar.getFieldType().equalsIgnoreCase("Employee")){
// formulaVar.setComponentKey("Employee");
// dataType.setComponentKey("Employee");
// }else{
// dataType.setComponentKey("RadioBox");
// }
// }
//
// break;
// case DataType.DATASOURCE:
// dataType.setContent(paramFactory.getSelectValue());
// dataType.setText(paramFactory.getSelectValue());
// dataType.setScore(paramFactory.getDoubleValue());
// dataType.setDataType(DataType.OPTION);
// dataType.setComponentKey("RadioBox");
// break;
// default:
// break;
// }
// if(StringUtils.isNotEmpty(formulaVar.getDataType())){
// dataType.setDataType(formulaVar.getDataType());
// }
//
// dataType.setFieldId(formulaVar.getFieldId()+"");
// dataType.setFormId(formulaVar.getFormId()!=null?Long.parseLong(formulaVar.getFormId()):null);
// dataType.setEmployee(employee);
// if(StringUtils.isNotEmpty(formulaVar.getModule())){
// try {
// try {
// dataType.setModule(formulaVar.getModule());
// } catch (IllegalArgumentException e) {
// logger.error("err",e);
// dataType.setModule(formulaVar.getModule());
// }
// } catch (IllegalArgumentException e) {
// logger.error("err",e);
// dataType.setModule(formulaVar.getModule());
// }
//
// }
// dataType.setName(formulaVar.getTitle());
// if(StringUtils.isEmpty(dataType.getName())){
// dataType.setName(formulaVar.getName());
// }
// return dataType;
// }
//
// private static DataType transFormulaVarToDataType(FormulaVar localFormulaVar,List<FormulaVar> dataVars,DataCollectionEmployee employee){
// DataType dataType =new DataType();
// if(localFormulaVar == null){
// return null;
// }
//
// String typeKey=localFormulaVar.getProperKey();
// if(StringUtils.isNotEmpty(localFormulaVar.getFieldType())){
// typeKey=localFormulaVar.getFieldType();
// }else if(StringUtils.isNotEmpty(localFormulaVar.getType())){
// typeKey=localFormulaVar.getType();
// }else if(StringUtils.isNotEmpty(localFormulaVar.getFieldType())){
// typeKey=localFormulaVar.getFieldType();
// localFormulaVar.setComponentKey(localFormulaVar.getFieldType());
// }
// logger.info(localFormulaVar.getId()+"typeKey=:"+typeKey);
// switch (ExcelParamUtil.findDataType(typeKey)){
// case DataType.DATE:
// dataType.setDataType(DataType.STRING);
// setContent(dataType,typeKey,localFormulaVar.getFieldId(),dataVars,"field");
// if(dataType.getContent()==null){
// dataType.setContent("");
// }
// break;
// case DataType.STRING:
// dataType.setDataType(DataType.STRING);
// setContent(dataType,typeKey,localFormulaVar.getFieldId(),dataVars,"field");
// if(dataType.getContent()==null){
// dataType.setContent("");
// }
// break;
// case DataType.NUMBER:
// dataType.setDataType(DataType.NUMBER);
// setContent(dataType,typeKey,localFormulaVar.getFieldId(),dataVars,"field");
// break;
// case DataType.OPTION:
// logger.info("函数构建选项型："+JSON.toJSONString(localFormulaVar));
// dataType.setDataType(DataType.OPTION);
// setContent(dataType,typeKey,localFormulaVar.getFieldId(),dataVars,"option");
// if(dataType.getContent() == null){
// dataType.setContent(localFormulaVar.getId()!=null?localFormulaVar.getId():localFormulaVar.getOptionId());
// dataType.setText(dataType.getContent()+"");
// }
// //当前操作人赋值
// if(localFormulaVar.getId()!=null){
// switch (localFormulaVar.getId()){
// case "current_user":
// dataType.setContent(employee.getId());
// dataType.setOptionContent(employee.getName());
// break;
// case "current_superior":
// dataType.setContent(employee.getSuperiorId());
// break;
// case "current_department":
// dataType.setContent(employee.getDepartmentId());
// break;
// case "current_position":
// dataType.setContent(employee.getPositionId());
// break;
// default:
// break;
// }
// logger.info("当前操作人赋值完成："+JSON.toJSONString(dataType));
// }
// break;
// case DataType.DATASOURCE:
// dataType.setDataType(DataType.DATASOURCE);
// setContent(dataType,typeKey,localFormulaVar.getFieldId(),dataVars,"option");
// break;
// default:
// logger.info("未匹配到参数类型："+(JSON.toJSONString(localFormulaVar)));
// break;
// }
// if(StringUtils.isNotEmpty(localFormulaVar.getDataType())){
// dataType.setDataType(localFormulaVar.getDataType());
// }
// if(StringUtils.isEmpty(dataType.getComponentKey())){
// if(StringUtils.isNotEmpty(localFormulaVar.getFieldType())){
// dataType.setComponentKey(localFormulaVar.getFieldType());
// }else if(StringUtils.isNotEmpty(localFormulaVar.getProperKey())){
// dataType.setComponentKey(localFormulaVar.getProperKey());
// }else if(StringUtils.isNotEmpty(localFormulaVar.getComponentKey())){
// dataType.setComponentKey(localFormulaVar.getComponentKey());
// }
// }
// dataType.setFieldId(localFormulaVar.getFieldId()+"");
// dataType.setFormId(localFormulaVar.getFormId()!=null?Long.parseLong(localFormulaVar.getFormId()):null);
// dataType.setEmployee(employee);
// if(StringUtils.isNotEmpty(localFormulaVar.getModule())){
// try {
// dataType.setModule(localFormulaVar.getModule());
// } catch (IllegalArgumentException e) {
// logger.error("err",e);
// dataType.setModule(localFormulaVar.getModule());
// }
// }
// dataType.setName(localFormulaVar.getTitle()!=null?localFormulaVar.getTitle():localFormulaVar.getName());
// logger.info("构建值完毕："+JSON.toJSONString(dataType));
// return dataType;
// }
// private static void setContent(DataType dataType,String typeKey,String sourceVar,List<FormulaVar> targetVarList,String type){
// if(sourceVar==null){
// return ;
// }
// for (FormulaVar loopVar:targetVarList){
// switch (type){
// case "field":
// if(sourceVar.equalsIgnoreCase(loopVar.getFieldId())){
// dataType.setContent(loopVar.getContent()!=null?loopVar.getContent():"");
// dataType.setText(dataType.getContent()+"");
// if(StringUtils.isNotEmpty(loopVar.getsFormId())){
// dataType.setSubFormId(Long.parseLong(loopVar.getsFormId()));
// }
// dataType.setComponentKey(loopVar.getComponentKey());
// }else{
// dataType.setComponentKey(typeKey);
// }
// break;
// case "form":
// if(sourceVar.equalsIgnoreCase(loopVar.getFormId())){
// dataType.setContent(loopVar.getContent());
// }
// break;
// case "option":
// if(sourceVar.equalsIgnoreCase(loopVar.getFieldId())){
// dataType.setContent(loopVar.getContent());
// if(dataType.getContent()==null){
// dataType.setContent(loopVar.getOptionId());
// dataType.setText(loopVar.getOptionId());
// }
// //常量
// if(StringUtils.isNotEmpty(loopVar.getOptionContent())){
// dataType.setOptionContent(loopVar.getOptionContent());
// }else if(loopVar.getDataOptionList()!=null && loopVar.getDataOptionList().size()>0){
// String optionContents="";
// List<DataOption> dataOptions=loopVar.getDataOptionList();
// for(DataOption dataOption:dataOptions){
// optionContents+=dataOption.getOptionContent()+",";
// }
// if(optionContents.lastIndexOf(",")>0){
// optionContents=optionContents.substring(0,optionContents.lastIndexOf(","));
// }
// dataType.setOptionContent(optionContents);
// }else {//变量
// dataType.setOptionContent(loopVar.getContent());
// }
//
// dataType.setScore(loopVar.getScore());
// if(StringUtils.isNotEmpty(loopVar.getsFormId())){
// dataType.setSubFormId(Long.parseLong(loopVar.getsFormId()));
// }
// dataType.setComponentKey(loopVar.getComponentKey());
// }
// break;
// default:
// break;
// }
// }
// }
//}

227
src/com/engine/salary/formlua/util/ExpressRegularUtil.java Normal file
View File

@ -0,0 +1,227 @@
package com.engine.salary.formlua.util;
import com.alibaba.fastjson.JSONObject;
import com.engine.salary.formlua.entity.parameter.FormulaContext;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
public class ExpressRegularUtil {
private static final String[] checkRegularNullParameter=new String[]{"TRUE","FALSE","NOW","TODAY"};
private static final String[] operSymbs=new String[]{">",">=","=","<","<=","\\+","-","\\*","\\/","!="};
private static final String checkRegularParameter="AND|OR|IF|NOT|LIKE|DATEDIFF|DATEADD|WEEKNUM|WEEKDAY|DATEFORMAT|Y|M|D|H|I|S|COUNT|SUM|MAX|MIN|CONCAT|SEARCH|TEXT|PAD|REPLACE|VALUE|LEN|LEFT|RIGHT|MID";
private final static String leftCircleBracket="Unmatched closing '('";
private final static String rightCircleBracket="Unmatched closing ')'";
private final static String leftSquareBracket="Unmatched closing '['";
private final static String rightSquareeBracket="Unmatched closing ']'";
private final static String leftBigBracket="Unmatched closing '{'";
private final static String rightBigBracket="Unmatched closing '}'";
public static boolean checkFuncExpress(String str){
filter(str);
return true;
}
public static boolean isContainChinese(String str) {
Pattern p = Pattern.compile("[\u4E00-\u9FA5|\\！|\\，|\\。|\\（|\\）|\\《|\\》|\\“|\\”|\\？|\\：|\\；|\\【|\\】]");
Matcher m = p.matcher(str);
if (m.find()) {
return true;
}
return false;
}
private static void filter(String formula){
try {
testSymbol(formula);
checkNullRegular(formula);
checkOperatorNullParam(formula);
formula=formula.replaceAll("","#");
String leftReplace="";
String rightReplace="";
leftReplace=formula.replaceAll("\\(","");
rightReplace=formula.replaceAll("\\)","");
if(leftReplace.length()>rightReplace.length()){
PatternSyntaxException patternSyntaxException=new PatternSyntaxException(leftCircleBracket,formula,formula.lastIndexOf(")"));
throw patternSyntaxException;
}
if(leftReplace.length()<rightReplace.length()){
PatternSyntaxException patternSyntaxException=new PatternSyntaxException(rightCircleBracket,formula,formula.indexOf("("));
throw patternSyntaxException;
}
leftReplace=formula.replaceAll("\\{","");
rightReplace=formula.replaceAll("}","");
if(leftReplace.length()>rightReplace.length()){
PatternSyntaxException patternSyntaxException=new PatternSyntaxException(leftBigBracket,formula,formula.lastIndexOf("}"));
throw patternSyntaxException;
}
if(leftReplace.length()<rightReplace.length()){
PatternSyntaxException patternSyntaxException=new PatternSyntaxException(rightBigBracket,formula,formula.indexOf("{"));
throw patternSyntaxException;
}
leftReplace=formula.replaceAll("\\[","");
rightReplace=formula.replaceAll("]","");
if(leftReplace.length()>rightReplace.length()){
PatternSyntaxException patternSyntaxException=new PatternSyntaxException(leftSquareBracket,formula,formula.lastIndexOf("]"));
throw patternSyntaxException;
}
if(leftReplace.length()<rightReplace.length()){
PatternSyntaxException patternSyntaxException=new PatternSyntaxException(rightSquareeBracket,formula,formula.indexOf("["));
throw patternSyntaxException;
}
} catch (PatternSyntaxException e) {
String error=e.getDescription().trim();
int errorIdx=e.getIndex();
int errorEndIdx=-1;
switch (error){
case leftCircleBracket:
error="'('括号没有找到";
errorEndIdx=-1;
break;
case rightCircleBracket:
error="'('括号没有闭合";
errorEndIdx=-1;
break;
case leftSquareBracket:
error="'['括号没有找到";
errorEndIdx=-1;
break;
case rightSquareeBracket:
error="'['括号没有闭合";
errorEndIdx=-1;
break;
case leftBigBracket:
error="'{'括号没有找到";
errorEndIdx=-1;
break;
case rightBigBracket:
error="'{'括号没有闭合";
errorEndIdx=-1;
break;
case "TRUE函数不能有参数":
errorEndIdx=errorIdx+4;
break;
case "FALSE函数不能有参数":
errorEndIdx=errorIdx+5;
break;
case "NOW函数不能有参数":
errorEndIdx=errorIdx+3;
break;
case "TODAY函数不能有参数":
errorEndIdx=errorIdx+5;
break;
}
JSONObject catchJson=null;
if(errorEndIdx<0){
catchJson= ErrorUtil.buildError(formula,errorIdx+1,null,error);
}else {
catchJson= ErrorUtil.buildError(formula,errorIdx+1,errorEndIdx,null,error);
}
catchJson.put("formula",formula);
throw new PatternSyntaxException(catchJson.toJSONString(),null,errorIdx+1);
}
}
private static void checkNullRegular(String formula){
String filterPattern=null;
for(int i=0;i<checkRegularNullParameter.length;i++){
int eidx=formula.indexOf(checkRegularNullParameter[i]);
if(eidx>=0){
if(FormulaContext.get().getValue(checkRegularNullParameter[i])!=null){
Integer paramCount=FormulaContext.get().getValue(checkRegularNullParameter[i]);
paramCount++;
FormulaContext.get().setValue(checkRegularNullParameter[i]);
}else {
FormulaContext.get().setValue(checkRegularNullParameter[i]);
}
filterPattern=checkRegularNullParameter[i]+"{1}\\({1}\\){1}";
Pattern pattern= Pattern.compile(filterPattern);
Matcher matcher=pattern.matcher(formula);
boolean excuteBool=matcher.find();
if(!excuteBool){
eidx=0;
Integer errorCount=FormulaContext.get().getFormulaJson().getInteger(checkRegularNullParameter[i]);
String [] errorCutArray=formula.split(checkRegularNullParameter[i]);
for (int fi=0;fi<errorCount;fi++){
eidx+=errorCutArray[fi].length();
if(errorCutArray.length>1&&fi>0){
eidx+=checkRegularNullParameter[i].length();
}
}
PatternSyntaxException patternSyntaxException=new PatternSyntaxException(checkRegularNullParameter[i]+"函数不能有参数",formula,eidx);
throw patternSyntaxException;
}
}else {
}
}
}
private static void checkOperatorNullParam(String formula){
formula=formula.trim();
JSONObject errorJson=new JSONObject();
Map<String,Integer> operMap=new HashMap<>();
for (int i=0;i<operSymbs.length;i++){
String operSymb=operSymbs[i];
if(formula.indexOf(operSymb)<0){
continue;
}
if(operMap.get(operSymb)==null){
operMap.put(operSymb,1);
}else{
operMap.put(operSymb,operMap.get(operSymb)+1);
}
String commonP="("+operSymb+")";
Pattern wrongPone=Pattern.compile("^.+"+commonP+"+?$");
Pattern wrongPtwo=Pattern.compile("^"+commonP+"+?.+$");
Pattern wrongPthree=Pattern.compile("^"+commonP+"+?$");
Matcher m=wrongPone.matcher(formula);
if(m.find()){
errorJson= ErrorUtil.buildError(operSymb,formula.length(),operMap.get(operSymb),"操作符两端的参数不能为空");
throw new RuntimeException(errorJson.getString("msg"));
}
Matcher mtwo=wrongPtwo.matcher(formula);
if(mtwo.find()){
errorJson= ErrorUtil.buildError(operSymb,1,operMap.get(operSymb),"操作符两端的参数不能为空");
throw new RuntimeException(errorJson.getString("msg"));
}
Matcher mthree=wrongPthree.matcher(formula);
if(mthree.find()){
errorJson= ErrorUtil.buildError(operSymb,1,operMap.get(operSymb),"操作符两端的参数不能为空");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
public static void testSymbol(String formula){
Pattern pattern=Pattern.compile(",+?\\s*\\)");
Matcher m=pattern.matcher(formula);
if(m.find()){
int idx=formula.indexOf(m.group());
PatternSyntaxException patternSyntaxException=new PatternSyntaxException("参数格式错误",formula,idx);
throw patternSyntaxException;
}
}
public static void main(String args[]){
checkOperatorNullParam(" abc>=");
}
}

21
src/com/engine/salary/formlua/util/IgnoreFilter.java Normal file
View File

@ -0,0 +1,21 @@
package com.engine.salary.formlua.util;
import java.util.LinkedList;
import java.util.List;
public class IgnoreFilter {
private static List<String> list=new LinkedList<String>();
public static boolean contains(String key){
list.add("formId");
return list.contains(key);
}
public static boolean containsFixedKey(String key){
list.add("operators");
list.add("names");
list.add("createTimes");
list.add("types");
list.add("datastatus");
return list.contains(key);
}
}

769
src/com/engine/salary/formlua/util/IgnoreParamFilter.java Normal file
View File

@ -0,0 +1,769 @@
package com.engine.salary.formlua.util;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.engine.salary.formlua.core.exception.ErrorType;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.formlua.entity.parameter.FormulaContext;
import com.engine.salary.formlua.entity.parameter.FuncNames;
import com.weaver.esb.server.enums.ParamType;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
public class IgnoreParamFilter {
protected static final Logger logger = LoggerFactory.getLogger(IgnoreParamFilter.class);
private static JSONObject errorJson = null;
private static String[] dateFuncs = new String[]{"YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"};
private static String[] numberOperArray = new String[]{">", "<", ">=", "<="};
public static void main(String[] args) throws Exception {
DataType dataType = new DataType();
dataType.setDataType(DataType.NUMBER);
dataType.setContent(0.0);
// DataType dataType2=new DataType();
// dataType2.setDataType(DataType.STRING);
// DataType dataType3=new DataType();
// dataType3.setDataType(DataType.STRING);
filterCompareFunc("", 0.5);
}
/**
* 判断是人员参数
*
* @param object
* @return
*/
public static boolean isEmployee(Object object) {
logger.info("校验人员参数" + JSON.toJSONString(object));
// if (object instanceof DataType) {
// DataType dataType = (DataType) object;
// if (dataType.getComponentKey() != null && dataType.getComponentKey().equalsIgnoreCase(ComponentType.Employee.toString())) {
// return true;
// }
// }
return false;
}
/**
* 通用的校验参数类型一致的方法
*
* @param objects
* @return
*/
public static boolean checkType(Object... objects) {
if (objects == null || objects.length == 0) {
return true;
}
Map<String, Object> typeCheckMap = new HashMap<>();
int i;
for (i = 0; i < objects.length; i++) {
Object obj = objects[i];
if (obj instanceof DataType) {
DataType dataType = (DataType) obj;
if (StringUtils.isNotEmpty(dataType.getDataType())) {
typeCheckMap.put(DataType.returnType(dataType.getDataType()).toLowerCase(), obj);
} else if (StringUtils.isNotEmpty(dataType.getComponentKey())) {
typeCheckMap.put(DataType.returnType(dataType.getComponentKey()).toLowerCase(), obj);
}
} else {
String localtype = obj.getClass().getName();
typeCheckMap.put(DataType.returnType(ExcelParamUtil.getParamType(localtype).toLowerCase()), obj);
}
}
if (typeCheckMap.keySet().size() > 1) {
return false;
} else {
return true;
}
}
/**
* 校验参数是否统一了类型
*
* @param objects
* @return
*/
public static boolean commonCheckParamsType(Object... objects) {
if (objects == null || objects.length == 0) {
return false;
}
String type = null;
String objFunc = objects[objects.length - 1].toString();
for (int i = 0; i < objects.length - 1; i++) {
Object obj = objects[i];
String loopType = ExcelParamUtil.getParamType(obj);
if (type == null) {
type = loopType;
} else {
if (!type.equalsIgnoreCase(loopType)) {
return false;
}
}
}
return true;
}
public static void filterParams(String func, int min, int max, Object... objects) {
Integer number = getSetFuncNumber(func);
if (null == objects) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数参数为空");
throw new RuntimeException(errorJson.getString("msg"));
}
if (objects.length < min) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数至少需要" + min + "个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
if (max > 0 && objects.length > max) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数最多允许" + max + "个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
}
public static void filterDateParamTypes(String func, int funcNumber, Class[] typeClasses, Object... objects) {
Integer number = funcNumber;
if (null == objects || null == typeClasses || objects.length == 0 || typeClasses.length == 0 || objects.length > typeClasses.length) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
}
/**
* 通用验证方法
*
* @param func
* @param min
* @param max
* @param typeClasses
* @param objects
*/
public static void commonFilter(String func, int min, int max, Class[] typeClasses, Object... objects) {
Integer number = getSetFuncNumber(func);
if (null == objects) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数参数为空");
throw new RuntimeException(errorJson.getString("msg"));
}
if (objects.length < min) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数至少需要" + min + "个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
if (max > 0 && objects.length > max) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数最多允许" + max + "个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
if (typeClasses != null && typeClasses.length > 0) {
if (null == objects || objects.length == 0 || typeClasses.length == 0 || objects.length > typeClasses.length) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
for (int i = 0; i < objects.length; i++) {
String fieldType = null;
String paramType = ExcelParamUtil.getParamType(typeClasses[i].getName());
paramType = ExcelParamUtil.checkParamType(paramType);
if (objects[i] instanceof DataType) {
DataType dataType = (DataType) objects[i];
List<String> datafunclist = Arrays.asList(dateFuncs);
if (datafunclist.contains(func)) {
fieldType = dataType.getDataType();
} else {
fieldType = ExcelParamUtil.checkParamType(dataType.getDataType());
}
} else {
fieldType = ExcelParamUtil.getParamType(objects[i].getClass().getName());
fieldType = ExcelParamUtil.checkParamType(fieldType);
}
if (null == fieldType) {
errorJson = ErrorUtil.buildError(func, i + 1, number, func + "函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
boolean compareResult = false;
if (paramType.equals("dateandstring") && (fieldType.toLowerCase().equals("string") || fieldType.toLowerCase().equals("date"))) {
compareResult = true;
} else if (paramType.toLowerCase().equals(fieldType.toLowerCase())) {
compareResult = true;
} else if (ExcelParamUtil.inNumber(paramType) && ExcelParamUtil.inNumber(fieldType)) {
compareResult = true;
} else {
if (!compareResult) {
errorJson = ErrorUtil.buildError(func, (i + 1), number, func + "函数参数类型错误");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
}
}
/**
* 过滤字符串函数参数
*
* @param objects
*/
public static void filterStringConcat(int min, int max, Object... objects) {
Integer number = getSetFuncNumber(FuncNames.CONCAT.toString());
String func = FuncNames.CONCAT.toString();
if (objects.length < min) {
errorJson = ErrorUtil.buildError(func, number, number, "CONCAT函数至少需要" + min + "个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
if (max > 0 && objects.length > max) {
errorJson = ErrorUtil.buildError(func, number, number, "CONCAT函数最多允许" + min + "个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
}
/**
* 过滤聚合函数参数
*
* @param objects
* @throws RuntimeException
*/
public static void filterAggFunc(String func, Object... objects) throws RuntimeException {
logger.info("聚合参数：" + JSON.toJSONString(objects));
Integer number = getSetFuncNumber(func);
Map<String, String> map = new HashMap<>();
boolean mustNumber = false;
if (objects == null) {
errorJson = ErrorUtil.buildError(func, number, number, func + ErrorType.VAR_TYPE_WRONG.name());
throw new RuntimeException(errorJson.getString("msg"));
}
if (objects.length > 2) {
errorJson = ErrorUtil.buildError(func, number, number, func + "函数最多只支持两个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
checkArrayParamNull(func, number, objects);
Object obj = objects[0];
if (func.equals("MAX") || func.equals("MIN") || func.equals("AVG") || func.equals("SUM")) {
mustNumber = true;
}
if (!(obj instanceof DataType)) {
number = getSetFuncNumber(obj.toString());
errorJson = ErrorUtil.buildError(obj.toString(), number, number, func + "函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
String paramType = "";
DataType dataType = (DataType) objects[0];
if (dataType.getFormId() == null && dataType.getFieldId() == null) {
number = getSetFuncNumber(obj.toString());
errorJson = ErrorUtil.buildError(obj.toString(), number, number, func + "函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
//除了
if (mustNumber) {
if (objects[0] instanceof DataType && dataType.getDataType() != null) {
paramType = ExcelParamUtil.checkParamType(dataType.getDataType());
if (paramType != null) {
paramType = ExcelParamUtil.checkParamType(paramType);
}
} else {
errorJson = ErrorUtil.buildError(func, number, number, func + "函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
if (paramType == null || !(paramType.equals(DataType.NUMBER))) {
errorJson = ErrorUtil.buildError(func, number, number, func + "第一个变量必须为数字字段");
throw new RuntimeException(errorJson.getString("msg"));
}
} else {
if (dataType.getFormId() == null) {
errorJson = ErrorUtil.buildError(func, number, number, func + "第一个变量必须为表格");
throw new RuntimeException(errorJson.getString("msg"));
}
}
for (int i = 0; i < objects.length; i++) {
Object param = objects[i];
if (param != null && param instanceof DataType) {
DataType pramDataType = (DataType) param;
if (pramDataType.getSubLogic() != null && pramDataType.getSubLogic().size() > 1) {
throw new RuntimeException(func + "函数的参数不能嵌套使用逻辑函数（AND、OR）");
}
}
}
}
public static void filterInFunc(Object... objects) {
String oper = objects[objects.length - 1].toString();
Integer number = getSetFuncNumber(oper);
List<Object> params = (List<Object>) objects[0];
if (params.size() < 2) {
errorJson = ErrorUtil.buildError(oper, number, number, "IN操作符第二个条件至少需要两个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
String type = null;
for (Object object : params) {
String thisType;
if (object instanceof DataType) {
thisType = ((DataType) object).getDataType();
if (type == null) {
type = thisType;
} else {
if (!thisType.equals(type)) {
errorJson = ErrorUtil.buildError(oper, number, number, "IN操作符参数类型不一致");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
}
}
/***
* 过滤比较操作符的参数类型
* @param objects
*/
public static void filterCompareFunc(Object... objects) throws Exception {
String oper = objects[objects.length - 1].toString();
Integer number = getSetFuncNumber(oper);
String type1 = "";
String type2 = "";
for (int i = 0; i < objects.length; i++) {
Object object = objects[i];
if (object == null) {
throw new RuntimeException("[" + oper + "]" + ErrorType.VAR_NOT_NULL.name());
}
}
if (objects.length < 2) {
throw new RuntimeException("[" + oper + "]" + ErrorType.VAR_NOT_NULL.name());
}
boolean isDate = false;
for (int i = 0; i < objects.length - 1; i++) {
Object object = objects[i];
if (object == null) {
throw new RuntimeException("[" + oper + "]" + ErrorType.VAR_NOT_NULL.name());
}
String typeName = "";
if (object instanceof DataType) {
DataType param = (DataType) object;
typeName = param.getDataType();
if (typeName.equalsIgnoreCase(DataType.FORM)) {
throw new RuntimeException("[" + oper + "]" + ErrorType.CANT_FORM_FIELD.name());
}
if (!typeName.toLowerCase().equals("option")) {
typeName = ExcelParamUtil.checkParamType(typeName.toLowerCase());
}
if (typeName.toLowerCase().equals(DataType.DATE.toLowerCase())) {
typeName = DataType.STRING;
isDate = true;
}
} else {
//校验比较操作符中的数组是不是为空
if (object instanceof Object[]) {
Object[] arrayP = (Object[]) object;
if (arrayP.length == 0) {
throw new RuntimeException("[" + oper + "]" + ErrorType.VAR_NOT_NULL.name());
}
if (arrayP[0] instanceof DataType) {
DataType arrayParamOne = (DataType) arrayP[0];
typeName = arrayParamOne.getDataType();
} else {
typeName = ExcelParamUtil.getParamType(arrayP[0].getClass().getName());
}
} else {
typeName = ExcelParamUtil.getParamType(object.getClass().getName());
}
if (!typeName.equalsIgnoreCase("option")) {
typeName = ExcelParamUtil.checkParamType(typeName);
}
}
//判断非等于和不等于操作符的两端参数是否为数字，不是数字返回错误
if (!isDate && !oper.equals("=") && !oper.equals("!=") && (typeName.toLowerCase().equals(DataType.OPTION))) {
errorJson = ErrorUtil.buildError(oper, 1, number, "比较操作符'" + oper + "'不支持选项类型的运算");
throw new RuntimeException(errorJson.getString("msg"));
}
if (i == 0) {
type1 = typeName;
} else {
type2 = typeName;
}
}
List<String> operList = Arrays.asList(numberOperArray);
if (operList.contains(oper) && (type1.equalsIgnoreCase("string") || type2.equalsIgnoreCase("string"))) {
String msg = "[" + oper + "]操作符不允许非数字类型参数";
throw new RuntimeException(msg);
}
if (!IgnoreParamFilter.checkType(objects[0], objects[1])) {
errorJson = ErrorUtil.buildError(oper, 1, number, "比较操作符参数类型不一致");
throw new RuntimeException(errorJson.getString("msg"));
}
if (objects[0] instanceof Object[]) {
errorJson = ErrorUtil.buildError(oper, 1, number, "比较操作符不支持数组参数");
throw new RuntimeException(errorJson.getString("msg"));
}
}
/**
* 过滤日期函数参数
*
* @param objects
* @throws Exception
*/
public static void filterDateFunc(Object... objects) throws Exception {
Integer number = getSetFuncNumber("");
boolean isWrong = false;
if (objects.length < 2) {
errorJson = ErrorUtil.buildError("Date", 0, number, "日期函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
int idx = 1;
for (Object object : objects) {
if (!(object instanceof String) && !(object instanceof Date) && !(object instanceof DataType)) {
isWrong = true;
break;
} else if (object instanceof DataType) {
Object content;
DataType dataType = (DataType) object;
content = dataType.getContent();
if (!(content instanceof String) && !(content instanceof Date) && !(content instanceof DataType)) {
isWrong = true;
break;
}
}
idx++;
}
if (isWrong) {
errorJson = ErrorUtil.buildDataError("Date", idx, objects, "日期函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
}
/**
* 逻辑函数过滤器
*
* @param objects
*/
public static void filterLogicAndORFunc(Object... objects) {
String method = objects[objects.length - 1].toString();
FormulaContext.get().setValue(method);
Object[] paramArray = (Object[]) objects[0];
Integer number = getSetFuncNumber(method);
if (null == paramArray || paramArray.length == 0) {
errorJson = ErrorUtil.buildError(method, 0, number, method + "函数参数不能为空");
throw new RuntimeException(errorJson.getString("msg"));
}
for (int i = 0; i < paramArray.length; i++) {
String fieldType = null;
if (paramArray[i] instanceof DataType) {
DataType dataType = (DataType) paramArray[i];
fieldType = dataType.getDataType();
} else {
fieldType = ExcelParamUtil.getParamType(paramArray[i].getClass().getName());
}
fieldType = ExcelParamUtil.checkParamType(fieldType);
if (!fieldType.equalsIgnoreCase(ParamType.BOOLEAN.getValue())) {
errorJson = ErrorUtil.buildError(method, (i + 1), number, method + "函数第" + (i + 1) + "个条件必须为真假值");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
/**
* 判断IF函数的参数合法性
*
* @param objects
*/
public static void filterIfFunc(Object... objects) {
Integer number = getSetFuncNumber("IF");
String cndType = "";
if (objects[0] instanceof DataType) {
DataType dataType = (DataType) objects[0];
cndType = dataType.getDataType();
} else {
cndType = ExcelParamUtil.getParamType(objects[0].getClass().getName());
}
cndType = ExcelParamUtil.checkParamType(cndType);
if (null == cndType || !cndType.equals(ParamType.BOOLEAN.getValue())) {
errorJson = ErrorUtil.buildError("If", 0, number, "IF函数条件应为真假值类型");
throw new RuntimeException(errorJson.getString("msg"));
}
String pType1 = "";
String pType2 = "";
if (objects[1] instanceof DataType) {
DataType dataType = (DataType) objects[1];
pType1 = dataType.getDataType();
} else {
pType1 = ExcelParamUtil.getParamType(objects[1].getClass().getName());
}
pType1 = ExcelParamUtil.checkParamType(pType1);
if (objects[2] instanceof DataType) {
DataType dataType = (DataType) objects[2];
pType2 = dataType.getDataType();
} else {
pType2 = ExcelParamUtil.getParamType(objects[2].getClass().getName());
}
pType2 = ExcelParamUtil.checkParamType(pType2);
if (!pType1.equals(pType2)) {
errorJson = ErrorUtil.buildError("If", 0, number, "IF函数表达式返回值不一致");
throw new RuntimeException(errorJson.getString("msg"));
}
}
public static void filterLikeFunc(Object... objects) {
Integer number = getSetFuncNumber("LIKE");
String sourceTxt = "";
List<Object> params = new ArrayList<Object>() {
};
if (objects.length < 2) {
errorJson = ErrorUtil.buildError("LIKE", 0, number, "LIKE函数至少需要两个参数");
throw new RuntimeException(errorJson.getString("msg"));
} else if (objects.length > 2) {
errorJson = ErrorUtil.buildError("LIKE", 0, number, "LIKE函数最多支持两个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
for (Object obj : objects) {
if (obj.getClass().isArray()) {
Object[] subArray = (Object[]) obj;
for (int i = 0; i < subArray.length; i++) {
params.add(subArray[i]);
}
} else {
params.add(obj);
}
}
Object object = params.get(0);
if (object instanceof DataType) {
DataType dataType = (DataType) object;
sourceTxt = dataType.getDataType();
} else {
sourceTxt = ExcelParamUtil.getParamType(object.getClass().getName());
}
sourceTxt = ExcelParamUtil.checkParamType(sourceTxt);
if (null == sourceTxt || !sourceTxt.toLowerCase().equals(ParamType.STRING.getValue().toLowerCase())) {
String key = ExcelParamUtil.getKeyString(object);
number = getSetFuncNumber(key);
errorJson = ErrorUtil.buildError(key, 0, number, "LIKE函数第1个参数应该为文本类型");
throw new RuntimeException(errorJson.getString("msg"));
}
for (int i = 0; i < params.size(); i++) {
Object txtObj = params.get(i);
if (null == txtObj) {
errorJson = ErrorUtil.buildError("LIKE", (i + 1), number, "LIKE函数条件错误");
throw new RuntimeException(errorJson.getString("msg"));
}
String txt = "";
if (txtObj instanceof DataType) {
DataType dataType = (DataType) txtObj;
txt = dataType.getDataType();
} else {
txt = ExcelParamUtil.getParamType(txtObj.getClass().getName());
}
txt = ExcelParamUtil.checkParamType(txt);
if (!txt.toLowerCase().equals(ExcelParamUtil.getParamType(ParamType.STRING.getValue().toLowerCase()))) {
errorJson = ErrorUtil.buildError("LIKE", (i + 1), number, "LIKE函数条件数组第" + (i + 1) + "个参数应该为文本类型");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
public static int getSetFuncNumber(String func) {
Integer number = 0;
FormulaContext.get().getValue(func);
if (number == null || number == 0) {
FormulaContext.get().setValue(func);
number = FormulaContext.get().getValue(func);
} else {
FormulaContext.get().setValue(func);
number = FormulaContext.get().getValue(func);
}
return number;
}
public static void checkArrayParamNull(String func, int number, Object[] objects) {
for (Object object : objects) {
if (object == null) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数条件存在未知参数");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
/**
* 校验数学加减乘除运算符号
*
* @param objects
* @param oper
*/
public static void checkNumberOper(Object[] objects, String oper) {
Integer number = getSetFuncNumber("");
if (objects.length != 2) {
errorJson = ErrorUtil.buildError(oper, 1, number, "操作符只支持数字类型的运算");
throw new RuntimeException(errorJson.getString("msg"));
}
String type1 = "";
String type2 = "";
for (int i = 0; i < objects.length; i++) {
Object object = objects[i];
if (object == null) {
errorJson = ErrorUtil.buildError(oper, 1, number, "[" + oper + "]" + "操作符参数不能为空");
throw new RuntimeException(errorJson.getString("msg"));
}
String typeName = "";
if (object instanceof DataType) {
DataType param = (DataType) object;
if (param.getContent() == null) {
param.setContent(0);//没有值时给0，保存函数运算结果
}
if (param.getName() != null && param.getName().equals("当前表格")) {
errorJson = ErrorUtil.buildError(oper, 1, number, "[" + oper + "]" + "操作符参数不能为空");
throw new RuntimeException(errorJson.getString("msg"));
}
typeName = param.getDataType();
if (!typeName.toLowerCase().equals("option")) {
typeName = ExcelParamUtil.checkParamType(typeName.toLowerCase());
}
if (typeName.toLowerCase().equals(DataType.DATE.toLowerCase())) {
typeName = DataType.STRING;
}
} else if (object instanceof Date) {
typeName = "string";
//当参数为数组时
} else if (object instanceof Object[]) {
Object[] objArray = (Object[]) object;
String arrayType = null;
for (Object obj : objArray) {
String localType = null;
if (obj instanceof DataType) {
localType = ExcelParamUtil.getParamType(obj);
localType = ExcelParamUtil.checkParamType(localType);
} else {
localType = ExcelParamUtil.getParamType(obj.getClass().getName()).toLowerCase();
localType = ExcelParamUtil.checkParamType(localType);
}
if (arrayType == null) {
arrayType = localType;
} else {
if (!arrayType.equals(localType)) {
errorJson = ErrorUtil.buildError(oper, 1, number, "操作符参数类型不一致");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
typeName = arrayType;
} else {
typeName = ExcelParamUtil.getParamType(object.getClass().getName());
typeName = ExcelParamUtil.checkParamType(typeName);
}
//判断非等于和不等于操作符的两端参数是否为数字，不是数字返回错误
if (!typeName.toLowerCase().equals(DataType.NUMBER)) {
errorJson = ErrorUtil.buildError(oper, 1, number, "操作符只支持数字类型的运算");
throw new RuntimeException(errorJson.getString("msg"));
}
if (i == 0) {
type1 = typeName;
} else {
type2 = typeName;
}
}
if (!type1.toLowerCase().equals(type2.toLowerCase()) || type1.equals("") || type2.equals("")) {
errorJson = ErrorUtil.buildError(oper, 1, number, "操作符参数类型不一致");
throw new RuntimeException(errorJson.getString("msg"));
}
}
/**
* 校验分数取值函数
*
* @param func
* @param objects
*/
public static void checkFraction(String func, Object... objects) {
Integer number = getSetFuncNumber(func);
if (objects == null || objects.length == 0) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数参数为空");
throw new RuntimeException(errorJson.getString("msg"));
}
if (objects.length > 1) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数参数错误");
throw new RuntimeException(errorJson.getString("msg"));
}
Object object = objects[0];
if (object instanceof DataType) {
DataType dataType = (DataType) object;
if (null == dataType.getScore()) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数参数类型错误");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
public static void checkValiIdCard(String func, Object... objects) {
Integer number = getSetFuncNumber(func);
if (objects == null || objects.length == 0) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数参数为空");
throw new RuntimeException(errorJson.getString("msg"));
}
if (objects.length != 2) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数只允许两个参数");
throw new RuntimeException(errorJson.getString("msg"));
}
if (objects[0] instanceof DataType) {
DataType dataType = (DataType) objects[0];
if (dataType.getDataType().equalsIgnoreCase(DataType.OPTION) || dataType.getDataType().equalsIgnoreCase(DataType.DATE)) {
errorJson = ErrorUtil.buildError(func, 0, number, func + "函数只允许操作数字或字符");
throw new RuntimeException(errorJson.getString("msg"));
}
}
}
/**
* 校验参数类型
*
* @param paramArray
* @param exclDataTypeList
* @return
*/
public static List checkParamType(Object[] paramArray, List<String> exclDataTypeList) {
List<Integer> errorIdxList = new ArrayList();
if (paramArray != null && paramArray.length != 0) {
for (int i = 0; i < paramArray.length; i++) {
Object object = paramArray[i];
if (object instanceof DataType) {
DataType paramDataType = (DataType) object;
if (paramDataType.getDataType() != null && !paramDataType.getDataType().equalsIgnoreCase(exclDataTypeList.get(i))) {
errorIdxList.add(i);
return errorIdxList;
}
} else {
String typeString = ExcelParamUtil.getParamType(object.getClass().getName());
typeString = DataType.returnType(typeString);
if (!typeString.equalsIgnoreCase(exclDataTypeList.get(0))) {
errorIdxList.add(i);
return errorIdxList;
}
}
}
}
return errorIdxList;
}
}

7162
src/com/engine/salary/formlua/util/NativePlace.java Normal file
View File

File diff suppressed because it is too large Load Diff

241
src/com/engine/salary/formlua/util/RegularUtil.java Normal file
View File

@ -0,0 +1,241 @@
package com.engine.salary.formlua.util;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @className：
* @Description：正则表达式工具
* @Author：
* @date：
*/
public class RegularUtil {
public static void validateIDCard(String idCard){
Pattern pattern = Pattern.compile("^[1-9]\\d{5}(18|19|([23]\\d))\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$");
Matcher matcher = pattern.matcher(idCard);
if (!matcher.matches()) {
throw new RuntimeException("身份证号码不合法");
}
}
public static void checkAggCnd(String formula){
String startPartternStr="^(OR\\(|AND\\()";
Pattern startPattern = Pattern.compile(startPartternStr);
Matcher startMatcher = startPattern.matcher(formula);
if(!startMatcher.find()){
throw new RuntimeException("条件筛选函数只允许AND函数与OR函数");
}
// else {
// String partternStr="(AND|OR)+\\(+(.)+\\)+";
// Pattern pattern = Pattern.compile(partternStr);
// Matcher matcher = pattern.matcher(formula);
// while (matcher.find()){
// String fr=matcher.group();
// logger.info(fr);
// fr=fr.replaceAll("(AND|OR)","");
// String partternStr2="(.)+\\(+(.)+\\)+";
// Pattern pattern2 = Pattern.compile(partternStr2);
// Matcher matcher2 = pattern2.matcher(fr);
// if(matcher2.find()){
// throw new RuntimeException("条件筛选参数不正确");
// }
// }
// }
}
public static boolean isNumber(Object obj) {
if(obj==null){
return false;
}
String nstr=obj.toString();
String reg = "\\d+(\\.\\d+)?";
if(nstr.startsWith("-")){
nstr=nstr.substring(1);
}
Boolean strResult = nstr.matches(reg);
return strResult;
}
/**
* 判断是否是0或正整数
* @param obj
* @return
*/
public static boolean isNonNegativeInteger(Object obj) {
if(obj == null) return false;
String nstr = obj.toString();
String reg = "^[1-9]\\d*|0$";
return nstr.matches(reg);
}
/**
* 是否是整数，正整数、0、负整数
* @param obj
* @return
*/
public static boolean isInteger(Object obj){
if(obj == null) return false;
String nstr = obj.toString();
String reg = "^-?[1-9]\\d*$";
return nstr.matches(reg);
}
/**
* IF函数的规则判断
* @param str
* @return
*/
public static Map<String,Object> checkIfFunc(String str){
Map<String,Object> rmap=new HashMap<String,Object>();
str=str.trim().replaceAll(" ","");
boolean r=true;
String patt="if{1}\\({1}\\w+[<|>|!=｜==]+\\w+\\){1}[\\w\\{\\}]*";
String charCheckIf="if{1}";
String charCheckLf="if{1}\\({1}";
String charCheckRf="\\){1}";
String paramLeft="\\({1}\\w+[<|>|!=]+";
String paramRight="[<|>|!=]+\\w+\\){1}";
String paramOperSym="[<|>|!=]+";
Pattern rPattern = Pattern.compile(patt);
Pattern ifPattern=Pattern.compile(charCheckIf);
Pattern leftPattern=Pattern.compile(charCheckLf);
Pattern rightPattern=Pattern.compile(charCheckRf);
Pattern leftParamPatt=Pattern.compile(paramLeft);
Pattern rightParamPatt = Pattern.compile(paramRight);
Pattern operSybmPattern=Pattern.compile(paramOperSym);
//先测试整条语句是否符合规则
boolean pOneResult=rPattern.matcher(str).find();
if(!pOneResult){
//以下为逐一排查问题的位置
boolean pIfResult =ifPattern.matcher(str).find();
boolean leftResult=leftPattern.matcher(str).find();
boolean rightResult=rightPattern.matcher(str).find();
boolean lpResult=leftParamPatt.matcher(str).find();
boolean rpResult=rightParamPatt.matcher(str).find();
boolean operSybmResult=operSybmPattern.matcher(str).find();
r=false;
rmap.put("result",r);
if(!pIfResult){
rmap.put("info","格式不正确缺少if标识符");
}else if(!leftResult){
rmap.put("info","格式不正确缺少左括号(标识符");
}else if(!rightResult){
rmap.put("info","格式不正确缺少右括号)标识符");
}else if(!lpResult){
rmap.put("info","格式不正确缺少左侧参数");
}else if(!rpResult){
rmap.put("info","格式不正确缺少右侧参数");
}else if(!operSybmResult){
rmap.put("info","格式不正确缺少操作符");
}else{
rmap.put("info","格式未通过格式验证");
}
}
return rmap;
}
/**
* 判断是否含有字母
* @param str
* @return
*/
public static boolean containsLetter(String str) {
String patt="[a-z|A-Z]";
Pattern r = Pattern.compile(patt);
Matcher matcher = r.matcher(str);
return matcher.find();
}
/**
* 判断是否含有数字
* @param str
* @return
*/
public static boolean containsNum(String str) {
String patt="[0-9]";
Pattern r = Pattern.compile(patt);
Matcher matcher = r.matcher(str);
return matcher.find();
}
/**
* 判断是否含有非字母
* @param str
* @return
*/
public static boolean containsNotLetter(String str) {
String patt="[^a-z|^A-Z]";
Pattern r = Pattern.compile(patt);
Matcher matcher = r.matcher(str);
return matcher.find();
}
/**
* 判断是否包含非数字
* @param str
* @return
*/
public static boolean containsNotNum(String str){
String patt="[^0-9]";
Pattern r = Pattern.compile(patt);
Matcher matcher = r.matcher(str);
return matcher.find();
}
/**
* 替换非字母
* @param str
* @return
*/
public static String containsNotLetterR(String str,String replaceStr) {
String patt="[^a-z|^A-Z]";
Pattern r = Pattern.compile(patt);
Matcher matcher = r.matcher(str);
return matcher.replaceAll(replaceStr);
}
/**
* 替换非数字
* @param str
* @param replaceStr
* @return
*/
public static String containsNotNumR(String str,String replaceStr){
String patt="[^0-9]";
Pattern r = Pattern.compile(patt);
Matcher matcher = r.matcher(str);
return matcher.replaceAll(replaceStr);
}
/**
* 判断是否含有字母并替换
* @param str
* @param replaceStr
* @return
*/
public static String containsLetterR(String str,String replaceStr) {
String patt="[a-z|A-Z]";
Pattern r = Pattern.compile(patt);
Matcher matcher = r.matcher(str);
str=matcher.replaceAll(replaceStr);
return str;
}
/**
* 判断是否含有数字并替换
* @param str
* @param replaceStr
* @return
*/
public static String containsNumR(String str,String replaceStr) {
String patt="[0-9]";
Pattern r = Pattern.compile(patt);
Matcher matcher = r.matcher(str);
return matcher.replaceAll(replaceStr);
}
}

49
src/com/engine/salary/formlua/util/SortUtil.java Normal file
View File

@ -0,0 +1,49 @@
package com.engine.salary.formlua.util;
public class SortUtil {
/**
* 数组快速排序
* @param array
* @param left
* @param right
*/
public static void sort(int[] array, int left, int right){
if(left > right) {
return;
}
// base中存放基准数
int base = array[left];
int i = left, j = right;
while(i != j) {
// 顺序很重要，先从右边开始往左找，直到找到比base值小的数
while(array[j] >= base && i < j) {
j--;
}
// 再从左往右边找，直到找到比base值大的数
while(array[i] <= base && i < j) {
i++;
}
// 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
if(i < j) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
// 将基准数放到中间的位置（基准数归位）
array[left] = array[i];
array[i] = base;
// 递归，继续向基准的左右两边执行和上面同样的操作
// i的索引处为上面已确定好的基准值的位置，无需再处理
sort(array, left, i - 1);
sort(array, i + 1, right);
}
}

8
src/com/engine/salary/formlua/util/standard/ExcelDataType.java Normal file
View File

@ -0,0 +1,8 @@
package com.engine.salary.formlua.util.standard;
public enum ExcelDataType {
string("字符类型"),number("数字类型"),date("日期类型"),option("选项类型"),form("表格类型"),dataSource("数据源类型");
ExcelDataType(String name) {
}
}

2
src/com/engine/salary/remote/attend/cmd/GetKQReportCmd.java
View File

@ -280,7 +280,7 @@ public class GetKQReportCmd extends AbstractCommonCommand<Map<String, Object>> {
// }
// }
// } else {
sql = " select " + sql;
sql = " select " + sql;
// }
Map<String,Object> flowData = kqReportBiz.getFlowData(params,user);
rs.execute(sql);

14
src/com/engine/salary/service/RemoteExcelService.java
View File

@ -8,9 +8,9 @@ import java.util.List;
import java.util.Map;
public interface RemoteExcelService {
// ExcelResult aggregation(AggFunc func, String sourceId, String fieldId, List<FormulaFilterData> filterFormDataList, Map<String, Object> extendParam, SimpleEmployee employee);
// ExcelResult aggregation(AggFunc func, String sourceId, String fieldId, List<FormulaFilterData> filterFormDataList, Map<String, Object> extendParam, DataCollectionEmployee employee);
//
// ExcelPage<FormulaCategory> categoryList(ExcelPage<FormulaCategory> page, Map<String, Object> extendParam, SimpleEmployee employee);
// ExcelPage<FormulaCategory> categoryList(ExcelPage<FormulaCategory> page, Map<String, Object> extendParam, DataCollectionEmployee employee);
List<FormulaVar> fieldList(String sourceId, Map<String, Object> extendParam);
@ -19,13 +19,13 @@ public interface RemoteExcelService {
Map<String,List<FormulaVar>> allFieldList(ReferenceTypeEnum referenceTypeEnum);
// ExcelPage<FormulaDataSource> dataSourceList(String categoryId, ExcelPage<FormulaDataSource> page, Map<String, Object> extendParam, SimpleEmployee employee);
// ExcelPage<FormulaDataSource> dataSourceList(String categoryId, ExcelPage<FormulaDataSource> page, Map<String, Object> extendParam, DataCollectionEmployee employee);
//
// List<FormulaVar> findProperData(String dataId, String fieldId, String fieldType, Map<String, Object> extendParam, SimpleEmployee employee);
// List<FormulaVar> findProperData(String dataId, String fieldId, String fieldType, Map<String, Object> extendParam, DataCollectionEmployee employee);
//
// List<DataType> choose(String sourceId, List<FormulaFilterData> filterFormDataList, Map<String, Object> extendParam, SimpleEmployee employee);
// List<DataType> choose(String sourceId, List<FormulaFilterData> filterFormDataList, Map<String, Object> extendParam, DataCollectionEmployee employee);
//
// List<DataType> vlookups(String sourceId, List<FormulaFilterData> filterFormDataList, List<String> returnFields, Map<String, Object> extendParam, SimpleEmployee employee);
// List<DataType> vlookups(String sourceId, List<FormulaFilterData> filterFormDataList, List<String> returnFields, Map<String, Object> extendParam, DataCollectionEmployee employee);
//
// Map<String, SimpleExcelEntity> findSourceName(String Module, List<String> idList, Map<String, Object> extendParam, SimpleEmployee employee);
// Map<String, SimpleExcelEntity> findSourceName(String Module, List<String> idList, Map<String, Object> extendParam, DataCollectionEmployee employee);
}

2
src/com/engine/salary/service/impl/AddUpDeductionServiceImpl.java
View File

@ -161,7 +161,7 @@ public class AddUpDeductionServiceImpl extends Service implements AddUpDeduction
//日期范围选项
// List<SearchConditionOption> dateOptions = new ArrayList<SearchConditionOption>();
// dateOptions.add(new SearchConditionOption("6", SystemEnv.getHtmlLabelName(32530, user.getLanguage()), true));//指定日期范围(必须为6)
// dateOptions.add(new SearchConditionOption("6", SalaryI18nUtil.getI18nLabel(32530, user.getLanguage()), true));//指定日期范围(必须为6)
// SearchConditionItem hiredate = conditionFactory.createCondition(ConditionType.RANGEPICKER, 18648, new String[]{"hiredate", "hiredate"});
// hiredate.setInputType("rangepicker");
// hiredate.setFormat("yyyy-MM-dd");

2
src/com/engine/salary/service/impl/AddUpSituationServiceImpl.java
View File

@ -144,7 +144,7 @@ public class AddUpSituationServiceImpl extends Service implements AddUpSituation
//
// //日期范围选项
// List<SearchConditionOption> dateOptions = new ArrayList<SearchConditionOption>();
// dateOptions.add(new SearchConditionOption("6", SystemEnv.getHtmlLabelName(32530, user.getLanguage()), true));//指定日期范围(必须为6)
// dateOptions.add(new SearchConditionOption("6", SalaryI18nUtil.getI18nLabel(32530, user.getLanguage()), true));//指定日期范围(必须为6)
// SearchConditionItem hiredate = conditionFactory.createCondition(ConditionType.RANGEPICKER, 18648, new String[]{"hiredate", "hiredate"});
// hiredate.setInputType("rangepicker");
// hiredate.setFormat("yyyy-MM-dd");

69
src/com/engine/salary/service/impl/FormulaRunServiceImpl.java
View File

@ -1,11 +1,13 @@
package com.engine.salary.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.engine.core.impl.Service;
import com.engine.salary.encrypt.AESEncryptUtil;
import com.engine.salary.entity.datacollection.DataCollectionEmployee;
import com.engine.salary.entity.salaryformula.ExpressFormula;
import com.engine.salary.entity.salaryformula.po.FormulaVar;
import com.engine.salary.enums.salaryformula.ReferenceTypeEnum;
import com.engine.salary.formlua.core.QlExpress;
import com.engine.salary.formlua.entity.parameter.DataType;
import com.engine.salary.service.FormulaRunService;
import com.engine.salary.sys.enums.OpenEnum;
@ -22,7 +24,9 @@ import weaver.conn.RecordSetDataSource;
import weaver.general.BaseBean;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Slf4j
public class FormulaRunServiceImpl extends Service implements FormulaRunService {
@ -35,6 +39,8 @@ public class FormulaRunServiceImpl extends Service implements FormulaRunService
private final Boolean isLog = "true".equals(baseBean.getPropValue("hrmSalary", "log"));
QlExpress express = new QlExpress();
@Override
public Object run(ExpressFormula expressFormula, List<FormulaVar> formulaVars, DataCollectionEmployee simpleEmployee) throws Exception {
@ -96,7 +102,7 @@ public class FormulaRunServiceImpl extends Service implements FormulaRunService
//外部数据源
if (StringUtils.isNotBlank(datasourceId)) {
RecordSetDataSource rs = new RecordSetDataSource(datasourceId);
log.error("执行外部sql,{},datasourceId{}", sql,datasourceId);
log.error("执行外部sql,{},datasourceId{}", sql, datasourceId);
if (rs.executeSql(sql)) {
if (rs.next()) {
result = rs.getString(sqlReturnKey);
@ -118,21 +124,58 @@ public class FormulaRunServiceImpl extends Service implements FormulaRunService
}
private Object runFormula(ExpressFormula expressFormula, List<FormulaVar> formulaVars) throws Exception {
//是否是自定义函数
boolean isCustomFunction = true;
String extendParam = expressFormula.getExtendParam();
try {
JsonNode jsonNode = objectMapper.readTree(extendParam);
//返回值配置
JsonNode isCustomFunctionNode = jsonNode.get("isCustomFunction");
if (isCustomFunctionNode != null) {
isCustomFunction = StringUtils.equals(isCustomFunctionNode.asText().trim(), "1");
}
} catch (JsonProcessingException e) {
log.error("express execute fail, sql extendParam parse fail", e);
}
if (isLog) {
log.info("FORMULA ExpressFormula {} {}", expressFormula.getFormula(), expressFormula.getFormulaRunScript());
}
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
formulaVars.forEach(v -> {
if (isLog) {
log.info("FORMULA formulaVar {} - {}", v.getFieldId(), v.getContent());
}
if (DataType.NUMBER.equals(v.getFieldType()) && NumberUtils.isCreatable(v.getContent())) {
context.put(v.getFieldId(), new BigDecimal(v.getContent()));
} else {
context.put(v.getFieldId(), v.getContent());
}
});
String formula = expressFormula.getFormulaRunScript();
return runner.execute(formula, context, null, true, false);
if(isCustomFunction){
DefaultContext<String, Object> context = new DefaultContext<String, Object>();
formulaVars.forEach(v -> {
if (isLog) {
log.info("FORMULA formulaVar {} - {}", v.getFieldId(), v.getContent());
}
if (DataType.NUMBER.equals(v.getFieldType()) && NumberUtils.isCreatable(v.getContent())) {
context.put(v.getFieldId(), new BigDecimal(v.getContent()));
} else {
context.put(v.getFieldId(), v.getContent());
}
});
return runner.execute(formula, context, null, true, false);
}else{
Map<String, Object> context = new HashMap<>();
formulaVars.forEach(v -> {
if (isLog) {
log.info("FORMULA formulaVar {} - {}", v.getFieldId(), v.getContent());
}
if (DataType.NUMBER.equals(v.getFieldType()) && NumberUtils.isCreatable(v.getContent())) {
context.put(v.getFieldId(), new BigDecimal(v.getContent()));
} else {
context.put(v.getFieldId(), v.getContent());
}
});
Object execute = express.execute(formula, context);
if(execute instanceof JSONObject){
return ((JSONObject) execute).get("data");
}
return execute;
}
}
}

26
src/com/engine/salary/service/impl/RemoteExcelServiceImpl.java
View File

@ -79,12 +79,12 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
// @Override
// public ExcelResult aggregation(AggFunc func, String sourceId, String fieldId, List<FormulaFilterData> filterFormDataList, Map<String, Object> extendParam,
// SimpleEmployee employee) {
// DataCollectionEmployee employee) {
// return null;
// }
// @Override
// public ExcelPage<FormulaCategory> categoryList(ExcelPage<FormulaCategory> page, Map<String, Object> extendParam, SimpleEmployee employee) {
// public ExcelPage<FormulaCategory> categoryList(ExcelPage<FormulaCategory> page, Map<String, Object> extendParam, DataCollectionEmployee employee) {
// log.info("page: {}", JsonUtil.toJsonString(page));
// List<FormulaCategory> categories = Lists.newArrayList();
// FormulaCategory category = new FormulaCategory();
@ -157,6 +157,12 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
case ATTEND:
vars = attendData2FormulaVar(referenceEnum);
break;
case SALARY_ACCT_EMPLOYEE:
vars = convert2FormulaVar(SalaryAcctEmployeePO.class, referenceEnum.getValue() + "");
break;
case SALARY_CYCLE:
vars = convert2FormulaVar(SalarySobCycleDTO.class, referenceEnum.getValue() + "");
break;
default:
break;
}
@ -236,13 +242,17 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
welfare2FormulaVar(SalaryFormulaReferenceEnum.WELFARE));
result.put(SalaryFormulaReferenceEnum.ATTEND.getDefaultLabel(),
attendData2FormulaVar(SalaryFormulaReferenceEnum.ATTEND));
result.put(SalarySQLReferenceEnum.SALARY_ACCT_EMPLOYEE.getDefaultLabel(),
convert2FormulaVar(SalaryAcctEmployeePO.class, SalarySQLReferenceEnum.SALARY_ACCT_EMPLOYEE.getValue() + ""));
result.put(SalarySQLReferenceEnum.SALARY_CYCLE.getDefaultLabel(),
convert2FormulaVar(SalarySobCycleDTO.class, SalarySQLReferenceEnum.SALARY_CYCLE.getValue() + ""));
return result;
}
return result;
}
// @Override
// public ExcelPage<FormulaDataSource> dataSourceList(String categoryId, ExcelPage<FormulaDataSource> page, Map<String, Object> extendParam, SimpleEmployee employee) {
// public ExcelPage<FormulaDataSource> dataSourceList(String categoryId, ExcelPage<FormulaDataSource> page, Map<String, Object> extendParam, DataCollectionEmployee employee) {
// log.info("categoryId: {}, page: {}", categoryId, JsonUtil.toJsonString(page));
// if (StringUtils.equals("TAX_RATE", categoryId)) {
// taxRate2FormulaDataSource(page, employee.getTenantKey());
@ -252,18 +262,18 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
// }
//
// @Override
// public List<FormulaVar> findProperData(String dataId, String fieldId, String fieldType, Map<String, Object> extendParam, SimpleEmployee employee) {
// public List<FormulaVar> findProperData(String dataId, String fieldId, String fieldType, Map<String, Object> extendParam, DataCollectionEmployee employee) {
// return null;
// }
//
// @Override
// public List<DataType> choose(String sourceId, List<FormulaFilterData> filterFormDataList, Map<String, Object> extendParam, SimpleEmployee employee) {
// public List<DataType> choose(String sourceId, List<FormulaFilterData> filterFormDataList, Map<String, Object> extendParam, DataCollectionEmployee employee) {
// return null;
// }
//
//// @Override
// public List<DataType> vlookups(String sourceId, List<FormulaFilterData> filterFormDataList, List<String> returnFields, Map<String, Object> extendParam,
// SimpleEmployee employee) {
// DataCollectionEmployee employee) {
// log.info("sourceId: {}, filterFormDataList: {}, returnFields: {}", sourceId, JsonUtil.toJsonString(filterFormDataList), JsonUtil.toJsonString(returnFields));
// Map<String, String> columnMap = Maps.newHashMap();
// for (Field declaredField : SalaryFormulaTaxRateDTO.class.getDeclaredFields()) {
@ -298,12 +308,12 @@ public class RemoteExcelServiceImpl extends Service implements RemoteExcelServic
// }
//
// @Override
// public Map<String, SimpleExcelEntity> findSourceName(String Module, List<String> idList, Map<String, Object> extendParam, SimpleEmployee employee) {
// public Map<String, SimpleExcelEntity> findSourceName(String Module, List<String> idList, Map<String, Object> extendParam, DataCollectionEmployee employee) {
// return null;
// }
//
//// @Override
//// public List<DataType> getFieldData(String dataId, List<String> fieldIds, SimpleEmployee employee) {
//// public List<DataType> getFieldData(String dataId, List<String> fieldIds, DataCollectionEmployee employee) {
//// return null;
//// }
//

4
src/com/engine/salary/service/impl/SalaryAcctExcelServiceImpl.java
View File

@ -1129,8 +1129,8 @@ public class SalaryAcctExcelServiceImpl extends Service implements SalaryAcctExc
// return excelSheetData;
// }
// List<Long> employeeIds = SalaryEntityUtil.properties(salaryCheckResultRecords, SalaryCheckResultRecordPO::getEmployeeId, Collectors.toList());
// List<SimpleEmployee> simpleEmployees = hrmCommonEmployeeService.getEmployeeByIds(employeeIds);
// Map<Long, String> simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, SimpleEmployee::getEmployeeId, SimpleEmployee::getUsername);
// List<DataCollectionEmployee> simpleEmployees = hrmCommonEmployeeService.getEmployeeByIds(employeeIds);
// Map<Long, String> simpleEmployeeMap = SalaryEntityUtil.convert2Map(simpleEmployees, DataCollectionEmployee::getEmployeeId, DataCollectionEmployee::getUsername);
// List<ExpressFormula> expressFormulas = getSalaryFormulaService(user).listExpressFormula(Collections.singleton(checkResult.getFormulaId()));
// Map<Long, String> formulaMap = SalaryEntityUtil.convert2Map(expressFormulas, ExpressFormula::getId, ExpressFormula::getFormula);
// for (SalaryCheckResultRecordPO salaryCheckResultRecord : salaryCheckResultRecords) {

36
src/com/engine/salary/service/impl/SalaryFormulaServiceImpl.java
View File

@ -325,21 +325,21 @@ public class SalaryFormulaServiceImpl extends Service implements SalaryFormulaSe
}
//验证公式是否可运行
if (ReferenceTypeEnum.parseByValue(param.getReferenceType()) == ReferenceTypeEnum.FORMULA) {
ExpressFormula test = ExpressFormula.builder().formulaRunScript(formulaRunScript).extendParam(param.getExtendParam()).referenceType(param.getReferenceType()).build();
Object run = null;
try {
run = getFormulaRunService(user).run(test, parameters, DataCollectionEmployee.builder().employeeId((long) user.getUID()).build());
} catch (Exception e) {
log.error("express execute fail ", e);
throw new SalaryRunTimeException("公式模拟运行出错,请检查公式配置！", e);
}
if (run != null && StringUtils.isNotBlank(String.valueOf(run)) && returnTypeEnum == ReturnTypeEnum.NUMBER) {
//返回结果不是数字
if (!NumberUtils.isCreatable(String.valueOf(run))) {
throw new SalaryRunTimeException("返回结果不是数值");
}
}
// ExpressFormula test = ExpressFormula.builder().formulaRunScript(formulaRunScript).extendParam(param.getExtendParam()).referenceType(param.getReferenceType()).build();
// Object run = null;
// try {
// run = getFormulaRunService(user).run(test, parameters, DataCollectionEmployee.builder().employeeId((long) user.getUID()).build());
// } catch (Exception e) {
// log.error("express execute fail ", e);
// throw new SalaryRunTimeException("公式模拟运行出错,请检查公式配置！", e);
// }
//
// if (run != null && StringUtils.isNotBlank(String.valueOf(run)) && returnTypeEnum == ReturnTypeEnum.NUMBER) {
// //返回结果不是数字
// if (!NumberUtils.isCreatable(String.valueOf(run))) {
// throw new SalaryRunTimeException("返回结果不是数值");
// }
// }
}
if (ReferenceTypeEnum.parseByValue(param.getReferenceType()) == ReferenceTypeEnum.SQL) {
@ -368,12 +368,6 @@ public class SalaryFormulaServiceImpl extends Service implements SalaryFormulaSe
log.error("express execute fail ", e);
throw new SalaryRunTimeException("公式测试运行出错,请检查公式配置！", e);
}
if (run != null && StringUtils.isNotBlank(String.valueOf(run)) && returnTypeEnum == ReturnTypeEnum.NUMBER) {
//返回结果不是数字
if (!NumberUtils.isCreatable(String.valueOf(run))) {
throw new SalaryRunTimeException("返回结果不是数值");
}
}
return run;
}

4
src/com/engine/salary/service/impl/SalarySendServiceImpl.java
View File

@ -1014,13 +1014,13 @@ public class SalarySendServiceImpl extends Service implements SalarySendService
//
// // 获取所有人员信息
// List<Long> ids = enableSendList.stream().map(e->Long.valueOf(e.get("employeeId").toString())).collect(Collectors.toList());
// List<SimpleEmployee> allEmployees = hrmCommonEmployeeService.getEmployeeByIds(ids, currentTenantKey);
// List<DataCollectionEmployee> allEmployees = hrmCommonEmployeeService.getEmployeeByIds(ids, currentTenantKey);
// List<SalaryTemplateSalaryItemSetListDTO> listDTOS = JSONArray.parseArray(salaryTemplate.getSalaryItemSetting(), SalaryTemplateSalaryItemSetListDTO.class);
// Optional<SalaryTemplateSalaryItemSetListDTO> optionalEmployeeInformation = listDTOS.stream().filter(e -> SalaryTemplateSalaryItemSetGroupConstant.EMPLOYEE_INFO_GROUP_ID.equals(e.getGroupId())).findFirst();
// SalaryTemplateSalaryItemSetListDTO employeeInformation = optionalEmployeeInformation.orElse(null);
// Map<String, String> employeeField = SalaryAcctResultBO.buildEmployeeFieldName();
// enableSendList.forEach(e -> {
// Optional<SimpleEmployee> optionalSimpleEmployee = allEmployees.stream().filter(f->f.getEmployeeId().equals(Long.valueOf(e.get("employeeId").toString()))).findFirst();
// Optional<DataCollectionEmployee> optionalSimpleEmployee = allEmployees.stream().filter(f->f.getEmployeeId().equals(Long.valueOf(e.get("employeeId").toString()))).findFirst();
// if (optionalSimpleEmployee.isPresent()) {
// buildEmployeeInfo(employeeInformation, optionalSimpleEmployee.get(), e.get("taxAgent").toString(), employeeField);
// }

12
src/com/engine/salary/util/JsonUtil.java
View File

@ -65,15 +65,11 @@ public class JsonUtil {
if (map != null && map.size() > 0) {
Iterator var4 = map.entrySet().iterator();
while(var4.hasNext()) {
Entry<String, Object> entry = (Entry)var4.next();
while (var4.hasNext()) {
Entry<String, Object> entry = (Entry) var4.next();
Object obj = entry.getValue();
try {
V value = JSON.parseObject(JSON.toJSONString(obj), valueCls);
result.put(entry.getKey(), value);
} catch (Exception var8) {
}
V value = JSON.parseObject(JSON.toJSONString(obj), valueCls);
result.put(entry.getKey(), value);
}
}

6
src/com/engine/salary/util/SalaryI18nUtil.java
View File

@ -32,7 +32,7 @@ public class SalaryI18nUtil {
// */
// public static String getI18nLabel(String tenantKey, Long employeeId, int labelId, String defaultLabel) {
// int languageId = I18nLanguageUtil.getLangId(employeeId);
// return SystemEnv.getHtmlLabelName(labelId, languageId, tenantKey, defaultLabel);
// return SalaryI18nUtil.getI18nLabel(labelId, languageId, tenantKey, defaultLabel);
// }
//
// /**
@ -43,8 +43,8 @@ public class SalaryI18nUtil {
// * @param defaultLabel 默认中文
// * @return
// */
// public static String getI18nLabel(SimpleEmployee simpleEmployee, int labelId, String defaultLabel) {
// public static String getI18nLabel(DataCollectionEmployee simpleEmployee, int labelId, String defaultLabel) {
// int languageId = I18nLanguageUtil.getLangId(simpleEmployee.getEmployeeId());
// return SystemEnv.getHtmlLabelName(labelId, languageId, simpleEmployee.getTenantKey(), defaultLabel);
// return SalaryI18nUtil.getI18nLabel(labelId, languageId, simpleEmployee.getTenantKey(), defaultLabel);
// }
}

16
src/com/engine/salary/web/SalaryAcctController.java
View File

@ -49,28 +49,28 @@ public class SalaryAcctController {
private SalaryAcctRecordWrapper salaryAcctRecordWrapper;
private SalaryAcctRecordWrapper getSalaryAcctRecordWrapper(User user) {
return (SalaryAcctRecordWrapper) ServiceUtil.getService(SalaryAcctRecordWrapper.class, user);
return ServiceUtil.getService(SalaryAcctRecordWrapper.class, user);
}
private SalaryAcctEmployeeWrapper getSalaryAcctEmployeeWrapper(User user) {
return (SalaryAcctEmployeeWrapper) ServiceUtil.getService(SalaryAcctEmployeeWrapper.class, user);
return ServiceUtil.getService(SalaryAcctEmployeeWrapper.class, user);
}
private SalaryAcctResultWrapper getSalaryAcctResultWrapper(User user) {
return (SalaryAcctResultWrapper) ServiceUtil.getService(SalaryAcctResultWrapper.class, user);
return ServiceUtil.getService(SalaryAcctResultWrapper.class, user);
}
// private SalaryAcctCheckResultWrapper salaryAcctCheckResultWrapper;
private SalaryComparisonResultWrapper getSalaryComparisonResultWrapper(User user) {
return (SalaryComparisonResultWrapper) ServiceUtil.getService(SalaryComparisonResultWrapper.class, user);
return ServiceUtil.getService(SalaryComparisonResultWrapper.class, user);
}
private SalaryAcctExcelWrapper getSalaryAcctExcelWrapper(User user) {
return (SalaryAcctExcelWrapper) ServiceUtil.getService(SalaryAcctExcelWrapper.class, user);
return ServiceUtil.getService(SalaryAcctExcelWrapper.class, user);
}
private SalaryAcctExcelService getSalaryAcctExcelService(User user) {
return (SalaryAcctExcelService) ServiceUtil.getService(SalaryAcctExcelServiceImpl.class, user);
return ServiceUtil.getService(SalaryAcctExcelServiceImpl.class, user);
}
// /**********************************薪资核算记录相关 start*********************************/
@ -606,7 +606,7 @@ public class SalaryAcctController {
// @ApiOperation("校验异常导出")
// @WeaPermission
// public WeaResult<Map<String, Object>> exportCheckResult(@RequestBody @Validated SalaryCheckResultExportParam exportParam) {
// SimpleEmployee simpleEmployee = UserContext.getCurrentUser();
// DataCollectionEmployee simpleEmployee = UserContext.getCurrentUser();
// String tenantKey = TenantContext.getCurrentTenantKey();
// String eteamsId = TenantRpcContext.getEteamsId();
// Map<String, Object> map = salaryAcctExcelWrapper.exportCheckResult(exportParam, simpleEmployee, tenantKey, eteamsId);
@ -617,7 +617,7 @@ public class SalaryAcctController {
// @ApiOperation("校验异常明细导出")
// @WeaPermission
// public WeaResult<Map<String, Object>> exportCheckResultDetail(@RequestParam(value = "checkResultId") Long checkResultId) {
// SimpleEmployee simpleEmployee = UserContext.getCurrentUser();
// DataCollectionEmployee simpleEmployee = UserContext.getCurrentUser();
// String tenantKey = TenantContext.getCurrentTenantKey();
// String eteamsId = TenantRpcContext.getEteamsId();
// Map<String, Object> map = salaryAcctExcelWrapper.exportCheckResultDetail(checkResultId, simpleEmployee, tenantKey, eteamsId);

21
src/com/engine/salary/web/SalaryFormulaController.java
View File

File diff suppressed because one or more lines are too long

2
src/com/engine/salary/wrapper/OtherDeductionWrapper.java
View File

@ -108,7 +108,7 @@ public class OtherDeductionWrapper extends Service {
//
// //日期范围选项
// List<SearchConditionOption> dateOptions = new ArrayList<SearchConditionOption>();
// dateOptions.add(new SearchConditionOption("6", SystemEnv.getHtmlLabelName(32530, user.getLanguage()), true));//指定日期范围(必须为6)
// dateOptions.add(new SearchConditionOption("6", SalaryI18nUtil.getI18nLabel(32530, user.getLanguage()), true));//指定日期范围(必须为6)
// SearchConditionItem hiredate = conditionFactory.createCondition(ConditionType.RANGEPICKER, 18648, new String[]{"hiredate", "hiredate"});
// hiredate.setInputType("rangepicker");
// hiredate.setFormat("yyyy-MM-dd");

4
src/com/engine/salary/wrapper/SalaryAcctExcelWrapper.java
View File

@ -102,7 +102,7 @@ public class SalaryAcctExcelWrapper extends Service {
// * @return
// */
// public Map<String, Object> exportCheckResult(SalaryCheckResultExportParam exportParam,
// SimpleEmployee simpleEmployee, String tenantKey, String eteamsId) {
// DataCollectionEmployee simpleEmployee, String tenantKey, String eteamsId) {
// ExcelExportParam excelExportParam = new ExcelExportParam()
// .setModule(EntityType.hrsa.name())
// .setFunction("salaryCheckResultHandler");
@ -131,7 +131,7 @@ public class SalaryAcctExcelWrapper extends Service {
// * @return
// */
// public Map<String, Object> exportCheckResultDetail(Long checkResultId,
// SimpleEmployee simpleEmployee, String tenantKey, String eteamsId) {
// DataCollectionEmployee simpleEmployee, String tenantKey, String eteamsId) {
// ExcelExportParam excelExportParam = new ExcelExportParam()
// .setModule(EntityType.hrsa.name())
// .setFunction("salaryCheckResultDetailHandler");

2
src/com/engine/salary/wrapper/SalaryAcctResultWrapper.java
View File

@ -263,7 +263,7 @@ public class SalaryAcctResultWrapper extends Service {
* @param simpleEmployee 当前登陆人员
* @param tenantKey 租户key
*/
// public void check(SalaryAcctCheckParam checkParam, SimpleEmployee simpleEmployee, String tenantKey) {
// public void check(SalaryAcctCheckParam checkParam, DataCollectionEmployee simpleEmployee, String tenantKey) {
// // 检查是否正在核算中
// SalaryAcctProgressDTO salaryAcctProgressDTO = salaryAcctProgressService.getProgress("" + checkParam.getSalaryAcctRecordId(), simpleEmployee.getEmployeeId(), tenantKey);
// if (Objects.nonNull(salaryAcctProgressDTO) && salaryAcctProgressDTO.isStatus() && Optional.ofNullable(salaryAcctProgressDTO.getProgress()).orElse(BigDecimal.ZERO).compareTo(BigDecimal.ONE) < 0) {