3107 lines
115 KiB
TypeScript
3107 lines
115 KiB
TypeScript
import { Injectable, Inject, Logger } from '@nestjs/common'
|
||
import { AuthorizationRole, MonthlyAssessment } from '@/domain/aggregates'
|
||
import { LadderTargetRule } from '@/domain/entities'
|
||
import {
|
||
UserId,
|
||
AdminUserId,
|
||
RegionCode,
|
||
AuthorizationId,
|
||
Month,
|
||
} from '@/domain/value-objects'
|
||
import { RoleType, AuthorizationStatus } from '@/domain/enums'
|
||
import {
|
||
IAuthorizationRoleRepository,
|
||
AUTHORIZATION_ROLE_REPOSITORY,
|
||
IMonthlyAssessmentRepository,
|
||
MONTHLY_ASSESSMENT_REPOSITORY,
|
||
} from '@/domain/repositories'
|
||
import {
|
||
AuthorizationValidatorService,
|
||
IReferralRepository,
|
||
ITeamStatisticsRepository,
|
||
TeamStatistics,
|
||
} from '@/domain/services'
|
||
import { EventPublisherService } from '@/infrastructure/kafka'
|
||
import { ReferralServiceClient, IdentityServiceClient } from '@/infrastructure/external'
|
||
import { ApplicationError, NotFoundError } from '@/shared/exceptions'
|
||
import {
|
||
ApplyCommunityAuthCommand,
|
||
ApplyCommunityAuthResult,
|
||
ApplyAuthProvinceCompanyCommand,
|
||
ApplyAuthProvinceCompanyResult,
|
||
ApplyAuthCityCompanyCommand,
|
||
ApplyAuthCityCompanyResult,
|
||
GrantCommunityCommand,
|
||
GrantProvinceCompanyCommand,
|
||
GrantCityCompanyCommand,
|
||
GrantAuthProvinceCompanyCommand,
|
||
GrantAuthCityCompanyCommand,
|
||
RevokeAuthorizationCommand,
|
||
GrantMonthlyBypassCommand,
|
||
ExemptLocalPercentageCheckCommand,
|
||
SelfApplyAuthorizationCommand,
|
||
} from '@/application/commands'
|
||
import {
|
||
SelfApplyAuthorizationResponseDto,
|
||
UserAuthorizationStatusResponseDto,
|
||
SelfApplyAuthorizationType,
|
||
TeamChainOccupiedRegionDto,
|
||
} from '@/api/dto/request/self-apply-authorization.dto'
|
||
import { AuthorizationDTO, StickmanRankingDTO, CommunityHierarchyDTO } from '@/application/dto'
|
||
|
||
export const REFERRAL_REPOSITORY = Symbol('IReferralRepository')
|
||
export const TEAM_STATISTICS_REPOSITORY = Symbol('ITeamStatisticsRepository')
|
||
|
||
@Injectable()
|
||
export class AuthorizationApplicationService {
|
||
private readonly logger = new Logger(AuthorizationApplicationService.name)
|
||
private readonly validatorService = new AuthorizationValidatorService()
|
||
|
||
constructor(
|
||
@Inject(AUTHORIZATION_ROLE_REPOSITORY)
|
||
private readonly authorizationRepository: IAuthorizationRoleRepository,
|
||
@Inject(MONTHLY_ASSESSMENT_REPOSITORY)
|
||
private readonly assessmentRepository: IMonthlyAssessmentRepository,
|
||
@Inject(REFERRAL_REPOSITORY)
|
||
private readonly referralRepository: IReferralRepository,
|
||
@Inject(TEAM_STATISTICS_REPOSITORY)
|
||
private readonly statsRepository: ITeamStatisticsRepository,
|
||
private readonly eventPublisher: EventPublisherService,
|
||
private readonly referralServiceClient: ReferralServiceClient,
|
||
private readonly identityServiceClient: IdentityServiceClient,
|
||
) {}
|
||
|
||
/**
|
||
* 申请社区授权
|
||
*/
|
||
async applyCommunityAuth(
|
||
command: ApplyCommunityAuthCommand,
|
||
): Promise<ApplyCommunityAuthResult> {
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
|
||
// 1. 检查是否已有社区授权
|
||
const existing = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
userId.accountSequence,
|
||
RoleType.COMMUNITY,
|
||
)
|
||
|
||
if (existing && existing.status !== AuthorizationStatus.REVOKED) {
|
||
throw new ApplicationError('您已申请过社区授权')
|
||
}
|
||
|
||
// 2. 创建社区授权
|
||
const authorization = AuthorizationRole.createCommunityAuth({
|
||
userId,
|
||
communityName: command.communityName,
|
||
})
|
||
|
||
// 3. 检查初始考核（10棵）- 使用下级团队认种数（不含自己）
|
||
const teamStats = await this.statsRepository.findByAccountSequence(userId.accountSequence)
|
||
const subordinateTreeCount = teamStats?.subordinateTeamPlantingCount || 0
|
||
|
||
if (subordinateTreeCount >= authorization.getInitialTarget()) {
|
||
// 达标，激活权益
|
||
authorization.activateBenefit()
|
||
}
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
|
||
return {
|
||
authorizationId: authorization.authorizationId.value,
|
||
status: authorization.status,
|
||
benefitActive: authorization.benefitActive,
|
||
message: authorization.benefitActive
|
||
? '社区权益已激活'
|
||
: `需要下级团队累计认种达到${authorization.getInitialTarget()}棵才能激活`,
|
||
currentTreeCount: subordinateTreeCount,
|
||
requiredTreeCount: authorization.getInitialTarget(),
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 申请授权省公司
|
||
*/
|
||
async applyAuthProvinceCompany(
|
||
command: ApplyAuthProvinceCompanyCommand,
|
||
): Promise<ApplyAuthProvinceCompanyResult> {
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const regionCode = RegionCode.create(command.provinceCode)
|
||
|
||
// 1. 验证授权申请（团队内唯一性）
|
||
const validation = await this.validatorService.validateAuthorizationRequest(
|
||
userId,
|
||
RoleType.AUTH_PROVINCE_COMPANY,
|
||
regionCode,
|
||
this.referralRepository,
|
||
this.authorizationRepository,
|
||
)
|
||
|
||
if (!validation.isValid) {
|
||
throw new ApplicationError(validation.errorMessage!)
|
||
}
|
||
|
||
// 2. 创建授权
|
||
const authorization = AuthorizationRole.createAuthProvinceCompany({
|
||
userId,
|
||
provinceCode: command.provinceCode,
|
||
provinceName: command.provinceName,
|
||
})
|
||
|
||
// 3. 检查初始考核（500棵）- 使用下级团队认种数（不含自己）
|
||
const teamStats = await this.statsRepository.findByAccountSequence(userId.accountSequence)
|
||
const subordinateTreeCount = teamStats?.subordinateTeamPlantingCount || 0
|
||
|
||
if (subordinateTreeCount >= authorization.getInitialTarget()) {
|
||
// 达标，激活权益并创建首月考核
|
||
authorization.activateBenefit()
|
||
await this.createInitialAssessment(authorization, teamStats!)
|
||
}
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
|
||
return {
|
||
authorizationId: authorization.authorizationId.value,
|
||
status: authorization.status,
|
||
benefitActive: authorization.benefitActive,
|
||
displayTitle: authorization.displayTitle,
|
||
message: authorization.benefitActive
|
||
? '授权省公司权益已激活，开始阶梯考核'
|
||
: `需要下级团队累计认种达到${authorization.getInitialTarget()}棵才能激活`,
|
||
currentTreeCount: subordinateTreeCount,
|
||
requiredTreeCount: authorization.getInitialTarget(),
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 申请授权市公司
|
||
*/
|
||
async applyAuthCityCompany(
|
||
command: ApplyAuthCityCompanyCommand,
|
||
): Promise<ApplyAuthCityCompanyResult> {
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const regionCode = RegionCode.create(command.cityCode)
|
||
|
||
// 1. 验证
|
||
const validation = await this.validatorService.validateAuthorizationRequest(
|
||
userId,
|
||
RoleType.AUTH_CITY_COMPANY,
|
||
regionCode,
|
||
this.referralRepository,
|
||
this.authorizationRepository,
|
||
)
|
||
|
||
if (!validation.isValid) {
|
||
throw new ApplicationError(validation.errorMessage!)
|
||
}
|
||
|
||
// 2. 创建授权
|
||
const authorization = AuthorizationRole.createAuthCityCompany({
|
||
userId,
|
||
cityCode: command.cityCode,
|
||
cityName: command.cityName,
|
||
})
|
||
|
||
// 3. 检查初始考核（100棵）- 使用下级团队认种数（不含自己）
|
||
const teamStats = await this.statsRepository.findByAccountSequence(userId.accountSequence)
|
||
const subordinateTreeCount = teamStats?.subordinateTeamPlantingCount || 0
|
||
|
||
if (subordinateTreeCount >= authorization.getInitialTarget()) {
|
||
authorization.activateBenefit()
|
||
await this.createInitialAssessment(authorization, teamStats!)
|
||
}
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
|
||
return {
|
||
authorizationId: authorization.authorizationId.value,
|
||
status: authorization.status,
|
||
benefitActive: authorization.benefitActive,
|
||
displayTitle: authorization.displayTitle,
|
||
message: authorization.benefitActive
|
||
? '授权市公司权益已激活，开始阶梯考核'
|
||
: `需要下级团队累计认种达到${authorization.getInitialTarget()}棵才能激活`,
|
||
currentTreeCount: subordinateTreeCount,
|
||
requiredTreeCount: authorization.getInitialTarget(),
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 管理员直接授权社区
|
||
*
|
||
* 业务规则：
|
||
* - 一个用户只能拥有一个社区角色
|
||
* - 社区名称全局唯一，不允许重复
|
||
*/
|
||
async grantCommunity(command: GrantCommunityCommand): Promise<void> {
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const adminId = AdminUserId.create(command.adminId, command.adminAccountSequence)
|
||
|
||
// 0. 检查用户是否已认种（授权前置条件）
|
||
await this.ensureUserHasPlanted(command.accountSequence)
|
||
|
||
// 1. 检查用户是否已有社区角色
|
||
const existingUserCommunity = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
command.accountSequence,
|
||
RoleType.COMMUNITY,
|
||
)
|
||
if (existingUserCommunity) {
|
||
throw new ApplicationError(
|
||
`用户 ${command.accountSequence} 已拥有社区角色「${existingUserCommunity.displayTitle}」，不能重复授权`,
|
||
)
|
||
}
|
||
|
||
// 2. 检查社区名称是否已被使用
|
||
const existingCommunityName = await this.authorizationRepository.findCommunityByName(command.communityName)
|
||
if (existingCommunityName) {
|
||
throw new ApplicationError(
|
||
`社区名称「${command.communityName}」已被使用，请选择其他名称`,
|
||
)
|
||
}
|
||
|
||
// 3. 创建社区授权
|
||
const authorization = AuthorizationRole.createCommunity({
|
||
userId,
|
||
communityName: command.communityName,
|
||
adminId,
|
||
skipAssessment: command.skipAssessment,
|
||
})
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
}
|
||
|
||
/**
|
||
* 管理员授权正式省公司（省区域）
|
||
*
|
||
* 业务规则：
|
||
* - 同一个用户不能同时拥有省区域和市区域两种身份
|
||
* - 同一个省份只允许授权给一个账户（按省份唯一）
|
||
*/
|
||
async grantProvinceCompany(command: GrantProvinceCompanyCommand): Promise<void> {
|
||
// 0. 检查用户是否已认种（授权前置条件）
|
||
await this.ensureUserHasPlanted(command.accountSequence)
|
||
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const adminId = AdminUserId.create(command.adminId, command.adminAccountSequence)
|
||
|
||
// 1. 检查用户是否已有市区域授权（省区域和市区域互斥）
|
||
const existingCityCompany = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
command.accountSequence,
|
||
RoleType.CITY_COMPANY,
|
||
)
|
||
if (existingCityCompany && existingCityCompany.status !== AuthorizationStatus.REVOKED) {
|
||
throw new ApplicationError(
|
||
`用户 ${command.accountSequence} 已拥有市区域角色「${existingCityCompany.regionName}」，不能同时拥有省区域角色`,
|
||
)
|
||
}
|
||
|
||
// 2. 检查用户是否已有省区域授权（一个用户只能有一个省区域）
|
||
const existingProvinceCompany = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
command.accountSequence,
|
||
RoleType.PROVINCE_COMPANY,
|
||
)
|
||
if (existingProvinceCompany && existingProvinceCompany.status !== AuthorizationStatus.REVOKED) {
|
||
throw new ApplicationError(
|
||
`用户 ${command.accountSequence} 已拥有省区域角色「${existingProvinceCompany.regionName}」，不能重复授权`,
|
||
)
|
||
}
|
||
|
||
// 3. 检查该省份是否已有省区域授权（同一省份只能授权给一个账户）
|
||
const existingProvinceRegion = await this.authorizationRepository.findProvinceCompanyByRegion(command.provinceCode)
|
||
if (existingProvinceRegion) {
|
||
throw new ApplicationError(
|
||
`省份「${command.provinceName}」已有省区域角色授权给用户 ${existingProvinceRegion.userId.accountSequence}，不能重复授权`,
|
||
)
|
||
}
|
||
|
||
// 4. 创建授权
|
||
const authorization = AuthorizationRole.createProvinceCompany({
|
||
userId,
|
||
provinceCode: command.provinceCode,
|
||
provinceName: command.provinceName,
|
||
adminId,
|
||
skipAssessment: command.skipAssessment,
|
||
})
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
}
|
||
|
||
/**
|
||
* 管理员授权正式市公司（市区域）
|
||
*
|
||
* 业务规则：
|
||
* - 同一个用户不能同时拥有市区域和省区域两种身份
|
||
* - 同一个城市只允许一个市区域角色被授权
|
||
*/
|
||
async grantCityCompany(command: GrantCityCompanyCommand): Promise<void> {
|
||
// 0. 检查用户是否已认种（授权前置条件）
|
||
await this.ensureUserHasPlanted(command.accountSequence)
|
||
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const adminId = AdminUserId.create(command.adminId, command.adminAccountSequence)
|
||
|
||
// 1. 检查用户是否已有省区域授权（市区域和省区域互斥）
|
||
const existingProvinceCompany = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
command.accountSequence,
|
||
RoleType.PROVINCE_COMPANY,
|
||
)
|
||
if (existingProvinceCompany && existingProvinceCompany.status !== AuthorizationStatus.REVOKED) {
|
||
throw new ApplicationError(
|
||
`用户 ${command.accountSequence} 已拥有省区域角色「${existingProvinceCompany.regionName}」，不能同时拥有市区域角色`,
|
||
)
|
||
}
|
||
|
||
// 2. 检查用户是否已有市区域授权（一个用户只能有一个市区域）
|
||
const existingCityCompany = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
command.accountSequence,
|
||
RoleType.CITY_COMPANY,
|
||
)
|
||
if (existingCityCompany && existingCityCompany.status !== AuthorizationStatus.REVOKED) {
|
||
throw new ApplicationError(
|
||
`用户 ${command.accountSequence} 已拥有市区域角色「${existingCityCompany.regionName}」，不能重复授权`,
|
||
)
|
||
}
|
||
|
||
// 3. 检查该城市是否已有市区域授权（同一城市全局唯一）
|
||
const existingCityRegion = await this.authorizationRepository.findCityCompanyByRegion(command.cityCode)
|
||
if (existingCityRegion && existingCityRegion.status !== AuthorizationStatus.REVOKED) {
|
||
throw new ApplicationError(
|
||
`城市「${command.cityName}」已有市区域角色授权给用户 ${existingCityRegion.userId.accountSequence}，不能重复授权`,
|
||
)
|
||
}
|
||
|
||
// 4. 创建授权
|
||
const authorization = AuthorizationRole.createCityCompany({
|
||
userId,
|
||
cityCode: command.cityCode,
|
||
cityName: command.cityName,
|
||
adminId,
|
||
skipAssessment: command.skipAssessment,
|
||
})
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
}
|
||
|
||
/**
|
||
* 管理员授权授权省公司（省团队）
|
||
* Admin直接授权，跳过用户申请流程
|
||
* 需要验证团队内唯一性：同一推荐链上不能有重复的相同省份授权
|
||
*/
|
||
async grantAuthProvinceCompany(command: GrantAuthProvinceCompanyCommand): Promise<void> {
|
||
// 0. 检查用户是否已认种（授权前置条件）
|
||
await this.ensureUserHasPlanted(command.accountSequence)
|
||
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const adminId = AdminUserId.create(command.adminId, command.adminAccountSequence)
|
||
const regionCode = RegionCode.create(command.provinceCode)
|
||
|
||
// 1. 验证团队内唯一性（同一推荐链上不能有重复的相同省份授权）
|
||
const validation = await this.validatorService.validateAuthorizationRequest(
|
||
userId,
|
||
RoleType.AUTH_PROVINCE_COMPANY,
|
||
regionCode,
|
||
this.referralRepository,
|
||
this.authorizationRepository,
|
||
)
|
||
|
||
if (!validation.isValid) {
|
||
throw new ApplicationError(validation.errorMessage!)
|
||
}
|
||
|
||
// 2. 创建授权
|
||
const authorization = AuthorizationRole.createAuthProvinceCompanyByAdmin({
|
||
userId,
|
||
provinceCode: command.provinceCode,
|
||
provinceName: command.provinceName,
|
||
adminId,
|
||
skipAssessment: command.skipAssessment,
|
||
})
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
}
|
||
|
||
/**
|
||
* 管理员授权授权市公司（市团队）
|
||
* Admin直接授权，跳过用户申请流程
|
||
* 需要验证团队内唯一性：同一推荐链上不能有重复的相同城市授权
|
||
*/
|
||
async grantAuthCityCompany(command: GrantAuthCityCompanyCommand): Promise<void> {
|
||
// 0. 检查用户是否已认种（授权前置条件）
|
||
await this.ensureUserHasPlanted(command.accountSequence)
|
||
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const adminId = AdminUserId.create(command.adminId, command.adminAccountSequence)
|
||
const regionCode = RegionCode.create(command.cityCode)
|
||
|
||
// 1. 验证团队内唯一性（同一推荐链上不能有重复的相同城市授权）
|
||
const validation = await this.validatorService.validateAuthorizationRequest(
|
||
userId,
|
||
RoleType.AUTH_CITY_COMPANY,
|
||
regionCode,
|
||
this.referralRepository,
|
||
this.authorizationRepository,
|
||
)
|
||
|
||
if (!validation.isValid) {
|
||
throw new ApplicationError(validation.errorMessage!)
|
||
}
|
||
|
||
// 2. 创建授权
|
||
const authorization = AuthorizationRole.createAuthCityCompanyByAdmin({
|
||
userId,
|
||
cityCode: command.cityCode,
|
||
cityName: command.cityName,
|
||
adminId,
|
||
skipAssessment: command.skipAssessment,
|
||
})
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
}
|
||
|
||
/**
|
||
* 撤销授权
|
||
*/
|
||
async revokeAuthorization(command: RevokeAuthorizationCommand): Promise<void> {
|
||
const authorization = await this.authorizationRepository.findById(
|
||
AuthorizationId.create(command.authorizationId),
|
||
)
|
||
|
||
if (!authorization) {
|
||
throw new NotFoundError('授权不存在')
|
||
}
|
||
|
||
// Note: We need the adminId from somewhere, for now using a placeholder
|
||
// In a real scenario, we would need to fetch the admin's userId from the accountSequence
|
||
const adminId = AdminUserId.create('admin', command.adminAccountSequence)
|
||
authorization.revoke(adminId, command.reason)
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
}
|
||
|
||
/**
|
||
* 授予单月豁免
|
||
*/
|
||
async grantMonthlyBypass(command: GrantMonthlyBypassCommand): Promise<void> {
|
||
const assessment = await this.assessmentRepository.findByAuthorizationAndMonth(
|
||
AuthorizationId.create(command.authorizationId),
|
||
Month.create(command.month),
|
||
)
|
||
|
||
if (!assessment) {
|
||
throw new NotFoundError('考核记录不存在')
|
||
}
|
||
|
||
// Note: We need the adminId from somewhere, for now using a placeholder
|
||
const adminId = AdminUserId.create('admin', command.adminAccountSequence)
|
||
assessment.grantBypass(adminId)
|
||
|
||
await this.assessmentRepository.save(assessment)
|
||
await this.eventPublisher.publishAll(assessment.domainEvents)
|
||
assessment.clearDomainEvents()
|
||
}
|
||
|
||
/**
|
||
* 豁免占比考核
|
||
*/
|
||
async exemptLocalPercentageCheck(command: ExemptLocalPercentageCheckCommand): Promise<void> {
|
||
const authorization = await this.authorizationRepository.findById(
|
||
AuthorizationId.create(command.authorizationId),
|
||
)
|
||
|
||
if (!authorization) {
|
||
throw new NotFoundError('授权不存在')
|
||
}
|
||
|
||
// Note: We need the adminId from somewhere, for now using a placeholder
|
||
const adminId = AdminUserId.create('admin', command.adminAccountSequence)
|
||
authorization.exemptLocalPercentageCheck(adminId)
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
}
|
||
|
||
/**
|
||
* 查询用户授权列表
|
||
*/
|
||
async getUserAuthorizations(accountSequence: string): Promise<AuthorizationDTO[]> {
|
||
const authorizations = await this.authorizationRepository.findByAccountSequence(
|
||
accountSequence,
|
||
)
|
||
|
||
// 查询用户团队统计数据
|
||
const teamStats = await this.statsRepository.findByAccountSequence(accountSequence)
|
||
const currentTreeCount = teamStats?.totalTeamPlantingCount || 0
|
||
|
||
return authorizations.map((auth) => this.toAuthorizationDTO(auth, currentTreeCount))
|
||
}
|
||
|
||
/**
|
||
* 查询用户授权详情
|
||
*/
|
||
async getAuthorizationById(authorizationId: string): Promise<AuthorizationDTO | null> {
|
||
const authorization = await this.authorizationRepository.findById(
|
||
AuthorizationId.create(authorizationId),
|
||
)
|
||
|
||
if (!authorization) return null
|
||
|
||
// 查询用户团队统计数据
|
||
const teamStats = await this.statsRepository.findByAccountSequence(authorization.userId.accountSequence)
|
||
const currentTreeCount = teamStats?.totalTeamPlantingCount || 0
|
||
|
||
return this.toAuthorizationDTO(authorization, currentTreeCount)
|
||
}
|
||
|
||
/**
|
||
* 查询火柴人排名数据
|
||
*
|
||
* 业务规则：查询全系统该角色类型的所有排名数据（不按区域过滤）
|
||
* 只要有任何一个用户达标，所有申请了该角色类型授权的用户都能看到排名
|
||
*/
|
||
async getStickmanRanking(
|
||
month: string,
|
||
roleType: RoleType,
|
||
regionCode: string,
|
||
currentUserId?: string,
|
||
): Promise<StickmanRankingDTO[]> {
|
||
this.logger.log(
|
||
`[getStickmanRanking] 查询火柴人排名: month=${month}, roleType=${roleType}, regionCode=${regionCode}, currentUserId=${currentUserId}`,
|
||
)
|
||
|
||
// 查询全系统该角色类型的所有评估记录（不按区域过滤）
|
||
const assessments = await this.assessmentRepository.findRankingsByMonthAndRoleType(
|
||
Month.create(month),
|
||
roleType,
|
||
)
|
||
|
||
this.logger.log(
|
||
`[getStickmanRanking] 查询到 ${assessments.length} 条评估记录`,
|
||
)
|
||
|
||
if (assessments.length === 0) {
|
||
this.logger.warn(
|
||
`[getStickmanRanking] 没有找到任何评估记录，month=${month}, roleType=${roleType}`,
|
||
)
|
||
return []
|
||
}
|
||
|
||
// 批量获取用户信息
|
||
const userIds = assessments.map(a => a.userId.value)
|
||
const userInfoMap = await this.identityServiceClient.batchGetUserInfo(userIds)
|
||
|
||
const rankings: StickmanRankingDTO[] = []
|
||
const finalTarget = LadderTargetRule.getFinalTarget(roleType)
|
||
|
||
for (const assessment of assessments) {
|
||
const userInfo = userInfoMap.get(assessment.userId.value)
|
||
this.logger.debug(
|
||
`[getStickmanRanking] 处理评估记录: userId=${assessment.userId.value}, ` +
|
||
`regionCode=${assessment.regionCode.value}, cumulativeCompleted=${assessment.cumulativeCompleted}`,
|
||
)
|
||
rankings.push({
|
||
id: assessment.authorizationId.value,
|
||
userId: assessment.userId.value,
|
||
authorizationId: assessment.authorizationId.value,
|
||
roleType: assessment.roleType,
|
||
regionCode: assessment.regionCode.value,
|
||
nickname: userInfo?.nickname || `用户${assessment.userId.accountSequence.slice(-4)}`,
|
||
avatarUrl: userInfo?.avatarUrl,
|
||
completedCount: assessment.cumulativeCompleted,
|
||
monthlyEarnings: 0, // TODO: 从奖励服务获取本月可结算收益
|
||
isCurrentUser: currentUserId ? assessment.userId.value === currentUserId : false,
|
||
ranking: assessment.rankingInRegion || 0,
|
||
isFirstPlace: assessment.isFirstPlace,
|
||
cumulativeCompleted: assessment.cumulativeCompleted,
|
||
cumulativeTarget: assessment.cumulativeTarget,
|
||
finalTarget,
|
||
progressPercentage: (assessment.cumulativeCompleted / finalTarget) * 100,
|
||
exceedRatio: assessment.exceedRatio,
|
||
monthlyRewardUsdt: 0, // TODO: 从奖励服务获取
|
||
monthlyRewardRwad: 0,
|
||
})
|
||
}
|
||
|
||
// 按完成数量降序排序
|
||
rankings.sort((a, b) => b.completedCount - a.completedCount)
|
||
|
||
this.logger.log(
|
||
`[getStickmanRanking] 返回 ${rankings.length} 条排名数据`,
|
||
)
|
||
|
||
return rankings
|
||
}
|
||
|
||
// 辅助方法
|
||
private async createInitialAssessment(
|
||
authorization: AuthorizationRole,
|
||
teamStats: TeamStatistics,
|
||
): Promise<void> {
|
||
const currentMonth = Month.current()
|
||
const target = LadderTargetRule.getTarget(authorization.roleType, 1)
|
||
|
||
const assessment = MonthlyAssessment.create({
|
||
authorizationId: authorization.authorizationId,
|
||
userId: authorization.userId,
|
||
roleType: authorization.roleType,
|
||
regionCode: authorization.regionCode,
|
||
assessmentMonth: currentMonth,
|
||
monthIndex: 1,
|
||
monthlyTarget: target.monthlyTarget,
|
||
cumulativeTarget: target.cumulativeTarget,
|
||
})
|
||
|
||
// 立即评估首月
|
||
const localTeamCount = this.getLocalTeamCount(
|
||
teamStats,
|
||
authorization.roleType,
|
||
authorization.regionCode,
|
||
)
|
||
|
||
assessment.assess({
|
||
cumulativeCompleted: teamStats.totalTeamPlantingCount,
|
||
localTeamCount,
|
||
totalTeamCount: teamStats.totalTeamPlantingCount,
|
||
requireLocalPercentage: authorization.requireLocalPercentage,
|
||
exemptFromPercentageCheck: authorization.exemptFromPercentageCheck,
|
||
})
|
||
|
||
await this.assessmentRepository.save(assessment)
|
||
await this.eventPublisher.publishAll(assessment.domainEvents)
|
||
assessment.clearDomainEvents()
|
||
}
|
||
|
||
private getLocalTeamCount(
|
||
teamStats: TeamStatistics,
|
||
roleType: RoleType,
|
||
regionCode: RegionCode,
|
||
): number {
|
||
if (roleType === RoleType.AUTH_PROVINCE_COMPANY) {
|
||
return teamStats.getProvinceTeamCount(regionCode.value)
|
||
} else if (roleType === RoleType.AUTH_CITY_COMPANY) {
|
||
return teamStats.getCityTeamCount(regionCode.value)
|
||
}
|
||
return 0
|
||
}
|
||
|
||
private toAuthorizationDTO(auth: AuthorizationRole, currentTreeCount: number): AuthorizationDTO {
|
||
// 获取月度考核目标（社区固定10，其他类型根据阶梯规则）
|
||
let monthlyTargetTreeCount = 0
|
||
if (auth.roleType === RoleType.COMMUNITY) {
|
||
monthlyTargetTreeCount = 10 // 社区固定每月新增10棵
|
||
} else if (auth.benefitActive && auth.currentMonthIndex > 0) {
|
||
// 省/市公司使用阶梯目标
|
||
const target = LadderTargetRule.getTarget(auth.roleType, auth.currentMonthIndex)
|
||
monthlyTargetTreeCount = target.monthlyTarget
|
||
}
|
||
|
||
return {
|
||
authorizationId: auth.authorizationId.value,
|
||
userId: auth.userId.value,
|
||
roleType: auth.roleType,
|
||
regionCode: auth.regionCode.value,
|
||
regionName: auth.regionName,
|
||
status: auth.status,
|
||
displayTitle: auth.displayTitle,
|
||
benefitActive: auth.benefitActive,
|
||
currentMonthIndex: auth.currentMonthIndex,
|
||
requireLocalPercentage: auth.requireLocalPercentage,
|
||
exemptFromPercentageCheck: auth.exemptFromPercentageCheck,
|
||
// 考核进度字段
|
||
initialTargetTreeCount: auth.getInitialTarget(),
|
||
currentTreeCount,
|
||
monthlyTargetTreeCount,
|
||
createdAt: auth.createdAt,
|
||
updatedAt: auth.updatedAt,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取用户的社区层级信息
|
||
* - myCommunity: 我的社区授权（如果有）
|
||
* - parentCommunity: 上级社区（沿推荐链往上找最近的，如果没有则返回总部社区）
|
||
* - childCommunities: 下级社区（在我的团队中找最近的社区）
|
||
*/
|
||
async getCommunityHierarchy(accountSequence: string): Promise<CommunityHierarchyDTO> {
|
||
this.logger.debug(`[getCommunityHierarchy] accountSequence=${accountSequence}`)
|
||
|
||
// 1. 查询我的社区授权
|
||
const myCommunity = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
accountSequence,
|
||
RoleType.COMMUNITY,
|
||
)
|
||
|
||
// 2. 获取我的祖先链（推荐链）
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
this.logger.debug(`[getCommunityHierarchy] ancestorPath: ${ancestorAccountSequences.join(',')}`)
|
||
|
||
// 3. 查找上级社区（在祖先链中找最近的有社区授权的用户）
|
||
let parentCommunityAuth: AuthorizationRole | null = null
|
||
if (ancestorAccountSequences.length > 0) {
|
||
const ancestorCommunities = await this.authorizationRepository.findActiveCommunityByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
// 找最近的（ancestorAccountSequences 是从直接推荐人到根节点的顺序）
|
||
if (ancestorCommunities.length > 0) {
|
||
// 按祖先链顺序找第一个匹配的
|
||
for (const ancestorSeq of ancestorAccountSequences) {
|
||
const found = ancestorCommunities.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq,
|
||
)
|
||
if (found) {
|
||
parentCommunityAuth = found
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 4. 获取我的团队成员
|
||
const teamMemberAccountSequences = await this.referralServiceClient.getTeamMembers(accountSequence)
|
||
this.logger.debug(`[getCommunityHierarchy] teamMembers count: ${teamMemberAccountSequences.length}`)
|
||
|
||
// 5. 查找下级社区（在团队成员中找最近的有社区授权的用户）
|
||
// "最近" 的定义：直接下级优先，然后是下级的下级，以此类推
|
||
// 由于 getTeamMembers 返回的是广度优先遍历结果，可以直接使用顺序
|
||
let childCommunityAuths: AuthorizationRole[] = []
|
||
if (teamMemberAccountSequences.length > 0) {
|
||
const teamCommunities = await this.authorizationRepository.findActiveCommunityByAccountSequences(
|
||
teamMemberAccountSequences,
|
||
)
|
||
|
||
// 只保留"最近的"下级社区
|
||
// 如果一个社区的上级不在我的直接团队成员中，或者其上级就是我，则它是"最近的"
|
||
// 简化实现：返回所有团队中的社区，前端可以根据需要过滤
|
||
// 但按用户要求"只计算最近的那个"，这里需要做过滤
|
||
// 算法：如果某个社区 A 的祖先中有另一个社区 B 也在团队中，则 A 不是最近的
|
||
|
||
const communityAccountSeqs = new Set(teamCommunities.map((c) => c.userId.accountSequence))
|
||
|
||
for (const comm of teamCommunities) {
|
||
// 获取这个社区成员的祖先链
|
||
const commAncestors = await this.referralServiceClient.getReferralChain(comm.userId.accountSequence)
|
||
|
||
// 检查这个社区是否有"更近"的祖先社区
|
||
let hasCloserAncestorCommunity = false
|
||
for (const ancestorSeq of commAncestors) {
|
||
// 如果祖先是我，停止检查
|
||
if (ancestorSeq === accountSequence) {
|
||
break
|
||
}
|
||
// 如果祖先也是社区且在我的团队中，则当前社区不是最近的
|
||
if (communityAccountSeqs.has(ancestorSeq)) {
|
||
hasCloserAncestorCommunity = true
|
||
break
|
||
}
|
||
}
|
||
|
||
if (!hasCloserAncestorCommunity) {
|
||
childCommunityAuths.push(comm)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 6. 构建响应
|
||
const HEADQUARTERS_COMMUNITY = {
|
||
authorizationId: 'headquarters',
|
||
accountSequence: '0',
|
||
communityName: '总部社区',
|
||
userId: undefined,
|
||
isHeadquarters: true,
|
||
}
|
||
|
||
return {
|
||
myCommunity: myCommunity && myCommunity.status === AuthorizationStatus.AUTHORIZED
|
||
? {
|
||
authorizationId: myCommunity.authorizationId.value,
|
||
accountSequence: myCommunity.userId.accountSequence,
|
||
communityName: myCommunity.displayTitle,
|
||
userId: myCommunity.userId.value,
|
||
isHeadquarters: false,
|
||
}
|
||
: null,
|
||
parentCommunity: parentCommunityAuth
|
||
? {
|
||
authorizationId: parentCommunityAuth.authorizationId.value,
|
||
accountSequence: parentCommunityAuth.userId.accountSequence,
|
||
communityName: parentCommunityAuth.displayTitle,
|
||
userId: parentCommunityAuth.userId.value,
|
||
isHeadquarters: false,
|
||
}
|
||
: HEADQUARTERS_COMMUNITY,
|
||
childCommunities: childCommunityAuths.map((auth) => ({
|
||
authorizationId: auth.authorizationId.value,
|
||
accountSequence: auth.userId.accountSequence,
|
||
communityName: auth.displayTitle,
|
||
userId: auth.userId.value,
|
||
isHeadquarters: false,
|
||
})),
|
||
hasParentCommunity: parentCommunityAuth !== null,
|
||
childCommunityCount: childCommunityAuths.length,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查找用户推荐链中最近的社区授权用户
|
||
* 用于 reward-service 分配社区权益
|
||
* @returns accountSequence of nearest community authorization holder, or null
|
||
*/
|
||
async findNearestAuthorizedCommunity(accountSequence: string): Promise<string | null> {
|
||
this.logger.debug(`[findNearestAuthorizedCommunity] accountSequence=${accountSequence}`)
|
||
|
||
// 获取用户的祖先链（推荐链）
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
|
||
if (ancestorAccountSequences.length === 0) {
|
||
return null
|
||
}
|
||
|
||
// 在祖先链中找最近的有社区授权的用户
|
||
const ancestorCommunities = await this.authorizationRepository.findActiveCommunityByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
if (ancestorCommunities.length === 0) {
|
||
return null
|
||
}
|
||
|
||
// 按祖先链顺序找第一个匹配的
|
||
for (const ancestorSeq of ancestorAccountSequences) {
|
||
const found = ancestorCommunities.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq,
|
||
)
|
||
if (found) {
|
||
return found.userId.accountSequence
|
||
}
|
||
}
|
||
|
||
return null
|
||
}
|
||
|
||
/**
|
||
* 查找用户推荐链中最近的省公司授权用户（匹配指定省份）
|
||
* 用于 reward-service 分配省团队权益
|
||
* @returns accountSequence of nearest province authorization holder, or null
|
||
*/
|
||
async findNearestAuthorizedProvince(
|
||
accountSequence: string,
|
||
provinceCode: string,
|
||
): Promise<string | null> {
|
||
this.logger.debug(
|
||
`[findNearestAuthorizedProvince] accountSequence=${accountSequence}, provinceCode=${provinceCode}`,
|
||
)
|
||
|
||
// 获取用户的祖先链（推荐链）
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
|
||
if (ancestorAccountSequences.length === 0) {
|
||
return null
|
||
}
|
||
|
||
// 在祖先链中找最近的有省公司授权且匹配省份代码的用户
|
||
const ancestorProvinces = await this.authorizationRepository.findActiveProvinceByAccountSequencesAndRegion(
|
||
ancestorAccountSequences,
|
||
provinceCode,
|
||
)
|
||
|
||
if (ancestorProvinces.length === 0) {
|
||
return null
|
||
}
|
||
|
||
// 按祖先链顺序找第一个匹配的
|
||
for (const ancestorSeq of ancestorAccountSequences) {
|
||
const found = ancestorProvinces.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq,
|
||
)
|
||
if (found) {
|
||
return found.userId.accountSequence
|
||
}
|
||
}
|
||
|
||
return null
|
||
}
|
||
|
||
/**
|
||
* 查找用户推荐链中最近的市公司授权用户（匹配指定城市）
|
||
* 用于 reward-service 分配市团队权益
|
||
* @returns accountSequence of nearest city authorization holder, or null
|
||
*/
|
||
async findNearestAuthorizedCity(
|
||
accountSequence: string,
|
||
cityCode: string,
|
||
): Promise<string | null> {
|
||
this.logger.debug(
|
||
`[findNearestAuthorizedCity] accountSequence=${accountSequence}, cityCode=${cityCode}`,
|
||
)
|
||
|
||
// 获取用户的祖先链（推荐链）
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
|
||
if (ancestorAccountSequences.length === 0) {
|
||
return null
|
||
}
|
||
|
||
// 在祖先链中找最近的有市公司授权且匹配城市代码的用户
|
||
const ancestorCities = await this.authorizationRepository.findActiveCityByAccountSequencesAndRegion(
|
||
ancestorAccountSequences,
|
||
cityCode,
|
||
)
|
||
|
||
if (ancestorCities.length === 0) {
|
||
return null
|
||
}
|
||
|
||
// 按祖先链顺序找第一个匹配的
|
||
for (const ancestorSeq of ancestorAccountSequences) {
|
||
const found = ancestorCities.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq,
|
||
)
|
||
if (found) {
|
||
return found.userId.accountSequence
|
||
}
|
||
}
|
||
|
||
return null
|
||
}
|
||
|
||
/**
|
||
* 检查用户是否已认种至少一棵树
|
||
* 授权前置条件：用户必须先认种才能被授权任何角色
|
||
*/
|
||
private async ensureUserHasPlanted(accountSequence: string): Promise<void> {
|
||
const teamStats = await this.referralServiceClient.findByAccountSequence(accountSequence)
|
||
const selfPlantingCount = teamStats?.selfPlantingCount || 0
|
||
|
||
if (selfPlantingCount < 1) {
|
||
throw new ApplicationError(
|
||
`用户 ${accountSequence} 尚未认种任何树，无法授权。请先至少认种1棵树后再进行授权操作。`,
|
||
)
|
||
}
|
||
|
||
this.logger.debug(
|
||
`[ensureUserHasPlanted] User ${accountSequence} has planted ${selfPlantingCount} tree(s), authorization allowed`,
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 尝试激活授权权益
|
||
* 仅当权益未激活时执行激活操作
|
||
*
|
||
* 对于社区权益：需要级联激活推荐链上所有父级社区
|
||
*/
|
||
private async tryActivateBenefit(authorization: AuthorizationRole): Promise<void> {
|
||
if (authorization.benefitActive) {
|
||
return // 已激活，无需操作
|
||
}
|
||
|
||
this.logger.log(
|
||
`[tryActivateBenefit] Activating benefit for authorization ${authorization.authorizationId.value}, ` +
|
||
`role=${authorization.roleType}, accountSequence=${authorization.userId.accountSequence}`,
|
||
)
|
||
|
||
authorization.activateBenefit()
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
|
||
// 如果是社区权益，需要级联激活上级社区
|
||
if (authorization.roleType === RoleType.COMMUNITY) {
|
||
await this.cascadeActivateParentCommunities(authorization.userId.accountSequence)
|
||
}
|
||
|
||
// 如果是市团队授权权益，需要级联激活上级市团队授权
|
||
if (authorization.roleType === RoleType.AUTH_CITY_COMPANY) {
|
||
await this.cascadeActivateParentAuthCities(authorization.userId.accountSequence)
|
||
}
|
||
|
||
// 如果是省团队授权权益，需要级联激活上级省团队授权
|
||
if (authorization.roleType === RoleType.AUTH_PROVINCE_COMPANY) {
|
||
await this.cascadeActivateParentAuthProvinces(authorization.userId.accountSequence)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 级联激活上级社区权益
|
||
* 当一个社区的权益被激活时，需要同时激活推荐链上所有父级社区的权益
|
||
*
|
||
* 业务规则：
|
||
* - 从当前社区往上找，找到所有已授权但权益未激活的社区
|
||
* - 将它们的权益都激活
|
||
* - 总部社区不需要考核，不在此处理
|
||
*/
|
||
private async cascadeActivateParentCommunities(accountSequence: string): Promise<void> {
|
||
this.logger.log(
|
||
`[cascadeActivateParentCommunities] Starting cascade activation for communities above ${accountSequence}`,
|
||
)
|
||
|
||
// 1. 获取推荐链（不包括当前用户）
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
if (ancestorAccountSequences.length === 0) {
|
||
return
|
||
}
|
||
|
||
// 2. 查找推荐链上所有社区授权（包括 benefitActive=false）
|
||
const ancestorCommunities = await this.authorizationRepository.findCommunityByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
// 3. 筛选出已授权但权益未激活的社区
|
||
const inactiveCommunities = ancestorCommunities.filter(
|
||
(auth) => auth.status === AuthorizationStatus.AUTHORIZED && !auth.benefitActive,
|
||
)
|
||
|
||
if (inactiveCommunities.length === 0) {
|
||
this.logger.debug('[cascadeActivateParentCommunities] No inactive parent communities to activate')
|
||
return
|
||
}
|
||
|
||
// 4. 激活这些社区的权益
|
||
for (const community of inactiveCommunities) {
|
||
this.logger.log(
|
||
`[cascadeActivateParentCommunities] Cascade activating community benefit: ` +
|
||
`authorizationId=${community.authorizationId.value}, accountSequence=${community.userId.accountSequence}`,
|
||
)
|
||
|
||
community.activateBenefit()
|
||
await this.authorizationRepository.save(community)
|
||
await this.eventPublisher.publishAll(community.domainEvents)
|
||
community.clearDomainEvents()
|
||
}
|
||
|
||
this.logger.log(
|
||
`[cascadeActivateParentCommunities] Cascade activated ${inactiveCommunities.length} parent communities`,
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 级联停用社区权益
|
||
* 当一个社区的月度考核失败时，需要停用该社区及其推荐链上所有父级社区的权益
|
||
*
|
||
* 业务规则：
|
||
* - 从当前社区开始，往上找到所有已授权且权益已激活的社区
|
||
* - 将它们的权益都停用，重新开始10棵树的初始考核
|
||
* - 总部社区不受影响
|
||
*
|
||
* @param accountSequence 月度考核失败的社区的 accountSequence
|
||
* @param reason 停用原因
|
||
*/
|
||
async cascadeDeactivateCommunityBenefits(
|
||
accountSequence: string,
|
||
reason: string,
|
||
): Promise<{ deactivatedCount: number }> {
|
||
this.logger.log(
|
||
`[cascadeDeactivateCommunityBenefits] Starting cascade deactivation from ${accountSequence}, reason=${reason}`,
|
||
)
|
||
|
||
// 1. 获取当前社区的授权
|
||
const currentCommunity = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
accountSequence,
|
||
RoleType.COMMUNITY,
|
||
)
|
||
|
||
if (!currentCommunity) {
|
||
this.logger.warn(`[cascadeDeactivateCommunityBenefits] Community not found for ${accountSequence}`)
|
||
return { deactivatedCount: 0 }
|
||
}
|
||
|
||
// 2. 收集需要停用的社区列表
|
||
const communitiesToDeactivate: AuthorizationRole[] = []
|
||
|
||
// 如果当前社区权益已激活，加入停用列表
|
||
if (currentCommunity.benefitActive) {
|
||
communitiesToDeactivate.push(currentCommunity)
|
||
}
|
||
|
||
// 3. 获取推荐链上的所有父级社区
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
if (ancestorAccountSequences.length > 0) {
|
||
const ancestorCommunities = await this.authorizationRepository.findCommunityByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
// 筛选出已授权且权益已激活的社区
|
||
const activeCommunities = ancestorCommunities.filter(
|
||
(auth) => auth.status === AuthorizationStatus.AUTHORIZED && auth.benefitActive,
|
||
)
|
||
|
||
communitiesToDeactivate.push(...activeCommunities)
|
||
}
|
||
|
||
if (communitiesToDeactivate.length === 0) {
|
||
this.logger.debug('[cascadeDeactivateCommunityBenefits] No active communities to deactivate')
|
||
return { deactivatedCount: 0 }
|
||
}
|
||
|
||
// 4. 停用这些社区的权益
|
||
for (const community of communitiesToDeactivate) {
|
||
this.logger.log(
|
||
`[cascadeDeactivateCommunityBenefits] Deactivating community benefit: ` +
|
||
`authorizationId=${community.authorizationId.value}, accountSequence=${community.userId.accountSequence}`,
|
||
)
|
||
|
||
community.deactivateBenefit(reason)
|
||
await this.authorizationRepository.save(community)
|
||
await this.eventPublisher.publishAll(community.domainEvents)
|
||
community.clearDomainEvents()
|
||
}
|
||
|
||
this.logger.log(
|
||
`[cascadeDeactivateCommunityBenefits] Cascade deactivated ${communitiesToDeactivate.length} communities`,
|
||
)
|
||
|
||
return { deactivatedCount: communitiesToDeactivate.length }
|
||
}
|
||
|
||
/**
|
||
* 级联激活上级市团队授权权益
|
||
* 当一个市团队授权的权益被激活时，需要同时激活推荐链上所有父级市团队授权的权益
|
||
*
|
||
* 业务规则：
|
||
* - 从当前市团队授权往上找，找到所有已授权但权益未激活的市团队授权
|
||
* - 将它们的权益都激活
|
||
* - 系统账户不需要考核，不在此处理
|
||
*/
|
||
private async cascadeActivateParentAuthCities(accountSequence: string): Promise<void> {
|
||
this.logger.log(
|
||
`[cascadeActivateParentAuthCities] Starting cascade activation for auth cities above ${accountSequence}`,
|
||
)
|
||
|
||
// 1. 获取推荐链（不包括当前用户）
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
if (ancestorAccountSequences.length === 0) {
|
||
return
|
||
}
|
||
|
||
// 2. 查找推荐链上所有市团队授权（包括 benefitActive=false）
|
||
const ancestorAuthCities = await this.authorizationRepository.findAuthCityByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
// 3. 筛选出已授权但权益未激活的市团队授权
|
||
const inactiveAuthCities = ancestorAuthCities.filter(
|
||
(auth) => auth.status === AuthorizationStatus.AUTHORIZED && !auth.benefitActive,
|
||
)
|
||
|
||
if (inactiveAuthCities.length === 0) {
|
||
this.logger.debug('[cascadeActivateParentAuthCities] No inactive parent auth cities to activate')
|
||
return
|
||
}
|
||
|
||
// 4. 激活这些市团队授权的权益
|
||
for (const authCity of inactiveAuthCities) {
|
||
this.logger.log(
|
||
`[cascadeActivateParentAuthCities] Cascade activating auth city benefit: ` +
|
||
`authorizationId=${authCity.authorizationId.value}, accountSequence=${authCity.userId.accountSequence}`,
|
||
)
|
||
|
||
authCity.activateBenefit()
|
||
await this.authorizationRepository.save(authCity)
|
||
await this.eventPublisher.publishAll(authCity.domainEvents)
|
||
authCity.clearDomainEvents()
|
||
}
|
||
|
||
this.logger.log(
|
||
`[cascadeActivateParentAuthCities] Cascade activated ${inactiveAuthCities.length} parent auth cities`,
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 级联停用市团队授权权益
|
||
* 当一个市团队授权的月度考核失败时，需要停用该市团队授权及其推荐链上所有父级市团队授权的权益
|
||
*
|
||
* 业务规则：
|
||
* - 从当前市团队授权开始，往上找到所有已授权且权益已激活的市团队授权
|
||
* - 将它们的权益都停用，重新开始100棵树的初始考核
|
||
*/
|
||
async cascadeDeactivateAuthCityBenefits(
|
||
accountSequence: string,
|
||
reason: string,
|
||
): Promise<{ deactivatedCount: number }> {
|
||
this.logger.log(
|
||
`[cascadeDeactivateAuthCityBenefits] Starting cascade deactivation from ${accountSequence}, reason=${reason}`,
|
||
)
|
||
|
||
// 1. 获取当前市团队授权
|
||
const currentAuthCity = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
accountSequence,
|
||
RoleType.AUTH_CITY_COMPANY,
|
||
)
|
||
|
||
if (!currentAuthCity) {
|
||
this.logger.warn(`[cascadeDeactivateAuthCityBenefits] Auth city not found for ${accountSequence}`)
|
||
return { deactivatedCount: 0 }
|
||
}
|
||
|
||
// 2. 收集需要停用的市团队授权列表
|
||
const authCitiesToDeactivate: AuthorizationRole[] = []
|
||
|
||
// 如果当前市团队授权权益已激活，加入停用列表
|
||
if (currentAuthCity.benefitActive) {
|
||
authCitiesToDeactivate.push(currentAuthCity)
|
||
}
|
||
|
||
// 3. 获取推荐链上的所有父级市团队授权
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
if (ancestorAccountSequences.length > 0) {
|
||
const ancestorAuthCities = await this.authorizationRepository.findAuthCityByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
// 筛选出已授权且权益已激活的市团队授权
|
||
const activeAuthCities = ancestorAuthCities.filter(
|
||
(auth) => auth.status === AuthorizationStatus.AUTHORIZED && auth.benefitActive,
|
||
)
|
||
|
||
authCitiesToDeactivate.push(...activeAuthCities)
|
||
}
|
||
|
||
if (authCitiesToDeactivate.length === 0) {
|
||
this.logger.debug('[cascadeDeactivateAuthCityBenefits] No active auth cities to deactivate')
|
||
return { deactivatedCount: 0 }
|
||
}
|
||
|
||
// 4. 停用这些市团队授权的权益
|
||
for (const authCity of authCitiesToDeactivate) {
|
||
this.logger.log(
|
||
`[cascadeDeactivateAuthCityBenefits] Deactivating auth city benefit: ` +
|
||
`authorizationId=${authCity.authorizationId.value}, accountSequence=${authCity.userId.accountSequence}`,
|
||
)
|
||
|
||
authCity.deactivateBenefit(reason)
|
||
await this.authorizationRepository.save(authCity)
|
||
await this.eventPublisher.publishAll(authCity.domainEvents)
|
||
authCity.clearDomainEvents()
|
||
}
|
||
|
||
this.logger.log(
|
||
`[cascadeDeactivateAuthCityBenefits] Cascade deactivated ${authCitiesToDeactivate.length} auth cities`,
|
||
)
|
||
|
||
return { deactivatedCount: authCitiesToDeactivate.length }
|
||
}
|
||
|
||
/**
|
||
* 处理过期的市团队授权权益
|
||
* 定时任务调用此方法来检查并处理过期的市团队授权权益
|
||
*
|
||
* 业务规则：
|
||
* - 查找所有 benefitValidUntil < 当前时间 且 benefitActive=true 的市团队授权
|
||
* - 检查其月度考核（当月新增100棵树）
|
||
* - 如果达标，续期；如果不达标，级联停用
|
||
*
|
||
* @param limit 每次处理的最大数量
|
||
*/
|
||
async processExpiredAuthCityBenefits(limit = 100): Promise<{
|
||
processedCount: number
|
||
renewedCount: number
|
||
deactivatedCount: number
|
||
}> {
|
||
const now = new Date()
|
||
this.logger.log(`[processExpiredAuthCityBenefits] Starting at ${now.toISOString()}, limit=${limit}`)
|
||
|
||
// 查找过期但仍激活的市团队授权
|
||
const expiredAuthCities = await this.findExpiredActiveAuthCities(now, limit)
|
||
|
||
if (expiredAuthCities.length === 0) {
|
||
this.logger.debug('[processExpiredAuthCityBenefits] No expired auth cities found')
|
||
return { processedCount: 0, renewedCount: 0, deactivatedCount: 0 }
|
||
}
|
||
|
||
let renewedCount = 0
|
||
let deactivatedCount = 0
|
||
|
||
for (const authCity of expiredAuthCities) {
|
||
const accountSequence = authCity.userId.accountSequence
|
||
|
||
// 使用 getTreesForAssessment 获取正确的考核数据
|
||
const treesForAssessment = authCity.getTreesForAssessment(now)
|
||
|
||
this.logger.debug(
|
||
`[processExpiredAuthCityBenefits] Checking auth city ${accountSequence}: ` +
|
||
`treesForAssessment=${treesForAssessment}, ` +
|
||
`monthlyTreesAdded=${authCity.monthlyTreesAdded}, ` +
|
||
`lastMonthTreesAdded=${authCity.lastMonthTreesAdded}, ` +
|
||
`benefitValidUntil=${authCity.benefitValidUntil?.toISOString()}, target=100`,
|
||
)
|
||
|
||
if (treesForAssessment >= 100) {
|
||
// 达标，续期
|
||
authCity.renewBenefit(treesForAssessment)
|
||
await this.authorizationRepository.save(authCity)
|
||
renewedCount++
|
||
|
||
this.logger.log(
|
||
`[processExpiredAuthCityBenefits] Auth city ${accountSequence} renewed, ` +
|
||
`trees=${treesForAssessment}, new validUntil=${authCity.benefitValidUntil?.toISOString()}`,
|
||
)
|
||
} else {
|
||
// 不达标，级联停用
|
||
const result = await this.cascadeDeactivateAuthCityBenefits(
|
||
accountSequence,
|
||
`月度考核不达标：考核期内新增${treesForAssessment}棵，未达到100棵目标`,
|
||
)
|
||
deactivatedCount += result.deactivatedCount
|
||
}
|
||
}
|
||
|
||
this.logger.log(
|
||
`[processExpiredAuthCityBenefits] Completed: processed=${expiredAuthCities.length}, ` +
|
||
`renewed=${renewedCount}, deactivated=${deactivatedCount}`,
|
||
)
|
||
|
||
return {
|
||
processedCount: expiredAuthCities.length,
|
||
renewedCount,
|
||
deactivatedCount,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查找过期但仍激活的市团队授权
|
||
*/
|
||
private async findExpiredActiveAuthCities(
|
||
checkDate: Date,
|
||
limit: number,
|
||
): Promise<AuthorizationRole[]> {
|
||
return this.authorizationRepository.findExpiredActiveByRoleType(
|
||
RoleType.AUTH_CITY_COMPANY,
|
||
checkDate,
|
||
limit,
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 级联激活上级省团队授权权益
|
||
* 当一个省团队授权的权益被激活时，需要同时激活推荐链上所有父级省团队授权的权益
|
||
*
|
||
* 业务规则：
|
||
* - 从当前省团队授权往上找，找到所有已授权但权益未激活的省团队授权
|
||
* - 将它们的权益都激活
|
||
* - 系统账户不需要考核，不在此处理
|
||
*/
|
||
private async cascadeActivateParentAuthProvinces(accountSequence: string): Promise<void> {
|
||
this.logger.log(
|
||
`[cascadeActivateParentAuthProvinces] Starting cascade activation for auth provinces above ${accountSequence}`,
|
||
)
|
||
|
||
// 1. 获取推荐链（不包括当前用户）
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
if (ancestorAccountSequences.length === 0) {
|
||
return
|
||
}
|
||
|
||
// 2. 查找推荐链上所有省团队授权（包括 benefitActive=false）
|
||
const ancestorAuthProvinces = await this.authorizationRepository.findAuthProvinceByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
// 3. 筛选出已授权但权益未激活的省团队授权
|
||
const inactiveAuthProvinces = ancestorAuthProvinces.filter(
|
||
(auth) => auth.status === AuthorizationStatus.AUTHORIZED && !auth.benefitActive,
|
||
)
|
||
|
||
if (inactiveAuthProvinces.length === 0) {
|
||
this.logger.debug('[cascadeActivateParentAuthProvinces] No inactive parent auth provinces to activate')
|
||
return
|
||
}
|
||
|
||
// 4. 激活这些省团队授权的权益
|
||
for (const authProvince of inactiveAuthProvinces) {
|
||
this.logger.log(
|
||
`[cascadeActivateParentAuthProvinces] Cascade activating auth province benefit: ` +
|
||
`authorizationId=${authProvince.authorizationId.value}, accountSequence=${authProvince.userId.accountSequence}`,
|
||
)
|
||
|
||
authProvince.activateBenefit()
|
||
await this.authorizationRepository.save(authProvince)
|
||
await this.eventPublisher.publishAll(authProvince.domainEvents)
|
||
authProvince.clearDomainEvents()
|
||
}
|
||
|
||
this.logger.log(
|
||
`[cascadeActivateParentAuthProvinces] Cascade activated ${inactiveAuthProvinces.length} parent auth provinces`,
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 级联停用省团队授权权益
|
||
* 当一个省团队授权的月度考核失败时，需要停用该省团队授权及其推荐链上所有父级省团队授权的权益
|
||
*
|
||
* 业务规则：
|
||
* - 从当前省团队授权开始，往上找到所有已授权且权益已激活的省团队授权
|
||
* - 将它们的权益都停用，重新开始500棵树的初始考核
|
||
*/
|
||
async cascadeDeactivateAuthProvinceBenefits(
|
||
accountSequence: string,
|
||
reason: string,
|
||
): Promise<{ deactivatedCount: number }> {
|
||
this.logger.log(
|
||
`[cascadeDeactivateAuthProvinceBenefits] Starting cascade deactivation from ${accountSequence}, reason=${reason}`,
|
||
)
|
||
|
||
// 1. 获取当前省团队授权
|
||
const currentAuthProvince = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
accountSequence,
|
||
RoleType.AUTH_PROVINCE_COMPANY,
|
||
)
|
||
|
||
if (!currentAuthProvince) {
|
||
this.logger.warn(`[cascadeDeactivateAuthProvinceBenefits] Auth province not found for ${accountSequence}`)
|
||
return { deactivatedCount: 0 }
|
||
}
|
||
|
||
// 2. 收集需要停用的省团队授权列表
|
||
const authProvincesToDeactivate: AuthorizationRole[] = []
|
||
|
||
// 如果当前省团队授权权益已激活，加入停用列表
|
||
if (currentAuthProvince.benefitActive) {
|
||
authProvincesToDeactivate.push(currentAuthProvince)
|
||
}
|
||
|
||
// 3. 获取推荐链上的所有父级省团队授权
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
if (ancestorAccountSequences.length > 0) {
|
||
const ancestorAuthProvinces = await this.authorizationRepository.findAuthProvinceByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
// 筛选出已授权且权益已激活的省团队授权
|
||
const activeAuthProvinces = ancestorAuthProvinces.filter(
|
||
(auth) => auth.status === AuthorizationStatus.AUTHORIZED && auth.benefitActive,
|
||
)
|
||
|
||
authProvincesToDeactivate.push(...activeAuthProvinces)
|
||
}
|
||
|
||
if (authProvincesToDeactivate.length === 0) {
|
||
this.logger.debug('[cascadeDeactivateAuthProvinceBenefits] No active auth provinces to deactivate')
|
||
return { deactivatedCount: 0 }
|
||
}
|
||
|
||
// 4. 停用这些省团队授权的权益
|
||
for (const authProvince of authProvincesToDeactivate) {
|
||
this.logger.log(
|
||
`[cascadeDeactivateAuthProvinceBenefits] Deactivating auth province benefit: ` +
|
||
`authorizationId=${authProvince.authorizationId.value}, accountSequence=${authProvince.userId.accountSequence}`,
|
||
)
|
||
|
||
authProvince.deactivateBenefit(reason)
|
||
await this.authorizationRepository.save(authProvince)
|
||
await this.eventPublisher.publishAll(authProvince.domainEvents)
|
||
authProvince.clearDomainEvents()
|
||
}
|
||
|
||
this.logger.log(
|
||
`[cascadeDeactivateAuthProvinceBenefits] Cascade deactivated ${authProvincesToDeactivate.length} auth provinces`,
|
||
)
|
||
|
||
return { deactivatedCount: authProvincesToDeactivate.length }
|
||
}
|
||
|
||
/**
|
||
* 处理过期的省团队授权权益
|
||
* 定时任务调用此方法来检查并处理过期的省团队授权权益
|
||
*
|
||
* 业务规则：
|
||
* - 查找所有 benefitValidUntil < 当前时间 且 benefitActive=true 的省团队授权
|
||
* - 检查其月度考核（当月新增500棵树）
|
||
* - 如果达标，续期；如果不达标，级联停用
|
||
*
|
||
* @param limit 每次处理的最大数量
|
||
*/
|
||
async processExpiredAuthProvinceBenefits(limit = 100): Promise<{
|
||
processedCount: number
|
||
renewedCount: number
|
||
deactivatedCount: number
|
||
}> {
|
||
const now = new Date()
|
||
this.logger.log(`[processExpiredAuthProvinceBenefits] Starting at ${now.toISOString()}, limit=${limit}`)
|
||
|
||
// 查找过期但仍激活的省团队授权
|
||
const expiredAuthProvinces = await this.findExpiredActiveAuthProvinces(now, limit)
|
||
|
||
if (expiredAuthProvinces.length === 0) {
|
||
this.logger.debug('[processExpiredAuthProvinceBenefits] No expired auth provinces found')
|
||
return { processedCount: 0, renewedCount: 0, deactivatedCount: 0 }
|
||
}
|
||
|
||
let renewedCount = 0
|
||
let deactivatedCount = 0
|
||
|
||
for (const authProvince of expiredAuthProvinces) {
|
||
const accountSequence = authProvince.userId.accountSequence
|
||
|
||
// 使用 getTreesForAssessment 获取正确的考核数据
|
||
const treesForAssessment = authProvince.getTreesForAssessment(now)
|
||
|
||
this.logger.debug(
|
||
`[processExpiredAuthProvinceBenefits] Checking auth province ${accountSequence}: ` +
|
||
`treesForAssessment=${treesForAssessment}, ` +
|
||
`monthlyTreesAdded=${authProvince.monthlyTreesAdded}, ` +
|
||
`lastMonthTreesAdded=${authProvince.lastMonthTreesAdded}, ` +
|
||
`benefitValidUntil=${authProvince.benefitValidUntil?.toISOString()}, target=500`,
|
||
)
|
||
|
||
if (treesForAssessment >= 500) {
|
||
// 达标，续期
|
||
authProvince.renewBenefit(treesForAssessment)
|
||
await this.authorizationRepository.save(authProvince)
|
||
renewedCount++
|
||
|
||
this.logger.log(
|
||
`[processExpiredAuthProvinceBenefits] Auth province ${accountSequence} renewed, ` +
|
||
`trees=${treesForAssessment}, new validUntil=${authProvince.benefitValidUntil?.toISOString()}`,
|
||
)
|
||
} else {
|
||
// 不达标，级联停用
|
||
const result = await this.cascadeDeactivateAuthProvinceBenefits(
|
||
accountSequence,
|
||
`月度考核不达标：考核期内新增${treesForAssessment}棵，未达到500棵目标`,
|
||
)
|
||
deactivatedCount += result.deactivatedCount
|
||
}
|
||
}
|
||
|
||
this.logger.log(
|
||
`[processExpiredAuthProvinceBenefits] Completed: processed=${expiredAuthProvinces.length}, ` +
|
||
`renewed=${renewedCount}, deactivated=${deactivatedCount}`,
|
||
)
|
||
|
||
return {
|
||
processedCount: expiredAuthProvinces.length,
|
||
renewedCount,
|
||
deactivatedCount,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查找过期但仍激活的省团队授权
|
||
*/
|
||
private async findExpiredActiveAuthProvinces(
|
||
checkDate: Date,
|
||
limit: number,
|
||
): Promise<AuthorizationRole[]> {
|
||
return this.authorizationRepository.findExpiredActiveByRoleType(
|
||
RoleType.AUTH_PROVINCE_COMPANY,
|
||
checkDate,
|
||
limit,
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 处理过期的社区权益
|
||
* 定时任务调用此方法来检查并处理过期的社区权益
|
||
*
|
||
* 业务规则：
|
||
* - 查找所有 benefitValidUntil < 当前时间 且 benefitActive=true 的社区
|
||
* - 检查其月度考核（当月新增10棵树）
|
||
* - 如果达标，续期；如果不达标，级联停用
|
||
*
|
||
* @param limit 每次处理的最大数量
|
||
*/
|
||
async processExpiredCommunityBenefits(limit = 100): Promise<{
|
||
processedCount: number
|
||
renewedCount: number
|
||
deactivatedCount: number
|
||
}> {
|
||
const now = new Date()
|
||
this.logger.log(`[processExpiredCommunityBenefits] Starting at ${now.toISOString()}, limit=${limit}`)
|
||
|
||
// 查找过期但仍激活的社区
|
||
// 需要在 repository 中添加此查询方法
|
||
const expiredCommunities = await this.findExpiredActiveCommunities(now, limit)
|
||
|
||
if (expiredCommunities.length === 0) {
|
||
this.logger.debug('[processExpiredCommunityBenefits] No expired communities found')
|
||
return { processedCount: 0, renewedCount: 0, deactivatedCount: 0 }
|
||
}
|
||
|
||
let renewedCount = 0
|
||
let deactivatedCount = 0
|
||
|
||
for (const community of expiredCommunities) {
|
||
const accountSequence = community.userId.accountSequence
|
||
|
||
// 使用 getTreesForAssessment 获取正确的考核数据
|
||
// - 有效期在上月末 → 用 lastMonthTreesAdded（存档数据）
|
||
// - 有效期在当月末 → 用 monthlyTreesAdded（当月数据）
|
||
const treesForAssessment = community.getTreesForAssessment(now)
|
||
|
||
this.logger.debug(
|
||
`[processExpiredCommunityBenefits] Checking community ${accountSequence}: ` +
|
||
`treesForAssessment=${treesForAssessment}, ` +
|
||
`monthlyTreesAdded=${community.monthlyTreesAdded}, ` +
|
||
`lastMonthTreesAdded=${community.lastMonthTreesAdded}, ` +
|
||
`benefitValidUntil=${community.benefitValidUntil?.toISOString()}, target=10`,
|
||
)
|
||
|
||
if (treesForAssessment >= 10) {
|
||
// 达标，续期
|
||
community.renewBenefit(treesForAssessment)
|
||
await this.authorizationRepository.save(community)
|
||
renewedCount++
|
||
|
||
this.logger.log(
|
||
`[processExpiredCommunityBenefits] Community ${accountSequence} renewed, ` +
|
||
`trees=${treesForAssessment}, new validUntil=${community.benefitValidUntil?.toISOString()}`,
|
||
)
|
||
} else {
|
||
// 不达标，级联停用
|
||
const result = await this.cascadeDeactivateCommunityBenefits(
|
||
accountSequence,
|
||
`月度考核不达标：考核期内新增${treesForAssessment}棵，未达到10棵目标`,
|
||
)
|
||
deactivatedCount += result.deactivatedCount
|
||
}
|
||
}
|
||
|
||
this.logger.log(
|
||
`[processExpiredCommunityBenefits] Completed: processed=${expiredCommunities.length}, ` +
|
||
`renewed=${renewedCount}, deactivated=${deactivatedCount}`,
|
||
)
|
||
|
||
return {
|
||
processedCount: expiredCommunities.length,
|
||
renewedCount,
|
||
deactivatedCount,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查找过期但仍激活的社区
|
||
* TODO: 后续优化可以移到 repository 层
|
||
*/
|
||
private async findExpiredActiveCommunities(now: Date, limit: number): Promise<AuthorizationRole[]> {
|
||
// 获取所有激活的社区授权
|
||
const activeCommunities = await this.authorizationRepository.findAllActive(RoleType.COMMUNITY)
|
||
|
||
// 筛选出已过期的
|
||
return activeCommunities
|
||
.filter((auth) => auth.benefitActive && auth.isBenefitExpired(now))
|
||
.slice(0, limit)
|
||
}
|
||
|
||
/**
|
||
* 获取社区权益分配方案
|
||
* 根据考核规则计算每棵树的社区权益应该分配给谁
|
||
*
|
||
* 规则：
|
||
* 1. 找到认种用户推荐链上最近的社区
|
||
* 2. 如果该社区 benefitActive=true，全部权益给该社区
|
||
* 3. 如果该社区 benefitActive=false：
|
||
* - 计算该社区还需要多少棵才能达到初始考核(10棵)
|
||
* - 考核前的部分给上级社区或总部
|
||
* - 考核后的部分给该社区（同时激活权益）
|
||
* 4. 如果没有社区，全部给总部
|
||
*/
|
||
async getCommunityRewardDistribution(
|
||
accountSequence: string,
|
||
treeCount: number,
|
||
): Promise<{
|
||
distributions: Array<{
|
||
accountSequence: string
|
||
treeCount: number
|
||
reason: string
|
||
}>
|
||
}> {
|
||
this.logger.debug(
|
||
`[getCommunityRewardDistribution] accountSequence=${accountSequence}, treeCount=${treeCount}`,
|
||
)
|
||
|
||
const HEADQUARTERS_ACCOUNT_SEQUENCE = '1' // 总部社区账号
|
||
|
||
// 1. 获取用户的祖先链（推荐链）
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
|
||
if (ancestorAccountSequences.length === 0) {
|
||
// 无推荐链，全部给总部
|
||
return {
|
||
distributions: [
|
||
{
|
||
accountSequence: HEADQUARTERS_ACCOUNT_SEQUENCE,
|
||
treeCount,
|
||
reason: '无推荐链，进总部社区',
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
// 2. 查找祖先链中所有社区授权（包括 benefitActive=false 的）
|
||
const ancestorCommunities = await this.authorizationRepository.findCommunityByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
if (ancestorCommunities.length === 0) {
|
||
// 推荐链上没有社区，全部给总部
|
||
return {
|
||
distributions: [
|
||
{
|
||
accountSequence: HEADQUARTERS_ACCOUNT_SEQUENCE,
|
||
treeCount,
|
||
reason: '推荐链上无社区授权，进总部社区',
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
// 3. 按祖先链顺序找最近的社区
|
||
let nearestCommunity: typeof ancestorCommunities[0] | null = null
|
||
let nearestCommunityIndex = -1
|
||
|
||
for (let i = 0; i < ancestorAccountSequences.length; i++) {
|
||
const ancestorSeq = ancestorAccountSequences[i]
|
||
const found = ancestorCommunities.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq,
|
||
)
|
||
if (found) {
|
||
nearestCommunity = found
|
||
nearestCommunityIndex = i
|
||
break
|
||
}
|
||
}
|
||
|
||
if (!nearestCommunity) {
|
||
// 这种情况理论上不应该发生，但作为兜底
|
||
return {
|
||
distributions: [
|
||
{
|
||
accountSequence: HEADQUARTERS_ACCOUNT_SEQUENCE,
|
||
treeCount,
|
||
reason: '未找到匹配的社区，进总部社区',
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
// 4. 检查最近社区的权益状态
|
||
if (nearestCommunity.benefitActive) {
|
||
// 权益已激活，全部给该社区
|
||
// 累加月度新增树数（用于月度考核）
|
||
nearestCommunity.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(nearestCommunity)
|
||
|
||
return {
|
||
distributions: [
|
||
{
|
||
accountSequence: nearestCommunity.userId.accountSequence,
|
||
treeCount,
|
||
reason: '社区权益已激活',
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
// 5. 权益未激活，需要计算考核分配
|
||
// 获取该社区的团队统计数据 - 使用下级团队认种数（不含自己）
|
||
const communityStats = await this.statsRepository.findByAccountSequence(
|
||
nearestCommunity.userId.accountSequence,
|
||
)
|
||
const rawSubordinateCount = communityStats?.subordinateTeamPlantingCount ?? 0
|
||
|
||
// 重要：由于 referral-service 和 reward-service 都消费同一个 Kafka 事件，
|
||
// 存在竞态条件，此时查询到的 subordinateTeamPlantingCount 可能已经包含了本次认种。
|
||
// 因此需要减去本次认种数量来还原"认种前"的下级团队数。
|
||
// 注意：如果 referral-service 还没处理完，rawSubordinateCount 可能还是旧值，
|
||
// 此时 currentTeamCount 可能为负数，需要取 max(0, ...)
|
||
const currentTeamCount = Math.max(0, rawSubordinateCount - treeCount)
|
||
const initialTarget = nearestCommunity.getInitialTarget() // 社区初始考核目标：10棵
|
||
|
||
this.logger.debug(
|
||
`[getCommunityRewardDistribution] Community ${nearestCommunity.userId.accountSequence} ` +
|
||
`benefitActive=false, rawSubordinateCount=${rawSubordinateCount}, treeCount=${treeCount}, ` +
|
||
`currentTeamCount(before)=${currentTeamCount}, initialTarget=${initialTarget}`,
|
||
)
|
||
|
||
// 6. 查找上级社区（用于接收考核前的权益）
|
||
let parentCommunityAccountSequence: string = HEADQUARTERS_ACCOUNT_SEQUENCE
|
||
let parentCommunityReason = '上级为总部社区'
|
||
|
||
// 从最近社区之后继续查找上级社区
|
||
for (let i = nearestCommunityIndex + 1; i < ancestorAccountSequences.length; i++) {
|
||
const ancestorSeq = ancestorAccountSequences[i]
|
||
const found = ancestorCommunities.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq && auth.benefitActive,
|
||
)
|
||
if (found) {
|
||
parentCommunityAccountSequence = found.userId.accountSequence
|
||
parentCommunityReason = '上级社区权益已激活'
|
||
break
|
||
}
|
||
}
|
||
|
||
// 7. 计算分配方案
|
||
const distributions: Array<{
|
||
accountSequence: string
|
||
treeCount: number
|
||
reason: string
|
||
}> = []
|
||
|
||
if (currentTeamCount >= initialTarget) {
|
||
// 已达标但权益未激活（可能是月度考核失败），全部给该社区
|
||
// 注：这种情况下应该由系统自动激活权益，但这里作为兜底处理
|
||
distributions.push({
|
||
accountSequence: nearestCommunity.userId.accountSequence,
|
||
treeCount,
|
||
reason: '已达初始考核目标',
|
||
})
|
||
|
||
// 自动激活权益
|
||
await this.tryActivateBenefit(nearestCommunity)
|
||
|
||
// 累加月度新增树数（用于月度考核）
|
||
nearestCommunity.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(nearestCommunity)
|
||
} else {
|
||
// 未达标，需要拆分
|
||
// toReachTarget: 还差多少棵达到考核目标（包括达标那一棵）
|
||
// 业务规则：第1-10棵全部给上级的上级/总部，第11棵开始才给该社区
|
||
// 例如：目标10棵，当前2棵 -> toReachTarget = 8（第3-10棵给上级，第11棵开始给自己）
|
||
const toReachTarget = Math.max(0, initialTarget - currentTeamCount)
|
||
const afterPlantingCount = currentTeamCount + treeCount // 本次认种后的总数
|
||
|
||
if (afterPlantingCount <= initialTarget) {
|
||
// 本次认种后仍未超过目标（包括刚好达标），全部给上级/总部
|
||
distributions.push({
|
||
accountSequence: parentCommunityAccountSequence,
|
||
treeCount,
|
||
reason: `初始考核中(${currentTeamCount}+${treeCount}=${afterPlantingCount}/${initialTarget})，${parentCommunityReason}`,
|
||
})
|
||
|
||
// 如果刚好达标，激活权益（但本批次树全部给上级）
|
||
if (afterPlantingCount === initialTarget) {
|
||
await this.tryActivateBenefit(nearestCommunity)
|
||
}
|
||
} else {
|
||
// 本次认种跨越考核达标点 (afterPlantingCount > initialTarget)
|
||
// 达标前的部分（包括第10棵）给上级/总部
|
||
if (toReachTarget > 0) {
|
||
distributions.push({
|
||
accountSequence: parentCommunityAccountSequence,
|
||
treeCount: toReachTarget,
|
||
reason: `初始考核(${currentTeamCount}+${toReachTarget}=${initialTarget}/${initialTarget})，${parentCommunityReason}`,
|
||
})
|
||
}
|
||
// 超过达标点的部分（第11棵开始），给该社区
|
||
const afterTargetCount = treeCount - toReachTarget
|
||
if (afterTargetCount > 0) {
|
||
distributions.push({
|
||
accountSequence: nearestCommunity.userId.accountSequence,
|
||
treeCount: afterTargetCount,
|
||
reason: `考核达标后权益生效(第${initialTarget + 1}棵起)`,
|
||
})
|
||
}
|
||
|
||
// 自动激活权益（本次认种使其达标）
|
||
await this.tryActivateBenefit(nearestCommunity)
|
||
|
||
// 激活后累加月度新增树数（只计算归自己的那部分）
|
||
if (afterTargetCount > 0) {
|
||
nearestCommunity.addMonthlyTrees(afterTargetCount)
|
||
await this.authorizationRepository.save(nearestCommunity)
|
||
}
|
||
}
|
||
}
|
||
|
||
this.logger.debug(
|
||
`[getCommunityRewardDistribution] Result: ${JSON.stringify(distributions)}`,
|
||
)
|
||
|
||
return { distributions }
|
||
}
|
||
|
||
/**
|
||
* 获取省团队权益分配方案 (20 USDT)
|
||
*
|
||
* 规则：
|
||
* 1. 找到认种用户推荐链上最近的授权省公司（AUTH_PROVINCE_COMPANY）
|
||
* 2. 如果该授权省公司 benefitActive=true，全部权益给该用户
|
||
* 3. 如果该授权省公司 benefitActive=false：
|
||
* - 计算还需要多少棵才能达到初始考核(500棵)
|
||
* - 考核前的部分给上级/总部
|
||
* - 考核后的部分给该用户
|
||
* 4. 如果没有授权省公司，全部给总部
|
||
*/
|
||
async getProvinceTeamRewardDistribution(
|
||
accountSequence: string,
|
||
provinceCode: string,
|
||
treeCount: number,
|
||
): Promise<{
|
||
distributions: Array<{
|
||
accountSequence: string
|
||
treeCount: number
|
||
reason: string
|
||
}>
|
||
}> {
|
||
this.logger.debug(
|
||
`[getProvinceTeamRewardDistribution] accountSequence=${accountSequence}, provinceCode=${provinceCode}, treeCount=${treeCount}`,
|
||
)
|
||
|
||
// 系统省团队账户ID格式: 7 + 省份代码
|
||
const systemProvinceTeamAccountSequence = `7${provinceCode.padStart(6, '0')}`
|
||
|
||
// 1. 获取用户的祖先链
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
|
||
if (ancestorAccountSequences.length === 0) {
|
||
return {
|
||
distributions: [
|
||
{ accountSequence: systemProvinceTeamAccountSequence, treeCount, reason: '无推荐链，进系统省团队账户' },
|
||
],
|
||
}
|
||
}
|
||
|
||
// 2. 查找祖先链中所有授权省公司（包括 benefitActive=false）
|
||
// 注意：省团队收益不再要求省份匹配，只要推荐链上有省团队授权即可获得收益
|
||
const ancestorAuthProvinces = await this.authorizationRepository.findAuthProvinceByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
if (ancestorAuthProvinces.length === 0) {
|
||
return {
|
||
distributions: [
|
||
{ accountSequence: systemProvinceTeamAccountSequence, treeCount, reason: '推荐链上无授权省公司，进系统省团队账户' },
|
||
],
|
||
}
|
||
}
|
||
|
||
// 3. 按祖先链顺序找最近的授权省公司
|
||
let nearestAuthProvince: typeof ancestorAuthProvinces[0] | null = null
|
||
let nearestIndex = -1
|
||
|
||
for (let i = 0; i < ancestorAccountSequences.length; i++) {
|
||
const ancestorSeq = ancestorAccountSequences[i]
|
||
const found = ancestorAuthProvinces.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq,
|
||
)
|
||
if (found) {
|
||
nearestAuthProvince = found
|
||
nearestIndex = i
|
||
break
|
||
}
|
||
}
|
||
|
||
if (!nearestAuthProvince) {
|
||
return {
|
||
distributions: [
|
||
{ accountSequence: systemProvinceTeamAccountSequence, treeCount, reason: '未找到匹配的授权省公司，进系统省团队账户' },
|
||
],
|
||
}
|
||
}
|
||
|
||
// 4. 检查权益状态
|
||
if (nearestAuthProvince.benefitActive) {
|
||
// 权益已激活，全部给该省团队
|
||
// 累加月度新增树数（用于月度考核）
|
||
nearestAuthProvince.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(nearestAuthProvince)
|
||
|
||
return {
|
||
distributions: [
|
||
{ accountSequence: nearestAuthProvince.userId.accountSequence, treeCount, reason: '省团队权益已激活' },
|
||
],
|
||
}
|
||
}
|
||
|
||
// 5. 权益未激活，计算考核分配 - 使用下级团队认种数（不含自己）
|
||
const stats = await this.statsRepository.findByAccountSequence(nearestAuthProvince.userId.accountSequence)
|
||
const rawSubordinateCount = stats?.subordinateTeamPlantingCount ?? 0
|
||
// 修复竞态条件：减去本次认种数量来还原"认种前"的下级团队数
|
||
const currentTeamCount = Math.max(0, rawSubordinateCount - treeCount)
|
||
const initialTarget = nearestAuthProvince.getInitialTarget() // 500棵
|
||
|
||
this.logger.debug(
|
||
`[getProvinceTeamRewardDistribution] rawSubordinateCount=${rawSubordinateCount}, treeCount=${treeCount}, currentTeamCount(before)=${currentTeamCount}`,
|
||
)
|
||
|
||
// 6. 查找上级（用于接收考核前的权益）
|
||
let parentAccountSequence: string = systemProvinceTeamAccountSequence
|
||
let parentReason = '上级为系统省团队账户'
|
||
|
||
for (let i = nearestIndex + 1; i < ancestorAccountSequences.length; i++) {
|
||
const ancestorSeq = ancestorAccountSequences[i]
|
||
const found = ancestorAuthProvinces.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq && auth.benefitActive,
|
||
)
|
||
if (found) {
|
||
parentAccountSequence = found.userId.accountSequence
|
||
parentReason = '上级授权省公司权益已激活'
|
||
break
|
||
}
|
||
}
|
||
|
||
// 7. 计算分配
|
||
const distributions: Array<{ accountSequence: string; treeCount: number; reason: string }> = []
|
||
|
||
if (currentTeamCount >= initialTarget) {
|
||
// 已达标但权益未激活（可能是月度考核失败），全部给该省团队
|
||
// 注：这种情况下应该由系统自动激活权益，但这里作为兜底处理
|
||
distributions.push({
|
||
accountSequence: nearestAuthProvince.userId.accountSequence,
|
||
treeCount,
|
||
reason: '已达初始考核目标',
|
||
})
|
||
|
||
// 自动激活权益
|
||
await this.tryActivateBenefit(nearestAuthProvince)
|
||
|
||
// 累加月度新增树数（用于月度考核）
|
||
nearestAuthProvince.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(nearestAuthProvince)
|
||
} else {
|
||
// toReachTarget: 还差多少棵达到考核目标（包括达标那一棵）
|
||
// 业务规则：达标前的全部给上级/总部，超过达标点后才给该省团队
|
||
const toReachTarget = Math.max(0, initialTarget - currentTeamCount)
|
||
const afterPlantingCount = currentTeamCount + treeCount
|
||
|
||
if (afterPlantingCount <= initialTarget) {
|
||
// 本次认种后仍未超过目标（包括刚好达标），全部给上级/总部
|
||
distributions.push({
|
||
accountSequence: parentAccountSequence,
|
||
treeCount,
|
||
reason: `初始考核中(${currentTeamCount}+${treeCount}=${afterPlantingCount}/${initialTarget})，${parentReason}`,
|
||
})
|
||
|
||
// 如果刚好达标，激活权益（但本批次树全部给上级）
|
||
if (afterPlantingCount === initialTarget) {
|
||
await this.tryActivateBenefit(nearestAuthProvince)
|
||
}
|
||
} else {
|
||
// 本次认种跨越考核达标点 (afterPlantingCount > initialTarget)
|
||
// 达标前的部分（包括第500棵）给上级/总部
|
||
if (toReachTarget > 0) {
|
||
distributions.push({
|
||
accountSequence: parentAccountSequence,
|
||
treeCount: toReachTarget,
|
||
reason: `初始考核(${currentTeamCount}+${toReachTarget}=${initialTarget}/${initialTarget})，${parentReason}`,
|
||
})
|
||
}
|
||
// 超过达标点的部分（第501棵开始），给该省团队
|
||
const afterTargetCount = treeCount - toReachTarget
|
||
if (afterTargetCount > 0) {
|
||
distributions.push({
|
||
accountSequence: nearestAuthProvince.userId.accountSequence,
|
||
treeCount: afterTargetCount,
|
||
reason: `考核达标后权益生效(第${initialTarget + 1}棵起)`,
|
||
})
|
||
}
|
||
|
||
// 自动激活权益（本次认种使其达标）
|
||
await this.tryActivateBenefit(nearestAuthProvince)
|
||
|
||
// 激活后累加月度新增树数（只计算归自己的那部分）
|
||
if (afterTargetCount > 0) {
|
||
nearestAuthProvince.addMonthlyTrees(afterTargetCount)
|
||
await this.authorizationRepository.save(nearestAuthProvince)
|
||
}
|
||
}
|
||
}
|
||
|
||
this.logger.debug(`[getProvinceTeamRewardDistribution] Result: ${JSON.stringify(distributions)}`)
|
||
return { distributions }
|
||
}
|
||
|
||
/**
|
||
* 获取省区域权益分配方案 (15 USDT + 1%算力)
|
||
*
|
||
* 规则：
|
||
* 1. 查找该省份是否有正式省公司（PROVINCE_COMPANY）
|
||
* 2. 如果有且 benefitActive=true，权益进该省公司自己的账户，并累加当月新增树数
|
||
* 3. 如果有但 benefitActive=false（考核中）：
|
||
* - 使用阶梯目标（第1月150，第2月300，...，第9月11750）
|
||
* - 计算还需要多少棵才能达到当月目标
|
||
* - 考核前的部分进系统省账户
|
||
* - 考核后的部分给该省公司
|
||
* - 第一个月达标150棵立即激活权益
|
||
* 4. 如果没有正式省公司，全部进系统省账户
|
||
*/
|
||
async getProvinceAreaRewardDistribution(
|
||
provinceCode: string,
|
||
treeCount: number,
|
||
): Promise<{
|
||
distributions: Array<{
|
||
accountSequence: string
|
||
treeCount: number
|
||
reason: string
|
||
isSystemAccount: boolean
|
||
}>
|
||
}> {
|
||
this.logger.debug(
|
||
`[getProvinceAreaRewardDistribution] provinceCode=${provinceCode}, treeCount=${treeCount}`,
|
||
)
|
||
|
||
// 系统省账户ID格式: 9 + 省份代码
|
||
const systemProvinceAccountId = `9${provinceCode.padStart(6, '0')}`
|
||
|
||
// 查找该省份的正式省公司
|
||
const provinceCompany = await this.authorizationRepository.findProvinceCompanyByRegion(provinceCode)
|
||
|
||
if (!provinceCompany) {
|
||
// 无正式省公司，全部进系统省账户
|
||
return {
|
||
distributions: [
|
||
{
|
||
accountSequence: systemProvinceAccountId,
|
||
treeCount,
|
||
reason: '无正式省公司授权，进系统省账户',
|
||
isSystemAccount: true,
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
if (provinceCompany.benefitActive) {
|
||
// 正式省公司权益已激活，进该省公司账户
|
||
// 累加当月新增树数用于月度考核
|
||
provinceCompany.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(provinceCompany)
|
||
|
||
return {
|
||
distributions: [
|
||
{
|
||
accountSequence: provinceCompany.userId.accountSequence,
|
||
treeCount,
|
||
reason: '省区域权益已激活',
|
||
isSystemAccount: false,
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
// 权益未激活，使用阶梯目标计算考核分配
|
||
// 使用当前月份索引获取阶梯目标（第一个月为150棵）
|
||
const monthIndex = provinceCompany.currentMonthIndex || 1
|
||
const ladderTarget = LadderTargetRule.getTarget(RoleType.PROVINCE_COMPANY, monthIndex)
|
||
const initialTarget = ladderTarget.monthlyTarget // 第一个月150棵
|
||
|
||
// 使用 monthlyTreesAdded 作为当前累计认种数
|
||
const currentTeamCount = provinceCompany.monthlyTreesAdded
|
||
|
||
this.logger.debug(
|
||
`[getProvinceAreaRewardDistribution] monthIndex=${monthIndex}, currentTeamCount=${currentTeamCount}, treeCount=${treeCount}, initialTarget=${initialTarget}`,
|
||
)
|
||
|
||
const distributions: Array<{
|
||
accountSequence: string
|
||
treeCount: number
|
||
reason: string
|
||
isSystemAccount: boolean
|
||
}> = []
|
||
|
||
if (currentTeamCount >= initialTarget) {
|
||
// 已达标但权益未激活，全部给该省公司
|
||
distributions.push({
|
||
accountSequence: provinceCompany.userId.accountSequence,
|
||
treeCount,
|
||
reason: '已达初始考核目标',
|
||
isSystemAccount: false,
|
||
})
|
||
// 累加当月新增树数
|
||
provinceCompany.addMonthlyTrees(treeCount)
|
||
// 自动激活权益
|
||
await this.tryActivateBenefit(provinceCompany)
|
||
} else {
|
||
// toReachTarget: 还差多少棵达到考核目标（包括达标那一棵）
|
||
// 业务规则：达标前的全部进系统省账户，超过达标点后才给该省公司
|
||
const toReachTarget = Math.max(0, initialTarget - currentTeamCount)
|
||
const afterPlantingCount = currentTeamCount + treeCount
|
||
|
||
if (afterPlantingCount <= initialTarget) {
|
||
// 本次认种后仍未超过目标（包括刚好达标），全部进系统省账户
|
||
distributions.push({
|
||
accountSequence: systemProvinceAccountId,
|
||
treeCount,
|
||
reason: `初始考核中(${currentTeamCount}+${treeCount}=${afterPlantingCount}/${initialTarget})，进系统省账户`,
|
||
isSystemAccount: true,
|
||
})
|
||
// 累加当月新增树数
|
||
provinceCompany.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(provinceCompany)
|
||
|
||
// 如果刚好达标，激活权益（但本批次树全部进系统省账户）
|
||
if (afterPlantingCount === initialTarget) {
|
||
await this.tryActivateBenefit(provinceCompany)
|
||
}
|
||
} else {
|
||
// 本次认种跨越考核达标点 (afterPlantingCount > initialTarget)
|
||
// 达标前的部分进系统省账户
|
||
if (toReachTarget > 0) {
|
||
distributions.push({
|
||
accountSequence: systemProvinceAccountId,
|
||
treeCount: toReachTarget,
|
||
reason: `初始考核(${currentTeamCount}+${toReachTarget}=${initialTarget}/${initialTarget})，进系统省账户`,
|
||
isSystemAccount: true,
|
||
})
|
||
}
|
||
// 超过达标点的部分，给该省公司
|
||
const afterTargetCount = treeCount - toReachTarget
|
||
if (afterTargetCount > 0) {
|
||
distributions.push({
|
||
accountSequence: provinceCompany.userId.accountSequence,
|
||
treeCount: afterTargetCount,
|
||
reason: `考核达标后权益生效(第${initialTarget + 1}棵起)`,
|
||
isSystemAccount: false,
|
||
})
|
||
}
|
||
// 累加当月新增树数
|
||
provinceCompany.addMonthlyTrees(treeCount)
|
||
// 自动激活权益（本次认种使其达标）
|
||
await this.tryActivateBenefit(provinceCompany)
|
||
}
|
||
}
|
||
|
||
this.logger.debug(`[getProvinceAreaRewardDistribution] Result: ${JSON.stringify(distributions)}`)
|
||
return { distributions }
|
||
}
|
||
|
||
/**
|
||
* 获取市团队权益分配方案 (40 USDT)
|
||
*
|
||
* 规则：
|
||
* 1. 找到认种用户推荐链上最近的授权市公司（AUTH_CITY_COMPANY）
|
||
* 2. 如果该授权市公司 benefitActive=true，全部权益给该用户
|
||
* 3. 如果该授权市公司 benefitActive=false：
|
||
* - 计算还需要多少棵才能达到初始考核(100棵)
|
||
* - 考核前的部分给上级/总部
|
||
* - 考核后的部分给该用户
|
||
* 4. 如果没有授权市公司，全部给总部
|
||
*/
|
||
async getCityTeamRewardDistribution(
|
||
accountSequence: string,
|
||
cityCode: string,
|
||
treeCount: number,
|
||
): Promise<{
|
||
distributions: Array<{
|
||
accountSequence: string
|
||
treeCount: number
|
||
reason: string
|
||
}>
|
||
}> {
|
||
this.logger.debug(
|
||
`[getCityTeamRewardDistribution] accountSequence=${accountSequence}, cityCode=${cityCode}, treeCount=${treeCount}`,
|
||
)
|
||
|
||
// 系统市团队账户ID格式: 6 + 城市代码
|
||
const systemCityTeamAccountSequence = `6${cityCode.padStart(6, '0')}`
|
||
|
||
// 1. 获取用户的祖先链
|
||
const ancestorAccountSequences = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
|
||
if (ancestorAccountSequences.length === 0) {
|
||
return {
|
||
distributions: [
|
||
{ accountSequence: systemCityTeamAccountSequence, treeCount, reason: '无推荐链，进系统市团队账户' },
|
||
],
|
||
}
|
||
}
|
||
|
||
// 2. 查找祖先链中所有授权市公司（包括 benefitActive=false）
|
||
// 注意：市团队收益不再要求城市匹配，只要推荐链上有市团队授权即可获得收益
|
||
const ancestorAuthCities = await this.authorizationRepository.findAuthCityByAccountSequences(
|
||
ancestorAccountSequences,
|
||
)
|
||
|
||
if (ancestorAuthCities.length === 0) {
|
||
return {
|
||
distributions: [
|
||
{ accountSequence: systemCityTeamAccountSequence, treeCount, reason: '推荐链上无授权市公司，进系统市团队账户' },
|
||
],
|
||
}
|
||
}
|
||
|
||
// 3. 按祖先链顺序找最近的授权市公司
|
||
let nearestAuthCity: typeof ancestorAuthCities[0] | null = null
|
||
let nearestIndex = -1
|
||
|
||
for (let i = 0; i < ancestorAccountSequences.length; i++) {
|
||
const ancestorSeq = ancestorAccountSequences[i]
|
||
const found = ancestorAuthCities.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq,
|
||
)
|
||
if (found) {
|
||
nearestAuthCity = found
|
||
nearestIndex = i
|
||
break
|
||
}
|
||
}
|
||
|
||
if (!nearestAuthCity) {
|
||
return {
|
||
distributions: [
|
||
{ accountSequence: systemCityTeamAccountSequence, treeCount, reason: '未找到匹配的授权市公司，进系统市团队账户' },
|
||
],
|
||
}
|
||
}
|
||
|
||
// 4. 检查权益状态
|
||
if (nearestAuthCity.benefitActive) {
|
||
// 权益已激活，全部给该市团队
|
||
// 累加月度新增树数（用于月度考核）
|
||
nearestAuthCity.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(nearestAuthCity)
|
||
|
||
return {
|
||
distributions: [
|
||
{ accountSequence: nearestAuthCity.userId.accountSequence, treeCount, reason: '市团队权益已激活' },
|
||
],
|
||
}
|
||
}
|
||
|
||
// 5. 权益未激活，计算考核分配 - 使用下级团队认种数（不含自己）
|
||
const stats = await this.statsRepository.findByAccountSequence(nearestAuthCity.userId.accountSequence)
|
||
const rawSubordinateCount = stats?.subordinateTeamPlantingCount ?? 0
|
||
// 修复竞态条件：减去本次认种数量来还原"认种前"的下级团队数
|
||
const currentTeamCount = Math.max(0, rawSubordinateCount - treeCount)
|
||
const initialTarget = nearestAuthCity.getInitialTarget() // 100棵
|
||
|
||
this.logger.debug(
|
||
`[getCityTeamRewardDistribution] rawSubordinateCount=${rawSubordinateCount}, treeCount=${treeCount}, currentTeamCount(before)=${currentTeamCount}`,
|
||
)
|
||
|
||
// 6. 查找上级
|
||
let parentAccountSequence: string = systemCityTeamAccountSequence
|
||
let parentReason = '上级为系统市团队账户'
|
||
|
||
for (let i = nearestIndex + 1; i < ancestorAccountSequences.length; i++) {
|
||
const ancestorSeq = ancestorAccountSequences[i]
|
||
const found = ancestorAuthCities.find(
|
||
(auth) => auth.userId.accountSequence === ancestorSeq && auth.benefitActive,
|
||
)
|
||
if (found) {
|
||
parentAccountSequence = found.userId.accountSequence
|
||
parentReason = '上级授权市公司权益已激活'
|
||
break
|
||
}
|
||
}
|
||
|
||
// 7. 计算分配
|
||
const distributions: Array<{ accountSequence: string; treeCount: number; reason: string }> = []
|
||
|
||
if (currentTeamCount >= initialTarget) {
|
||
// 已达标但权益未激活（可能是月度考核失败），全部给该市团队
|
||
// 注：这种情况下应该由系统自动激活权益，但这里作为兜底处理
|
||
distributions.push({
|
||
accountSequence: nearestAuthCity.userId.accountSequence,
|
||
treeCount,
|
||
reason: '已达初始考核目标',
|
||
})
|
||
|
||
// 自动激活权益
|
||
await this.tryActivateBenefit(nearestAuthCity)
|
||
|
||
// 累加月度新增树数（用于月度考核）
|
||
nearestAuthCity.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(nearestAuthCity)
|
||
} else {
|
||
// toReachTarget: 还差多少棵达到考核目标（包括达标那一棵）
|
||
// 业务规则：达标前的全部给上级/总部，超过达标点后才给该市团队
|
||
const toReachTarget = Math.max(0, initialTarget - currentTeamCount)
|
||
const afterPlantingCount = currentTeamCount + treeCount
|
||
|
||
if (afterPlantingCount <= initialTarget) {
|
||
// 本次认种后仍未超过目标（包括刚好达标），全部给上级/总部
|
||
distributions.push({
|
||
accountSequence: parentAccountSequence,
|
||
treeCount,
|
||
reason: `初始考核中(${currentTeamCount}+${treeCount}=${afterPlantingCount}/${initialTarget})，${parentReason}`,
|
||
})
|
||
|
||
// 如果刚好达标，激活权益（但本批次树全部给上级）
|
||
if (afterPlantingCount === initialTarget) {
|
||
await this.tryActivateBenefit(nearestAuthCity)
|
||
}
|
||
} else {
|
||
// 本次认种跨越考核达标点 (afterPlantingCount > initialTarget)
|
||
// 达标前的部分（包括第100棵）给上级/总部
|
||
if (toReachTarget > 0) {
|
||
distributions.push({
|
||
accountSequence: parentAccountSequence,
|
||
treeCount: toReachTarget,
|
||
reason: `初始考核(${currentTeamCount}+${toReachTarget}=${initialTarget}/${initialTarget})，${parentReason}`,
|
||
})
|
||
}
|
||
// 超过达标点的部分（第101棵开始），给该市团队
|
||
const afterTargetCount = treeCount - toReachTarget
|
||
if (afterTargetCount > 0) {
|
||
distributions.push({
|
||
accountSequence: nearestAuthCity.userId.accountSequence,
|
||
treeCount: afterTargetCount,
|
||
reason: `考核达标后权益生效(第${initialTarget + 1}棵起)`,
|
||
})
|
||
}
|
||
|
||
// 自动激活权益（本次认种使其达标）
|
||
await this.tryActivateBenefit(nearestAuthCity)
|
||
|
||
// 激活后累加月度新增树数（只计算归自己的那部分）
|
||
if (afterTargetCount > 0) {
|
||
nearestAuthCity.addMonthlyTrees(afterTargetCount)
|
||
await this.authorizationRepository.save(nearestAuthCity)
|
||
}
|
||
}
|
||
}
|
||
|
||
this.logger.debug(`[getCityTeamRewardDistribution] Result: ${JSON.stringify(distributions)}`)
|
||
return { distributions }
|
||
}
|
||
|
||
/**
|
||
* 获取市区域权益分配方案 (35 USDT + 2%算力)
|
||
*
|
||
* 规则：
|
||
* 1. 查找该城市是否有正式市公司（CITY_COMPANY）
|
||
* 2. 如果有且 benefitActive=true，权益进该市公司自己的账户，并累加 monthlyTreesAdded
|
||
* 3. 如果有但 benefitActive=false（考核中）：
|
||
* - 使用阶梯考核目标（第一个月30棵，逐月递增）
|
||
* - 计算还需要多少棵才能达到当前月份的考核目标
|
||
* - 考核前的部分进系统市账户
|
||
* - 考核后的部分给该市公司
|
||
* 4. 如果没有正式市公司，全部进系统市账户
|
||
*/
|
||
async getCityAreaRewardDistribution(
|
||
cityCode: string,
|
||
treeCount: number,
|
||
): Promise<{
|
||
distributions: Array<{
|
||
accountSequence: string
|
||
treeCount: number
|
||
reason: string
|
||
isSystemAccount: boolean
|
||
}>
|
||
}> {
|
||
this.logger.debug(
|
||
`[getCityAreaRewardDistribution] cityCode=${cityCode}, treeCount=${treeCount}`,
|
||
)
|
||
|
||
// 系统市账户ID格式: 8 + 城市代码
|
||
const systemCityAccountId = `8${cityCode.padStart(6, '0')}`
|
||
|
||
// 查找该城市的正式市公司
|
||
const cityCompany = await this.authorizationRepository.findCityCompanyByRegion(cityCode)
|
||
|
||
if (!cityCompany) {
|
||
// 无正式市公司，全部进系统市账户
|
||
return {
|
||
distributions: [
|
||
{
|
||
accountSequence: systemCityAccountId,
|
||
treeCount,
|
||
reason: '无正式市公司授权，进系统市账户',
|
||
isSystemAccount: true,
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
if (cityCompany.benefitActive) {
|
||
// 正式市公司权益已激活，进该市公司账户
|
||
// 累加月度新增树数（用于后续月度考核）
|
||
cityCompany.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(cityCompany)
|
||
|
||
return {
|
||
distributions: [
|
||
{
|
||
accountSequence: cityCompany.userId.accountSequence,
|
||
treeCount,
|
||
reason: '市区域权益已激活',
|
||
isSystemAccount: false,
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
// 权益未激活，计算考核分配 - 使用阶梯目标
|
||
// 对于未激活的正式市公司，使用第一个月的目标(30棵)进行初始考核
|
||
const monthIndex = cityCompany.currentMonthIndex || 1
|
||
const ladderTarget = LadderTargetRule.getTarget(RoleType.CITY_COMPANY, monthIndex)
|
||
const initialTarget = ladderTarget.monthlyTarget // 第一个月30棵
|
||
|
||
// 获取当前月度新增树数
|
||
const rawMonthlyCount = cityCompany.monthlyTreesAdded ?? 0
|
||
// 修复竞态条件：减去本次认种数量来还原"认种前"的月度数
|
||
const currentMonthlyCount = Math.max(0, rawMonthlyCount - treeCount)
|
||
|
||
this.logger.debug(
|
||
`[getCityAreaRewardDistribution] rawMonthlyCount=${rawMonthlyCount}, treeCount=${treeCount}, currentMonthlyCount(before)=${currentMonthlyCount}, initialTarget=${initialTarget}, monthIndex=${monthIndex}`,
|
||
)
|
||
|
||
const distributions: Array<{
|
||
accountSequence: string
|
||
treeCount: number
|
||
reason: string
|
||
isSystemAccount: boolean
|
||
}> = []
|
||
|
||
if (currentMonthlyCount >= initialTarget) {
|
||
// 已达标但权益未激活，全部给该市公司
|
||
distributions.push({
|
||
accountSequence: cityCompany.userId.accountSequence,
|
||
treeCount,
|
||
reason: '已达初始考核目标',
|
||
isSystemAccount: false,
|
||
})
|
||
// 自动激活权益
|
||
await this.tryActivateBenefit(cityCompany)
|
||
} else {
|
||
// toReachTarget: 还差多少棵达到考核目标（包括达标那一棵）
|
||
// 业务规则：达标前的全部进系统市账户，超过达标点后才给该市公司
|
||
const toReachTarget = Math.max(0, initialTarget - currentMonthlyCount)
|
||
const afterPlantingCount = currentMonthlyCount + treeCount
|
||
|
||
if (afterPlantingCount <= initialTarget) {
|
||
// 本次认种后仍未超过目标（包括刚好达标），全部进系统市账户
|
||
distributions.push({
|
||
accountSequence: systemCityAccountId,
|
||
treeCount,
|
||
reason: `初始考核中(${currentMonthlyCount}+${treeCount}=${afterPlantingCount}/${initialTarget})，进系统市账户`,
|
||
isSystemAccount: true,
|
||
})
|
||
|
||
// 累加月度新增树数（用于月底考核）
|
||
cityCompany.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(cityCompany)
|
||
|
||
// 如果刚好达标，激活权益（但本批次树全部进系统市账户）
|
||
if (afterPlantingCount === initialTarget) {
|
||
await this.tryActivateBenefit(cityCompany)
|
||
}
|
||
} else {
|
||
// 本次认种跨越考核达标点 (afterPlantingCount > initialTarget)
|
||
// 达标前的部分进系统市账户
|
||
if (toReachTarget > 0) {
|
||
distributions.push({
|
||
accountSequence: systemCityAccountId,
|
||
treeCount: toReachTarget,
|
||
reason: `初始考核(${currentMonthlyCount}+${toReachTarget}=${initialTarget}/${initialTarget})，进系统市账户`,
|
||
isSystemAccount: true,
|
||
})
|
||
}
|
||
// 超过达标点的部分，给该市公司
|
||
const afterTargetCount = treeCount - toReachTarget
|
||
if (afterTargetCount > 0) {
|
||
distributions.push({
|
||
accountSequence: cityCompany.userId.accountSequence,
|
||
treeCount: afterTargetCount,
|
||
reason: `考核达标后权益生效(第${initialTarget + 1}棵起)`,
|
||
isSystemAccount: false,
|
||
})
|
||
}
|
||
|
||
// 累加月度新增树数
|
||
cityCompany.addMonthlyTrees(treeCount)
|
||
await this.authorizationRepository.save(cityCompany)
|
||
|
||
// 自动激活权益（本次认种使其达标）
|
||
await this.tryActivateBenefit(cityCompany)
|
||
}
|
||
}
|
||
|
||
this.logger.debug(`[getCityAreaRewardDistribution] Result: ${JSON.stringify(distributions)}`)
|
||
return { distributions }
|
||
}
|
||
|
||
/**
|
||
* 处理过期的正式市公司权益（月度考核）
|
||
*
|
||
* 业务规则：
|
||
* - 检查所有 benefitValidUntil < 当前时间 且 benefitActive=true 的正式市公司
|
||
* - 获取当前月份索引对应的阶梯目标
|
||
* - 如果月度新增树数 >= 阶梯目标，续期并递增月份索引
|
||
* - 如果不达标，停用权益并重置月份索引为0
|
||
*/
|
||
async processExpiredCityCompanyBenefits(
|
||
limit: number,
|
||
): Promise<{ processedCount: number; renewedCount: number; deactivatedCount: number }> {
|
||
const now = new Date()
|
||
const expiredCityCompanies = await this.authorizationRepository.findExpiredActiveByRoleType(
|
||
RoleType.CITY_COMPANY,
|
||
now,
|
||
limit,
|
||
)
|
||
|
||
let renewedCount = 0
|
||
let deactivatedCount = 0
|
||
|
||
for (const cityCompany of expiredCityCompanies) {
|
||
// 获取当前月份索引对应的阶梯目标
|
||
const monthIndex = cityCompany.currentMonthIndex || 1
|
||
const ladderTarget = LadderTargetRule.getTarget(RoleType.CITY_COMPANY, monthIndex)
|
||
const monthlyTarget = ladderTarget.monthlyTarget
|
||
|
||
// 获取用于考核的树数
|
||
const treesForAssessment = cityCompany.getTreesForAssessment(now)
|
||
|
||
this.logger.debug(
|
||
`[processExpiredCityCompanyBenefits] ${cityCompany.userId.accountSequence}: ` +
|
||
`monthIndex=${monthIndex}, target=${monthlyTarget}, trees=${treesForAssessment}`,
|
||
)
|
||
|
||
if (treesForAssessment >= monthlyTarget) {
|
||
// 达标：续期权益并递增月份索引
|
||
cityCompany.renewBenefit(treesForAssessment)
|
||
cityCompany.incrementMonthIndex()
|
||
await this.authorizationRepository.save(cityCompany)
|
||
renewedCount++
|
||
|
||
this.logger.log(
|
||
`[processExpiredCityCompanyBenefits] ${cityCompany.userId.accountSequence} 考核达标，续期成功`,
|
||
)
|
||
} else {
|
||
// 不达标：停用权益
|
||
cityCompany.deactivateBenefit(`月度考核不达标(${treesForAssessment}/${monthlyTarget})`)
|
||
await this.authorizationRepository.save(cityCompany)
|
||
|
||
await this.eventPublisher.publishAll(cityCompany.domainEvents)
|
||
cityCompany.clearDomainEvents()
|
||
|
||
deactivatedCount++
|
||
|
||
this.logger.log(
|
||
`[processExpiredCityCompanyBenefits] ${cityCompany.userId.accountSequence} 考核不达标，权益已停用`,
|
||
)
|
||
}
|
||
}
|
||
|
||
return {
|
||
processedCount: expiredCityCompanies.length,
|
||
renewedCount,
|
||
deactivatedCount,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取过期的正式市公司授权列表
|
||
*/
|
||
async findExpiredCityCompanyBenefits(
|
||
checkDate: Date,
|
||
limit: number,
|
||
): Promise<AuthorizationRole[]> {
|
||
return this.authorizationRepository.findExpiredActiveByRoleType(
|
||
RoleType.CITY_COMPANY,
|
||
checkDate,
|
||
limit,
|
||
)
|
||
}
|
||
|
||
/**
|
||
* 处理过期的正式省公司权益
|
||
*
|
||
* 业务规则：
|
||
* - 检查所有 benefitValidUntil < 当前时间 且 benefitActive=true 的正式省公司
|
||
* - 使用阶梯目标（第1月150，第2月300，...，第9月11750）
|
||
* - 如果当月新增树数达标，续期并递增月份索引
|
||
* - 如果不达标，停用权益并重置月份索引到1
|
||
*/
|
||
async processExpiredProvinceCompanyBenefits(
|
||
limit: number,
|
||
): Promise<{ processedCount: number; renewedCount: number; deactivatedCount: number }> {
|
||
const now = new Date()
|
||
const expiredProvinceCompanies = await this.authorizationRepository.findExpiredActiveByRoleType(
|
||
RoleType.PROVINCE_COMPANY,
|
||
now,
|
||
limit,
|
||
)
|
||
|
||
let renewedCount = 0
|
||
let deactivatedCount = 0
|
||
|
||
for (const provinceCompany of expiredProvinceCompanies) {
|
||
// 获取当前月份索引对应的阶梯目标
|
||
const monthIndex = provinceCompany.currentMonthIndex || 1
|
||
const ladderTarget = LadderTargetRule.getTarget(RoleType.PROVINCE_COMPANY, monthIndex)
|
||
const monthlyTarget = ladderTarget.monthlyTarget
|
||
|
||
// 获取用于考核的树数
|
||
const treesForAssessment = provinceCompany.getTreesForAssessment(now)
|
||
|
||
this.logger.debug(
|
||
`[processExpiredProvinceCompanyBenefits] ${provinceCompany.userId.accountSequence}: ` +
|
||
`monthIndex=${monthIndex}, target=${monthlyTarget}, trees=${treesForAssessment}`,
|
||
)
|
||
|
||
if (treesForAssessment >= monthlyTarget) {
|
||
// 达标：续期权益并递增月份索引
|
||
provinceCompany.renewBenefit(treesForAssessment)
|
||
provinceCompany.incrementMonthIndex()
|
||
await this.authorizationRepository.save(provinceCompany)
|
||
renewedCount++
|
||
|
||
this.logger.log(
|
||
`[processExpiredProvinceCompanyBenefits] ${provinceCompany.userId.accountSequence} 考核达标，续期成功`,
|
||
)
|
||
} else {
|
||
// 不达标：停用权益
|
||
provinceCompany.deactivateBenefit(`月度考核不达标(${treesForAssessment}/${monthlyTarget})`)
|
||
await this.authorizationRepository.save(provinceCompany)
|
||
|
||
await this.eventPublisher.publishAll(provinceCompany.domainEvents)
|
||
provinceCompany.clearDomainEvents()
|
||
|
||
deactivatedCount++
|
||
|
||
this.logger.log(
|
||
`[processExpiredProvinceCompanyBenefits] ${provinceCompany.userId.accountSequence} 考核不达标，权益已停用`,
|
||
)
|
||
}
|
||
}
|
||
|
||
return {
|
||
processedCount: expiredProvinceCompanies.length,
|
||
renewedCount,
|
||
deactivatedCount,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取过期的正式省公司授权列表
|
||
*/
|
||
async findExpiredProvinceCompanyBenefits(
|
||
checkDate: Date,
|
||
limit: number,
|
||
): Promise<AuthorizationRole[]> {
|
||
return this.authorizationRepository.findExpiredActiveByRoleType(
|
||
RoleType.PROVINCE_COMPANY,
|
||
checkDate,
|
||
limit,
|
||
)
|
||
}
|
||
|
||
// ============================================
|
||
// 自助申请授权相关方法
|
||
// ============================================
|
||
|
||
/**
|
||
* 获取用户授权状态
|
||
* 用于自助申请页面显示用户当前状态
|
||
*/
|
||
async getUserAuthorizationStatus(
|
||
accountSequence: string,
|
||
): Promise<UserAuthorizationStatusResponseDto> {
|
||
this.logger.log(`[getUserAuthorizationStatus] accountSequence=${accountSequence}`)
|
||
|
||
// 1. 获取用户认种数据
|
||
const teamStats = await this.statsRepository.findByAccountSequence(accountSequence)
|
||
const hasPlanted = (teamStats?.selfPlantingCount || 0) > 0
|
||
const plantedCount = teamStats?.selfPlantingCount || 0
|
||
|
||
// 2. 获取用户已有的授权
|
||
const authorizations = await this.authorizationRepository.findByAccountSequence(accountSequence)
|
||
const existingAuthorizations = authorizations
|
||
.filter(auth => auth.status !== AuthorizationStatus.REVOKED)
|
||
.map(auth => this.mapRoleTypeToDisplayName(auth.roleType))
|
||
|
||
// 3. 查找团队链中已被占用的城市和省份
|
||
const teamChainOccupiedCities = await this.findTeamChainOccupiedRegions(
|
||
accountSequence,
|
||
RoleType.AUTH_CITY_COMPANY,
|
||
)
|
||
const teamChainOccupiedProvinces = await this.findTeamChainOccupiedRegions(
|
||
accountSequence,
|
||
RoleType.AUTH_PROVINCE_COMPANY,
|
||
)
|
||
|
||
return {
|
||
hasPlanted,
|
||
plantedCount,
|
||
existingAuthorizations,
|
||
teamChainOccupiedCities,
|
||
teamChainOccupiedProvinces,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 自助申请授权
|
||
*/
|
||
async selfApplyAuthorization(
|
||
command: SelfApplyAuthorizationCommand,
|
||
): Promise<SelfApplyAuthorizationResponseDto> {
|
||
this.logger.log(
|
||
`[selfApplyAuthorization] userId=${command.userId}, type=${command.type}, ` +
|
||
`photos=${command.officePhotoUrls.length}`,
|
||
)
|
||
|
||
// 1. 验证用户已认种
|
||
const teamStats = await this.statsRepository.findByAccountSequence(command.accountSequence)
|
||
const selfPlantingCount = teamStats?.selfPlantingCount || 0
|
||
if (selfPlantingCount <= 0) {
|
||
throw new ApplicationError('申请授权需要先完成认种')
|
||
}
|
||
|
||
// 2. 验证照片数量
|
||
if (command.officePhotoUrls.length < 2) {
|
||
throw new ApplicationError('请至少上传2张办公室照片')
|
||
}
|
||
if (command.officePhotoUrls.length > 6) {
|
||
throw new ApplicationError('最多上传6张办公室照片')
|
||
}
|
||
|
||
// 3. 根据申请类型处理
|
||
let result: SelfApplyAuthorizationResponseDto
|
||
|
||
switch (command.type) {
|
||
case SelfApplyAuthorizationType.COMMUNITY:
|
||
if (!command.communityName) {
|
||
throw new ApplicationError('申请社区授权需要提供社区名称')
|
||
}
|
||
result = await this.processCommunityApplication(command)
|
||
break
|
||
|
||
case SelfApplyAuthorizationType.CITY_TEAM:
|
||
if (!command.cityCode || !command.cityName) {
|
||
throw new ApplicationError('申请市团队授权需要提供城市信息')
|
||
}
|
||
result = await this.processCityTeamApplication(command)
|
||
break
|
||
|
||
case SelfApplyAuthorizationType.PROVINCE_TEAM:
|
||
if (!command.provinceCode || !command.provinceName) {
|
||
throw new ApplicationError('申请省团队授权需要提供省份信息')
|
||
}
|
||
result = await this.processProvinceTeamApplication(command)
|
||
break
|
||
|
||
default:
|
||
throw new ApplicationError('不支持的授权类型')
|
||
}
|
||
|
||
return result
|
||
}
|
||
|
||
/**
|
||
* 处理社区授权申请
|
||
*/
|
||
private async processCommunityApplication(
|
||
command: SelfApplyAuthorizationCommand,
|
||
): Promise<SelfApplyAuthorizationResponseDto> {
|
||
// 检查是否已有社区授权
|
||
const existing = await this.authorizationRepository.findByAccountSequenceAndRoleType(
|
||
command.accountSequence,
|
||
RoleType.COMMUNITY,
|
||
)
|
||
if (existing && existing.status !== AuthorizationStatus.REVOKED) {
|
||
throw new ApplicationError('您已拥有社区授权')
|
||
}
|
||
|
||
// 直接创建授权（自助申请的社区授权直接生效，状态为 AUTHORIZED）
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const authorization = AuthorizationRole.createSelfAppliedCommunity({
|
||
userId,
|
||
communityName: command.communityName!,
|
||
})
|
||
|
||
// 检查初始考核
|
||
const teamStats = await this.statsRepository.findByAccountSequence(command.accountSequence)
|
||
const subordinateTreeCount = teamStats?.subordinateTeamPlantingCount || 0
|
||
if (subordinateTreeCount >= authorization.getInitialTarget()) {
|
||
authorization.activateBenefit()
|
||
}
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
|
||
return {
|
||
authorizationId: authorization.authorizationId.value,
|
||
type: SelfApplyAuthorizationType.COMMUNITY,
|
||
grantedAt: new Date(),
|
||
benefitsActivated: authorization.benefitActive,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理市团队授权申请
|
||
*/
|
||
private async processCityTeamApplication(
|
||
command: SelfApplyAuthorizationCommand,
|
||
): Promise<SelfApplyAuthorizationResponseDto> {
|
||
// 检查用户是否已拥有省团队授权（市团队和省团队互斥，只能二选一）
|
||
const userAuthorizations = await this.authorizationRepository.findByAccountSequence(command.accountSequence)
|
||
const hasProvinceTeam = userAuthorizations.some(
|
||
auth => auth.roleType === RoleType.AUTH_PROVINCE_COMPANY && auth.status !== AuthorizationStatus.REVOKED,
|
||
)
|
||
if (hasProvinceTeam) {
|
||
throw new ApplicationError('您已拥有省团队授权，市团队和省团队只能二选一')
|
||
}
|
||
|
||
// 检查是否已有该市的授权市公司（全局唯一性）
|
||
const existingList = await this.authorizationRepository.findActiveByRoleTypeAndRegion(
|
||
RoleType.AUTH_CITY_COMPANY,
|
||
RegionCode.create(command.cityCode!),
|
||
)
|
||
if (existingList.length > 0) {
|
||
throw new ApplicationError('该市已有授权市公司')
|
||
}
|
||
|
||
// 检查团队链中是否已有人申请该城市（团队链唯一性）
|
||
const occupiedCities = await this.findTeamChainOccupiedRegions(
|
||
command.accountSequence,
|
||
RoleType.AUTH_CITY_COMPANY,
|
||
)
|
||
const isCityOccupiedInChain = occupiedCities.some(r => r.regionCode === command.cityCode)
|
||
if (isCityOccupiedInChain) {
|
||
throw new ApplicationError(`您的团队链中已有人申请了「${command.cityName}」的市团队授权`)
|
||
}
|
||
|
||
// 创建授权市公司授权（自助申请直接生效，状态为 AUTHORIZED）
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const authorization = AuthorizationRole.createSelfAppliedAuthCityCompany({
|
||
userId,
|
||
cityCode: command.cityCode!,
|
||
cityName: command.cityName!,
|
||
})
|
||
|
||
// 检查初始考核（100棵）
|
||
const teamStats = await this.statsRepository.findByAccountSequence(command.accountSequence)
|
||
const subordinateTreeCount = teamStats?.subordinateTeamPlantingCount || 0
|
||
if (subordinateTreeCount >= authorization.getInitialTarget()) {
|
||
authorization.activateBenefit()
|
||
}
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
|
||
return {
|
||
authorizationId: authorization.authorizationId.value,
|
||
type: SelfApplyAuthorizationType.CITY_TEAM,
|
||
grantedAt: new Date(),
|
||
benefitsActivated: authorization.benefitActive,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理省团队授权申请
|
||
*/
|
||
private async processProvinceTeamApplication(
|
||
command: SelfApplyAuthorizationCommand,
|
||
): Promise<SelfApplyAuthorizationResponseDto> {
|
||
// 检查用户是否已拥有市团队授权（市团队和省团队互斥，只能二选一）
|
||
const userAuthorizations = await this.authorizationRepository.findByAccountSequence(command.accountSequence)
|
||
const hasCityTeam = userAuthorizations.some(
|
||
auth => auth.roleType === RoleType.AUTH_CITY_COMPANY && auth.status !== AuthorizationStatus.REVOKED,
|
||
)
|
||
if (hasCityTeam) {
|
||
throw new ApplicationError('您已拥有市团队授权，市团队和省团队只能二选一')
|
||
}
|
||
|
||
// 检查是否已有该省的授权省公司（全局唯一性）
|
||
const existingList = await this.authorizationRepository.findActiveByRoleTypeAndRegion(
|
||
RoleType.AUTH_PROVINCE_COMPANY,
|
||
RegionCode.create(command.provinceCode!),
|
||
)
|
||
if (existingList.length > 0) {
|
||
throw new ApplicationError('该省已有授权省公司')
|
||
}
|
||
|
||
// 检查团队链中是否已有人申请该省份（团队链唯一性）
|
||
const occupiedProvinces = await this.findTeamChainOccupiedRegions(
|
||
command.accountSequence,
|
||
RoleType.AUTH_PROVINCE_COMPANY,
|
||
)
|
||
const isProvinceOccupiedInChain = occupiedProvinces.some(r => r.regionCode === command.provinceCode)
|
||
if (isProvinceOccupiedInChain) {
|
||
throw new ApplicationError(`您的团队链中已有人申请了「${command.provinceName}」的省团队授权`)
|
||
}
|
||
|
||
// 创建授权省公司授权（自助申请直接生效，状态为 AUTHORIZED）
|
||
const userId = UserId.create(command.userId, command.accountSequence)
|
||
const authorization = AuthorizationRole.createSelfAppliedAuthProvinceCompany({
|
||
userId,
|
||
provinceCode: command.provinceCode!,
|
||
provinceName: command.provinceName!,
|
||
})
|
||
|
||
// 检查初始考核（500棵）
|
||
const teamStats = await this.statsRepository.findByAccountSequence(command.accountSequence)
|
||
const subordinateTreeCount = teamStats?.subordinateTeamPlantingCount || 0
|
||
if (subordinateTreeCount >= authorization.getInitialTarget()) {
|
||
authorization.activateBenefit()
|
||
}
|
||
|
||
await this.authorizationRepository.save(authorization)
|
||
await this.eventPublisher.publishAll(authorization.domainEvents)
|
||
authorization.clearDomainEvents()
|
||
|
||
return {
|
||
authorizationId: authorization.authorizationId.value,
|
||
type: SelfApplyAuthorizationType.PROVINCE_TEAM,
|
||
grantedAt: new Date(),
|
||
benefitsActivated: authorization.benefitActive,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 查找团队链中指定类型的所有已占用区域
|
||
* 遍历用户的祖先链（推荐链），收集所有已被占用的城市/省份
|
||
*
|
||
* @returns 已占用区域列表（包含持有者信息和区域信息）
|
||
*/
|
||
private async findTeamChainOccupiedRegions(
|
||
accountSequence: string,
|
||
roleType: RoleType.AUTH_CITY_COMPANY | RoleType.AUTH_PROVINCE_COMPANY,
|
||
): Promise<TeamChainOccupiedRegionDto[]> {
|
||
const occupiedRegions: TeamChainOccupiedRegionDto[] = []
|
||
|
||
try {
|
||
// 获取用户的祖先链（推荐链）
|
||
const ancestorChain = await this.referralServiceClient.getReferralChain(accountSequence)
|
||
if (!ancestorChain || ancestorChain.length === 0) {
|
||
return occupiedRegions
|
||
}
|
||
|
||
// 遍历祖先链，收集所有持有该类型授权的区域
|
||
for (const ancestorAccountSeq of ancestorChain) {
|
||
const authorizations = await this.authorizationRepository.findByAccountSequence(ancestorAccountSeq)
|
||
const matchingAuths = authorizations.filter(
|
||
auth => auth.roleType === roleType && auth.status !== AuthorizationStatus.REVOKED,
|
||
)
|
||
|
||
for (const auth of matchingAuths) {
|
||
// 获取用户昵称
|
||
const userInfo = await this.identityServiceClient.getUserInfo(auth.userId.value)
|
||
occupiedRegions.push({
|
||
accountSequence: ancestorAccountSeq,
|
||
nickname: userInfo?.nickname || `用户${ancestorAccountSeq}`,
|
||
regionCode: auth.regionCode?.value || '',
|
||
regionName: auth.regionName || '',
|
||
})
|
||
}
|
||
}
|
||
|
||
return occupiedRegions
|
||
} catch (error) {
|
||
this.logger.error(`[findTeamChainOccupiedRegions] Error: ${error}`)
|
||
return occupiedRegions
|
||
}
|
||
}
|
||
|
||
private mapRoleTypeToDisplayName(roleType: RoleType): string {
|
||
const mapping: Record<RoleType, string> = {
|
||
[RoleType.COMMUNITY]: '社区',
|
||
[RoleType.AUTH_CITY_COMPANY]: '市团队',
|
||
[RoleType.AUTH_PROVINCE_COMPANY]: '省团队',
|
||
[RoleType.CITY_COMPANY]: '市区域',
|
||
[RoleType.PROVINCE_COMPANY]: '省区域',
|
||
}
|
||
return mapping[roleType] || roleType
|
||
}
|
||
}
|