.

src/commission/commission.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common'
+import { Module, forwardRef } from '@nestjs/common'
 import { CommissionService } from './commission.service'
 import { CommissionController } from './commission.controller'
 import { TypeOrmModule } from '@nestjs/typeorm'
@@ -6,9 +6,14 @@ import { CommissionConfig } from './entities/commission-config.entity'
 import { CommissionRecord } from './entities/commission-record.entity'
 import { Users } from 'src/users/entities/users.entity'
 import { UserBalanceModule } from 'src/user-balance/user-balance.module'
+import { MembershipModule } from 'src/membership/membership.module'
 
 @Module({
-    imports: [TypeOrmModule.forFeature([CommissionRecord, CommissionConfig, Users]), UserBalanceModule],
+    imports: [
+        TypeOrmModule.forFeature([CommissionRecord, CommissionConfig, Users]),
+        UserBalanceModule,
+        forwardRef(() => MembershipModule)
+    ],
     providers: [CommissionService],
     controllers: [CommissionController],
     exports: [CommissionService]

src/commission/commission.service.ts

@@ -1,5 +1,5 @@
 import { join } from 'path'
-import { Injectable } from '@nestjs/common'
+import { Inject, Injectable, forwardRef } from '@nestjs/common'
 import { InjectRepository } from '@nestjs/typeorm'
 import { CommissionConfig } from './entities/commission-config.entity'
 import { Repository } from 'typeorm'
@@ -10,6 +10,7 @@ import { BalanceType as BalanceType } from 'src/user-balance/entities/balance-re
 import { BigNumber } from 'bignumber.js'
 import { CommissionRecordDto } from './dto/commission-record.dto'
 import { hideSensitiveData } from 'src/utils/common'
+import { MembershipService } from 'src/membership/membership.service'
 
 @Injectable()
 export class CommissionService {
@@ -20,7 +21,9 @@ export class CommissionService {
         private readonly commissionRecordRepository: Repository<CommissionRecord>,
         @InjectRepository(Users)
         private readonly usersRepository: Repository<Users>,
-        private readonly userBalanceService: UserBalanceService
+        private readonly userBalanceService: UserBalanceService,
+        @Inject(forwardRef(() => MembershipService))
+        private readonly membershipService: MembershipService
     ) {}
 
     async saveConfig(config: Partial<CommissionConfig>) {
@@ -34,6 +37,7 @@ export class CommissionService {
         })
         if (!user || !user.invitor) return
 
+        const plans = await this.membershipService.getPlans()
         const configs = await this.commissionConfigRepository.find()
         const maxLevel = configs.map((config) => config.level).sort((a, b) => b - a)[0] || 0
 
@@ -43,20 +47,25 @@ export class CommissionService {
                 id: invitorId
             })
             if (!invitor) return
-            const config = configs.find((config) => config.level === i + 1)
-            if (config) {
-                const commission = amount.times(config.ratio)
-                await this.userBalanceService.modifyBalance(invitorId, commission, BalanceType.COMMISSION)
-                await this.commissionRecordRepository.save(
-                    new CommissionRecord({
-                        userId: invitorId,
-                        fromUserId: userId,
-                        amount: commission,
-                        level: configs[i].level,
-                        ratio: configs[i].ratio
-                    })
-                )
+            const membership = await this.membershipService.getMembership(invitorId)
+            const plan = plans.find((plan) => plan.id === membership.planId)
+            if (plan?.commissionable) {
+                const config = configs.find((config) => config.level === i + 1)
+                if (config) {
+                    const commission = amount.times(config.ratio)
+                    await this.userBalanceService.modifyBalance(invitorId, commission, BalanceType.COMMISSION)
+                    await this.commissionRecordRepository.save(
+                        new CommissionRecord({
+                            userId: invitorId,
+                            fromUserId: userId,
+                            amount: commission,
+                            level: configs[i].level,
+                            ratio: configs[i].ratio
+                        })
+                    )
+                }
             }
+
             if (!invitor.invitor) return
             invitorId = invitor.invitor
         }

src/membership/entities/memberPlan.entity.ts

@@ -20,4 +20,7 @@ export class MemberPlan {
 
     @Column()
     tokenLimit: number
+
+    @Column()
+    commissionable: boolean
 }

src/membership/membership.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common'
+import { Module, forwardRef } from '@nestjs/common'
 import { MembershipService } from './membership.service'
 import { MembershipController } from './membership.controller'
 import { TypeOrmModule } from '@nestjs/typeorm'
@@ -10,7 +10,11 @@ import { WeixinModule } from '../weixin/weixin.module'
 import { CommissionModule } from '../commission/commission.module'
 
 @Module({
-    imports: [TypeOrmModule.forFeature([Membership, MemberPlan, MemberOrder]), WeixinModule, CommissionModule],
+    imports: [
+        TypeOrmModule.forFeature([Membership, MemberPlan, MemberOrder]),
+        WeixinModule,
+        forwardRef(() => CommissionModule)
+    ],
     providers: [MembershipService],
     controllers: [MembershipController, MembershipAdminController],
     exports: [MembershipService]

src/membership/membership.service.ts

@@ -1,4 +1,4 @@
-import { Injectable, InternalServerErrorException, NotFoundException } from '@nestjs/common'
+import { Inject, Injectable, InternalServerErrorException, NotFoundException, forwardRef } from '@nestjs/common'
 import { InjectRepository } from '@nestjs/typeorm'
 import { MemberType, Membership } from './entities/membership.entity'
 import { Repository, LessThan } from 'typeorm'
@@ -20,6 +20,7 @@ export class MembershipService {
         @InjectRepository(MemberPlan) private readonly memberPlanRepository: Repository<MemberPlan>,
         @InjectRepository(MemberOrder) private readonly memberOrderRepository: Repository<MemberOrder>,
         private readonly weixinService: WeixinService,
+        @Inject(forwardRef(() => CommissionService))
         private readonly commissionService: CommissionService
     ) {}
 
@@ -55,18 +56,16 @@ export class MembershipService {
         if (!membership) {
             membership = new Membership()
             membership.userId = userId
-            membership.planId = planId
+        }
+
+        if (!membership.expireAt || membership.expireAt < new Date() || MemberType.Trial == membership.memberType) {
             membership.expireAt = addDays(new Date(), plan.duration)
             membership.tokenLeft = plan.tokenLimit
         } else {
-            if (membership.expireAt < new Date() || membership.memberType == MemberType.Trial) {
-                membership.expireAt = addDays(new Date(), plan.duration)
-                membership.tokenLeft = plan.tokenLimit
-            } else {
-                membership.expireAt = addDays(membership.expireAt, plan.duration)
-                membership.tokenLeft = Math.max(membership.tokenLeft, 0) + plan.tokenLimit
-            }
+            membership.expireAt = addDays(membership.expireAt, plan.duration)
+            membership.tokenLeft = Math.max(membership.tokenLeft, 0) + plan.tokenLimit
         }
+        membership.planId = planId
         membership.memberType = MemberType.Paid
         await this.memberShipRepository.save(membership)
         return {