Commit 05e2d04b by zhangxingmin

new interface

parent 4c71bab6
...@@ -4,4 +4,4 @@ ...@@ -4,4 +4,4 @@
<option name="path" value="项目群组-&gt;银盾-微服务" /> <option name="path" value="项目群组-&gt;银盾-微服务" />
<option name="projectId" value="4cc05386e898000" /> <option name="projectId" value="4cc05386e898000" />
</component> </component>
</project> </project>
\ No newline at end of file
...@@ -13,4 +13,4 @@ ...@@ -13,4 +13,4 @@
</profile> </profile>
</annotationProcessing> </annotationProcessing>
</component> </component>
</project> </project>
\ No newline at end of file
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 业务员累计积分表 - 存储业务员的累计FYC积分和当前等级信息 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/agentAccumulatedFyc")
public class AgentAccumulatedFycController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 业务员积分明细表 - 存储业务员的每次增加或者减少的FYC积分 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/agentDetailFyc")
public class AgentDetailFycController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 推荐关系表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/agentReferralRelation")
public class AgentReferralRelationController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 辅导关系表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/agentTutoringRelation")
public class AgentTutoringRelationController {
}
package com.yd.csf.api.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiCommissionRuleConfigService;
import com.yd.csf.feign.client.commissionruleconfig.ApiCommissionRuleConfigFeignClient;
import com.yd.csf.feign.request.additional.ApiAdditionalPageRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigAddRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigEditRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigPageRequest;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigDetailResponse;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigPageResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.validation.constraints.NotBlank;
/**
* 基本法配置信息
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/commissionRuleConfig")
@Validated
public class ApiCommissionRuleConfigController implements ApiCommissionRuleConfigFeignClient {
@Autowired
private ApiCommissionRuleConfigService apiCommissionRuleConfigService;
/**
* 分页查询-基本法配置信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiCommissionRuleConfigPageResponse>> page(ApiCommissionRuleConfigPageRequest request) {
return apiCommissionRuleConfigService.page(request);
}
/**
* 详情-基本法配置信息
* @param ruleBizId
* @return
*/
@Override
public Result<ApiCommissionRuleConfigDetailResponse> detail(String ruleBizId) {
return apiCommissionRuleConfigService.detail(ruleBizId);
}
/**
* 添加-基本法配置信息
* @param request
* @return
*/
@Override
public Result add(ApiCommissionRuleConfigAddRequest request) {
return apiCommissionRuleConfigService.add(request);
}
/**
* 编辑-基本法配置信息
* @param request
* @return
*/
@Override
public Result edit(ApiCommissionRuleConfigEditRequest request) {
return apiCommissionRuleConfigService.edit(request);
}
/**
* 删除-基本法配置信息 TODO
* @param ruleBizId
* @return
*/
@Override
public Result del(String ruleBizId) {
return apiCommissionRuleConfigService.del(ruleBizId);
}
}
package com.yd.csf.api.controller;
import com.yd.csf.feign.client.formulaconfig.ApiFormulaConfigFeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 公式配置信息
*
* @author zxm
* @since 2025-10-17
*/
@RestController
@RequestMapping("/formulaConfig")
@Validated
public class ApiFormulaConfigController implements ApiFormulaConfigFeignClient {
}
package com.yd.csf.api.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiRuleItemConfigService;
import com.yd.csf.feign.client.ruleItemconfig.ApiRuleItemConfigFeignClient;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigAddRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigEditRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigPageRequest;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigDetailResponse;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigPageResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 基本法项目配置信息
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/ruleItemConfig")
@Validated
public class ApiRuleItemConfigController implements ApiRuleItemConfigFeignClient {
@Autowired
private ApiRuleItemConfigService apiRuleItemConfigService;
/**
* 分页查询-基本法项目配置信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiRuleItemConfigPageResponse>> page(ApiRuleItemConfigPageRequest request) {
return apiRuleItemConfigService.page(request);
}
/**
* 详情-基本法项目配置信息
* @param ruleItemBizId
* @return
*/
@Override
public Result<ApiRuleItemConfigDetailResponse> detail(String ruleItemBizId) {
return apiRuleItemConfigService.detail(ruleItemBizId);
}
/**
* 添加-基本法项目配置信息
* @param request
* @return
*/
@Override
public Result add(ApiRuleItemConfigAddRequest request) {
return apiRuleItemConfigService.add(request);
}
/**
* 编辑-基本法项目配置信息
* @param request
* @return
*/
@Override
public Result edit(ApiRuleItemConfigEditRequest request) {
return apiRuleItemConfigService.edit(request);
}
/**
* 删除-基本法项目配置信息 TODO
* @param ruleItemBizId
* @return
*/
@Override
public Result del(String ruleItemBizId) {
return apiRuleItemConfigService.del(ruleItemBizId);
}
}
package com.yd.csf.api.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiVariableService;
import com.yd.csf.feign.client.variable.ApiVariableFeignClient;
import com.yd.csf.feign.request.variable.ApiVariableAddRequest;
import com.yd.csf.feign.request.variable.ApiVariableEditRequest;
import com.yd.csf.feign.request.variable.ApiVariablePageRequest;
import com.yd.csf.feign.response.variable.ApiVariableDetailResponse;
import com.yd.csf.feign.response.variable.ApiVariablePageResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 变量信息
*
* @author zxm
* @since 2025-10-16
*/
@RestController
@RequestMapping("/variable")
@Validated
public class ApiVariableController implements ApiVariableFeignClient {
@Autowired
private ApiVariableService apiVariableService;
/**
* 分页查询-变量信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiVariablePageResponse>> page(ApiVariablePageRequest request) {
return apiVariableService.page(request);
}
/**
* 详情-变量信息
* @param variableBizId
* @return
*/
@Override
public Result<ApiVariableDetailResponse> detail( String variableBizId) {
return apiVariableService.detail(variableBizId);
}
/**
* 添加-变量信息
* @param request
* @return
*/
@Override
public Result add(ApiVariableAddRequest request) {
return apiVariableService.add(request);
}
/**
* 编辑-变量信息
* @param request
* @return
*/
@Override
public Result edit(ApiVariableEditRequest request) {
return apiVariableService.edit(request);
}
/**
* 删除-变量信息 TODO
* @param variableBizId
* @return
*/
@Override
public Result del(String variableBizId) {
return apiVariableService.detail(variableBizId);
}
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 保单批次保单关联表 - 存储批次与保单的关联关系,记录批次中每个保单的计算状态 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/batchPolicy")
public class BatchPolicyController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 车辆预约申请表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/carApply")
public class CarApplyController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 客户端角色表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/clientRole")
public class ClientRoleController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 保单佣金计算结果表(出账表) - 存储佣金计算的详细结果,用于查询、对账和发放 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/commissionResult")
public class CommissionResultController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 基本法绑定表 - 存储基本法与业务员或团队的绑定关系,支持灵活的权限分配 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/commissionRuleBinding")
public class CommissionRuleBindingController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* SQL模板表 - 存储所有佣金计算相关的动态SQL模板,支持灵活配置和参数化查询,实现业务逻辑与代码解耦 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/commissionSqlTemplate")
public class CommissionSqlTemplateController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 条件配置表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@RestController
@RequestMapping("/conditionConfig")
public class ConditionConfigController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 业务员积分任务表 - 定时跑批业务员绑定的基本法计算点,算出当前业务员所得的积分(一级管理奖、二级管理奖、辅导津贴奖、终身推荐奖等月末计算,季度结算等) 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/fycTask")
public class FycTaskController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 权益表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/interests")
public class InterestsController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 邀请码表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/invitation")
public class InvitationController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 会员表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/member")
public class MemberController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 会员等级配置表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/memberGradeConfig")
public class MemberGradeConfigController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 保单发佣批次表 - 存储发佣批次信息,用于批量处理佣金计算和发放 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/payoutBatch")
public class PayoutBatchController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 保单业务员关联表 - 存储保单与业务员的关联关系及佣金分配信息 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/policyAgentRelation")
public class PolicyAgentRelationController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 业务员和客户关联表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/relAgentCustomer")
public class RelAgentCustomerController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 权益表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/relCustomerInterests")
public class RelCustomerInterestsController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 会员等级和服务关系表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/relGradeService")
public class RelGradeServiceController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 客户端角色表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/relMemberRole")
public class RelMemberRoleController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 对象和条件配置关系表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@RestController
@RequestMapping("/relObjectCondition")
public class RelObjectConditionController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 对象和公式配置关系表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@RestController
@RequestMapping("/relObjectFormula")
public class RelObjectFormulaController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 对象和SQL模板配置关系表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@RestController
@RequestMapping("/relObjectSql")
public class RelObjectSqlController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 服务权益关系表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/relServiceInterests")
public class RelServiceInterestsController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 团队和会员关系表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/relTeamMember")
public class RelTeamMemberController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 规则条件配置表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/ruleConditionConfig")
public class RuleConditionConfigController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 服务配置表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/serviceConfig")
public class ServiceConfigController {
}
package com.yd.csf.api.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 团队表 前端控制器
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@RestController
@RequestMapping("/team")
public class TeamController {
}
package com.yd.csf.api.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigAddRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigEditRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigPageRequest;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigDetailResponse;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigPageResponse;
public interface ApiCommissionRuleConfigService {
Result<IPage<ApiCommissionRuleConfigPageResponse>> page(ApiCommissionRuleConfigPageRequest request);
Result<ApiCommissionRuleConfigDetailResponse> detail(String ruleBizId);
Result add(ApiCommissionRuleConfigAddRequest request);
Result edit(ApiCommissionRuleConfigEditRequest request);
Result del(String ruleBizId);
}
package com.yd.csf.api.service;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.conditionconfig.ApiRelObjectConditionDto;
import com.yd.csf.feign.dto.conditionconfig.ApiConditionTypeDto;
import java.util.List;
public interface ApiRelObjectConditionService {
Result saveRelList(ApiRelObjectConditionDto dto);
Result<List<ApiConditionTypeDto>> apiConditionTypeDtoList(ApiRelObjectConditionDto dto);
}
package com.yd.csf.api.service;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.formulaconfig.ApiFormulaConfigDto;
import com.yd.csf.feign.dto.formulaconfig.ApiRelObjectFormulaDto;
import java.util.List;
public interface ApiRelObjectFormulaService {
Result<List<ApiFormulaConfigDto>> apiFormulaConfigDtoList(ApiRelObjectFormulaDto dto);
Result saveRelList(ApiRelObjectFormulaDto dto);
}
package com.yd.csf.api.service;
import com.yd.common.result.Result;
import com.yd.csf.feign.dto.sqltemplate.ApiCommissionSqlTemplateDto;
import com.yd.csf.feign.dto.sqltemplate.ApiRelObjectSqlDto;
import java.util.List;
public interface ApiRelObjectSqlService {
Result saveRelList(ApiRelObjectSqlDto dto);
Result<List<ApiCommissionSqlTemplateDto>> apiCommissionSqlTemplateDtoList(ApiRelObjectSqlDto dto);
}
package com.yd.csf.api.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigAddRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigEditRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigPageRequest;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigDetailResponse;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigPageResponse;
public interface ApiRuleItemConfigService {
Result<IPage<ApiRuleItemConfigPageResponse>> page(ApiRuleItemConfigPageRequest request);
Result<ApiRuleItemConfigDetailResponse> detail(String ruleItemBizId);
Result add(ApiRuleItemConfigAddRequest request);
Result edit(ApiRuleItemConfigEditRequest request);
Result del(String ruleItemBizId);
}
package com.yd.csf.api.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.yd.common.result.Result;
import com.yd.csf.feign.request.variable.ApiVariableAddRequest;
import com.yd.csf.feign.request.variable.ApiVariableEditRequest;
import com.yd.csf.feign.request.variable.ApiVariablePageRequest;
import com.yd.csf.feign.response.variable.ApiVariableDetailResponse;
import com.yd.csf.feign.response.variable.ApiVariablePageResponse;
public interface ApiVariableService {
Result<IPage<ApiVariablePageResponse>> page(ApiVariablePageRequest request);
Result<ApiVariableDetailResponse> detail(String variableBizId);
Result add(ApiVariableAddRequest request);
Result edit(ApiVariableEditRequest request);
Result del(String variableBizId);
}
package com.yd.csf.api.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.common.constant.CodeGeneratorConstants;
import com.yd.common.enums.CommonEnum;
import com.yd.common.enums.ResultCode;
import com.yd.common.exception.BusinessException;
import com.yd.common.result.Result;
import com.yd.common.utils.CodeGenerator;
import com.yd.common.utils.RandomStringGenerator;
import com.yd.csf.api.service.ApiCommissionRuleConfigService;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigAddRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigEditRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigPageRequest;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigDetailResponse;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigPageResponse;
import com.yd.csf.service.dto.CommissionRuleConfigDto;
import com.yd.csf.service.model.CommissionRuleConfig;
import com.yd.csf.service.service.ICommissionRuleConfigService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Objects;
@Service
public class ApiCommissionRuleConfigServiceImpl implements ApiCommissionRuleConfigService {
@Autowired
private ICommissionRuleConfigService iCommissionRuleConfigService;
/**
* 分页查询-基本法配置信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiCommissionRuleConfigPageResponse>> page(ApiCommissionRuleConfigPageRequest request) {
Page<ApiCommissionRuleConfigPageResponse> page = new Page<>(request.getPageNo(), request.getPageSize());
IPage<ApiCommissionRuleConfigPageResponse> iPage = iCommissionRuleConfigService.page(page, request);
return Result.success(iPage);
}
/**
* 详情-基本法配置信息
* @param ruleBizId
* @return
*/
@Override
public Result<ApiCommissionRuleConfigDetailResponse> detail(String ruleBizId) {
//校验基本法配置信息是否存在
Result<CommissionRuleConfig> result = checkCommissionRuleConfigIsExist(ruleBizId);
CommissionRuleConfig config = result.getData();
ApiCommissionRuleConfigDetailResponse response = new ApiCommissionRuleConfigDetailResponse();
BeanUtils.copyProperties(config,response);
return Result.success(response);
}
/**
* 添加-基本法配置信息
* @param request
* @return
*/
@Override
public Result add(ApiCommissionRuleConfigAddRequest request) {
//校验基本法名称的唯一性
List<CommissionRuleConfig> list = iCommissionRuleConfigService.queryList(CommissionRuleConfigDto.builder()
.ruleName(request.getRuleName())
.build());
if (!CollectionUtils.isEmpty(list)) {
throw new BusinessException("基本法名称已存在");
}
CommissionRuleConfig config = new CommissionRuleConfig();
BeanUtils.copyProperties(request,config);
config.setRuleBizId(RandomStringGenerator.generateBizId16(CommonEnum.UID_TYPE_COMMISSION_RULE_CONFIG.getCode()));
//基本法编码
config.setRuleCode(CodeGenerator.generate10Code(CodeGeneratorConstants.PREFIX_RULE_CODE));
iCommissionRuleConfigService.saveOrUpdate(config);
return Result.success();
}
/**
* 编辑-基本法配置信息
* @param request
* @return
*/
@Override
public Result edit(ApiCommissionRuleConfigEditRequest request) {
//校验基本法配置信息是否存在
Result<CommissionRuleConfig> result = checkCommissionRuleConfigIsExist(request.getRuleBizId());
CommissionRuleConfig config = result.getData();
//校验基本法名称的唯一性
List<CommissionRuleConfig> list = iCommissionRuleConfigService.queryList(CommissionRuleConfigDto.builder()
.ruleName(request.getRuleName())
.isExcludeMy(true)
.ruleBizId(request.getRuleBizId())
.build());
if (!CollectionUtils.isEmpty(list)) {
throw new BusinessException("基本法名称已存在");
}
BeanUtils.copyProperties(request,config);
iCommissionRuleConfigService.saveOrUpdate(config);
return Result.success();
}
/**
* 删除-基本法配置信息
* @param ruleBizId
* @return
*/
@Override
public Result del(String ruleBizId) {
return null;
}
/**
* 校验基本法配置信息是否存在
* @param ruleBizId
* @return
*/
public Result<CommissionRuleConfig> checkCommissionRuleConfigIsExist(String ruleBizId) {
CommissionRuleConfig config = iCommissionRuleConfigService.queryOne(ruleBizId);
if (Objects.isNull(config)) {
//数据不存在
throw new BusinessException(ResultCode.NULL_ERROR.getCode(),ResultCode.NULL_ERROR.getMessage());
}
return Result.success(config);
}
}
package com.yd.csf.api.service.impl;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiRelObjectConditionService;
import com.yd.csf.feign.dto.conditionconfig.ApiRelObjectConditionDto;
import com.yd.csf.feign.dto.conditionconfig.ApiConditionTypeDto;
import com.yd.csf.service.dto.ConditionTypeDto;
import com.yd.csf.service.dto.RelObjectConditionDto;
import com.yd.csf.service.model.*;
import com.yd.csf.service.service.IConditionTypeService;
import com.yd.csf.service.service.IRelObjectConditionService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class ApiRelObjectConditionServiceImpl implements ApiRelObjectConditionService {
@Autowired
private IRelObjectConditionService iRelObjectConditionService;
@Autowired
private IConditionTypeService iConditionTypeService;
/**
* 保存对象和规则条件配置关系
* @param dto
* @return
*/
@Override
public Result saveRelList(ApiRelObjectConditionDto dto) {
//先删后新增
iRelObjectConditionService.del(dto);
//新增
if (!CollectionUtils.isEmpty(dto.getConditionTypeBizIdList())) {
List<RelObjectCondition> saveList = dto.getConditionTypeBizIdList().stream().map(conditionTypeBizId -> {
RelObjectCondition relObjectCondition = new RelObjectCondition();
BeanUtils.copyProperties(dto,relObjectCondition);
relObjectCondition.setConditionTypeBizId(conditionTypeBizId);
return relObjectCondition;
}).collect(Collectors.toList());
iRelObjectConditionService.saveOrUpdateBatch(saveList);
}
return Result.success();
}
/**
* 根据对象关系查询条件类型列表信息
* @param dto
* @return
*/
@Override
public Result<List<ApiConditionTypeDto>> apiConditionTypeDtoList(ApiRelObjectConditionDto dto) {
List<ApiConditionTypeDto> apiConditionTypeDtoList = new ArrayList<>();
RelObjectConditionDto relObjectConditionDto = new RelObjectConditionDto();
BeanUtils.copyProperties(dto,relObjectConditionDto);
List<RelObjectCondition> relObjectConditionList = iRelObjectConditionService.queryList(relObjectConditionDto);
if (!CollectionUtils.isEmpty(relObjectConditionList)) {
List<String> conditionTypeBizIdList = relObjectConditionList.stream().map(RelObjectCondition::getConditionTypeBizId).collect(Collectors.toList());
List<ConditionType> conditionTypeList = iConditionTypeService.queryList(ConditionTypeDto.builder()
.conditionTypeBizIdList(conditionTypeBizIdList)
.build());
if (!CollectionUtils.isEmpty(conditionTypeList)) {
apiConditionTypeDtoList = conditionTypeList.stream().map(d -> {
ApiConditionTypeDto typeDto = new ApiConditionTypeDto();
BeanUtils.copyProperties(d,typeDto);
return typeDto;
}).collect(Collectors.toList());
}
}
return Result.success(apiConditionTypeDtoList);
}
}
package com.yd.csf.api.service.impl;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiRelObjectFormulaService;
import com.yd.csf.feign.dto.formulaconfig.ApiFormulaConfigDto;
import com.yd.csf.feign.dto.formulaconfig.ApiRelObjectFormulaDto;
import com.yd.csf.service.dto.FormulaConfigDto;
import com.yd.csf.service.dto.RelObjectFormulaDto;
import com.yd.csf.service.model.FormulaConfig;
import com.yd.csf.service.model.RelObjectFormula;
import com.yd.csf.service.service.IFormulaConfigService;
import com.yd.csf.service.service.IRelObjectFormulaService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class ApiRelObjectFormulaServiceImpl implements ApiRelObjectFormulaService {
@Autowired
private IRelObjectFormulaService iRelObjectFormulaService;
@Autowired
private IFormulaConfigService iFormulaConfigService;
/**
* 根据对象关系查询公式配置列表信息
* @param dto
* @return
*/
@Override
public Result<List<ApiFormulaConfigDto>> apiFormulaConfigDtoList(ApiRelObjectFormulaDto dto) {
List<ApiFormulaConfigDto> apiFormulaConfigDtoList = new ArrayList<>();
RelObjectFormulaDto relObjectFormulaDto = new RelObjectFormulaDto();
BeanUtils.copyProperties(dto,relObjectFormulaDto);
List<RelObjectFormula> relObjectFormulaList = iRelObjectFormulaService.queryList(relObjectFormulaDto);
if (!CollectionUtils.isEmpty(relObjectFormulaList)) {
List<String> formulaBizIdList = relObjectFormulaList.stream().map(RelObjectFormula::getFormulaBizId).collect(Collectors.toList());
List<FormulaConfig> formulaConfigList = iFormulaConfigService.queryList(FormulaConfigDto.builder()
.formulaBizIdList(formulaBizIdList)
.build());
if (!CollectionUtils.isEmpty(formulaConfigList)) {
apiFormulaConfigDtoList = formulaConfigList.stream().map(d -> {
ApiFormulaConfigDto configDto = new ApiFormulaConfigDto();
BeanUtils.copyProperties(d,configDto);
return configDto;
}).collect(Collectors.toList());
}
}
return Result.success(apiFormulaConfigDtoList);
}
/**
* 保存对象和公式配置关系
* @param dto
* @return
*/
@Override
public Result saveRelList(ApiRelObjectFormulaDto dto) {
//先删后新增
RelObjectFormulaDto relObjectFormulaDto = new RelObjectFormulaDto();
BeanUtils.copyProperties(dto,relObjectFormulaDto);
iRelObjectFormulaService.del(relObjectFormulaDto);
//新增
if (!CollectionUtils.isEmpty(dto.getFormulaBizIdList())) {
List<RelObjectFormula> saveList = dto.getFormulaBizIdList().stream().map(bizId -> {
RelObjectFormula relObjectFormula = new RelObjectFormula();
BeanUtils.copyProperties(dto,relObjectFormula);
relObjectFormula.setFormulaBizId(bizId);
return relObjectFormula;
}).collect(Collectors.toList());
iRelObjectFormulaService.saveOrUpdateBatch(saveList);
}
return Result.success();
}
}
package com.yd.csf.api.service.impl;
import com.yd.common.result.Result;
import com.yd.csf.api.service.ApiRelObjectSqlService;
import com.yd.csf.feign.dto.sqltemplate.ApiCommissionSqlTemplateDto;
import com.yd.csf.feign.dto.sqltemplate.ApiRelObjectSqlDto;
import com.yd.csf.service.dto.CommissionSqlTemplateDto;
import com.yd.csf.service.dto.RelObjectSqlDto;
import com.yd.csf.service.model.CommissionSqlTemplate;
import com.yd.csf.service.model.RelObjectSql;
import com.yd.csf.service.service.ICommissionSqlTemplateService;
import com.yd.csf.service.service.IRelObjectSqlService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class ApiRelObjectSqlServiceImpl implements ApiRelObjectSqlService {
@Autowired
private IRelObjectSqlService iRelObjectSqlService;
@Autowired
private ICommissionSqlTemplateService iCommissionSqlTemplateService;
@Override
public Result saveRelList(ApiRelObjectSqlDto dto) {
//先删后新增
RelObjectSqlDto relObjectSqlDto = new RelObjectSqlDto();
BeanUtils.copyProperties(dto,relObjectSqlDto);
iRelObjectSqlService.del(relObjectSqlDto);
//新增
if (!CollectionUtils.isEmpty(dto.getSqlTemplateBizIdList())) {
List<RelObjectSql> saveList = dto.getSqlTemplateBizIdList().stream().map(bizId -> {
RelObjectSql relObjectSql = new RelObjectSql();
BeanUtils.copyProperties(dto,relObjectSql);
relObjectSql.setSqlTemplateBizId(bizId);
return relObjectSql;
}).collect(Collectors.toList());
iRelObjectSqlService.saveOrUpdateBatch(saveList);
}
return Result.success();
}
/**
* 根据对象关系查询SQL模板配置列表信息
* @param dto
* @return
*/
@Override
public Result<List<ApiCommissionSqlTemplateDto>> apiCommissionSqlTemplateDtoList(ApiRelObjectSqlDto dto) {
List<ApiCommissionSqlTemplateDto> apiCommissionSqlTemplateDtoList = new ArrayList<>();
RelObjectSqlDto relObjectSqlDto = new RelObjectSqlDto();
BeanUtils.copyProperties(dto,relObjectSqlDto);
List<RelObjectSql> relObjectSqlList = iRelObjectSqlService.queryList(relObjectSqlDto);
if (!CollectionUtils.isEmpty(relObjectSqlList)) {
List<String> sqlTemplateBizIdList = relObjectSqlList.stream().map(RelObjectSql::getSqlTemplateBizId).collect(Collectors.toList());
List<CommissionSqlTemplate> commissionSqlTemplateList = iCommissionSqlTemplateService.queryList(CommissionSqlTemplateDto.builder()
.sqlTemplateBizIdList(sqlTemplateBizIdList)
.build());
if (!CollectionUtils.isEmpty(commissionSqlTemplateList)) {
apiCommissionSqlTemplateDtoList = commissionSqlTemplateList.stream().map(d -> {
ApiCommissionSqlTemplateDto sqlTemplateDto = new ApiCommissionSqlTemplateDto();
BeanUtils.copyProperties(d,sqlTemplateDto);
return sqlTemplateDto;
}).collect(Collectors.toList());
}
}
return Result.success(apiCommissionSqlTemplateDtoList);
}
}
package com.yd.csf.api.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.common.constant.CodeGeneratorConstants;
import com.yd.common.enums.CommonEnum;
import com.yd.common.enums.ResultCode;
import com.yd.common.exception.BusinessException;
import com.yd.common.result.Result;
import com.yd.common.utils.CodeGenerator;
import com.yd.common.utils.RandomStringGenerator;
import com.yd.csf.api.service.ApiRelObjectFormulaService;
import com.yd.csf.api.service.ApiRuleItemConfigService;
import com.yd.csf.feign.dto.formulaconfig.ApiFormulaConfigDto;
import com.yd.csf.feign.dto.formulaconfig.ApiRelObjectFormulaDto;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigAddRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigEditRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigPageRequest;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigDetailResponse;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigPageResponse;
import com.yd.csf.service.dto.RuleItemConfigDto;
import com.yd.csf.service.model.RuleItemConfig;
import com.yd.csf.service.service.IRuleItemConfigService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@Service
public class ApiRuleItemConfigServiceImpl implements ApiRuleItemConfigService {
@Autowired
private IRuleItemConfigService iRuleItemConfigService;
@Autowired
private ApiRelObjectFormulaService apiRelObjectFormulaService;
/**
* 分页查询-基本法项目配置信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiRuleItemConfigPageResponse>> page(ApiRuleItemConfigPageRequest request) {
Page<ApiRuleItemConfigPageResponse> page = new Page<>(request.getPageNo(), request.getPageSize());
IPage<ApiRuleItemConfigPageResponse> iPage = iRuleItemConfigService.page(page, request);
return Result.success(iPage);
}
/**
* 详情-基本法项目配置信息
* @param ruleItemBizId
* @return
*/
@Override
public Result<ApiRuleItemConfigDetailResponse> detail(String ruleItemBizId) {
//校验基本法项目配置信息是否存在
Result<RuleItemConfig> result = checkRuleItemConfigIsExist(ruleItemBizId);
RuleItemConfig ruleItemConfig = result.getData();
ApiRuleItemConfigDetailResponse response = new ApiRuleItemConfigDetailResponse();
BeanUtils.copyProperties(ruleItemConfig,response);
//计算公式 - 查询对象公式配置关系表
Result<List<ApiFormulaConfigDto>> listResult = apiRelObjectFormulaService.apiFormulaConfigDtoList(ApiRelObjectFormulaDto.builder()
.objectBizId(ruleItemBizId)
.build());
if (!CollectionUtils.isEmpty(listResult.getData())) {
ApiFormulaConfigDto configDto = listResult.getData().get(0);
response.setApiFormulaConfigDto(configDto);
}
return Result.success(response);
}
/**
* 添加-基本法项目配置信息
* @param request
* @return
*/
@Override
public Result add(ApiRuleItemConfigAddRequest request) {
//校验基本法项目名称的唯一性
List<RuleItemConfig> list = iRuleItemConfigService.queryList(RuleItemConfigDto.builder()
.itemName(request.getItemName())
.build());
if (!CollectionUtils.isEmpty(list)) {
throw new BusinessException("基本法项目名称已存在");
}
RuleItemConfig ruleItemConfig = new RuleItemConfig();
BeanUtils.copyProperties(request,ruleItemConfig);
//基本法项目配置表唯一业务ID
ruleItemConfig.setRuleItemBizId(RandomStringGenerator.generateBizId16(CommonEnum.UID_TYPE_RULE_ITEM_CONFIG.getCode()));
//基本法项目编码
ruleItemConfig.setItemCode(CodeGenerator.generate10Code(CodeGeneratorConstants.PREFIX_ITEM_CODE));
iRuleItemConfigService.saveOrUpdate(ruleItemConfig);
//保存对象和公式配置关系
List<String> formulaBizIdList = new ArrayList<>();
formulaBizIdList.add(request.getFormulaBizId());
apiRelObjectFormulaService.saveRelList(ApiRelObjectFormulaDto.builder()
.objectBizId(ruleItemConfig.getRuleItemBizId())
.objectName(CommonEnum.UID_TYPE_RULE_ITEM_CONFIG.getName())
.objectTableName(CommonEnum.UID_TYPE_RULE_ITEM_CONFIG.getCode())
.objectType(CommonEnum.UID_TYPE_RULE_ITEM_CONFIG.getCode())
.formulaBizIdList(formulaBizIdList)
.build());
return Result.success();
}
/**
* 编辑-基本法项目配置信息
* @param request
* @return
*/
@Override
public Result edit(ApiRuleItemConfigEditRequest request) {
Result<RuleItemConfig> result = checkRuleItemConfigIsExist(request.getRuleItemBizId());
RuleItemConfig ruleItemConfig = result.getData();
//校验基本法项目名称的唯一性
List<RuleItemConfig> list = iRuleItemConfigService.queryList(RuleItemConfigDto.builder()
.itemName(request.getItemName())
.isExcludeMy(true)
.ruleItemBizId(request.getRuleItemBizId())
.build());
if (!CollectionUtils.isEmpty(list)) {
throw new BusinessException("基本法项目名称已存在");
}
BeanUtils.copyProperties(request,ruleItemConfig);
iRuleItemConfigService.saveOrUpdate(ruleItemConfig);
//保存对象和公式配置关系
List<String> formulaBizIdList = new ArrayList<>();
formulaBizIdList.add(request.getFormulaBizId());
apiRelObjectFormulaService.saveRelList(ApiRelObjectFormulaDto.builder()
.objectBizId(ruleItemConfig.getRuleItemBizId())
.objectName(CommonEnum.UID_TYPE_RULE_ITEM_CONFIG.getName())
.objectTableName(CommonEnum.UID_TYPE_RULE_ITEM_CONFIG.getCode())
.objectType(CommonEnum.UID_TYPE_RULE_ITEM_CONFIG.getCode())
.formulaBizIdList(formulaBizIdList)
.build());
return Result.success();
}
/**
* 删除-基本法项目配置信息 TODO
* @param ruleItemBizId
* @return
*/
@Override
public Result del(String ruleItemBizId) {
return null;
}
/**
* 校验基本法项目配置信息是否存在
* @param ruleItemBizId
* @return
*/
public Result<RuleItemConfig> checkRuleItemConfigIsExist(String ruleItemBizId) {
RuleItemConfig config = iRuleItemConfigService.queryOne(ruleItemBizId);
if (Objects.isNull(config)) {
//数据不存在
throw new BusinessException(ResultCode.NULL_ERROR.getCode(),ResultCode.NULL_ERROR.getMessage());
}
return Result.success(config);
}
}
package com.yd.csf.api.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.common.constant.CodeGeneratorConstants;
import com.yd.common.enums.CommonEnum;
import com.yd.common.enums.ResultCode;
import com.yd.common.exception.BusinessException;
import com.yd.common.result.Result;
import com.yd.common.utils.CodeGenerator;
import com.yd.common.utils.RandomStringGenerator;
import com.yd.csf.api.service.ApiRelObjectConditionService;
import com.yd.csf.api.service.ApiRelObjectSqlService;
import com.yd.csf.api.service.ApiVariableService;
import com.yd.csf.feign.dto.conditionconfig.ApiConditionTypeDto;
import com.yd.csf.feign.dto.conditionconfig.ApiRelObjectConditionDto;
import com.yd.csf.feign.dto.formulaconfig.ApiRelObjectFormulaDto;
import com.yd.csf.feign.dto.sqltemplate.ApiCommissionSqlTemplateDto;
import com.yd.csf.feign.dto.sqltemplate.ApiRelObjectSqlDto;
import com.yd.csf.feign.request.variable.ApiVariableAddRequest;
import com.yd.csf.feign.request.variable.ApiVariableEditRequest;
import com.yd.csf.feign.request.variable.ApiVariablePageRequest;
import com.yd.csf.feign.response.variable.ApiVariableDetailResponse;
import com.yd.csf.feign.response.variable.ApiVariablePageResponse;
import com.yd.csf.service.dto.VariableDto;
import com.yd.csf.service.model.Variable;
import com.yd.csf.service.service.IRelObjectConditionService;
import com.yd.csf.service.service.IVariableService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@Service
public class ApiVariableServiceImpl implements ApiVariableService {
@Autowired
private IVariableService iVariableService;
@Autowired
private ApiRelObjectConditionService apiRelObjectConditionService;
@Autowired
private ApiRelObjectSqlService apiRelObjectSqlService;
/**
* 分页查询-变量信息
* @param request
* @return
*/
@Override
public Result<IPage<ApiVariablePageResponse>> page(ApiVariablePageRequest request) {
Page<ApiVariablePageResponse> page = new Page<>(request.getPageNo(), request.getPageSize());
IPage<ApiVariablePageResponse> iPage = iVariableService.page(page, request);
return Result.success(iPage);
}
/**
* 详情-变量信息
* @param variableBizId
* @return
*/
@Override
public Result<ApiVariableDetailResponse> detail(String variableBizId) {
//校验变量信息是否存在
Result<Variable> result = checkVariableIsExist(variableBizId);
Variable variable = result.getData();
ApiVariableDetailResponse response = new ApiVariableDetailResponse();
BeanUtils.copyProperties(variable,response);
//绑定的条件类型对象 - 查询对象条件关系表
Result<List<ApiConditionTypeDto>> listResult = apiRelObjectConditionService.apiConditionTypeDtoList(ApiRelObjectConditionDto.builder().objectBizId(variableBizId).build());
if (!CollectionUtils.isEmpty(listResult.getData())) {
ApiConditionTypeDto typeDto = listResult.getData().get(0);
response.setApiConditionTypeDto(typeDto);
}
//绑定的SQL模板对象
Result<List<ApiCommissionSqlTemplateDto>> listResult1 = apiRelObjectSqlService.apiCommissionSqlTemplateDtoList(ApiRelObjectSqlDto.builder().objectBizId(variableBizId).build());
if (!CollectionUtils.isEmpty(listResult1.getData())) {
ApiCommissionSqlTemplateDto sqlTemplateDto = listResult1.getData().get(0);
response.setApiCommissionSqlTemplateDto(sqlTemplateDto);
}
return Result.success(response);
}
/**
* 添加-变量信息
* @param request
* @return
*/
@Override
public Result add(ApiVariableAddRequest request) {
//校验变量中文名唯一性
List<Variable> variableList = iVariableService.queryList(VariableDto.builder()
.nameCn(request.getNameCn())
.build());
if (!CollectionUtils.isEmpty(variableList)) {
throw new BusinessException("变量中文名已存在");
}
//校验变量英文名唯一性
List<Variable> variableList1 = iVariableService.queryList(VariableDto.builder()
.nameEn(request.getNameEn())
.build());
if (!CollectionUtils.isEmpty(variableList1)) {
throw new BusinessException("变量英文名已存在");
}
Variable variable = new Variable();
BeanUtils.copyProperties(request,variable);
variable.setVariableBizId(RandomStringGenerator.generateBizId16(CommonEnum.UID_TYPE_VARIABLE.getCode()));
//变量编码
variable.setVariableCode(CodeGenerator.generate10Code(CodeGeneratorConstants.PREFIX_VARIABLE_CODE));
iVariableService.saveOrUpdate(variable);
//绑定的条件类型业务ID - 保存对象条件关系表数据
List<String> conditionTypeBizIdList = new ArrayList<>();
conditionTypeBizIdList.add(request.getConditionTypeBizId());
apiRelObjectConditionService.saveRelList(ApiRelObjectConditionDto.builder()
.objectBizId(variable.getVariableBizId())
.objectName(CommonEnum.UID_TYPE_VARIABLE.getName())
.objectTableName(CommonEnum.UID_TYPE_VARIABLE.getCode())
.objectType(CommonEnum.UID_TYPE_VARIABLE.getCode())
.conditionTypeBizIdList(conditionTypeBizIdList)
.build());
//绑定的sql模板业务ID - 保存对象sql模板关系表数据
List<String> sqlTemplateBizIdList = new ArrayList<>();
sqlTemplateBizIdList.add(request.getSqlTemplateBizId());
apiRelObjectSqlService.saveRelList(ApiRelObjectSqlDto.builder()
.objectBizId(variable.getVariableBizId())
.objectName(CommonEnum.UID_TYPE_VARIABLE.getName())
.objectTableName(CommonEnum.UID_TYPE_VARIABLE.getCode())
.objectType(CommonEnum.UID_TYPE_VARIABLE.getCode())
.sqlTemplateBizIdList(sqlTemplateBizIdList)
.build());
return Result.success();
}
/**
* 编辑-变量信息
* @param request
* @return
*/
@Override
public Result edit(ApiVariableEditRequest request) {
//校验变量中文名唯一性
List<Variable> variableList = iVariableService.queryList(VariableDto.builder()
.nameCn(request.getNameCn())
.isExcludeMy(true)
.variableBizId(request.getVariableBizId())
.build());
if (!CollectionUtils.isEmpty(variableList)) {
throw new BusinessException("变量中文名已存在");
}
//校验变量英文名唯一性
List<Variable> variableList1 = iVariableService.queryList(VariableDto.builder()
.nameEn(request.getNameEn())
.isExcludeMy(true)
.variableBizId(request.getVariableBizId())
.build());
if (!CollectionUtils.isEmpty(variableList1)) {
throw new BusinessException("变量英文名已存在");
}
Variable variable = new Variable();
BeanUtils.copyProperties(request,variable);
iVariableService.saveOrUpdate(variable);
//绑定的条件类型业务ID - 保存对象条件关系表数据
List<String> conditionTypeBizIdList = new ArrayList<>();
conditionTypeBizIdList.add(request.getConditionTypeBizId());
apiRelObjectConditionService.saveRelList(ApiRelObjectConditionDto.builder()
.objectBizId(variable.getVariableBizId())
.objectName(CommonEnum.UID_TYPE_VARIABLE.getName())
.objectTableName(CommonEnum.UID_TYPE_VARIABLE.getCode())
.objectType(CommonEnum.UID_TYPE_VARIABLE.getCode())
.conditionTypeBizIdList(conditionTypeBizIdList)
.build());
//绑定的sql模板业务ID - 保存对象sql模板关系表数据
List<String> sqlTemplateBizIdList = new ArrayList<>();
sqlTemplateBizIdList.add(request.getSqlTemplateBizId());
apiRelObjectSqlService.saveRelList(ApiRelObjectSqlDto.builder()
.objectBizId(variable.getVariableBizId())
.objectName(CommonEnum.UID_TYPE_VARIABLE.getName())
.objectTableName(CommonEnum.UID_TYPE_VARIABLE.getCode())
.objectType(CommonEnum.UID_TYPE_VARIABLE.getCode())
.sqlTemplateBizIdList(sqlTemplateBizIdList)
.build());
return Result.success();
}
/**
* 删除-变量信息 TODO
* @param variableBizId
* @return
*/
@Override
public Result del(String variableBizId) {
return null;
}
/**
* 校验变量信息是否存在
* @param variableBizId
* @return
*/
public Result<Variable> checkVariableIsExist(String variableBizId) {
Variable variable = iVariableService.queryOne(variableBizId);
if (Objects.isNull(variable)) {
//数据不存在
throw new BusinessException(ResultCode.NULL_ERROR.getCode(),ResultCode.NULL_ERROR.getMessage());
}
return Result.success(variable);
}
}
...@@ -44,7 +44,7 @@ spring: ...@@ -44,7 +44,7 @@ spring:
# 配置中心 # 配置中心
config: config:
# 命名空间id(此处不用public,因public初始化的空间, id为空) # 命名空间id(此处不用public,因public初始化的空间, id为空)
namespace: b3b01715-eb85-4242-992a-5aff03d864d4 namespace: 8fbea9a4-b626-46de-a4e6-9d23f6609318
# nacos的ip地址和端口 # nacos的ip地址和端口
server-addr: 139.224.145.34:8848 server-addr: 139.224.145.34:8848
# 这个就表示 在我们nacos命名空间id为 dev中 有一个data-id 为 demo-service.yml 的配置文件 读取这个里面的配置 # 这个就表示 在我们nacos命名空间id为 dev中 有一个data-id 为 demo-service.yml 的配置文件 读取这个里面的配置
......
package com.yd.csf.feign.client.commissionruleconfig;
import com.yd.common.result.Result;
import com.yd.csf.feign.fallback.commissionruleconfig.ApiCommissionRuleConfigFeignFallbackFactory;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigAddRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigEditRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigPageRequest;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigDetailResponse;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.NotBlank;
/**
* 香港保险服务-基本法配置信息Feign客户端
*/
@FeignClient(name = "yd-csf-api", fallbackFactory = ApiCommissionRuleConfigFeignFallbackFactory.class)
public interface ApiCommissionRuleConfigFeignClient {
/**
* 分页查询-基本法配置信息
* @param request
* @return
*/
@PostMapping("/page")
Result page(@RequestBody ApiCommissionRuleConfigPageRequest request);
/**
* 详情-基本法配置信息
* @param ruleBizId
* @return
*/
@GetMapping("/detail")
Result<ApiCommissionRuleConfigDetailResponse> detail(@NotBlank(message = "基本法配置表唯一业务ID不能为空不能为空") @RequestParam(value = "ruleBizId") String ruleBizId);
/**
* 添加-基本法配置信息
* @param request
* @return
*/
@PostMapping("/add")
Result add(@Validated @RequestBody ApiCommissionRuleConfigAddRequest request);
/**
* 编辑-基本法配置信息
* @param request
* @return
*/
@PutMapping("/edit")
Result edit(@Validated @RequestBody ApiCommissionRuleConfigEditRequest request);
/**
* 删除-基本法配置信息 TODO
* @param ruleBizId
* @return
*/
@DeleteMapping("/del")
Result del(@NotBlank(message = "基本法配置表唯一业务ID不能为空不能为空") @RequestParam(value = "ruleBizId") String ruleBizId);
}
package com.yd.csf.feign.client.formulaconfig;
import com.yd.csf.feign.fallback.formulaconfig.ApiFormulaConfigFeignFallbackFactory;
import org.springframework.cloud.openfeign.FeignClient;
/**
* 香港保险服务-公式配置信息Feign客户端
*/
@FeignClient(name = "yd-csf-api", fallbackFactory = ApiFormulaConfigFeignFallbackFactory.class)
public interface ApiFormulaConfigFeignClient {
}
package com.yd.csf.feign.client.ruleItemconfig;
import com.yd.common.result.Result;
import com.yd.csf.feign.fallback.ruleItemconfig.ApiRuleItemConfigFeignFallbackFactory;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigAddRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigEditRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigPageRequest;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigDetailResponse;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.NotBlank;
/**
* 香港保险服务-基本法项目配置信息Feign客户端
*/
@FeignClient(name = "yd-csf-api", fallbackFactory = ApiRuleItemConfigFeignFallbackFactory.class)
public interface ApiRuleItemConfigFeignClient {
/**
* 分页查询-基本法项目配置信息
* @param request
* @return
*/
@PostMapping("/page")
Result page(@RequestBody ApiRuleItemConfigPageRequest request);
/**
* 详情-基本法项目配置信息
* @param ruleItemBizId
* @return
*/
@GetMapping("/detail")
Result<ApiRuleItemConfigDetailResponse> detail(@NotBlank(message = "基本法项目配置信息表唯一业务ID不能为空不能为空") @RequestParam(value = "ruleItemBizId") String ruleItemBizId);
/**
* 添加-基本法项目配置信息
* @param request
* @return
*/
@PostMapping("/add")
Result add(@Validated @RequestBody ApiRuleItemConfigAddRequest request);
/**
* 编辑-基本法项目配置信息
* @param request
* @return
*/
@PutMapping("/edit")
Result edit(@Validated @RequestBody ApiRuleItemConfigEditRequest request);
/**
* 删除-基本法项目配置信息 TODO
* @param ruleItemBizId
* @return
*/
@DeleteMapping("/del")
Result del(@NotBlank(message = "基本法项目配置信息表唯一业务ID不能为空不能为空") @RequestParam(value = "ruleItemBizId") String ruleItemBizId);
}
package com.yd.csf.feign.client.variable;
import com.yd.common.result.Result;
import com.yd.csf.feign.fallback.variable.ApiVariableFeignFallbackFactory;
import com.yd.csf.feign.request.variable.ApiVariableAddRequest;
import com.yd.csf.feign.request.variable.ApiVariableEditRequest;
import com.yd.csf.feign.request.variable.ApiVariablePageRequest;
import com.yd.csf.feign.response.variable.ApiVariableDetailResponse;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.NotBlank;
/**
* 香港保险服务-变量信息Feign客户端
*/
@FeignClient(name = "yd-csf-api", fallbackFactory = ApiVariableFeignFallbackFactory.class)
public interface ApiVariableFeignClient {
/**
* 分页查询-变量信息
* @param request
* @return
*/
@PostMapping("/page")
Result page(@RequestBody ApiVariablePageRequest request);
/**
* 详情-变量信息
* @param variableBizId
* @return
*/
@GetMapping("/detail")
Result<ApiVariableDetailResponse> detail(@NotBlank(message = "变量信息表唯一业务ID不能为空不能为空") @RequestParam(value = "variableBizId") String variableBizId);
/**
* 添加-变量信息
* @param request
* @return
*/
@PostMapping("/add")
Result add(@Validated @RequestBody ApiVariableAddRequest request);
/**
* 编辑-变量信息
* @param request
* @return
*/
@PutMapping("/edit")
Result edit(@Validated @RequestBody ApiVariableEditRequest request);
/**
* 删除-变量信息 TODO
* @param variableBizId
* @return
*/
@DeleteMapping("/del")
Result del(@NotBlank(message = "变量信息表唯一业务ID不能为空不能为空") @RequestParam(value = "variableBizId") String variableBizId);
}
package com.yd.csf.feign.dto.conditionconfig;
import lombok.Data;
@Data
public class ApiConditionTypeDto {
/**
* 条件类型表唯一业务ID
*/
private String conditionTypeBizId;
/**
* 条件类型编码(一个条件类型编码可能包含多个条件)
*/
private String code;
/**
* 条件类型名称
*/
private String name;
}
package com.yd.csf.feign.dto.conditionconfig;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ApiRelObjectConditionDto {
/**
* 对象类型
*/
private String objectType;
/**
* 对象所属表名
*/
private String objectTableName;
/**
* 对象名
*/
private String objectName;
/**
* 对象业务ID
*/
private String objectBizId;
/**
* 绑定条件类型表唯一业务ID列表
*/
private List<String> conditionTypeBizIdList;
}
package com.yd.csf.feign.dto.formulaconfig;
import lombok.Data;
@Data
public class ApiFormulaConfigDto {
/**
* 公式配置表唯一业务ID
*/
private String formulaBizId;
/**
* 公式编码
*/
private String code;
/**
* 公式名称
*/
private String name;
/**
* 计算公式(变量中文名称组合,用于展示)
*/
private String calculationFormulaCn;
/**
* 计算公式(变量表唯一业务ID组合)
*/
private String calculationFormulaBizId;
}
package com.yd.csf.feign.dto.formulaconfig;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ApiRelObjectFormulaDto {
/**
* 对象类型
*/
private String objectType;
/**
* 对象所属表名
*/
private String objectTableName;
/**
* 对象名
*/
private String objectName;
/**
* 对象业务ID
*/
private String objectBizId;
/**
* 公式配置表唯一业务ID
*/
private String formulaBizId;
/**
* 公式配置表唯一业务ID列表
*/
private List<String> formulaBizIdList;
}
package com.yd.csf.feign.dto.sqltemplate;
import lombok.Data;
@Data
public class ApiCommissionSqlTemplateDto {
/**
* SQL模板表唯一业务ID
*/
private String sqlTemplateBizId;
/**
* 模板编码
*/
private String sqlTemplateCode;
/**
* 模板名称
*/
private String sqlTemplateName;
/**
* SQL模板内容
*/
private String sqlTemplate;
}
package com.yd.csf.feign.dto.sqltemplate;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ApiRelObjectSqlDto {
/**
* 对象类型
*/
private String objectType;
/**
* 对象所属表名
*/
private String objectTableName;
/**
* 对象名
*/
private String objectName;
/**
* 对象业务ID
*/
private String objectBizId;
/**
* 绑定的sql模板业务ID列表
*/
private List<String> sqlTemplateBizIdList;
}
package com.yd.csf.feign.dto.variable;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class ApiRuleConditionConfigDto {
/**
* 主键ID
*/
private Long id;
/**
* 条件配置唯一业务ID
*/
private String conditionBizId;
/**
* 类型(1-条件 2-计算公式)
*/
private String type;
/**
* 一级分类编码
*/
private String firstCategoryCode;
/**
* 一级分类名称
*/
private String firstCategoryName;
/**
* 二级分类编码
*/
private String secondCategoryCode;
/**
* 二级分类名称
*/
private String secondCategoryName;
/**
* 计算公式
*/
private String calculationFormula;
/**
* 条件值(范围内的值)
*/
private String conditionalValue;
/**
* 条件-最小值(在范围条件中表示最小值)
*/
private BigDecimal minValue;
/**
* 条件-最大值(在范围条件中表示最大值)
*/
private BigDecimal maxValue;
/**
* 条件-是否包含最小值(是否包含最小值,1表示包含,0表示不包含)
*/
private Integer includeMin;
/**
* 条件-是否包含最大值(是否包含最大值,1表示包含,0表示不包含)
*/
private Integer includeMax;
/**
* 优先级(数字越小优先级越高)
*/
private Integer priority;
}
package com.yd.csf.feign.fallback.commissionruleconfig;
import com.yd.common.result.Result;
import com.yd.csf.feign.client.commissionruleconfig.ApiCommissionRuleConfigFeignClient;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigAddRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigEditRequest;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigPageRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
/**
* 香港保险服务-基本法配置信息Feign降级处理
*/
@Slf4j
@Component
public class ApiCommissionRuleConfigFeignFallbackFactory implements FallbackFactory<ApiCommissionRuleConfigFeignClient> {
@Override
public ApiCommissionRuleConfigFeignClient create(Throwable cause) {
return new ApiCommissionRuleConfigFeignClient() {
@Override
public Result page(ApiCommissionRuleConfigPageRequest request) {
return null;
}
@Override
public Result detail(String ruleBizId) {
return null;
}
@Override
public Result add(ApiCommissionRuleConfigAddRequest request) {
return null;
}
@Override
public Result edit(ApiCommissionRuleConfigEditRequest request) {
return null;
}
@Override
public Result del(String ruleBizId) {
return null;
}
};
}
}
package com.yd.csf.feign.fallback.formulaconfig;
import com.yd.csf.feign.client.formulaconfig.ApiFormulaConfigFeignClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
/**
* 香港保险服务-受益人信息Feign降级处理
*/
@Slf4j
@Component
public class ApiFormulaConfigFeignFallbackFactory implements FallbackFactory<ApiFormulaConfigFeignClient> {
@Override
public ApiFormulaConfigFeignClient create(Throwable cause) {
return null;
}
}
package com.yd.csf.feign.fallback.ruleItemconfig;
import com.yd.common.result.Result;
import com.yd.csf.feign.client.ruleItemconfig.ApiRuleItemConfigFeignClient;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigAddRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigEditRequest;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigPageRequest;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigDetailResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
/**
* 香港保险服务-基本法项目配置信息Feign降级处理
*/
@Slf4j
@Component
public class ApiRuleItemConfigFeignFallbackFactory implements FallbackFactory<ApiRuleItemConfigFeignClient> {
@Override
public ApiRuleItemConfigFeignClient create(Throwable cause) {
return new ApiRuleItemConfigFeignClient() {
@Override
public Result page(ApiRuleItemConfigPageRequest request) {
return null;
}
@Override
public Result<ApiRuleItemConfigDetailResponse> detail(String ruleItemBizId) {
return null;
}
@Override
public Result add(ApiRuleItemConfigAddRequest request) {
return null;
}
@Override
public Result edit(ApiRuleItemConfigEditRequest request) {
return null;
}
@Override
public Result del(String ruleItemBizId) {
return null;
}
};
}
}
package com.yd.csf.feign.fallback.variable;
import com.yd.common.result.Result;
import com.yd.csf.feign.client.variable.ApiVariableFeignClient;
import com.yd.csf.feign.request.variable.ApiVariableAddRequest;
import com.yd.csf.feign.request.variable.ApiVariableEditRequest;
import com.yd.csf.feign.request.variable.ApiVariablePageRequest;
import com.yd.csf.feign.response.variable.ApiVariableDetailResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
/**
* 香港保险服务-变量信息Feign降级处理
*/
@Slf4j
@Component
public class ApiVariableFeignFallbackFactory implements FallbackFactory<ApiVariableFeignClient> {
@Override
public ApiVariableFeignClient create(Throwable cause) {
return new ApiVariableFeignClient() {
@Override
public Result page(ApiVariablePageRequest request) {
return null;
}
@Override
public Result<ApiVariableDetailResponse> detail(String variableBizId) {
return null;
}
@Override
public Result add(ApiVariableAddRequest request) {
return null;
}
@Override
public Result edit(ApiVariableEditRequest request) {
return null;
}
@Override
public Result del(String variableBizId) {
return null;
}
};
}
}
package com.yd.csf.feign.request.commissionruleconfig;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.time.LocalDateTime;
@Data
public class ApiCommissionRuleConfigAddRequest {
/**
* 基本法名称
*/
@NotBlank(message = "基本法名称不能为空")
private String ruleName;
/**
* 基本法描述
*/
private String description;
/**
* 生效开始日期
*/
private LocalDateTime effectiveStart;
/**
* 生效结束日期
*/
private LocalDateTime effectiveEnd;
/**
* 状态(0:停用 1:启用)
*/
@NotNull(message = "状态不能为空")
private Integer status;
/**
* 版本号
*/
private Integer ruleVersion;
// /**
// * 所属租户唯一业务ID(冗余)
// */
// private String tenantBizId;
//
// /**
// * 所属项目唯一业务ID(冗余)
// */
// private String projectBizId;
}
package com.yd.csf.feign.request.commissionruleconfig;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.time.LocalDateTime;
@Data
public class ApiCommissionRuleConfigEditRequest {
/**
* 基本法配置表唯一业务ID
*/
@NotBlank(message = "基本法配置表唯一业务ID不能为空")
private String ruleBizId;
/**
* 基本法名称
*/
@NotBlank(message = "基本法名称不能为空")
private String ruleName;
/**
* 基本法描述
*/
private String description;
/**
* 生效开始日期
*/
private LocalDateTime effectiveStart;
/**
* 生效结束日期
*/
private LocalDateTime effectiveEnd;
/**
* 状态(0:停用 1:启用)
*/
@NotNull(message = "状态不能为空")
private Integer status;
/**
* 版本号
*/
private Integer ruleVersion;
// /**
// * 所属租户唯一业务ID(冗余)
// */
// private String tenantBizId;
//
// /**
// * 所属项目唯一业务ID(冗余)
// */
// private String projectBizId;
}
package com.yd.csf.feign.request.commissionruleconfig;
import com.yd.common.dto.PageDto;
import lombok.Data;
@Data
public class ApiCommissionRuleConfigPageRequest extends PageDto {
/**
* 基本法名称(模糊搜索)
*/
private String ruleName;
}
package com.yd.csf.feign.request.ruleItemconfig;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
@Data
public class ApiRuleItemConfigAddRequest {
/**
* 基本法配置表唯一业务ID
*/
@NotBlank(message = "基本法配置表唯一业务ID不能为空")
private String ruleBizId;
/**
* 基本法项目名称
*/
@NotBlank(message = "基本法项目名称不能为空")
private String itemName;
/**
* 计算时间点(字典)
*/
@NotBlank(message = "计算时间点不能为空")
private String calculate;
/**
* 执行顺序,数值越小越先执行,用于控制佣金项目的计算顺序
*/
private Integer executionOrder;
/**
* 公式配置表唯一业务ID
*/
private String formulaBizId;
/**
* 项目描述
*/
private String description;
/**
* 状态(0:停用 1:启用)
*/
@NotNull(message = "状态不能为空")
private Integer status;
// /**
// * 所属租户唯一业务ID(冗余)
// */
// private String tenantBizId;
//
// /**
// * 所属项目唯一业务ID(冗余)
// */
// private String projectBizId;
}
package com.yd.csf.feign.request.ruleItemconfig;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
@Data
public class ApiRuleItemConfigEditRequest {
/**
* 基本法项目配置表唯一业务ID
*/
@NotBlank(message = "基本法项目配置表唯一业务ID不能为空")
private String ruleItemBizId;
/**
* 基本法配置表唯一业务ID
*/
@NotBlank(message = "基本法配置表唯一业务ID不能为空")
private String ruleBizId;
/**
* 基本法项目名称
*/
@NotBlank(message = "基本法项目名称不能为空")
private String itemName;
/**
* 计算时间点(字典)
*/
@NotBlank(message = "计算时间点不能为空")
private String calculate;
/**
* 执行顺序,数值越小越先执行,用于控制佣金项目的计算顺序
*/
private Integer executionOrder;
/**
* 公式配置表唯一业务ID
*/
private String formulaBizId;
/**
* 项目描述
*/
private String description;
/**
* 状态(0:停用 1:启用)
*/
@NotNull(message = "状态不能为空")
private Integer status;
// /**
// * 所属租户唯一业务ID(冗余)
// */
// private String tenantBizId;
//
// /**
// * 所属项目唯一业务ID(冗余)
// */
// private String projectBizId;
}
package com.yd.csf.feign.request.ruleItemconfig;
import com.yd.common.dto.PageDto;
import lombok.Data;
@Data
public class ApiRuleItemConfigPageRequest extends PageDto {
/**
* 基本法项目名称(模糊搜索)
*/
private String itemName;
/**
* 计算时间点(字典)
*/
private String calculate;
}
package com.yd.csf.feign.request.variable;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
@Data
public class ApiVariableAddRequest {
/**
* 变量名称中文名
*/
@NotBlank(message = "变量名称中文名不能为空")
private String nameCn;
/**
* 变量名称英文名
*/
@NotBlank(message = "变量名称英文名不能为空")
private String nameEn;
/**
* 变量类型(字典: 固定值、动态计算,如果固定值这个变量取值就是value变量值这个字段,如果是动态计算需要关联条件(对象和条件配置关系表)和SQL计算(对象和SQL模板配置关系表)对应的变量值)
*/
@NotBlank(message = "变量类型不能为空")
private String type;
/**
* 变量值
*/
@NotBlank(message = "变量值不能为空")
private String value;
// /**
// * 所属租户唯一业务ID(冗余)
// */
// private String tenantBizId;
//
// /**
// * 所属项目唯一业务ID(冗余)
// */
// private String projectBizId;
/**
* 状态(0:停用 1:启用)
*/
@NotNull(message = "状态不能为空")
private Integer status;
/**
* 绑定的条件类型业务ID
*/
private String conditionTypeBizId;
/**
* 绑定SQL模板表唯一业务ID
*/
private String sqlTemplateBizId;
}
package com.yd.csf.feign.request.variable;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
@Data
public class ApiVariableEditRequest {
/**
* 变量表唯一业务ID
*/
@NotBlank(message = "变量表唯一业务ID不能为空")
private String variableBizId;
/**
* 变量名称中文名
*/
@NotBlank(message = "变量名称中文名不能为空")
private String nameCn;
/**
* 变量名称英文名
*/
@NotBlank(message = "变量名称英文名不能为空")
private String nameEn;
/**
* 变量类型(字典: 固定值、动态计算,如果固定值这个变量取值就是value变量值这个字段,如果是动态计算需要关联条件(对象和条件配置关系表)和SQL计算(对象和SQL模板配置关系表)对应的变量值)
*/
@NotBlank(message = "变量类型不能为空")
private String type;
/**
* 变量值
*/
@NotBlank(message = "变量值不能为空")
private String value;
/**
* 状态(0:停用 1:启用)
*/
@NotNull(message = "状态不能为空")
private Integer status;
/**
* 绑定的条件类型业务ID
*/
private String conditionTypeBizId;
/**
* 绑定SQL模板表唯一业务ID
*/
private String sqlTemplateBizId;
// /**
// * 所属租户唯一业务ID(冗余)
// */
// private String tenantBizId;
//
// /**
// * 所属项目唯一业务ID(冗余)
// */
// private String projectBizId;
}
package com.yd.csf.feign.request.variable;
import com.yd.common.dto.PageDto;
import lombok.Data;
@Data
public class ApiVariablePageRequest extends PageDto {
/**
* 变量名称中文名
*/
private String nameCn;
/**
* 变量类型(字典: 固定值、动态计算,如果固定值这个变量取值就是value变量值这个字段,如果是动态计算需要关联条件和SQL计算对应的变量值)
*/
private String type;
}
package com.yd.csf.feign.response.commissionruleconfig;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class ApiCommissionRuleConfigDetailResponse {
/**
* 主键ID
*/
private Long id;
/**
* 基本法配置表唯一业务ID
*/
private String ruleBizId;
/**
* 基本法编码
*/
private String ruleCode;
/**
* 基本法名称
*/
private String ruleName;
/**
* 基本法描述
*/
private String description;
/**
* 生效开始日期
*/
private LocalDateTime effectiveStart;
/**
* 生效结束日期
*/
private LocalDateTime effectiveEnd;
/**
* 状态(0:停用 1:启用)
*/
private Integer status;
/**
* 版本号
*/
private Integer ruleVersion;
// /**
// * 所属租户唯一业务ID(冗余)
// */
// private String tenantBizId;
//
// /**
// * 所属项目唯一业务ID(冗余)
// */
// private String projectBizId;
/**
* 通用备注
*/
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
private Integer isDeleted;
/**
* 创建人ID
*/
private String creatorId;
/**
* 更新人ID
*/
private String updaterId;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
package com.yd.csf.feign.response.commissionruleconfig;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class ApiCommissionRuleConfigPageResponse {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
private Long id;
/**
* 基本法配置表唯一业务ID
*/
private String ruleBizId;
/**
* 基本法编码
*/
private String ruleCode;
/**
* 基本法名称
*/
private String ruleName;
/**
* 基本法描述
*/
private String description;
/**
* 生效开始日期
*/
private LocalDateTime effectiveStart;
/**
* 生效结束日期
*/
private LocalDateTime effectiveEnd;
/**
* 状态(0:停用 1:启用)
*/
private Integer status;
/**
* 通用备注
*/
private String remark;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
package com.yd.csf.feign.response.ruleItemconfig;
import com.yd.csf.feign.dto.formulaconfig.ApiFormulaConfigDto;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class ApiRuleItemConfigDetailResponse {
/**
* 主键ID
*/
private Long id;
/**
* 基本法项目配置表唯一业务ID
*/
private String ruleItemBizId;
/**
* 基本法配置表唯一业务ID
*/
private String ruleBizId;
/**
* 基本法项目编码
*/
private String itemCode;
/**
* 基本法项目名称
*/
private String itemName;
/**
* 计算时间点(字典)
*/
private String calculate;
/**
* 执行顺序,数值越小越先执行,用于控制佣金项目的计算顺序
*/
private Integer executionOrder;
/**
* 项目描述
*/
private String description;
/**
* 状态(0:停用 1:启用)
*/
private Integer status;
/**
* 通用备注
*/
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
private Integer isDeleted;
/**
* 创建人ID
*/
private String creatorId;
/**
* 更新人ID
*/
private String updaterId;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 绑定的公式对象
*/
private ApiFormulaConfigDto apiFormulaConfigDto;
}
package com.yd.csf.feign.response.ruleItemconfig;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class ApiRuleItemConfigPageResponse {
/**
* 基本法项目配置表主键ID
*/
private Long id;
/**
* 基本法项目配置表唯一业务ID
*/
private String ruleItemBizId;
/**
* 基本法配置表唯一业务ID
*/
private String ruleBizId;
/**
* 基本法名称
*/
private String ruleName;
/**
* 基本法项目编码
*/
private String itemCode;
/**
* 基本法项目名称
*/
private String itemName;
/**
* 计算时间点(字典)
*/
private String calculate;
/**
* 执行顺序,数值越小越先执行,用于控制佣金项目的计算顺序
*/
private Integer executionOrder;
/**
* 状态(0:停用 1:启用)
*/
private Integer status;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
package com.yd.csf.feign.response.variable;
import com.yd.csf.feign.dto.conditionconfig.ApiConditionTypeDto;
import com.yd.csf.feign.dto.sqltemplate.ApiCommissionSqlTemplateDto;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
@Data
public class ApiVariableDetailResponse {
/**
* 主键ID
*/
private Long id;
/**
* 变量表唯一业务ID
*/
private String variableBizId;
/**
* 变量编码
*/
private String variableCode;
/**
* 变量名称中文名
*/
private String nameCn;
/**
* 变量名称英文名
*/
private String nameEn;
/**
* 变量类型(字典: 固定值、动态计算,如果固定值这个变量取值就是value变量值这个字段,如果是动态计算需要关联条件和SQL计算对应的变量值)
*/
private String type;
/**
* 变量值
*/
private String value;
/**
* 状态(0:停用 1:启用)
*/
private Integer status;
/**
* 通用备注
*/
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
private Integer isDeleted;
/**
* 创建人ID
*/
private String creatorId;
/**
* 更新人ID
*/
private String updaterId;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 绑定的条件类型对象
*/
private ApiConditionTypeDto apiConditionTypeDto;
/**
* 绑定的SQL模板对象
*/
private ApiCommissionSqlTemplateDto apiCommissionSqlTemplateDto;
}
package com.yd.csf.feign.response.variable;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class ApiVariablePageResponse {
/**
* 主键ID
*/
private Long id;
/**
* 变量表唯一业务ID
*/
private String variableBizId;
/**
* 变量编码
*/
private String variableCode;
/**
* 变量名称中文名
*/
private String nameCn;
/**
* 变量名称英文名
*/
private String nameEn;
/**
* 变量类型(字典: 固定值、动态计算,如果固定值这个变量取值就是value变量值这个字段,如果是动态计算需要关联条件和SQL计算对应的变量值)
*/
private String type;
/**
* 变量值
*/
private String value;
/**
* 状态(0:停用 1:启用)
*/
private Integer status;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.AgentAccumulatedFyc;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 业务员累计积分表 - 存储业务员的累计FYC积分和当前等级信息 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface AgentAccumulatedFycMapper extends BaseMapper<AgentAccumulatedFyc> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.AgentDetailFyc;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 业务员积分明细表 - 存储业务员的每次增加或者减少的FYC积分 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface AgentDetailFycMapper extends BaseMapper<AgentDetailFyc> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.AgentReferralRelation;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 推荐关系表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface AgentReferralRelationMapper extends BaseMapper<AgentReferralRelation> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.AgentTutoringRelation;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 辅导关系表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface AgentTutoringRelationMapper extends BaseMapper<AgentTutoringRelation> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.BatchPolicy;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 保单批次保单关联表 - 存储批次与保单的关联关系,记录批次中每个保单的计算状态 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface BatchPolicyMapper extends BaseMapper<BatchPolicy> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.CarApply;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 车辆预约申请表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface CarApplyMapper extends BaseMapper<CarApply> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.ClientRole;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 客户端角色表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface ClientRoleMapper extends BaseMapper<ClientRole> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.CommissionResult;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 保单佣金计算结果表(出账表) - 存储佣金计算的详细结果,用于查询、对账和发放 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface CommissionResultMapper extends BaseMapper<CommissionResult> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.CommissionRuleBinding;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 基本法绑定表 - 存储基本法与业务员或团队的绑定关系,支持灵活的权限分配 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface CommissionRuleBindingMapper extends BaseMapper<CommissionRuleBinding> {
}
package com.yd.csf.service.dao;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigPageRequest;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigPageResponse;
import com.yd.csf.service.model.CommissionRuleConfig;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* 基本法配置表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface CommissionRuleConfigMapper extends BaseMapper<CommissionRuleConfig> {
IPage<ApiCommissionRuleConfigPageResponse> page(@Param("page") Page<ApiCommissionRuleConfigPageResponse> page,
@Param("request") ApiCommissionRuleConfigPageRequest request);
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.CommissionSqlTemplate;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* SQL模板表 - 存储所有佣金计算相关的动态SQL模板,支持灵活配置和参数化查询,实现业务逻辑与代码解耦 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface CommissionSqlTemplateMapper extends BaseMapper<CommissionSqlTemplate> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.ConditionConfig;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 条件配置表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface ConditionConfigMapper extends BaseMapper<ConditionConfig> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.ConditionType;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 条件类型表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface ConditionTypeMapper extends BaseMapper<ConditionType> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.FormulaConfig;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 公式配置表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface FormulaConfigMapper extends BaseMapper<FormulaConfig> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.FycTask;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 业务员积分任务表 - 定时跑批业务员绑定的基本法计算点,算出当前业务员所得的积分(一级管理奖、二级管理奖、辅导津贴奖、终身推荐奖等月末计算,季度结算等) Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface FycTaskMapper extends BaseMapper<FycTask> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.Interests;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 权益表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface InterestsMapper extends BaseMapper<Interests> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.Invitation;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 邀请码表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface InvitationMapper extends BaseMapper<Invitation> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.MemberGradeConfig;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 会员等级配置表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface MemberGradeConfigMapper extends BaseMapper<MemberGradeConfig> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.Member;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 会员表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface MemberMapper extends BaseMapper<Member> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.PayoutBatch;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 保单发佣批次表 - 存储发佣批次信息,用于批量处理佣金计算和发放 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface PayoutBatchMapper extends BaseMapper<PayoutBatch> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.PolicyAgentRelation;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 保单业务员关联表 - 存储保单与业务员的关联关系及佣金分配信息 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface PolicyAgentRelationMapper extends BaseMapper<PolicyAgentRelation> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelAgentCustomer;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 业务员和客户关联表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RelAgentCustomerMapper extends BaseMapper<RelAgentCustomer> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelCustomerInterests;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 权益表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RelCustomerInterestsMapper extends BaseMapper<RelCustomerInterests> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelGradeService;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 会员等级和服务关系表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RelGradeServiceMapper extends BaseMapper<RelGradeService> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelMemberRole;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 客户端角色表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RelMemberRoleMapper extends BaseMapper<RelMemberRole> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelObjectCondition;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 对象和规则条件配置关系表 - 配置所有相关的涉及到条件和计算公式的业务表条件规则 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RelObjectConditionMapper extends BaseMapper<RelObjectCondition> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelObjectFormula;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 对象和公式配置关系表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface RelObjectFormulaMapper extends BaseMapper<RelObjectFormula> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelObjectSql;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 对象和SQL模板配置关系表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface RelObjectSqlMapper extends BaseMapper<RelObjectSql> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelServiceInterests;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 服务权益关系表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RelServiceInterestsMapper extends BaseMapper<RelServiceInterests> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RelTeamMember;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 团队和会员关系表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RelTeamMemberMapper extends BaseMapper<RelTeamMember> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.RuleConditionConfig;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 规则条件配置表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RuleConditionConfigMapper extends BaseMapper<RuleConditionConfig> {
}
package com.yd.csf.service.dao;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigPageRequest;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigPageResponse;
import com.yd.csf.service.model.RuleItemConfig;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* 基本法项目配置表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface RuleItemConfigMapper extends BaseMapper<RuleItemConfig> {
IPage<ApiRuleItemConfigPageResponse> page(@Param("page") Page<ApiRuleItemConfigPageResponse> page,
@Param("request") ApiRuleItemConfigPageRequest request);
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.ServiceConfig;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 服务配置表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface ServiceConfigMapper extends BaseMapper<ServiceConfig> {
}
package com.yd.csf.service.dao;
import com.yd.csf.service.model.Team;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* 团队表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface TeamMapper extends BaseMapper<Team> {
}
package com.yd.csf.service.dao;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.variable.ApiVariablePageRequest;
import com.yd.csf.feign.response.variable.ApiVariablePageResponse;
import com.yd.csf.service.model.Variable;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* 变量表 Mapper 接口
* </p>
*
* @author zxm
* @since 2025-10-16
*/
public interface VariableMapper extends BaseMapper<Variable> {
IPage<ApiVariablePageResponse> page(@Param("page") Page<ApiVariablePageResponse> page,
@Param("request") ApiVariablePageRequest request);
}
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CommissionRuleConfigDto {
/**
* 基本法配置表唯一业务ID
*/
private String ruleBizId;
/**
* 基本法名称
*/
private String ruleName;
/**
* 查询是否排除当前
*/
@Builder.Default
private Boolean isExcludeMy = false;
}
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CommissionSqlTemplateDto {
/**
* SQL模板表唯一业务ID列表
*/
private List<String> sqlTemplateBizIdList;
}
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ConditionTypeDto {
/**
* 条件类型表唯一业务ID列表
*/
private List<String> conditionTypeBizIdList;
}
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class FormulaConfigDto {
/**
* 公式配置表唯一业务ID
*/
private String formulaBizId;
/**
* 公式配置表唯一业务ID集合
*/
private List<String> formulaBizIdList;
}
package com.yd.csf.service.dto;
import lombok.Data;
@Data
public class RelObjectConditionDto {
/**
* 对象类型
*/
private String objectType;
/**
* 对象所属表名
*/
private String objectTableName;
/**
* 对象名
*/
private String objectName;
/**
* 对象业务ID
*/
private String objectBizId;
}
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RelObjectFormulaDto {
/**
* 对象类型
*/
private String objectType;
/**
* 对象所属表名
*/
private String objectTableName;
/**
* 对象名
*/
private String objectName;
/**
* 对象业务ID
*/
private String objectBizId;
/**
* 公式配置表唯一业务ID
*/
private String formulaBizId;
}
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RelObjectSqlDto {
/**
* 对象类型
*/
private String objectType;
/**
* 对象所属表名
*/
private String objectTableName;
/**
* 对象名
*/
private String objectName;
/**
* 对象业务ID
*/
private String objectBizId;
}
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RuleItemConfigDto {
/**
* 基本法项目配置表唯一业务ID
*/
private String ruleItemBizId;
/**
* 基本法项目名称
*/
private String itemName;
/**
* 查询是否排除当前
*/
@Builder.Default
private Boolean isExcludeMy = false;
}
package com.yd.csf.service.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class VariableDto {
/**
* 变量表唯一业务ID
*/
private String variableBizId;
/**
* 变量名称中文名
*/
private String nameCn;
/**
* 变量名称英文名
*/
private String nameEn;
/**
* 查询是否排除当前
*/
@Builder.Default
private Boolean isExcludeMy = false;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 业务员累计积分表 - 存储业务员的累计FYC积分和当前等级信息
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("agent_accumulated_fyc")
public class AgentAccumulatedFyc implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 业务员ID(会员唯一业务ID)
*/
@TableField("agent_id")
private String agentId;
/**
* 累计FYC,业务员历史累计的FYC总额
*/
@TableField("total_fyc")
private BigDecimal totalFyc;
/**
* 当前等级,业务员当前的会员等级编码(会员等级配置表等级编码)
*/
@TableField("current_grade_code")
private String currentGradeCode;
/**
* 最后计算日期,记录最后一次计算累计FYC的日期
*/
@TableField("last_calc_date")
private LocalDateTime lastCalcDate;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 业务员积分明细表 - 存储业务员的每次增加或者减少的FYC积分
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("agent_detail_fyc")
public class AgentDetailFyc implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 业务员ID(会员唯一业务ID)
*/
@TableField("agent_id")
private String agentId;
/**
* 积分来源类型:保单转介费、一级管理奖、二级管理奖、辅导津贴奖、终身推荐奖
*/
@TableField("source_type")
private String sourceType;
/**
* 积分提供保单表唯一业务ID
*/
@TableField("policy_biz_id")
private String policyBizId;
/**
* 积分提供者(会员唯一业务ID)
*/
@TableField("provide_id")
private String provideId;
/**
* 变化前的业务员总FYC积分
*/
@TableField("before_fyc")
private BigDecimal beforeFyc;
/**
* 变化后的业务员总FYC积分
*/
@TableField("after_fyc")
private BigDecimal afterFyc;
/**
* 变化值(-代表减少)
*/
@TableField("change_fyc")
private String changeFyc;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 推荐关系表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("agent_referral_relation")
public class AgentReferralRelation implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 推荐关系表唯一业务ID
*/
@TableField("referral_biz_id")
private String referralBizId;
/**
* 被推荐人ID(会员唯一业务ID)
*/
@TableField("agent_id")
private String agentId;
/**
* 推荐人ID(会员唯一业务ID)
*/
@TableField("referrer_id")
private String referrerId;
/**
* 推荐路径(用于快速查询关系链)
*/
@TableField("referral_path")
private String referralPath;
/**
* 是否有效(0:否 1:是)
*/
@TableField("is_active")
private Integer isActive;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 辅导关系表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("agent_tutoring_relation")
public class AgentTutoringRelation implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 辅导关系表唯一业务ID
*/
@TableField("tutoring_biz_id")
private String tutoringBizId;
/**
* 被辅导人ID(会员唯一业务ID)
*/
@TableField("agent_id")
private String agentId;
/**
* 辅导员ID(会员唯一业务ID)
*/
@TableField("tutor_id")
private String tutorId;
/**
* 生效日期
*/
@TableField("effective_date")
private LocalDateTime effectiveDate;
/**
* 结束日期
*/
@TableField("end_date")
private LocalDateTime endDate;
/**
* 是否有效(0:否 1:是)
*/
@TableField("is_active")
private Integer isActive;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 保单批次保单关联表 - 存储批次与保单的关联关系,记录批次中每个保单的计算状态
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("batch_policy")
public class BatchPolicy implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 发佣批次表唯一业务ID
*/
@TableField("batch_biz_id")
private String batchBizId;
/**
* 保单表唯一业务ID
*/
@TableField("policy_biz_id")
private String policyBizId;
/**
* 保单FYC,记录该保单在批次中的FYC金额
*/
@TableField("policy_fyc")
private BigDecimal policyFyc;
/**
* 计算状态:PENDING-待计算, PROCESSING-计算中, CALCULATED-已计算, ERROR-计算错误
*/
@TableField("calc_status")
private String calcStatus;
/**
* 错误信息,当计算状态为ERROR时记录错误详情
*/
@TableField("error_message")
private String errorMessage;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 车辆预约申请表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("car_apply")
public class CarApply implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 车辆预约申请表唯一业务ID
*/
@TableField("apply_biz_id")
private String applyBizId;
/**
* 预约信息主表唯一业务ID
*/
@TableField("appointment_biz_id")
private String appointmentBizId;
/**
* 会员唯一业务ID(业务员)
*/
@TableField("member_biz_id")
private String memberBizId;
/**
* 司机姓名
*/
@TableField("driver_name")
private String driverName;
/**
* 司机电话
*/
@TableField("driver_telephone")
private String driverTelephone;
/**
* 车辆类型(字典:专车、顺风车)
*/
@TableField("vehicle_type")
private String vehicleType;
/**
* 车牌号
*/
@TableField("car_no")
private String carNo;
/**
* 客户表唯一业务ID
*/
@TableField("customer_biz_id")
private String customerBizId;
/**
* 客户类型(签单客户、非签单客户)
*/
@TableField("customer_type")
private String customerType;
/**
* 客户姓名
*/
@TableField("customer_name")
private String customerName;
/**
* 申请人
*/
@TableField("applicant")
private String applicant;
/**
* 接送日期
*/
@TableField("send_date")
private LocalDateTime sendDate;
/**
* 接送时间
*/
@TableField("send_time")
private LocalDateTime sendTime;
/**
* 申请状态(待审批,初审通过、初审驳回、复核通过、复核驳回、预约确认、终审驳回、已过期、已取消、已完成)
*/
@TableField("status")
private String status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 客户端角色表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("client_role")
public class ClientRole implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 客户端角色表唯一业务ID
*/
@TableField("role_biz_id")
private String roleBizId;
/**
* 角色编码
*/
@TableField("code")
private String code;
/**
* 角色名称
*/
@TableField("name")
private String name;
/**
* 角色描述
*/
@TableField("description")
private String description;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 保单佣金计算结果表(出账表) - 存储佣金计算的详细结果,用于查询、对账和发放
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("commission_result")
public class CommissionResult implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 发佣批次表唯一业务ID
*/
@TableField("batch_biz_id")
private String batchBizId;
/**
* 保单表唯一业务ID
*/
@TableField("policy_biz_id")
private String policyBizId;
/**
* 业务员ID(会员唯一业务ID)
*/
@TableField("agent_id")
private String agentId;
/**
* 佣金金额(出账金额)
*/
@TableField("commission_amount")
private BigDecimal commissionAmount;
/**
* 出账时间,记录该条佣金结果的出账时间
*/
@TableField("billing_date")
private LocalDateTime billingDate;
/**
* 出账状态:待出账、出账中、已出账、出账失败
*/
@TableField("status")
private String status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 基本法绑定表 - 存储基本法与业务员或团队的绑定关系,支持灵活的权限分配
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("commission_rule_binding")
public class CommissionRuleBinding implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 基本法配置表唯一业务ID
*/
@TableField("rule_biz_id")
private String ruleBizId;
/**
* 基本法项目配置表唯一业务ID
*/
@TableField("rule_item_biz_id")
private String ruleItemBizId;
/**
* 绑定目标类型:AGENT-业务员, TEAM-团队
*/
@TableField("target_type")
private String targetType;
/**
* 目标ID,业务员ID或团队ID
*/
@TableField("target_id")
private String targetId;
/**
* 生效开始时间,绑定关系开始生效的时间
*/
@TableField("effective_start")
private LocalDateTime effectiveStart;
/**
* 生效结束时间,绑定关系失效的时间
*/
@TableField("effective_end")
private LocalDateTime effectiveEnd;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 基本法配置表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("commission_rule_config")
public class CommissionRuleConfig implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 基本法配置表唯一业务ID
*/
@TableField("rule_biz_id")
private String ruleBizId;
/**
* 基本法编码
*/
@TableField("rule_code")
private String ruleCode;
/**
* 基本法名称
*/
@TableField("rule_name")
private String ruleName;
/**
* 基本法描述
*/
@TableField("description")
private String description;
/**
* 生效开始日期
*/
@TableField("effective_start")
private LocalDateTime effectiveStart;
/**
* 生效结束日期
*/
@TableField("effective_end")
private LocalDateTime effectiveEnd;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 版本号
*/
@TableField("rule_version")
private Integer ruleVersion;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* SQL模板表 - 存储所有佣金计算相关的动态SQL模板,支持灵活配置和参数化查询,实现业务逻辑与代码解耦
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("commission_sql_template")
public class CommissionSqlTemplate implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* SQL模板表唯一业务ID
*/
@TableField("sql_template_biz_id")
private String sqlTemplateBizId;
/**
* 模板编码
*/
@TableField("sql_template_code")
private String sqlTemplateCode;
/**
* 模板名称
*/
@TableField("sql_template_name")
private String sqlTemplateName;
/**
* 模板类型
*/
@TableField("sql_template_type")
private String sqlTemplateType;
/**
* 模板详细描述
*/
@TableField("description")
private String description;
/**
* SQL模板内容,支持参数化查询,使用 :参数名 作为占位符,如:SELECT SUM(fyc) FROM policy WHERE agent_id = :agentId AND period = :period
*/
@TableField("sql_template")
private String sqlTemplate;
/**
* 参数定义,JSON格式,定义SQL模板所需的参数列表,如:[{"name": "agentId", "type": "STRING", "required": true, "description": "业务员ID"}, {"name": "period", "type": "STRING", "required": true, "description": "计算周期"}]
*/
@TableField("parameters")
private String parameters;
/**
* 所属租户唯一业务ID
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 显示顺序
*/
@TableField("display_order")
private Integer displayOrder;
/**
* 状态:0-停用,1-启用。
*/
@TableField("status")
private Integer status;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 条件配置表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("condition_config")
public class ConditionConfig implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 条件配置表唯一业务ID
*/
@TableField("condition_biz_id")
private String conditionBizId;
/**
* 条件类型表唯一业务ID
*/
@TableField("condition_type_biz_id")
private String conditionTypeBizId;
/**
* 条件编码
*/
@TableField("code")
private String code;
/**
* 条件名称
*/
@TableField("name")
private String name;
/**
* 条件描述
*/
@TableField("description")
private String description;
/**
* 最小值(在范围条件中表示最小值)
*/
@TableField("min_value")
private BigDecimal minValue;
/**
* 最大值(在范围条件中表示最大值)
*/
@TableField("max_value")
private BigDecimal maxValue;
/**
* 是否包含最小值(是否包含最小值,1表示包含,0表示不包含)
*/
@TableField("include_min")
private Boolean includeMin;
/**
* 是否包含最大值(是否包含最大值,1表示包含,0表示不包含)
*/
@TableField("include_max")
private Boolean includeMax;
/**
* 条件值(范围内的值)
*/
@TableField("conditional_value")
private String conditionalValue;
/**
* 优先级(数字越小优先级越高)
*/
@TableField("priority")
private Integer priority;
/**
* 显示顺序
*/
@TableField("display_order")
private Integer displayOrder;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Byte status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 条件类型表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("condition_type")
public class ConditionType implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 条件类型表唯一业务ID
*/
@TableField("condition_type_biz_id")
private String conditionTypeBizId;
/**
* 条件类型编码(一个条件类型编码可能包含多个条件)
*/
@TableField("code")
private String code;
/**
* 条件类型名称
*/
@TableField("name")
private String name;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Byte status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 公式配置表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("formula_config")
public class FormulaConfig implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 公式配置表唯一业务ID
*/
@TableField("formula_biz_id")
private String formulaBizId;
/**
* 公式编码
*/
@TableField("code")
private String code;
/**
* 公式名称
*/
@TableField("name")
private String name;
/**
* 计算公式(变量中文名称组合,用于展示)
*/
@TableField("calculation_formula_cn")
private String calculationFormulaCn;
/**
* 计算公式(变量表唯一业务ID组合)
*/
@TableField("calculation_formula_biz_id")
private String calculationFormulaBizId;
/**
* 描述
*/
@TableField("description")
private String description;
/**
* 显示顺序
*/
@TableField("display_order")
private Integer displayOrder;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 业务员积分任务表 - 定时跑批业务员绑定的基本法计算点,算出当前业务员所得的积分(一级管理奖、二级管理奖、辅导津贴奖、终身推荐奖等月末计算,季度结算等)
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("fyc_task")
public class FycTask implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 业务员积分任务表唯一业务ID
*/
@TableField("fyc_task_biz_id")
private String fycTaskBizId;
/**
* 业务员ID(会员唯一业务ID)
*/
@TableField("agent_id")
private String agentId;
/**
* 基本法项目配置表唯一业务ID
*/
@TableField("rule_item_biz_id")
private String ruleItemBizId;
/**
* 任务定时时间
*/
@TableField("schedule_time")
private LocalDateTime scheduleTime;
/**
* 任务状态(待执行、已执行、执行失败)
*/
@TableField("status")
private String status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 权益表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("interests")
public class Interests implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 权益表唯一业务ID
*/
@TableField("interests_biz_id")
private String interestsBizId;
/**
* 权益名称
*/
@TableField("name")
private String name;
/**
* 权益内容
*/
@TableField("content")
private String content;
/**
* 权益描述
*/
@TableField("description")
private String description;
/**
* 权益价格
*/
@TableField("price")
private BigDecimal price;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 邀请码表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("invitation")
public class Invitation implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 邀请码表唯一业务ID
*/
@TableField("invitation_biz_id")
private String invitationBizId;
/**
* 邀请类型(字典:OPEN_ACCOUNT-开通账号,RECOMMEND-推荐,辅导-TUTORING)
*/
@TableField("invitation_type")
private String invitationType;
/**
* 邀请人(会员唯一业务ID)
*/
@TableField("inviter")
private String inviter;
/**
* 被邀请人(会员唯一业务ID)
*/
@TableField("invitee")
private String invitee;
/**
* 邀请码
*/
@TableField("invitation_code")
private String invitationCode;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 会员表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("member")
public class Member implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 会员唯一业务ID
*/
@TableField("member_biz_id")
private String memberBizId;
/**
* 姓名
*/
@TableField("name")
private String name;
/**
* 手机号
*/
@TableField("phone")
private String phone;
/**
* 邮箱
*/
@TableField("email")
private String email;
/**
* 证件类型
*/
@TableField("id_card_type")
private String idCardType;
/**
* 证件号码
*/
@TableField("id_card_number")
private String idCardNumber;
/**
* 登录密码
*/
@TableField("password")
private String password;
/**
* 邀请码
*/
@TableField("invitation_code")
private String invitationCode;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 会员等级配置表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("member_grade_config")
public class MemberGradeConfig implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 会员等级配置表唯一业务ID
*/
@TableField("grade_biz_id")
private String gradeBizId;
/**
* 等级编码
*/
@TableField("grade_code")
private String gradeCode;
/**
* 等级名称
*/
@TableField("grade_name")
private String gradeName;
/**
* 拥有等级有无条件限制(0-无 1-有。例:如果1-有,在对象和规则条件配置关系表配置)
*/
@TableField("is_condition")
private Integer isCondition;
/**
* 积分比例。例:91%、100%
*/
@TableField("integral_ratio")
private BigDecimal integralRatio;
/**
* 等级描述
*/
@TableField("description")
private String description;
/**
* 显示顺序
*/
@TableField("display_order")
private Integer displayOrder;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 保单发佣批次表 - 存储发佣批次信息,用于批量处理佣金计算和发放
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("payout_batch")
public class PayoutBatch implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 发佣批次表唯一业务ID
*/
@TableField("batch_biz_id")
private String batchBizId;
/**
* 批次号
*/
@TableField("batch_no")
private String batchNo;
/**
* 批次名称
*/
@TableField("batch_name")
private String batchName;
/**
* 发佣日期
*/
@TableField("payout_date")
private LocalDateTime payoutDate;
/**
* 总保费,该批次所有保单的总保费
*/
@TableField("total_premium")
private BigDecimal totalPremium;
/**
* 总佣金,该批次计算出的总佣金金额
*/
@TableField("total_commission")
private BigDecimal totalCommission;
/**
* 保单数量,该批次包含的保单总数
*/
@TableField("policy_count")
private Integer policyCount;
/**
* 批次状态:DRAFT-草稿, CALCULATING-计算中, CALCULATED-已计算, CONFIRMED-已确认, PAID-已发放
*/
@TableField("batch_status")
private String batchStatus;
/**
* 计算开始时间,记录批次佣金计算开始的时间
*/
@TableField("calc_start_time")
private LocalDateTime calcStartTime;
/**
* 计算结束时间,记录批次佣金计算结束的时间
*/
@TableField("calc_end_time")
private LocalDateTime calcEndTime;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 保单业务员关联表 - 存储保单与业务员的关联关系及佣金分配信息
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("policy_agent_relation")
public class PolicyAgentRelation implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 保单表唯一业务ID
*/
@TableField("policy_biz_id")
private String policyBizId;
/**
* 业务员ID(会员唯一业务ID)
*/
@TableField("agent_id")
private String agentId;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 业务员和客户关联表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("rel_agent_customer")
public class RelAgentCustomer implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 客户表唯一业务ID
*/
@TableField("customer_biz_id")
private String customerBizId;
/**
* 业务员ID(会员唯一业务ID)
*/
@TableField("agent_id")
private String agentId;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 权益表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("rel_customer_interests")
public class RelCustomerInterests implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 客户表唯一业务ID
*/
@TableField("customer_biz_id")
private String customerBizId;
/**
* 权益表唯一业务ID
*/
@TableField("interests_biz_id")
private String interestsBizId;
/**
* 是否使用: 0-否, 1-是
*/
@TableField("is_use")
private Integer isUse;
/**
* 是否过期: 0-否, 1-是
*/
@TableField("is_expired")
private Integer isExpired;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 会员等级和服务关系表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("rel_grade_service")
public class RelGradeService implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 会员等级和服务关系表唯一业务ID
*/
@TableField("rel_grade_service_biz_id")
private String relGradeServiceBizId;
/**
* 会员等级配置表唯一业务ID
*/
@TableField("grade_biz_id")
private String gradeBizId;
/**
* 等级编码
*/
@TableField("grade_code")
private String gradeCode;
/**
* 拥有服务有无条件限制(0-无 1-有。例:如果1-有,在对象和规则条件配置关系表配置)
*/
@TableField("is_condition")
private Integer isCondition;
/**
* 服务配置表唯一业务ID
*/
@TableField("service_config_biz_id")
private String serviceConfigBizId;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 客户端角色表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("rel_member_role")
public class RelMemberRole implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 会员唯一业务ID
*/
@TableField("member_biz_id")
private String memberBizId;
/**
* 客户端角色表唯一业务ID
*/
@TableField("role_biz_id")
private String roleBizId;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 对象和条件配置关系表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("rel_object_condition")
public class RelObjectCondition implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 对象类型
*/
@TableField("object_type")
private String objectType;
/**
* 对象所属表名
*/
@TableField("object_table_name")
private String objectTableName;
/**
* 对象名
*/
@TableField("object_name")
private String objectName;
/**
* 对象业务ID
*/
@TableField("object_biz_id")
private String objectBizId;
/**
* 条件类型表唯一业务ID
*/
@TableField("condition_type_biz_id")
private String conditionTypeBizId;
/**
* 条件配置表唯一业务ID
*/
@TableField("condition_biz_id")
private String conditionBizId;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 对象和公式配置关系表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("rel_object_formula")
public class RelObjectFormula implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 对象类型
*/
@TableField("object_type")
private String objectType;
/**
* 对象所属表名
*/
@TableField("object_table_name")
private String objectTableName;
/**
* 对象名
*/
@TableField("object_name")
private String objectName;
/**
* 对象业务ID
*/
@TableField("object_biz_id")
private String objectBizId;
/**
* 公式配置表唯一业务ID
*/
@TableField("formula_biz_id")
private String formulaBizId;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 对象和SQL模板配置关系表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("rel_object_sql")
public class RelObjectSql implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 对象类型
*/
@TableField("object_type")
private String objectType;
/**
* 对象所属表名
*/
@TableField("object_table_name")
private String objectTableName;
/**
* 对象名
*/
@TableField("object_name")
private String objectName;
/**
* 对象业务ID
*/
@TableField("object_biz_id")
private String objectBizId;
/**
* SQL模板表唯一业务ID
*/
@TableField("sql_template_biz_id")
private String sqlTemplateBizId;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 服务权益关系表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("rel_service_interests")
public class RelServiceInterests implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 服务权益关系表唯一业务ID
*/
@TableField("rel_service_interests_biz_id")
private String relServiceInterestsBizId;
/**
* 服务配置表唯一业务ID
*/
@TableField("service_config_biz_id")
private String serviceConfigBizId;
/**
* 拥有权益有无条件限制(0-无 1-有。例:如果1-有,在对象和规则条件配置关系表配置)
*/
@TableField("is_condition")
private String isCondition;
/**
* 权益表唯一业务ID
*/
@TableField("interests_biz_id")
private String interestsBizId;
/**
* 赠送权益次数
*/
@TableField("num")
private String num;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 团队和会员关系表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("rel_team_member")
public class RelTeamMember implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 团队表唯一业务ID
*/
@TableField("team_biz_id")
private String teamBizId;
/**
* 会员唯一业务ID
*/
@TableField("member_biz_id")
private String memberBizId;
/**
* 是否有效(0:否 1:是)
*/
@TableField("is_active")
private Integer isActive;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 规则条件配置表
* </p>
*
* @author zxm
* @since 2025-10-16
*/
@Getter
@Setter
@TableName("rule_condition_config")
public class RuleConditionConfig implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 条件配置唯一业务ID
*/
@TableField("condition_biz_id")
private String conditionBizId;
/**
* 类型(1-条件 2-计算公式)
*/
@TableField("type")
private String type;
/**
* 一级分类编码
*/
@TableField("first_category_code")
private String firstCategoryCode;
/**
* 一级分类名称
*/
@TableField("first_category_name")
private String firstCategoryName;
/**
* 二级分类编码
*/
@TableField("second_category_code")
private String secondCategoryCode;
/**
* 二级分类名称
*/
@TableField("second_category_name")
private String secondCategoryName;
/**
* 计算公式
*/
@TableField("calculation_formula")
private String calculationFormula;
/**
* 条件值(范围内的值)
*/
@TableField("conditional_value")
private String conditionalValue;
/**
* 条件-最小值(在范围条件中表示最小值)
*/
@TableField("min_value")
private BigDecimal minValue;
/**
* 条件-最大值(在范围条件中表示最大值)
*/
@TableField("max_value")
private BigDecimal maxValue;
/**
* 条件-是否包含最小值(是否包含最小值,1表示包含,0表示不包含)
*/
@TableField("include_min")
private Integer includeMin;
/**
* 条件-是否包含最大值(是否包含最大值,1表示包含,0表示不包含)
*/
@TableField("include_max")
private Integer includeMax;
/**
* 优先级(数字越小优先级越高)
*/
@TableField("priority")
private Integer priority;
/**
* 描述
*/
@TableField("description")
private String description;
/**
* 显示顺序
*/
@TableField("display_order")
private Integer displayOrder;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 基本法项目配置表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("rule_item_config")
public class RuleItemConfig implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 基本法项目配置表唯一业务ID
*/
@TableField("rule_item_biz_id")
private String ruleItemBizId;
/**
* 基本法配置表唯一业务ID
*/
@TableField("rule_biz_id")
private String ruleBizId;
/**
* 基本法项目编码
*/
@TableField("item_code")
private String itemCode;
/**
* 基本法项目名称
*/
@TableField("item_name")
private String itemName;
/**
* 计算时间点(字典)
*/
@TableField("calculate")
private String calculate;
/**
* 执行顺序,数值越小越先执行,用于控制佣金项目的计算顺序
*/
@TableField("execution_order")
private Integer executionOrder;
/**
* 项目描述
*/
@TableField("description")
private String description;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 服务配置表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("service_config")
public class ServiceConfig implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 服务配置表唯一业务ID
*/
@TableField("service_config_biz_id")
private String serviceConfigBizId;
/**
* 服务类型(字典:基础服务、签单用车服务、VIP 增值服务)
*/
@TableField("service_type")
private String serviceType;
/**
* 服务内容(字典:产品咨询、续期、保全、理赔等服务。)
*/
@TableField("service_content")
private String serviceContent;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 团队表
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Getter
@Setter
@TableName("team")
public class Team implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 团队表唯一业务ID
*/
@TableField("team_biz_id")
private String teamBizId;
/**
* 团队编码
*/
@TableField("team_code")
private String teamCode;
/**
* 团队名称
*/
@TableField("team_name")
private String teamName;
/**
* 团队长ID(会员唯一业务ID)
*/
@TableField("team_leader_id")
private Long teamLeaderId;
/**
* 团队层级
*/
@TableField("team_level")
private Integer teamLevel;
/**
* 团队成员数
*/
@TableField("member_count")
private Integer memberCount;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 所属部门唯一业务ID(冗余)
*/
@TableField("dept_biz_id")
private String deptBizId;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Integer isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.Getter;
import lombok.Setter;
/**
* <p>
* 变量表
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Getter
@Setter
@TableName("variable")
public class Variable implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 变量表唯一业务ID
*/
@TableField("variable_biz_id")
private String variableBizId;
/**
* 变量编码
*/
@TableField("variable_code")
private String variableCode;
/**
* 变量名称中文名
*/
@TableField("name_cn")
private String nameCn;
/**
* 变量名称英文名
*/
@TableField("name_en")
private String nameEn;
/**
* 变量类型(字典: 固定值、动态计算,如果固定值这个变量取值就是value变量值这个字段,如果是动态计算需要关联条件(对象和条件配置关系表)和SQL计算(对象和SQL模板配置关系表)对应的变量值)
*/
@TableField("type")
private String type;
/**
* 变量值
*/
@TableField("value")
private String value;
/**
* 所属租户唯一业务ID(冗余)
*/
@TableField("tenant_biz_id")
private String tenantBizId;
/**
* 所属项目唯一业务ID(冗余)
*/
@TableField("project_biz_id")
private String projectBizId;
/**
* 状态(0:停用 1:启用)
*/
@TableField("status")
private Integer status;
/**
* 通用备注
*/
@TableField("remark")
private String remark;
/**
* 删除标识: 0-正常, 1-删除
*/
@TableField("is_deleted")
private Boolean isDeleted;
/**
* 创建人ID
*/
@TableField("creator_id")
private String creatorId;
/**
* 更新人ID
*/
@TableField("updater_id")
private String updaterId;
/**
* 创建时间
*/
@TableField("create_time")
private LocalDateTime createTime;
/**
* 更新时间
*/
@TableField("update_time")
private LocalDateTime updateTime;
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.AgentAccumulatedFyc;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 业务员累计积分表 - 存储业务员的累计FYC积分和当前等级信息 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IAgentAccumulatedFycService extends IService<AgentAccumulatedFyc> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.AgentDetailFyc;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 业务员积分明细表 - 存储业务员的每次增加或者减少的FYC积分 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IAgentDetailFycService extends IService<AgentDetailFyc> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.AgentReferralRelation;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 推荐关系表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IAgentReferralRelationService extends IService<AgentReferralRelation> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.AgentTutoringRelation;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 辅导关系表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IAgentTutoringRelationService extends IService<AgentTutoringRelation> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.BatchPolicy;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 保单批次保单关联表 - 存储批次与保单的关联关系,记录批次中每个保单的计算状态 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IBatchPolicyService extends IService<BatchPolicy> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.CarApply;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 车辆预约申请表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface ICarApplyService extends IService<CarApply> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.ClientRole;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 客户端角色表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IClientRoleService extends IService<ClientRole> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.CommissionResult;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 保单佣金计算结果表(出账表) - 存储佣金计算的详细结果,用于查询、对账和发放 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface ICommissionResultService extends IService<CommissionResult> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.CommissionRuleBinding;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 基本法绑定表 - 存储基本法与业务员或团队的绑定关系,支持灵活的权限分配 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface ICommissionRuleBindingService extends IService<CommissionRuleBinding> {
}
package com.yd.csf.service.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigPageRequest;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigPageResponse;
import com.yd.csf.service.dto.CommissionRuleConfigDto;
import com.yd.csf.service.model.CommissionRuleConfig;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 基本法配置表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface ICommissionRuleConfigService extends IService<CommissionRuleConfig> {
IPage<ApiCommissionRuleConfigPageResponse> page(Page<ApiCommissionRuleConfigPageResponse> page,
ApiCommissionRuleConfigPageRequest request);
List<CommissionRuleConfig> queryList(CommissionRuleConfigDto dto);
CommissionRuleConfig queryOne(String ruleBizId);
}
package com.yd.csf.service.service;
import com.yd.csf.service.dto.CommissionSqlTemplateDto;
import com.yd.csf.service.model.CommissionSqlTemplate;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* SQL模板表 - 存储所有佣金计算相关的动态SQL模板,支持灵活配置和参数化查询,实现业务逻辑与代码解耦 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface ICommissionSqlTemplateService extends IService<CommissionSqlTemplate> {
List<CommissionSqlTemplate> queryList(CommissionSqlTemplateDto dto);
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.ConditionConfig;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 条件配置表 服务类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface IConditionConfigService extends IService<ConditionConfig> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.dto.ConditionTypeDto;
import com.yd.csf.service.model.ConditionType;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 条件类型表 服务类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface IConditionTypeService extends IService<ConditionType> {
List<ConditionType> queryList(ConditionTypeDto dto);
}
package com.yd.csf.service.service;
import com.yd.csf.service.dto.FormulaConfigDto;
import com.yd.csf.service.model.FormulaConfig;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 公式配置表 服务类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface IFormulaConfigService extends IService<FormulaConfig> {
List<FormulaConfig> queryList(FormulaConfigDto dto);
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.FycTask;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 业务员积分任务表 - 定时跑批业务员绑定的基本法计算点,算出当前业务员所得的积分(一级管理奖、二级管理奖、辅导津贴奖、终身推荐奖等月末计算,季度结算等) 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IFycTaskService extends IService<FycTask> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.Interests;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 权益表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IInterestsService extends IService<Interests> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.Invitation;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 邀请码表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IInvitationService extends IService<Invitation> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.MemberGradeConfig;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 会员等级配置表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IMemberGradeConfigService extends IService<MemberGradeConfig> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.Member;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 会员表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IMemberService extends IService<Member> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.PayoutBatch;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 保单发佣批次表 - 存储发佣批次信息,用于批量处理佣金计算和发放 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IPayoutBatchService extends IService<PayoutBatch> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.PolicyAgentRelation;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 保单业务员关联表 - 存储保单与业务员的关联关系及佣金分配信息 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IPolicyAgentRelationService extends IService<PolicyAgentRelation> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.RelAgentCustomer;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 业务员和客户关联表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRelAgentCustomerService extends IService<RelAgentCustomer> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.RelCustomerInterests;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 权益表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRelCustomerInterestsService extends IService<RelCustomerInterests> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.RelGradeService;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 会员等级和服务关系表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRelGradeServiceService extends IService<RelGradeService> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.RelMemberRole;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 客户端角色表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRelMemberRoleService extends IService<RelMemberRole> {
}
package com.yd.csf.service.service;
import com.yd.csf.feign.dto.conditionconfig.ApiRelObjectConditionDto;
import com.yd.csf.service.dto.RelObjectConditionDto;
import com.yd.csf.service.model.RelObjectCondition;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 对象和条件关系表 - 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRelObjectConditionService extends IService<RelObjectCondition> {
Boolean del(ApiRelObjectConditionDto dto);
List<RelObjectCondition> queryList(RelObjectConditionDto dto);
}
package com.yd.csf.service.service;
import com.yd.csf.service.dto.RelObjectFormulaDto;
import com.yd.csf.service.model.RelObjectFormula;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 对象和公式配置关系表 服务类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface IRelObjectFormulaService extends IService<RelObjectFormula> {
List<RelObjectFormula> queryList(RelObjectFormulaDto dto);
Boolean del(RelObjectFormulaDto dto);
}
package com.yd.csf.service.service;
import com.yd.csf.service.dto.RelObjectSqlDto;
import com.yd.csf.service.model.RelObjectSql;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 对象和SQL模板配置关系表 服务类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
public interface IRelObjectSqlService extends IService<RelObjectSql> {
List<RelObjectSql> queryList(RelObjectSqlDto dto);
Boolean del(RelObjectSqlDto dto);
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.RelServiceInterests;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 服务权益关系表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRelServiceInterestsService extends IService<RelServiceInterests> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.RelTeamMember;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 团队和会员关系表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRelTeamMemberService extends IService<RelTeamMember> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.RuleConditionConfig;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 规则条件配置表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRuleConditionConfigService extends IService<RuleConditionConfig> {
RuleConditionConfig queryOne(String conditionBizId);
}
package com.yd.csf.service.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigPageRequest;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigPageResponse;
import com.yd.csf.service.dto.RuleItemConfigDto;
import com.yd.csf.service.model.RuleItemConfig;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 基本法项目配置表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IRuleItemConfigService extends IService<RuleItemConfig> {
IPage<ApiRuleItemConfigPageResponse> page(Page<ApiRuleItemConfigPageResponse> page,
ApiRuleItemConfigPageRequest request);
RuleItemConfig queryOne(String ruleItemBizId);
List<RuleItemConfig> queryList(RuleItemConfigDto dto);
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.ServiceConfig;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 服务配置表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface IServiceConfigService extends IService<ServiceConfig> {
}
package com.yd.csf.service.service;
import com.yd.csf.service.model.Team;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 团队表 服务类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
public interface ITeamService extends IService<Team> {
}
package com.yd.csf.service.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.variable.ApiVariablePageRequest;
import com.yd.csf.feign.response.variable.ApiVariablePageResponse;
import com.yd.csf.service.dto.VariableDto;
import com.yd.csf.service.model.Variable;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 变量表 服务类
* </p>
*
* @author zxm
* @since 2025-10-16
*/
public interface IVariableService extends IService<Variable> {
IPage<ApiVariablePageResponse> page(Page<ApiVariablePageResponse> page,
ApiVariablePageRequest request);
Variable queryOne(String variableBizId);
List<Variable> queryList(VariableDto dto);
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.AgentAccumulatedFyc;
import com.yd.csf.service.dao.AgentAccumulatedFycMapper;
import com.yd.csf.service.service.IAgentAccumulatedFycService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 业务员累计积分表 - 存储业务员的累计FYC积分和当前等级信息 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class AgentAccumulatedFycServiceImpl extends ServiceImpl<AgentAccumulatedFycMapper, AgentAccumulatedFyc> implements IAgentAccumulatedFycService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.AgentDetailFyc;
import com.yd.csf.service.dao.AgentDetailFycMapper;
import com.yd.csf.service.service.IAgentDetailFycService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 业务员积分明细表 - 存储业务员的每次增加或者减少的FYC积分 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class AgentDetailFycServiceImpl extends ServiceImpl<AgentDetailFycMapper, AgentDetailFyc> implements IAgentDetailFycService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.AgentReferralRelation;
import com.yd.csf.service.dao.AgentReferralRelationMapper;
import com.yd.csf.service.service.IAgentReferralRelationService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 推荐关系表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class AgentReferralRelationServiceImpl extends ServiceImpl<AgentReferralRelationMapper, AgentReferralRelation> implements IAgentReferralRelationService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.AgentTutoringRelation;
import com.yd.csf.service.dao.AgentTutoringRelationMapper;
import com.yd.csf.service.service.IAgentTutoringRelationService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 辅导关系表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class AgentTutoringRelationServiceImpl extends ServiceImpl<AgentTutoringRelationMapper, AgentTutoringRelation> implements IAgentTutoringRelationService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.BatchPolicy;
import com.yd.csf.service.dao.BatchPolicyMapper;
import com.yd.csf.service.service.IBatchPolicyService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 保单批次保单关联表 - 存储批次与保单的关联关系,记录批次中每个保单的计算状态 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class BatchPolicyServiceImpl extends ServiceImpl<BatchPolicyMapper, BatchPolicy> implements IBatchPolicyService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.CarApply;
import com.yd.csf.service.dao.CarApplyMapper;
import com.yd.csf.service.service.ICarApplyService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 车辆预约申请表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class CarApplyServiceImpl extends ServiceImpl<CarApplyMapper, CarApply> implements ICarApplyService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.ClientRole;
import com.yd.csf.service.dao.ClientRoleMapper;
import com.yd.csf.service.service.IClientRoleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 客户端角色表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class ClientRoleServiceImpl extends ServiceImpl<ClientRoleMapper, ClientRole> implements IClientRoleService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.CommissionResult;
import com.yd.csf.service.dao.CommissionResultMapper;
import com.yd.csf.service.service.ICommissionResultService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 保单佣金计算结果表(出账表) - 存储佣金计算的详细结果,用于查询、对账和发放 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class CommissionResultServiceImpl extends ServiceImpl<CommissionResultMapper, CommissionResult> implements ICommissionResultService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.CommissionRuleBinding;
import com.yd.csf.service.dao.CommissionRuleBindingMapper;
import com.yd.csf.service.service.ICommissionRuleBindingService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 基本法绑定表 - 存储基本法与业务员或团队的绑定关系,支持灵活的权限分配 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class CommissionRuleBindingServiceImpl extends ServiceImpl<CommissionRuleBindingMapper, CommissionRuleBinding> implements ICommissionRuleBindingService {
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.commissionruleconfig.ApiCommissionRuleConfigPageRequest;
import com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigPageResponse;
import com.yd.csf.service.dto.CommissionRuleConfigDto;
import com.yd.csf.service.model.CommissionRuleConfig;
import com.yd.csf.service.dao.CommissionRuleConfigMapper;
import com.yd.csf.service.service.ICommissionRuleConfigService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Objects;
/**
* <p>
* 基本法配置表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class CommissionRuleConfigServiceImpl extends ServiceImpl<CommissionRuleConfigMapper, CommissionRuleConfig> implements ICommissionRuleConfigService {
@Override
public IPage<ApiCommissionRuleConfigPageResponse> page(Page<ApiCommissionRuleConfigPageResponse> page,
ApiCommissionRuleConfigPageRequest request) {
return baseMapper.page(page,request);
}
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<CommissionRuleConfig> queryList(CommissionRuleConfigDto dto) {
List<CommissionRuleConfig> list = baseMapper.selectList(new LambdaQueryWrapper<CommissionRuleConfig>()
.eq(StringUtils.isNotBlank(dto.getRuleBizId()) && !dto.getIsExcludeMy(),CommissionRuleConfig::getRuleBizId,dto.getRuleBizId())
.eq(StringUtils.isNotBlank(dto.getRuleName()),CommissionRuleConfig::getRuleName,dto.getRuleName())
.ne(dto.getIsExcludeMy(),CommissionRuleConfig::getRuleBizId,dto.getRuleBizId())
);
return list;
}
/**
* 查询单个对象
* @param ruleBizId
* @return
*/
@Override
public CommissionRuleConfig queryOne(String ruleBizId) {
return this.getOne(new LambdaQueryWrapper<CommissionRuleConfig>().eq(CommissionRuleConfig::getRuleBizId,ruleBizId));
}
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.service.dto.CommissionSqlTemplateDto;
import com.yd.csf.service.model.CommissionSqlTemplate;
import com.yd.csf.service.dao.CommissionSqlTemplateMapper;
import com.yd.csf.service.model.ConditionType;
import com.yd.csf.service.service.ICommissionSqlTemplateService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.List;
/**
* <p>
* SQL模板表 - 存储所有佣金计算相关的动态SQL模板,支持灵活配置和参数化查询,实现业务逻辑与代码解耦 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class CommissionSqlTemplateServiceImpl extends ServiceImpl<CommissionSqlTemplateMapper, CommissionSqlTemplate> implements ICommissionSqlTemplateService {
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<CommissionSqlTemplate> queryList(CommissionSqlTemplateDto dto) {
List<CommissionSqlTemplate> list = baseMapper.selectList(new LambdaQueryWrapper<CommissionSqlTemplate>()
.in(!CollectionUtils.isEmpty(dto.getSqlTemplateBizIdList()),CommissionSqlTemplate::getSqlTemplateBizId,dto.getSqlTemplateBizIdList())
);
return list;
}
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.ConditionConfig;
import com.yd.csf.service.dao.ConditionConfigMapper;
import com.yd.csf.service.service.IConditionConfigService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 条件配置表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Service
public class ConditionConfigServiceImpl extends ServiceImpl<ConditionConfigMapper, ConditionConfig> implements IConditionConfigService {
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.service.dto.ConditionTypeDto;
import com.yd.csf.service.model.ConditionType;
import com.yd.csf.service.dao.ConditionTypeMapper;
import com.yd.csf.service.model.FormulaConfig;
import com.yd.csf.service.service.IConditionTypeService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.List;
/**
* <p>
* 条件类型表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Service
public class ConditionTypeServiceImpl extends ServiceImpl<ConditionTypeMapper, ConditionType> implements IConditionTypeService {
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<ConditionType> queryList(ConditionTypeDto dto) {
List<ConditionType> list = baseMapper.selectList(new LambdaQueryWrapper<ConditionType>()
.in(!CollectionUtils.isEmpty(dto.getConditionTypeBizIdList()),ConditionType::getConditionTypeBizId,dto.getConditionTypeBizIdList())
);
return list;
}
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.service.dto.FormulaConfigDto;
import com.yd.csf.service.model.FormulaConfig;
import com.yd.csf.service.dao.FormulaConfigMapper;
import com.yd.csf.service.model.RuleItemConfig;
import com.yd.csf.service.service.IFormulaConfigService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.List;
/**
* <p>
* 公式配置表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Service
public class FormulaConfigServiceImpl extends ServiceImpl<FormulaConfigMapper, FormulaConfig> implements IFormulaConfigService {
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<FormulaConfig> queryList(FormulaConfigDto dto) {
List<FormulaConfig> list = baseMapper.selectList(new LambdaQueryWrapper<FormulaConfig>()
.in(!CollectionUtils.isEmpty(dto.getFormulaBizIdList()),FormulaConfig::getFormulaBizId,dto.getFormulaBizIdList())
);
return list;
}
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.FycTask;
import com.yd.csf.service.dao.FycTaskMapper;
import com.yd.csf.service.service.IFycTaskService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 业务员积分任务表 - 定时跑批业务员绑定的基本法计算点,算出当前业务员所得的积分(一级管理奖、二级管理奖、辅导津贴奖、终身推荐奖等月末计算,季度结算等) 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class FycTaskServiceImpl extends ServiceImpl<FycTaskMapper, FycTask> implements IFycTaskService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.Interests;
import com.yd.csf.service.dao.InterestsMapper;
import com.yd.csf.service.service.IInterestsService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 权益表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class InterestsServiceImpl extends ServiceImpl<InterestsMapper, Interests> implements IInterestsService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.Invitation;
import com.yd.csf.service.dao.InvitationMapper;
import com.yd.csf.service.service.IInvitationService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 邀请码表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class InvitationServiceImpl extends ServiceImpl<InvitationMapper, Invitation> implements IInvitationService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.MemberGradeConfig;
import com.yd.csf.service.dao.MemberGradeConfigMapper;
import com.yd.csf.service.service.IMemberGradeConfigService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 会员等级配置表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class MemberGradeConfigServiceImpl extends ServiceImpl<MemberGradeConfigMapper, MemberGradeConfig> implements IMemberGradeConfigService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.Member;
import com.yd.csf.service.dao.MemberMapper;
import com.yd.csf.service.service.IMemberService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 会员表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class MemberServiceImpl extends ServiceImpl<MemberMapper, Member> implements IMemberService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.PayoutBatch;
import com.yd.csf.service.dao.PayoutBatchMapper;
import com.yd.csf.service.service.IPayoutBatchService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 保单发佣批次表 - 存储发佣批次信息,用于批量处理佣金计算和发放 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class PayoutBatchServiceImpl extends ServiceImpl<PayoutBatchMapper, PayoutBatch> implements IPayoutBatchService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.PolicyAgentRelation;
import com.yd.csf.service.dao.PolicyAgentRelationMapper;
import com.yd.csf.service.service.IPolicyAgentRelationService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 保单业务员关联表 - 存储保单与业务员的关联关系及佣金分配信息 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class PolicyAgentRelationServiceImpl extends ServiceImpl<PolicyAgentRelationMapper, PolicyAgentRelation> implements IPolicyAgentRelationService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.RelAgentCustomer;
import com.yd.csf.service.dao.RelAgentCustomerMapper;
import com.yd.csf.service.service.IRelAgentCustomerService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 业务员和客户关联表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RelAgentCustomerServiceImpl extends ServiceImpl<RelAgentCustomerMapper, RelAgentCustomer> implements IRelAgentCustomerService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.RelCustomerInterests;
import com.yd.csf.service.dao.RelCustomerInterestsMapper;
import com.yd.csf.service.service.IRelCustomerInterestsService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 权益表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RelCustomerInterestsServiceImpl extends ServiceImpl<RelCustomerInterestsMapper, RelCustomerInterests> implements IRelCustomerInterestsService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.RelGradeService;
import com.yd.csf.service.dao.RelGradeServiceMapper;
import com.yd.csf.service.service.IRelGradeServiceService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 会员等级和服务关系表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RelGradeServiceServiceImpl extends ServiceImpl<RelGradeServiceMapper, RelGradeService> implements IRelGradeServiceService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.RelMemberRole;
import com.yd.csf.service.dao.RelMemberRoleMapper;
import com.yd.csf.service.service.IRelMemberRoleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 客户端角色表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RelMemberRoleServiceImpl extends ServiceImpl<RelMemberRoleMapper, RelMemberRole> implements IRelMemberRoleService {
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.feign.dto.conditionconfig.ApiRelObjectConditionDto;
import com.yd.csf.service.dto.RelObjectConditionDto;
import com.yd.csf.service.model.RelObjectCondition;
import com.yd.csf.service.dao.RelObjectConditionMapper;
import com.yd.csf.service.service.IRelObjectConditionService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 对象和规则条件配置关系表 - 配置所有相关的涉及到条件和计算公式的业务表条件规则 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RelObjectConditionServiceImpl extends ServiceImpl<RelObjectConditionMapper, RelObjectCondition> implements IRelObjectConditionService {
/**
* 删除关系
* @param dto
* @return
*/
@Override
public Boolean del(ApiRelObjectConditionDto dto) {
return this.remove(new LambdaQueryWrapper<RelObjectCondition>()
.eq(StringUtils.isNotBlank(dto.getObjectBizId()),RelObjectCondition::getObjectBizId,dto.getObjectBizId())
);
}
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<RelObjectCondition> queryList(RelObjectConditionDto dto) {
List<RelObjectCondition> list = baseMapper.selectList(new LambdaQueryWrapper<RelObjectCondition>()
.eq(StringUtils.isNotBlank(dto.getObjectBizId()),RelObjectCondition::getObjectBizId,dto.getObjectBizId())
);
return list;
}
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.service.dto.RelObjectFormulaDto;
import com.yd.csf.service.model.RelObjectFormula;
import com.yd.csf.service.dao.RelObjectFormulaMapper;
import com.yd.csf.service.service.IRelObjectFormulaService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 对象和公式配置关系表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Service
public class RelObjectFormulaServiceImpl extends ServiceImpl<RelObjectFormulaMapper, RelObjectFormula> implements IRelObjectFormulaService {
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<RelObjectFormula> queryList(RelObjectFormulaDto dto) {
List<RelObjectFormula> list = baseMapper.selectList(new LambdaQueryWrapper<RelObjectFormula>()
.eq(StringUtils.isNotBlank(dto.getObjectBizId()),RelObjectFormula::getObjectBizId,dto.getObjectBizId())
);
return list;
}
/**
* 删除关系
* @param dto
* @return
*/
@Override
public Boolean del(RelObjectFormulaDto dto) {
return this.remove(new LambdaQueryWrapper<RelObjectFormula>().eq(RelObjectFormula::getObjectBizId,dto.getObjectBizId()));
}
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.service.dto.RelObjectSqlDto;
import com.yd.csf.service.model.RelObjectFormula;
import com.yd.csf.service.model.RelObjectSql;
import com.yd.csf.service.dao.RelObjectSqlMapper;
import com.yd.csf.service.service.IRelObjectSqlService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 对象和SQL模板配置关系表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-17
*/
@Service
public class RelObjectSqlServiceImpl extends ServiceImpl<RelObjectSqlMapper, RelObjectSql> implements IRelObjectSqlService {
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<RelObjectSql> queryList(RelObjectSqlDto dto) {
List<RelObjectSql> list = baseMapper.selectList(new LambdaQueryWrapper<RelObjectSql>()
.eq(StringUtils.isNotBlank(dto.getObjectBizId()),RelObjectSql::getObjectBizId,dto.getObjectBizId())
);
return list;
}
/**
* 删除关系
* @param dto
* @return
*/
@Override
public Boolean del(RelObjectSqlDto dto) {
return this.remove(new LambdaQueryWrapper<RelObjectSql>().eq(RelObjectSql::getObjectBizId,dto.getObjectBizId()));
}
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.RelServiceInterests;
import com.yd.csf.service.dao.RelServiceInterestsMapper;
import com.yd.csf.service.service.IRelServiceInterestsService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 服务权益关系表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RelServiceInterestsServiceImpl extends ServiceImpl<RelServiceInterestsMapper, RelServiceInterests> implements IRelServiceInterestsService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.RelTeamMember;
import com.yd.csf.service.dao.RelTeamMemberMapper;
import com.yd.csf.service.service.IRelTeamMemberService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 团队和会员关系表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RelTeamMemberServiceImpl extends ServiceImpl<RelTeamMemberMapper, RelTeamMember> implements IRelTeamMemberService {
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.yd.csf.service.model.RuleConditionConfig;
import com.yd.csf.service.dao.RuleConditionConfigMapper;
import com.yd.csf.service.service.IRuleConditionConfigService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 规则条件配置表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RuleConditionConfigServiceImpl extends ServiceImpl<RuleConditionConfigMapper, RuleConditionConfig> implements IRuleConditionConfigService {
/**
* 查询单个对象
* @param conditionBizId
* @return
*/
@Override
public RuleConditionConfig queryOne(String conditionBizId) {
return this.getOne(new LambdaQueryWrapper<RuleConditionConfig>().eq(RuleConditionConfig::getConditionBizId,conditionBizId));
}
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.ruleItemconfig.ApiRuleItemConfigPageRequest;
import com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigPageResponse;
import com.yd.csf.service.dto.RuleItemConfigDto;
import com.yd.csf.service.model.CommissionRuleConfig;
import com.yd.csf.service.model.RuleItemConfig;
import com.yd.csf.service.dao.RuleItemConfigMapper;
import com.yd.csf.service.service.IRuleItemConfigService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 基本法项目配置表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class RuleItemConfigServiceImpl extends ServiceImpl<RuleItemConfigMapper, RuleItemConfig> implements IRuleItemConfigService {
@Override
public IPage<ApiRuleItemConfigPageResponse> page(Page<ApiRuleItemConfigPageResponse> page,
ApiRuleItemConfigPageRequest request) {
return baseMapper.page(page,request);
}
/**
* 查询单个对象
* @param ruleItemBizId
* @return
*/
@Override
public RuleItemConfig queryOne(String ruleItemBizId) {
return this.getOne(new LambdaQueryWrapper<RuleItemConfig>().eq(RuleItemConfig::getRuleItemBizId,ruleItemBizId));
}
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<RuleItemConfig> queryList(RuleItemConfigDto dto) {
List<RuleItemConfig> list = baseMapper.selectList(new LambdaQueryWrapper<RuleItemConfig>()
.eq(StringUtils.isNotBlank(dto.getRuleItemBizId()) && !dto.getIsExcludeMy(),RuleItemConfig::getRuleItemBizId,dto.getRuleItemBizId())
.eq(StringUtils.isNotBlank(dto.getItemName()),RuleItemConfig::getItemName,dto.getItemName())
.ne(dto.getIsExcludeMy(),RuleItemConfig::getRuleItemBizId,dto.getRuleItemBizId())
);
return list;
}
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.ServiceConfig;
import com.yd.csf.service.dao.ServiceConfigMapper;
import com.yd.csf.service.service.IServiceConfigService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 服务配置表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class ServiceConfigServiceImpl extends ServiceImpl<ServiceConfigMapper, ServiceConfig> implements IServiceConfigService {
}
package com.yd.csf.service.service.impl;
import com.yd.csf.service.model.Team;
import com.yd.csf.service.dao.TeamMapper;
import com.yd.csf.service.service.ITeamService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* <p>
* 团队表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-15
*/
@Service
public class TeamServiceImpl extends ServiceImpl<TeamMapper, Team> implements ITeamService {
}
package com.yd.csf.service.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yd.csf.feign.request.variable.ApiVariablePageRequest;
import com.yd.csf.feign.response.variable.ApiVariablePageResponse;
import com.yd.csf.service.dto.VariableDto;
import com.yd.csf.service.model.CommissionRuleConfig;
import com.yd.csf.service.model.Variable;
import com.yd.csf.service.dao.VariableMapper;
import com.yd.csf.service.service.IVariableService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 变量表 服务实现类
* </p>
*
* @author zxm
* @since 2025-10-16
*/
@Service
public class VariableServiceImpl extends ServiceImpl<VariableMapper, Variable> implements IVariableService {
@Override
public IPage<ApiVariablePageResponse> page(Page<ApiVariablePageResponse> page,
ApiVariablePageRequest request) {
return baseMapper.page(page,request);
}
/**
* 查询单个对象
* @param variableBizId
* @return
*/
@Override
public Variable queryOne(String variableBizId) {
return this.getOne(new LambdaQueryWrapper<Variable>().eq(Variable::getVariableBizId,variableBizId));
}
/**
* 查询列表
* @param dto
* @return
*/
@Override
public List<Variable> queryList(VariableDto dto) {
List<Variable> list = baseMapper.selectList(new LambdaQueryWrapper<Variable>()
.eq(StringUtils.isNotBlank(dto.getVariableBizId()) && !dto.getIsExcludeMy(),Variable::getVariableBizId,dto.getVariableBizId())
.eq(StringUtils.isNotBlank(dto.getNameCn()),Variable::getNameCn,dto.getNameCn())
.eq(StringUtils.isNotBlank(dto.getNameEn()),Variable::getNameEn,dto.getNameEn())
.ne(dto.getIsExcludeMy(),Variable::getVariableBizId,dto.getVariableBizId())
);
return list;
}
}
...@@ -5,7 +5,7 @@ import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine; ...@@ -5,7 +5,7 @@ import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
public class MyBatisPlusCodeGenerator { public class MyBatisPlusCodeGenerator {
public static void main(String[] args) { public static void main(String[] args) {
FastAutoGenerator.create("jdbc:mysql://localhost:3306/yd-csf?serverTimezone=GMT%2B8", "root", "123456") FastAutoGenerator.create("jdbc:mysql://localhost:3306/yd_csf?serverTimezone=GMT%2B8", "root", "123456")
.globalConfig(builder -> { .globalConfig(builder -> {
builder.author("zxm") builder.author("zxm")
.outputDir("src/main/java/com/yd/csf/service"); .outputDir("src/main/java/com/yd/csf/service");
...@@ -21,11 +21,7 @@ public class MyBatisPlusCodeGenerator { ...@@ -21,11 +21,7 @@ public class MyBatisPlusCodeGenerator {
}) })
.strategyConfig(builder -> { .strategyConfig(builder -> {
builder.addInclude( builder.addInclude(
"appointment","beneficiary","insurant","policyholder" "formula_config"
// "additional", "appointment", "appointment_file",
// "beneficiary", "beneficiary_company", "beneficiary_individual",
// "insurant", "policyholder", "product_plan",
// "rel_tenant_project_appointment", "second_holder"
) )
.entityBuilder() .entityBuilder()
......
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.AgentAccumulatedFycMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.AgentDetailFycMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.AgentReferralRelationMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.AgentTutoringRelationMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.BatchPolicyMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.CarApplyMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.ClientRoleMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.CommissionResultMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.CommissionRuleBindingMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.CommissionRuleConfigMapper">
<select id="page"
resultType="com.yd.csf.feign.response.commissionruleconfig.ApiCommissionRuleConfigPageResponse">
select * from commission_rule_config crc
<where>
<if test="request.ruleName != null and request.ruleName != ''">
and crc.rule_name like concat('%', #{request.ruleName}, '%')
</if>
and crc.is_deleted = 0
</where>
order by crc.create_time desc
</select>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.CommissionSqlTemplateMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.ConditionConfigMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.ConditionTypeMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.FormulaConfigMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.FycTaskMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.InterestsMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.InvitationMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.MemberGradeConfigMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.MemberMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.PayoutBatchMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.PolicyAgentRelationMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelAgentCustomerMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelCustomerInterestsMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelGradeServiceMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelMemberRoleMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelObjectConditionMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelObjectFormulaMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelObjectSqlMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelServiceInterestsMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RelTeamMemberMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RuleConditionConfigMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.RuleItemConfigMapper">
<select id="page" resultType="com.yd.csf.feign.response.ruleItemconfig.ApiRuleItemConfigPageResponse">
select ric.*,crc.rule_name
from rule_item_config ric
left join commission_rule_config crc on crc.rule_biz_id = ric.rule_biz_id and crc.is_deleted = 0
<where>
<if test="request.itemName != null and request.itemName != ''">
and ric.item_name like concat('%', #{request.itemName}, '%')
</if>
<if test="request.calculate != null and request.calculate != ''">
and ric.calculate = #{request.calculate}
</if>
and ric.is_deleted = 0
</where>
</select>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.ServiceConfigMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.TeamMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yd.csf.service.dao.VariableMapper">
<select id="page" resultType="com.yd.csf.feign.response.variable.ApiVariablePageResponse">
select * from variable v
<where>
<if test="request.nameCn != null and request.nameCn != ''">
and v.name_cn like concat('%', #{request.nameCn}, '%')
</if>
<if test="request.type != null and request.type != ''">
and v.type = #{request.type}
</if>
and v.is_deleted = 0
</where>
</select>
</mapper>
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment