# doc_method

class_name: kd.sdk.tmc.cfm.extpoint.common.IGetExtCfmBillLayoutInfoDev
method_name: getExtCfmBillLayoutInfoDev
param_types_key: String,String
signature_text:
default java.util.Map<String, String> getExtCfmBillLayoutInfoDev(String openEntityName, String loanType)

comment:
publicclassGetExtCfmBillLayoutInfoDevImplimplementsIGetExtCfmBillLayoutInfoDev {
public Map getExtCfmBillLayoutInfoDev(String openEntityName, String loanType) {
Mapresult=newHashMap<>(10);
//贷款,借款if ("direct".equals(loanType)) {
//合同,展期,还款,利息,提款,预提 ...switch (openEntityName) {
case"cfm_loancontractbill":
result.put("wkzb_cfm_loancontrac_ext", "直接融资合同");
return result;
case"cfm_loanbill":
result.put("wkzb_cfm_loanbill_ext", "直接融资提款");
return result;
case"cfm_repaymentbill":
result.put("wkzb_cfm_repaymentbill_ext", "直接融资还款");
return result;
case"cfm_interestbill":
result.put("wkzb_cfm_interestbill_ext", "直接融资利息");
return result;
case"cfm_preinterestbill":
result.put("wkzb_cfm_preinterestbill_ext", "直接融资预提");
return result;
}
} elseif ("other".equals(loanType)) {
//合同,展期,还款,利息,提款,预提 ...switch (openEntityName) {
case"cfm_loancontractbill":
result.put("wkzb_cfm_loancontrac_ext2", "其他融资合同");
return result;
case"cfm_loanbill":
result.put("wkzb_cfm_loanbill_ext2", "其他融资提款");
return result;
}
}
return result;
}
}
@param `openEntityName` 打开单据的实体类型
@param `loanType` 贷款类型
@return k:布局类型,v:布局实体名称


class_name: kd.sdk.tmc.cfm.extpoint.confirm.IConfirmListInterface
method_name: columnsName
param_types_key: String
signature_text: default String[] columnsName(String dataSource)
comment:
public String[] columnsName(String dataSource) {
if ("cfm".equals(dataSource)) {
returnnewString[]{"payintdate"};
}
returnnewString[0];
}
@param `dataSource` 借款确认=invest, 贷款确认=cfm
@return 二开增加的列名


class_name: kd.sdk.tmc.cfm.extpoint.confirm.IConfirmListInterface
method_name: resultObject
param_types_key: String,DynamicObject,Object[]
signature_text: default Object[] resultObject(String dataSource, DynamicObject row, Object[] objectArr)
comment:
public Object[] resultObject(String dataSource, DynamicObject row, Object[] objectArr) {
if (!"cfm".equals(dataSource)) {
return objectArr;
}
Object[] objects = Arrays.copyOf(objectArr, objectArr.length+1);
if ("interest".equals(objects[2])) {
objects[objectArr.length] = row.get("bizdate");
} else {
objects[objectArr.length] = null;
}
return objects;
}
@param `dataSource` 借款确认=invest, 贷款确认=cfm
@param `row` 查询出来的单据数据
@param `objectArr` 列表结果对象，根据 objectArr[2] 可判断行数据的业务确认类型
@return 列表结果对象


class_name: kd.sdk.tmc.cfm.extpoint.creditm.IApplyReturnCreditlimit
method_name: applyReturnCreditlimit
param_types_key: DynamicObject,DynamicObject,Map
signature_text:
default void applyReturnCreditlimit(DynamicObject bill, DynamicObject applyBill, java.util.Map<String, Object> map)

comment:
融资申请返还授信金额扩展
*
*   map.put("returnAmount", newBigDecimal("800"));
*   map.put("isLast", true);
*
*
@param `bill` 实际占用的单据（合同、提款）
@param `applyBill` 融资申请单（预占授信）
@return returnAmount-预占返还金额，isLast-全额返还 *


class_name: kd.sdk.tmc.cfm.extpoint.extapply.IExtApplyBillSecondDevFields
method_name: extApplyBillSecondDevFields
param_types_key: DynamicObject
signature_text: default java.util.Map<String, Object> extApplyBillSecondDevFields(DynamicObject extApplyBill)
comment:
publicclassextApplyBillSecondDevFieldsimplementsIExtApplyBillSecondDevFields {
public Map< String, Object> extApplyBillSecondDevFields(DynamicObject extApplyBill) {
//通过extApplyBill查询对应的字段属性
Map< String, Object> fieldMap = newHashMap<>(16);
//基本字段
fieldMap.put("tarprop", extApplyBill.get("srcprop"));
//基础资料
fieldMap.put("tarbanksdk", extApplyBill.getDynamicObject("scrbanksdk").getPkValue());
//多选基础资料DynamicObjectCollectionscrMulSdk= extApplyBill.getDynamicObjectCollection("scrmulsdk");
fieldMap.put("tarmulsdk", scrMulSdk.stream().map(o -> o.getDynamicObject("fbasedataid").getPkValue()).collect(Collectors.toList()));
return fieldMap;
}
}
@param `extApplyBill` 展期申请单据
@return java.util.Map 返回封装好的二开字段集合; key:目标单二开字段标识, value: 对应源单二开字段在源单上绑定的值


class_name: kd.sdk.tmc.cfm.extpoint.init.IInitBillSecondDevFields
method_name: initBillSecondDevFields
param_types_key: DynamicObject,DynamicObject
signature_text: default void initBillSecondDevFields(DynamicObject initBill, DynamicObject targetBill)
comment:
publicclassInitBillSecondDevFieldsimplementsIInitBillSecondDevFields {
publicvoidinitBillSecondDevFields(DynamicObject initBill, DynamicObject targetBill){
// 基本字段booleanextIsPay= initBill.getBoolean("ext_ispay");
targetBill.set("ext_ispay", extIsPay);
// 基础资料DynamicObjectextPaycurrency= initBill.getDynamicObject("ext_paycurrency");
targetBill.set("ext_paycurrency", extPaycurrency);
}
}
@param `initBill` 初始化单据
@param `targetBill` 目标单--合同/债券发行计划单


class_name: kd.sdk.tmc.cfm.extpoint.interestbill.IGetOtherIntBillPayAmtExt
method_name: getOtherIntBillPayAmtExt
param_types_key: Long
signature_text: default java.math.BigDecimal getOtherIntBillPayAmtExt(Long intBillId)
comment:
publicclassGetOtherIntBillPayAmtExtImplimplementsIGetOtherIntBillPayAmtExt {
public BigDecimal getOtherIntBillPayAmtExt(Long intBillId) {
//先查询DynamicObjectbizBill= BusinessDataServiceHelper.loadSingle("cfm_interestbill","ext_feeamt", newQFilter("id", QCP.equals, intBillId).toArray());
return bizBill.getBigDecimal("feeAmt");//获取其他利息单的可付款金额
}
}
@param `intBillId` 利息单Id
@return 额外的可付款金额


class_name: kd.sdk.tmc.cfm.extpoint.interestbill.ILoanIntBillBatchSecondDevFields
method_name: loanIntBillBatchSecondDevFields
param_types_key: DynamicObject,DynamicObject,DynamicObject
signature_text:
default void loanIntBillBatchSecondDevFields(DynamicObject batchIntBill, DynamicObject loanBillEntry, DynamicObject targetIntBill)

comment:
publicclassLoanIntBillBatchSecondDevFieldsimplementsILoanIntBillBatchSecondDevFields {
publicvoidloanIntBillBatchSecondDevFields(DynamicObject batchIntBill, DynamicObject loanBill, DynamicObject targetIntBill) {
// 基本字段booleanextIsPay= loanBill.getBoolean("ext_ispay");
targetIntBill.set("ext_ispay", extIsPay);
// 基础资料DynamicObjectextPaycurrency= loanBill.getDynamicObject("ext_paycurrency");
targetIntBill.set("ext_paycurrency", extPaycurrency);
}
}
@param `batchIntBill` 批量结息处理单 - 主单据
@param `loanBillEntry` 放款处理单 - 分录中的单据
@param `targetIntBill` 付息单 - 目标单据


class_name: kd.sdk.tmc.cfm.extpoint.loan.IUpdateLoanRateReset2Point
method_name: updateLoanRateReset2Point
param_types_key: DynamicObjectCollection,Long,String
comment: @param `rateAdjustEntry` 利率重置分录 @param `loanId` 提款单id @param `interestType` 利率类型
signature_text:
default void updateLoanRateReset2Point(DynamicObjectCollection rateAdjustEntry, Long loanId, String interestType)


class_name: kd.sdk.tmc.cfm.extpoint.preinst.IPreIntBillBatchSecondDevFields
method_name: preIntBillBatchSecondDevFields
param_types_key: DynamicObject,DynamicObject,DynamicObject
signature_text:
default void preIntBillBatchSecondDevFields(DynamicObject batchPreIntBill, DynamicObject loanBillEntry, DynamicObject targetPreIntBill)

comment:
publicclassPreIntBillBatchSecondDevFieldsimplementsIPreIntBillBatchSecondDevFields {
publicvoidpreIntBillBatchSecondDevFields(DynamicObject batchPreIntBill, DynamicObject loanBill, DynamicObject targetPreIntBill) {
// 基本字段booleanextIsPay= loanBill.getBoolean("ext_ispay");
targetPreIntBill.set("ext_ispay", extIsPay);
// 基础资料DynamicObjectextPaycurrency= loanBill.getDynamicObject("ext_paycurrency");
targetPreIntBill.set("ext_paycurrency", extPaycurrency);
}
}
@param `batchPreIntBill` 利息预提批量处理 - 主单据
@param `loanBillEntry` 放款处理单 - 分录中的单据
@param `targetPreIntBill` 预提单 - 目标单据


