kre-form
Version:
本项目由 Angular8+ 编写的表单设计器和表单应用，所有的配置都是 JSON 结构体组成,PC 端是基于 ANT 组件库封装
1,478 lines (1,475 loc) • 216 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
export class Formula {
constructor() {
this.FormulaUsage = [
{
category: "班段验证",
categoryCode: "SHIFTVALID",
contains: [
{
name: "ABNORMALHD",
intro: `ABNORMALHD函数用于验证班段全天异常
<br/>
函数包含3个参数可配置：是否加上所有休假项目；是否加上所有公出项目；是否加上所有加班项目
<br/>
规则：
<br/>
（打卡时段（上）+所有休假时段+所有公出时段+所有加班时段）<标准班段(上)
<br/>
（打卡时段（下）+所有休假时段+所有公出时段+所有加班时段）<标准班段(下)
<br/>
二者均符合<br/>
`,
usage: `ABNORMALHD（0，0，0）
<br/>
0代表关闭参数，1代表开启参数
<br/>
验证通过返回值为true，验证不通过返回false
`,
example: `配置：ABNORMALHD（1，0，0）
<br/>
当 打卡时段（上）+所有休假时段<标准班段(上) 或者 打卡时段（下）+所有休假时段<标准班段(下)
<br/>
符合所有情况则返回为true
<br/>
不符合则返回false
`,
},
{
name: "ABNORMALAD",
intro: `ABNORMALAD函数用于验证班段半天异常
<br/>
函数包含3个参数可配置：是否加上所有休假项目；是否加上所有公出项目；是否加上所有加班项目
<br/>
规则：
<br/>
（打卡时段（上）+所有休假时段+所有公出时段+所有加班时段）<标准班段(上)
<br/>
（打卡时段（下）+所有休假时段+所有公出时段+所有加班时段）<标准班段(下)
<br/>
二者仅符合其一
<br/>
`,
usage: `ABNORMALAD（0，0，0）
<br/>
0代表关闭参数，1代表开启参数
<br/>
验证通过返回值为true，验证不通过返回false
<br/>
`,
example: `配置：ABNORMALAD（1，0，0）
<br/>
当 打卡时段（上）+所有休假时段<标准班段(上) 或者 打卡时段（下）+所有休假时段<标准班段(下)
<br/>
符合任意情况则返回为true
<br/>
均不符合则返回false`,
},
],
},
{
category: "计算出勤天数",
categoryCode: "ATSDAYCALC",
contains: [
{
name: "ATTENDANCE1",
intro: `ATTENDANCE1函数用于计算班段上出勤时数
<br/>
函数包含4个参数可配置：是否加上所有休假时段；是否加上所有公出时段；是否加上所有加班时段；允许差值数。
<br/>
规则：
<br/>
打卡时段（班段上）+所有休假时段（班段上）+所有公出时段（班段上）+所有加班时段（班段上）+ 允许差值数 验证是否全覆盖标准班段(班段上)
`,
usage: `ATTENDANCE1（0，0，0，0）
<br/>
前3个参数0代表关闭参数，1代表开启参数
<br/>
后一个参数0代表不允许差值，具体数字代表允许差值分钟数（支持正整数）
<br/>
返回全覆盖则返回当前配置班段时数，未全覆盖则返回0
<br/>
`,
example: `配置：ATTENDANCE1（0，0，0，0）
<br/>
计算班段上出勤天数：ATTENDANCE1（1，0，0，0）
<br/>
当打卡时段（班段上）+所有休假时段（班段上）全覆盖标准班段(班段上)
<br/>
符合情况则返回标准工时（班段上）（时数），均不符合则返回0`,
},
{
name: "ATTENDANCE2",
intro: `ATTENDANCE2函数用于计算班段下出勤时数
<br/>
函数包含4个参数可配置：是否加上所有休假时段；是否加上所有公出时段；是否加上所有加班时段；允许差值数。
<br/>
规则：
<br/>
打卡时段（班段下）+所有休假时段（班段下）+所有公出时段（班段下）+所有加班时段（班段下）+ 允许差值数验证是否全覆盖标准班段(班段下)
`,
usage: `ATTENDANCE2（0，0，0，0）
<br/>
前3个参数0代表关闭参数，1代表开启参数
<br/>
后一个参数0代表不允许差值，具体数字代表允许差值分钟数（支持正整数）
<br/>
返回全覆盖则返回当前配置班段时数，未全覆盖则返回0
<br/>
`,
example: `配置：ATTENDANCE2（0，0，0，0）
<br/>
计算班段下出勤天数：ATTENDANCE2（1，0，0，0）
<br/>
当打卡时段（班段下）+所有休假时段（班段下）全覆盖标准班段(班段下)
<br/>
符合情况则返回标准工时（班段下）（时数），均不符合则返回0`,
},
],
},
{
category: "通用函数",
categoryCode: "BASE",
contains: [
{
name: "PRECISION",
intro: `PRECISION函数用于设置计算结果输出的精度与进位规则
<br/>
函数包含2个参数可配置：精度；进位规则`,
usage: `PRECISION（计算对象，0，0）
<br/>
第一个参数：设置精度，支持属于0-3之间的整数。其余结果按0计算
<br/>
第二个参数：设置进位规则，0代表四舍五入；1代表向上进位；2代表向下进位
<br/>
`,
example: `配置：PRECISION（7.916，1，0），则输出结果为：7.9
<br/>
PRECISION（7.916，2，1），则输出结果为：7.92
<br/>
PRECISION（7.916，2，2），则输出结果为：7.91`,
},
{
name: "Daycompute",
intro: `Daycompute可基于另一个日期型字段加减一个指定的数值，从而计算当前日期型字段的默认值`,
usage: `Daycompute（日期型字段,运算天数）
<br/>
第一个参数：选择日期型字段
<br/>
第二个参数：输入天数，支持正负数；不支持小数
`,
example: `配置：Daycompute（离职日期,1）
<br/>
离职日期=2022/1/1
<br/>
结果输出=2022/1/2
<br/>
配置：Daycompute（离职日期,-1）
<br/>
离职日期=2022/1/1
<br/>
结果输出=2021/12/31
<br/>
`,
},
{
name: "Hourcalculation",
intro: `Hourcalculation用于计算日期时间之间小时数
<br/>
包含6个参数：开始时间；是否包含开始时间；结束时间；是否包含结束时间；最小单位；进位规则`,
usage: `Hourcalculation（开始时间,0,结束时间,0,1,1）
<br/>
第一个参数：选择开始日期字段
<br/>
第二个参数：是否包含开始日期，1代表包含，0代表不包含
<br/>
第三个参数：选择结束日期字段
<br/>
第四个参数：是否包含结束日期，1代表包含，0代表不包含
<br/>
第五个参数：设置最小单位，1代表最小单位为1，0.5代表最小单位为0.5
<br/>
第六个参数：设置进位规则，1代表向上进位，2代表向下进位，3代表取接近值（中间值向下取值），4代表4舍5入（最小单位为1时生效）
<br/>
`,
example: `配置：Hourcalculation（开始时间,1,结束时间,1,1,1）
<br/>
开始日期=10/1 10:00
<br/>
结束日期=10/1 13:30
<br/>
结果输出=4
`,
},
{
name: "SUM",
intro: `SUM用于计算多记录数值型字段求和
<br/>
包含1个参数：字段名称`,
usage: `SUM（明细金额）
<br/>
参数：选择计算字段
`,
example: `配置：SUM（明细金额）
<br/>
明细1为100；明细2为200；明细3为300
<br/>
则汇总金额为：600
`,
},
{
name: "CalendarDay",
intro: `CalendarDay用于获取周期内日历中不用属性日期的天数
<br/>
包含3个参数：1，日历类型；2，日期属性；3，周期类型`,
usage: `CalendarDay(0，0，0)
<br/>
第一个参数日历类型：输入“0”代表获取员工关联日历；输入具体日历名称代表指定日历
<br/>
第二个参数日期属性：输入“0”代表计算自然日天数；输入“1”代表获取工作日天数；输入“2”代表获取公休日天数；输入“3”代表获取节假日天数；输入“4”代表获取周六天数；输入“5”代表获取周日天数；输入“6”代表获取周六天数（排除非公休日的周六）；输入“7”代表获取周日天数（排除非公休日的周日）
<br/>
第三个参数周期类型：输入“0”代表统计周期内自然日数据；输入“1”代表统计周期内员工在职区间数据
<br/>
`,
example: `
示例1：
<br/>
CalendarDay（0，0，0）
<br/>
代表获取员工关联日历周期内的自然日天数
<br/>
示例2：
<br/>
CalendarDay（”国家日历“，1，1）
<br/>
代表获取“国家日历”下，周期内，员工在职区间内的工作日天数
`,
},
{
name: "DepartmentScope",
intro: `DepartmentScope函数用于部门选择
<br/>
包含2个参数：1，部门选择；2，包含范围`,
usage: `DepartmentScope（'0',0）
<br/>
1,部门选择：输入部门编码,多个部门使用|隔开
<br/>
2,定义包含范围：1，仅本级；2，本级+直接下级；3，本级+所有下级；4，直接下级；5，所有下级
<br/>
`,
example: `
设置DepartmentScope('P01|P02|P03',1)
<br/>
则结果返回部门为：P01，P02，P03
<br/>
`,
},
],
},
{
category: "逻辑函数",
categoryCode: "LOGIC",
contains: [
{
name: "AND",
intro: "如果所有参数都为真，AND函数返回布尔值true，否则返回布尔值false",
usage: "AND(逻辑表达式1,逻辑表达式2,...)",
example: "AND(语文成绩>90,数学成绩>90,英语成绩>90)，如果三门课成绩都>90，返回true，否则返回false",
},
{
name: "OR",
intro: "如果任意参数为真，OR 函数返回布尔值true；如果所有参数为假，返回布尔值false",
usage: "OR(逻辑表达式1,逻辑表达式2,...)",
example: "OR(语文成绩>90,数学成绩>90,英语成绩>90)，任何一门课成绩> 90，返回true，否则返回false",
},
{
name: "IF",
intro: "IF函数判断一个条件能否满足；如果满足返回一个值，如果不满足则返回另外一个值",
usage: "IF(逻辑表达式,为true时返回的值,为false时返回的值)",
example: 'IF(语文成绩>60,"及格","不及格")，当语文成绩>60时返回及格，否则返回不及格。',
},
{
name: "IN",
intro: "IN函数用于判断目标对象，是否包含在当前限定的范围内，包含则返回true，不包含返回false",
usage: "用法：IN（表名称.字段名称，'参数1','参数2','参数3'......）",
example: `示例：in(组织表.区域,'上海','成都','北京')，判断组织表.区域在上海、成都、北京，符合返回true，否则返回false`,
},
],
},
{
category: "工时计算函数",
categoryCode: "SHIFTTIMECALC",
contains: [
{
name: "MANHOURS",
intro: `MANHOURS函数用于工时（取各类型时段的并集）
<br/>
函数包含5个参数可配置：打卡时数；是否加上休假时段；是否加上公出时段；是否加上加班时段；指定日历类型（0点拆分）
<br/>
规则：
<br/>
打卡时段+所有休假时段/指定休假项目时段+所有公出时段/指定公出项目时段+所有加班时段
<br/>
日历类型：0代表获取所有日历类型，1代表获取工作日，2代表获取公休日，3代表获取节假日
`,
usage: `MANHOURS（0，0，0，0，0）
<br/>
0代表关闭参数；1代表开启参数；选择项目代表指定项目，多个项目“/”分隔
<br/>
返回 计算结果
<br/>
`,
example: `
示例1：
<br/>
计算工时：MANHOURS（1，1，0，0，0）
<br/>
结果返回，打卡时数+所有休假时数（取并集）
<br/>
示例2：
<br/>
计算工时：MANHOURS（1，年假/事假，0，0，0）
<br/>
结果返回，打卡时数+休假项目年假/事假的时数（取并集）
<br/>`,
},
],
},
{
category: "日期间天数计算函数",
categoryCode: "DATECALC",
contains: [
{
name: "Daycalculation",
intro: `Daycalculation用于计算日期之间天数：
<br/>
包含4个参数：开始日期；是否包含开始日期；结束日期；是否包含结束日期
<br/>
`,
usage: `Daycalculation（开始日期,0,结束日期,0）
<br/>
第一个参数：选择开始日期字段
<br/>
第二个参数：是否包含开始日期，1代表包含，0代表不包含
<br/>
第三个参数：选择结束日期字段
<br/>
第四个参数：是否包含结束日期，1代表包含，0代表不包含
<br/>
`,
example: `配置：Daycalculation（开始日期,1,结束日期,1）
<br/>
开始日期=10/1
<br/>
结束日期=10/3
<br/>
结果输出=3
<br/>
`,
},
],
},
{
category: "内置函数",
categoryCode: "BUILTIN",
contains: [
{
name: "VERIFICATION",
intro: `VERIFICATION用于未打卡验证：
<br/>
验证上班后或下班前指定时间内未进行打卡，且期间休假公出记录未全覆盖时则计未打卡
<br/>
函数包含4个参数：
<br/>
`,
usage: `
第一个参数：配置未打卡统计时长，大写X代表获取最大迟到或早退数；输入数字代表指定时长，小于0的数字按0处理（若开启弹性打卡，系统将根据弹性规则动态计算）
<br/>
第二个参数：配置休假记录参与覆盖计算，1代表开启，0代表关闭
<br/>
第三个参数：配置公出记录参与覆盖计算，1代表开启，0代表关闭
<br/>
第四个参数：配置时段间容差分钟数，小于0的数字按0处理
<br/>
`,
example: `若上班未打卡配置（X，1，1，0）
<br/>
则在最大迟到数之间未打卡；或打卡加上休假，公出未完全覆盖上班段，则计未打卡
<br/>
`,
},
],
},
{
category: "编制相关",
categoryCode: "PREPARATION",
contains: [
{
name: "PositionHeadcount",
intro: `PositionHeadcount函数用于表单字段获取当前自定义维度职位编制相关数：
<br/>
包含2个参数：1，获取对象；2，获取值类型
<br/>
`,
usage: `
<br/>
第一个参数获取对象：需填写对应表单的字段编码，字段必须是职位单选组件型字段，用于对应需获取编制所对应的组织
<br/>
第二个参数获取值类型：输入“1”代表获取当前职位编制数；输入“2”代表获取当前职位在编数；输入“3”代表获取当前职位占编数；输入“4”代表获取当前职位缺编数；输入“5”代表获取当前职位超编数
<br/>
前置条件：
<br/>
需当前启用自定义维度编制，且末级统计维度为职位
<br/>
`,
example: `
<br/>
若设置PositionHeadcount（applyinfo$employeebasic$positionid$empmobilize，1）
<br/>
则获取当前表单applyinfo$employeebasic$positionid$empmobilize字段下所选职位的编制数
<br/>
`,
},
],
},
];
/*
FormulaUsage = [
{
category: "班段验证",
contains: [
{
name: "ABNORMALHD",
intro:
"ABNORMALHD函数用于验证班段全天异常;函数包含3个参数可配置：是否加上所有休假项目；是否加上所有公出项目；是否加上所有加班项目",
usage:
"ABNORMALHD(标准班段(上)>打卡时段(上)+所有休假时段+所有公出时段+所有加班时段,标准班段(下)>打卡时段（下）+所有休假时段+所有公出时段+所有加班时段)",
example:
"ABNORMALHD(标准班段(上)>打卡时段(上)+所有休假时段+所有公出时段+所有加班时段,标准班段(下)>打卡时段（下）+所有休假时段+所有公出时段+所有加班时段)，二者都满足，返回true，否则返回false",
},
{
name: "ABNORMALAD",
intro:
"ABNORMALAD函数用于验证班段半天异常;函数包含3个参数可配置：是否加上所有休假项目；是否加上所有公出项目；是否加上所有加班项目",
usage:
"ABNORMALAD(标准班段(上)>打卡时段(上)+所有休假时段+所有公出时段+所有加班时段,标准班段(下)>打卡时段（下）+所有休假时段+所有公出时段+所有加班时段)",
example:
"ABNORMALAD(标准班段(上)>打卡时段(上)+所有休假时段+所有公出时段+所有加班时段,标准班段(下)>打卡时段（下）+所有休假时段+所有公出时段+所有加班时段)，二者仅符合其一，返回true，否则返回false",
},
],
},
{
category: "数学函数",
contains: [
{
name: "ABS",
intro: "ABS函数可以获取一个数的绝对值",
usage: "ABS(数字)",
example: "ABS(-1)可以返回1，也就是-1的绝对值",
},
{
name: "AVERAGE",
intro: "AVERAGE函数可以获取一组数值的算术平均值",
usage: "AVERAGE(数字1,数字2,...)",
example:
"AVERAGE({语文成绩},{数学成绩}, {英语成绩})返回三门课程的平均分",
},
{
name: "CEILING",
intro: "CEILING函数可以将数字增大到最接近原值的指定因数的倍数",
usage: "CEILING(数字,因数)",
example:
"CEILING(7,6)返回12，因为12比7大的同时，也是6的倍数中最接近7的数字",
},
{
name: "COUNT",
intro: "COUNT函数可以获取参数的数量",
usage: "COUNT(值,值,...)",
example: "COUNT(小明,小王,小张,小李)返回4，也就是人员的数量",
},
{
name: "COUNTIF",
intro: "COUNTIF函数可以获取数组中满足条件的参数个数",
usage: 'COUNTIF(数组,"条件")',
example:
'COUNTIF(子表单.性别, "女")，可得到子表单中性别填的是"女"的数据条数；COUNTIF([1,2,3,4],">2")，可得到1,2,3,4中大于2的数字数量，结果为2。',
},
{
name: "FIXED",
intro: "FIXED函数可将数字舍入到指定的小数位数并输出为文本",
usage: "FIXED(数字,小数位数)",
example: 'FIXED(3.1415,2)返回"3.14"',
},
{
name: "FLOOR",
intro: "FLOOR函数可将数字减小到最接近原值的指定因数的倍数",
usage: "FLOOR(数字,因数)",
example:
"FLOOR(7,6)返回6，因为6比7小的同时，也是6的倍数中最接近7的数字",
},
{
name: "INT",
intro: "INT函数可以获取一个数的整数部分",
usage: "INT(数字)",
example: "INT(3.1415)返回3，也就是3.1415的整数部分",
},
{
name: "LARGE",
intro: "LARGE函数可以获取数据集中第k个最大值",
usage: "LARGE(数组,k)",
example:
'LARGE({学生成绩.数学成绩},1)返回子表单"学生成绩"中排名第1的"数学成绩"',
},
{
name: "LOG",
intro: "LOG函数可以根据指定底数返回数字的对数",
usage: "LOG(数字,底数)",
example: "LOG(100,10)返回2，也就是以10为底数100的对数",
},
{
name: "MAX",
intro: "MAX函数可以获取一组数值的最大值",
usage: "MAX(数字1,数字2,...)",
example:
"MAX({语文成绩},{数学成绩},{英语成绩})返回三门课程中的最高分",
},
{
name: "MIN",
intro: "MIN函数可以获取一组数值的最小值",
usage: "MIN(数字1,数字2,...)",
example:
"MAX({语文成绩},{数学成绩},{英语成绩})返回三门课程中的最低分",
},
{
name: "MOD",
intro: "MOD函数可以获取两数相除的余数",
usage: "MOD(被除数,除数)",
example: "MOD(4,3)返回1，也就是4/3的余数",
},
{
name: "POWER",
intro: "POWER函数可以获取数字乘幂的结果",
usage: "POWER(数字,指数)",
example: "POWER(3，2)返回9，也就是3的2次方",
},
{
name: "PRODUCT",
intro: "PRODUCT函数可以获取一组数值的乘积",
usage: "PRODUCT(数字1,数字2,...)",
example: "PRODUCT({单价}, {数量})获取总价，也就是单价和数量的乘积",
},
{
name: "ROUND",
intro: "ROUND函数可以将数字四舍五入到指定的位数",
usage: "ROUND(数字,数字位数)",
example: "ROUND(3.1485,2)返回3.15",
},
{
name: "SQRT",
intro: "SQRT函数可以获取一个数字的正平方根",
usage: "SQRT(数字)",
example: "SQRT(9)返回3，也就是9的正平方根",
},
{
name: "SUM",
intro: "SUM函数可以获取一组数值的总和",
usage: "SUM(数字1,数字2,...)",
example: "SUM({语文成绩},{数学成绩}, {英语成绩})返回三门课程的总分",
},
{
name: "SUMPRODUCT",
intro:
"SUMPRODUCT函数可以将数组间对应的元素相乘，并返回乘积之和，适用于加权求和",
usage: "SUMPRODUCT(数组,数组...)",
example:
"SUMPRODUCT([1,2,3],[0.1,0.2,0.3])返回1.4，也就是 1×0.1 + 2×0.2 + 3×0.3的值",
},
],
},
{
category: "文本函数",
contains: [
{
name: "CONCATENATE",
intro: "CONCATENATE函数可以将多个文本合并成一个文本",
usage: "CONCATENATE(文本1,文本2,...)",
example:
'CONCATENATE("上海肯耐珂萨人力资源科技股份有限公司","张三")会返回"上海肯耐珂萨人力资源科技股份有限公司张三"',
},
{
name: "EXACT",
intro:
"EXACT函数可以比较两个文本是否完全相同，完全相同则返回true，否则返回false",
usage: "EXACT(文本1, 文本2)",
example:
"EXACT({手机号},{中奖手机号})，如果两者相同，返回true，如果不相同，返回false",
},
{
name: "GETUSERNAME",
intro: "GETUSERNAME函数可以获取当前用户的昵称",
usage: "GETUSERNAME()",
example: "略",
},
{
name: "ISEMPTY",
intro: "ISEMPTY函数可以用来判断值是否为空文本、空对象或者空数组",
usage: "ISEMPTY(文本)",
example: "略",
},
{
name: "LEFT",
intro: "LEFT函数可以从一个文本的第一个字符开始返回指定个数的字符",
usage: "LEFT(文本,文本长度)",
example:
'LEFT("上海肯耐珂萨人力资源科技股份有限公司张三",2)返回"上海"，也就是"上海肯耐珂萨人力资源科技股份有限公司张三"的从左往右的前2个字符',
},
{
name: "LEN",
intro: "LEN函数可以获取文本中的字符个数",
usage: "LEN(文本)",
example: 'LEN("朝辞白帝彩云间")返回7，因为这句诗中有7个字符',
},
{
name: "LOWER",
intro: "LOWER函数可以将一个文本中的所有大写字母转换为小写字母",
usage: "LOWER(文本)",
example: 'LOWER("JAYZ")返回"jayz"',
},
{
name: "MID",
intro: "MID返回文本中从指定位置开始的指定数目的字符",
usage: "MID(文本,开始位置_数字,指定数目)",
example:
'MID("肯耐珂萨数字化组织效能提升专家",5,1)返回"数字化组织效能提升专家"',
},
{
name: "REPLACE",
intro: "REPLACE函数可以根据指定的字符数，将部分文本替换为不同的文本",
usage: "REPLACE(文本,开始位置,替换长度,新文本)",
example:
'REPLACE("肯耐珂萨应用定制工具",5,6,"企业数据管理平台")返回"肯耐珂萨企业数据管理平台"',
},
{
name: "REPT",
intro: "REPT函数可以将文本重复一定次数",
usage: "REPT(文本,重复次数)",
example: 'REPT("肯耐珂萨",3)返回"肯耐珂萨肯耐珂萨肯耐珂萨"',
},
{
name: "RIGHT",
intro: "RIGHT函数可以获取由给定文本右端指定数量的字符构成的文本值",
usage: "RIGHT(文本,文本长度)",
example:
'RIGHT("三年二班周杰伦",3)返回"周杰伦"，也就是"三年二班周杰伦"从右往左的前3个字符',
},
{
name: "SEARCH",
intro: "SEARCH函数可以获取文本1在文本2中的开始位置",
usage: "SEARCH(文本1,文本2)",
example: 'SEARCH("2021","肯耐珂萨2021")返回4',
},
{
name: "SPLIT",
intro: "SPLIT函数可以将文本按指定分割符分割成数组",
usage: "SPLIT(文本,分隔符_文本)",
example:
'SPLIT("肯耐珂萨-应用定制工具","-")返回"肯耐珂萨，应用定制工具"',
},
{
name: "TEXT",
intro: "TEXT函数可以将数字转化成文本",
usage: "TEXT(数字)",
example: 'TEXT(3.1415)返回"3.1415"',
},
{
name: "TRIM",
intro: "TRIM函数可以删除文本首尾的空格",
usage: "TRIM(文本)",
example: 'TRIM(" 肯耐珂萨 ")返回"肯耐珂萨"',
},
{
name: "UPPER",
intro: "UPPER函数可以将一个文本中的所有小写字母转换为大写字母",
usage: "UPPER(文本)",
example: 'UPPER("jayz")返回"JAYZ"',
},
{
name: "VALUE",
intro: "VALUE函数可以将文本转化为数字",
usage: "VALUE(文本)",
example: 'VALUE("3.1415")返回3.1415',
},
],
},
{
category: "日期函数",
contains: [
{
name: "DATE",
intro: "DATE函数可以将时间戳转换为日期对象",
usage: "DATE(时间戳)",
example: "略",
},
{
name: "DATEDELTA",
intro: "DATEDELTA函数可以将指定日期加/减指定天数",
usage: "DATEDELTA(指定日期,需要加减的天数)",
example: "略",
},
{
name: "DAY",
intro: "DAY函数可以获取某日期是当月的第几日",
usage: "DAY(时间戳)",
example: "略",
},
{
name: "DAYS",
intro: "DAYS函数可以返回两个日期之间相差的天数。",
usage: "DAYS(结束日期,开始日期)",
example: "略",
},
{
name: "DAYS360",
intro: "DAYS360按照一年 360 天的算法，返回两个日期间相差的天数",
usage: "DAYS360(结束日期,开始日期)",
example: "略",
},
{
name: "HOUR",
intro: "HOUR函数可以返回某日期的小时数",
usage: "HOUR(时间戳)",
example: "略",
},
{
name: "ISOWEEKNUM",
intro: "ISOWEEKNUM函数可以返回指定日期在全年中的ISO周数",
usage: "ISOWEEKNUM(指定日期)",
example: "略",
},
{
name: "MINUTE",
intro: "MINUTE函数可以返回某日期的分钟数",
usage: "MINUTE(日期)",
example: "略",
},
{
name: "MONTH",
intro: "MONTH返回某日期的月份",
usage: "MONTH(日期)",
example: "略",
},
{
name: "NOW",
intro: "NOW函数可以获取当前时间",
usage: "NOW()",
example: "略",
},
{
name: "SECOND",
intro: "SECOND函数可以返回某日期的秒数",
usage: "SECOND(日期)",
example: "略",
},
{
name: "SYSTIME",
intro: "SYSTIME函数可以获取当前服务器时间",
usage: "SYSTIME()",
example: "略",
},
{
name: "TIME",
intro: "TIME函数可以返回特定时间的十进制数字",
usage: "TIME(时_数字,分_数字,秒_数字)",
example: "略",
},
{
name: "TIMESTAMP",
intro: "TIMESTAMP函数可以将日期对象转换成时间戳。",
usage: "TIMESTAMP(日期)",
example: "略",
},
{
name: "TODAY",
intro: "TODAY函数可以返回今天",
usage: "TODAY()",
example: "略",
},
{
name: "WEEKNUM",
intro: "WEEKNUM函数可以返回指定日期在当年是第几周",
usage: "WEEKNUM(指定日期)",
example: "略",
},
{
name: "YEAR",
intro: "YEAR函数可以返回某日期的年份",
usage: "YEAR(时间戳)",
example: "略",
},
],
},
{
category: "逻辑函数",
contains: [
{
name: "AND",
intro:
"如果所有参数都为真，AND函数返回布尔值true，否则返回布尔值 false",
usage: "AND(逻辑表达式1,逻辑表达式2,...)",
example:
"AND({语文成绩}>90,{数学成绩}>90,{英语成绩}>90)，如果三门课成绩都> 90，返回true，否则返回false",
},
{
name: "FALSE",
intro: "FALSE函数返回布尔值false",
usage: "FALSE()",
example: "略",
},
{
name: "IF",
intro:
"IF函数判断一个条件能否满足；如果满足返回一个值，如果不满足则返回另外一个值",
usage: "IF(逻辑表达式,为true时返回的值,为false时返回的值)",
example:
'IF({语文成绩}>60,"及格","不及格")，当语文成绩>60时返回及格，否则返回不及格。',
},
{
name: "NOT",
intro: "NOT函数返回与指定表达式相反的布尔值。",
usage: "NOT(逻辑表达式)",
example:
"NOT({语文成绩}>60)，如果语文成绩大于60返回false，否则返回true",
},
{
name: "OR",
intro:
"如果任意参数为真，OR 函数返回布尔值true；如果所有参数为假，返回布尔值false。",
usage: "OR(逻辑表达式1,逻辑表达式2,...)",
example:
"OR({语文成绩}>90,{数学成绩}>90,{英语成绩}>90)，任何一门课成绩> 90，返回true，否则返回false",
},
{
name: "TRUE",
intro: "TRUE函数返回布尔值true",
usage: "TRUE()",
example: "略",
},
{
name: "XOR",
intro: "XOR函数可以返回所有参数的异或值",
usage: "XOR(逻辑表达式1, 逻辑表达式2,...)",
example:
"XOR({语文成绩}>90,{数学成绩}>90)，如果两门成绩都>90,返回false；如果两门成绩都<90，返回false；如果其中一门>90，另外一门<90，返回true",
},
],
},
{
category: "高级函数",
contains: [
{
name: "MAPX",
intro: "MAPX函数是一个可以用来进行跨表单取数的高级函数",
usage: "MAPX(operation,map_value,map_field,result_field)",
example: "略",
},
{
name: "RECNO",
intro: "RECNO函数依据当前表单被新打开的次数进行不断累计，起始值为1。",
usage: "RECNO()",
example: "略",
},
{
name: "UUID",
intro: "UUID函数随机码生成器。可适用于随机流水号的使用场景等",
usage: "UUID()",
example: "略",
},
],
},
];
*/
this.FormulaEditor = {
CONST: {
NAME_FILED_CLS: "cm-field-name",
VALUE_FIELD_CLS: "cm-field-value",
INVALID_FIELD_CLS: "cm-field-invalid",
DEPRECATE_FIELD_CLS: "cm-deprecate",
NEGATIVE_FIELD_CLS: "cm-negative",
FIELD_REG: /^\$(_widget_*|_formula_[0-9]{13}|ext|createTime|updateTime|creator|wx_open_id|wx_nickname|wx_gender)/,
},
COMMON_REG: {
VALIDATOR_FORMULA: "(\\$[0-9a-zA-Z._]+#)",
FORM_FORMULA: "(\\$[0-9a-zA-Z._#@]+)",
NEW_LINE: "[\\r\\n]",
},
};
this.Utils = {};
this.Formula = {};
/** @type {?} */
let that = this;
that.Utils = {
/**
* @param {?} a
* @return {?}
*/
isString(a) {
return "string" == typeof a;
},
/**
* @param {?} b
* @return {?}
*/
isNumber(b) {
that.Utils.isNumeric(b);
},
/**
* @param {?} b
* @return {?}
*/
isFunction(b) {
return this.isFunction(b);
},
/**
* @param {?} a
* @return {?}
*/
isDate(a) {
return a instanceof Date;
},
/**
* @param {?} b
* @return {?}
*/
isArray(b) {
return this.isArray(b);
},
/**
* @param {?} a
* @return {?}
*/
isEmpty(a) {
return "" === a || that.Utils.isNull(a);
},
/**
* @param {?} a
* @return {?}
*/
isBlank(a) {
return that.Utils.isNull(a) || "" === a.trim();
},
/**
* @param {?} a
* @return {?}
*/
isNull(a) {
return null == a;
},
/**
* @param {?} a
* @return {?}
*/
isObjectEmpty(a) {
if (null == a)
return !0;
if (a.length > 0)
return !1;
if (0 === a.length)
return !0;
for (var b in a) {
if (this.hasOwnProperty.call(a, b)) {
return !1;
}
return isNaN(a);
}
},
/**
* @param {?} a
* @return {?}
*/
isValueWidget(a) {
return !!this.ValueWidgets[a];
},
/**
* @param {?} a
* @param {?} b
* @param {?} c
* @return {?}
*/
address2Str(a, b, c) {
if (c && a) {
b = "";
/** @type {?} */
var d = !0;
/p/.test(c) &&
a.province &&
((b += a.province), a.province === a.city && (d = !1)),
/c/.test(c) && a.city && d && (b += a.city),
/d/.test(c) && a.district && (b += a.district),
/a/.test(c) && a.detail && (b += a.detail);
}
return b;
},
/**
* @param {?} a
* @param {?} b
* @return {?}
*/
num2Str(a, b) {
if (that.Utils.isEmpty(a))
return "";
/** @type {?} */
var c = a + "";
if (that.Utils.isEmpty(b))
return c;
/** @type {?} */
var d = /\[Num0\]/;
if (d.test(b))
return b.replace(d, c);
if (((d = /\[Num1\]/), d.test(b)))
return b.replace(d, that.Utils._num2CN(c, !1));
if (((d = /\[Num2\]/), d.test(b)))
return b.replace(d, that.Utils._num2CN(c, !0));
d = /[#0]+,?[#0]*\.?[#0]*%?/;
/** @type {?} */
var e = b.match(d);
if (e && e.length > 0) {
/** @type {?} */
var f = e[0];
return (c = that.Utils._numberFormat(a, f)), b.replace(d, c);
}
return b;
},
/**
* @param {?} a
* @param {?} b
* @return {?}
*/
_numberFormat(a, b) {
/** @type {?} */
var c = "";
/** @type {?} */
var d = a + "";
if (/%$/.test(b)) {
(c = "%"), (a = 100 * a), (b = b.replace("%", ""));
/** @type {?} */
var e = d.indexOf(".");
if (e > -1) {
/** @type {?} */
var f = d.length - 3 - e;
(f = f < 0 ? 0 : f > 8 ? 8 : f), (a = parseFloat(a.toFixed(f)));
}
d = a + "";
}
/** @type {?} */
var g = b.split(".");
/** @type {?} */
var h = g[0];
/** @type {?} */
var i = g[1];
if ("" !== i) {
/** @type {?} */
var j = i ? i.length : 0;
d = parseFloat(a).toFixed(j);
/** @type {?} */
let k = d.split("");
for (let l = j; l > 0 && "#" === i.charAt(l - 1); l--) {
/** @type {?} */
let m = k.pop();
if ("0" !== m) {
k.push(m);
break;
}
}
/** @type {?} */
var n = k.pop();
"." === n && (n = ""), (d = k.join("") + n);
}
/** @type {?} */
var o = d.split(".");
/** @type {?} */
var p = o[0];
if (/,/.test(h))
o[0] = p.replace(/(\d{1,3})(?=(?:\d{3})+(?!\d))/g, "$1,");
else {
/** @type {?} */
var q = h.match(/[0]+[0#]*$/);
q && q.length > 0 && (o[0] = that.Utils.leftPad(p, q[0].length, "0"));
}
return o.join(".") + c;
},
/**
* @param {?} a
* @param {?} b
* @return {?}
*/
_num2CN(a, b) {
/** @type {?} */
var c = "〇一二三四五六七八九";
/** @type {?} */
var d = "个十百千万亿";
b && ((c = "零壹贰叁肆伍陆柒捌玖"), (d = "个拾佰仟万亿"));
/** @type {?} */
var e = Math.floor(Math.abs(a));
/** @type {?} */
var f = Math.abs(a).toString();
/** @type {?} */
var g = f.replace(/\..*$/, "");
/** @type {?} */
var h = f.split(".");
/** @type {?} */
var i = c;
/** @type {?} */
var j = d;
/** @type {?} */
var k = "-.";
/** @type {?} */
var l = i[0];
/** @type {?} */
var m = new RegExp(i[0] + "*$");
/** @type {?} */
var n = new RegExp(i[0] + "+", "g");
/** @type {?} */
var o = "";
/** @type {?} */
var p = "";
if (((o = a < 0 ? k[0] : ""), h.length >= 2)) {
/** @type {?} */
var q = h[1];
if (q) {
p = k[1];
for (var r = 0; r < q.length; r++)
p += i[+q[r]];
}
}
if (1 == g.length)
return o + i[e] + p;
if (g.length <= 5) {
for (var s = "", t = 0, e = g.length; e--;) {
/** @type {?} */
var u = +g[t];
(s += this._num2CN(g[t], b) + (u && e ? j[e] : "")), t++;
}
return (s = s.replace(n, l)), (s = s.replace(m, "")), o + s + p;
}
for (var v = (g.length / 4) >> 0, w = g.length % 4, s = ""; 0 == w || !j[3 + v];)
(w += 4), v--;
if (+g.substr(0, w)) {
s = this._num2CN(g.substr(0, w), b) + j[3 + v];
/** @type {?} */
var x = g.substr(w);
"0" === x[0] && (s += i[0]), (s += this._num2CN(x, b));
}
else
s = this._num2CN(g.substr(0, w), b) + this._num2CN(g.substr(w), b);
return (s = s.replace(n, l)), (s = s.replace(m, "")), o + s + p;
},
/**
* @param {?} a
* @param {?} b
* @return {?}
*/
date2Str(a, b) {
if (!a)
return "";
/** @type {?} */
var c = b.length;
/** @type {?} */
var d = "";
if (c > 0) {
for (var e = b.charAt(0), f = 0, g = e, h = 1; h < c; h++) {
/** @type {?} */
var i = b.charAt(h);
e !== i
? ((d += that.Utils._compileDateFormat({
char: e,
str: g,
len: h - f,
}, a)),
(e = i),
(f = h),
(g = e))
: (g += i);
}
d += that.Utils._compileDateFormat({
char: e,
str: g,
len: c - f,
}, a);
}
return d;
},
/**
* @param {?} a
* @param {?} b
* @return {?}
*/
_compileDateFormat(a, b) {
/** @type {?} */
var c = a.str;
/** @type {?} */
var d = a.len;
/** @type {?} */
var e = a.char;
switch (e) {
case "E":
// c =
// d > 2
// ? Date._DN[b.getDay()]
// : d > 1
// ? Date._SDN[b.getDay()]
// : b.getDay() + "";
break;
case "y":
c = d <= 3 ? (b.getFullYear() + "").slice(2, 4) : b.getFullYear();
break;
case "M":
// c =
// d > 2
// ? Date._MN[b.getMonth()]
// : d < 2
// ? b.getMonth() + 1
// : that.Utils.leftPad(b.getMonth() + 1 + "", 2, "0");
break;
case "d":
c =
d > 1
? that.Utils.leftPad(b.getDate() + "", 2, "0")
: b.getDate();
break;
case "h":
/** @type {?} */
var f = b.getHours() % 12;
0 === f && (f = 12),
(c = d > 1 ? that.Utils.leftPad(f + "", 2, "0") : f);
break;
case "H":
c =
d > 1
? that.Utils.leftPad(b.getHours() + "", 2, "0")
: b.getHours();
break;
case "m":
c =
d > 1
? that.Utils.leftPad(b.getMinutes() + "", 2, "0")
: b.getMinutes();
break;
case "s":
c =
d > 1
? that.Utils.leftPad(b.getSeconds() + "", 2, "0")
: b.getSeconds();
break;
case "a":
c = b.getHours() < 12 ? "am" : "pm";
break;
default:
c = a.str;
}
return c;
},
/**
* @param {?} a
* @param {?} b
* @return {?}
*/
pick(a, b) {
/** @type {?} */
var c = {};
return (that.Utils.forEach(b, (/**
* @param {?} b
* @param {?} d
* @return {?}
*/
function (b, d) {
d in a && (c[d] = a[d]);
})),
c);
},
/**
* @param {?} a
* @param {?} b
* @param {?} c
* @param {?} d
* @return {?}
*/
applyFunc(a, b, c, d) {
return that.Utils.isFunction(b) ? b.apply(a, c ? c : []) : d;
},
/**
* @param {?} a
* @param {?} b
* @return {?}
*/
forEach(a, b) {
if (Array.isArray(a))
for (var c = 0, d = a.length; c < d && b.apply(a[c], [c, a[c]]) !== !1; c++)
;
else if (a && "object" == typeof a)
for (var e in a)
if (a.hasOwnProperty(e) && b.apply(a[e], [e, a[e]]) === !1)
break;
},
/**
* @param {?=} a
* @param {?=} b
* @param {?=} c
* @return {?}
*/
flatten(a, b, c) {
if ((c || (c = []), a))
for (var d = 0, e = a.length; d < e; d++) {
/** @type {?} */
var f = a[d];
Array.isArray(f)
? that.Utils.flatten(f, b, c)
: (b && !b(f)) || c.push(f);
}
return c;
},
/**
* @param {?} a
* @param {?} b
* @return {?}
*/
applyCss(a, b) {
that.Utils.isEmpty(b) ||
(that.Utils.isString(b) ? a.addClass(b) : a.css(b));
},
/**
* @param {?} a
* @return {?}
*/
getServerDate(a) {
if (a && a.getResponseHeader) {
/** @type {?} */
var b = a.getResponseHeader("date");
b &&
((this.STATIC._st = new Date(b).getTime()),
(this.STATIC._ct = new Date().getTime()));
}
},
/**
* @param {?} a
* @return {?}
*/
getUrlParameter(a) {
for (var b = window.location.search.substring(1), c = b.split("&"), d = 0; d < c.length; d++) {
/** @type {?} */
var e = c[d].split("=");
if (e[0] == a)
return e[1];
}
return null;
},
/**
* @param {?} a
* @return {?}
*/
validateEmail(a) {
return /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/.test(a);
},
/**
* @param {?} a
* @return {?}
*/
redirectTo(a) {
window.location.href = a;
},
/**
* @return {?}
*/
isCanvasSupported() {
/** @type {?} */
var a = document.createElement("canvas");
return !(!a.getContext || !a.getContext("2d"));
},
/**
* @return {?}
*/
isFormDataSupported() {
return true; //void 0 !== window["FormData"];
},
/**
* @param {?} a
* @param {?} b
* @param {?} c
* @return {?}
*/
getFileDownloadURL(a, b, c) {
switch (a.bucket) {
case this.CONST.QN_BUCKET.PUBLIC_IMAGE:
/** @type {?} */
var d = "";
/** @type {?} */
var e = a.thumb;
return (e &&
(d =
"?imageView2/" + e.mode + "/w/" + e.width + "/h/" + e.height),
b(this.CONFIG.HOST.IMAGE_HOST + "/" + a.qnKey + d));
case this.CONST.OSS_BUCKET.PUBLIC_IMAGE:
return b(this.CONFIG.HOST.OSS_IMAGE_HOST + "/" + a.ossKey);
case this.CONST.QN_BUCKET.PRIVATE_FILE:
default:
return c();
}
},
/**
* @param {?} a
* @return {?}
*/
evalFormula(a) {
/** @type {?} */
var b = [];
that.Utils.forEach(Object.keys(this.Formula), (/**
* @param {?} a
* @param {?} c
* @return {?}
*/
function (a, c) {
b.push(`let ${c}=fml.Formula.${c}`);
}));
/** @type {?} */
var it = b.join(";") + ";";
/** @type {?} */
var c = new Function(it + "return " + a)();
return c;
},
/**
* @param {?} b
* @param {?} c
* @return {?}
*/
createEntryAttributeField(b, c) {
/** @type {?} */
var d = {
id: c.entryId,
};
switch (b) {
case "ext":
this.extend(d, {
name: "ext",
type: "text",
text: "扩展字段",
items: c.extParams,
});
break;
case "createTime":
this.extend(d, {
name: "createTime",
type: "datetime",
format: "yyyy-MM-dd HH:mm:ss",
text: "提交时间",
});
break;
case "updateTime":
this.extend(d, {
name: "updateTime",
type: "datetime",
format: "yyyy-MM-dd HH:mm:ss",
text: "更新时间",
});
brea