2539 lines
83 KiB
TypeScript
2539 lines
83 KiB
TypeScript
import {
|
||
Injectable,
|
||
NotFoundException,
|
||
ConflictException,
|
||
Logger,
|
||
BadRequestException,
|
||
Inject,
|
||
} from '@nestjs/common';
|
||
import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
|
||
import { Logger as WinstonLogger } from 'winston';
|
||
import { InjectModel, InjectConnection } from '@nestjs/sequelize';
|
||
import { Gender, User } from './models/user.model';
|
||
import { UserResponseDto } from './dto/user-response.dto';
|
||
import { ResponseCode } from 'src/base.dto';
|
||
import { Transaction, Op } from 'sequelize';
|
||
import { Sequelize } from 'sequelize-typescript';
|
||
import { UpdateUserDto, UpdateUserResponseDto } from './dto/update-user.dto';
|
||
|
||
import { UserPurchase, PurchaseType, PurchaseStatus, PurchasePlatform } from './models/user-purchase.model';
|
||
import { ApplePurchaseService } from './services/apple-purchase.service';
|
||
import * as dayjs from 'dayjs';
|
||
import { AccessTokenPayload, AppleAuthService, AppleTokenPayload } from './services/apple-auth.service';
|
||
import { AppleLoginDto, AppleLoginResponseDto, RefreshTokenDto, RefreshTokenResponseDto } from './dto/apple-login.dto';
|
||
import { DeleteAccountDto, DeleteAccountResponseDto } from './dto/delete-account.dto';
|
||
import { GuestLoginDto, GuestLoginResponseDto, RefreshGuestTokenDto, RefreshGuestTokenResponseDto } from './dto/guest-login.dto';
|
||
import { AppStoreServerNotificationDto, ProcessNotificationResponseDto, NotificationType } from './dto/app-store-notification.dto';
|
||
import { RevenueCatEvent } from './models/revenue-cat-event.model';
|
||
import { UserProfile } from './models/user-profile.model';
|
||
import { RevenueCatWebhookDto, RevenueCatEventType } from './dto/revenue-cat-webhook.dto';
|
||
import { RestorePurchaseDto, RestorePurchaseResponseDto, RestoredPurchaseInfo, ActiveEntitlement, NonSubscriptionTransaction } from './dto/restore-purchase.dto';
|
||
import { PurchaseRestoreLog, RestoreStatus, RestoreSource } from './models/purchase-restore-log.model';
|
||
import { BlockedTransaction, BlockReason } from './models/blocked-transaction.model';
|
||
import { UserWeightHistory, WeightUpdateSource } from './models/user-weight-history.model';
|
||
import { UserDietHistory, DietRecordSource, MealType } from './models/user-diet-history.model';
|
||
import { ActivityLogsService } from '../activity-logs/activity-logs.service';
|
||
import { UserActivityService } from './services/user-activity.service';
|
||
import { GetUserActivityHistoryResponseDto } from './dto/user-activity.dto';
|
||
import { ActivityActionType, ActivityEntityType } from '../activity-logs/models/activity-log.model';
|
||
import { CreateDietRecordDto, UpdateDietRecordDto, GetDietHistoryQueryDto, DietRecordResponseDto, DietHistoryResponseDto, NutritionSummaryDto } from './dto/diet-record.dto';
|
||
|
||
const DEFAULT_FREE_USAGE_COUNT = 5;
|
||
|
||
@Injectable()
|
||
export class UsersService {
|
||
private readonly logger = new Logger(UsersService.name);
|
||
constructor(
|
||
@Inject(WINSTON_MODULE_PROVIDER) private readonly winstonLogger: WinstonLogger,
|
||
@InjectModel(User)
|
||
private userModel: typeof User,
|
||
@InjectModel(UserPurchase)
|
||
private userPurchaseModel: typeof UserPurchase,
|
||
@InjectModel(RevenueCatEvent)
|
||
private revenueCatEventModel: typeof RevenueCatEvent,
|
||
@InjectModel(PurchaseRestoreLog)
|
||
private purchaseRestoreLogModel: typeof PurchaseRestoreLog,
|
||
private appleAuthService: AppleAuthService,
|
||
private applePurchaseService: ApplePurchaseService,
|
||
@InjectModel(BlockedTransaction)
|
||
private blockedTransactionModel: typeof BlockedTransaction,
|
||
@InjectModel(UserProfile)
|
||
private userProfileModel: typeof UserProfile,
|
||
@InjectModel(UserWeightHistory)
|
||
private userWeightHistoryModel: typeof UserWeightHistory,
|
||
@InjectModel(UserDietHistory)
|
||
private userDietHistoryModel: typeof UserDietHistory,
|
||
@InjectConnection()
|
||
private sequelize: Sequelize,
|
||
private readonly activityLogsService: ActivityLogsService,
|
||
private readonly userActivityService: UserActivityService,
|
||
) { }
|
||
|
||
async getProfile(user: AccessTokenPayload): Promise<UserResponseDto> {
|
||
try {
|
||
// 使用NestJS Logger (会通过winston输出)
|
||
this.logger.log(`getProfile: ${JSON.stringify(user)}`);
|
||
|
||
// 也可以直接使用winston logger
|
||
this.winstonLogger.info('getProfile method called', {
|
||
context: 'UsersService',
|
||
userId: user.sub,
|
||
email: user.email
|
||
});
|
||
// 检查email是否已存在
|
||
const existingUser = await this.userModel.findOne({
|
||
where: { mail: user.email },
|
||
});
|
||
|
||
if (!existingUser) {
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `用户不存在，请先注册`,
|
||
data: null as any,
|
||
};
|
||
}
|
||
|
||
const [profile] = await this.userProfileModel.findOrCreate({
|
||
where: { userId: existingUser.id },
|
||
defaults: { userId: existingUser.id },
|
||
});
|
||
// 检查并记录今日登录活跃
|
||
await this.userActivityService.checkAndRecordTodayLogin(existingUser.id);
|
||
|
||
const returnData = {
|
||
...existingUser.toJSON(),
|
||
maxUsageCount: DEFAULT_FREE_USAGE_COUNT,
|
||
isVip: existingUser.isVip,
|
||
dailyStepsGoal: profile?.dailyStepsGoal,
|
||
dailyCaloriesGoal: profile?.dailyCaloriesGoal,
|
||
pilatesPurposes: profile?.pilatesPurposes,
|
||
weight: profile?.weight,
|
||
initialWeight: profile?.initialWeight,
|
||
targetWeight: profile?.targetWeight,
|
||
height: profile?.height,
|
||
activityLevel: profile?.activityLevel,
|
||
}
|
||
|
||
this.logger.log(`getProfile returnData: ${JSON.stringify(returnData, null, 2)}`);
|
||
|
||
// 返回用户信息，包含购买状态
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: 'success',
|
||
data: returnData,
|
||
};
|
||
} catch (error) {
|
||
this.logger.error(`getProfile error: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
if (error instanceof ConflictException) {
|
||
throw error;
|
||
}
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `获取用户信息失败: ${error instanceof Error ? error.message : '未知错误'}`,
|
||
data: null as any,
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @desc 获取用户剩余的聊天次数
|
||
*/
|
||
async getUserUsageCount(userId: string): Promise<number> {
|
||
try {
|
||
const user = await this.userModel.findOne({ where: { id: userId } });
|
||
|
||
if (!user) {
|
||
this.logger.log(`getUserUsageCount: ${userId} not found, return 0`);
|
||
return 0
|
||
}
|
||
|
||
if (user.isVip) {
|
||
// 会员用户无限次
|
||
this.logger.log(`getUserUsageCount: ${userId} is vip, return 999`);
|
||
return 999
|
||
}
|
||
|
||
this.logger.log(`getUserUsageCount: ${userId} freeUsageCount: ${user.freeUsageCount}`);
|
||
|
||
return user.freeUsageCount || 0;
|
||
} catch (error) {
|
||
this.logger.error(`getUserUsageCount error: ${error instanceof Error ? error.message : String(error)}`);
|
||
return 0
|
||
}
|
||
}
|
||
|
||
// 扣减用户免费次数
|
||
async deductUserUsageCount(userId: string, count: number = 1): Promise<void> {
|
||
try {
|
||
this.logger.log(`deductUserUsageCount: ${userId} deduct ${count} times`);
|
||
const user = await this.userModel.findOne({ where: { id: userId } });
|
||
if (!user) {
|
||
throw new NotFoundException(`ID为${userId}的用户不存在`);
|
||
}
|
||
user.freeUsageCount -= count;
|
||
await user.save();
|
||
} catch (error) {
|
||
this.logger.error(`deductUserUsageCount error: ${error instanceof Error ? error.message : String(error)}`);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
|
||
// 更新用户昵称、头像
|
||
async updateUser(updateUserDto: UpdateUserDto, userId: string): Promise<UpdateUserResponseDto> {
|
||
const { name, avatar, gender, birthDate, dailyStepsGoal, dailyCaloriesGoal, pilatesPurposes, weight, initialWeight, targetWeight, height, activityLevel } = updateUserDto;
|
||
|
||
this.logger.log(`updateUser: ${JSON.stringify(updateUserDto, null, 2)}`);
|
||
|
||
const user = await this.userModel.findOne({
|
||
where: { id: userId },
|
||
});
|
||
|
||
if (!user) {
|
||
throw new NotFoundException(`ID为${userId}的用户不存在`);
|
||
}
|
||
|
||
const profileChanges: Record<string, any> = {};
|
||
const userChanges: Record<string, any> = {};
|
||
if (name) {
|
||
user.name = name;
|
||
userChanges.name = name;
|
||
}
|
||
if (avatar) {
|
||
user.avatar = avatar;
|
||
userChanges.avatar = avatar;
|
||
}
|
||
if (gender) {
|
||
user.gender = gender;
|
||
userChanges.gender = gender;
|
||
}
|
||
if (birthDate) {
|
||
user.birthDate = dayjs(birthDate * 1000).startOf('day').toDate();
|
||
userChanges.birthDate = birthDate;
|
||
}
|
||
|
||
this.logger.log(`updateUser user: ${JSON.stringify(user, null, 2)}`);
|
||
|
||
await user.save();
|
||
|
||
const [profile] = await this.userProfileModel.findOrCreate({
|
||
where: { userId },
|
||
defaults: { userId },
|
||
});
|
||
|
||
// 更新或创建扩展信息
|
||
if (dailyStepsGoal !== undefined || dailyCaloriesGoal !== undefined || pilatesPurposes !== undefined || weight !== undefined || initialWeight !== undefined || targetWeight !== undefined || height !== undefined || activityLevel !== undefined) {
|
||
if (dailyStepsGoal !== undefined) { profile.dailyStepsGoal = dailyStepsGoal as any; profileChanges.dailyStepsGoal = dailyStepsGoal; }
|
||
if (dailyCaloriesGoal !== undefined) { profile.dailyCaloriesGoal = dailyCaloriesGoal as any; profileChanges.dailyCaloriesGoal = dailyCaloriesGoal; }
|
||
if (pilatesPurposes !== undefined) { profile.pilatesPurposes = pilatesPurposes as any; profileChanges.pilatesPurposes = pilatesPurposes; }
|
||
if (weight !== undefined) {
|
||
profile.weight = weight;
|
||
try {
|
||
await this.userWeightHistoryModel.create({ userId, weight, source: WeightUpdateSource.Manual });
|
||
} catch (e) {
|
||
this.logger.error(`记录体重历史失败: ${e instanceof Error ? e.message : String(e)}`);
|
||
}
|
||
profileChanges.weight = weight;
|
||
}
|
||
if (initialWeight !== undefined) {
|
||
profile.initialWeight = initialWeight;
|
||
profileChanges.initialWeight = initialWeight;
|
||
}
|
||
if (targetWeight !== undefined) {
|
||
profile.targetWeight = targetWeight;
|
||
profileChanges.targetWeight = targetWeight;
|
||
}
|
||
if (height !== undefined) {
|
||
profile.height = height;
|
||
profileChanges.height = height;
|
||
}
|
||
if (activityLevel !== undefined) {
|
||
profile.activityLevel = activityLevel;
|
||
profileChanges.activityLevel = activityLevel;
|
||
}
|
||
await profile.save();
|
||
}
|
||
|
||
// 记录用户基础与扩展信息更新
|
||
if (Object.keys(userChanges).length > 0) {
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER,
|
||
action: ActivityActionType.UPDATE,
|
||
entityId: userId,
|
||
changes: userChanges,
|
||
});
|
||
}
|
||
if (Object.keys(profileChanges).length > 0) {
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER_PROFILE,
|
||
action: ActivityActionType.UPDATE,
|
||
entityId: userId,
|
||
changes: profileChanges,
|
||
});
|
||
}
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: 'success',
|
||
data: {
|
||
...user.toJSON(),
|
||
...profile.toJSON(),
|
||
isNew: false,
|
||
} as any,
|
||
};
|
||
}
|
||
|
||
async addWeightByVision(userId: string, weight: number): Promise<void> {
|
||
const t = await this.sequelize.transaction();
|
||
try {
|
||
const [profile] = await this.userProfileModel.findOrCreate({ where: { userId }, defaults: { userId }, transaction: t });
|
||
profile.weight = weight;
|
||
await profile.save({ transaction: t });
|
||
await this.userWeightHistoryModel.create({ userId, weight, source: WeightUpdateSource.Vision }, { transaction: t });
|
||
await t.commit();
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER_PROFILE,
|
||
action: ActivityActionType.UPDATE,
|
||
entityId: userId,
|
||
changes: { weight },
|
||
metadata: { source: 'vision' },
|
||
});
|
||
} catch (e) {
|
||
await t.rollback();
|
||
this.logger.error(`addWeightByVision error: ${e instanceof Error ? e.message : String(e)}`);
|
||
}
|
||
}
|
||
|
||
async getWeightHistory(userId: string, params: { start?: Date; end?: Date; limit?: number } = {}) {
|
||
const where: any = { userId };
|
||
if (params.start || params.end) {
|
||
where.createdAt = {} as any;
|
||
if (params.start) where.createdAt.$gte = params.start as any;
|
||
if (params.end) where.createdAt.$lte = params.end as any;
|
||
}
|
||
const limit = params.limit && params.limit > 0 ? Math.min(1000, params.limit) : 200;
|
||
const rows = await this.userWeightHistoryModel.findAll({
|
||
where,
|
||
order: [['created_at', 'DESC']],
|
||
limit,
|
||
});
|
||
return rows.map(r => ({
|
||
id: r.id,
|
||
weight: r.weight,
|
||
source: r.source,
|
||
createdAt: r.createdAt
|
||
}));
|
||
}
|
||
|
||
/**
|
||
* 更新体重记录
|
||
*/
|
||
async updateWeightRecord(userId: string, recordId: number, updateData: { weight: number; source?: WeightUpdateSource }) {
|
||
const t = await this.sequelize.transaction();
|
||
try {
|
||
// 查找并验证体重记录是否存在且属于当前用户
|
||
const weightRecord = await this.userWeightHistoryModel.findOne({
|
||
where: { id: recordId, userId },
|
||
transaction: t,
|
||
});
|
||
|
||
if (!weightRecord) {
|
||
throw new NotFoundException('体重记录不存在');
|
||
}
|
||
|
||
const oldWeight = weightRecord.weight;
|
||
const oldSource = weightRecord.source;
|
||
|
||
// 更新体重记录
|
||
await weightRecord.update({
|
||
weight: updateData.weight,
|
||
source: updateData.source || weightRecord.source,
|
||
}, { transaction: t });
|
||
|
||
// 如果这是最新的体重记录，同时更新用户档案中的体重
|
||
const latestRecord = await this.userWeightHistoryModel.findOne({
|
||
where: { userId },
|
||
order: [['created_at', 'DESC']],
|
||
transaction: t,
|
||
});
|
||
|
||
if (latestRecord && latestRecord.id === recordId) {
|
||
const profile = await this.userProfileModel.findOne({
|
||
where: { userId },
|
||
transaction: t,
|
||
});
|
||
if (profile) {
|
||
profile.weight = updateData.weight;
|
||
await profile.save({ transaction: t });
|
||
}
|
||
}
|
||
|
||
await t.commit();
|
||
|
||
// 记录活动日志
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER_PROFILE,
|
||
action: ActivityActionType.UPDATE,
|
||
entityId: recordId.toString(),
|
||
changes: {
|
||
weight: { from: oldWeight, to: updateData.weight },
|
||
...(updateData.source && updateData.source !== oldSource ? { source: { from: oldSource, to: updateData.source } } : {}),
|
||
},
|
||
});
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: 'success',
|
||
data: {
|
||
id: weightRecord.id,
|
||
userId: weightRecord.userId,
|
||
weight: weightRecord.weight,
|
||
source: weightRecord.source,
|
||
createdAt: weightRecord.createdAt,
|
||
updatedAt: weightRecord.updatedAt,
|
||
},
|
||
};
|
||
} catch (error) {
|
||
await t.rollback();
|
||
this.logger.error(`更新体重记录失败: ${error instanceof Error ? error.message : String(error)}`);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 删除体重记录
|
||
*/
|
||
async deleteWeightRecord(userId: string, recordId: number): Promise<boolean> {
|
||
const t = await this.sequelize.transaction();
|
||
try {
|
||
// 查找并验证体重记录是否存在且属于当前用户
|
||
const weightRecord = await this.userWeightHistoryModel.findOne({
|
||
where: { id: recordId, userId },
|
||
transaction: t,
|
||
});
|
||
|
||
if (!weightRecord) {
|
||
return false;
|
||
}
|
||
|
||
const recordData = {
|
||
id: weightRecord.id,
|
||
weight: weightRecord.weight,
|
||
source: weightRecord.source,
|
||
createdAt: weightRecord.createdAt,
|
||
};
|
||
|
||
// 删除体重记录
|
||
await weightRecord.destroy({ transaction: t });
|
||
|
||
// 如果删除的是最新记录，需要更新用户档案中的体重为倒数第二新的记录
|
||
const latestRecord = await this.userWeightHistoryModel.findOne({
|
||
where: { userId },
|
||
order: [['created_at', 'DESC']],
|
||
transaction: t,
|
||
});
|
||
|
||
const profile = await this.userProfileModel.findOne({
|
||
where: { userId },
|
||
transaction: t,
|
||
});
|
||
|
||
if (profile) {
|
||
if (latestRecord) {
|
||
// 有其他体重记录，更新为最新的体重
|
||
profile.weight = latestRecord.weight;
|
||
} else {
|
||
// 没有其他体重记录，清空体重字段
|
||
profile.weight = null;
|
||
}
|
||
await profile.save({ transaction: t });
|
||
}
|
||
|
||
await t.commit();
|
||
|
||
// 记录活动日志
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER_PROFILE,
|
||
action: ActivityActionType.DELETE,
|
||
entityId: recordId.toString(),
|
||
changes: recordData,
|
||
});
|
||
|
||
return true;
|
||
} catch (error) {
|
||
await t.rollback();
|
||
this.logger.error(`删除体重记录失败: ${error instanceof Error ? error.message : String(error)}`);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 添加饮食记录
|
||
*/
|
||
async addDietRecord(userId: string, createDto: CreateDietRecordDto): Promise<DietRecordResponseDto> {
|
||
const t = await this.sequelize.transaction();
|
||
try {
|
||
const dietRecord = await this.userDietHistoryModel.create({
|
||
userId,
|
||
mealType: createDto.mealType,
|
||
foodName: createDto.foodName,
|
||
foodDescription: createDto.foodDescription || null,
|
||
weightGrams: createDto.weightGrams || null,
|
||
portionDescription: createDto.portionDescription || null,
|
||
estimatedCalories: createDto.estimatedCalories || null,
|
||
proteinGrams: createDto.proteinGrams || null,
|
||
carbohydrateGrams: createDto.carbohydrateGrams || null,
|
||
fatGrams: createDto.fatGrams || null,
|
||
fiberGrams: createDto.fiberGrams || null,
|
||
sugarGrams: createDto.sugarGrams || null,
|
||
sodiumMg: createDto.sodiumMg || null,
|
||
additionalNutrition: createDto.additionalNutrition || null,
|
||
source: createDto.source || DietRecordSource.Manual,
|
||
mealTime: createDto.mealTime ? new Date(createDto.mealTime) : null,
|
||
imageUrl: createDto.imageUrl || null,
|
||
aiAnalysisResult: createDto.aiAnalysisResult || null,
|
||
notes: createDto.notes || null,
|
||
deleted: false,
|
||
}, { transaction: t });
|
||
|
||
await t.commit();
|
||
|
||
// 记录活动日志
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER_PROFILE,
|
||
entityId: userId,
|
||
action: ActivityActionType.UPDATE,
|
||
changes: { diet_record_added: dietRecord.id },
|
||
metadata: {
|
||
source: createDto.source || 'manual',
|
||
mealType: createDto.mealType,
|
||
foodName: createDto.foodName
|
||
},
|
||
});
|
||
|
||
return this.mapDietRecordToDto(dietRecord);
|
||
} catch (e) {
|
||
await t.rollback();
|
||
this.logger.error(`addDietRecord error: ${e instanceof Error ? e.message : String(e)}`);
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 通过视觉识别添加饮食记录
|
||
*/
|
||
async addDietRecordByVision(userId: string, dietData: CreateDietRecordDto): Promise<DietRecordResponseDto> {
|
||
return this.addDietRecord(userId, {
|
||
...dietData,
|
||
source: DietRecordSource.Vision
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 获取饮食记录历史
|
||
*/
|
||
async getDietHistory(userId: string, query: GetDietHistoryQueryDto): Promise<DietHistoryResponseDto> {
|
||
const where: any = { userId, deleted: false };
|
||
|
||
// 日期过滤
|
||
if (query.startDate || query.endDate) {
|
||
where.createdAt = {} as any;
|
||
if (query.startDate) where.createdAt[Op.gte] = new Date(query.startDate);
|
||
if (query.endDate) where.createdAt[Op.lte] = new Date(query.endDate);
|
||
}
|
||
|
||
// 餐次类型过滤
|
||
if (query.mealType) {
|
||
where.mealType = query.mealType;
|
||
}
|
||
|
||
const limit = Math.min(100, Math.max(1, query.limit || 20));
|
||
const page = Math.max(1, query.page || 1);
|
||
const offset = (page - 1) * limit;
|
||
|
||
const { rows, count } = await this.userDietHistoryModel.findAndCountAll({
|
||
where,
|
||
order: [['created_at', 'DESC']],
|
||
limit,
|
||
offset,
|
||
});
|
||
|
||
const totalPages = Math.ceil(count / limit);
|
||
|
||
return {
|
||
records: rows.map(record => this.mapDietRecordToDto(record)),
|
||
total: count,
|
||
page,
|
||
limit,
|
||
totalPages,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 更新饮食记录
|
||
*/
|
||
async updateDietRecord(userId: string, recordId: number, updateDto: UpdateDietRecordDto): Promise<DietRecordResponseDto> {
|
||
const t = await this.sequelize.transaction();
|
||
try {
|
||
const record = await this.userDietHistoryModel.findOne({
|
||
where: { id: recordId, userId, deleted: false },
|
||
transaction: t,
|
||
});
|
||
|
||
if (!record) {
|
||
throw new NotFoundException('饮食记录不存在');
|
||
}
|
||
|
||
// 更新字段
|
||
if (updateDto.mealType !== undefined) record.mealType = updateDto.mealType;
|
||
if (updateDto.foodName !== undefined) record.foodName = updateDto.foodName;
|
||
if (updateDto.foodDescription !== undefined) record.foodDescription = updateDto.foodDescription;
|
||
if (updateDto.weightGrams !== undefined) record.weightGrams = updateDto.weightGrams;
|
||
if (updateDto.portionDescription !== undefined) record.portionDescription = updateDto.portionDescription;
|
||
if (updateDto.estimatedCalories !== undefined) record.estimatedCalories = updateDto.estimatedCalories;
|
||
if (updateDto.proteinGrams !== undefined) record.proteinGrams = updateDto.proteinGrams;
|
||
if (updateDto.carbohydrateGrams !== undefined) record.carbohydrateGrams = updateDto.carbohydrateGrams;
|
||
if (updateDto.fatGrams !== undefined) record.fatGrams = updateDto.fatGrams;
|
||
if (updateDto.fiberGrams !== undefined) record.fiberGrams = updateDto.fiberGrams;
|
||
if (updateDto.sugarGrams !== undefined) record.sugarGrams = updateDto.sugarGrams;
|
||
if (updateDto.sodiumMg !== undefined) record.sodiumMg = updateDto.sodiumMg;
|
||
if (updateDto.additionalNutrition !== undefined) record.additionalNutrition = updateDto.additionalNutrition;
|
||
if (updateDto.mealTime !== undefined) record.mealTime = updateDto.mealTime ? new Date(updateDto.mealTime) : null;
|
||
if (updateDto.imageUrl !== undefined) record.imageUrl = updateDto.imageUrl;
|
||
if (updateDto.aiAnalysisResult !== undefined) record.aiAnalysisResult = updateDto.aiAnalysisResult;
|
||
if (updateDto.notes !== undefined) record.notes = updateDto.notes;
|
||
|
||
await record.save({ transaction: t });
|
||
await t.commit();
|
||
|
||
// 记录活动日志
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER_PROFILE,
|
||
entityId: userId,
|
||
action: ActivityActionType.UPDATE,
|
||
changes: { diet_record_updated: recordId },
|
||
metadata: { updateDto },
|
||
});
|
||
|
||
return this.mapDietRecordToDto(record);
|
||
} catch (e) {
|
||
await t.rollback();
|
||
this.logger.error(`updateDietRecord error: ${e instanceof Error ? e.message : String(e)}`);
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 删除饮食记录
|
||
*/
|
||
async deleteDietRecord(userId: string, recordId: number): Promise<boolean> {
|
||
const t = await this.sequelize.transaction();
|
||
try {
|
||
const record = await this.userDietHistoryModel.findOne({
|
||
where: { id: recordId, userId, deleted: false },
|
||
transaction: t,
|
||
});
|
||
|
||
if (!record) {
|
||
return false;
|
||
}
|
||
|
||
record.deleted = true;
|
||
await record.save({ transaction: t });
|
||
await t.commit();
|
||
|
||
// 记录活动日志
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER_PROFILE,
|
||
entityId: userId,
|
||
action: ActivityActionType.DELETE,
|
||
changes: { diet_record_deleted: recordId },
|
||
metadata: { foodName: record.foodName, mealType: record.mealType },
|
||
});
|
||
|
||
return true;
|
||
} catch (e) {
|
||
await t.rollback();
|
||
this.logger.error(`deleteDietRecord error: ${e instanceof Error ? e.message : String(e)}`);
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取最近N顿饮食的营养汇总
|
||
*/
|
||
async getRecentNutritionSummary(userId: string, mealCount: number = 10): Promise<NutritionSummaryDto> {
|
||
const records = await this.userDietHistoryModel.findAll({
|
||
where: { userId, deleted: false },
|
||
order: [['created_at', 'DESC']],
|
||
limit: mealCount,
|
||
});
|
||
|
||
if (records.length === 0) {
|
||
throw new NotFoundException('暂无饮食记录');
|
||
}
|
||
|
||
const summary = records.reduce((acc, record) => {
|
||
acc.totalCalories += record.estimatedCalories || 0;
|
||
acc.totalProtein += record.proteinGrams || 0;
|
||
acc.totalCarbohydrates += record.carbohydrateGrams || 0;
|
||
acc.totalFat += record.fatGrams || 0;
|
||
acc.totalFiber += record.fiberGrams || 0;
|
||
acc.totalSugar += record.sugarGrams || 0;
|
||
acc.totalSodium += record.sodiumMg || 0;
|
||
return acc;
|
||
}, {
|
||
totalCalories: 0,
|
||
totalProtein: 0,
|
||
totalCarbohydrates: 0,
|
||
totalFat: 0,
|
||
totalFiber: 0,
|
||
totalSugar: 0,
|
||
totalSodium: 0,
|
||
});
|
||
|
||
const oldestRecord = records[records.length - 1];
|
||
const newestRecord = records[0];
|
||
|
||
return {
|
||
...summary,
|
||
recordCount: records.length,
|
||
dateRange: {
|
||
start: oldestRecord.createdAt,
|
||
end: newestRecord.createdAt,
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 将数据库模型转换为DTO
|
||
*/
|
||
private mapDietRecordToDto(record: UserDietHistory): DietRecordResponseDto {
|
||
return {
|
||
id: record.id,
|
||
mealType: record.mealType,
|
||
foodName: record.foodName,
|
||
foodDescription: record.foodDescription || undefined,
|
||
weightGrams: record.weightGrams || undefined,
|
||
portionDescription: record.portionDescription || undefined,
|
||
estimatedCalories: record.estimatedCalories || undefined,
|
||
proteinGrams: record.proteinGrams || undefined,
|
||
carbohydrateGrams: record.carbohydrateGrams || undefined,
|
||
fatGrams: record.fatGrams || undefined,
|
||
fiberGrams: record.fiberGrams || undefined,
|
||
sugarGrams: record.sugarGrams || undefined,
|
||
sodiumMg: record.sodiumMg || undefined,
|
||
additionalNutrition: record.additionalNutrition || undefined,
|
||
source: record.source,
|
||
mealTime: record.mealTime || undefined,
|
||
imageUrl: record.imageUrl || undefined,
|
||
notes: record.notes || undefined,
|
||
createdAt: record.createdAt,
|
||
updatedAt: record.updatedAt,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Apple 登录
|
||
*/
|
||
async appleLogin(appleLoginDto: AppleLoginDto): Promise<AppleLoginResponseDto> {
|
||
try {
|
||
this.logger.log(`appleLogin: ${JSON.stringify(appleLoginDto)}`);
|
||
|
||
// 验证 Apple Identity Token
|
||
const applePayload: AppleTokenPayload = await this.appleAuthService.verifyAppleToken(appleLoginDto.identityToken);
|
||
|
||
// 构造用户ID（使用 Apple 的 sub 作为用户ID，添加前缀以区分）
|
||
const userId = applePayload.sub
|
||
|
||
this.logger.log(`appleLogin userId: ${userId}`);
|
||
|
||
// 查找或创建用户
|
||
let user = await this.userModel.findOne({
|
||
where: { id: userId },
|
||
});
|
||
|
||
let isNewUser = false;
|
||
|
||
if (!user) {
|
||
// 创建新用户
|
||
const userName = appleLoginDto.name || applePayload.email?.split('@')[0] || '用户';
|
||
const userEmail = appleLoginDto.email || applePayload.email || '';
|
||
|
||
if (!userEmail) {
|
||
throw new BadRequestException('无法获取用户邮箱信息');
|
||
}
|
||
|
||
user = await this.userModel.create({
|
||
id: userId,
|
||
name: userName,
|
||
mail: userEmail,
|
||
gender: Gender.MALE,
|
||
freeUsageCount: DEFAULT_FREE_USAGE_COUNT,
|
||
lastLogin: new Date(),
|
||
avatar: 'https://plates-1251306435.cos.ap-guangzhou.myqcloud.com/images/seal-avatar/1.jpeg'
|
||
});
|
||
|
||
isNewUser = true;
|
||
this.logger.log(`创建新的Apple用户: ${userId}`);
|
||
|
||
// 创建默认扩展记录
|
||
await this.userProfileModel.findOrCreate({ where: { userId }, defaults: { userId } });
|
||
|
||
} else {
|
||
// 更新现有用户的登录时间
|
||
user.lastLogin = new Date();
|
||
await user.save();
|
||
this.logger.log(`Apple用户登录: ${userId}`);
|
||
}
|
||
|
||
// 生成访问令牌和刷新令牌
|
||
const accessToken = this.appleAuthService.generateAccessToken(userId, user.mail);
|
||
const refreshToken = this.appleAuthService.generateRefreshToken(userId);
|
||
|
||
// 构造用户数据
|
||
const profileForLogin = await this.userProfileModel.findByPk(user.id);
|
||
const userData = {
|
||
...user.toJSON(),
|
||
isNew: isNewUser,
|
||
isVip: user.isVip,
|
||
maxUsageCount: DEFAULT_FREE_USAGE_COUNT,
|
||
profile: profileForLogin ? {
|
||
dailyStepsGoal: profileForLogin.dailyStepsGoal,
|
||
dailyCaloriesGoal: profileForLogin.dailyCaloriesGoal,
|
||
pilatesPurposes: profileForLogin.pilatesPurposes,
|
||
weight: profileForLogin.weight,
|
||
initialWeight: profileForLogin.initialWeight,
|
||
targetWeight: profileForLogin.targetWeight,
|
||
height: profileForLogin.height,
|
||
activityLevel: profileForLogin.activityLevel,
|
||
} : undefined,
|
||
};
|
||
|
||
// 登录行为也可视为活动（可选，记录创建或登录行为）
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER,
|
||
action: ActivityActionType.UPDATE,
|
||
entityId: userId,
|
||
changes: { lastLogin: user.lastLogin },
|
||
metadata: { source: 'appleLogin' },
|
||
});
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: 'success',
|
||
data: {
|
||
accessToken,
|
||
refreshToken,
|
||
expiresIn: this.appleAuthService.getAccessTokenExpiresIn(),
|
||
user: userData,
|
||
},
|
||
};
|
||
|
||
} catch (error) {
|
||
this.logger.error(`Apple登录失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `Apple登录失败: ${error instanceof Error ? error.message : '未知错误'}`,
|
||
data: null as any,
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 刷新访问令牌
|
||
*/
|
||
async refreshToken(refreshTokenDto: RefreshTokenDto): Promise<RefreshTokenResponseDto> {
|
||
try {
|
||
this.logger.log(`refreshToken: ${JSON.stringify(refreshTokenDto)}`);
|
||
|
||
// 验证刷新令牌并获取用户信息
|
||
const payload = this.appleAuthService.verifyRefreshToken(refreshTokenDto.refreshToken);
|
||
|
||
// 查找用户以获取邮箱信息
|
||
const user = await this.userModel.findByPk(payload.sub);
|
||
if (!user) {
|
||
throw new BadRequestException('用户不存在');
|
||
}
|
||
|
||
// 生成新的访问令牌
|
||
const result = await this.appleAuthService.refreshAccessToken(refreshTokenDto.refreshToken, user.mail);
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: 'success',
|
||
data: result,
|
||
};
|
||
|
||
} catch (error) {
|
||
this.logger.error(`刷新令牌失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `刷新令牌失败: ${error instanceof Error ? error.message : '未知错误'}`,
|
||
data: null as any,
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 删除用户账号
|
||
*/
|
||
async deleteAccount(deleteAccountDto: DeleteAccountDto): Promise<DeleteAccountResponseDto> {
|
||
this.logger.log(`deleteAccount: ${JSON.stringify(deleteAccountDto)}`);
|
||
const transaction: Transaction = await this.sequelize.transaction();
|
||
try {
|
||
|
||
const { userId } = deleteAccountDto;
|
||
|
||
// 查找用户
|
||
const user = await this.userModel.findByPk(userId, { transaction });
|
||
if (!user) {
|
||
await transaction.rollback();
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `ID为${userId}的用户不存在`,
|
||
data: { success: false },
|
||
};
|
||
}
|
||
|
||
// 开始删除用户相关数据（使用事务确保数据一致性）
|
||
// 1. 删除用户购买记录
|
||
await this.userPurchaseModel.destroy({
|
||
where: { userId },
|
||
transaction,
|
||
});
|
||
|
||
// 2. 删除用户扩展信息
|
||
await this.userProfileModel.destroy({
|
||
where: { userId },
|
||
transaction,
|
||
});
|
||
|
||
// 最后删除用户本身
|
||
await this.userModel.destroy({
|
||
where: { id: userId },
|
||
transaction,
|
||
});
|
||
|
||
|
||
// 提交事务
|
||
await transaction.commit();
|
||
|
||
this.logger.log(`用户账号删除成功: ${userId}`);
|
||
|
||
// 记录删除账户行为
|
||
await this.activityLogsService.record({
|
||
userId,
|
||
entityType: ActivityEntityType.USER,
|
||
action: ActivityActionType.DELETE,
|
||
entityId: userId,
|
||
changes: null,
|
||
metadata: { reason: 'deleteAccount' },
|
||
});
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: '账号删除成功',
|
||
data: { success: true },
|
||
};
|
||
|
||
} catch (error) {
|
||
// 回滚事务
|
||
await transaction.rollback();
|
||
|
||
this.logger.error(`删除账号失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `删除账号失败: ${error instanceof Error ? error.message : '未知错误'}`,
|
||
data: { success: false },
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 游客登录
|
||
*/
|
||
async guestLogin(guestLoginDto: GuestLoginDto): Promise<GuestLoginResponseDto> {
|
||
try {
|
||
this.logger.log(`guestLogin: ${JSON.stringify(guestLoginDto)}`);
|
||
|
||
const { deviceId, deviceName, deviceModel, iosVersion } = guestLoginDto;
|
||
|
||
// 构造游客用户ID（使用设备ID加前缀）
|
||
const guestUserId = `guest_${deviceId}`;
|
||
|
||
// 查找是否已存在该游客用户
|
||
let user = await this.userModel.findOne({
|
||
where: { id: guestUserId },
|
||
});
|
||
|
||
let isNewUser = false;
|
||
|
||
if (!user) {
|
||
// 创建新的游客用户
|
||
user = await this.userModel.create({
|
||
id: guestUserId,
|
||
name: `游客_${deviceName}`,
|
||
gender: Gender.MALE, // 默认性别
|
||
isGuest: true,
|
||
deviceId,
|
||
deviceName,
|
||
deviceModel,
|
||
iosVersion,
|
||
freeUsageCount: DEFAULT_FREE_USAGE_COUNT,
|
||
lastLogin: new Date(),
|
||
mail: `guest_${deviceId}@gmail.com`,
|
||
});
|
||
|
||
isNewUser = true;
|
||
this.logger.log(`创建新的游客用户: ${guestUserId}`);
|
||
|
||
await this.userProfileModel.findOrCreate({ where: { userId: guestUserId }, defaults: { userId: guestUserId } });
|
||
|
||
} else {
|
||
// 更新现有游客用户的登录时间和设备信息
|
||
user.lastLogin = new Date();
|
||
user.deviceName = deviceName;
|
||
|
||
await user.save();
|
||
this.logger.log(`游客用户登录: ${guestUserId}`);
|
||
}
|
||
|
||
// 生成访问令牌和刷新令牌
|
||
const accessToken = this.appleAuthService.generateAccessToken(guestUserId, user.mail);
|
||
const refreshToken = this.appleAuthService.generateRefreshToken(guestUserId);
|
||
|
||
// 构造用户数据
|
||
const profileForGuest = await this.userProfileModel.findByPk(user.id);
|
||
const userData = {
|
||
...user.toJSON(),
|
||
isNew: isNewUser,
|
||
isVip: user.membershipExpiration ? dayjs(user.membershipExpiration).isAfter(dayjs()) : false,
|
||
isGuest: true,
|
||
maxUsageCount: DEFAULT_FREE_USAGE_COUNT,
|
||
profile: profileForGuest ? {
|
||
dailyStepsGoal: profileForGuest.dailyStepsGoal,
|
||
dailyCaloriesGoal: profileForGuest.dailyCaloriesGoal,
|
||
pilatesPurposes: profileForGuest.pilatesPurposes,
|
||
weight: profileForGuest.weight,
|
||
initialWeight: profileForGuest.initialWeight,
|
||
targetWeight: profileForGuest.targetWeight,
|
||
height: profileForGuest.height,
|
||
activityLevel: profileForGuest.activityLevel,
|
||
} : undefined,
|
||
};
|
||
|
||
await this.activityLogsService.record({
|
||
userId: guestUserId,
|
||
entityType: ActivityEntityType.USER,
|
||
action: ActivityActionType.UPDATE,
|
||
entityId: guestUserId,
|
||
changes: { lastLogin: user.lastLogin },
|
||
metadata: { source: 'guestLogin' },
|
||
});
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: 'success',
|
||
data: {
|
||
accessToken,
|
||
refreshToken,
|
||
expiresIn: this.appleAuthService.getAccessTokenExpiresIn(),
|
||
user: userData,
|
||
},
|
||
};
|
||
|
||
} catch (error) {
|
||
this.logger.error(`游客登录失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `游客登录失败: ${error instanceof Error ? error.message : '未知错误'}`,
|
||
data: null as any,
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 刷新游客令牌
|
||
*/
|
||
async refreshGuestToken(refreshGuestTokenDto: RefreshGuestTokenDto): Promise<RefreshGuestTokenResponseDto> {
|
||
try {
|
||
this.logger.log(`refreshGuestToken: ${JSON.stringify(refreshGuestTokenDto)}`);
|
||
|
||
// 验证刷新令牌并获取用户信息
|
||
const payload = this.appleAuthService.verifyRefreshToken(refreshGuestTokenDto.refreshToken);
|
||
|
||
// 查找用户以获取邮箱信息
|
||
const user = await this.userModel.findByPk(payload.sub);
|
||
if (!user) {
|
||
throw new BadRequestException('用户不存在');
|
||
}
|
||
|
||
// 验证是否为游客用户
|
||
if (!user.isGuest) {
|
||
throw new BadRequestException('非游客用户不能使用此接口');
|
||
}
|
||
|
||
// 生成新的访问令牌
|
||
const result = await this.appleAuthService.refreshAccessToken(refreshGuestTokenDto.refreshToken, user.mail);
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: 'success',
|
||
data: result,
|
||
};
|
||
|
||
} catch (error) {
|
||
this.logger.error(`刷新游客令牌失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `刷新游客令牌失败: ${error instanceof Error ? error.message : '未知错误'}`,
|
||
data: null as any,
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理App Store服务器通知
|
||
*/
|
||
async processAppStoreNotification(notificationDto: AppStoreServerNotificationDto): Promise<ProcessNotificationResponseDto> {
|
||
try {
|
||
this.logger.log(`processAppStoreNotification start: ${JSON.stringify(notificationDto)}`);
|
||
|
||
// 使用ApplePurchaseService处理通知
|
||
const { notificationPayload, transactionInfo, renewalInfo } = await this.applePurchaseService.processServerNotification(
|
||
notificationDto.signedPayload
|
||
);
|
||
|
||
if (!notificationPayload) {
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: '无法解析通知负载',
|
||
data: { processed: false },
|
||
};
|
||
}
|
||
|
||
// 提取基本信息
|
||
const notificationType = notificationPayload.notificationType as NotificationType;
|
||
const notificationUUID = notificationPayload.notificationUUID;
|
||
const bundleId = notificationPayload.data?.bundleId;
|
||
|
||
this.logger.log(`processAppStoreNotification 通知类型: ${notificationType}, UUID: ${notificationUUID}, Bundle ID: ${bundleId}`);
|
||
this.logger.log(`processAppStoreNotification transactionInfo: ${JSON.stringify(transactionInfo)}`);
|
||
this.logger.log(`processAppStoreNotification renewalInfo: ${JSON.stringify(renewalInfo)}`);
|
||
|
||
// 根据通知类型进行具体处理
|
||
const handlerResult = await this.applePurchaseService.handleNotificationByType(
|
||
notificationType,
|
||
transactionInfo,
|
||
renewalInfo
|
||
);
|
||
|
||
// 如果有交易信息，尝试找到对应的用户
|
||
let userId: string | undefined;
|
||
let transactionId: string | undefined;
|
||
|
||
if (transactionInfo) {
|
||
transactionId = transactionInfo.transactionId || transactionInfo.originalTransactionId;
|
||
|
||
// 通过appAccountToken查找用户（如果有的话）
|
||
if (transactionInfo.appAccountToken) {
|
||
const user = await this.userModel.findOne({
|
||
where: { id: transactionInfo.appAccountToken },
|
||
});
|
||
if (user) {
|
||
userId = user.id;
|
||
}
|
||
}
|
||
}
|
||
|
||
this.logger.log(`processAppStoreNotification userId: ${userId}`);
|
||
|
||
if (!userId) {
|
||
this.logger.error(`未找到用户ID，通知处理失败`);
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: '未找到用户ID，通知处理失败',
|
||
data: {
|
||
processed: false,
|
||
},
|
||
};
|
||
}
|
||
|
||
// 根据通知类型执行相应的业务逻辑
|
||
await this.handleNotificationBusinessLogic(notificationType, transactionInfo, renewalInfo, userId);
|
||
|
||
this.logger.log(`processAppStoreNotification App Store通知处理完成: ${JSON.stringify(handlerResult)}`);
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: '通知处理成功',
|
||
data: {
|
||
processed: true,
|
||
notificationType,
|
||
notificationUUID,
|
||
userId,
|
||
transactionId,
|
||
},
|
||
};
|
||
|
||
} catch (error) {
|
||
this.logger.error(`processAppStoreNotification 处理App Store服务器通知失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `处理通知失败: ${error instanceof Error ? error.message : '未知错误'}`,
|
||
data: { processed: false },
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 根据通知类型执行具体的业务逻辑
|
||
*/
|
||
private async handleNotificationBusinessLogic(
|
||
notificationType: NotificationType,
|
||
transactionInfo: any,
|
||
renewalInfo: any,
|
||
userId?: string
|
||
): Promise<void> {
|
||
this.logger.log(`执行业务逻辑 - 通知类型: ${notificationType}, 用户ID: ${userId}`);
|
||
|
||
try {
|
||
switch (notificationType) {
|
||
case NotificationType.SUBSCRIBED:
|
||
await this.handleSubscribedNotification(transactionInfo, renewalInfo, userId);
|
||
break;
|
||
|
||
case NotificationType.DID_RENEW:
|
||
await this.handleRenewalNotification(transactionInfo, renewalInfo, userId);
|
||
break;
|
||
|
||
case NotificationType.EXPIRED:
|
||
await this.handleExpirationNotification(transactionInfo, renewalInfo, userId);
|
||
break;
|
||
|
||
case NotificationType.DID_FAIL_TO_RENEW:
|
||
await this.handleRenewalFailureNotification(transactionInfo, renewalInfo, userId);
|
||
break;
|
||
|
||
case NotificationType.REFUND:
|
||
await this.handleRefundNotification(transactionInfo, renewalInfo, userId);
|
||
break;
|
||
|
||
case NotificationType.REVOKE:
|
||
await this.handleRevokeNotification(transactionInfo, renewalInfo, userId);
|
||
break;
|
||
|
||
case NotificationType.DID_CHANGE_RENEWAL_STATUS:
|
||
await this.handleRenewalStatusChangeNotification(transactionInfo, renewalInfo, userId);
|
||
break;
|
||
|
||
case NotificationType.TEST:
|
||
this.logger.log('收到测试通知，无需特殊处理');
|
||
break;
|
||
|
||
default:
|
||
this.logger.warn(`未处理的通知类型: ${notificationType}`);
|
||
}
|
||
} catch (error) {
|
||
this.logger.error(`执行业务逻辑失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理订阅通知
|
||
*/
|
||
private async handleSubscribedNotification(transactionInfo: any, renewalInfo: any, userId?: string): Promise<void> {
|
||
this.logger.log(`handleSubscribedNotification 处理订阅通知 - 用户ID: ${userId}`);
|
||
|
||
if (!userId || !transactionInfo) {
|
||
this.logger.warn('handleSubscribedNotification 缺少用户ID或交易信息，跳过订阅处理');
|
||
return;
|
||
}
|
||
|
||
// 更新用户订阅状态
|
||
const user = await this.userModel.findByPk(userId);
|
||
if (user && transactionInfo.expiresDate) {
|
||
user.membershipExpiration = new Date(transactionInfo.expiresDate);
|
||
await user.save();
|
||
this.logger.log(`handleSubscribedNotification 用户 ${userId} 订阅状态已更新，到期时间: ${user.membershipExpiration}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理续订通知
|
||
*/
|
||
private async handleRenewalNotification(transactionInfo: any, renewalInfo: any, userId?: string): Promise<void> {
|
||
this.logger.log(`handleRenewalNotification 处理续订通知 - 用户ID: ${userId}`);
|
||
|
||
if (!userId || !transactionInfo) {
|
||
this.logger.warn('handleRenewalNotification 缺少用户ID或交易信息，跳过续订处理');
|
||
return;
|
||
}
|
||
|
||
// 更新用户订阅到期时间
|
||
const user = await this.userModel.findByPk(userId);
|
||
if (user && transactionInfo.expiresDate) {
|
||
user.membershipExpiration = new Date(transactionInfo.expiresDate);
|
||
await user.save();
|
||
this.logger.log(`handleRenewalNotification 用户 ${userId} 订阅已续订，新的到期时间: ${user.membershipExpiration}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理过期通知
|
||
*/
|
||
private async handleExpirationNotification(transactionInfo: any, renewalInfo: any, userId?: string): Promise<void> {
|
||
this.logger.log(`handleExpirationNotification 处理过期通知 - 用户ID: ${userId}`);
|
||
|
||
if (!userId) {
|
||
this.logger.warn('handleExpirationNotification 缺少用户ID，跳过过期处理');
|
||
return;
|
||
}
|
||
|
||
// 可以在这里实现过期后的处理逻辑
|
||
// 例如：发送邮件通知、降级用户权限等
|
||
this.logger.log(`用户 ${userId} 的订阅已过期`);
|
||
}
|
||
|
||
/**
|
||
* 处理续订失败通知
|
||
*/
|
||
private async handleRenewalFailureNotification(transactionInfo: any, renewalInfo: any, userId?: string): Promise<void> {
|
||
this.logger.log(`处理续订失败通知 - 用户ID: ${userId}`);
|
||
|
||
if (!userId) {
|
||
this.logger.warn('缺少用户ID，跳过续订失败处理');
|
||
return;
|
||
}
|
||
|
||
// 可以在这里实现续订失败的处理逻辑
|
||
// 例如：发送付款提醒邮件
|
||
this.logger.log(`用户 ${userId} 的订阅续订失败`);
|
||
}
|
||
|
||
/**
|
||
* 处理退款通知
|
||
*/
|
||
private async handleRefundNotification(transactionInfo: any, renewalInfo: any, userId?: string): Promise<void> {
|
||
this.logger.log(`处理退款通知 - 用户ID: ${userId}`);
|
||
|
||
if (!userId) {
|
||
this.logger.warn('缺少用户ID，跳过退款处理');
|
||
return;
|
||
}
|
||
|
||
// 处理退款逻辑：撤销用户的订阅权限
|
||
const user = await this.userModel.findByPk(userId);
|
||
if (user) {
|
||
// 将会员到期时间设置为当前时间，立即取消会员权限
|
||
user.membershipExpiration = new Date();
|
||
await user.save();
|
||
this.logger.log(`用户 ${userId} 的订阅因退款已被撤销`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理撤销通知
|
||
*/
|
||
private async handleRevokeNotification(transactionInfo: any, renewalInfo: any, userId?: string): Promise<void> {
|
||
this.logger.log(`处理撤销通知 - 用户ID: ${userId}`);
|
||
|
||
if (!userId) {
|
||
this.logger.warn('缺少用户ID，跳过撤销处理');
|
||
return;
|
||
}
|
||
|
||
// 处理撤销逻辑：撤销用户的订阅权限
|
||
const user = await this.userModel.findByPk(userId);
|
||
if (user) {
|
||
user.membershipExpiration = new Date();
|
||
await user.save();
|
||
this.logger.log(`用户 ${userId} 的订阅已被撤销`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理续订状态变更通知
|
||
*/
|
||
private async handleRenewalStatusChangeNotification(transactionInfo: any, renewalInfo: any, userId?: string): Promise<void> {
|
||
this.logger.log(`处理续订状态变更通知 - 用户ID: ${userId}`);
|
||
|
||
if (!userId || !renewalInfo) {
|
||
this.logger.warn('缺少用户ID或续订信息，跳过续订状态变更处理');
|
||
return;
|
||
}
|
||
|
||
// 可以在这里实现续订状态变更的处理逻辑
|
||
// 例如：根据autoRenewStatus更新用户的自动续订设置
|
||
const autoRenewEnabled = renewalInfo.autoRenewStatus === 1;
|
||
this.logger.log(`用户 ${userId} 的自动续订状态: ${autoRenewEnabled ? '启用' : '禁用'}`);
|
||
}
|
||
|
||
async handleRevenueCatWebhook(webhook: RevenueCatWebhookDto): Promise<void> {
|
||
const { event } = webhook;
|
||
|
||
// 1. Check for duplicate event
|
||
const existingEvent = await this.revenueCatEventModel.findOne({
|
||
where: { eventId: event.id },
|
||
});
|
||
|
||
if (existingEvent) {
|
||
this.winstonLogger.warn('RevenueCat event already processed', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
reason: 'duplicate_event'
|
||
});
|
||
return;
|
||
}
|
||
|
||
this.winstonLogger.info('RevenueCat event processing started', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
eventTimestamp: event.event_timestamp_ms
|
||
});
|
||
|
||
// 2. Save the event to the database
|
||
await this.revenueCatEventModel.create({
|
||
eventId: event.id,
|
||
type: event.type,
|
||
appUserId: event.app_user_id,
|
||
eventTimestamp: new Date(event.event_timestamp_ms),
|
||
payload: event,
|
||
});
|
||
|
||
// 3. Process the event based on its type
|
||
const user = await this.userModel.findByPk(event.app_user_id);
|
||
|
||
if (!user) {
|
||
this.winstonLogger.warn('User not found for RevenueCat event', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
reason: 'user_not_found'
|
||
});
|
||
// Even if user not found, we mark event as processed to avoid retries
|
||
return;
|
||
}
|
||
|
||
this.winstonLogger.info('User found for RevenueCat event', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
userId: user.id,
|
||
userEmail: user.mail,
|
||
currentMembershipExpiration: user.membershipExpiration
|
||
});
|
||
|
||
switch (event.type) {
|
||
case RevenueCatEventType.INITIAL_PURCHASE:
|
||
case RevenueCatEventType.RENEWAL:
|
||
case RevenueCatEventType.UNCANCELLATION:
|
||
case RevenueCatEventType.PRODUCT_CHANGE:
|
||
case RevenueCatEventType.NON_RENEWING_PURCHASE:
|
||
case RevenueCatEventType.TRANSFER:
|
||
if (user && typeof event.expiration_at_ms === 'number') {
|
||
const previousExpiration = user.membershipExpiration;
|
||
user.membershipExpiration = new Date(event.expiration_at_ms);
|
||
await user.save();
|
||
|
||
this.winstonLogger.info('Membership updated for purchase event', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
userId: user.id,
|
||
previousExpiration: previousExpiration,
|
||
newExpiration: user.membershipExpiration,
|
||
productId: event.product_id,
|
||
expirationAtMs: event.expiration_at_ms
|
||
});
|
||
}
|
||
break;
|
||
|
||
case RevenueCatEventType.CANCELLATION:
|
||
// For cancellations, you might want to record the cancellation reason
|
||
// but not immediately revoke access. Access is typically revoked on EXPIRATION.
|
||
this.winstonLogger.warn('Subscription cancelled', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
userId: user.id,
|
||
cancelReason: event.cancel_reason,
|
||
productId: event.product_id,
|
||
currentMembershipExpiration: user.membershipExpiration,
|
||
note: 'Access not immediately revoked - will be revoked on EXPIRATION event'
|
||
});
|
||
break;
|
||
|
||
case RevenueCatEventType.EXPIRATION:
|
||
// The subscription has truly expired.
|
||
// You could set membershipExpiration to now or a past date.
|
||
if (user) {
|
||
// Check if the current expiration date is in the future.
|
||
// If so, it means the user might have had a longer plan from a previous purchase
|
||
// and we should not shorten it.
|
||
const now = new Date();
|
||
const previousExpiration = user.membershipExpiration;
|
||
|
||
if (user.membershipExpiration && user.membershipExpiration > now) {
|
||
this.winstonLogger.info('Expiration event ignored - user has future expiration', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
userId: user.id,
|
||
currentExpiration: user.membershipExpiration,
|
||
eventExpirationMs: event.expiration_at_ms,
|
||
reason: 'current_expiration_in_future'
|
||
});
|
||
} else if (typeof event.expiration_at_ms === 'number') {
|
||
user.membershipExpiration = new Date(event.expiration_at_ms);
|
||
await user.save();
|
||
|
||
this.winstonLogger.warn('Membership expired', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
userId: user.id,
|
||
previousExpiration: previousExpiration,
|
||
newExpiration: user.membershipExpiration,
|
||
productId: event.product_id,
|
||
expirationAtMs: event.expiration_at_ms
|
||
});
|
||
}
|
||
}
|
||
break;
|
||
|
||
case RevenueCatEventType.TEST:
|
||
this.winstonLogger.info('RevenueCat test event received', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
note: 'Test event - no processing required'
|
||
});
|
||
break;
|
||
|
||
default:
|
||
this.winstonLogger.warn('Unhandled RevenueCat event type', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
reason: 'unknown_event_type',
|
||
eventData: event
|
||
});
|
||
}
|
||
|
||
// 4. Mark event as processed
|
||
const savedEvent = await this.revenueCatEventModel.findOne({ where: { eventId: event.id } });
|
||
if (savedEvent) {
|
||
savedEvent.processed = true;
|
||
savedEvent.processedAt = new Date();
|
||
await savedEvent.save();
|
||
|
||
this.winstonLogger.info('RevenueCat event processing completed', {
|
||
context: 'UsersService',
|
||
method: 'handleRevenueCatWebhook',
|
||
eventId: event.id,
|
||
eventType: event.type,
|
||
appUserId: event.app_user_id,
|
||
userId: user?.id,
|
||
processedAt: savedEvent.processedAt,
|
||
status: 'completed'
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 恢复购买 - 根据 RevenueCat 客户信息恢复用户的购买记录（安全版本）
|
||
*/
|
||
async restorePurchase(
|
||
restorePurchaseDto: RestorePurchaseDto,
|
||
currentUserId: string,
|
||
clientIp?: string,
|
||
userAgent?: string
|
||
): Promise<RestorePurchaseResponseDto> {
|
||
// 输入验证
|
||
if (!restorePurchaseDto?.customerInfo) {
|
||
return this.createErrorResponse('客户信息不能为空');
|
||
}
|
||
|
||
if (!currentUserId?.trim()) {
|
||
return this.createErrorResponse('用户ID不能为空');
|
||
}
|
||
|
||
const dbTransaction = await this.sequelize.transaction();
|
||
|
||
try {
|
||
this.winstonLogger.info('Restoring purchase', {
|
||
context: 'UsersService',
|
||
method: 'restorePurchase',
|
||
customerInfo: restorePurchaseDto.customerInfo
|
||
});
|
||
|
||
// 验证用户存在性
|
||
const user = await this.validateUserExists(currentUserId, dbTransaction);
|
||
if (!user) {
|
||
await dbTransaction.rollback();
|
||
return this.createErrorResponse('用户不存在');
|
||
}
|
||
|
||
const { customerInfo } = restorePurchaseDto;
|
||
|
||
this.winstonLogger.info('RevenueCat customer info', {
|
||
context: 'UsersService',
|
||
method: 'restorePurchase',
|
||
customerInfo: customerInfo
|
||
});
|
||
|
||
// 🔒 安全验证：检查RevenueCat原始用户ID关联性
|
||
const securityValidation = await this.validateRevenueCatUserAssociation(
|
||
customerInfo.originalAppUserId,
|
||
currentUserId,
|
||
dbTransaction
|
||
);
|
||
|
||
this.winstonLogger.info('RevenueCat security validation', {
|
||
context: 'UsersService',
|
||
method: 'restorePurchase',
|
||
customerInfo: customerInfo,
|
||
securityValidation: securityValidation
|
||
});
|
||
|
||
if (!securityValidation.isValid) {
|
||
await this.logRestoreAttempt(
|
||
currentUserId,
|
||
'',
|
||
'',
|
||
customerInfo.originalAppUserId,
|
||
RestoreStatus.FRAUD_DETECTED,
|
||
securityValidation.reason || '安全验证失败',
|
||
restorePurchaseDto,
|
||
clientIp,
|
||
userAgent,
|
||
dbTransaction
|
||
);
|
||
await dbTransaction.rollback();
|
||
return this.createErrorResponse('安全验证失败：用户身份验证不通过');
|
||
}
|
||
|
||
// 🔒 安全验证：检查被阻止的交易
|
||
const blockedCheck = await this.checkForBlockedTransactions(
|
||
customerInfo,
|
||
dbTransaction
|
||
);
|
||
|
||
this.winstonLogger.info('RevenueCat blocked check', {
|
||
context: 'UsersService',
|
||
method: 'restorePurchase',
|
||
customerInfo: customerInfo,
|
||
blockedCheck: blockedCheck
|
||
});
|
||
|
||
if (blockedCheck.hasBlocked) {
|
||
await this.logRestoreAttempt(
|
||
currentUserId,
|
||
'',
|
||
'',
|
||
customerInfo.originalAppUserId,
|
||
RestoreStatus.FRAUD_DETECTED,
|
||
`检测到被阻止的交易: ${blockedCheck.blockedTransactions.join(', ')}`,
|
||
restorePurchaseDto,
|
||
clientIp,
|
||
userAgent,
|
||
dbTransaction
|
||
);
|
||
await dbTransaction.rollback();
|
||
return this.createErrorResponse(`检测到被阻止的交易，恢复失败。涉及交易: ${blockedCheck.blockedTransactions.join(', ')}`);
|
||
}
|
||
|
||
this.winstonLogger.info('RevenueCat blocked check', {
|
||
context: 'UsersService',
|
||
method: 'restorePurchase',
|
||
customerInfo: customerInfo,
|
||
blockedCheck: blockedCheck
|
||
});
|
||
|
||
// 🔒 安全验证：检查交易ID全局唯一性
|
||
const duplicateCheck = await this.checkForDuplicateTransactions(
|
||
customerInfo,
|
||
currentUserId,
|
||
dbTransaction
|
||
);
|
||
|
||
if (duplicateCheck.hasDuplicates) {
|
||
// 自动阻止重复使用的交易
|
||
await this.autoBlockDuplicateTransactions(
|
||
duplicateCheck.duplicateTransactions,
|
||
'Automatic block due to duplicate usage across multiple accounts',
|
||
dbTransaction
|
||
);
|
||
|
||
await this.logRestoreAttempt(
|
||
currentUserId,
|
||
'',
|
||
'',
|
||
customerInfo.originalAppUserId,
|
||
RestoreStatus.DUPLICATE,
|
||
`检测到重复交易: ${duplicateCheck.duplicateTransactions.join(', ')}`,
|
||
restorePurchaseDto,
|
||
clientIp,
|
||
userAgent,
|
||
dbTransaction
|
||
);
|
||
await dbTransaction.rollback();
|
||
return this.createErrorResponse(`检测到重复交易，恢复失败。涉及交易: ${duplicateCheck.duplicateTransactions.join(', ')}`);
|
||
}
|
||
|
||
const restoredPurchases: RestoredPurchaseInfo[] = [];
|
||
|
||
// 处理活跃权益（带安全日志）
|
||
const activeEntitlementResults = await this.processActiveEntitlements(
|
||
customerInfo.activeEntitlements,
|
||
currentUserId,
|
||
dbTransaction
|
||
);
|
||
|
||
this.winstonLogger.info('RevenueCat active entitlements', {
|
||
context: 'UsersService',
|
||
method: 'restorePurchase',
|
||
customerInfo: customerInfo,
|
||
activeEntitlements: activeEntitlementResults
|
||
});
|
||
|
||
// 记录成功的恢复日志
|
||
await this.logSuccessfulRestores(
|
||
activeEntitlementResults.purchases,
|
||
currentUserId,
|
||
customerInfo.originalAppUserId,
|
||
restorePurchaseDto,
|
||
clientIp,
|
||
userAgent,
|
||
dbTransaction
|
||
);
|
||
|
||
restoredPurchases.push(...activeEntitlementResults.purchases);
|
||
|
||
// 处理非订阅交易（带安全日志）
|
||
const nonSubResults = await this.processNonSubscriptionTransactions(
|
||
customerInfo.nonSubscriptionTransactions,
|
||
currentUserId,
|
||
dbTransaction
|
||
);
|
||
|
||
// 记录成功的恢复日志
|
||
await this.logSuccessfulRestores(
|
||
nonSubResults.purchases,
|
||
currentUserId,
|
||
customerInfo.originalAppUserId,
|
||
restorePurchaseDto,
|
||
clientIp,
|
||
userAgent,
|
||
dbTransaction
|
||
);
|
||
|
||
restoredPurchases.push(...nonSubResults.purchases);
|
||
|
||
// 更新用户会员状态
|
||
const allExpirationDates = [
|
||
...activeEntitlementResults.expirationDates,
|
||
...nonSubResults.expirationDates
|
||
];
|
||
const membershipExpiration = await this.updateUserMembership(
|
||
user,
|
||
allExpirationDates,
|
||
dbTransaction
|
||
);
|
||
|
||
await dbTransaction.commit();
|
||
|
||
const totalRestoredCount = restoredPurchases.length;
|
||
const message = this.generateSuccessMessage(totalRestoredCount, membershipExpiration);
|
||
|
||
this.logger.log(`恢复购买完成 - 用户ID: ${currentUserId}, 恢复了 ${totalRestoredCount} 个购买记录`);
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: totalRestoredCount > 0 ? '购买记录恢复成功' : '未找到可恢复的购买记录',
|
||
data: {
|
||
restoredPurchases,
|
||
membershipExpiration: membershipExpiration?.toISOString(),
|
||
message,
|
||
totalRestoredCount
|
||
}
|
||
};
|
||
|
||
} catch (error) {
|
||
await dbTransaction.rollback();
|
||
this.logger.error(`恢复购买失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return this.createErrorResponse(`恢复购买失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🔒 验证RevenueCat用户关联性
|
||
*/
|
||
private async validateRevenueCatUserAssociation(
|
||
originalAppUserId: string,
|
||
currentUserId: string,
|
||
transaction: Transaction
|
||
): Promise<{ isValid: boolean; reason?: string }> {
|
||
// 检查是否是同一个用户ID（直接匹配）
|
||
if (originalAppUserId === currentUserId) {
|
||
return { isValid: true };
|
||
}
|
||
|
||
// 检查是否是游客用户升级为正式用户的情况
|
||
if (originalAppUserId.startsWith('guest_') && !currentUserId.startsWith('guest_')) {
|
||
// 可以添加更复杂的验证逻辑，比如设备ID匹配等
|
||
this.winstonLogger.warn(`游客用户升级检测: ${originalAppUserId} -> ${currentUserId}`);
|
||
return { isValid: true }; // 暂时允许，但应该添加更严格的验证
|
||
}
|
||
|
||
// 检查是否已经有其他用户使用过这个RevenueCat用户ID
|
||
const existingLog = await this.purchaseRestoreLogModel.findOne({
|
||
where: {
|
||
originalAppUserId,
|
||
status: RestoreStatus.SUCCESS
|
||
},
|
||
transaction
|
||
});
|
||
|
||
if (existingLog && existingLog.userId !== currentUserId) {
|
||
return {
|
||
isValid: false,
|
||
reason: `RevenueCat用户ID ${originalAppUserId} 已被其他用户 ${existingLog.userId} 使用`
|
||
};
|
||
}
|
||
|
||
return { isValid: true };
|
||
}
|
||
|
||
/**
|
||
* 🔒 检查交易ID重复使用
|
||
*/
|
||
private async checkForDuplicateTransactions(
|
||
customerInfo: any,
|
||
currentUserId: string,
|
||
transaction: Transaction
|
||
): Promise<{ hasDuplicates: boolean; duplicateTransactions: string[] }> {
|
||
const allTransactionIds: string[] = [];
|
||
|
||
// 收集所有交易ID
|
||
Object.values(customerInfo.activeEntitlements).forEach((entitlement: any) => {
|
||
if (entitlement.latestPurchaseDate) {
|
||
allTransactionIds.push(entitlement.latestPurchaseDate);
|
||
}
|
||
});
|
||
|
||
customerInfo.nonSubscriptionTransactions.forEach((nonSub: any) => {
|
||
if (nonSub.transactionIdentifier) {
|
||
allTransactionIds.push(nonSub.transactionIdentifier);
|
||
}
|
||
});
|
||
|
||
if (allTransactionIds.length === 0) {
|
||
return { hasDuplicates: false, duplicateTransactions: [] };
|
||
}
|
||
|
||
// 检查这些交易ID是否已被其他用户使用
|
||
const existingLogs = await this.purchaseRestoreLogModel.findAll({
|
||
where: {
|
||
transactionId: allTransactionIds,
|
||
status: RestoreStatus.SUCCESS,
|
||
userId: { [Op.ne]: currentUserId } // 排除当前用户
|
||
},
|
||
transaction
|
||
});
|
||
|
||
const duplicateTransactions = existingLogs.map(log => log.transactionId);
|
||
|
||
return {
|
||
hasDuplicates: duplicateTransactions.length > 0,
|
||
duplicateTransactions
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 🔒 记录恢复尝试日志
|
||
*/
|
||
private async logRestoreAttempt(
|
||
userId: string,
|
||
transactionId: string,
|
||
productId: string,
|
||
originalAppUserId: string,
|
||
status: RestoreStatus,
|
||
failureReason: string | null,
|
||
rawData: any,
|
||
clientIp?: string,
|
||
userAgent?: string,
|
||
transaction?: Transaction
|
||
): Promise<void> {
|
||
try {
|
||
await this.purchaseRestoreLogModel.create({
|
||
userId,
|
||
transactionId,
|
||
productId,
|
||
originalAppUserId,
|
||
status,
|
||
source: RestoreSource.REVENUE_CAT,
|
||
rawData: JSON.stringify(rawData),
|
||
clientIp,
|
||
userAgent,
|
||
failureReason
|
||
}, { transaction });
|
||
} catch (error) {
|
||
this.logger.error(`记录恢复日志失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🔒 记录成功的恢复日志
|
||
*/
|
||
private async logSuccessfulRestores(
|
||
restoredPurchases: RestoredPurchaseInfo[],
|
||
userId: string,
|
||
originalAppUserId: string,
|
||
rawData: any,
|
||
clientIp?: string,
|
||
userAgent?: string,
|
||
transaction?: Transaction
|
||
): Promise<void> {
|
||
try {
|
||
const logPromises = restoredPurchases.map(purchase =>
|
||
this.purchaseRestoreLogModel.create({
|
||
userId,
|
||
transactionId: purchase.transactionId,
|
||
productId: purchase.productId,
|
||
originalAppUserId,
|
||
status: RestoreStatus.SUCCESS,
|
||
source: RestoreSource.REVENUE_CAT,
|
||
rawData: JSON.stringify(rawData),
|
||
clientIp,
|
||
userAgent,
|
||
failureReason: null
|
||
}, { transaction })
|
||
);
|
||
|
||
await Promise.all(logPromises);
|
||
this.logger.log(`记录了 ${restoredPurchases.length} 个成功恢复的购买日志`);
|
||
} catch (error) {
|
||
this.logger.error(`记录成功恢复日志失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🔒 检查被阻止的交易
|
||
*/
|
||
private async checkForBlockedTransactions(
|
||
customerInfo: any,
|
||
transaction: Transaction
|
||
): Promise<{ hasBlocked: boolean; blockedTransactions: string[] }> {
|
||
const allTransactionIds: string[] = [];
|
||
|
||
// 收集所有交易ID
|
||
Object.values(customerInfo.activeEntitlements).forEach((entitlement: any) => {
|
||
if (entitlement.latestPurchaseDate) {
|
||
allTransactionIds.push(entitlement.latestPurchaseDate);
|
||
}
|
||
});
|
||
|
||
customerInfo.nonSubscriptionTransactions.forEach((nonSub: any) => {
|
||
if (nonSub.transactionIdentifier) {
|
||
allTransactionIds.push(nonSub.transactionIdentifier);
|
||
}
|
||
});
|
||
|
||
if (allTransactionIds.length === 0) {
|
||
return { hasBlocked: false, blockedTransactions: [] };
|
||
}
|
||
|
||
// 检查这些交易ID是否被阻止
|
||
const blockedTransactions = await this.blockedTransactionModel.findAll({
|
||
where: {
|
||
transactionId: allTransactionIds,
|
||
isActive: true,
|
||
[Op.or]: [
|
||
{ expiresAt: null }, // 永久阻止
|
||
{ expiresAt: { [Op.gt]: new Date() } } // 未过期的临时阻止
|
||
]
|
||
},
|
||
transaction
|
||
});
|
||
|
||
const blockedTransactionIds = blockedTransactions.map(bt => bt.transactionId);
|
||
|
||
return {
|
||
hasBlocked: blockedTransactionIds.length > 0,
|
||
blockedTransactions: blockedTransactionIds
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 🔒 自动阻止重复使用的交易
|
||
*/
|
||
private async autoBlockDuplicateTransactions(
|
||
transactionIds: string[],
|
||
reason: string,
|
||
transaction?: Transaction
|
||
): Promise<void> {
|
||
try {
|
||
const blockPromises = transactionIds.map(transactionId =>
|
||
this.blockedTransactionModel.findOrCreate({
|
||
where: { transactionId },
|
||
defaults: {
|
||
transactionId,
|
||
blockReason: BlockReason.DUPLICATE_USAGE,
|
||
description: reason,
|
||
isActive: true,
|
||
expiresAt: null // 永久阻止
|
||
},
|
||
transaction
|
||
})
|
||
);
|
||
|
||
await Promise.all(blockPromises);
|
||
this.logger.warn(`自动阻止了 ${transactionIds.length} 个重复使用的交易: ${transactionIds.join(', ')}`);
|
||
} catch (error) {
|
||
this.logger.error(`自动阻止交易失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🔒 手动阻止交易
|
||
*/
|
||
async blockTransaction(
|
||
transactionId: string,
|
||
reason: string,
|
||
operatorId: string,
|
||
expiresAt?: Date
|
||
): Promise<{ success: boolean; message: string }> {
|
||
try {
|
||
const [blockedTransaction, created] = await this.blockedTransactionModel.findOrCreate({
|
||
where: { transactionId },
|
||
defaults: {
|
||
transactionId,
|
||
blockReason: BlockReason.MANUAL_BLOCK,
|
||
description: reason,
|
||
operatorId,
|
||
isActive: true,
|
||
expiresAt: expiresAt || null
|
||
}
|
||
});
|
||
|
||
if (!created) {
|
||
// 更新现有记录
|
||
blockedTransaction.description = reason;
|
||
blockedTransaction.operatorId = operatorId;
|
||
blockedTransaction.isActive = true;
|
||
if (expiresAt) {
|
||
blockedTransaction.expiresAt = expiresAt;
|
||
} else {
|
||
blockedTransaction.expiresAt = null;
|
||
}
|
||
await blockedTransaction.save();
|
||
}
|
||
|
||
this.logger.warn(`交易 ${transactionId} 已被手动阻止，操作员: ${operatorId}, 原因: ${reason}`);
|
||
return { success: true, message: '交易已成功阻止' };
|
||
} catch (error) {
|
||
this.logger.error(`阻止交易失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return { success: false, message: `阻止交易失败: ${error instanceof Error ? error.message : '未知错误'}` };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 🔒 解除交易阻止
|
||
*/
|
||
async unblockTransaction(
|
||
transactionId: string,
|
||
operatorId: string
|
||
): Promise<{ success: boolean; message: string }> {
|
||
try {
|
||
const blockedTransaction = await this.blockedTransactionModel.findOne({
|
||
where: { transactionId, isActive: true }
|
||
});
|
||
|
||
if (!blockedTransaction) {
|
||
return { success: false, message: '未找到被阻止的交易' };
|
||
}
|
||
|
||
blockedTransaction.isActive = false;
|
||
blockedTransaction.operatorId = operatorId;
|
||
await blockedTransaction.save();
|
||
|
||
this.logger.log(`交易 ${transactionId} 已被解除阻止，操作员: ${operatorId}`);
|
||
return { success: true, message: '交易阻止已成功解除' };
|
||
} catch (error) {
|
||
this.logger.error(`解除交易阻止失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return { success: false, message: `解除交易阻止失败: ${error instanceof Error ? error.message : '未知错误'}` };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 验证用户是否存在
|
||
*/
|
||
private async validateUserExists(userId: string, transaction: Transaction): Promise<User | null> {
|
||
return await this.userModel.findByPk(userId, { transaction });
|
||
}
|
||
|
||
/**
|
||
* 处理活跃权益
|
||
*/
|
||
private async processActiveEntitlements(
|
||
activeEntitlements: { [key: string]: ActiveEntitlement },
|
||
userId: string,
|
||
transaction: Transaction
|
||
): Promise<{ purchases: RestoredPurchaseInfo[]; expirationDates: Date[] }> {
|
||
const purchases: RestoredPurchaseInfo[] = [];
|
||
const expirationDates: Date[] = [];
|
||
|
||
this.logger.log(`处理活跃权益 - 数量: ${Object.keys(activeEntitlements).length}`);
|
||
|
||
// 批量查询现有购买记录以避免N+1问题
|
||
const entitlementKeys = Object.keys(activeEntitlements);
|
||
const existingPurchases = await this.getExistingPurchasesForEntitlements(
|
||
userId,
|
||
activeEntitlements,
|
||
transaction
|
||
);
|
||
|
||
for (const [entitlementKey, entitlement] of Object.entries(activeEntitlements)) {
|
||
if (!entitlement.isActive) continue;
|
||
|
||
this.logger.log(`处理权益: ${entitlementKey}, 产品ID: ${entitlement.productIdentifier}`);
|
||
|
||
const purchaseType = this.determinePurchaseType(entitlement.productIdentifier);
|
||
const existingPurchase = existingPurchases.find(p =>
|
||
p.productId === entitlement.productIdentifier &&
|
||
p.transactionId === entitlement.latestPurchaseDate
|
||
);
|
||
|
||
if (!existingPurchase) {
|
||
const expirationDate = await this.createPurchaseRecord(
|
||
userId,
|
||
entitlement,
|
||
purchaseType,
|
||
transaction
|
||
);
|
||
|
||
if (expirationDate) {
|
||
expirationDates.push(expirationDate);
|
||
}
|
||
}
|
||
|
||
// 添加到恢复列表
|
||
purchases.push(this.createRestoredPurchaseInfo(entitlement, entitlementKey, purchaseType));
|
||
}
|
||
|
||
return { purchases, expirationDates };
|
||
}
|
||
|
||
/**
|
||
* 处理非订阅交易
|
||
*/
|
||
private async processNonSubscriptionTransactions(
|
||
nonSubTransactions: NonSubscriptionTransaction[],
|
||
userId: string,
|
||
transaction: Transaction
|
||
): Promise<{ purchases: RestoredPurchaseInfo[]; expirationDates: Date[] }> {
|
||
const purchases: RestoredPurchaseInfo[] = [];
|
||
const expirationDates: Date[] = [];
|
||
|
||
this.logger.log(`处理非订阅交易 - 数量: ${nonSubTransactions.length}`);
|
||
|
||
// 批量查询现有购买记录
|
||
const existingPurchases = await this.getExistingPurchasesForNonSub(
|
||
userId,
|
||
nonSubTransactions,
|
||
transaction
|
||
);
|
||
|
||
for (const nonSubTransaction of nonSubTransactions) {
|
||
this.logger.log(`处理非订阅交易: ${nonSubTransaction.productIdentifier}`);
|
||
|
||
const purchaseType = this.determinePurchaseType(nonSubTransaction.productIdentifier);
|
||
const existingPurchase = existingPurchases.find(p =>
|
||
p.productId === nonSubTransaction.productIdentifier &&
|
||
p.transactionId === nonSubTransaction.transactionIdentifier
|
||
);
|
||
|
||
if (!existingPurchase) {
|
||
const expirationDate = await this.createNonSubPurchaseRecord(
|
||
userId,
|
||
nonSubTransaction,
|
||
purchaseType,
|
||
transaction
|
||
);
|
||
|
||
if (expirationDate) {
|
||
expirationDates.push(expirationDate);
|
||
}
|
||
}
|
||
|
||
// 添加到恢复列表
|
||
purchases.push(this.createRestoredPurchaseInfoFromNonSub(nonSubTransaction, purchaseType));
|
||
}
|
||
|
||
return { purchases, expirationDates };
|
||
}
|
||
|
||
/**
|
||
* 批量查询活跃权益的现有购买记录
|
||
*/
|
||
private async getExistingPurchasesForEntitlements(
|
||
userId: string,
|
||
entitlements: { [key: string]: ActiveEntitlement },
|
||
transaction: Transaction
|
||
): Promise<UserPurchase[]> {
|
||
const conditions = Object.values(entitlements).map(entitlement => ({
|
||
userId,
|
||
productId: entitlement.productIdentifier,
|
||
transactionId: entitlement.latestPurchaseDate
|
||
}));
|
||
|
||
if (conditions.length === 0) return [];
|
||
|
||
return await this.userPurchaseModel.findAll({
|
||
where: {
|
||
[Op.or]: conditions
|
||
},
|
||
transaction
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 批量查询非订阅交易的现有购买记录
|
||
*/
|
||
private async getExistingPurchasesForNonSub(
|
||
userId: string,
|
||
nonSubTransactions: NonSubscriptionTransaction[],
|
||
transaction: Transaction
|
||
): Promise<UserPurchase[]> {
|
||
const conditions = nonSubTransactions.map(transaction => ({
|
||
userId,
|
||
productId: transaction.productIdentifier,
|
||
transactionId: transaction.transactionIdentifier
|
||
}));
|
||
|
||
if (conditions.length === 0) return [];
|
||
|
||
return await this.userPurchaseModel.findAll({
|
||
where: {
|
||
[Op.or]: conditions
|
||
},
|
||
transaction
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 确定购买类型
|
||
*/
|
||
private determinePurchaseType(productIdentifier: string): PurchaseType {
|
||
const productId = productIdentifier.toLowerCase();
|
||
|
||
if (productId.includes('lifetime')) {
|
||
return PurchaseType.LIFETIME;
|
||
} else if (productId.includes('quarterly')) {
|
||
return PurchaseType.QUARTERLY;
|
||
} else if (productId.includes('weekly')) {
|
||
return PurchaseType.WEEKLY;
|
||
}
|
||
|
||
return PurchaseType.WEEKLY; // 默认值
|
||
}
|
||
|
||
/**
|
||
* 创建购买记录（活跃权益）
|
||
*/
|
||
private async createPurchaseRecord(
|
||
userId: string,
|
||
entitlement: ActiveEntitlement,
|
||
purchaseType: PurchaseType,
|
||
transaction: Transaction
|
||
): Promise<Date | null> {
|
||
const expirationDate = entitlement.expirationDate ? new Date(entitlement.expirationDate) : null;
|
||
let finalExpirationDate: Date;
|
||
|
||
if (purchaseType === PurchaseType.LIFETIME && !expirationDate) {
|
||
finalExpirationDate = this.getLifetimeExpirationDate();
|
||
} else if (expirationDate) {
|
||
finalExpirationDate = expirationDate;
|
||
} else {
|
||
return null;
|
||
}
|
||
|
||
await this.userPurchaseModel.create({
|
||
userId,
|
||
purchaseType,
|
||
status: PurchaseStatus.ACTIVE,
|
||
platform: PurchasePlatform.IOS,
|
||
transactionId: entitlement.latestPurchaseDate,
|
||
productId: entitlement.productIdentifier,
|
||
expiresAt: finalExpirationDate
|
||
}, { transaction });
|
||
|
||
this.logger.log(`创建购买记录: ${entitlement.productIdentifier}, 类型: ${purchaseType}`);
|
||
return finalExpirationDate;
|
||
}
|
||
|
||
/**
|
||
* 创建非订阅购买记录
|
||
*/
|
||
private async createNonSubPurchaseRecord(
|
||
userId: string,
|
||
nonSubTransaction: NonSubscriptionTransaction,
|
||
purchaseType: PurchaseType,
|
||
transaction: Transaction
|
||
): Promise<Date> {
|
||
const lifetimeExpiration = this.getLifetimeExpirationDate();
|
||
|
||
await this.userPurchaseModel.create({
|
||
userId,
|
||
purchaseType,
|
||
status: PurchaseStatus.ACTIVE,
|
||
platform: PurchasePlatform.IOS,
|
||
transactionId: nonSubTransaction.transactionIdentifier,
|
||
productId: nonSubTransaction.productIdentifier,
|
||
expiresAt: lifetimeExpiration
|
||
}, { transaction });
|
||
|
||
this.logger.log(`创建非订阅购买记录: ${nonSubTransaction.productIdentifier}, 类型: ${purchaseType}`);
|
||
return lifetimeExpiration;
|
||
}
|
||
|
||
/**
|
||
* 获取终身购买的过期时间
|
||
*/
|
||
private getLifetimeExpirationDate(): Date {
|
||
const LIFETIME_YEARS = 100; // 常量化魔法数字
|
||
const lifetimeExpiration = new Date();
|
||
lifetimeExpiration.setFullYear(lifetimeExpiration.getFullYear() + LIFETIME_YEARS);
|
||
return lifetimeExpiration;
|
||
}
|
||
|
||
/**
|
||
* 创建恢复购买信息（活跃权益）
|
||
*/
|
||
private createRestoredPurchaseInfo(
|
||
entitlement: ActiveEntitlement,
|
||
entitlementKey: string,
|
||
purchaseType: PurchaseType
|
||
): RestoredPurchaseInfo {
|
||
return {
|
||
productId: entitlement.productIdentifier,
|
||
transactionId: entitlement.latestPurchaseDate,
|
||
purchaseDate: entitlement.originalPurchaseDate,
|
||
expirationDate: entitlement.expirationDate || undefined,
|
||
entitlementId: entitlementKey,
|
||
store: entitlement.store,
|
||
purchaseType: purchaseType
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 创建恢复购买信息（非订阅交易）
|
||
*/
|
||
private createRestoredPurchaseInfoFromNonSub(
|
||
nonSubTransaction: NonSubscriptionTransaction,
|
||
purchaseType: PurchaseType
|
||
): RestoredPurchaseInfo {
|
||
return {
|
||
productId: nonSubTransaction.productIdentifier,
|
||
transactionId: nonSubTransaction.transactionIdentifier,
|
||
purchaseDate: nonSubTransaction.purchaseDate,
|
||
entitlementId: nonSubTransaction.productIdentifier,
|
||
store: 'APP_STORE',
|
||
purchaseType: purchaseType
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 更新用户会员状态
|
||
*/
|
||
private async updateUserMembership(
|
||
user: User,
|
||
expirationDates: Date[],
|
||
transaction: Transaction
|
||
): Promise<Date | null> {
|
||
if (expirationDates.length === 0) return null;
|
||
|
||
const latestExpirationDate = new Date(Math.max(...expirationDates.map(date => date.getTime())));
|
||
const currentExpiration = user.membershipExpiration;
|
||
|
||
if (!currentExpiration || latestExpirationDate > currentExpiration) {
|
||
user.membershipExpiration = latestExpirationDate;
|
||
await user.save({ transaction });
|
||
|
||
this.winstonLogger.info(`用户 ${user.id} 的会员状态已更新，过期时间: ${latestExpirationDate}`, {
|
||
context: 'UsersService',
|
||
method: 'updateUserMembership',
|
||
user
|
||
});
|
||
return latestExpirationDate;
|
||
}
|
||
|
||
return currentExpiration;
|
||
}
|
||
|
||
/**
|
||
* 生成成功消息
|
||
*/
|
||
private generateSuccessMessage(totalRestoredCount: number, membershipExpiration: Date | null): string {
|
||
if (totalRestoredCount === 0) {
|
||
return '未找到可恢复的购买记录';
|
||
}
|
||
|
||
let message = `成功恢复 ${totalRestoredCount} 个购买记录`;
|
||
if (membershipExpiration) {
|
||
message += `，会员有效期至 ${dayjs(membershipExpiration).format('YYYY-MM-DD HH:mm:ss')}`;
|
||
}
|
||
return message;
|
||
}
|
||
|
||
/**
|
||
* 创建错误响应
|
||
*/
|
||
private createErrorResponse(message: string): RestorePurchaseResponseDto {
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message,
|
||
data: {
|
||
restoredPurchases: [],
|
||
message,
|
||
totalRestoredCount: 0
|
||
}
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 调用 RevenueCat API 获取用户信息
|
||
*/
|
||
private async getRevenueCatCustomerInfo(userId: string): Promise<any> {
|
||
try {
|
||
const REVENUECAT_PUBLIC_API_KEY = process.env.REVENUECAT_PUBLIC_API_KEY;
|
||
const REVENUECAT_APP_USER_ID = userId;
|
||
|
||
if (!REVENUECAT_PUBLIC_API_KEY) {
|
||
throw new Error('RevenueCat API key 未配置');
|
||
}
|
||
|
||
// RevenueCat REST API v1 endpoint
|
||
const url = `https://api.revenuecat.com/v2/subscribers/${REVENUECAT_APP_USER_ID}`;
|
||
|
||
const response = await fetch(url, {
|
||
method: 'GET',
|
||
headers: {
|
||
'Authorization': `Bearer ${REVENUECAT_PUBLIC_API_KEY}`,
|
||
'Content-Type': 'application/json',
|
||
},
|
||
});
|
||
|
||
if (!response.ok) {
|
||
if (response.status === 404) {
|
||
this.logger.warn(`RevenueCat 中未找到用户: ${userId}`);
|
||
return null;
|
||
}
|
||
throw new Error(`RevenueCat API 请求失败: ${response.status} ${response.statusText}`);
|
||
}
|
||
|
||
const data = await response.json();
|
||
this.logger.log(`RevenueCat API 响应: ${JSON.stringify(data)}`);
|
||
return data;
|
||
|
||
} catch (error) {
|
||
this.logger.error(`调用 RevenueCat API 失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 关联 RevenueCat 用户ID 与当前用户ID
|
||
*/
|
||
private async linkRevenueCatUser(oldRevenueCatUserId: string, newUserId: string): Promise<void> {
|
||
try {
|
||
const REVENUECAT_SECRET_API_KEY = process.env.REVENUECAT_SECRET_API_KEY;
|
||
|
||
if (!REVENUECAT_SECRET_API_KEY) {
|
||
this.logger.warn('RevenueCat Secret API key 未配置，跳过用户关联');
|
||
return;
|
||
}
|
||
|
||
// 调用 RevenueCat API 创建用户别名
|
||
const url = `https://api.revenuecat.com/v1/subscribers/${oldRevenueCatUserId}/alias`;
|
||
|
||
const response = await fetch(url, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Authorization': `Bearer ${REVENUECAT_SECRET_API_KEY}`,
|
||
'Content-Type': 'application/json',
|
||
},
|
||
body: JSON.stringify({
|
||
new_app_user_id: newUserId
|
||
}),
|
||
});
|
||
|
||
if (response.ok) {
|
||
this.logger.log(`成功关联 RevenueCat 用户: ${oldRevenueCatUserId} -> ${newUserId}`);
|
||
} else {
|
||
this.logger.warn(`RevenueCat 用户关联失败: ${response.status} ${response.statusText}`);
|
||
}
|
||
|
||
} catch (error) {
|
||
this.logger.error(`关联 RevenueCat 用户失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取用户最近六个月的活跃情况
|
||
*/
|
||
async getUserActivityHistory(userId: string): Promise<GetUserActivityHistoryResponseDto> {
|
||
try {
|
||
const activityHistory = await this.userActivityService.getUserActivityHistory(userId);
|
||
|
||
return {
|
||
code: ResponseCode.SUCCESS,
|
||
message: 'success',
|
||
data: activityHistory,
|
||
};
|
||
} catch (error) {
|
||
this.logger.error(`获取用户活跃历史失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
||
return {
|
||
code: ResponseCode.ERROR,
|
||
message: `获取用户活跃历史失败: ${error instanceof Error ? error.message : '未知错误'}`,
|
||
data: [],
|
||
};
|
||
}
|
||
}
|
||
}
|