class_name: kd.sdk.tmc.cfm.extpoint.repay.IGetOtherRepayBillPayAmtExt
method_name: getOtherRepayBillPayAmtExt
param_types_key: Long
signature_text: default java.math.BigDecimal getOtherRepayBillPayAmtExt(Long repayBillId)
comment:
publicclassGetOtherRepayBillPayAmtExtImplimplementsIGetOtherRepayBillPayAmtExt {
@param `repayBillId` 还款单Id
@return 额外的可付款金额


class_name: kd.sdk.tmc.cfm.extpoint.repay.IRepayBillSecondDevFields
method_name: repayBillSecondDevFields
param_types_key: DynamicObject
signature_text: default java.util.Map<String, Object> repayBillSecondDevFields(DynamicObject repayBill)
comment:
Description: 还款处理的还本付息场景下二开字段封装到 Map 集合中
publicclassRepayBillSecondDevFieldsimplementsIRepayBillSecondDevFields {
public Map< String, Object> repayBillSecondDevFields(DynamicObject repayBill) {
//通过repayBill查询对应的字段属性
Map< String, Object> fieldMap = newHashMap<>(16);
//基本字段
fieldMap.put("tarprop", repayBill.get("srcprop"));
//基础资料
fieldMap.put("tarbanksdk", repayBill.getDynamicObject("scrbanksdk").getPkValue());
//多选基础资料DynamicObjectCollectionscrMulSdk= repayBill.getDynamicObjectCollection("scrmulsdk");
fieldMap.put("tarmulsdk", scrMulSdk.stream().map(o -> o.getDynamicObject("fbasedataid").getPkValue()).collect(Collectors.toList()));
return fieldMap;
}
}
@param `repayBill` 还款单
@return java.util.Map 返回封装好的二开字段集合; key:目标单二开字段标识, value: 对应源单二开字段在源单上绑定的值


class_name: kd.sdk.tmc.cfm.extpoint.repayapply.IRepayApplyBillSecondDevFields
method_name: repayApplyBillSecondDevFields
param_types_key: DynamicObject
signature_text: default java.util.Map<String, Object> repayApplyBillSecondDevFields(DynamicObject repayApplyBill)
comment:
Description: 还款申请支持下推封装二开字段扩展插件 Map 集合中
publicclassrepayApplyBillSecondDevFieldsimplementsIRepayApplyBillSecondDevFields {
public Map< String, Object> repayApplyBillSecondDevFields(DynamicObject repayApplyBill) {
//通过repayApplyBill查询对应的字段属性
Map< String, Object> fieldMap = newHashMap<>(16);
//基本字段
fieldMap.put("tarprop", repayApplyBill.get("srcprop"));
//基础资料
fieldMap.put("tarbanksdk", repayApplyBill.getDynamicObject("scrbanksdk").getPkValue());
//多选基础资料DynamicObjectCollectionscrMulSdk= repayApplyBill.getDynamicObjectCollection("scrmulsdk");
fieldMap.put("tarmulsdk", scrMulSdk.stream().map(o -> o.getDynamicObject("fbasedataid").getPkValue()).collect(Collectors.toList()));
return fieldMap;
}
}
@param `repayApplyBill` 还款申请单据
@return java.util.Map 返回封装好的二开字段集合; key:目标单二开字段标识, value: 对应源单二开字段在源单上绑定的值


class_name: kd.sdk.tmc.cfm.util.CostShareUtil
method_name: getCostShareList
param_types_key: FeeCostParam
signature_text:
public static java.util.List<FeeCostShareInfo> getCostShareList(FeeCostParam param) throws KDBizException

comment:
获取摊销明细
调用示例:
FeeCostParamparam=newkd.sdk.tmc.cfm.util.FeeCostParam();
//业务金额
param.setAmount(amount);
//业务金额-费用总额（异币别费用，需要按汇率转成业务币别）
param.setInitCcbAmt(initCcbAmt);
//息票率
param.setLoanRate(loanRate);
//计息基准：默认算头不算尾-headnotail/算尾不算头-noheadtail/算头又算尾-headtail/头尾都不算-noheadnotail
param.setBasis(basisEnum.getValue());
//币别精度
param.setAmtPrecision(amtPrecision);
//摊销方式：实际利率法-1 直线法-2
param.setShareType(shareType);
//头尾规则：默认算头不算尾-headnotail/算尾不算头-noheadtail/算头又算尾-headtail/头尾都不算-noheadnotail
param.setHtRule("");
//开始日期
param.setStartDate(DateUtils.stringToDate("2024-05-29", DateUtils.FORMAT_YMD));
//结束日期
param.setEndDate(DateUtils.stringToDate("2026-04-09", DateUtils.FORMAT_YMD));
//摊销频率：每日-day/每月-month/每季度-quarter/每半年-halfyear/每年-year
param.setShareFrequency("month");
ListcostShareList=  kd.sdk.tmc.cfm.util.CostShareUtil#getCostShareList(param)
@param `param` 摊销数据对象
@return 摊销明细
@throws `KDBizException `


class_name: kd.sdk.tmc.cim.extpoint.IReleaseApplyAutoReleaseSDKService
method_name: isAutoRelease
param_types_key: DynamicObject
signature_text: default boolean isAutoRelease(DynamicObject applyBill)
comment:
是否默认自动下推解活单，默认是true，二开可根据自己需求是否生成
publicclassDealReleaseApplyAutoPushimplementsIReleaseApplyAutoReleaseSDKService {
``
@param `applyBill` 存款解活申请单


class_name: kd.sdk.tmc.cim.extpoint.IReleasePushDptRevenue
method_name: getReleaseBillSecondFields
param_types_key: DynamicObject
signature_text: default java.util.Map<String, Object> getReleaseBillSecondFields(DynamicObject releaseBill)
comment:
解活单支持下推解活类型的收益单封装二开字段扩展插件 Map 集合中 在操作中OperateOption option中的key= SecondDevFieldVal，取出后再 Map secondDevFieldVal = JSON.parseObject("SecondDevFieldVal", Map.class)得到此方法返回map
publicclassDepositReleasePushDptRevenueimplementsIReleasePushDptRevenue{
``
@param `releaseBill` 解活单
@return 返回封装好的二开字段集合; key:目标单二开字段标识, value: 二开字段在源单上绑定的值


class_name: kd.sdk.tmc.creditm.extpoint.ICreditLimitExtInerface
method_name: getCredituseRate
param_types_key: Long,Long,Long,Date
signature_text:
default java.math.BigDecimal getCredituseRate(Long sourceCurrencyId, Long targetCurrencyId, Long orgId, java.util.Date date)

comment:
``
@param `sourceCurrencyId` 原币别ID
@param `targetCurrencyId` 目标币别ID
@param `orgId` 组织ID
@param `date` 日期
@return 汇率值


class_name: kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil
method_name: cancelCreditLimit
param_types_key: String
signature_text: public static String cancelCreditLimit(String info)
comment:
取消占用授信
调用示例:
CreditLimitInfoinfo=newCreditLimitInfo();
info.setXXX(XXX);
...
kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.cancelCreditLimit(SerializationUtils.toJsonString(info));
@param `info` SerializationUtils.toJsonString(CreditLimitInfo.class) 授信对象
@return SerializationUtils.toJsonString(CreditLimitInfo.class) 授信对象
@throws `KDBizException` 取消占用授信调用异常


class_name: kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil
method_name: cancelReturnCreditLimit
param_types_key: String
signature_text: public static String cancelReturnCreditLimit(String info)
comment:
取消返还授信
调用示例:
ReturnCreditLimitInfoinfo=newReturnCreditLimitInfo();
info.setXXX(XXX);
...
kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.cancelReturnCreditLimit(SerializationUtils.toJsonString(info));
@param `info` SerializationUtils.toJsonString(ReturnCreditLimitInfo.class) 返还授信对象
@return SerializationUtils.toJsonString(ReturnCreditLimitInfo.class) 返还授信对象
@throws `KDBizException` 取消返还授信调用异常


class_name: kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil
method_name: confirmCreditLimit
param_types_key: String
signature_text: public static String confirmCreditLimit(String info)
comment:
确认占用授信
调用示例:
CreditLimitInfoinfo=newCreditLimitInfo();
info.setXXX(XXX);
...
kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.confirmCreditLimit(SerializationUtils.toJsonString(info));
@param `info` SerializationUtils.toJsonString(CreditLimitInfo.class) 授信对象
@return SerializationUtils.toJsonString(CreditLimitInfo.class) 授信对象
@throws `KDBizException` 确认占用授信调用异常


class_name: kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil
method_name: returnCreditLimit
param_types_key: String
signature_text: public static String returnCreditLimit(String info)
comment:
返还授信
调用示例:
ReturnCreditLimitInfoinfo=newReturnCreditLimitInfo();
info.setXXX(XXX);
...
kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.returnCreditLimit(SerializationUtils.toJsonString(info));
@param `info` SerializationUtils.toJsonString(ReturnCreditLimitInfo.class) 返还授信对象
@return SerializationUtils.toJsonString(ReturnCreditLimitInfo.class) 返还授信对象
@throws `KDBizException` 返还授信调用异常


class_name: kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil
method_name: updateCreditLimitUse
param_types_key: String
signature_text: public static String updateCreditLimitUse(String info)
comment:
释放授信根据指定金额
调用示例:
CreditLimitUseBeaninfo=newCreditLimitUseBean();
info.setXXX(XXX);
...
kd.sdk.tmc.creditm.util.creditlimit.CreditLimitServiceUtil.updateCreditLimitUse(SerializationUtils.toJsonString(info));
@param `info` SerializationUtils.toJsonString(CreditLimitUseBean.class) 授信对象
@return SerializationUtils.toJsonString(CreditLimitUseBean.class) 授信对象
@throws `KDBizException` 释放授信根据指定金额调用异常


class_name: kd.sdk.tmc.ext.extpoint.committobe.IGenBankBillSDKService
method_name: extFillBankBill
param_types_key: String,List
signature_text:
java.util.Map<Long, java.util.Map<String, Object>> extFillBankBill(String entityName, java.util.List<DynamicObject> billList)

comment:
提交银企，单据生成银行单据，用于二开字段数据填充
扩展示例如下
package kd.sdk.tmc.ext.extpoint.committobe;
import kd.bos.dataentity.entity.DynamicObject;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
publicclassGenBankBillServiceimplementsIGenBankBillSDKService{
public Map< Long, Map< String, Object>> extFillBankBill(String entityName, List< DynamicObject> billList) {
Map< Long, Map< String, Object>> result = newHashMap<>();
switch (entityName){
case"付款单":
Map< String,Object> prop = newHashMap<>();
for(DynamicObject bill:billList) {
prop.put("exfield", "二开字段");
result.put(bill.getLong("id"), prop);
}
break;
}
return result;
}
}
@param `entityName` 单据实体名
@param `billList` 单据集合
@return Map< Long, Map< String, Object>>: key->银行单据id；value->二开字段名和值的键值对


class_name: kd.sdk.tmc.fbp.extpoint.IFeeDetailSaveAndSubmitAddFields
method_name: feeDetailSaveAndSubmitAddFields
param_types_key: DynamicObject,DynamicObject,DynamicObject
signature_text:
default void feeDetailSaveAndSubmitAddFields(DynamicObject feeBill, DynamicObject row, DynamicObject feeDetailRow)

comment:
业务单据费用明细页签二开新增字段后，需要在保存和提交操作中携带字段值保存到费用明细单据中 test:新加的字段
扩展示例如下
publicclassFeeDetailSecondDevFieldsimplementsIFeeDetailSaveAndSubmitAddFields {
publicvoidfeeDetailSaveAndSubmitAddFields(DynamicObject feeBill,DynamicObject row, DynamicObject feeDetailRow) {
//单头
feeBill.set("test",feeDetailRow.get("test"));
//分录
row.set("test",feeDetailRow.get("test"));
}
}
@param `feeBill` 费用明细单据
@param `row` 费用明细单据的分录行
@param `feeDetailRow` 业务单据的费用明细页签的要保存的行


class_name: kd.sdk.tmc.fbp.extpoint.IGetCustomSceneBillStatusSDKService
method_name: getCustomSceneStatusList
param_types_key: String,String
signature_text: java.util.List<String> getCustomSceneStatusList(String sceneStr, String entityName)
comment:
获取自定义的非在途/非在途的单据状态
publicclassGetCustomProcessStatusimplementsIGetCustomSceneBillStatusSDKService {
``
@param `entityName` 单据的标识


class_name: kd.sdk.tmc.fbp.extpoint.orgfilter.IFunderOrgPermissionExtDev
method_name: getDrawBillAuthOrgIdList
param_types_key: List,List,String,String
signature_text:
default java.util.List<Long> getDrawBillAuthOrgIdList(java.util.List<Long> srcAuthOrgIds, java.util.List<Long> tagAuthOrgIds, String srcEntity, String tagEntity)

comment:
得到选单有权限的组织集合
publicclassFunderOrgPermissionExtDevImplimplementsIFunderOrgPermissionExtDev {
public List getDrawBillAuthOrgIdList(List srcAuthOrgIds, List tagAuthOrgIds, String srcEntity, String tagEntity) {
if ("XXX".equals(srcEntity) && "YYY".equals(tagEntity)) {
//支持自定义根据不同的源单目标单来判断(特殊情况)return srcAuthOrgIds;
} elseif (srcAuthOrgIds != null && tagAuthOrgIds != null) {
//求交集return srcAuthOrgIds.stream().filter(tagAuthOrgIds::contains).collect(Collectors.toList());
//直接取目标单集合//return tagAuthOrgIds;
} else {
//直接取源单集合return srcAuthOrgIds;
}
}
}
@param `srcEntity` 源单实体
@param `srcAuthOrgIds` 有权限的源单的组织集合
@param `tagEntity` 目标实体
@param `tagAuthOrgIds` 有权限的目标实体组织结合


class_name: kd.sdk.tmc.fbp.extpoint.orgfilter.IFunderOrgPermissionExtDev
method_name: isCtrOrgPermissionExtDev
param_types_key: String
signature_text: default Boolean isCtrOrgPermissionExtDev(String entityName)
comment:
资金组织权限范围支持二开
publicclassFunderOrgPermissionExtDevImplimplementsIFunderOrgPermissionExtDev{
public Boolean isCtrOrgPermissionExtDev(String entityName){
DynamicObjectCollectionresult= QueryServiceHelper.query("ext_table", "id", newQFilter("entity", QCP.equals, entityName).toArray());
returnresult== null || result.isEmpty();
}
}
@param `entityName` 实体类型
@return true:需要标准的资金权限控制 false:不需要标准的资金组织权限控制


class_name: kd.sdk.tmc.fca.extpoint.IBalanceService
method_name: getBalanceAmount
param_types_key: String,Long,Long,Long
signature_text:
java.math.BigDecimal getBalanceAmount(String transferType, Long strategyId, Long accountId, Long currencyId)

comment:
Title: BalanceService.java
Description: 资金调度计算划拨金额，即时余额二开扩展
publicclassBalanceServiceimplementsIBalanceService {
``
@param `transferType` 划拨类型 UP上划，DOWN 下拨
@param `strategyId` 划拨策略ID
@param `accountId` 账户ID
@param `currencyId` 币别ID
@return 账户余额


class_name: kd.sdk.tmc.fca.extpoint.ITranSupBillVoucher
method_name: setIVoucher
param_types_key: DynamicObjectCollection
signature_text: default void setIVoucher(DynamicObjectCollection rows)
comment:
上划处理单凭证号扩展插件
package kd.tmc.fca.formplugin.transbill;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.entity.DynamicObjectCollection;
import kd.sdk.tmc.fca.extpoint.ITranSupBillVoucher;
publicclassTranSupBillVoucherimplementsITranSupBillVoucher {
**
**``**
@param `rows` 列表数据
@return void **扩展示例如下


class_name: kd.sdk.tmc.fcs.extpoint.paymonitor.IRelationShipJob
method_name: doExt
param_types_key: String,String,String
signature_text: void doExt(String srcObj, String destObj, String flag)
comment:
@param `srcObj` 源单查询对象
@param `destObj` 目标单查询对象：查询自身关系时有值，查询外部关系无值
@param `flag` 无关联关系结果标签："NotLink"-没有查到searchA的关联数据；"HasLinkButNotFound"-有查到关联数据，但是没有发现searchA与searchB存在关系


class_name: kd.sdk.tmc.fpm.extpoint.IInOutCollectSaveExt
method_name: inOutCollectEditFieldVal
param_types_key: List
signature_text: default void inOutCollectEditFieldVal(java.util.List<DynamicObject> dataEntityList)
comment:
收支计划采集单保存时，需要扩展修改内部往来字段反写的判断逻辑 test:新加的字段
扩展示例如下：
publicclassInOutCollectSaveExtimplementsIInOutCollectSaveExt {
publicvoidinOutCollectEditFieldVal(List dataEntityList) {
//单头
dataEntities.forEach(bill -> bill.set("innerinoutflag", Boolean.TRUE);
}
}
@param `dataEntityList` 收支计划采集单集合


class_name: kd.sdk.tmc.ifm.expoint.IGlAccountBalance
method_name: dealDailyGLBalanceSql
param_types_key: DynamicObject,String,String
signature_text: default String dealDailyGLBalanceSql(DynamicObject intObject, String periodStr, String flexIdStr)
comment:
期间凭证明细数据
* @code
*   sqlStr.append("select b.fentryid,b.faccountid,a.fbookeddate vdate,case when b.fentrydc = '1' then b.foriginaldebit else -1*b.foriginalcredit end amount ");
if (EmptyUtil.isNoEmpty(flexIdStr)) {
sqlStr.append("from t_gl_voucher a inner join t_gl_voucherentry b on a.fid = b.fid inner join t_gl_assist_bd c on c.fid = b.fassgrpid ");
sqlStr.append(" where  a.forgid = ? and a.fbooktypeid = ? and a.fperiodid in (%s) and a.Fbookeddate >= ? and a.Fbookeddate <= ? and b.faccountid = ? and b.fcurrencyid = ? ");
sqlStr.append(" and b.forgid = ? and b.fperiodid in (%s) and c.fvalue in (").append(flexIdStr).append( ")");
} else {
sqlStr.append("from t_gl_voucher a inner join t_gl_voucherentry b on a.fid = b.fid ");
sqlStr.append(" where a.forgid = ? and a.fbooktypeid = ? and a.fperiodid in (%s) and a.Fbookeddate >= ? and a.Fbookeddate <= ? and b.faccountid = ? and b.fcurrencyid = ? ");
sqlStr.append(" and b.forgid = ? and b.fperiodid in (%s)");
}
*
@param `intObject`
@param `periodStr`
@param `flexIdStr` ` *


class_name: kd.sdk.tmc.ifm.expoint.IGlAccountBalance
method_name: dealPeriodStartDateAndBalance
param_types_key: DynamicObject
signature_text: default java.util.Map<String, Object> dealPeriodStartDateAndBalance(DynamicObject intObject)
comment:
扩展修改期间初始余额和对应日期
* @code
Map map = new HashMap<>();
map.put("startDate", DateUtils.stringToDate("2024-01-01", DateUtils.FORMAT_YMD));
map.put("startBalance", new BigDecimal("0"));
*
@param `intObject` ` *


class_name: kd.sdk.tmc.ifm.expoint.IInstBalanceCalcSecondDev
method_name: getExtInstBalance
param_types_key: DynamicObject,DynamicObject,Date,Date
signature_text:
default java.util.List<kd.sdk.tmc.ifm.expoint.ExtPlanCallResult> getExtInstBalance(DynamicObject innerAcct, DynamicObject currency, java.util.Date beginDate, java.util.Date endDate)

comment:
活期计息利息计算余额封装二开处理
publicclassInstBalanceCalcSecondDevimplementsIInstBalanceCalcSecondDev {
@param `innerAcct` 余额信息列表
@param `currency` 币别
@param `beginDate` 开始日期
@param `endDate` 结束日期


class_name: kd.sdk.tmc.ifp.expoint.planedit.IPlanEditBasedataF7Filter2Dev
method_name: getExtBasedataQFilter
param_types_key: IDataModel,String,String
signature_text: default QFilter getExtBasedataQFilter(IDataModel model, String propKey, String baseDataType)
comment:
计划编制维度基础资料添加二开过滤条件
public QFilter getExtBasedataQFilter(IDataModel model, String propKey, String baseDataType) {
QFilterqFilter=null;
if ("bos_org".equals(baseDataType)) {
qFilter = newQFilter("id", QCP.in, "1");
}elseif("cfm_financingvarieties".equals(baseDataType)){
qFilter = newQFilter("isleaf", QCP.equals, "1");
}
return qFilter;
}
@param `model` 页面模型
@param `propKey` 字段属性
@param `baseDataType` 基础资料类型


class_name: kd.sdk.tmc.mon.extpoint.mobile.IMobileSecondaryDevCard
method_name: adjustCard
param_types_key: Map
signature_text: default java.util.Map<String, String> adjustCard(java.util.Map<String, String> cardMap)
comment:
调整 自定义首页卡片信息
扩展示例如下
publicclassMonMobileSecondaryDevCardTestimplementsIMobileSecondaryDevCard {
`
@param `cardMap` 调整前卡片信息
@return 调整后卡片 key:卡片元数据标识 value:标题


class_name: kd.sdk.tmc.mon.extpoint.mobile.IMobileSecondaryDevCard
method_name: adjustCardPerm
param_types_key: Map
signature_text: default java.util.Map<String, String> adjustCardPerm(java.util.Map<String, String> permMap)
comment:
调整 卡片权限
扩展示例如下
publicclassMonMobileSecondaryDevCardTestimplementsIMobileSecondaryDevCard {
`
@param `permMap` 调整前 卡片权限信息
@return 调整后卡片权限信息 key:卡片元数据标识 value:权限项


class_name: kd.sdk.tmc.mon.extpoint.mobile.IMobileSecondaryDevCard
method_name: adjustSubject
param_types_key: String,List
signature_text: default java.util.List<String> adjustSubject(String subject, java.util.List<String> cards)
comment:
调整 主题 卡片
扩展示例如下
publicclassMonMobileSecondaryDevCardTestimplementsIMobileSecondaryDevCard {
````
@param `subject` 主题标识 @see kd.tmc.mon.formplugin.mobile.card.SubjectEnum
@param `cards` 卡片集合


class_name: kd.sdk.tmc.mrm.extpoint.IExRateGapAnalysisService
method_name: dealExtField
param_types_key: DynamicObjectCollection
signature_text: default void dealExtField(DynamicObjectCollection treeEntry)
comment:
publicclassExRateGapAnalysisServiceimplementsIExRateGapAnalysisService {
``
@param `treeEntry` 汇率敞口分析报表树型单据体


class_name: kd.sdk.tmc.psd.extpoint.ICheckDefaultAccount
method_name: validate
param_types_key: PayScheduleInfo,DynamicObject
signature_text: default Boolean validate(PayScheduleInfo payScheduleInfo, DynamicObject defaultAccountInfo)
comment:
Title: TestGetDefaultAccount.java
Description: 自动排程或自动排票时，可以自定义默认账户
publicclassTestGetDefaultAccountimplementsICheckDefaultAccount {
``
@param `payScheduleInfo` 排程信息
@param `defaultAccountInfo` 默认账户信息


class_name: kd.sdk.tmc.psd.extpoint.IPayScheduleSelectBill
method_name: selectBills
param_types_key: SelectBillParam
signature_text: default java.util.Set<Long> selectBills(SelectBillParam selectBillParam)
comment:
排程选票 选票时机-背书付款：在标品自动排票规则之间加入自定义选票逻辑 步骤： 1，结算方式、金额、币别、票据到期日、是否直联票据过滤； 2，根据1的结果传入selectBills，获取接口返回的结果 3，根据2的结果进行最后的选票：金额优先/日期优先排序等
@param `selectBillParam` 选票入参
@return 票据id集合


class_name: kd.sdk.tmc.psd.extpoint.task.IAssemblySecondaryDevFields
method_name: assemblySecondaryDevFields
param_types_key: DynamicObject
signature_text: default java.util.Map<String, Object> assemblySecondaryDevFields(DynamicObject schebill)
comment:
排程处理单二开字段封装到 Map 集合中
扩展示例如下
import kd.bos.dataentity.entity.DynamicObject;
import java.util.HashMap;
import java.util.Map;
publicclassAssemblySecondaryDevFields_DemoimplementsIAssemblySecondaryDevFields {
public Map assemblySecondaryDevFields(DynamicObject schebill) {
MapfieldMap=newHashMap<>(16);
fieldMap.put("a1", schebill.getString("xxxx1"));
fieldMap.put("a2", schebill.getString("xxxx2"));
fieldMap.put("a3", schebill.getString("xxxx3"));
return fieldMap;
}
}
@param `schebill` 排程处理单动态对象
@return java.util.Map 返回封装好的二开字段集合; key:二开字段标识, value: 对应二开字段绑定的值


class_name: kd.sdk.tmc.tda.extpoint.arap.IArApTopCustSuppInterface
method_name: buildExtendFilter
param_types_key: String
signature_text: FilterFunction buildExtendFilter(String propertyName)
comment:
默认拓展示例如下
package kd.tmc.tda.report.arap.extpoint;
import kd.bos.algo.FilterFunction;
import kd.bos.algo.Row;
import kd.bos.dataentity.resource.ResManager;
import kd.sdk.tmc.tda.extpoint.arap.IArApTopCustSuppInterface;
publicclassArApTopCustSuppDefaultExtimplementsIArApTopCustSuppInterface {
// 客户名称字段privatestaticfinalStringCUSTOMER_FIELD="customername";
// 供应商名称字段privatestaticfinalStringSUPPLIER_FIELD="suppliername";
public FilterFunction buildExtendFilter(String propertyName) {
returnnewFilterFunction() {
publicbooleantest(Row row) {
StringcustomerName= row.getString(propertyName);
// 剔除包含特殊字符的客户if (customerName != null && CUSTOMER_FIELD.equals(propertyName)) {
return !customerName.contains(getSpecialChar0()) && !customerName.contains(getSpecialChar1()) &&
!customerName.contains(getSpecialChar2()) && !customerName.contains(getSpecialChar3()) &&
!customerName.contains(getSpecialChar5());
} elseif (customerName != null && SUPPLIER_FIELD.equals(propertyName)) {   // 剔除包含特殊字符的供应商return !customerName.contains(getSpecialChar0()) && !customerName.contains(getSpecialChar1()) &&
!customerName.contains(getSpecialChar2()) && !customerName.contains(getSpecialChar3()) &&
!customerName.contains(getSpecialChar4());
}
returnfalse;
}
};
}
private String getSpecialChar0() {
return ResManager.loadKDString("0万", "ArApTopCustSuppDefaultExt_0", "tmc-tda-report");
}
private String getSpecialChar1() {
return ResManager.loadKDString("其他", "ArApTopCustSuppDefaultExt_1", "tmc-tda-report");
}
private String getSpecialChar2() {
return ResManager.loadKDString("外部", "ArApTopCustSuppDefaultExt_2", "tmc-tda-report");
}
private String getSpecialChar3() {
return ResManager.loadKDString("客户", "ArApTopCustSuppDefaultExt_3", "tmc-tda-report");
}
private String getSpecialChar4() {
return ResManager.loadKDString("供应商", "ArApTopCustSuppDefaultExt_4", "tmc-tda-report");
}
private String getSpecialChar5() {
return ResManager.loadKDString("收入", "ArApTopCustSuppDefaultExt_5", "tmc-tda-report");
}
}
@param `propertyName` 客户：customername 供应商：suppliername
@return 过滤器


class_name: kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctByBankInterfaceRPA
method_name: queryRPADataSet
param_types_key: Map
signature_text: DataSet queryRPADataSet(java.util.Map<String, Object> param)
comment:
通过银行账户ID查询对应账户绑定RPA个数
默认扩展示例如下
package kd.tmc.tda.report.bankacct.extpoint;
import kd.bos.algo.DataSet;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.bos.servicehelper.QueryServiceHelper;
import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctByBankInterfaceRPA;
import java.util.List;
import java.util.Map;
publicclassBankInterfaceRPATestExtimplementsIBankAcctByBankInterfaceRPA {
public DataSet queryRPADataSet(Map param) {
ListacctIds= (List) param.get("acctIds");
// 默认通过网银登录信息维护银行账户RPA数据，则查询元数据标识 bcr_bankudsetDataSetrpaDataSet= QueryServiceHelper.queryDataSet("BankAcctByBankInterfaceSum", "bcr_bankudset",
"entry.acctbank acct_id", newQFilter[]{newQFilter("entry.acctbank", QCP.in, acctIds)}, null);
DataSetrpaCountSet= rpaDataSet.groupBy(newString[]{"acct_id"}).countDistinct(newString[]{"acct_id"}, "rpa_count").finish();
return rpaCountSet;
}
}
@param `param` Map key：acctIds，value：需要查询的银行账户ID集合
@return DataSet。共两列，列名依次为：acct_id（银行账户ID）、rpa_count（RPA个数）


class_name: kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface
method_name: detailColumnItemsExt
param_types_key: List
signature_text: default java.util.List<Object[]> detailColumnItemsExt(java.util.List<Object[]> fieldColumns)
comment:
账户明细表字段列扩展 扩展报表列，其中fieldKey与明细DataSet中fieldname相对应；列名称为多语言文本；可根据需要设置列数据类型
默认扩展示例如下
package kd.tmc.tda.report.bankacct.extpoint;
import kd.bos.algo.DataSet;
import kd.bos.dataentity.entity.LocaleString;
import kd.bos.dataentity.resource.ResManager;
import kd.bos.entity.report.AbstractReportColumn;
import kd.bos.entity.report.ReportColumn;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
import java.util.List;
publicclassBankAcctInterfaceDefaultExtimplementsIBankAcctInterface {
public List detailColumnItemsExt(List fieldColumns) {
fieldColumns.add(newObject[]{"fieldKey", ResManager.loadKDString("列名称", "AcctDetailDataListPlugin_20", "tmc-tda-report"), ReportColumn.TYPE_TEXT, false,});
fieldColumns.add(newObject[]{"fieldKey", ResManager.loadKDString("列名称", "AcctDetailDataListPlugin_20", "tmc-tda-report"), ReportColumn.TYPE_TEXT, false,});
return fieldColumns;
}
}
@param `fieldColumns`
@return 扩展后的明细报表列


class_name: kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface
method_name: metadataSignExt
signature_text: default String metadataSignExt()
comment:
账户运营元数据扩展 默认查询bd_accountbanks（银行账户），有特殊账户查询场景时需替换元数据标识即可。
默认扩展示例如下
package kd.tmc.tda.report.bankacct.extpoint;
import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
publicclassBankAcctInterfaceDefaultExtimplementsIBankAcctInterface {
public String metadataSignExt() {
// 账户查询元数据return am_accountbank;
}
}
@return 元数据标识字符串


class_name: kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface
method_name: qFilterExt
param_types_key: QFilter
signature_text: default QFilter qFilterExt(QFilter qFilter)
comment:
账户查询过滤条件扩展 在原有QFilter的基础上扩展自定义QFilter
默认扩展示例如下
package kd.tmc.tda.report.bankacct.extpoint;
import kd.bos.algo.DataSet;
import kd.bos.dataentity.entity.LocaleString;
import kd.bos.dataentity.resource.ResManager;
import kd.bos.entity.report.AbstractReportColumn;
import kd.bos.entity.report.ReportColumn;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
import java.util.List;
publicclassBankAcctInterfaceDefaultExtimplementsIBankAcctInterface {
public QFilter qFilterExt(QFilter qFilter) {
return qFilter.and("1", QCP.equals, 1);
}
}
@param `qFilter`
@return 扩展后的qFilter


class_name: kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface
method_name: reportColumnsExt
param_types_key: List
signature_text:
default java.util.List<AbstractReportColumn> reportColumnsExt(java.util.List<AbstractReportColumn> columns)

comment:
报表列扩展 用于动态创建报表列，列标识fieldKey与报表数据DataSet中fieldname相对应
默认扩展示例如下
package kd.tmc.tda.report.bankacct.extpoint;
import kd.bos.algo.DataSet;
import kd.bos.dataentity.entity.LocaleString;
import kd.bos.dataentity.resource.ResManager;
import kd.bos.entity.report.AbstractReportColumn;
import kd.bos.entity.report.ReportColumn;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
import java.util.List;
publicclassBankAcctInterfaceDefaultExtimplementsIBankAcctInterface {
public List reportColumnsExt(List columns) {
columns.add(createColumn("fieldKey", "动态测试列", false));
return columns;
}
private ReportColumn createColumn(String fieldKey, String caption, boolean isHide) {
ReportColumnreportColumn=newReportColumn();
// 列标识
reportColumn.setFieldKey(fieldKey);
// 报表列数据类型
reportColumn.setFieldType(ReportColumn.TYPE_INTEGER);
// 列值为0是否显示
reportColumn.setZeroShow(true);
// 列名称
reportColumn.setCaption(newLocaleString(caption));
// 列是否隐藏
reportColumn.setHide(isHide);
return reportColumn;
}
}
@param `columns`
@return 扩展后的columns


class_name: kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface
method_name: selectFieldsExt
signature_text: default String selectFieldsExt()
comment:
账户查询字段扩展 自定义扩展字段，也可对查询字段重命名，形如：field1 as fd1
默认扩展示例如下
package kd.tmc.tda.report.bankacct.extpoint;
import kd.bos.algo.DataSet;
import kd.bos.dataentity.entity.LocaleString;
import kd.bos.dataentity.resource.ResManager;
import kd.bos.entity.report.AbstractReportColumn;
import kd.bos.entity.report.ReportColumn;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.sdk.tmc.tda.extpoint.bankacct.IBankAcctInterface;
import java.util.List;
publicclassBankAcctInterfaceDefaultExtimplementsIBankAcctInterface {
public String selectFieldsExt() {
return"field1 as fd1, field2";
}
}
@return 查询字段字符串，以英文逗号分隔


class_name: kd.sdk.tmc.tda.extpoint.bankacct.IParentAcctInterface
method_name: getParentAcct
param_types_key: Map
signature_text: java.util.List<Long> getParentAcct(java.util.Map<String, Object> param)
comment:
通过组织视图获取所有母账户id
默认扩展示例如下
package kd.tmc.tda.report.bankacct.extpoint;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.tmc.fbp.common.helper.TmcDataServiceHelper;
import kd.tmc.fbp.common.helper.TmcOrgDataHelper;
import kd.tmc.fbp.common.util.EmptyUtil;
import kd.tmc.tda.common.propertys.DecisionAnlsVersionProp;
import kd.sdk.tmc.tda.extpoint.bankacct.IParentAcctInterface;
publicclassParentAcctDefaultExtimplementsIParentAcctInterface {
public List getParentAcct(Map paramMap) {
ListacctIds=newArrayList<>();
LongorgviewId= ((DynamicObject) paramMap.get(DecisionAnlsVersionProp.ORGVIEW)).getLong("id");
LongorgId= ((DynamicObject) paramMap.get(DecisionAnlsVersionProp.ORG)).getLong("id");
ListorgIds=  TmcOrgDataHelper.getAllSubordinateOrgs(orgviewId, Collections.singletonList(orgId), true);
QFilterfilter=newQFilter("company", QCP.in, orgIds);
DynamicObject[] accts = TmcDataServiceHelper.load("fca_acctgroup","id",filter.toArray());
if(EmptyUtil.isNoEmpty(accts)) {//查出组织视图下的所有母账户
acctIds = Arrays.stream(accts).map(p->p.getLong("id")).collect(Collectors.toList());
}
return acctIds;
}
}
@param `param` Map key：orgview，value：组织视图对象
@return List所有的母账户id集合


class_name: kd.sdk.tmc.tda.extpoint.cash.ICashCommonSourceReBuildInterface
method_name: rebuildDataSet
param_types_key: DataSet
signature_text: DataSet rebuildDataSet(DataSet sources)
comment:
决策分析头寸公共取数扩展接口
默认扩展示例如下
package kd.tmc.tda.report.bankacct.extpoint;
import kd.bos.algo.DataSet;
import kd.sdk.tmc.tda.extpoint.cash.ICashCommonSourceReBuildInterface;
import kd.tmc.fbp.common.helper.DataSetHelper;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
importstatic kd.tmc.fbp.common.enums.CashTypeEnum.ACCOUNT;
importstatic kd.tmc.fbp.common.enums.CashTypeEnum.STRUCT;
publicclassCashCommonSourceReBuildDefaultExtimplementsICashCommonSourceReBuildInterface {
``
@param `sources` DataSet 标准产品公共取数的结果集
@return DataSet 二开根据业务重新扩展调整后结果集


class_name: kd.sdk.tmc.tda.extpoint.cash.ICashConcentrationDataFocusTypeInterface
method_name: rebuildFocusType
param_types_key: String,Row
signature_text: String rebuildFocusType(String focusType, Row row)
comment:
决策分析资金集中集团归集资金扩展接口 可根据row中返回结果，支持现场将非结算中心组织的母账户剔除
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.cash;
import kd.bos.algo.Row;
publicclassCashConcentrationDataFocusTypeInterfaceExtimplementsICashConcentrationDataFocusTypeInterface {
``
@param `focusType` 资金集中的类型
@param `row` 数据返回结果


class_name: kd.sdk.tmc.tda.extpoint.cash.ICashDistributionByAreaTopNumInterface
method_name: getTopCountryNum
signature_text: default int getTopCountryNum()
comment:
决策分析头寸按区域分布显示前N个国家地区 默认15
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.cash;
import kd.sdk.tmc.tda.extpoint.cash.ICashDistributionByAreaTopNumInterface;
publicclassCashDistributionByAreaTopNumExtimplementsICashDistributionByAreaTopNumInterface{
`
@return topNum


class_name: kd.sdk.tmc.tda.extpoint.cash.ICashDistributionByAreaTopNumInterface
method_name: getTopProvinceNum
signature_text: default int getTopProvinceNum()
comment:
决策分析头寸按区域分布显示前N个省份
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.cash;
import kd.sdk.tmc.tda.extpoint.cash.ICashDistributionByAreaTopNumInterface;
publicclassCashDistributionByAreaTopNumExtimplementsICashDistributionByAreaTopNumInterface{
```
@return topNum


class_name: kd.sdk.tmc.tda.extpoint.credit.ICreditGetDataInterface
method_name: getTdaCreditExtendFilter
param_types_key: QFilter
signature_text: QFilter getTdaCreditExtendFilter(QFilter qFilter)
comment:
查询授信额度自定义条件
默认扩展示例如下
package kd.tmc.tda.report.credit.extpoint;
import kd.bos.orm.query.QFilter;
import kd.sdk.tmc.tda.extpoint.credit.ICreditGetDataInterface;
publicclassCreditGetDataDefaultExtimplementsICreditGetDataInterface {
public QFilter getTdaCreditExtendFilter(QFilter qFilter) {
// 返回自定义的QFilterreturn qFilter.and("1", QCP.equals, 1);
}
}
@return 自定义条件


class_name: kd.sdk.tmc.tda.extpoint.finance.IFinanceDataFilter
method_name: getFilter
signature_text: String getFilter()
comment:
决策分析融资统一取数过滤企业借款
默认扩展示例如下
package kd.tmc.tda.common.extpoint;
import kd.sdk.tmc.tda.extpoint.finance.IFinanceDataFilter;
publicclassFinanceDataExcludeCompanyimplementsIFinanceDataFilter {
public String getFilter() {
return"financetype != 2";
}
}
@return String dataset过滤条件


class_name: kd.sdk.tmc.tda.extpoint.finance.IFinanceLeaseSourceInterface
method_name: getFormId
signature_text: String getFormId()
comment:
决策分析融资租赁取数源表单标识拓展
默认扩展示例如下
package kd.tmc.tda.common.extpoint;
import kd.sdk.tmc.tda.extpoint.finance.IFinanceLeaseSourceInterface;
publicclassFinanceLeaseSourceDefaultExtimplementsIFinanceLeaseSourceInterface {
public String getFormId() {
return"fa_lease_contract";
}
}
@return String 融资租赁取数表单标识


class_name: kd.sdk.tmc.tda.extpoint.finance.IFinanceSourceReBuildInterface
method_name: rebuildDataSet
param_types_key: DataSet[]
signature_text: DataSet[] rebuildDataSet(DataSet[] sources)
comment:
决策分析融资分析集团内财务公司数据和融资租赁数据源重新分组扩展接口
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.finance;
import kd.bos.algo.DataSet;
publicclassFinanceSourceReBuildDefaultExtimplementsIFinanceSourceReBuildInterface {
public DataSet[] rebuildDataSet(DataSet[] sources) {
//财务公司DataSetfinComDataSet= sources[0];
//融资租赁DataSetleaseDataSet= sources[1];
//将财务公司中要移到招商租赁的数据分割出来 ("billno = '融资租赁单据标号'")这个条件现场自己根据业务写
DataSet[] splitDataSet = finComDataSet.splitByFilter(newString[]{"billno = '融资租赁单据标号'"}, true);
//分割出来的融资租赁数据DataSetleaseExtDataSet= splitDataSet[0];
//分割后剩下的财务公司的数据DataSetnewFinComDataSet= splitDataSet[1];
//重新合并融资租赁数据DataSetnewLeaseDataSet= leaseDataSet.union(leaseExtDataSet);
returnnewDataSet[]{newFinComDataSet, newLeaseDataSet};
}
}
@param `sources` DataSet[] 第一个DataSet是财务公司数据源，第二个DataSet是融资租赁分组的数据源
@return DataSet[] 重新分组后结果，第一个是财务公司数据DataSet和第二个是融资租赁数据DataSet


class_name: kd.sdk.tmc.tda.extpoint.interloan.IInterLoanDetailInterface
method_name: detailColumnItemsExt
param_types_key: List
signature_text: default java.util.List<Object[]> detailColumnItemsExt(java.util.List<Object[]> fieldColumns)
comment:
企业借贷明细报表列扩展 扩展报表列，其中fieldKey与明细DataSet中fieldname相对应；列名称为多语言文本；可根据需要设置列数据类型
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.interloan;
import kd.bos.algo.DataSet;
import kd.bos.algo.Row;
import kd.bos.dataentity.resource.ResManager;
import kd.bos.entity.report.ReportColumn;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.bos.servicehelper.QueryServiceHelper;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
publicclassInterLoanInterfaceDefaultExtimplementsIInterLoanDetailInterface {
public List detailColumnItemsExt(List fieldColumns) {
fieldColumns.add(newObject[]{"billno", ResManager.loadKDString("单据编号", "FinanceDetailDataListPlugin_1", "tmc-tda-report"), ReportColumn.TYPE_TEXT, false});
fieldColumns.add(newObject[]{"contractno", ResManager.loadKDString("合同编号", "FinanceDetailDataListPlugin_2", "tmc-tda-report"), ReportColumn.TYPE_TEXT, false});
return fieldColumns;
}
}
@param `fieldColumns`
@return 扩展后的明细报表列


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface
method_name: addSelectorFields
param_types_key: List
signature_text: default java.util.List<String> addSelectorFields(java.util.List<String> fields)
comment:
增加的字段
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
import kd.bos.dataentity.entity.DynamicObject;
import kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface;
import java.math.BigDecimal;
import java.math.RoundingMode;
publicclassLiquidityCalculateDefaultExtimplementsILiquidityCalculateInterface {
public List addSelectorFields(List fields) {
fields.add("duesixmonthamt");
fields.add("fundduesixmthratio");
fields.add("duesixmonthratio");
returnnull;
}
}


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface
method_name: monthDebtExt
signature_text: default java.util.Map<Integer, java.util.Map<String, String>> monthDebtExt()
comment:
扩展的n个月内有息债务指标 key：月份 value：字段名（n个月内到期有息债务、n个月内到期债务占比、货币资金对n个月内到期债务覆盖倍数）
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
import kd.bos.dataentity.entity.DynamicObject;
import kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface;
import java.math.BigDecimal;
import java.math.RoundingMode;
publicclassLiquidityCalculateDefaultExtimplementsILiquidityCalculateInterface {
public Map<Integer, Map<String, String>> monthDebtExt() {
Map<Integer, Map<String, String>> map = newHashMap<>();
Map<String, String> monthMap = newHashMap<>();
monthMap.put(LiquidityExtProp.MONTHDEBTAMT, "duesixmonthamt");
monthMap.put(LiquidityExtProp.FUNDDUEMTHRATIO, "fundduesixmthratio");
monthMap.put(LiquidityExtProp.DUEMONTHRATIO, "duesixmonthratio");
map.put(6, monthMap);
return map;
}
}
</pre>


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface
method_name: resetCalculationFormula
param_types_key: DynamicObject
signature_text: DynamicObject resetCalculationFormula(DynamicObject liquidityBill)
comment:
重新设置流动性指标计算公式
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
import kd.bos.dataentity.entity.DynamicObject;
import kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityCalculateInterface;
import java.math.BigDecimal;
import java.math.RoundingMode;
publicclassLiquidityCalculateDefaultExtimplementsILiquidityCalculateInterface {
privatefinalintDEFAULT_SCALE=10;
public DynamicObject resetCalculationFormula(DynamicObject liquidityBill) {
// 资产BigDecimalassetsAmt= liquidityBill.getBigDecimal(LiquidityBillProp.ASSETSAMT);
// 负债BigDecimaldebtAmt= liquidityBill.getBigDecimal(LiquidityBillProp.DEBTAMT);
// 有息负债率 = 有息负债/负债BigDecimalintDebtRate= EmptyUtil.isEmpty(debtAmt) ? BigDecimal.ZERO : intDebtAmt.divide(debtAmt, DEFAULT_SCALE, RoundingMode.HALF_UP);
liquidityBill.set(LiquidityBillProp.INTDEBTRATE, intDebtRate);
return liquidityBill;
}
}
@return 流动性对象


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityIndicatorDetailInterface
method_name: addColumns
param_types_key: List
signature_text: default java.util.List<Object[]> addColumns(java.util.List<Object[]> fields)
comment:
增加的指标数据
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
publicclassILiquidityIndicatorDetailInterfaceExtimplementsILiquidityIndicatorDetailInterface {
public List<Object[]> addColumns(List<Object[]> fields) {
fields.add(newObject[]{"duesixmonthamt", ResManager.loadKDString("6个月内到期有息债务", "LiquidityIndicatorQingDataListPlugin_7", "tmc-tda-report"), QingFieldType.Number.toNumber(), false});
fields.add(newObject[]{"fundduesixmthratio", ResManager.loadKDString("货币资金对6个月内到期债务覆盖倍数", "LiquidityIndicatorQingDataListPlugin_7", "tmc-tda-report"), QingFieldType.Number.toNumber(), false});
fields.add(newObject[]{"duesixmonthratio", ResManager.loadKDString("6个月内到期债务占比", "LiquidityIndicatorQingDataListPlugin_7", "tmc-tda-report"), QingFieldType.Number.toNumber(), false});
return fields;
}
}
</pre>
@param `fields`


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityIndicatorDetailInterface
method_name: resetGetAmountFields
param_types_key: Set
signature_text: java.util.Set<String> resetGetAmountFields(java.util.Set<String> set)
comment:
流动性分析明细数据扩展-单位换算 需要切换单位的添加set
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
publicclassILiquidityIndicatorDetailInterfaceExtimplementsILiquidityIndicatorDetailInterface {
public Set resetGetAmountFields(Set set) {
set.add("intfeeamt");
return set;
}
}
@return String[]


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityIndicatorDetailInterface
method_name: resetIndicatorCountZeroFields
param_types_key: Set
signature_text: java.util.Set<String> resetIndicatorCountZeroFields(java.util.Set<String> set)
comment:
流动性分析明细数据扩展-预处理防呆 扩展往set内添加扩展元素 此处格式化字段名称为resetIndicatorExpansion接口写入的扩展字段及别名
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
import java.util.Set;
publicclassILiquidityIndicatorDetailInterfaceExtimplementsILiquidityIndicatorDetailInterface {
public Set resetIndicatorCountZeroFields(Set set) {
set.add("intfeeamt");
set.add("intfeeamtyear");
set.add("intfeeamtmonth");
return set;
}
}
@return set集合


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityIndicatorDetailInterface
method_name: resetIndicatorExpansion
param_types_key: Map
signature_text:
java.util.Map<String, java.util.List<String>> resetIndicatorExpansion(java.util.Map<String, java.util.List<String>> liquidityMap)

comment:
流动性分析明细数据扩展-扩展基础字段、同比、环比 扩展需要添加的位置 此处扩展字段,同比别名为:xxx+year,环比别名为:xxx+month
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
publicclassILiquidityIndicatorDetailInterfaceExtimplementsILiquidityIndicatorDetailInterface {
public  Map> resetIndicatorExpansion(Map> liquidityMap){
//扩展字段所需集合 无需更改ListextFieldList= liquidityMap.get("dataSets1");
ListextFieldYear1List= liquidityMap.get("dataSetsYear1");
ListextFieldYear2List= liquidityMap.get("dataSetsYear2");
ListextFieldMonthList= liquidityMap.get("dataSetsMonth2");
//扩展需要添加的位置 基础字段 以利息支出intfeeamt为例
extFieldList.add("intfeeamt");
//扩展同比 使用基础字段加别名的方式 别名为基础字段+year 以利息支出intfeeamt为例
extFieldYear1List.add("intfeeamt intfeeamtyear");
//扩展同比 基础字段 基础字段别名
extFieldYear2List.add("intfeeamt");
extFieldYear2List.add("intfeeamtyear");
//扩展环比 使用基础字段加别名的方式 别名为基础字段+month
extFieldMonthList.add("intfeeamt intfeeamtmonth");
//扩展后重新赋值 无需更改
liquidityMap.put("dataSets1",extFieldList);
liquidityMap.put("dataSetsYear1",extFieldYear1List);
liquidityMap.put("dataSetsYear2",extFieldYear2List);
liquidityMap.put("dataSetsMonth2",extFieldMonthList);
return liquidityMap;
}
}
@return String[]


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityIndicatorDetailInterface
method_name: resetIndicatorFieldsBigFormat
param_types_key: String[]
signature_text: String[] resetIndicatorFieldsBigFormat(String[] files)
comment:
流动性分析明细数据扩展-数值类型格式化 扩展往数组内添加扩展元素
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
import java.util.ArrayList;
import java.util.Arrays;
publicclassILiquidityIndicatorDetailInterfaceExtimplementsILiquidityIndicatorDetailInterface {
public String[] resetIndicatorFieldsBigFormat(String[] files) {
List strList= newArrayList<>(Arrays.asList(files));
//格式化基础字段
strList.add("intfeeamt");
return strList.toArray(newString[0]);
}
}
@return String[]


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityIndicatorDetailInterface
method_name: resetIndicatorFieldsSrFormat
param_types_key: String[]
signature_text: String[] resetIndicatorFieldsSrFormat(String[] files)
comment:
流动性分析明细数据扩展-百分比格式化 扩展往数组内添加扩展元素 此处格式化字段名称为resetIndicatorExpansion接口写入的扩展字段及别名
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
import java.util.ArrayList;
import java.util.Arrays;
publicclassILiquidityIndicatorDetailInterfaceExtimplementsILiquidityIndicatorDetailInterface {
public String[] resetIndicatorFieldsSrFormat(String[] files) {
List strList= newArrayList<>(Arrays.asList(files));
//格式化同比环比
strList.add("intfeeamtyear");
strList.add("intfeeamtmonth");
return strList.toArray(newString[0]);
}
}
@return String[]


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityIndicatorDetailInterface
method_name: resetIndicatorFiles
param_types_key: String[]
signature_text: String[] resetIndicatorFiles(String[] files)
comment:
流动性分析明细数据扩展-扩展字段列 扩展往数组内添加扩展元素
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
import java.util.ArrayList;
import java.util.Arrays;
publicclassILiquidityIndicatorDetailInterfaceExtimplementsILiquidityIndicatorDetailInterface {
public String[] resetIndicatorFiles(String[] files) {
ListstrList=newArrayList<>(Arrays.asList(files));
//流动性指标明细扩展数值列
strList.add("intfeeamt");
return strList.toArray(newString[0]);
}
}
@return String[]


class_name: kd.sdk.tmc.tda.extpoint.liquidity.ILiquidityIndicatorDetailInterface
method_name: resetIndicatorStr
param_types_key: String
signature_text: String resetIndicatorStr(String files)
comment:
流动性分析明细数据扩展-扩展列表查询拼接 扩展往数组内添加扩展元素
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.liquidity;
publicclassILiquidityIndicatorDetailInterfaceExtimplementsILiquidityIndicatorDetailInterface {
public String resetIndicatorStr(String files) {
//扩展的基础字段select拼接
files = files +", intfeeamt";
return files;
}
}
@return String[]


class_name: kd.sdk.tmc.tda.extpoint.note.IDraftBillDecisionRptInterface
method_name: getDraftBillEntityName
param_types_key: String
signature_text: String getDraftBillEntityName(String entityName)
comment:
决策分析票据管理替换标准产品的票据实体
默认扩展示例如下
package kd.tmc.tda.report.note.extpoint;
import kd.sdk.tmc.tda.extpoint.note.IDraftBillDecisionRptInterface;
import kd.tmc.fbp.common.constant.TmcEntityConst;
publicclassDraftBillDecisionRptDefaultExtimplementsIDraftBillDecisionRptInterface {
public String getDraftBillEntityName(String entityName) {
StringdraftBillEntityName= entityName == null ? "" : entityName;
switch (draftBillEntityName) {
case TmcEntityConst.CDM_RECEIVABLEBILL:
// 收票登记
draftBillEntityName = TmcEntityConst.CDM_RECEIVABLEBILL;
break;
case TmcEntityConst.CDM_PAYABLEBILL:
// 开票登记
draftBillEntityName = TmcEntityConst.CDM_PAYABLEBILL;
break;
case TmcEntityConst.CDM_DRAFTTRADEBILL:
// 业务处理
draftBillEntityName = TmcEntityConst.CDM_DRAFTTRADEBILL;
break;
default:
}
return draftBillEntityName;
}
}
@param `entityName` ：源票据名称` 应收票据：cdm_receivablebill； 应付票据：cdm_payablebill； 业务处理单据：cdm_drafttradebill
@return 二开票据实体名称


class_name: kd.sdk.tmc.tda.extpoint.settle.IBigAmountCommonSourceReBuildInterface
method_name: rebuildDataSet
param_types_key: DataSet
signature_text: DataSet rebuildDataSet(DataSet sources)
comment:
决策分析大额流入流出取数扩展接口
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.settle;
import kd.bos.algo.DataSet;
publicclassBigAmountCommonSourceReBuildInterfaceimplementsIBigAmountCommonSourceReBuildInterface {
``
@param `sources` DataSet 标准产品公共取数的结果集
@return DataSet 二开根据业务重新扩展调整后结果集


class_name: kd.sdk.tmc.tda.extpoint.settle.IBigAmountDataInterface
method_name: getExtendFilter
signature_text: QFilter getExtendFilter()
comment:
取交易明细数据自定义条件
默认扩展示例如下
package kd.tmc.tda.mservice.settle.extpoint;
import kd.bos.orm.query.QFilter;
import kd.sdk.tmc.tda.extpoint.settle.IBigAmountDataInterface;
publicclassBigAmountDataDefaultExtimplementsIBigAmountDataInterface {
public QFilter getExtendFilter() {
// 返回自定义的QFilterreturn QFilter.of("1=1");
}
}
@return 自定义条件


class_name: kd.sdk.tmc.tda.extpoint.synthesis.ISynthesisLoadDataInterface
method_name: getExtendProjectName
param_types_key: String
signature_text: String getExtendProjectName(String projectValue)
comment:
综合分析项目名称二开扩展
默认扩展示例如下
package kd.tmc.tda.mservice.synthesis.extpoint;
import kd.sdk.tmc.tda.extpoint.synthesis.ISynthesisLoadDataInterface;
publicclassSynthesisLoadDataDefaultExtimplementsISynthesisLoadDataInterface {
public String getExtendProjectName(String projectValue) {
// 修改后的名称，ProjectNameEnum需自己实现return ProjectNameEnum.getName(projectValue);
}
}
@param `projectValue`
@return 修改后的项目名称 FD: 货币资金 PR: 收益率（年化） IDA: 对外有息负债 FC: 融资成本（年化） NA: 净资产 EA: 其中：权益工具 ADR: 资产负债率 IDR: 有息负债率 IDER: 有息负债率（含权益工具）


class_name: kd.sdk.tmc.tda.extpoint.transdetail.ITransDetailCommonSourceReBuildInterface
method_name: rebuildDayDataSet
param_types_key: DataSet
signature_text: default DataSet rebuildDayDataSet(DataSet sources)
comment:
决策分析资金流入流出取数扩展接口 按日查询数据扩展接口
默认扩展示例如下
package kd.sdk.tmc.tda.extpoint.transdetail;
import kd.bos.algo.DataSet;
publicclassTransDetailCommonSourceReBuildInterfaceimplementsITransDetailCommonSourceReBuildInterface{
`
@param `sources` DataSet 标准产品公共取数的结果集
@return DataSet 二开根据业务重新扩展调整后结果集


class_name: kd.sdk.tmc.tda.extpoint.transdetail.ITransDetailGetDataInterface
method_name: getExtendFilter
signature_text: QFilter getExtendFilter()
comment:
查询交易明细自定义条件
默认扩展示例如下
package kd.tmc.tda.mservice.detail.extpoint;
import kd.bos.orm.query.QFilter;
import kd.sdk.tmc.tda.extpoint.transdetail.ITransDetailGetDataInterface;
publicclassTransDetailGetDataDefaultExtimplementsITransDetailGetDataInterface {
public QFilter getExtendFilter() {
// 返回自定义的QFilterreturn QFilter.of("1=1");
}
}
@return 自定义条件


class_name: kd.sdk.tmc.tm.forex.extpoint.IAutoSetExchangeRateDevService
method_name: isAutoSetExchangeRate
signature_text: default boolean isAutoSetExchangeRate()
comment:
是否需要程序自动获取汇率（外汇即期、外汇远期、外汇掉期交易执行单）
扩展示例如下
publicclassAutoSetExchangeRateDevServiceImplimplementsIAutoSetExchangeRateDevService {
``
``


class_name: kd.sdk.tmc.tm.forex.extpoint.IForexWbExcludeStatusExtService
method_name: getExcludeStatus
signature_text: default java.util.List<String> getExcludeStatus()
comment:
外汇单据的废弃状态的集合
扩展示例如下
publicclassForexWbExcludeStatusExtServiceImplimplementsIForexWbExcludeStatusExtService {
``
``


class_name: kd.sdk.tmc.tm.init.forexfwd.IForexFwdInit2BizBillSecondDevService
method_name: process
param_types_key: DynamicObject,DynamicObject,DynamicObject
signature_text: default void process(DynamicObject initBill, DynamicObject entryRow, DynamicObject BizBill)
comment:
外汇远期初始化单据的二开字段=>生命周期操作单
@param `initBill` 初始化单据
@param `entryRow` 初始化单据.生命周期信息.分录行
@param `BizBill` 生命周期操作单据


class_name: kd.sdk.tmc.tm.plinfo.extpoint.IPlInfoDevService
method_name: process
param_types_key: DynamicObject,DynamicObject
signature_text: default void process(DynamicObject plInfo, DynamicObject tradeBill)
comment:
（外汇类交易/利率类交易/结构化产品）“交易确认”操作或货币互换“买入结算”操作生成损益时支持二开字段带到损益信息单的扩展插件
扩展示例如下
publicclassPlInfoDevServiceImplimplementsIPlInfoDevService {
``
@param `plInfo` 损益信息单据
@param `tradeBill` 交易单据


class_name: kd.sdk.tmc.tm.swaps.extpoint.IFixedInterestRateAllowZeroDevService
method_name: isFixedInterestRateAllowZero
signature_text: default boolean isFixedInterestRateAllowZero()
comment:
互换交易的支付方和收取方的固定利率是否允许为0
扩展示例如下
publicclassFixedInterestRateAllowZeroDevServiceImplimplementsIFixedInterestRateAllowZeroDevService {
``
``


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVdeliveryService
method_name: deliveryBillHandler
param_types_key: DeliveryParam,KResumeBO,DynamicObject
comment: 投递单生成 @param `param` @param `empCVBO` @param `delivRecord`
signature_text:
kd.sdk.tsc.common.vo.BizResult deliveryBillHandler(kd.sdk.tsc.tsirm.extpoint.cv.DeliveryParam param, kd.sdk.tsc.common.vo.KResumeBO empCVBO, DynamicObject delivRecord)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVdeliveryValidator
method_name: deleveryCVValidator
param_types_key: DeliveryParam
comment: 投递简历校验 @param `param` param @return BizResult
signature_text:
kd.sdk.tsc.common.vo.BizResult deleveryCVValidator(kd.sdk.tsc.tsirm.extpoint.cv.DeliveryParam param)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVdeliveryValidator
method_name: shouldCreateDeliveryBill
param_types_key: DeliveryParam,KResumeBO
comment: 是否需要创建投递审批单 @return boolean
signature_text:
Boolean shouldCreateDeliveryBill(kd.sdk.tsc.tsirm.extpoint.cv.DeliveryParam param, kd.sdk.tsc.common.vo.KResumeBO KResumeBO)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVService
method_name: afterBindAccount
param_types_key: Long,BizResult
comment: 绑定账号后操作 @param `userId` @return BizResult
signature_text:
kd.sdk.tsc.common.vo.BizResult afterBindAccount(Long userId, kd.sdk.tsc.common.vo.BizResult bizResult)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVService
method_name: afterCreateCandidate
param_types_key: DeliveryParam,KResumeBO,BizResult
comment: 创建候选人 @param `param` 投递参数 @param `KResumeBO` 投递简历bo @return BizResult
signature_text:
kd.sdk.tsc.common.vo.BizResult afterCreateCandidate(kd.sdk.tsc.tsirm.extpoint.cv.DeliveryParam param, kd.sdk.tsc.common.vo.KResumeBO KResumeBO, kd.sdk.tsc.common.vo.BizResult bizResult)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVService
method_name: afterDeliveryCV
param_types_key: DeliveryParam,BizResult
comment: 投递简历 @param `param` 投递参数 @return BizResult
signature_text:
kd.sdk.tsc.common.vo.BizResult afterDeliveryCV(kd.sdk.tsc.tsirm.extpoint.cv.DeliveryParam param, kd.sdk.tsc.common.vo.BizResult bizResult)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVService
method_name: afterUnPublishedCV
param_types_key: Long,BizResult
comment: 取消公开简历 @param `userId` 账号ID @return BizResult
signature_text:
kd.sdk.tsc.common.vo.BizResult afterUnPublishedCV(Long userId, kd.sdk.tsc.common.vo.BizResult bizResult)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVService
method_name: afterUpdateCV
param_types_key: KResumeBO,BizResult
comment: 更新员工CV @param `kResumeBO` empCVBO @return BizResult
signature_text:
kd.sdk.tsc.common.vo.BizResult afterUpdateCV(kd.sdk.tsc.common.vo.KResumeBO kResumeBO, kd.sdk.tsc.common.vo.BizResult bizResult)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVService
method_name: afterUpdateCVFormPersonInfo
param_types_key: Long,BizResult
comment: 从核心人力人员信息更新员工C @param `cvId`
signature_text:
kd.sdk.tsc.common.vo.BizResult afterUpdateCVFormPersonInfo(Long cvId, kd.sdk.tsc.common.vo.BizResult bizResult)


class_name: kd.sdk.tsc.tsirm.extpoint.cv.IEmpCVService
method_name: beforeCreateCandidate
param_types_key: DeliveryParam,KResumeBO
comment: 创建候选人 @param `param` 投递参数 @param `KResumeBO` 投递简历bo @return BizResult
signature_text:
kd.sdk.tsc.common.vo.BizResult beforeCreateCandidate(kd.sdk.tsc.tsirm.extpoint.cv.DeliveryParam param, kd.sdk.tsc.common.vo.KResumeBO KResumeBO)


class_name: kd.sdk.tsc.tsirm.service.appfile.AppFileServiceHelper
method_name: changeAppFileStageStatusById
param_types_key: List
comment: 应聘档案环节状态操作 @param `data`
signature_text:
public static java.util.List<java.util.Map<String, Object>> changeAppFileStageStatusById(java.util.List<java.util.Map<String, Object>> data)


class_name: kd.sdk.tsc.tsirm.service.appfile.AppFileServiceHelper
method_name: eliminateAppFile
param_types_key: List
comment: 应聘档案淘态 @param `data`
signature_text:
public static java.util.List<java.util.Map<String, Object>> eliminateAppFile(java.util.List<java.util.Map<String, Object>> data)


class_name: kd.sdk.tsc.tsirm.service.cv.EmpCVServiceHelper
method_name: deliveryCVByAdId
param_types_key: Long
signature_text: public kd.sdk.tsc.common.vo.BizResult deliveryCVByAdId(Long advertId)
comment:
员工CV投递简历，后续逻辑生成投递记录 "员工CV"-》"投递简历",读取配置tsrbd_mtdmap, 源元数据为tsirm_empcv，目标元数据tsirm_delivcv
@param `advertId`


class_name: kd.sdk.tsc.tsirm.service.cv.EmpCVServiceHelper
method_name: saveResumeByDeliveryBillId
param_types_key: Long
signature_text: public static kd.sdk.tsc.common.vo.BizResult saveResumeByDeliveryBillId(Long delivBillId)
comment:
投递审批通过之后调用接口生成渠道简历 "投递简历"-》"渠道简历"读取元数据配置tsrbd_mtdmap，源元数据为tsirm_delivcv，目标源数据为tsirm_srrsm； 同时新增标准简历，"渠道简历"-》"标准简历",源元数据为tsirm_srrsm，目标源数据为 tsirm_stdrsm
@param `delivBillId`


class_name: kd.sdk.tsc.tsirm.service.rsm.ResumeServiceHelper
method_name: getResumeCollection
param_types_key: KResumeBO
comment: 获取渠道简历 @param `kResumeBo`
signature_text:
public static kd.sdk.tsc.common.vo.KResumeBO getResumeCollection(kd.sdk.tsc.common.vo.KResumeBO kResumeBo)


class_name: kd.sdk.tsc.tso.extpoint.IOfferCustomFieldValidate
method_name: doValidateField
param_types_key: DynamicObject,List,List
comment: 校验字段必填项 @param `offerInfo` offer 对象 @param `fieldTipMessages` 字段信息提示集 @param `fieldTips` 输入框提示对象
signature_text:
void doValidateField(DynamicObject offerInfo, java.util.List<FieldTip> fieldTips, java.util.List<String> fieldTipMessages)


class_name: kd.sdk.tsc.tsrbd.extpoint.gpt.IGptCustomParamService
method_name: addOrUpdateCustomParam
param_types_key: long,Map,DynamicObject
comment: 功能描述: 修改或增加GPT变量值 @param `gptId` gpt提示词id @param `param` gpt变量 @param `dynamicObject` 页面主对象
signature_text:
void addOrUpdateCustomParam(long gptId, java.util.Map<String, String> param, DynamicObject dynamicObject)


class_name: kd.sdk.tsc.tstpm.openservicehelper.CandidateServiceHelper
method_name: addArf
param_types_key: Map,Long,String,int
signature_text:
public static Long addArf(java.util.Map<String, Object> resumeInfoMap, Long appFileId, String mainEntityId, int type)

comment:
新增应聘登记表
@param `resumeInfoMap` 集成服务字段映射集合
@param `appFileId` 应聘档案ID
@param `mainEntityId` 主实体标识
@param `type` 1 新增 2 修改
@return 登记表/附表ID


class_name: kd.sdk.tsc.tstpm.openservicehelper.CandidateServiceHelper
method_name: addCandidate
param_types_key: Map,Long,Map,Map
signature_text:
public static Long addCandidate(java.util.Map<String, Object> resumeInfoMap, Long positionId, java.util.Map<String, Object> delivery, java.util.Map<String, Object> tpInfo)

comment:
新增候选人服务
@param `resumeInfoMap` 渠道简历信息map，key：元数据标识，value：具体信息
@param `positionId` 职位id
@param `delivery` 投递信息
@param `tpInfo` 第三方信息
@return 应聘档案id


class_name: kd.sdk.wtc.wtabm.business.helper.VaBillEntryEntityDto
method_name: getRealEndDate
signature_text: public java.util.Date getRealEndDate()
comment:
真实结束时间 带有到时分秒的时间点，根据班次和休假方式（上/下半天、全天）解析实际的休假时间； 注意： 1.OFF班无时段时，该字段值为休假单分录中选择的日期 2.解析上下半天的分割点为班次中间分割点
@return realEndDate


class_name: kd.sdk.wtc.wtabm.business.helper.VaBillEntryEntityDto
method_name: getRealStartDate
signature_text: public java.util.Date getRealStartDate()
comment:
真实开始时间 带有到时分秒的时间点，根据班次和休假方式（上/下半天、全天）解析实际的休假时间； 注意： 1.OFF班无时段时，该字段值为休假单分录中选择的日期 2.解析上下半天的分割点为班次中间分割点
@return realStartDate


class_name: kd.sdk.wtc.wtabm.business.helper.vaplan.VaPlanRuleQuery
method_name: <init>
param_types_key: long,Date,Long,DynamicObject,String,int
signature_text:
public VaPlanRuleQuery(long attFileBoId, java.util.Date targetDate, Long vaTypeId, DynamicObject billDy, String entryKey, int entryIndex)

comment:
构造休假方案规则查询请求参数
@param `attFileBoId` 考勤档案BOID, 不可传0
@param `targetDate` 要查询的日期(yyyy-MM-dd)
@param `vaTypeId` 休假类型ID，null则不根据类型取匹配休假规则的分录
@param `billDy` 单据动态对象，如果是创建单据查询休假规则此参数必传
@param `entryKey` 分录属性标识，如果是创建单据查询休假规则此参数必传
@param `entryIndex` 分录行号（0开始），如果是创建单据查询休假规则此参数必传


class_name: kd.sdk.wtc.wtabm.business.helper.WTABMHelper
method_name: getVaPlanAndRule
param_types_key: Set
signature_text:
public static java.util.List<VaPlanRuleResp> getVaPlanAndRule(java.util.Set<VaPlanRuleQuery> vaPlanRuleParams)

comment:
根据考勤档案BOID和休假日期查询对应的休假方案和休假规则
@param `vaPlanRuleParams` 请求参数 考勤档案BOID和日期不能为空，否则返回KDBizException
@return List 响应参数,返回该考勤档案下对应休假日期的休假方案和休假规则
@throws `KDBizException` 考勤档案BOID或休假日期为空时


class_name: kd.sdk.wtc.wtabm.business.quota.OnRenameVaTypeEvent
method_name: <init>
param_types_key: String,DynamicObject,String,String,String
signature_text:
public OnRenameVaTypeEvent(String source, DynamicObject vaTypeDyn, String quota, String unit, String unitName)


class_name: kd.sdk.wtc.wtabm.business.quota.VaTypeRenamePlugin
method_name: onRenameVaTypeName
param_types_key: OnRenameVaTypeEvent
signature_text: default void onRenameVaTypeName(OnRenameVaTypeEvent args)
comment:
前端额度假休假类型重命名时触发的事件
1.可以通过 OnRenameVaTypeEvent#setCancel(boolean) 取消当前事件，取消重命名； 2.可以通过 OnRenameVaTypeEvent#overrideVaTypeName(String) 覆盖标品生成的休假类型名称，如果设置的休假类型名称与基础资料原名称相同则不触发重命名； 3.可以通过 OnRenameVaTypeEvent#setShowQuotas(boolean) 设置是否展示额度信息，此处设置会默认处理标品的，不设置默认不展示 上述第2和第3点受到第1点控制
@param `args` 额度假休假类型重命名事件


class_name: kd.sdk.wtc.wtabm.business.spva.SpecialVaExpService
method_name: createSubEntry
param_types_key: SpecialVaTimeParam
signature_text: java.util.List<SpecialVaTimeDto> createSubEntry(SpecialVaTimeParam specialVaTimeParam)
comment:
自动生成自定义哺乳假休假方式的哺乳假休假时段，系统根据这个时间段
生成时间段应当在班次时段范围内且和班次内上班时段有时段交集，否则识别出时长会为0 班次内上班时段和当天生成的总时间范围交集时长不得超过maxVaTime,否则会触发每日可休时长校验导致校验不通过 生成的开始-结束时间对不允许和多个日期班次的时段范围交集，否则会触发跨班校验导致校验不通过 接口调用方式为：按日循环调用
扩展示例如下
public List<SpecialVaTimeDto> createSubEntry(SpecialVaTimeParam specialVaTimeParam) {
LocalDateTimestartTime= req.getDate().atTime(9, 0, 0, 0);
LocalDateTimeendTime= req.getDate().atTime(11, 30, 0, 0);
return Lists.newArrayList(newSpecialVaTimeDto(startTime, endTime));
}
@param `specialVaTimeParam` 生成休假明细时间段入参
@return 对应班次开始日的休假明细时间区间


class_name: kd.sdk.wtc.wtabm.business.spva.SpecialVaExpService
method_name: isAutoCreateSubEntry
param_types_key: DynamicObject
signature_text: boolean isAutoCreateSubEntry(DynamicObject spvaTypeDyn)
comment:
判断特殊假休假方式是否自动生成时段
当选择哺乳假休假方式之后，如果选中二开扩展的哺乳假休假方式，会调用此扩展点；如果返回true,则系统会继续后续校验，并生成休假时段，对时段计算时长并最终生成休假明细子分录信息 如果结果为false,则认为需要继续填写页面信息，不会触发后续校验和生成时长等
扩展示例如下
publicbooleanisAutoCreateSubEntry(DynamicObject spvaTypeDyn) {
Stringnumber= spvaTypeDyn.getString("number");
return StringUtils.equalsAny(number, "1011_S", "1012_s");
}
@param `spvaTypeDyn` 特殊假休假方式的动态对象，可以取的属性集为：id、number、name
@return 如果需要自动生成时段则返回true


class_name: kd.sdk.wtc.wtabm.business.spva.SpecialVaTimeDto
method_name: <init>
param_types_key: LocalDateTime,LocalDateTime
signature_text: public SpecialVaTimeDto(java.time.LocalDateTime startDateTime, java.time.LocalDateTime endDateTime)
comment:
哺乳假休假时间区间构造器。
@param `startDateTime` 休假开始时间，不能为null
@param `endDateTime` 休假结束时间，不能为null
@throws `IllegalArgumentException` 当休假结束时间早于休假开始时间时抛出异常。


class_name: kd.sdk.wtc.wtabm.business.va.VaApplyOverlapCheckExtPlugin
method_name: onCheckVaApplyOverlapTimePeriod
param_types_key: OnCheckVaApplyOverlapEvent
signature_text: void onCheckVaApplyOverlapTimePeriod(OnCheckVaApplyOverlapEvent onCheckVaApplyOverlapEvent)
comment:
休假申请时判定单据间重叠校验时调用此扩展接口。
通过该接口可以指定一些休假类型的单据不参与和其他休假类型的重叠校验。比如设置哺乳假不参与重叠校验，那么在同一时段哺乳假和其他类型假可以同时存在
示例代码可以参考休假申请单据重叠判定扩展场景示例，扩展场景编码：kd.sdk.wtc.wtabm.business.va.VaApplyRepeatCheckExtPlugin
@param `onCheckVaApplyOverlapEvent` 休假申请判定单据是否重叠时事件


class_name: kd.sdk.wtc.wtabm.business.va.VaApplyTimeCalExtPlugin
method_name: onCalVaApplyTimes
param_types_key: OnCalVaApplyTimeEvent
signature_text: void onCalVaApplyTimes(OnCalVaApplyTimeEvent onCalVaApplyTimeEvent)
comment:
休假申请分录时长计算时调用此接口。 当前接口会先调用标品时长计算逻辑，然后把标品计算结果放进入参 当前接口可以重写休假申请时长的计算时间,包括哺乳假的时长计算
示例代码可以参考休假申请时长计算扩展场景示例，扩展场景编码：kd.sdk.wtc.wtabm.business.va.VaApplyTimeCalExtPlugin
@param `onCalVaApplyTimeEvent` 休假申请时计算申请时长事件


class_name: kd.sdk.wtc.wtabm.business.va.VaInfoExpService
method_name: onCallBackVaInfo
param_types_key: VaInfoCallBackParam
signature_text: void onCallBackVaInfo(VaInfoCallBackParam callBackParam)
comment:
休假信息编辑内容回写休假单据
休假PC端，在新增或编辑休假信息之后，点击确定按钮回写数据到休假单主页面的分录中，提供此扩展接口，做个性化回写处理
扩展示例如下
@param `callBackParam` 参数信息


class_name: kd.sdk.wtc.wtabm.business.va.VaTimeResult
method_name: <init>
param_types_key: BigDecimal,BigDecimal
signature_text: public VaTimeResult(java.math.BigDecimal valHour, java.math.BigDecimal valDay)
comment:
构造类
@param `valHour` 必须；时长(单位：小时)，标品会默认对时长截取6位小数精度,设置为NULL会被认为是0请不要设置为NULL值
@param `valDay` 必须；时长（单位：天），标品会默认对时长截取6位小数精度,设置为NULL会被认为是0请不要设置为NULL值


class_name: kd.sdk.wtc.wtam.business.applytime.TpApplyTimeCalculateEvent
method_name: <init>
param_types_key: Long,DynamicObject,Map,TpApplyTimeCalculateResult
signature_text:
public TpApplyTimeCalculateEvent(Long attFileBo, DynamicObject entryDy, java.util.Map<java.time.LocalDate, kd.sdk.wtc.wtbs.common.dto.shift.ShiftDto> shiftMap, kd.sdk.wtc.wtam.business.applytime.bean.TpApplyTimeCalculateResult result)


class_name: kd.sdk.wtc.wtam.business.tp.TpInfoExpService
method_name: onCallBackTpInfo
param_types_key: TpInfoParameterParam
signature_text: void onCallBackTpInfo(TpInfoParameterParam tpInfoParameterParam)
comment:
出差信息编辑/新增内容回写出差单据
出差PC端，在新增或编辑出差信息之后，点击确定按钮回写数据到出差单主页面的分录中，提供此扩展接口，做扩展字段回写处理
扩展示例如下
@param `tpInfoParameterParam` 参数信息


class_name: kd.sdk.wtc.wtam.business.tp.TpInfoExpService
method_name: setChangeTpInfoValue
param_types_key: TpInfoParameterParam
signature_text: void setChangeTpInfoValue(TpInfoParameterParam tpInfoParameterParam)
comment:
本人变更/为他人变更单据页初始化
出差PC端，在本人列表/为他人列表变更后，变更单页面初始化时，分录数据赋值 ，提供此扩展接口，做扩展字段赋值处理
扩展示例如下
@param `tpInfoParameterParam` 参数信息


class_name: kd.sdk.wtc.wtam.business.tp.TpInfoExpService
method_name: setTpInfoValue
param_types_key: TpInfoParameterParam
signature_text: void setTpInfoValue(TpInfoParameterParam tpInfoParameterParam)
comment:
出差信息编辑显示字段值
出差PC端，在新增或编辑出差信息之后，点击确定按钮回写数据到出差单主页面的分录中，提供此扩展接口，做扩展字段回写处理
扩展示例如下
@param `tpInfoParameterParam` 参数信息


class_name: kd.sdk.wtc.wtam.business.tp.TpInfoParameterParam
method_name: <init>
param_types_key: IFormView,JSONObject,int
comment: @param `view` 页面的view对象 @param `jsonObject` 出差信息
signature_text:
public TpInfoParameterParam(IFormView view, com.alibaba.fastjson.JSONObject jsonObject, int rowIndex)


class_name: kd.sdk.wtc.wtam.business.tp.WtamHelper
method_name: getTripRuleInfo
param_types_key: List
comment: 获取出差规则（包含匹配的计算规则） 根据获取出差规则（包含匹配的计算规则） @param `queries` 规则参数信息
signature_text:
public java.util.List<kd.sdk.wtc.wtp.business.tripplan.TripPlanRuleResp> getTripRuleInfo(java.util.List<TripPlanRuleQuery> queries)


class_name: kd.sdk.wtc.wtbs.business.bill.dutydate.BillDutyDateExtPlugin
method_name: onMatchBillDutyDate
param_types_key: OnMatchBillDutyDateEvent
signature_text: void onMatchBillDutyDate(OnMatchBillDutyDateEvent onMatchBillDutyDateEvent)
comment:
自选时段申请，自定义归属日期拓展插件。
按自选时段申请时，会计算自选时段的归属日期，该拓展会替换标准的归属日期进行各校验配置项的获取
扩展示例如下
@param `onMatchBillDutyDateEvent` 假勤单据归属日期事件


class_name: kd.sdk.wtc.wtbs.business.bill.dutydate.OnMatchBillDutyDateEvent
method_name: <init>
param_types_key: Date,Date,Date,DutyDateErrorEnum
signature_text:
public OnMatchBillDutyDateEvent(java.util.Date startTime, java.util.Date endTime, java.util.Date standardDate, kd.sdk.wtc.wtbs.common.enums.DutyDateErrorEnum dutyDateErrorEnum)


class_name: kd.sdk.wtc.wtbs.business.datarange.DateRangeRuleExpPlugin
method_name: onResolveDateRange
param_types_key: OnResolveDateRangeEvent
signature_text: void onResolveDateRange(OnResolveDateRangeEvent onResolveDateRangeEvent)
comment:
考勤核算触发解析扩展的日期范围条件匹配的条件字段对应的结果的事件
日期范围条件匹配的条件字段增加了之后，这些扩展字段的解析结果可以通过实现该接口来处理
@param `onResolveDateRangeEvent` 核算触发解析扩展的日期范围事件对象


class_name: kd.sdk.wtc.wtbs.business.datarange.OnResolveDateRangeEvent
method_name: <init>
param_types_key: TieContextExt,TimeBucketExt,ConditionDtoExt,WTCDateRangeSource
signature_text:
public OnResolveDateRangeEvent(TieContextExt tieContextExt, TimeBucketExt timeBucketExt, ConditionDtoExt conditionDtoExt, WTCDateRangeSource wtcDateRangeSource)


class_name: kd.sdk.wtc.wtbs.business.limitcond.OnLimitConditionEvent
method_name: <init>
param_types_key: String,Long,PreLimitCondition,ConditionDtoExt
signature_text:
public OnLimitConditionEvent(String limitConditionSource, Long attFileVid, kd.sdk.wtc.wtes.business.tie.core.chain.PreLimitCondition preLimitCondition, ConditionDtoExt conditionDtoExt)


class_name: kd.sdk.wtc.wtbs.business.limitcond.OnLimitConditionExpPlugin
method_name: onLimitConditionEvent
param_types_key: OnLimitConditionEvent
signature_text: void onLimitConditionEvent(OnLimitConditionEvent onLimitConditionEvent)
comment:
提单和核算触发解析 扩展的限定条件匹配的条件字段 对应的结果的事件
限定条件匹配的条件字段增加了之后，这些扩展字段的解析结果可以通过实现该接口来处理
@param `onLimitConditionEvent` 核算触发解析扩展的限定条件事件对象


class_name: kd.sdk.wtc.wtbs.business.mobilescheme.SchemeMatchEvent
method_name: <init>
param_types_key: List,String
signature_text:
public SchemeMatchEvent(java.util.List<kd.sdk.wtc.wtbs.business.mobilescheme.SchemeMatchExtDto> attFileSchemes, String sceneNumber)


class_name: kd.sdk.wtc.wtbs.common.access.ConditionDtoExt
method_name: getOperators
signature_text: String getOperators()
comment:
操作符跟条件条件表达式的字段类型相关，具体操作符枚举如下： < 表示 小于 > 表示 大于 <= 表示 小于等于 >= 表示 大于等于 == 表示 等于 != 表示 不等于 is_null 表示 为空 is_not_null 表示 不为空 in 表示 在...中 not_in 表示 不在...中 contains 表示 包含 not_contains 表示 不包含 startsWith 表示 以...开始 endsWith 表示 以...结束 0d 表示 今天 <=0d 表示 小于等于今天 >=0d 表示 大于等于今天 -1d 表示 昨天 1d 表示 明天 0w 表示 本周 -1w 表示 上周 1w 表示 下周 0m 表示 本月 -1m 表示 上月 1m 表示 下月 -3~0m 表示 过去三个月 0~3m 表示 未来三个月 0q 表示 本季度 -1q 表示 上季度 1q 表示 下季度 0y 表示 今年 -1y 表示 去年 1y 表示 明年 is_or_isSub 表示 等于/...的下级  >dom 表示 大于（日） <=dom 表示 小于等于（日） >=dom 表示 大于等于（日）
@return 返回操作符


class_name: kd.sdk.wtc.wtbs.common.access.ConditionDtoExt
method_name: getParamType
signature_text: String getParamType()
comment:
条件表达式中字段的类型： boolean - 布尔值 date - 日期 string - 字符串 number - 数字 enum - 枚举 dynamicObject - 动态对象
@return 返回条件表达式中字段的类型


class_name: kd.sdk.wtc.wtbs.task.WTCSubTaskEndExtPlugin
method_name: afterSubTaskEnd
param_types_key: AfterSubTaskEndEvent
signature_text: void afterSubTaskEnd(AfterSubTaskEndEvent afterSubTaskEndEvent)
comment:
考勤子任务结束后处理事件，支持在考勤子任务结束后处理个性化的扩展逻辑。
当标品考勤子任务结束后，调用此扩展，处理个性化的扩展逻辑
LongtaskId= afterSubTaskEndEvent.getTaskId();
LongsubTaskId= afterSubTaskEndEvent.getSubTaskId();
Stringcategory= afterSubTaskEndEvent.getCategory();
// 判断任务类型是考勤核算，TaskCategoryEnum.WTTE_TIE.getCode()if (StringUtils.equals(category, "wtte_tie")) {
// 考勤子任务结束后发送消息或者做其他业务操作
}
@param `afterSubTaskEndEvent` 考勤子任务结束后处理事件


class_name: kd.sdk.wtc.wtbs.task.WTCTaskEndExtPlugin
method_name: afterTaskEnd
param_types_key: AfterTaskEndEvent
signature_text: void afterTaskEnd(AfterTaskEndEvent afterTaskEndEvent)
comment:
考勤主任务结束后处理事件，支持在考勤主任务结束后处理个性化的扩展逻辑。
当标品考勤主任务结束后，调用此扩展，处理个性化的扩展逻辑
LongtaskId= afterTaskEndEvent.getTaskId();
Stringcategory= afterTaskEndEvent.getCategory();
// 判断任务类型是考勤核算，TaskCategoryEnum.WTTE_TIE.getCode()if (StringUtils.equals(category, "wtte_tie")) {
// 考勤主任务结束后发送消息或者做其他业务操作
}
@param `afterTaskEndEvent` 考勤主任务结束后处理事件


class_name: kd.sdk.wtc.wtes.business.qte.executor.AfterQteGenQTEvent
method_name: <init>
param_types_key: long,LocalDate,Map,long,List,Object,Map,Map
signature_text:
public AfterQteGenQTEvent(long attPersonId, java.time.LocalDate calculateDate, java.util.Map<Long, Object> matchRule, long attFileBid, java.util.List<? extends QuotaDetail> quotaDetails, Object initDataExt, java.util.Map<String, Object> initData, java.util.Map<String, Object> lineVar)


class_name: kd.sdk.wtc.wtes.business.qte.executor.QteGenQTExtPlugin
method_name: afterCarryDwonQlGen
param_types_key: AfterQteGenQTEvent
signature_text: default void afterCarryDwonQlGen(AfterQteGenQTEvent afterQteGenQTEvent)
comment:
定额核算"定额生成"-“定额结转”步骤之后会调用改接口。 可根据入参数据对入参的（QuotaDetailOverdrawQl）quotaDetails中的值进行处理并返回。 当定额执行结转的步骤时会进入此节点。 可以通过此节点来修改已结转的数据 可以通过此节点来修改新增定额结转明细（来源是系统生成的）
该接口返回的“结转时长”、“失效时长”、“转业务领域时长”、“结算时长”、“离职时长”如果进行修改，其中一条明细中“结转时长”、“离职时长”、“转业务领域时长”不能同时出现 则对应步骤中的对应值会进行替换，如果未对对应属性值进行修改， 则保持原样。
拓展示例：
publicvoidafterOverdrawQlGen(AfterQteGenQTEvent afterQteGenQTEvent) {
List<QuotaDetailCarryDwon> list = (List<QuotaDetailCarryDwon>) afterQteGenQTEvent.getQuotaDetails();
for (QuotaDetailCarryDwon detail : list) {
detail.setCarryValue(three, CarryDwonType.CARRY_TO_BUSINESS, Boolean.TRUE);
detail.setSettlementValue(BigDecimal.ONE);
detail.setInvalidValue(totleCarryValue);
}
}
@param `afterQteGenQTEvent`


class_name: kd.sdk.wtc.wtes.business.qte.executor.QteGenQTExtPlugin
method_name: afterInOutGen
param_types_key: AfterQteGenQTEvent
signature_text: default void afterInOutGen(AfterQteGenQTEvent afterQteGenQTEvent)
comment:
定额核算"定额生成"-“入离职折算”步骤之后会调用改接口。 可根据入参数据对入参的（QuotaDetailInOut）quotaDetails中的值进行处理并返回。 当当前期间发生跨挂靠组织、跨阶是可能多条QuotaDetailInOut， 可以通过“跨组织、跨阶变更开始时间”来识别那条是跨阶前数据， 可以通过“档案版本”、“跨组织、跨阶变更开始时间”来识别那条是跨组织前数据。
该接口返回的“享有时长”如果进行修改， 则对应步骤中的对应值会进行替换，如果未对对应属性值进行修改， 则保持原样。
拓展示例：
publicvoidafterInOutGen(AfterQteGenQTEvent afterQteGenQTEvent) {
List<QuotaDetailInOutGen> list = (List<QuotaDetailInOutGen>) afterQteGenQTEvent.getQuotaDetails();
for (QuotaDetailInOutGen detail : list) {
detail.setOwnValue(BigDecimal.ONE);
detail.setDesc("update in or out value");
}
}
@param `afterQteGenQTEvent`


class_name: kd.sdk.wtc.wtes.business.qte.executor.QteGenQTExtPlugin
method_name: afterOverdrawGen
param_types_key: AfterQteGenQTEvent
signature_text: default void afterOverdrawGen(AfterQteGenQTEvent afterQteGenQTEvent)
comment:
定额核算"定额生成"-“定额标准透支时长”步骤之后会调用改接口。 可根据入参数据对入参的（QuotaDetailOverdraw）quotaDetails中的值进行处理并返回。 当当前期间发生跨挂靠组织、跨阶是可能多条QuotaDetailOverdraw， 可以通过“跨组织、跨阶变更开始时间”来识别那条是跨阶前数据， 可以通过“档案版本”、“跨组织、跨阶变更开始时间”来识别那条是跨组织前数据。
该接口返回的“享有透支时长”、“可透支时长”如果进行修改， 则对应步骤中的对应值会进行替换，如果未对对应属性值进行修改， 则保持原样。
拓展示例：
publicvoidafterOverdrawGen(AfterQteGenQTEvent afterQteGenQTEvent) {
List<QuotaDetailOverdrawGen> list = (List<QuotaDetailOverdrawGen>) afterQteGenQTEvent.getQuotaDetails();
for (QuotaDetailOverdrawGen detail : list) {
detail.setOwnOdValue(BigDecimal.ONE);
detail.setCanBeOdValue(BigDecimal.ONE);
detail.setDesc("update overdraw value");
}
}
@param `afterQteGenQTEvent`


class_name: kd.sdk.wtc.wtes.business.qte.executor.QteGenQTExtPlugin
method_name: afterOverdrawQlGen
param_types_key: AfterQteGenQTEvent
signature_text: default void afterOverdrawQlGen(AfterQteGenQTEvent afterQteGenQTEvent)
comment:
定额核算"定额生成"-“透支限定”步骤之后会调用改接口。 可根据入参数据对入参的（QuotaDetailOverdrawQl）quotaDetails中的值进行处理并返回。 当当前期间发生跨挂靠组织、跨阶是可能多条QuotaDetailOverdrawQl， 可以通过“跨组织、跨阶变更开始时间”来识别那条是跨阶前数据， 可以通过“档案版本”、“跨组织、跨阶变更开始时间”来识别那条是跨组织前数据。
该接口返回的“享有透支时长”、“可透支时长”如果进行修改， 则对应步骤中的对应值会进行替换，如果未对对应属性值进行修改， 则保持原样。
拓展示例：
publicvoidafterOverdrawQlGen(AfterQteGenQTEvent afterQteGenQTEvent) {
List<QuotaDetailOverdrawQlGen> list = (List<QuotaDetailOverdrawQlGen>) afterQteGenQTEvent.getQuotaDetails();
for (QuotaDetailOverdrawQlGen detail : list) {
detail.setOwnOdValue(BigDecimal.ONE);
detail.setCanBeOdValue(BigDecimal.ONE);
detail.setDesc("update overdraw  qualification value");
}
}
@param `afterQteGenQTEvent`


class_name: kd.sdk.wtc.wtes.business.qte.executor.QteGenQTExtPlugin
method_name: afterQualificationGen
param_types_key: AfterQteGenQTEvent
signature_text: default void afterQualificationGen(AfterQteGenQTEvent afterQteGenQTEvent)
comment:
定额核算"定额生成"-“生成限定”步骤之后会调用改接口。 可根据入参数据对入参的（QuotaDetailQualification）quotaDetails中的值进行处理并返回。 当当前期间发生跨挂靠组织、跨阶是可能多条QuotaDetailQualification， 可以通过“跨组织、跨阶变更开始时间”来识别那条是跨阶前数据， 可以通过“档案版本”、“跨组织、跨阶变更开始时间”来识别那条是跨组织前数据。
该接口返回的“享有时长”如果进行修改， 则对应步骤中的对应值会进行替换，如果未对对应属性值进行修改， 则保持原样。
拓展示例：
publicvoidafterQualificationGen(AfterQteGenQTEvent afterQteGenQTEvent) {
List<QuotaDetailQualificationGen> list = (List<QuotaDetailQualificationGen>) afterQteGenQTEvent.getQuotaDetails();
for (QuotaDetailQualificationGen detail : list) {
detail.setChange(true);
detail.setOwnValue(BigDecimal.ONE);
detail.setDesc("update qualification value");
}
}
@param `afterQteGenQTEvent`


class_name: kd.sdk.wtc.wtes.business.qte.executor.QteGenQTExtPlugin
method_name: afterStandardGen
param_types_key: AfterQteGenQTEvent
signature_text: default void afterStandardGen(AfterQteGenQTEvent afterQteGenQTEvent)
comment:
定额核算"定额生成"-“标准定额生成”步骤之后会调用改接口。 可根据入参数据对入参的（QuotaDetailStandard）quotaDetails中的值进行处理并返回。 当当前期间发生跨挂靠组织、跨阶是可能多条QuotaDetailStandard， 可以通过“跨组织、跨阶变更开始时间”来识别那条是跨阶前数据， 可以通过“档案版本”、“跨组织、跨阶变更开始时间”来识别那条是跨组织前数据。
该接口返回的“标准时长”、“生成开始时间”、“生成结束时间”如果进行修改， 则对应步骤中的对应值会进行替换，如果未对对应属性值进行修改， 则保持原样。
拓展示例：
publicvoidafterStandardGen(AfterQteGenQTEvent afterQteGenQTEvent) {
List<QuotaDetailStandardGen> list = (List<QuotaDetailStandardGen>) afterQteGenQTEvent.getQuotaDetails();
for (QuotaDetailStandardGen detail : list) {
detail.setGenValue(BigDecimal.ONE);
detail.setGenEndDate(newDate());
detail.setGenStartDate(newDate());
detail.setDesc("update Standard value");
}
}
@param `afterQteGenQTEvent`


class_name: kd.sdk.wtc.wtes.business.qte.executor.QteGenQTExtPlugin
method_name: afterUseGen
param_types_key: AfterQteGenQTEvent
signature_text: default void afterUseGen(AfterQteGenQTEvent afterQteGenQTEvent)
comment:
定额核算"定额生成"-“定额可用时间范围”步骤之后会调用改接口。 可根据入参数据对入参的（QuotaDetailUse）quotaDetails中的值进行处理并返回。 当当前期间发生跨挂靠组织、跨阶是可能多条QuotaDetailUse， 可以通过“跨组织、跨阶变更开始时间”来识别那条是跨阶前数据， 可以通过“档案版本”、“跨组织、跨阶变更开始时间”来识别那条是跨组织前数据。
该接口返回的“使用开始时间”、“使用结束时间”如果进行修改， 则对应步骤中的对应值会进行替换，如果未对对应属性值进行修改， 则保持原样。
拓展示例：
publicvoidafterUseGen(AfterQteGenQTEvent afterQteGenQTEvent) {
List<QuotaDetailUseGen> list = (List<QuotaDetailUseGen>) afterQteGenQTEvent.getQuotaDetails();
for (QuotaDetailUseGen detail : list) {
detail.setUseEndDate(newDate());
detail.setUseStartDate(newDate());
detail.setDesc("update using value");
}
}
@param `afterQteGenQTEvent`


class_name: kd.sdk.wtc.wtes.business.qte.executor.QteGenQTExtPlugin
method_name: afterUseQlGen
param_types_key: AfterQteGenQTEvent
signature_text: default void afterUseQlGen(AfterQteGenQTEvent afterQteGenQTEvent)
comment:
定额核算"定额生成"-“使用限定”步骤之后会调用改接口。 可根据入参数据对入参的（QuotaDetailUseQualification）quotaDetails中的值进行处理并返回。 当当前期间发生跨挂靠组织、跨阶是可能多条QuotaDetailUseQualification， 可以通过“跨组织、跨阶变更开始时间”来识别那条是跨阶前数据， 可以通过“档案版本”、“跨组织、跨阶变更开始时间”来识别那条是跨组织前数据。
该接口返回的“享有时长”如果进行修改， 则对应步骤中的对应值会进行替换，如果未对对应属性值进行修改， 则保持原样。
拓展示例：
publicvoidafterUseQlGen(AfterQteGenQTEvent afterQteGenQTEvent) {
List<QuotaDetailUseQualificationGen> list = (List<QuotaDetailUseQualificationGen>) afterQteGenQTEvent.getQuotaDetails();
for (QuotaDetailUseQualificationGen detail : list) {
detail.setOwnValue(BigDecimal.ONE);
detail.setDesc("update use qualification value");
}
}
@param `afterQteGenQTEvent`


class_name: kd.sdk.wtc.wtes.business.qte.executor.QuotaDetail
method_name: <init>
param_types_key:
long,long,long,long,long,int,String,BigDecimal,Date,Date,Date,Date,BigDecimal,BigDecimal,BigDecimal,BigDecimal,Date

signature_text:
public QuotaDetail(long id, long attFileVid, long orgId, long qtTypeId, long pCycleId, int periodNum, String source, java.math.BigDecimal genValue, java.util.Date genStartDate, java.util.Date genEndDate, java.util.Date useStartDate, java.util.Date useEndDate, java.math.BigDecimal ownValue, java.math.BigDecimal ownOdValue, java.math.BigDecimal usableValue, java.math.BigDecimal canBeOdValue, java.util.Date changeSatrt)


class_name: kd.sdk.wtc.wtes.business.qte.executor.QuotaDetailInOut
method_name: <init>
param_types_key:
long,long,long,long,long,int,String,BigDecimal,Date,Date,Date,Date,BigDecimal,BigDecimal,BigDecimal,BigDecimal,Date

signature_text:
public QuotaDetailInOut(long id, long attFileVid, long orgId, long qtTypeId, long pCycleId, int periodNum, String source, java.math.BigDecimal genValue, java.util.Date genStartDate, java.util.Date genEndDate, java.util.Date useStartDate, java.util.Date useEndDate, java.math.BigDecimal ownValue, java.math.BigDecimal ownOdValue, java.math.BigDecimal usableValue, java.math.BigDecimal canBeOdValue, java.util.Date changeSatrt)


class_name: kd.sdk.wtc.wtes.business.qte.executor.QuotaDetailOverdraw
method_name: <init>
param_types_key:
long,long,long,long,long,int,String,BigDecimal,Date,Date,Date,Date,BigDecimal,BigDecimal,BigDecimal,BigDecimal,Date

signature_text:
public QuotaDetailOverdraw(long id, long attFileVid, long orgId, long qtTypeId, long pCycleId, int periodNum, String source, java.math.BigDecimal genValue, java.util.Date genStartDate, java.util.Date genEndDate, java.util.Date useStartDate, java.util.Date useEndDate, java.math.BigDecimal ownValue, java.math.BigDecimal ownOdValue, java.math.BigDecimal usableValue, java.math.BigDecimal canBeOdValue, java.util.Date changeSatrt)


class_name: kd.sdk.wtc.wtes.business.qte.executor.QuotaDetailOverdrawQl
method_name: <init>
signature_text:
public QuotaDetailOverdrawQl(long id, long attFileVid, long orgId, long qtTypeId, long pCycleId, int periodNum, String source, java.math.BigDecimal genValue, java.util.Date genStartDate, java.util.Date genEndDate, java.util.Date useStartDate, java.util.Date useEndDate, java.math.BigDecimal ownValue, java.math.BigDecimal ownOdValue, java.math.BigDecimal usableValue, java.math.BigDecimal canBeOdValue, java.util.Date changeSatrt)


class_name: kd.sdk.wtc.wtes.business.qte.executor.QuotaDetailQualification
method_name: <init>
signature_text:
public QuotaDetailQualification(long id, long attFileVid, long orgId, long qtTypeId, long pCycleId, int periodNum, String source, java.math.BigDecimal genValue, java.util.Date genStartDate, java.util.Date genEndDate, java.util.Date useStartDate, java.util.Date useEndDate, java.math.BigDecimal ownValue, java.math.BigDecimal ownOdValue, java.math.BigDecimal usableValue, java.math.BigDecimal canBeOdValue, java.util.Date changeSatrt)


class_name: kd.sdk.wtc.wtes.business.qte.executor.QuotaDetailStandard
method_name: <init>
signature_text:
public QuotaDetailStandard(long id, long attFileVid, long orgId, long qtTypeId, long pCycleId, int periodNum, String source, java.math.BigDecimal genValue, java.util.Date genStartDate, java.util.Date genEndDate, java.util.Date useStartDate, java.util.Date useEndDate, java.math.BigDecimal ownValue, java.math.BigDecimal ownOdValue, java.math.BigDecimal usableValue, java.math.BigDecimal canBeOdValue, java.util.Date changeSatrt)


class_name: kd.sdk.wtc.wtes.business.qte.executor.QuotaDetailUse
method_name: <init>
signature_text:
public QuotaDetailUse(long id, long attFileVid, long orgId, long qtTypeId, long pCycleId, int periodNum, String source, java.math.BigDecimal genValue, java.util.Date genStartDate, java.util.Date genEndDate, java.util.Date useStartDate, java.util.Date useEndDate, java.math.BigDecimal ownValue, java.math.BigDecimal ownOdValue, java.math.BigDecimal usableValue, java.math.BigDecimal canBeOdValue, java.util.Date changeSatrt)


class_name: kd.sdk.wtc.wtes.business.qte.executor.QuotaDetailUseQualification
method_name: <init>
signature_text:
public QuotaDetailUseQualification(long id, long attFileVid, long orgId, long qtTypeId, long pCycleId, int periodNum, String source, java.math.BigDecimal genValue, java.util.Date genStartDate, java.util.Date genEndDate, java.util.Date useStartDate, java.util.Date useEndDate, java.math.BigDecimal ownValue, java.math.BigDecimal ownOdValue, java.math.BigDecimal usableValue, java.math.BigDecimal canBeOdValue, java.util.Date changeSatrt)


class_name: kd.sdk.wtc.wtes.business.qte.gendate.AfterQteNoGenDateEvent
method_name: <init>
param_types_key: long,long,long,String,LocalDate,Date,Object,Map
signature_text:
public AfterQteNoGenDateEvent(long attPersonId, long attFileBoId, long attFileVid, String noGenDateType, java.time.LocalDate baseDate, java.util.Date noGenDate, Object initDataExt, java.util.Map<String, Object> initData)


class_name: kd.sdk.wtc.wtes.business.qte.gendate.AfterQteNoGenDateEvent
method_name: getInitDataExt
signature_text: public Object getInitDataExt()
comment:
二开拓展的初始化参数。 值为初始化拓展接口 QTInitExtPlugin#onInitParamFinish 的返回值。 注意：调用该接口时，初始化拓展接口 QTInitExtPlugin#onInitParamFinish 可能还未被执行！


class_name: kd.sdk.wtc.wtes.business.qte.gendate.QteNoGenDateResolutionExtPlugin
method_name: afterResolveNoGenDate
param_types_key: AfterQteNoGenDateEvent
signature_text: void afterResolveNoGenDate(AfterQteNoGenDateEvent event)
comment:
特定日期前不生成扩展接口，定额核算在解析得出特定日期前不生成de日期后，将会执行该方法。 可根据入参中的特定日期前不生成类型以及特定日期前不生成日期的值进行特性化处理并返回。
该接口所返回的非null特定日期前不生成日期的值将会替换原定额核算出的特定日期前不生成日期的值。 如果返回null，定额核算将仍然使用原值进行处理。
拓展示例：
publicvoidafterResolveNoGenDate(AfterQteNoGenDateEvent event) {
DatenoGenDate= queryAllExpandNoGenDate(event.getAttPersonId(), event.getNoGenDateType());
DateresNoGenDate= noGenDate != null ? noGenDate : event.getNoGenDate();
event.setNoGenDate(resNoGenDate);
}
private Date queryAllExpandNoGenDate(long personBid, String noGenDateType) {
return personBid % 2 == 1 ? null : newDate();
}
@param `event` 特定日期前不生成


class_name: kd.sdk.wtc.wtes.business.qte.init.AfterQteParamInitEvent
method_name: <init>
param_types_key: String,Object,QteParamInitRequest,Map
signature_text:
public AfterQteParamInitEvent(String category, Object currentInitParam, QteParamInitRequest initParamReq, java.util.Map<String, Object> initData)


class_name: kd.sdk.wtc.wtes.business.qte.init.model.QuotaGenConditionExt
method_name: <init>
param_types_key: Map
comment: @param `recordDatas`
signature_text:
public QuotaGenConditionExt(java.util.Map<Long, java.util.Map<String, java.util.List<DataPoint>>> recordDatas)


class_name: kd.sdk.wtc.wtes.business.qte.init.QteParamInitRequest
method_name: <init>
param_types_key: List,LocalDate,LocalDate,QteRequest
signature_text:
public QteParamInitRequest(java.util.List<Long> attPersonIds, java.time.LocalDate startDate, java.time.LocalDate endDate, QteRequest request)


class_name: kd.sdk.wtc.wtes.business.qte.refdate.AfterQteResolveRefDateEvent
method_name: <init>
param_types_key: long,long,long,LocalDate,long,Date,Object,Map
signature_text:
public AfterQteResolveRefDateEvent(long attPersonId, long attFileBoId, long attFileVid, java.time.LocalDate baseDate, long refDateBaseDataId, java.util.Date refDate, Object initDataExt, java.util.Map<String, Object> initData)


class_name: kd.sdk.wtc.wtes.business.qte.refdate.QteRefDateResolutionExtPlugin
method_name: afterResolveRefDate
param_types_key: AfterQteResolveRefDateEvent
signature_text: void afterResolveRefDate(AfterQteResolveRefDateEvent event)
comment:
参照日期扩展接口，定额核算在解析得出参照日期后，将会执行该方法。 可根据入参中的参照日期id以及参照日期的值进行特性化处理并返回。
该接口所返回的非null参照日期值将会替换原定额核算出的参照日期值。 如果返回null，定额核算将仍然使用原值进行处理。
拓展示例：
publicvoidafterResolveRefDate(AfterQteResolveRefDateEvent event) {
DaterefDate= queryAllExpandRefDate(event.getAttPersonId(), event.getRefDateBaseDataId());
DateresRefDate= refDate != null ? refDate : event.getRefDate();
event.setRefDate(resRefDate);
}
private Date queryAllExpandRefDate(long personBid, long refDateId) {
return personBid % 2 == 1 ? null : newDate();
}
@param `event` 参照日期生成参数


class_name: kd.sdk.wtc.wtes.business.qte.varcondition.AfterQteResolveVarConditionEvent
method_name: <init>
param_types_key: long,long,long,LocalDate,Set,Map,Date,Date,Object,Map
signature_text:
public AfterQteResolveVarConditionEvent(long attPersonId, long attFileBoId, long attFileVid, java.time.LocalDate baseDate, java.util.Set<Long> baseDataIds, java.util.Map<Long, java.math.BigDecimal> varValue, java.util.Date startDay, java.util.Date endDay, Object initDataExt, java.util.Map<String, Object> initData)


class_name: kd.sdk.wtc.wtes.business.qte.varcondition.QteVarConditionResolutionExtPlugin
method_name: afterResolveVarValue
param_types_key: AfterQteResolveVarConditionEvent
signature_text: void afterResolveVarValue(AfterQteResolveVarConditionEvent event)
comment:
变量条件扩展接口，定额核算在解析得出变量条件值后，将会执行该方法。 可根据入参中的变量条件id以及变量条件的值进行特性化处理并返回。
该接口所返回的非null变量条件值将会替换原定额核算出的参照日期值。 如果返回null，定额核算将仍然使用原值进行处理。
拓展示例：
publicvoidafterResolveVarValue(AfterQteResolveVarConditionEvent event) {
Set<Long> baseDataIds = event.getBaseDataIds();
for (Long baseDataId : baseDataIds) {
event.setVarValue(baseDataId, BigDecimal.TEN);
}
}
@param `event` 变量条件值生成参数


class_name: kd.sdk.wtc.wtes.business.tie.core.chain.TieContentPersistentExt
method_name: getAttendPersonByAttPersonIdAndDate
param_types_key: long,LocalDate
signature_text:
AttendPersonExt getAttendPersonByAttPersonIdAndDate(long attPersonId, java.time.LocalDate chainDate)

comment:
根据考勤人员ID和日期获取对应的考勤人信息
@param `attPersonId` 考勤人员ID
@param `chainDate` 核算日期
@return 考勤人员ID和日期获取对应的考勤人信息


class_name: kd.sdk.wtc.wtes.business.tie.core.chain.TieContextExt
method_name: genAttItemInstanceExt
param_types_key: Long,BigDecimal,BigDecimal,BigDecimal
signature_text:
AttItemInstanceExt genAttItemInstanceExt(Long boId, java.math.BigDecimal itemValue, java.math.BigDecimal day, java.math.BigDecimal secondDecimal)

comment:
生成一个考勤项目实例
@param `boId` 考勤项目boId
@param `itemValue` 考勤项目值
@param `day` 考勤项目值（单位：天）
@param `secondDecimal` 考勤项目值（单位：秒）
@return 考勤项目实例


class_name: kd.sdk.wtc.wtes.business.tie.core.chain.TieContextExt
method_name: getLogicCardDataByPersonIdAndDate
param_types_key: long,LocalDate
signature_text:
java.util.List<LogicCardExt> getLogicCardDataByPersonIdAndDate(long attPersonId, java.time.LocalDate chainDate)

comment:
根据考勤人员ID和日期获取对应的有效卡数据（包含一次卡和多次卡）
@param `attPersonId` 考勤人员ID
@param `chainDate` 核算日期
@return 考勤人员ID和日期获取对应的有效卡数据


class_name: kd.sdk.wtc.wtes.business.tie.core.init.TieParamInitExtPlugin
method_name: afterAllParamInit
param_types_key: AfterTieAllParamInitEvent
signature_text: default void afterAllParamInit(AfterTieAllParamInitEvent event)
comment:
在考勤核算中，当初始化阶段完成时，将会执行该方法。
可通过该方法返回个性化拓展的初始化数据，所返回的个性化初始数据在后续的回调节点都将会被携带。
扩展示例：请参考业务扩展场景kd.sdk.wtc.wtes.business.tie.core.init.TieParamInitExtPlugin的扩展说明，菜单路径：业务扩展平台->业务扩展场景
@param `event` 初始化阶段完成事件


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.att.AttEvaluatorExpService
method_name: onEvaluateAttendanceEnd
param_types_key: OnEvaluateAttendanceEndEvent
signature_text: void onEvaluateAttendanceEnd(OnEvaluateAttendanceEndEvent endEvent)
comment:
考勤核算的步骤结束前调用此接口。 当前接口可以生成一些客户二开自定义的考勤项目值，在后续会把生成的考勤项目值加入到明细/汇总项目中 （根据考勤项目类型确定，如果是明细项目，则在考勤记录存储当日的明细项目值，如果是汇总项目，则存储当日汇总项目值，如是明细兼汇总项目，则都会存）
拓展示例：
publicvoidonEvaluateAttendanceEnd(OnEvaluateAttendanceEndEvent endEvent) {
TieContextExttieContextExt= endEvent.getTieContextExt();
LocalDatecalculateDate= tieContextExt.getCalculateDate();
Longbid=1667665341460901888L; // 此处写要生成考勤记录的考勤项目的BOID,demo使用 节假日加班_转调休 的考勤项目AttItemSpecExtattItemSpecExt= tieContextExt.getAttItemSpecExt(bid, calculateDate);
// 获取当日和次日的排班信息RosterExtrosterExt= tieContextExt.getRosterExt(calculateDate);
ShiftSpecExtshiftSpec= rosterExt.getShiftSpec();
RosterExtnextDayrosterExt= tieContextExt.getRosterExt(calculateDate.plusDays(1));
// 此处为demo，非demo打log请慎重，由于考勤核算时批量执行可能会拖慢系统速度// 当天的日期属性LongattrId= rosterExt.getDateAttributeId();
// 第二天的日期属性LongnextDayAttrId= nextDayrosterExt.getDateAttributeId();
// 如果当天和第二天都不是节假日，则直接返回;否则需要处理时间对并重新生成考勤项目时长;1220227377297100800L节假日if (!isHolday(nextDayAttrId) && !isHolday(attrId)) {
return;
}
List<TimeBucketExt> timeBucketExtList = endEvent.getTimeBucketExtList();
List<AttItemInstanceExt> itemInstanceExtList = Lists.newArrayListWithExpectedSize(timeBucketExtList.size());
for (TimeBucketExt timeBucketExt : timeBucketExtList) {
// 此处为demo，非demo打log请慎重，由于考勤核算时批量执行可能会拖慢系统速度
LOG.info("timeBucketExt:{}, {}, {}", timeBucketExt.getStartTime(), timeBucketExt.getEndTime(), timeBucketExt.getDateAttribute());
// 如果当天和第二天都是节假日不处理时间对直接计算；如果当天是节假日第二天不是需要截取时间对的当天时段；如果第二天日期属性是节假日当天不是需要截取时间对的第二天时间段LocalDateTimestartTime= timeBucketExt.getStartTime();
LocalDateTimeendTime= timeBucketExt.getEndTime();
if (!isHolday(nextDayAttrId)) {
LocalDateTimelocalDate= calculateDate.plusDays(1).atStartOfDay();
endTime = min(endTime, localDate);
}
if (!isHolday(attrId)) {
LocalDateTimelocalDate= calculateDate.plusDays(1).atStartOfDay();
startTime = max(startTime, localDate);
}
// 由于可能会调整开始结束时间，此处先做一下判定，如果不包含节假日时段，执行下一段日期范围if (!startTime.isBefore(endTime)) {
continue;
}
longmillis= Duration.between(startTime, endTime).toMillis();
BigDecimalsecondDecimal= BigDecimal.valueOf(millis / 1000.0d).setScale(6, RoundingMode.HALF_UP);
BigDecimaldayDecimal= shiftSpec.secondsToDays(secondDecimal);
AttItemInstanceExtinstanceExt=newAttItemInstanceExt(attItemSpecExt, secondDecimal, dayDecimal, secondDecimal);
itemInstanceExtList.add(instanceExt);
}
endEvent.setAttItemSpecExtList(itemInstanceExtList);
}
private LocalDateTime max(LocalDateTime... dateTimes) { // 日期求最晚,入参不允许有nullLocalDateTimemax= Arrays.stream(dateTimes).max((d1, d2) -> d1.isAfter(d2) ? 1 : -1).get();
return max;
}
private LocalDateTime min(LocalDateTime... dateTimes) { // 日期求最早,入参不允许有nullLocalDateTimemin= Arrays.stream(dateTimes).min((d1, d2) -> d1.isAfter(d2) ? 1 : -1).get();
return min;
}
privatebooleanisHolday(long dateAttributeId) { // 是否节假日，根据系统预置的节假日日期属性ID判定// 系统预置的节假日日期属性IDreturndateAttributeId== 1220227377297100800L;
}
@param `endEvent` 考勤核算出勤核算步骤后置事件


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.att.OnEvaluateAttendanceEndEvent
method_name: <init>
param_types_key: TieContextExt,List
comment: 带参构造方法，接口入参会在该方法中声明 @param `tieContextExt` 二开上下文 @param `timeBucketExtList` 实际出勤时间对过滤
signature_text:
public OnEvaluateAttendanceEndEvent(TieContextExt tieContextExt, java.util.List<TimeBucketExt> timeBucketExtList)


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.att.TieExecAttendanceExtPlugin
method_name: afterExecAttendance
param_types_key: AfterExecAttendanceEvent
signature_text: void afterExecAttendance(AfterExecAttendanceEvent event)
comment:
考勤核算标品步骤执行完成后调用执行扩展
当考勤核算步骤执行完毕，生成标品考勤项目后，调用此扩展，产生个性化考勤项目值
// 示例方法为：从当前阶段的合并/覆盖结果取考勤项目节假日加班_转调休(ID:1667665341460901888)的考勤项目值，如果考勤项目时长存在不能被1小时整除的时长，则补足一小时；// 比如时长为3700秒，则新增一个时长为3500秒的该考勤项目publicvoidafterExecAttendance(AfterExecAttendanceEvent event) {
LOG.info("【核算步骤扩展】【出勤】，入参：{}", JSON.toJSONString(event));
AfterExecAttendanceParamparam= event.getParam();
TieContextExttieContextExt= param.getTieContext();
Map<Long, AttItemInstanceExt> curStageInstances = param.getCurStageInstanceMap(); // 此处为当前阶段已计算出的考勤项目
Map<Long, AttItemInstanceExt> curChainInstances = param.getCurChainInstanceMap(); // 此处为当前核算链已计算出的考勤项目
List<TimeBucketExt> rawTimeBucket = param.getRawTimeBucket(); // 此处为原始时间对Longbid=1667665341460901888L; // 此处写要生成考勤记录的考勤项目的BOID,demo使用 节假日加班_转调休 的考勤项目AttItemInstanceExtattItemInstanceExt= curStageInstances.get(bid);
AttItemSpecExtattItemSpecExt= tieContextExt.getAttItemSpecExt(bid, tieContextExt.getCalculateDate());
if (attItemInstanceExt != null && attItemSpecExt != null) {
BigDecimalsumSecondDecimal= attItemInstanceExt.getSecondDecimal();
BigDecimalremainder= sumSecondDecimal.remainder(ONE_HOUR_SECONDS);
if (remainder.compareTo(BigDecimal.ZERO) > 0) {
BigDecimalsecondDecimal= ONE_HOUR_SECONDS.subtract(remainder);
RosterExtrosterExt= tieContextExt.getRosterExt(tieContextExt.getCalculateDate());
ShiftSpecExtshiftSpec= rosterExt.getShiftSpec();
BigDecimaldayDecimal= shiftSpec.secondsToDays(secondDecimal);
AttItemInstanceExtinstanceExt=newAttItemInstanceExt(attItemSpecExt, secondDecimal, dayDecimal, secondDecimal);
event.setTieDataNodeExtList(Lists.newArrayList(instanceExt));
}
}
LOG.info("【核算步骤扩展】【出勤】，出参：{}", JSON.toJSONString(event.getTieDataNodeExtList()));
}
@param `event` 出勤计算阶段执行结束时扩展事件


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.daily.TieAttDailyEvaluatorExtPlugin
method_name: doEvaluate
param_types_key: ExecDailyEvaluatorEvent
signature_text: void doEvaluate(ExecDailyEvaluatorEvent evaluatorEvent)
comment:
考勤核算自定义核算步骤
实现此方法可以在考勤核算链的期间汇总”阶段前添加一个步骤
publicvoiddoEvaluate(ExecDailyEvaluatorEvent evaluatorEvent) {
LOG.info("【核算步骤扩展】【自定义核算步骤】，入参：{}", JSON.toJSONString(evaluatorEvent));
Map<Long, AttItemInstanceExt> curChainInstanceMap = evaluatorEvent.getCurChainInstanceMap();
longbid=1576185320372699136L; // EX_1140_S:旷工天数TieContextExttieContext= evaluatorEvent.getTieContext();
AttItemSpecExtattItemSpecExt= tieContext.getAttItemSpecExt(bid, tieContext.getCalculateDate());
RosterExtrosterExt= tieContext.getRosterExt(tieContext.getCalculateDate());
ShiftSpecExtshiftSpec= rosterExt.getShiftSpec();
AttItemInstanceExtinstanceExt=newAttItemInstanceExt(attItemSpecExt, BigDecimal.ZERO,
BigDecimal.ONE, shiftSpec.daysToSecondDecimal(BigDecimal.ONE));
List<AttItemInstanceExt> tieDataNodeList = Lists.newArrayList(instanceExt);
evaluatorEvent.setTieDataNodeExtList(tieDataNodeList);
LOG.info("【核算步骤扩展】【自定义核算步骤】，出参：{}", JSON.toJSONString(tieDataNodeList));
}
`
@param `evaluatorEvent` 考勤核算自定义核算步骤事件


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.ex.ExAttItemInstanceExtDTO
method_name: <init>
param_types_key: AttItemSpecExt,BigDecimal,BigDecimal
signature_text:
public ExAttItemInstanceExtDTO(AttItemSpecExt attItemSpecExt, java.math.BigDecimal itemValue, java.math.BigDecimal secondDecimal)

comment:
异常考勤项目构造器
@param `attItemSpecExt` 考勤项目定义
@param `itemValue` 考勤项目值，按考勤项目单位转换后的结果
@param `secondDecimal` 考勤项目值（单位：秒）


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.ex.ExAttItemInstanceExtDTO
method_name: setAttItemSpecExt
param_types_key: AttItemSpecExt
signature_text: public void setAttItemSpecExt(AttItemSpecExt attItemSpecExt)
comment:
考勤项目定义
当考勤项目 AttItemSpecExt#dataType()是次数（“0”）时， 项目值取#getItemValue()字段，是时长（“1”）时，项目值取#getSecondDecimal()。
@param `attItemSpecExt` 考勤项目定义


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.ex.ExAttItemInstanceExtDTO
method_name: setSecondDecimal
param_types_key: BigDecimal
signature_text: public void setSecondDecimal(java.math.BigDecimal secondDecimal)
comment:
时长类型异常考勤项目的值（单位：秒）
当异常考勤项目是时长类型时，该字段值不能为null，单位不是秒的项目值需要转为秒才能设置该值。
@param `secondDecimal` 时长类型异常项目的值（单位：秒）


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.ex.TieExecExExtPlugin
method_name: afterExecEx
param_types_key: AfterExecExEvent
signature_text: void afterExecEx(AfterExecExEvent event)
comment:
执行考勤核算异常计算事件扩展方法
支持在异常计算中处理扩展逻辑，比如可以新增异常考勤项目来干预标品产生的，如果新增的异常考勤项目与标品的相同，异常考勤项目会合并。
示例代码可以参考考勤核算异常计算扩展场景示例，扩展场景编码：kd.sdk.wtc.wtes.business.tie.exexutor.ex.TieExecExExtPlugin `<pre> public void afterExecEx(AfterExecExEvent event) { LOG.info("【核算步骤扩展】【异常】，入参：{}", JSON.toJSONString(event)); AfterExecExParam param = event.getParam(); TieContextExt tieContextExt = param.getTieContext(); List<ExAttItemInstanceExt> exAttItemInstances = param.getExAttItemInstances(); // 迟到异常 Optional<ExAttItemInstanceExt> exAttItemInstanceOpt = exAttItemInstances.stream() .filter(exAttItemInstanceExt -> "EX_1010_S".equals(exAttItemInstanceExt.getAttItemSpecExt().getNumber())).findFirst(); Long bid = 1576191782905970688L; // 旷工次数 考勤项目的BOID AttItemSpecExt attItemSpecExt = tieContextExt.getAttItemSpecExt(bid, tieContextExt.getCalculateDate()); if (exAttItemInstanceOpt.isPresent() && attItemSpecExt != null) { ExAttItemInstanceExt exAttItemInstance = exAttItemInstanceOpt.get(); BigDecimal secondDecimal = exAttItemInstance.getSecondDecimal(); if (secondDecimal.compareTo(HALF_HOUR_SECONDS) > 0) { ExAttItemInstanceExtDTO instanceExt = new ExAttItemInstanceExtDTO(attItemSpecExt, BigDecimal.ONE, BigDecimal.ZERO); instanceExt.setExTypeId(exAttItemInstance.getExTypeId()); instanceExt.setExProcessId(exAttItemInstance.getExProcessId()); instanceExt.setShiftDate(exAttItemInstance.getShiftDate()); instanceExt.setShouldPunchCardSeqId(exAttItemInstance.getShouldPunchCardSeqId()); instanceExt.setShouldPunchPointStart(exAttItemInstance.getShouldPunchPointStart()); instanceExt.setShouldPunchPointEnd(exAttItemInstance.getShouldPunchPointEnd()); instanceExt.setShiftTimeBucketSeqId(exAttItemInstance.getShiftTimeBucketSeqId()); event.setExAttItemInstances(Lists.newArrayList(instanceExt)); } else { BigDecimal negate = secondDecimal.negate(); ExAttItemInstanceExtDTO instanceExt = new ExAttItemInstanceExtDTO(exAttItemInstance.getAttItemSpecExt(), negate, negate); instanceExt.setExTypeId(exAttItemInstance.getExTypeId()); instanceExt.setExProcessId(exAttItemInstance.getExProcessId()); instanceExt.setShiftDate(exAttItemInstance.getShiftDate()); instanceExt.setShouldPunchCardSeqId(exAttItemInstance.getShouldPunchCardSeqId()); instanceExt.setShouldPunchPointStart(exAttItemInstance.getShouldPunchPointStart()); instanceExt.setShouldPunchPointEnd(exAttItemInstance.getShouldPunchPointEnd()); instanceExt.setShiftTimeBucketSeqId(exAttItemInstance.getShiftTimeBucketSeqId()); instanceExt.setExFilterType(exAttItemInstance.getExFilterType()); event.setExAttItemInstances(Lists.newArrayList(instanceExt)); } } LOG.info("【核算步骤扩展】【异常】，出参：{}", JSON.toJSONString(event.getExAttItemInstances())); } </pre></code>`
`
`
``
@param `event` 异常计算阶段执行结束时扩展事件


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.otcal.TieExecOvertimeExtPlugin
method_name: afterExecOvertime
param_types_key: AfterExecOvertimeEvent
signature_text: void afterExecOvertime(AfterExecOvertimeEvent event)
comment:
考勤核算标品加班核算执行完成后调用执行扩展
当考勤核算步骤执行完毕，生成标品考勤项目后，调用此扩展，产生个性化考勤项目值
publicvoidafterExecOvertime(AfterExecOvertimeEvent event) {
LOG.info("【核算步骤扩展】【加班】，入参：{}", JSON.toJSONString(event));
AfterExecOvertimeParamparam= event.getParam();
TieContextExttieContextExt= param.getTieContext();
Map<Long, AttItemInstanceExt> curChainInstances = param.getCurChainInstanceMap(); // 当前核算链的考勤项目LongexBid=1667650973922881536L; //OT1_1100_S(工作日加班_转调休)Longbid=1667656552783409152L; // OT1_1130_S（工作日加班_转加班费）AttItemInstanceExtattItemInstanceExt= curChainInstances.get(exBid);
AttItemSpecExtattItemSpecExt= tieContextExt.getAttItemSpecExt(bid, tieContextExt.getCalculateDate());
if (attItemInstanceExt != null && attItemSpecExt != null) {
AttItemInstanceExtinstanceExt=newAttItemInstanceExt(attItemSpecExt, attItemInstanceExt.getSecondDecimal(),
attItemInstanceExt.getDay(), attItemInstanceExt.getSecondDecimal());
event.setTieDataNodeExtList(Lists.newArrayList(instanceExt));
}
LOG.info("【核算步骤扩展】【加班】，出参：{}", JSON.toJSONString(event.getTieDataNodeExtList()));
}
@param `event` 加班计算阶段执行结束时扩展事件


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.period.TieAttPeriodEvaluatorExt
method_name: doEvaluate
param_types_key: TieAttPeriodContextExt,Map
signature_text:
java.util.Map<Long, java.util.List<PeriodAttItemInstanceExt>> doEvaluate(TieAttPeriodContextExt tieAttPeriodContextExt, java.util.Map<Long, java.util.List<PeriodAttItemInstanceExt>> attPeriodItemInstanceMap)

comment:
执行期间汇总核算步骤后置事件方法
支持在标品汇总核算步骤结束后处理扩展逻辑，比如可以新增额外的汇总记录，但不允许修改/删除标品的汇总记录/p>
扩展示例如下
@param `tieAttPeriodContextExt` 期间汇总上下文
@param `attPeriodItemInstanceMap` 期间汇总结果按人员考勤期间分组 key ： 人员考勤期间id，value ： 期间汇总结果列表
@return 期间汇总结果按人员考勤期间分组 key ： 人员考勤期间id 人员考勤期间必须在人员考勤期间列表中，value ： 期间汇总结果列表 ， 考勤项目类型必须是汇总或汇总兼明细考勤项目


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.period.TieExecPerPeriodSummaryExtPlugin
method_name: afterExecPerPeriodSummary
param_types_key: TieAttPeriodContextExt,Map
signature_text:
java.util.Map<Long, java.util.List<PeriodAttItemInstanceExt>> afterExecPerPeriodSummary(TieAttPeriodContextExt tieAttPeriodContextExt, java.util.Map<Long, java.util.List<PeriodAttItemInstanceExt>> attPeriodItemInstanceMap)

comment:
执行期间汇总核算步骤后置事件方法，支持在标品汇总核算中处理扩展逻辑，比如可以新增额外的汇总记录，但不允许修改/删除标品的汇总记录。
支持在标品汇总核算中处理扩展逻辑，比如可以新增额外的汇总记录，但不允许修改/删除标品的汇总记录。
扩展示例：请参考业务扩展场景kd.sdk.wtc.wtes.business.tie.exexutor.period.TieExecPerPeriodSummaryExtPlugin扩展说明，菜单路径：业务扩展平台-业务扩展场景
@param `tieAttPeriodContextExt` 期间汇总上下文
@param `attPeriodItemInstanceMap` 期间汇总结果按人员考勤期间分组 key ： 人员考勤期间id，value ： 期间汇总结果列表
@return 期间汇总结果按人员考勤期间分组 key ： 人员考勤期间id 人员考勤期间必须在人员考勤期间列表中，value ： 期间汇总结果列表 ， 考勤项目类型必须是汇总或汇总兼明细考勤项目


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.tvl.TieExecBusinessTripExtPlugin
method_name: afterExecBusinessTrip
param_types_key: AfterExecBusinessTripEvent
signature_text: void afterExecBusinessTrip(AfterExecBusinessTripEvent event)
comment:
考勤核算标品异常转化步骤执行完成后调用执行扩展
当考勤核算步骤执行完毕，生成标品考勤项目后，调用此扩展，产生个性化考勤项目值
// 当前扩展点DEMO功能：// 当前核算阶段的考勤项目BT_1040_S（国外出差_结果时长 ID:1610167120157573120），计算其总时长，如果>28800秒（8小时），忘带卡次数（ID:1616554563408645120L）+1publicvoidafterExecBusinessTrip(AfterExecBusinessTripEvent event) {
LOG.info("【核算步骤扩展】【出差】，入参：{}", JSON.toJSONString(event));
AfterExecBusinessTripParamparam= event.getParam();
TieContextExttieContextExt= param.getTieContext();
Map<Long, AttItemInstanceExt> curStageInstances = param.getCurStageInstanceMap(); // 当前阶段计算出的项目值
Map<Long, AttItemInstanceExt> curChainInstances = param.getCurChainInstanceMap(); // 当前核算链计算出的项目值
List<TimeBucketExt> rawTimebucket = param.getRawTimeBucket(); // 原始时间对LongexBid=1610167120157573120L; // 国内出差_结果时长的BIDLongbid=1616554563408645120L; // 此处写要生成考勤记录的考勤项目的BOID,demo使用 忘带卡次数 的考勤项目AttItemInstanceExtattItemInstanceExt= curStageInstances.get(exBid);
AttItemSpecExtattItemSpecExt= tieContextExt.getAttItemSpecExt(bid, tieContextExt.getCalculateDate());
if (attItemInstanceExt != null && attItemSpecExt != null) {
BigDecimalsumDayDecimal= attItemInstanceExt.getDay();
BigDecimalsumSecondDecimal= attItemInstanceExt.getSecondDecimal();
if (sumSecondDecimal.compareTo(ONE_HOUR_SECONDS.multiply(BigDecimal.valueOf(8))) > 0) {
AttItemInstanceExtinstanceExt=newAttItemInstanceExt(attItemSpecExt, BigDecimal.ONE, BigDecimal.ZERO, BigDecimal.ZERO);
event.setTieDataNodeExtList(Lists.newArrayList(instanceExt));
}
}
LOG.info("【核算步骤扩展】【出差】，出参：{}", JSON.toJSONString(event.getTieDataNodeExtList()));
}
@param `event` 出差计算阶段执行结束时扩展事件


class_name: kd.sdk.wtc.wtes.business.tie.exexutor.va.TieExecVacationExtPlugin
method_name: afterExecVacation
param_types_key: AfterExecVacationEvent
signature_text: void afterExecVacation(AfterExecVacationEvent event)
comment:
考勤核算标品休假核算步骤执行完成后调用执行扩展
当考勤核算步骤执行完毕，生成标品考勤项目后，调用此扩展，产生个性化考勤项目值
publicvoidafterExecVacation(AfterExecVacationEvent event) {
LOG.info("【核算步骤扩展】【休假】，入参：{}", JSON.toJSONString(event));
AfterExecVacationParamparam= event.getParam();
TieContextExttieContextExt= param.getTieContext();
Map<Long, AttItemInstanceExt> curStageInstances = param.getCurStageInstanceMap();
Map<Long, AttItemInstanceExt> curChainInstances = param.getCurChainInstanceMap(); // 当前核算链的时长
List<TimeBucketExt> rawTimebucket = param.getRawTimeBucket();
LongexBid=1428132636110356480L; // LE_1170_S（事假_结果时长）Longbid=1428132636110356480L; // 此处写要生成考勤记录的考勤项目的BOID,demo使用 旷工时长 的考勤项目AttItemInstanceExtattItemInstanceExt= curChainInstances.get(exBid);
AttItemSpecExtattItemSpecExt= tieContextExt.getAttItemSpecExt(bid, tieContextExt.getCalculateDate());
if (attItemInstanceExt != null && attItemSpecExt != null) {
BigDecimalsumSecondDecimal= attItemInstanceExt.getSecondDecimal();
if (sumSecondDecimal.compareTo(BigDecimal.ZERO) > 0 && sumSecondDecimal.compareTo(ONE_HOUR_SECONDS) < 0) {
RosterExtrosterExt= tieContextExt.getRosterExt(tieContextExt.getAttPersonId(), tieContextExt.getCalculateDate());
ShiftSpecExtshiftSpec= rosterExt.getShiftSpec();
AttItemInstanceExtinstanceExt=newAttItemInstanceExt(attItemSpecExt, ONE_HOUR_SECONDS.subtract(sumSecondDecimal), shiftSpec.secondsToDays(ONE_HOUR_SECONDS.subtract(sumSecondDecimal)), ONE_HOUR_SECONDS.subtract(sumSecondDecimal));
event.setTieDataNodeExtList(Lists.newArrayList(instanceExt));
}
}
LOG.info("【核算步骤扩展】【休假】，出参：{}", JSON.toJSONString(event.getTieDataNodeExtList()));
}
@param `event` 休假阶段执行结束时扩展事件


class_name: kd.sdk.wtc.wtes.business.tie.init.accountplan.TieSchemeExtPlugin
method_name: onBuildDailyChain
param_types_key: TieSchemeExt
signature_text: void onBuildDailyChain(TieSchemeExt tieSchemeExt)
comment:
支持在所有日明细核算步骤执行后执行扩展步骤，效果相当于在“期间汇总”阶段前增加一个扩展步骤；
支持在所有日明细核算步骤执行后执行扩展步骤，效果相当于在“期间汇总”阶段前增加一个扩展步骤
扩展示例：请参考业务扩展场景kd.sdk.wtc.wtes.business.tie.init.accountplan.TieSchemeExtPlugin扩展说明，菜单路径：业务扩展平台-业务扩展场景
@param `tieSchemeExt` 核算方案


class_name: kd.sdk.wtc.wtes.business.tie.init.accountplan.TieSchemeExtPlugin
method_name: onBuildPeriodChain
param_types_key: TieSchemeExt
signature_text: void onBuildPeriodChain(TieSchemeExt tieSchemeExt)
comment:
支持在所有汇总核算步骤执行后执行扩展步骤，效果相当于在“期间汇总调整”阶段后增加一个扩展步骤；
支持在所有日明细核算步骤执行后执行扩展步骤，效果相当于在“期间汇总调整”阶段前增加一个扩展步骤
扩展示例：请参考业务扩展场景kd.sdk.wtc.wtes.business.tie.init.accountplan.TieSchemeExtPlugin扩展说明，菜单路径：业务扩展平台-业务扩展场景
@param `tieSchemeExt` 核算方案


class_name: kd.sdk.wtc.wtes.business.tie.init.attfile.AttFileQueryParamExt
method_name: setQFilter
param_types_key: QFilter
signature_text: void setQFilter(QFilter qFilter)
comment:
设置其它的查询条件，默认是空的
// 举例设置查询档案的数据状态QFilterattPersonIdsFilter=newQFilter(WTCCommonConstants.DATASTATUS, QCP.in, dataStatus)
@param `qFilter` 设置其它的过滤条件


class_name: kd.sdk.wtc.wtes.business.tie.init.attfile.TieInitAttFileExtPlugin
method_name: onQueryAttFile
param_types_key: OnQueryInitParamOfAttFileEvent
signature_text: void onQueryAttFile(OnQueryInitParamOfAttFileEvent event)
comment:
考勤核算考勤档案初始化扩展方法
考勤核算时，需要先准备数据，本接口适用于考勤档案数据准备的查询条件构建
Set<String> extKeys 支持查询时扩展的查询字段，扩展的属性必须是 档案元数据（wtp_attfilebase） 里的扩展属性
AttFileQueryParamExt  提供查询档案是设置一些查询的条件
扩展示例如下
publicvoidonQueryAttFile(OnQueryInitParamOfAttFileEvent event) {
// 查询时增加额外的考勤人查询
event.getAttFileQueryParam().getAttPersonSetIds().add(1863000118957967360L);
// 扩展字段增加工号，扩展字段必须来自档案（wtp_attfilebase）
event.setExtKeys(Sets.newHashSet("extkey01"));
}
@param `event` 扩展入参


class_name: kd.sdk.wtc.wtes.business.tie.init.attitemspec.TieInitAttItemSpecExtPlugin
method_name: onQueryAttItemSpec
param_types_key: OnQueryInitParamOfAttItemSpecEvent
signature_text: void onQueryAttItemSpec(OnQueryInitParamOfAttItemSpecEvent event)
comment:
执行查询考勤项目初始化参数前置事件方法，支持修改预置核算参数的新增查询字段
执行查询考勤项目初始化参数前置事件方法，支持修改预置核算参数的新增查询字段
Set<String> extKeys 支持查询时扩展的查询字段，扩展的属性必须是 考勤项目元数据（wtbd_attitem） 里的扩展属性
扩展示例如下
// 设置要增加扩展字段 举例："extkey01"
event.setExtKeys(Sets.newHashSet("extkey01"));
@param `event` 扩展入参


class_name: kd.sdk.wtc.wtes.business.tie.init.bill.VaBillInitExpService
method_name: onAddFilters
param_types_key: List
signature_text: void onAddFilters(java.util.List<QFilter> qFilters)
comment:
考勤核算休假单据初始化查询条件扩展方法
考勤核算时，需要先准备数据，本接口适用于休假单据数据准备的查询条件构建
系统将会完全使用该方法的返回结果做为查询条件查询休假单； 如果不修改预置条件，则需要在返回时把 [qFilters](https://docs.oracle.com/javase/8/docs/api/qFilters/package-summary.html) 带入到返回参数中 presetFilters当前的条件如下：
// 在指定考勤人ID列表中，且休假分录时间在给定的开始和结束日期中有交集，且单据状态为已审核，且单据没有被销假QFilterattPersonIdsFilter=newQFilter("personid", QFilter.in, attPersonIds);
QFilterfromDateFilter=newQFilter("entryentity.entrystartdate", QFilter.less_equals, WTCDateUtils.toDate(toDate));
QFiltertoDateDateFilter=newQFilter("entryentity.entrystartdate", QFilter.large_equals, WTCDateUtils.toDate(fromDate));
QFilteraudit=newQFilter(WTCBaseConstants.BILLSTATUS, QFilter.equals, WTCCommonConstants.AUDITSTATUS_AUDITPASS);
QFilterisNotLeave=newQFilter("isnotleave", QFilter.equals, WTCCommonConstants.STR_ZERO);
扩展示例如下
publicvoidonAddFilters(List<QFilter> qFilters) {
// 扩展示例：如果单据存在变更单，父单据不参与考勤核算
isHaveChangeFilter(qFilters);
}
private List<QFilter> isHaveChangeFilter(List<QFilter> presetQFilters) {
QFilterisHaveChangeFilter=newQFilter(IS_HAVE_CHANGE, QCP.equals, Boolean.FALSE);
presetQFilters.add(isHaveChangeFilter);
return presetQFilters;
}
@param `qFilters` 条件列表
@return 扩展完的查询条件


class_name: kd.sdk.wtc.wtes.business.tie.init.bill.VaTimeBucketSplitExtPlugin
method_name: onSplitVaBillTimeBucket
param_types_key: OnVaBillTimeBucketSplitEvent
signature_text:
void onSplitVaBillTimeBucket(kd.sdk.wtc.wtes.business.tie.init.bill.OnVaBillTimeBucketSplitEvent onSplitVaBillTimeBucketEvent)

comment:
休假单据时段信息初始化时调用此接口。 当前接口可以传入标品已拆出的休假单据时间对，对时间对重新调整拆分,会影响到休假的考勤核算和定额核算结果
示例代码可以参考休假申请单据重叠判定扩展场景示例，扩展场景编码：kd.sdk.wtc.wtes.business.tie.init.bill.TieInitializerVaTimeBucketSplitExtPlugin
@param `onSplitVaBillTimeBucketEvent` 核算时初始化休假单据拆对事件


class_name: kd.sdk.wtc.wtes.business.tie.init.configmix.TieConfigMixInitPlugin
method_name: onQuery
param_types_key: TieConfigMixQueryEvent
signature_text: void onQuery(TieConfigMixQueryEvent event)
comment:
查询考勤核算数据源的配置组合 返回的结果必须查询出这些配置组合中的属性countryid.number,attitemmap.id,attstsmap.id,tbpcrelcnf.id,entryentity.biztype,entryentity.exattr,entryentity.attendattr,entryentity.datasource 目前是取第一个配置组合(目前所有人只能用同一个配置组合)
查询配置组合方法
扩展示例如下,可以参考 @kd.sdk.wtc.wtes.business.tie.init.configmix.ConfigMixInitPluginDemo
publicvoidonQuery(TieConfigMixQueryEvent event) {
QFilter[] qFilters = newQFilter[3];
qFilters[0] = newQFilter("status", QCP.equals, "C");
qFilters[1] = newQFilter("iscurrentversion", QCP.equals, Boolean.TRUE);
qFilters[2] = newQFilter("enable", QCP.equals, "1");
DynamicObject[] dynamicObjects = BusinessDataServiceHelper.load("wtbd_confcombin", "countryid.number,attitemmap.id,attstsmap.id,tbpcrelcnf.id,entryentity.biztype,entryentity.exattr,entryentity.attendattr,entryentity.datasource", qFilters);
// 设置查询的组合配置
event.addConfigMixResult(Arrays.asList(dynamicObjects));
}
@param `event` 查询事件,返回结果放入查询事件


class_name: kd.sdk.wtc.wtes.business.tie.init.configmix.TieConfigMixQueryEvent
method_name: getConfigMixResult
signature_text: public java.util.List<DynamicObject> getConfigMixResult()
comment:
获取自定义的配置组合 返回的结果必须查询出这些配置组合中的属性countryid.number,attitemmap.id,attstsmap.id,tbpcrelcnf.id,entryentity.biztype,entryentity.exattr,entryentity.attendattr,entryentity.datasource
@return 自定义的配置组合


class_name: kd.sdk.wtc.wtes.business.tie.init.logiccard.TieInitEffectiveCardExtPlugin
method_name: onQueryMultiEffectiveCard
param_types_key: OnQueryInitParamOfLogicCardEvent
signature_text: default void onQueryMultiEffectiveCard(OnQueryInitParamOfLogicCardEvent event)
comment:
执行查询有效多次卡初始化参数前置事件方法，支持修改预置核算参数的查询条件和新增查询字段
考勤核算时，需要先准备数据，本接口适用于初始化多次卡数据的时候扩展
Set<String> extKeys 支持查询时扩展的查询字段，扩展的属性必须是 多次卡元数据（wtpm_multicard） 里的扩展属性
QFilter qFilter  里面已经包含了要查询的条件，系统将会完全使用该方法的返回结果做为查询条件查询多次次卡
扩展示例如下
// 设置要增加扩展字段 举例："extkey01"
event.setExtKeys(Sets.newHashSet("extkey01"));
// 修改查询过滤条件 列，增加时区限制 qFilter.and(new QFilter("timezone", QCP.in,320881823238577152L));QFilterqFilter= event.getQFilter();
@param `event` 扩展入参


class_name: kd.sdk.wtc.wtes.business.tie.init.logiccard.TieInitEffectiveCardExtPlugin
method_name: onQueryOnceEffectiveCard
param_types_key: OnQueryInitParamOfLogicCardEvent
signature_text: default void onQueryOnceEffectiveCard(OnQueryInitParamOfLogicCardEvent event)
comment:
执行查询有效一次卡初始化参数前置事件方法，支持修改预置核算参数的查询条件和新增查询字段
考勤核算时，需要先准备数据，本接口适用于初始化一次卡数据的时候扩展
Set<String> extKeys 支持查询时扩展的查询字段，扩展的属性必须是 一次卡元数据（wtpm_oncecard） 里的扩展属性
QFilter qFilter  里面已经包含了要查询的条件，系统将会完全使用该方法的返回结果做为查询条件查询一次卡
扩展示例如下
// 设置要增加扩展字段 举例："extkey01"
event.setExtKeys(Sets.newHashSet("extkey01"));
// 修改查询过滤条件 列，增加时区限制 qFilter.and(new QFilter("timezone", QCP.in,320881823238577152L));QFilterqFilter= event.getQFilter();
@param `event` 扩展入参


class_name: kd.sdk.wtc.wtes.business.tie.init.perattperiod.PerAttPeriodQueryParamExt
method_name: setQFilter
param_types_key: QFilter
signature_text: void setQFilter(QFilter qFilter)
comment:
设置其它的查询条件，默认是空的
// 举例设置查询业务状态的数据状态QFilterattPersonIdsFilter=newQFilter(AttConstants.BUSISTATUS, QCP.equals, busiStatus)
@param `qFilter` 设置其它的过滤条件


class_name: kd.sdk.wtc.wtes.business.tie.init.perattperiod.TieInitAttPeriodExtPlugin
method_name: onQueryAttPeriod
param_types_key: OnQueryInitParamOfPerAttPeriodEvent
signature_text: void onQueryAttPeriod(OnQueryInitParamOfPerAttPeriodEvent event)
comment:
考勤核算人员考勤期间初始化扩展方法
考勤核算时，需要先准备数据，本接口适用于人员考勤期间数据准备的查询条件构建
Set<String> extKeys 支持查询时扩展的查询字段，扩展的属性必须是 人员考勤期间元数据（wtp_perattperiod） 里的扩展属性
PerAttPeriodQueryParamExt  提供查询人员考勤期间时设置一些查询的条件
扩展示例如下
publicvoidonQueryAttPeriod(OnQueryInitParamOfPerAttPeriodEvent event) {
// 查询时增加额外的考勤人查询
event.getAttFileQueryParam().getAttPersonSetIds().add(1863000118957967360L);
// 扩展字段增加总天数，扩展字段必须来自档案（wtp_perattperiod）
event.setExtKeys(Sets.newHashSet("totaldays"));
}
@param `event` 扩展入参


class_name: kd.sdk.wtc.wtes.business.tie.model.attconfig.AttRuleCalExt
method_name: getAttCustomDurations
param_types_key: LocalDate
comment: 根据日期获取自定义出勤时长分录的时序性数据 @param `chainDate`
signature_text:
java.util.List<kd.sdk.wtc.wtes.business.tie.model.attconfig.AttCustomDurationExt> getAttCustomDurations(java.time.LocalDate chainDate)


class_name: kd.sdk.wtc.wtes.business.tie.model.attfile.AttFileExt
method_name: getAttCard
param_types_key: LocalDate
signature_text: String getAttCard(java.time.LocalDate inDate)
comment:
获取指定日期` inDate`所使用的分录数据 考勤卡号
@param `inDate` 使用的日期，不能为null
@return 无法获取有效数据将返回null
@throws `NullPointerException` if inDate is null


class_name: kd.sdk.wtc.wtes.business.tie.model.attfile.AttFileExt
method_name: getAttMode
param_types_key: LocalDate
signature_text: String getAttMode(java.time.LocalDate inDate)
comment:
获取指定日期` inDate`所使用的考勤方式
@param `inDate` 使用方案的日期，不能为null
@return 考勤方式，如果无法获取有效考勤方式将返回null
@throws `NullPointerException` if inDate is null


class_name: kd.sdk.wtc.wtes.business.tie.model.attitem.AttItemInstanceExt
method_name: <init>
param_types_key: AttItemSpecExt,BigDecimal,BigDecimal,BigDecimal
signature_text:
public AttItemInstanceExt(AttItemSpecExt attItemSpecExt, java.math.BigDecimal itemValue, java.math.BigDecimal day, java.math.BigDecimal secondDecimal)

comment:
考勤项目构造器
@param `attItemSpecExt` 考勤项目定义
@param `itemValue` 考勤项目值
@param `day` 考勤项目值（单位：天）
@param `secondDecimal` 考勤项目值（单位秒：天）


class_name: kd.sdk.wtc.wtes.business.tie.model.attitem.ExAttItemInstanceExt
method_name: <init>
param_types_key: AttItemSpecExt,BigDecimal,BigDecimal,BigDecimal
signature_text:
public ExAttItemInstanceExt(AttItemSpecExt attItemSpecExt, java.math.BigDecimal itemValue, java.math.BigDecimal day, java.math.BigDecimal secondDecimal)

comment:
异常考勤项目构造器
@param `attItemSpecExt` 考勤项目定义
@param `itemValue` 考勤项目值
@param `day` 考勤项目值（单位：天）
@param `secondDecimal` 考勤项目值（单位秒：天）


class_name: kd.sdk.wtc.wtes.business.tie.model.otcal.OtSubConfigExt
method_name: getOtDeductSubTimeItemList
comment: @return 满减扣除
signature_text:
java.util.List<kd.sdk.wtc.wtes.business.tie.model.otcal.OtDeductSubTimeItemExt> getOtDeductSubTimeItemList()


class_name: kd.sdk.wtc.wtes.business.tie.model.timebucket.AttBillTimeBucketExt
method_name: newInstanceResetTime
param_types_key: AttBillTimeBucketExt,LocalDate,LocalDateTime,LocalDateTime
signature_text:
AttBillTimeBucketExt newInstanceResetTime(AttBillTimeBucketExt attBillTimeBucketExt, java.time.LocalDate rosterDate, java.time.LocalDateTime startTime, java.time.LocalDateTime endTime)


class_name: kd.sdk.wtc.wtes.business.tie.model.timebucket.AttBillTimeBucketExt
method_name: split
param_types_key: LocalDateTime,LocalDateTime
signature_text: AttBillTimeBucketExt split(java.time.LocalDateTime newStart, java.time.LocalDateTime newEnd)
comment:
根据新的开始和结束时间，从当前timeBucket中拆分出新的TimeBucket（除开始时间和结束时间外，都是复制自当前对象，注意当前不支持无时段的timebucket拆分）
@param `newStart` 新的开始时间
@param `newEnd` 新的结束时间
@return AttBillTimeBucketExt 新的timeBucket


class_name: kd.sdk.wtc.wtes.business.tie.persistent.clean.AfterCleanExDataEvent
method_name: <init>
param_types_key: List,TieRequestExt
signature_text:
public AfterCleanExDataEvent(java.util.List<AttStateExt> attStateExtList, TieRequestExt tieRequestExt)


class_name: kd.sdk.wtc.wtes.business.tie.persistent.clean.TieCleanExDataExtPlugin
method_name: afterCleanExData
param_types_key: AfterCleanExDataEvent
signature_text: void afterCleanExData(AfterCleanExDataEvent afterCleanExDataEvent)
comment:
清理异常数据后置事件方法，支持清理异常考勤核算结果数据后处理扩展逻辑，比如删除客开的异常考勤核算结果数据。
当标品清理异常数据执行后，调用此扩展，删除个性化的异常考勤核算结果数据
publicvoidafterCleanExData(AfterCleanExDataEvent afterCleanExDataEvent) {
try {
// 获取核算信息集合
List<AttStateExt> attStateExtList = afterCleanExDataEvent.getAttStateExtList();
// 页面发起核算请求的考勤档案boId，并非实际核算的
List<Long> requestAttFileBoIdList = afterCleanExDataEvent.getTieRequestExt().getAttFileBoIdList();
// 记录有异常的考勤档案boId
List<Long> attFileBoIdList = newArrayList<>();
for (AttStateExt attStateInfoBO : attStateExtList) {
// 判断是否有异常if (attStateInfoBO.isExState() != null && !attStateInfoBO.isExState()) {
continue;
}
// 已锁定至DatelockToDate= attStateInfoBO.getLockTo();
// 异常开始日期DateexStartDate= attStateInfoBO.getExcStartDate();
// 异常结束日期DateexEndDate= attStateInfoBO.getExcEndDate();
// 档案BoIdLongfileBoId= attStateInfoBO.getFileBoId();
if (lockToDate != null && lockToDate.getTime() >= exStartDate.getTime()) {
// 不清除
} else {
attFileBoIdList.add(fileBoId);
// 如按考勤档案boId和异常开始日期进行清理// doClearByAttFileBoId(fileBoId, exStartDate);
}
}
} catch (Exception ex) {
logger.warn("TieCleanExDataExtPluginDemo.afterCleanExData error", ex);
}
}
@param `afterCleanExDataEvent` 清理异常数据后置事件


class_name: kd.sdk.wtc.wtes.business.tie.persistent.clean.TieCleanHisDataExtPlugin
method_name: afterCleanHisData
param_types_key: AfterCleanHisDataEvent
signature_text: void afterCleanHisData(AfterCleanHisDataEvent afterCleanHisDataEvent)
comment:
清理历史数据后置事件方法，支持在清理历史考勤核算结果数据后处理扩展逻辑，比如删除客开的考勤核算结果数据。
当标品清理历史数据执行后，调用此扩展，删除个性化的考勤核算结果数据
publicvoidafterCleanHisData(AfterCleanHisDataEvent afterCleanHisDataEvent) {
try {
// 考勤核算主体
List<TieAttSubjectExt> attSubjects = afterCleanHisDataEvent.getAttSubjects();
// 构造清理请求参数
List<QFilter> qFilterList = newArrayList<>();
QFilter qFilterKey;
Map<String, Tuple<QFilter, List<Long>>> qFilterListMap = newHashMap<>();
for (TieAttSubjectExt attSubject : attSubjects) {
// attSubject.getStartDate()为开始时间；attSubject.getEndDate()为结束时间；
qFilterKey = newQFilter("perperiodbegindate", QCP.less_equals, attSubject.getEndDate())
.and("perperiodenddate", QCP.large_equals, attSubject.getStartDate());
Tuple<QFilter, List<Long>> personIdList = qFilterListMap.get(qFilterKey.toString());
if (personIdList == null) {
personIdList = newTuple<>(qFilterKey, newArrayList<>());
}
for (TieAttFileBoExt attFileBo : attSubject.getAttFileBos()) {
// 考勤档案下的考勤答案boId
personIdList.getValue().add(attFileBo.getAttFileBoId());
}
qFilterListMap.put(qFilterKey.toString(), personIdList);
}
QFilter result;
for (Map.Entry<String, Tuple<QFilter, List<Long>>> entry : qFilterListMap.entrySet()) {
if (entry.getValue().getValue().size() == 1) {
result = newQFilter("attfileid", QCP.equals, entry.getValue().getValue().get(0)).and(entry.getValue().getKey());
} else {
result = newQFilter("attfileid", QCP.in, entry.getValue().getValue()).and(entry.getValue().getKey());
}
qFilterList.add(result);
}
QFilterqFilter=null;
// 组装请求参数for (QFilter filter : qFilterList) {
if (null == qFilter) {
qFilter = filter;
} else {
qFilter.or(filter);
}
}
// 根据构造的参数清理自己扩展的元数据数据// serviceHelper.deleteByFilter(new QFilter[]{qFilter});
} catch (Exception ex) {
logger.warn("TieCleanHisDataExtPluginDemo.afterCleanHisData error", ex);
}
}
@param `afterCleanHisDataEvent` 清理历史数据后置事件


class_name: kd.sdk.wtc.wtes.business.tie.persistent.daily.BeforeSaveDailyDataResultEvent
method_name: <init>
param_types_key: List,TieContentPersistentExt
signature_text:
public BeforeSaveDailyDataResultEvent(java.util.List<TieDataResultRelExt> tieDataResultRelExtList, TieContentPersistentExt tieContentPersistentExt)


class_name: kd.sdk.wtc.wtes.business.tie.persistent.daily.BeforeSaveDailyDataResultEvent
method_name: getTieDataResultRelExtList
signature_text: public java.util.List<TieDataResultRelExt> getTieDataResultRelExtList()
comment:
获取日明细项目主表和日明细项目明细表对应关系集合 日明细项目主表元数据（wtdtd_attrecordbase） 日明细项目明细表元数据（wtdtd_attrecorddetail）
@return 日明细项目主表和日明细项目明细表对应关系集合


class_name: kd.sdk.wtc.wtes.business.tie.persistent.daily.TieSaveDailyDataExtPlugin
method_name: beforeSaveDailyDataResult
param_types_key: BeforeSaveDailyDataResultEvent
signature_text: void beforeSaveDailyDataResult(BeforeSaveDailyDataResultEvent beforeSaveDailyDataResultEvent)
comment:
写入考勤核算明细结果数据前置事件方法，支持在考勤明细结果数据中写入扩展字段。
当标品考勤明细结果数据入库前，调用此扩展，在考勤明细结果数据中写入扩展字段
publicvoidbeforeSaveDailyDataResult(BeforeSaveDailyDataResultEvent beforeSaveDailyDataResultEvent) {
// 考勤核算上下文 可以获取排班，考勤项目定义，扩展参数，人员信息TieContentPersistentExttieContentPersistentExt= beforeSaveDailyDataResultEvent.getTieContentPersistentExt();
// 日明细项目主表和日明细项目明细表对应关系集合
List<TieDataResultRelExt> tieDataResultRelExtList = beforeSaveDailyDataResultEvent.getTieDataResultRelExtList();
for (inti=0; i < tieDataResultRelExtList.size(); i++) {
// 日明细项目主表和日明细项目明细表对应关系TieDataResultRelExttieDataResultRelExt= tieDataResultRelExtList.get(i);
// tieDataResultRelExt.getMainObject()为日明细项目主表元数据为(wtdtd_attrecordbase)；paramsext1，paramsext2为扩展字段// 日明细主表不能覆盖的字段为"createtime", "calculatedate", "reckoner", "personid", "orgid", "owndate", "datetype", "dateattr", "shiftvid", "shiftid", "departmentvid", "companyvid", "positionvid", "jobvid", "mode", "versionid", "perattperiodid", "perperiodenddate", "perperiodbegindate", "attperattperiodid", "managescopevid", "affiliateadminorgvid", "attperattperiodpk", "attfileid", "attfilevid"// 通过setExtProperties设置扩展属性的值，返回设置失败的键值对
Map<String, String> failMap = tieDataResultRelExt.getMainObject().setExtProperties("paramsext1", i);
tieDataResultRelExt.getMainObject().setExtProperties("paramsext2", tieDataResultRelExt.getDetailObjects().size());
// tieDataResultRelExt.getDetailObjects()日明细项目明细表元数据为(wtdtd_attrecorddetail)；paramsext1，paramsext2为扩展字段// 日明细项目明细表不能覆盖的字段为"owndate", "attitemtype", "attitemvid", "attitemid", "value", "valuesecond", "valuestring", "valuelong", "sourceattitemids", "attmain", "managingscope", "empgroup", "dependency", "dependencytype", "agreedworkplace", "workplace"
List<TieDataResultExt> detailObjects = tieDataResultRelExt.getDetailObjects();
for (intj=0; j < detailObjects.size(); j++) {
TieDataResultExttieDataResultExt= detailObjects.get(j);
tieDataResultExt.setExtProperties("paramsext1", i);
tieDataResultExt.setExtProperties("paramsext2", j);
}
}
}
@param `beforeSaveDailyDataResultEvent` 写入考勤核算明细结果数据前置事件


class_name: kd.sdk.wtc.wtes.business.tie.persistent.period.AfterSaveAllPerPeriodDataResultEvent
method_name: <init>
param_types_key: List,TieAttPeriodContextExt
signature_text:
public AfterSaveAllPerPeriodDataResultEvent(java.util.List<TieDataResultRelExt> tieDataResultRelExtList, TieAttPeriodContextExt tieAttPeriodContextExt)


class_name: kd.sdk.wtc.wtes.business.tie.persistent.period.AfterSaveAllPerPeriodDataResultEvent
method_name: getTieDataResultRelExtList
signature_text: public java.util.List<TieDataResultRelExt> getTieDataResultRelExtList()
comment:
获取期间汇总主表和期间汇总明细表对应关系集合 期间汇总主表元数据(wtctd_atttotalbase) 期间汇总明细表元数据(wtctd_atttotaldetail)
@return 期间汇总主表和期间汇总明细表对应关系集合


class_name: kd.sdk.wtc.wtes.business.tie.persistent.period.BeforeSavePerPeriodDataResultEvent
method_name: <init>
param_types_key: List,TieAttPeriodContextExt
signature_text:
public BeforeSavePerPeriodDataResultEvent(java.util.List<TieDataResultRelExt> tieDataResultRelExtList, TieAttPeriodContextExt tieAttPeriodContextExt)


class_name: kd.sdk.wtc.wtes.business.tie.persistent.period.TieSaveAllAttPeriodDataExtPlugin
method_name: afterSaveAllPerPeriodDataResult
param_types_key: AfterSaveAllPerPeriodDataResultEvent
signature_text:
void afterSaveAllPerPeriodDataResult(AfterSaveAllPerPeriodDataResultEvent afterSaveAllPerPeriodDataResultEvent)

comment:
写入所有考勤核算汇总结果数据后置事件方法，支持在汇总核算结果数据写入后处理扩展逻辑，比如写入其他期间汇总数据。
当标品期间汇总结果数据入库后，调用此扩展，处理个性化的扩展逻辑，比如写入其他期间汇总数据
publicvoidafterSaveAllPerPeriodDataResult(AfterSaveAllPerPeriodDataResultEvent afterSaveAllPerPeriodDataResultEvent) {
try {
// 考勤核算期间汇总上下文，含页面请求参数，实际考勤核算主体，所有要期间汇总的人员考勤期间集合等TieAttPeriodContextExttieAttPeriodContextExt= afterSaveAllPerPeriodDataResultEvent.getTieAttPeriodContextExt();
// 考勤核算的页面请求参数TieRequestExttieRequestExt= tieAttPeriodContextExt.getTieRequestExt();
// 实际的考勤核算主体
List<TieAttSubjectExt> attSubjects = tieAttPeriodContextExt.getAttSubjects();
DynamicObjectCollectiondynamicObjects=newDynamicObjectCollection();
attSubjects.forEach(item -> {
// 构建元数据（kdtest_wtctd_atttotal）动态对象DynamicObjectext= BusinessDataServiceHelper.newDynamicObject("kdtest_wtctd_atttotal");
ext.set("taskid", tieRequestExt.getTaskId());
ext.set("version", tieRequestExt.getVersion());
ext.set("totalpersoncount", attSubjects.size());
ext.set("personid", item.getAttPersonId());
dynamicObjects.add(ext);
});
HRBaseServiceHelperserviceHelper=newHRBaseServiceHelper("kdtest_wtctd_atttotal");
// 数据入库
serviceHelper.save(dynamicObjects);
} catch (Exception ex) {
logger.warn("TieSaveAllAttPeriodDataExtPluginDemo.afterSaveAllPerPeriodDataResult error", ex);
}
}
@param `afterSaveAllPerPeriodDataResultEvent` 写入所有考勤核算汇总结果数据后置事件


class_name: kd.sdk.wtc.wtes.business.tie.persistent.period.TieSavePerPeriodDataExtPlugin
method_name: beforeSavePerPeriodDataResult
param_types_key: BeforeSavePerPeriodDataResultEvent
signature_text:
void beforeSavePerPeriodDataResult(BeforeSavePerPeriodDataResultEvent beforeSavePerPeriodDataResultEvent)

comment:
写入考勤核算汇总结果数据前置事件方法，支持在考勤汇总记录结果数据中写入扩展字段。
当标品期间汇总结果数据入库前，调用此扩展，在考勤汇总记录结果数据中写入扩展字段
publicvoidbeforeSavePerPeriodDataResult(BeforeSavePerPeriodDataResultEvent beforeSavePerPeriodDataResultEvent) {
// 考勤核算期间汇总上下文，含页面请求参数，实际考勤核算主体，所有要期间汇总的人员考勤期间集合等TieAttPeriodContextExttieAttPeriodContextExt= beforeSavePerPeriodDataResultEvent.getTieAttPeriodContextExt();
// 期间汇总主表和期间汇总明细表对应关系集合
List<TieDataResultRelExt> tieDataResultRelExtList = beforeSavePerPeriodDataResultEvent.getTieDataResultRelExtList();
// 页面请求参数TieRequestExttieRequestExt= beforeSavePerPeriodDataResultEvent.getTieAttPeriodContextExt().getTieRequestExt();
for (inti=0; i < tieDataResultRelExtList.size(); i++) {
// 期间汇总主表和期间汇总明细表对应关系TieDataResultRelExttieDataResultRelExt= tieDataResultRelExtList.get(i);
// tieDataResultRelExt.getMainObject()为期间汇总主表元数据为(wtctd_atttotalbase)；paramsext1，paramsext2为扩展字段// 期间汇总主表不能覆盖的字段为"personid", "orgid", "companyvid", "positionvid", "departmentvid", "jobvid", "modifierfieldname", "createtime", "calculatedate", "versionid", "managescopevid", "affiliateadminorgvid", "reckoner", "attfileid", "attfilevid", "perattperiodid", "attperattperiodid", "perperiodbegindate", "perperiodenddate", "attperattperiodpk"// 通过setExtProperties设置扩展属性的值，返回设置失败的键值对
Map<String, String> failMap = tieDataResultRelExt.getMainObject().setExtProperties("paramsext1", i);
tieDataResultRelExt.getMainObject().setExtProperties("paramsext2", tieRequestExt.getVersion());
// tieDataResultRelExt.getDetailObjects()期间汇总明细表元数据为(wtctd_atttotaldetail)；paramsext1，paramsext2为扩展字段// 期间汇总明细表不能覆盖的字段为"perattperiodid", "attmain", "attitemtype", "attitemvid", "attitemid", "valuelong", "managingscope", "empgroup", "dependency", "dependencytype", "agreedworkplace", "workplace"
List<TieDataResultExt> detailObjects = tieDataResultRelExt.getDetailObjects();
for (intj=0; j < detailObjects.size(); j++) {
TieDataResultExttieDataResultExt= detailObjects.get(j);
tieDataResultExt.setExtProperties("paramsext1", j);
tieDataResultExt.setExtProperties("paramsext2", tieRequestExt.getVersion());
}
}
@param `beforeSavePerPeriodDataResultEvent` 写入考勤核算汇总结果数据前置事件


class_name: kd.sdk.wtc.wtes.business.tie.persistent.utils.TieDataResultExt
method_name: setExtProperties
param_types_key: Map
comment: 根据属性键值对设置扩展字段的属性值 @param `propertyMap` 属性名称和属性值键值对 @return 返回设置失败的属性和原因
signature_text:
public final java.util.Map<String, String> setExtProperties(java.util.Map<String, Object> propertyMap)


class_name: kd.sdk.wtc.wtes.business.tie.persistent.utils.TieDataResultRelExt
method_name: <init>
param_types_key: TieDataResultExt,List
signature_text:
public TieDataResultRelExt(TieDataResultExt mainObject, java.util.List<TieDataResultExt> detailObjects)


class_name: kd.sdk.wtc.wtes.business.tie.task.AfterTieTaskEndEvent
method_name: <init>
param_types_key: Long,Long,String,Set
signature_text:
public AfterTieTaskEndEvent(Long taskId, Long subTaskId, String version, java.util.Set<Long> attFileBoIds)


class_name: kd.sdk.wtc.wtes.business.tie.task.TieTaskEndExtPlugin
method_name: afterTieTaskEnd
param_types_key: AfterTieTaskEndEvent
signature_text: void afterTieTaskEnd(AfterTieTaskEndEvent afterTieTaskEndEvent)
comment:
考勤核算分片任务结束后处理事件，支持在考勤核算分片任务结束后处理个性化的扩展逻辑。
当标品考勤核算分片任务结束后，调用此扩展，处理个性化的扩展逻辑
LongtaskId= afterTieTaskEndEvent.getTaskId();
LongsubTaskId= afterTieTaskEndEvent.getSubTaskId();
Stringversion= afterTieTaskEndEvent.getVersion();
Set<Long> attFileBoIds = afterTieTaskEndEvent.getAttFileBoIds();
logger.info("考勤核算分片任务结束扩展接口taskId={},subTaskId={},version={},attFileBoIds={}", taskId, subTaskId, version, attFileBoIds);
@param `afterTieTaskEndEvent` 考勤核算分片任务结束后处理事件


class_name: kd.sdk.wtc.wtes.business.timecut.OnTimeCutMatchEvent
method_name: <init>
param_types_key: TieContextExt,RefDateType,ConditionDtoExt,WTCDateRangeSource
signature_text:
public OnTimeCutMatchEvent(TieContextExt tieContextExt, RefDateType refDateType, ConditionDtoExt conditionDtoExt, WTCDateRangeSource wtcDateRangeSource)


class_name: kd.sdk.wtc.wtes.business.timecut.TimeCutMatchExtPlugin
method_name: onTimeCutMatch
param_types_key: OnTimeCutMatchEvent
signature_text: void onTimeCutMatch(OnTimeCutMatchEvent onTimeCutMatchEvent)
comment:
核算触发解析 扩展的时段切分条件匹配的条件字段 对应的结果的事件
时段切分条件匹配的条件字段增加了之后，这些扩展字段的解析结果可以通过实现该接口来处理
@param `onTimeCutMatchEvent` 核算触发解析扩展的时段切分条件事件对象


class_name: kd.sdk.wtc.wtis.business.attdata.BeforeSavePayAttDataInfoEvent
method_name: <init>
param_types_key: String,long,long,DynamicObject,DynamicObject
signature_text:
public BeforeSavePayAttDataInfoEvent(String version, long mainTaskId, long taskId, DynamicObject rule, DynamicObject periodInfo)


class_name: kd.sdk.wtc.wtis.business.attdata.DoSetExtFieldEvent
method_name: <init>
param_types_key: DynamicObject,List
signature_text: public DoSetExtFieldEvent(DynamicObject payAttDataInfo, java.util.List<Object> restOneData)
comment:
构造方法
@param `payAttDataInfo` 数据库查到的数据 (T_WTIS_PAYATTDATAINFO)
@param `restOneData` 返回的每行数据,如果有额外增加的字段，按照顺序往 restOneData 里面加入


class_name: kd.sdk.wtc.wtis.business.coordination.NewAttFileCoordinationExpService
method_name: genAttFileSchemeForEntry
param_types_key: AttFileSchemeDto) genAttFileSchemeForEntry(EntryCoordinationParam
signature_text:
@Nullable() (@kd.sdk.wtc.wtbs.common.lang.Nullable :: kd.sdk.wtc.wtis.business.coordination.AttFileSchemeDto) genAttFileSchemeForEntry(EntryCoordinationParam entryCoordinationParam)

comment:
员工入职的时候生成档案的基础方案和规则方案。
员工入职的时候，工时假勤会监听到这个事件，通过中台协同生成档案； 但生成的档案目前默认是没有规则方案和基础方案的，可以通过本接口扩展实现来生成对应的规则方案和基础方案。
@param `entryCoordinationParam` 入职协同生成档案的业务对象
@return 档案的基础方案和规则方案的dto，如果无法获取合适的方案规则，则返回null


class_name: kd.sdk.wtc.wtom.business.applytime.OnSetOtApplyTimeQuery
method_name: getShiftDtoMap
signature_text:
public java.util.Map<java.time.LocalDate, kd.sdk.wtc.wtbs.common.dto.shift.ShiftDto> getShiftDtoMap()


class_name: kd.sdk.wtc.wtom.business.applytime.OnSetOtApplyTimeQuery
method_name: setShiftDtoMap
param_types_key: Map
signature_text:
setShiftDtoMap(java.util.Map<java.time.LocalDate, kd.sdk.wtc.wtbs.common.dto.shift.ShiftDto> shiftDtoMap)


class_name: kd.sdk.wtc.wtom.business.OtDutyDateExtPlugin
method_name: onMatchOtDutyDate
param_types_key: OnMatchOtDutyDateEvent
signature_text: void onMatchOtDutyDate(OnMatchOtDutyDateEvent onMatchOtDutyDateEvent)
comment:
时段申请自定义加班时间。
按时段申请的加班单，会根据该接口的实现，返回用户自定的加班日期到单据上。 OtDutyDateParam 注意： 1、当标准日期不为空，自定义的加班日期返回不能为空 2、加班时段如果在班次内不允许调整，如果非班次时段，则允许调整为前后的排班日期为加班日期 3、自定义加班日期所属的档案必须存在排班 4、自定义加班日期只能返回零点，如2023-11-06 00:00:00 ,不允许为2023-11-06 16:30:00
扩展示例如下
@param `onMatchOtDutyDateEvent` 加班单加班日期事件


class_name: kd.sdk.wtc.wtom.business.WtomHelper
method_name: getOTRuleInfo
param_types_key: List
comment: 获取加班规则（包含匹配的计算规则） 根据获取加班规则（包含匹配的计算规则） @param `otRuleQuery` 规则参数信息
signature_text:
public java.util.List<kd.sdk.wtc.wtom.business.common.OtRuleResp> getOTRuleInfo(java.util.List<kd.sdk.wtc.wtom.business.common.OtRuleQuery> otRuleQuery)


class_name: kd.sdk.wtc.wtom.business.WtomHelper
method_name: getStandardDutyDate
param_types_key: List
comment: 获取标准加班日期 获取标准产品逻辑下的加班日期 @param `standardDutyDateParam` 参数信息
signature_text:
public java.util.List<kd.sdk.wtc.wtom.business.common.OtStandardDutyDateResp> getStandardDutyDate(java.util.List<kd.sdk.wtc.wtom.business.common.OtStandardDutyDateQuery> standardDutyDateParam)


class_name: kd.sdk.wtc.wtom.business.WtomHelper
method_name: validateOtBills
param_types_key: List,String
signature_text:
public java.util.List<kd.sdk.wtc.wtom.business.validate.OtBillValidateResult> validateOtBills(java.util.List<DynamicObject> otBillDys, String appId)

comment:
本人申请、为他人申请加班单校验
failCode 校验项  MUST_INPUT	必录  	单据信息：id,attfile,attfilebasef7,personid,applytyperadio,ischange,isnewbill,originalid,parent,iscancel,otapplytype,sdottype  	时段信息：sdottype,otstartdate,otenddate  	时长信息：scottype,otdate,otdtime  ATTACHMENT	附件校验  LARGETZERO	申请时间需要大于0校验  OVER24INONEBILL	当前单据分录对应的加班日期小于24小时校验  REPEATINONEBILL	当前单据分录间时段重叠校验  EACHDATESHIFT	申请的加班时间每天包含排班校验  EXISTDUTYDATE	加班日期（归属日）存在校验  SHIFT	加班日期（归属日）排班校验  INSHIF	申请时段是否在出勤时段内校验  DUTYAUTH	加班日期（归属日）档案权限校验  SIMULATION_PERIOD	加班日期（归属日）模拟时段校验  OVER24	不同单据间24小时校验  REPEAT	不同单据间时段重复校验  SUSPEND	加班日期（归属日）暂停考勤校验  FROZEN	加班日期（归属日）冻结校验  PLANS	加班日期（归属日）方案存在校验  RULE	加班日期（归属日）规则存在校验  BASESET	加班日期（归属日）基础存在配置  MINOT	加班日期（归属日）符合最小加班时长校验  ADVANCE_AND_AFTER	加班日期（归属日）符合预提补提校验  MAX_LIMIT_ADVANCE	加班日期（归属日）符合最大提单范围校验  REASON	原因必填校验  SCFLXS	限制弹性班后加班校验  FLXS	限制弹性班后加班校验  COMPENSATION	补偿方式正确性校验  LARGERTIME	结束时间大于开始时间
@param `otBillDys` 加班单据校验对象，如入参为空，则返回空集合。
@param `appId` 应用标识，如 日常考勤（wtam），用于校验档案的权限(默认日常考勤（wtam）)
@return 加班校验结果集合


class_name: kd.sdk.wtc.wtom.OtDutyDateParam
method_name: <init>
param_types_key: DynamicObject,DynamicObject,int,Date
signature_text:
public OtDutyDateParam(DynamicObject otBillDy, DynamicObject entryDy, int entryIndex, java.util.Date standardDutyDate)


class_name: kd.sdk.wtc.wtp.business.adplan.AdPlanHelper
method_name: getAdPlanAndRule
param_types_key: List
signature_text:
public java.util.List<AdPlanRuleResp> getAdPlanAndRule(java.util.List<AdPlanRuleQuery> adPlanRuleParams)

comment:
根据考勤档案BOID和补签日期查询对应的补签方案和补签规则
考勤档案BOID和补签日期是必传项，返回该考勤档案下对应补签日期的补签方案和补签规则
@param `adPlanRuleParams` 请求参数
@return List 响应参数


class_name: kd.sdk.wtc.wtp.business.attfile.IAttFileDiscardExpandService
method_name: handleAttFileRelateData
param_types_key: List
signature_text:
java.util.Map<String, java.util.Map<Long, String>> handleAttFileRelateData(java.util.List<Long> fileBoIds)

comment:
返回值说明： key: success 处理成功的数据标识，failed 处理失败的数据标识 value: 处理成功和失败信息 类型为Map 格式如下 key: 档案boId 类型Long 如：1575282784384182272L value: 类型为String 错误信息 如：”档案正在执行更新任务，不可废弃。“ 例如： { "success":{ 1575282784384182272:"档案正在执行更新任务，不可废弃。" } }
@param `fileBoIds` 需要处理的考勤档案boId
@return Map>


class_name: kd.sdk.wtc.wtp.business.attfile.WTPAttFileHelper
method_name: getAttFile
param_types_key: LocalDate,long,UserModelType
signature_text:
public static (@kd.sdk.wtc.wtbs.common.lang.Nullable :: kd.sdk.wtc.wtp.business.attfile.AttFileVersion) getAttFile(java.time.LocalDate localDate, long userId, UserModelType userType)

comment:
通过人员类型，人员id查询某一天的档案版本
@param `localDate` 日期
@param `userId` 人员id
@param `userType` 人员类型
@return 档案版本信息的业务对象


class_name: kd.sdk.wtc.wtp.business.attperiod.WTPPerAttPeriodHelper
method_name: getPerAttPeriods
param_types_key: PerAttPeriodQueryParam
signature_text:
public static java.util.List<PerAttPeriod> getPerAttPeriods(PerAttPeriodQueryParam perAttPeriodQueryParam)

comment:
查询人员考勤期间列表
查询到的人员考勤期间日期范围与查询条件中的日期范围有交集，查询不到数据返回空集合
`
@param `perAttPeriodQueryParam` 查询请求
@return List 人员考勤期间列表，如果查询不到数据则返回空集合，如果查询条件中 attFileBoId==0或者startDate==null或endDate == null 则返回null


class_name: kd.sdk.wtc.wtp.business.attperiod.WTPPerAttPeriodHelper
method_name: getPerAttPeriod
param_types_key: PerAttPeriod) getPerAttPeriod(long,LocalDate
signature_text:
public static (@kd.sdk.wtc.wtbs.common.lang.Nullable :: kd.sdk.wtc.wtp.business.attperiod.PerAttPeriod) getPerAttPeriod(long attFileBoId, java.time.LocalDate dateInAttPeriod)

comment:
查询人员考勤期间
查询到的人员考勤的日期范围需包含指定日期 ` dateInAttPeriod</code>`
`
`
`
@param `attFileBoId` 考勤档案BoId
@param `dateInAttPeriod` 人员考勤期间中的某个日期，查询到的人员考勤期间日期范围包含该日期
@return 人员考勤期间，如果查不到则返回null；attFileBoId == 0 或者 dateInAttPeriod == null 则返回null


class_name: kd.sdk.wtc.wtp.business.attperson.WTPAttPersonHelper
method_name: getAttPerson
param_types_key: AttPerson) getAttPerson(long
comment: 通过自然人员id查询人员信息 @param `personId` 自然人id @return 考勤人员信息
signature_text:
public static (@kd.sdk.wtc.wtbs.common.lang.Nullable :: kd.sdk.wtc.wtp.business.attperson.AttPerson) getAttPerson(long personId)


class_name: kd.sdk.wtc.wtp.business.coordination.AfterCoordinationEvent
method_name: <init>
param_types_key: CoreCoordinationParam,DynamicObject,Map
signature_text:
public AfterCoordinationEvent(CoreCoordinationParam coreCoordinationParam, DynamicObject messageDy, java.util.Map<String, java.util.List<Object>> successPkIdMap)

comment:
AfterCoordinationEvent 构造方法
@param `coreCoordinationParam` coreCoordinationParam
@param `messageDy` messageDy
@param `successPkIdMap` successPkIdMap


class_name: kd.sdk.wtc.wtp.business.coordination.BeforeCoordinationEvent
method_name: <init>
param_types_key: CoreCoordinationParam,DynamicObject,boolean
signature_text:
public BeforeCoordinationEvent(CoreCoordinationParam coreCoordinationParam, DynamicObject messageDy, boolean stopCoordination)

comment:
BeforeCoordinationEvent 构造方法
@param `coreCoordinationParam` coreCoordinationParam
@param `messageDy` messageDy
@param `stopCoordination` stopCoordination


class_name: kd.sdk.wtc.wtp.business.coordination.CoordinationExecuteExtPlugin
method_name: afterExecuteCoordination
param_types_key: AfterCoordinationEvent
signature_text: default void afterExecuteCoordination(AfterCoordinationEvent afterCoordinationEvent)
comment:
协同执行后事件，协同执行后调用此接口，协同后处理和协同中处理的数据是分开的事务，一个协同事件只会执行一次
1.通过该接口可以在协同操作后根据协同事件核心参数，和已经协同处理成功的数据，可以自定义处理协同后业务逻辑，比如调动成功后需要修改或者刷新下游部分业务数据； 2.可以根据业务事件日志对象自定义处理业务事件日志和协作任务中心数据。
拓展示例：
示例代码可以参考人员协同任务执行扩展插件场景示例，扩展场景编码：kd.sdk.wtc.wtp.business.coordination.CoordinationExecuteExtPlugin
@param `afterCoordinationEvent` 协同事件执行后参数


class_name: kd.sdk.wtc.wtp.business.coordination.CoordinationExecuteExtPlugin
method_name: beforeExecuteCoordination
param_types_key: BeforeCoordinationEvent
signature_text: default void beforeExecuteCoordination(BeforeCoordinationEvent beforeCoordinationEvent)
comment:
协同执行前事件，协同执行前调用此接口，请注意协同前的数据处理，不会因协同事件失败而回撤，一个协同事件只会执行一次
1.可以在协同操作前根据协同事件核心参数前决定是否取消协同操作； 2.可以自定义处理协同前业务逻辑，比如转正前处理部分业务数据； 3.可以根据业务事件日志对象自定义处理业务事件日志和协作任务中心数据。
拓展示例：
示例代码可以参考人员协同任务执行扩展插件场景示例，扩展场景编码：kd.sdk.wtc.wtp.business.coordination.CoordinationExecuteExtPlugin
@param `beforeCoordinationEvent` 协同事件执行前参数


class_name: kd.sdk.wtc.wtp.business.coordination.CoordinationExecuteExtPlugin
method_name: executingCoordination
param_types_key: ExecutingCoordinationEvent
signature_text: default void executingCoordination(ExecutingCoordinationEvent executingCoordinationEvent)
comment:
协同执行中事件，在协同执行，调用实际的操作op前执行，一个协同事件可能会调用多次op操作，这里可能会执行多次 1.可以在协同执行中，修改执行的List exeOpDyList 动态对象数据，也可以自己自定义操作后，重定向执行新的操作operationKey； 2.可以根据业务事件日志对象自定义处理业务事件日志和协作任务中心数据。
拓展示例：
示例代码可以参考人员协同任务执行扩展插件场景示例，扩展场景编码：kd.sdk.wtc.wtp.business.coordination.CoordinationExecuteExtPlugin
@param `executingCoordinationEvent` 协同事件执行中参数


class_name: kd.sdk.wtc.wtp.business.coordination.CoordinationExpandService
method_name: genCoordinationSceneExpand
param_types_key: Map) genCoordinationSceneExpand(CoordinationExpandParam
signature_text:
@Nullable() (@kd.sdk.wtc.wtbs.common.lang.Nullable :: java.util.Map<String, Object>) genCoordinationSceneExpand(CoordinationExpandParam coordinationExpandParam)

comment:
核心人力的人员变动，生成/变更考勤档案。
核心人力的人员变动，工时假勤会监听到这个事件，通过中台协同生成/变更档案； 标品的生成/变更的档案的规则引擎场景不满足需求，可以通过本接口扩展实现来生成对应的规则引擎场景入参。
@param `coordinationExpandParam` 协同生成档案的业务对象
@return Map key:拓展的场景输入参数的参数标识，value:拓展的值，类型可以是基础资料，字符串、数值、布尔、日期等类型参数。


class_name: kd.sdk.wtc.wtp.business.coordination.CoreCoordinationParam
method_name: <init>
param_types_key: long,String,long,Date
comment: CoreCoordinationParam 构造方法
signature_text:
public CoreCoordinationParam(long configId, String msgSubNo, long personId, java.util.Date effectTime)


class_name: kd.sdk.wtc.wtp.business.coordination.ExecutingCoordinationEvent
method_name: <init>
param_types_key: String,String,DynamicObject,List
signature_text:
public ExecutingCoordinationEvent(String operationKey, String entityNumber, DynamicObject messageDy, java.util.List<DynamicObject> exeOpDyList)

comment:
ExecutingCoordinationEvent 构造方法
@param `operationKey` operationKey
@param `entityNumber` entityNumber
@param `messageDy` messageDy
@param `exeOpDyList` exeOpDyList


class_name: kd.sdk.wtc.wtp.business.coordination.ExecutingCoordinationEvent
method_name: <init>
param_types_key: String,String,CoreCoordinationParam,DynamicObject,List
signature_text:
public ExecutingCoordinationEvent(String operationKey, String entityNumber, CoreCoordinationParam coreCoordinationParam, DynamicObject messageDy, java.util.List<DynamicObject> exeOpDyList)


class_name: kd.sdk.wtc.wtp.business.formula.FormulaDataProvideExtPlugin
method_name: onDataProvide
param_types_key: OnDataProvideEvent
signature_text: void onDataProvide(OnDataProvideEvent onDataProvideEvent)
comment:
执行公式计算元素取数扩展,入参包含了: 1.扩展的计算元素唯一编码(uniqueCode),2.取数要用到的上下文map
拓展示例：
扩展案例参考：kd.sdk.wtc.wtp.business.formula.FormulaDataProvideExtDemo
@param `onDataProvideEvent` 考勤公式扩展取数事件


class_name: kd.sdk.wtc.wtp.business.quota.QuotaQueryParam
method_name: getEndDate
signature_text: public java.util.Date getEndDate()
comment:
时间范围过滤的结束时间，可为 null，为 null 时将直接使用当前时间查询且不考虑 startDate 的值。
当 startDate 和 endDate 任一一个为 null 时，将直接认定为使用当前系统日期查询。 当 startDate 和 endDate 均不为 null 时，要求 startDate 小于等于 endDate，否则返回空列表。


class_name: kd.sdk.wtc.wtp.business.quota.QuotaQueryParam
method_name: getStartDate
signature_text: public java.util.Date getStartDate()
comment:
时间范围过滤的开始时间，可为 null，为 null 时将直接使用当前时间查询且不考虑 endDate 的值。
当 startDate 和 endDate 任一一个为 null 时，将直接认定为使用当前系统日期查询。 当 startDate 和 endDate 均不为 null 时，要求 startDate 小于等于 endDate，否则返回空列表。


class_name: kd.sdk.wtc.wtp.business.quota.summary.QTSummaryExpService
method_name: query
param_types_key: ReportQueryParam,Object
signature_text: DataSet query(ReportQueryParam queryParam, Object object)
comment:
定额汇总报表查询方法
定额汇总报表查询方法
扩展示例如下,可以参考 @kd.sdk.wtc.wtp.business.quota.summary.DemoQTSummaryExpServiceImpl, 继承默认实现kd.sdk.wtc.wtp.business.quota.summary.QTSummaryServiceDef,然后选择要扩展的方法覆写
public DataSet query(ReportQueryParam queryParam, Object object) {
List<QFilter> qFilters = buildQFilters(queryParam);
List<QFilter> addQFilters = afterQFilters(queryParam);
if (addQFilters != null) {
qFilters.addAll(addQFilters);
}
DataSetdataSet= queryData(qFilters);
dataSet = groupAndSum(dataSet);
return dataSet;
}
@param `queryParam` 查询参数
@param `object` object
@return 报表数据


class_name: kd.sdk.wtc.wtp.business.quota.WTPQuotaHelper
method_name: queryQuota
param_types_key: QuotaQueryParam
signature_text: public static java.util.List<DynamicObject> queryQuota(QuotaQueryParam queryParam)
comment:
根据人员的档案boId查询的定额信息。
attfilebo（考勤档案bo）,
attfileid（考勤档案版本）,
qttype（定额类型）,
genstartdate（生成开始日期）,
genenddate（生成结束日期）,
usestartdate（使用开始日期）,
useenddate（使用结束日期）,
source（来源）,
ownvalue（享有可用值-自生成后固定）,
ownodvalue（享有透支值-自生成后固定）,
pastvalue（过期值-自生成后固定）,
balance（冲抵值-自生成后固定）,
cdedvalue（已结转值-自生成后固定）,
usablevalue（可用值-随单据的申请变化）,
freezevalue（冻结值-随单据的申请变化）,
usedvalue（已用值-随单据的申请变化）,
canbeodvalue（可透支值-随单据的申请变化）,
useodvalue（已透支值-随单据的申请变化）
@param `queryParam` 查询参数
@return 结果集中元素为页面（wtp_qtlinedetail）的动态对象，所查询的字段有：


class_name: kd.sdk.wtc.wtp.business.ruleengine.OnGenRuleEngineInputParamEvent
method_name: <init>
param_types_key: String,long,Map,Set,Map
signature_text:
public OnGenRuleEngineInputParamEvent(String source, long planVersionId, java.util.Map<String, Object> inputParamMap, java.util.Set<String> extendKeys, java.util.Map<String, Object> extendMap)


class_name: kd.sdk.wtc.wtp.business.ruleengine.OnGenRuleEngineInputParamEvent
method_name: <init>
param_types_key: Date,String,long,Map,Set,Map
comment: 适用于单据类调用规则引擎的条件字段二开埋点构造方法
signature_text:
public OnGenRuleEngineInputParamEvent(java.util.Date calDate, String source, long planVersionId, java.util.Map<String, Object> inputParamMap, java.util.Set<String> extendKeys, java.util.Map<String, Object> extendMap)


class_name: kd.sdk.wtc.wtp.business.ruleengine.OnGenRuleEngineInputParamEvent
method_name: <init>
param_types_key: Date,String,long,Map,Set,Map,TieContextExt
comment: 适用于核算链（单日核算链）调用规则引擎的条件字段二开埋点构造方法
signature_text:
public OnGenRuleEngineInputParamEvent(java.util.Date calDate, String source, long planVersionId, java.util.Map<String, Object> inputParamMap, java.util.Set<String> extendKeys, java.util.Map<String, Object> extendMap, TieContextExt tieContextExt)


class_name: kd.sdk.wtc.wtp.business.ruleengine.OnGenRuleEngineInputParamEvent
method_name: <init>
param_types_key: String,long,Map,Set,Map,TieAttPeriodContextExt,PerAttPeriodExt
comment: 适用于核算链（期间汇总核算链）调用规则引擎的条件字段二开埋点构造方法
signature_text:
public OnGenRuleEngineInputParamEvent(String source, long planVersionId, java.util.Map<String, Object> inputParamMap, java.util.Set<String> extendKeys, java.util.Map<String, Object> extendMap, TieAttPeriodContextExt tieAttPeriodContextExt, PerAttPeriodExt perAttPeriodExt)


class_name: kd.sdk.wtc.wtp.business.ruleengine.OnGenRuleEngineInputParamEvent
method_name: <init>
param_types_key: Date,String,long,Map,Set,Map,QteContextExt
comment: 适用于定额核算调用规则引擎的条件字段二开埋点构造方法
signature_text:
public OnGenRuleEngineInputParamEvent(java.util.Date calDate, String source, long planVersionId, java.util.Map<String, Object> inputParamMap, java.util.Set<String> extendKeys, java.util.Map<String, Object> extendMap, QteContextExt qteContextExt)


class_name: kd.sdk.wtc.wtp.business.ruleengine.RuleEngineInputParamExtPlugin
method_name: onGenInputParam
param_types_key: OnGenRuleEngineInputParamEvent
signature_text: void onGenInputParam(OnGenRuleEngineInputParamEvent onGenRuleEngineInputParamEvent)
comment:
wtc_scene_tp_v2 出差场景 wtc_scene_otp_v2 , wtc_scene_otp_v3加班场景 wtc_scene_idp_v2 增减场景 wtc_scene_attendplan_v2 出勤场景 wtc_scene_exception_v2 异常场景 wtc_scene_vacation_v2 休假场景 wtc_scene_ad_v2 补签场景 wtc_scene_quota_v2 定额方案场景 以上场景使用了规则引擎，且规则方案中输入参数包含了扩展字段，使用该方案的业务（比如考勤核算、休假单据）会调用该接口
入参包含了规则方案版本id、规则引擎条件入参map：inputParamMap、扩展的入参字段map：extendMap,规则场景编码：source、需要扩展的字段集合：extendKeys 如果扩展了入参标识，标识及对应的值需写入inputParamMap，如果是在inputParamMap里已存在的标识，只在该标识上扩展了业务字段，则更新inputParamMap里的该元素 无论是扩展新的入参标识还是在当前的入参标识上扩展字段，扩展的内容需写入extendMap，且写入的key需要和extendKeys的元素保持一致，注意：扩展的字段不能超过extendKeys集合的元素限制，否则会抛出异常。
拓展示例：
扩展案例参考：kd.sdk.wtc.wtp.business.ruleengine.demo.RuleEngineInputParamExtPluginDemo
定额规则扩展案例参考：kd.sdk.wtc.wtp.business.ruleengine.demo.QteRuleEngineInputParamExtPluginDemo
@param `onGenRuleEngineInputParamEvent` 构建规则引擎入参扩展事件


class_name: kd.sdk.wtc.wtp.business.tripplan.TripPlanRuleQuery
method_name: <init>
param_types_key: long,Date,Long
signature_text: public TripPlanRuleQuery(long attFileBoId, java.util.Date queryDate, Long tripType)
comment:
构造出差方案规则查询请求参数
@param `attFileBoId` 考勤档案BoId, 不可传0
@param `queryDate` 要查询的日期(yyyy-MM-dd)
@param `tripType` 要查询的出差类型


class_name: kd.sdk.wtc.wtpm.business.cardmatch.AfterCardMatchExtPlugin
method_name: adjustMultiCard
param_types_key: AfterCardMatchEvent
signature_text: default void adjustMultiCard(AfterCardMatchEvent event)
comment:
取卡匹配-取卡匹配计算，在匹配逻辑计算完成后，有效卡数据落库前会调用该接口。
该扩展方法适用于有效卡-多次卡记录落库前修改多次卡分录的属性，修改后的数据必须写入AfterCardMatchEvent.getMulTiCardExtMap()，没有变化则不需要写入 AfterCardMatchEvent.getTaskVoExt()方法可获取到取卡匹配逻辑的上下文信息，根据上下文信息修改多次卡分录属性。
扩展示例：请参考业务扩展场景kd.sdk.wtc.wtpm.business.cardmatch.AfterCardMatchExtPlugin的扩展说明，菜单路径：业务扩展平台->业务扩展场景
@param `event` 取卡匹配逻辑计算后置设置事件


class_name: kd.sdk.wtc.wtpm.business.cardmatch.CardMatchOffShiftExtPlugin
method_name: afterOffShiftTakeCardRange
param_types_key: OffShiftTakeCardRangeEvent
signature_text: default void afterOffShiftTakeCardRange(OffShiftTakeCardRangeEvent event)
comment:
取卡匹配-匹配off班（单档案单天）计算，获取当天off班无时段的取卡规则的取卡范围之后会调用改接口。
可根据入参数据对入参的初始的取卡范围的开始时间秒数（int），取卡范围的结束时间秒数（int）进行处理并返回，支持负数。 比如人参的匹配日期为2023-10-01，开始时间秒数=7200，结束时间秒数=86399，说明初始的取卡范围为[2023-10-01 02:00:00~2023-10-01 23:59:59] 修改入参的开始时间秒数=-1200，结束时间秒数=93600。说明拓展后的取卡范围为[2023-09-30 23:40:00~2023-10-02 02:00:00] 不修改开始结束时间秒数则取卡范围无变化，也可只修改开始结束时间秒数其中之一，也可全修改。
拓展示例：
publicvoidafterOffShiftTakeCardRange(OffShiftTakeCardRangeEvent event) {
// 根据入参信息获取匹配日期的取卡范围需要往前往后延多少时间(秒数)
event.setRangeStartSecords(event.getRangeStartSecords() - 1200);
event.setRangeEndSecords(event.getRangeEndSecords() + 7200);
}
@param `event` off班无时段班次取卡范围后置设置事件


class_name: kd.sdk.wtc.wtpm.business.cardmatch.OffShiftTakeCardRangeEvent
method_name: <init>
param_types_key: long,LocalDate,long,long,int,int
signature_text:
public OffShiftTakeCardRangeEvent(long attPersonId, java.time.LocalDate matchDate, long attFileBoId, long shiftId, int rangeStartSecords, int rangeEndSecords)


class_name: kd.sdk.wtc.wtpm.business.punchcard.WTPMPunchCardHelper
method_name: getPunchCardDetail
param_types_key: Long,Date,Date
signature_text:
public static java.util.Map<java.util.Date, java.util.Map<String, Object>> getPunchCardDetail(Long attPersonId, java.util.Date startDate, java.util.Date endDate)

comment:
查询用户某日打卡详情、班次时段
多次卡返回结构:
{
"type": "1",    --多次卡考勤方式
"attfileboid" : 123456789L,
"offshift": "true"/"false",
"sign":         --打卡详情
[
{
"mustsignpoint": "2022-05-01 09:00:00" -- 应打卡点(非off班无时段的班次且存在有效卡点才会设值)
"needsignon": "true",   --需要打上班卡
"hassignedon": "true",  --已打上班卡
"signon": "2022-05-01 09:00:02",    --实际上班打卡点
"signonaddress": "深圳金蝶软件园1F",  -- 实际上班打卡位置
"needsignoff": "true",  --需要打下班卡
"hassignedoff": "true", --已打下班卡
"signoff": "2022-05-01 12:01:07",   --实际下班打卡点
"signoffaddress": "深圳金蝶软件园3F"   --实际下班打卡位置
},
{
"needsignon": "false",  --需要打上班卡
"hassignedon": "false", --已打上班卡
"needsignoff": "true",  --需要打下班卡
"hassignedoff": "false", --已打下班卡
},
{
"needsignon": "false",  --需要打上班卡
"hassignedon": "false", --已打上班卡
"needsignoff": "true",  --需要打下班卡
"hassignedoff": "true", --已打下班卡
"mustsignpoint": "2022-05-01 18:00:00" -- 应打卡点(非off班无时段的班次且存在有效卡点才会设值)
"signoff": "2022-05-02 02:21:45"    --实际下班打卡点
"signoffaddress": "深圳金蝶软件园" --实际下班打卡位置
}
],
"shift":    --班次详情
[   {
"start": "2022-05-01 09:00:00", --班次时段1的上班卡点
"end": "2022-05-01 12:00:00"    --班次时段1的下班卡点
},
{
"start": "2022-05-01 14:00:00", --班次时段2的上班卡点
"end": "2022-05-01 18:00:00"    --班次时段2的下班卡点
},
{
"start": "2022-05-01 19:00:00", --班次时段3的上班卡点
"end": "2022-05-02 02:00:00"    --班次时段3的下班卡点
}
]
}
一次卡返回结构:
{
"type": "2",    --一次卡考勤方式
"attfileboid" : 123456789L,
"offshift": "true"/"false",
"sign": "2022-05-01 09:00:02",    --一次卡打卡点
"signaddress": "深圳金蝶软件园3F",    --一次卡打卡位置
"shift":    --班次详情
[   {
"start": "2022-05-01 09:00:00", --班次时段1的上班卡点
"end": "2022-05-01 12:00:00"    --班次时段1的下班卡点
},
{
"start": "2022-05-01 14:00:00", --班次时段2的上班卡点
"end": "2022-05-01 18:00:00"    --班次时段2的下班卡点
},
{
"start": "2022-05-01 19:00:00", --班次时段3的上班卡点
"end": "2022-05-02 02:00:00"    --班次时段3的下班卡点
}
]
}
不打卡返回结构:
{
"type": "3",    --考勤方式为不打卡
"attfileboid" : 123456789L,
"offshift": "true"/"false",
"shift":    --班次详情
[   {
"start": "2022-05-01 09:00:00", --班次时段1的上班卡点
"end": "2022-05-01 12:00:00"    --班次时段1的下班卡点
},
{
"start": "2022-05-01 14:00:00", --班次时段2的上班卡点
"end": "2022-05-01 18:00:00"    --班次时段2的下班卡点
},
{
"start": "2022-05-01 19:00:00", --班次时段3的上班卡点
"end": "2022-05-02 02:00:00"    --班次时段3的下班卡点
}]}
@param `attPersonId` 考勤人id
@param `startDate` 开始日期
@param `endDate` 结束日期
@return Map> key:班次日期


class_name: kd.sdk.wtc.wts.business.roster.OnRosterValidatorEvent
method_name: setFileAndRosterDateWithShiftVid
param_types_key: Map
signature_text:
public void setFileAndRosterDateWithShiftVid(java.util.Map<Long, java.util.Map<String, Long>> fileAndRosterDateWithShiftVid)


class_name: kd.sdk.wtc.wts.business.roster.RosterValidatorExt
method_name: onValidate
param_types_key: Collection,Date,Date
signature_text:
java.util.Map<Long, java.util.Map<String, java.util.Map<String, String>>> onValidate(java.util.Collection<Long> attFileBoIds, java.util.Date startDate, java.util.Date endDate)

comment:
排班校验扩展接口
@param `attFileBoIds` 档案boid集合
@param `startDate` 开始日期
@param `endDate` 结束日期
@return 返回类型为Map 返回值说明： key: 档案boid 类型为Long 如：1575282784384182272L value: 校验失败信息 类型为Map 格式如下 key: 日期：yyyy-MM-dd 类型String 如："2023-10-01" value: 类型为Map 格式如下： key： 类型为String 可存在值：”plan“,"actual" value: 类型为String 错误信息 如：”档案已封存，不可排班。“ 例如： { "1575282784384182272":{ "2022-08-31":{ "actual":"档案已封存，不可排班。", "plan":"档案已封存，不可排班。" } } }


class_name: kd.sdk.wtc.wts.business.roster.RosterValidatorExtPlugin
method_name: onValidate
param_types_key: OnRosterValidatorEvent
signature_text: void onValidate(OnRosterValidatorEvent event)
comment:
排班校验扩展接口
示例代码可以参考排班校验扩展场景，扩展场景编码：kd.sdk.wtc.wts.business.roster.RosterValidatorExtPlugin
@param `event` 排班校验事件


class_name: kd.sdk.wtc.wts.business.roster.WTSRosterHelper
method_name: queryRosterDataByFileId
param_types_key: Long,Date,Date
signature_text:
public static java.util.Map<String, java.util.Map<String, Object>> queryRosterDataByFileId(Long attFileBoId, java.util.Date startDate, java.util.Date endDate)

comment:
按月询指定考勤档案的人员排班表
---|---|---|---|---|---
是否OFF班次| isoff| -| Boolean| 是| 说明：可能的值 false: 非off班 ，true: off班
节假日名称集合| holidaynameset| -| Set<String>集合| 否| 说明：节假日名称集合，例如：{"劳动节","端午节"}
节假日id集合| holidayidset| -| Set<Long>集合| 否| 说明：节假日id集合，例如：{1410170658523971584L}
日期属性名称| dateattributename| -| String| 是| 说明：日期属性名称，例如：工作日
日期属性编码| dateattributecode| -| String| 是| 说明：日期属性编码，例如：DS-0002 详情参照下面特殊说明
班次id| shiftid| -| Long| 是| 说明：该日期对应的班次版本id
特别说明：日期属性为枚举类型（id,编码，名称），可能的值有以下3种 1: OFFDAY(1220227289099276288L,"DS-0002", "休息日") 2: HOLIDAY(1220227377297100800L,"DS-0003", "节假日") 3: WORKDAY(1220227453272723456L,"DS-0001", "工作日")
@param `attFileBoId` 考勤人id
@param `startDate` 开始日期 格式：yyyy-MM-dd 如：2023-01-01 不允许为空
@param `endDate` 结束日期 格式：yyyy-MM-dd 如：2023-01-01 不允许为空
@return 返回类型为Map 返回值说明： key: 日期：yyyy-MM-dd 如："2022-05-21" value: Map Map> key: 日期：yyyy-MM-dd 如："2022-05-21" value: Map 内容格式如下： 参数名称| 一级参数| 二级参数| 参数类型| 是否必录| 参数描述


class_name: kd.sdk.wtc.wts.business.roster.WTSRosterHelper
method_name: queryRosterDataByFileIds
param_types_key: List,Date,Date
signature_text:
public static java.util.Map<Long, java.util.Map<String, java.util.Map<String, Object>>> queryRosterDataByFileIds(java.util.List<Long> attFileBoIds, java.util.Date startDate, java.util.Date endDate)

comment:
按月询指定考勤档案的人员排班表
---|---|---|---|---|---
是否OFF班次| isoff| -| Boolean| 是| 说明：可能的值 false: 非off班 ，true: off班
节假日名称集合| holidaynameset| -| Set<String>集合| 否| 说明：节假日名称集合，例如：{"劳动节","端午节"}
节假日id集合| holidayidset| -| Set<Long>集合| 否| 说明：节假日id集合，例如：{1410170658523971584L}
日期属性名称| dateattributename| -| String| 是| 说明：日期属性名称，例如：工作日
日期属性编码| dateattributecode| -| String| 是| 说明：日期属性编码，例如：DS-0002 详情参照下面特殊说明
班次id| shiftid| -| Long| 是| 说明：该日期对应的班次版本id
特别说明：日期属性为枚举类型（id,编码，名称），可能的值有以下3种 1: OFFDAY(1220227289099276288L,"DS-0002", "休息日") 2: HOLIDAY(1220227377297100800L,"DS-0003", "节假日") 3: WORKDAY(1220227453272723456L,"DS-0001", "工作日")
@param `attFileBoIds` 考勤档案ids
@param `startDate` 开始日期 格式：yyyy-MM-dd 如：2023-01-01 不允许为空
@param `endDate` 结束日期 格式：yyyy-MM-dd 如：2023-01-01 不允许为空
@return 返回类型为Map 返回值说明： key: 档案boid 如：1410170658523971584L value: Map> 可参考单人 key: 日期：yyyy-MM-dd 如："2022-05-21" value: Map Map> key: 日期：yyyy-MM-dd 如："2022-05-21" value: Map 内容格式如下： 参数名称| 一级参数| 二级参数| 参数类型| 是否必录| 参数描述


class_name: kd.sdk.wtc.wts.business.roster.WTSRosterHelper
method_name: queryRosterDataByPersonId
param_types_key: Long,Date,Date
signature_text:
public static java.util.Map<String, java.util.Map<String, Object>> queryRosterDataByPersonId(Long personId, java.util.Date startDate, java.util.Date endDate)

comment:
按月询指定考勤人员的人员排班表
---|---|---|---|---|---
是否OFF班次| isoff| -| Boolean| 是| 说明：可能的值 false: 非off班 ，true: off班
节假日名称集合| holidaynameset| -| Set<String>集合| 否| 说明：节假日名称集合，例如：{"劳动节","端午节"}
节假日id集合| holidayidset| -| Set<Long>集合| 否| 说明：节假日id集合，例如：{1410170658523971584L}
日期属性名称| dateattributename| -| String| 是| 说明：日期属性名称，例如：工作日
日期属性编码| dateattributecode| -| String| 是| 说明： 日期属性编码，详情参照下面特殊说明
班次id| shiftid| -| Long| 是| 说明：该日期对应的班次版本id
特别说明：日期属性为枚举类型（id,编码，名称），可能的值有以下3种 1: OFFDAY(1220227289099276288L,"DS-0002", "休息日") 2: HOLIDAY(1220227377297100800L,"DS-0003", "节假日") 3: WORKDAY(1220227453272723456L,"DS-0001", "工作日")
@param `personId` 考勤人id
@param `startDate` 开始日期 格式：yyyy-MM-dd 如：2023-01-01 不允许为空
@param `endDate` 结束日期 格式：yyyy-MM-dd 如：2023-01-01 不允许为空
@return 返回类型为Map 返回值说明： key: 日期：yyyy-MM-dd 如："2022-05-21" value: Map参数名称| 一级参数| 二级参数| 参数类型| 是否必录| 参数描述


class_name: kd.sdk.wtc.wts.business.roster.WTSRosterHelper
method_name: queryRosterDataByPersonIds
param_types_key: List,Date,Date
signature_text:
public static java.util.Map<Long, java.util.Map<String, java.util.Map<String, Object>>> queryRosterDataByPersonIds(java.util.List<Long> personIds, java.util.Date startDate, java.util.Date endDate)

comment:
按月询指定考勤人员的人员排班表
---|---|---|---|---|---
是否OFF班次| isoff| -| Boolean| 是| 说明：可能的值 false: 非off班 ，true: off班
节假日名称集合| holidaynameset| -| Set<String>集合| 否| 说明：节假日名称集合，例如：{"劳动节","端午节"}
节假日id集合| holidayidset| -| Set<Long>集合| 否| 说明：节假日id集合，例如：{1410170658523971584L}
日期属性名称| dateattributename| -| String| 是| 说明：日期属性名称，例如：工作日
日期属性编码| dateattributecode| -| String| 是| 说明： 日期属性编码，详情参照下面特殊说明
班次id| shiftid| -| Long| 是| 说明：该日期对应的班次版本id
特别说明：日期属性为枚举类型（id,编码，名称），可能的值有以下3种 1: OFFDAY(1220227289099276288L,"DS-0002", "休息日") 2: HOLIDAY(1220227377297100800L,"DS-0003", "节假日") 3: WORKDAY(1220227453272723456L,"DS-0001", "工作日")
@param `personIds` 考勤人id
@param `startDate` 开始日期 格式：yyyy-MM-dd 如：2023-01-01 不允许为空
@param `endDate` 结束日期 格式：yyyy-MM-dd 如：2023-01-01 不允许为空
@return 返回类型为Map 返回值说明： key: 档案boid 如：1410170658523971584L value: Map> 可参考单人 key: 日期：yyyy-MM-dd 如："2022-05-21" value: Map参数名称| 一级参数| 二级参数| 参数类型| 是否必录| 参数描述


class_name: kd.sdk.wtc.wtss.business.homepage.BeforeShowApplyPageEvent
method_name: <init>
param_types_key: WTCBillType,WTCApplyType,FormShowParameter
comment: 打开单据申请页面事件构造器 @param `billType` 单据类型 @param `applyType` 申请类型 @param `formShowParameter` 表单参数
signature_text:
public BeforeShowApplyPageEvent(kd.sdk.wtc.wtbs.common.enums.WTCBillType billType, kd.sdk.wtc.wtbs.common.enums.WTCApplyType applyType, FormShowParameter formShowParameter)


class_name: kd.sdk.wtc.wtss.business.homepage.BeforeShowDetailPageEvent
method_name: <init>
param_types_key: WTCBillType,WTCApplyType,FormShowParameter
comment: 打开单据详情页面事件构造器 @param `billType` 单据类型 @param `applyType` 申请类型 @param `formShowParameter` 表单参数
signature_text:
public BeforeShowDetailPageEvent(kd.sdk.wtc.wtbs.common.enums.WTCBillType billType, kd.sdk.wtc.wtbs.common.enums.WTCApplyType applyType, FormShowParameter formShowParameter)


class_name: kd.sdk.wtc.wtss.business.homepage.BillReplaceExtPlugin
method_name: beforeShowApplyPage
param_types_key: BeforeShowApplyPageEvent
signature_text: default void beforeShowApplyPage(BeforeShowApplyPageEvent event)
comment:
PC端或移动端打开单据申请时触发的事件
可以通过 BeforeShowApplyPageEvent#getFormShowParameter() 设置打开替换页面所需要的参数；
@param `event` 二开单据申请替换扩展事件


class_name: kd.sdk.wtc.wtss.business.homepage.BillReplaceExtPlugin
method_name: beforeShowDetailPage
param_types_key: BeforeShowDetailPageEvent
signature_text: default void beforeShowDetailPage(BeforeShowDetailPageEvent event)
comment:
PC端或移动端打开单据详情时触发的事件
可以通过 BeforeShowApplyPageEvent#getFormShowParameter() 设置打开替换页面所需要的参数；
@param `event` 二开单据申请替换扩展事件


class_name: kd.sdk.wtc.wtss.business.homepage.BillReplaceExtPlugin
method_name: onFilterMobileBillList
param_types_key: OnFilterMobileBillListEvent
signature_text: default void onFilterMobileBillList(OnFilterMobileBillListEvent event)
comment:
移动端打开单据申请选择面板时触发的事件
可以通过 OnFilterMobileBillListEvent#setBillTypeRights(Map) 设置打开筛选面板时禁用的单据类型
@param `event` 二开单据申请替换扩展事件


class_name: kd.sdk.wtc.wtss.business.homepage.OnFilterMobileBillListEvent
method_name: setBillTypeRights
param_types_key: Map
comment: 设置是否有权限查看对应的单据类型
signature_text:
public void setBillTypeRights(java.util.Map<kd.sdk.wtc.wtbs.common.enums.WTCBillType, Boolean> billTypeRights)


class_name: kd.sdk.wtc.wtss.business.homepage.OnQueryMobileBillListEvent
method_name: getBillData
param_types_key: MobileBillListDto)[] getBillData(
comment: 查询的单据实体
signature_text:
public (@kd.sdk.wtc.wtbs.common.lang.Nullable :: kd.sdk.wtc.wtss.business.homepage.MobileBillListDto)[] getBillData()


class_name: kd.sdk.wtc.wtss.business.homepage.WtssHomepageServiceHelper
method_name: getAbnormalConfig
param_types_key: long,String
signature_text: public static java.util.Set<Long> getAbnormalConfig(long mobileSchemeId, String workspace)
comment:
获取日明细考勤项目中的异常类型，存在多条时，合并返回
@param `mobileSchemeId` 考勤方案id
@param `workspace` A-个人（现仅支持A）
@return 异常类型配置列表


class_name: kd.sdk.wtc.wtss.business.spi.homepage.WtssHomepageService
method_name: getAbnormalConfig
param_types_key: long,String
signature_text: java.util.Set<Long> getAbnormalConfig(long mobileSchemeId, String workspace)
comment:
获取日明细考勤项目中的异常类型，存在多条时，合并返回
@param `mobileSchemeId` 考勤方案id
@param `workspace` A-个人 B-团体
@return 异常类型配置列表


class_name: kd.sdk.wtc.wtss.business.teamhome.AttTargetQueryExpandService
method_name: getDetailMap
param_types_key: AttStatisticTargetQueryParam,Long
signature_text:
java.util.Map<String, java.util.List<java.util.Map<String, String>>> getDetailMap(AttStatisticTargetQueryParam queryParam, Long kpiId)

comment:
@param `queryParam` 指标查询参数
@param `kpiId` 指标id
@return Map 下钻详情 "header": List>对应的列， "body": Map>> 对应的数据


class_name: kd.sdk.wtc.wtte.business.attrecord.WTTEAttRecordHelper
method_name: getAttItemValueByPeriod
param_types_key: Long,Set,Set
signature_text:
public static java.util.Map<Long, java.util.Map<Long, Double>> getAttItemValueByPeriod(Long perAttPeriodId, java.util.Set<Long> attItemSet, java.util.Set<Long> attFileSet)

comment:
查询条件内人员的考勤项目考勤期间汇总值，接口无值时返回空Map
@param `perAttPeriodId` 考勤期间id（必填）
@param `attItemSet` 考勤项目boId集合（必填）
@param `attFileSet` 档案boId List（必填）
@return Map<档案boId, Map < 考勤项目boId ， 考勤项目统计值>>


