844 lines
25 KiB
TypeScript
844 lines
25 KiB
TypeScript
import cloud from '@lafjs/cloud'
|
||
|
||
export default async function (ctx: FunctionContext) {
|
||
console.log('Hello World')
|
||
return { data: 'hi, laf' }
|
||
}
|
||
export type JungleRewardType = "coin" | "freeze" | "hammer" | "magic_wand" | "infinite_health";
|
||
|
||
export interface JungleRewardConfig {
|
||
type: JungleRewardType;
|
||
count: number;
|
||
itemId?: number;
|
||
}
|
||
|
||
export interface JungleTierConfig {
|
||
id: number;
|
||
price: number;
|
||
isPaid: boolean;
|
||
productId: string;
|
||
priceTemporary?: boolean;
|
||
rewards: JungleRewardConfig[];
|
||
}
|
||
|
||
export interface JungleTreasureConfig {
|
||
activityId: string;
|
||
version: number;
|
||
totalTiers: number;
|
||
tiers: JungleTierConfig[];
|
||
}
|
||
|
||
export type JungleActivityType = "personal" | "calendar";
|
||
|
||
export interface JungleCalendarConfig {
|
||
enabled: boolean;
|
||
dayOfMonth: number;
|
||
startHour: number;
|
||
startMinute: number;
|
||
timezoneOffsetMinutes: number;
|
||
durationMs: number;
|
||
testUserIds: readonly string[];
|
||
}
|
||
|
||
export interface JungleCalendarPeriod {
|
||
key: string;
|
||
startsAt: number;
|
||
expiresAt: number;
|
||
}
|
||
|
||
/** 0=付费档未解锁，1=已解锁未领取，2=已领取。 */
|
||
export type JungleTierState = 0 | 1 | 2;
|
||
|
||
/** 仅服务端存储，paidOrderNos 不返回客户端。 */
|
||
export interface JungleStoredState {
|
||
activityId: string;
|
||
configVersion: number;
|
||
activityType: JungleActivityType;
|
||
periodKey: string;
|
||
startsAt: number;
|
||
firstTriggered: boolean;
|
||
lastCalendarPeriodKey: string;
|
||
tierStates: JungleTierState[];
|
||
paidOrderNos: Record<string, string>;
|
||
revision: number;
|
||
expiresAt: number;
|
||
updatedAt: number;
|
||
}
|
||
|
||
export interface JungleUnlockResult {
|
||
ok: boolean;
|
||
changed: boolean;
|
||
tierId?: number;
|
||
state?: JungleStoredState;
|
||
message?: string;
|
||
}
|
||
|
||
export interface JungleClaimResult {
|
||
ok: boolean;
|
||
tierId?: number;
|
||
paidOrderNo?: string;
|
||
state?: JungleStoredState;
|
||
message?: string;
|
||
}
|
||
|
||
export type JungleRewardTotals = Record<JungleRewardType, number>;
|
||
|
||
export interface JungleExpiredSettlementResult {
|
||
ok: boolean;
|
||
claimedTierIds: number[];
|
||
rewards: JungleRewardTotals;
|
||
state?: JungleStoredState;
|
||
message?: string;
|
||
}
|
||
|
||
export interface JungleActivityResolution {
|
||
available: boolean;
|
||
changed: boolean;
|
||
state?: JungleStoredState;
|
||
reason: string;
|
||
}
|
||
|
||
export interface JungleActivityResolutionOptions {
|
||
allowCalendarStart?: boolean;
|
||
calendarConfig?: JungleCalendarConfig;
|
||
calendarUserId?: unknown;
|
||
}
|
||
|
||
export const JUNGLE_TREASURE_ACTIVITY_ID = "jungle_treasure_v1";
|
||
export const JUNGLE_TREASURE_CONFIG_VERSION = 2;
|
||
export const JUNGLE_TREASURE_TOTAL_TIERS = 51;
|
||
export const JUNGLE_TREASURE_DURATION_MS = 7 * 24 * 60 * 60 * 1000;
|
||
/** 全服周期正式配置：每月 28 日 00:00（北京时间）开始。 */
|
||
export const JUNGLE_TREASURE_CALENDAR_CONFIG: JungleCalendarConfig = {
|
||
enabled: true,
|
||
dayOfMonth: 28,
|
||
startHour: 0,
|
||
startMinute: 0,
|
||
timezoneOffsetMinutes: 8 * 60,
|
||
durationMs: JUNGLE_TREASURE_DURATION_MS,
|
||
testUserIds: [],
|
||
};
|
||
|
||
/** 后端礼包配置入口。修改数值时只调整此函数中的档位数据。 */
|
||
export function createJungleTreasureConfig(): JungleTreasureConfig {
|
||
const tiers: JungleTierConfig[] = [
|
||
createTier(1, 0, [{ type: "coin", count: 100 }]),
|
||
createTier(2, 0, [{ type: "hammer", count: 1 }]),
|
||
createTier(3, 0, [
|
||
{ type: "coin", count: 200 },
|
||
{ type: "freeze", count: 1 },
|
||
{ type: "magic_wand", count: 1 },
|
||
]),
|
||
createTier(4, 3, [{ type: "coin", count: 700 }], "jungle_treasure_1"),
|
||
createTier(5, 0, [{ type: "hammer", count: 1 }]),
|
||
createTier(6, 0, [{ type: "infinite_health", count: 900 }]),
|
||
createTier(7, 0, [
|
||
{ type: "coin", count: 200 },
|
||
{ type: "magic_wand", count: 1 },
|
||
]),
|
||
createTier(8, 0, [{ type: "coin", count: 100 }]),
|
||
createTier(9, 0, [{ type: "freeze", count: 1 }]),
|
||
createTier(10, 6, [
|
||
{ type: "coin", count: 1500 },
|
||
{ type: "freeze", count: 1 },
|
||
{ type: "magic_wand", count: 1 },
|
||
], "jungle_treasure_2"),
|
||
createTier(11, 0, [{ type: "infinite_health", count: 900 }]),
|
||
createTier(12, 0, [{ type: "hammer", count: 1 }]),
|
||
createTier(13, 0, [{ type: "coin", count: 500 }]),
|
||
createTier(14, 0, [{ type: "hammer", count: 1 }]),
|
||
createTier(15, 0, [{ type: "magic_wand", count: 1 }]),
|
||
createTier(16, 9, [
|
||
{ type: "coin", count: 2000 },
|
||
{ type: "freeze", count: 1 },
|
||
{ type: "magic_wand", count: 1 },
|
||
], "jungle_treasure_3"),
|
||
createTier(17, 0, [{ type: "infinite_health", count: 900 }]),
|
||
createTier(18, 0, [
|
||
{ type: "hammer", count: 2 },
|
||
{ type: "freeze", count: 2 },
|
||
{ type: "magic_wand", count: 2 },
|
||
]),
|
||
createTier(19, 0, [{ type: "coin", count: 200 }]),
|
||
createTier(20, 0, [{ type: "freeze", count: 1 }]),
|
||
createTier(21, 0, [{ type: "magic_wand", count: 1 }]),
|
||
createTier(22, 15, [
|
||
{ type: "coin", count: 3000 },
|
||
{ type: "freeze", count: 3 },
|
||
{ type: "magic_wand", count: 3 },
|
||
], "jungle_treasure_4"),
|
||
createTier(23, 0, [
|
||
{ type: "hammer", count: 2 },
|
||
{ type: "freeze", count: 1 },
|
||
]),
|
||
createTier(24, 0, [
|
||
{ type: "infinite_health", count: 1800 },
|
||
{ type: "freeze", count: 2 },
|
||
]),
|
||
createTier(25, 0, [{ type: "magic_wand", count: 2 }]),
|
||
createTier(26, 0, [{ type: "hammer", count: 1 }]),
|
||
createTier(27, 0, [{ type: "magic_wand", count: 1 }]),
|
||
createTier(28, 24, [
|
||
{ type: "coin", count: 5000 },
|
||
{ type: "hammer", count: 2 },
|
||
], "jungle_treasure_5"),
|
||
createTier(29, 0, [
|
||
{ type: "hammer", count: 2 },
|
||
{ type: "freeze", count: 1 },
|
||
{ type: "magic_wand", count: 1 },
|
||
]),
|
||
createTier(30, 0, [
|
||
{ type: "freeze", count: 4 },
|
||
{ type: "magic_wand", count: 4 },
|
||
]),
|
||
createTier(31, 0, [
|
||
{ type: "infinite_health", count: 1800 },
|
||
{ type: "freeze", count: 2 },
|
||
]),
|
||
createTier(32, 0, [{ type: "magic_wand", count: 2 }]),
|
||
createTier(33, 0, [
|
||
{ type: "freeze", count: 1 },
|
||
{ type: "magic_wand", count: 1 },
|
||
]),
|
||
createTier(34, 42, [
|
||
{ type: "coin", count: 10000 },
|
||
{ type: "hammer", count: 3 },
|
||
{ type: "freeze", count: 5 },
|
||
], "jungle_treasure_6"),
|
||
createTier(35, 0, [
|
||
{ type: "coin", count: 3000 },
|
||
{ type: "freeze", count: 2 },
|
||
{ type: "magic_wand", count: 2 },
|
||
]),
|
||
createTier(36, 0, [
|
||
{ type: "infinite_health", count: 3600 },
|
||
{ type: "hammer", count: 2 },
|
||
]),
|
||
createTier(37, 0, [
|
||
{ type: "coin", count: 2000 },
|
||
{ type: "magic_wand", count: 5 },
|
||
]),
|
||
createTier(38, 0, [{ type: "freeze", count: 3 }]),
|
||
createTier(39, 0, [{ type: "magic_wand", count: 3 }]),
|
||
createTier(40, 68, [
|
||
{ type: "coin", count: 21000 },
|
||
{ type: "hammer", count: 10 },
|
||
], "jungle_treasure_7"),
|
||
createTier(41, 0, [
|
||
{ type: "infinite_health", count: 7200 },
|
||
{ type: "freeze", count: 15 },
|
||
]),
|
||
createTier(42, 0, [{ type: "magic_wand", count: 15 }]),
|
||
createTier(43, 0, [{ type: "coin", count: 2500 }]),
|
||
createTier(44, 0, [{ type: "freeze", count: 5 }]),
|
||
createTier(45, 0, [{ type: "magic_wand", count: 5 }]),
|
||
createTier(46, 98, [
|
||
{ type: "coin", count: 35000 },
|
||
{ type: "freeze", count: 15 },
|
||
{ type: "magic_wand", count: 15 },
|
||
], "jungle_treasure_8"),
|
||
createTier(47, 0, [
|
||
{ type: "infinite_health", count: 14400 },
|
||
{ type: "hammer", count: 10 },
|
||
]),
|
||
createTier(48, 0, [{ type: "hammer", count: 5 }]),
|
||
createTier(49, 0, [
|
||
{ type: "freeze", count: 10 },
|
||
{ type: "magic_wand", count: 5 },
|
||
]),
|
||
createTier(50, 0, [{ type: "coin", count: 2500 }]),
|
||
createTier(51, 0, [
|
||
{ type: "freeze", count: 5 },
|
||
{ type: "magic_wand", count: 10 },
|
||
]),
|
||
];
|
||
|
||
validateTierOrder(tiers);
|
||
return {
|
||
activityId: JUNGLE_TREASURE_ACTIVITY_ID,
|
||
version: JUNGLE_TREASURE_CONFIG_VERSION,
|
||
totalTiers: JUNGLE_TREASURE_TOTAL_TIERS,
|
||
tiers,
|
||
};
|
||
}
|
||
|
||
export const JUNGLE_TREASURE_CONFIG = createJungleTreasureConfig();
|
||
|
||
export function createDefaultJungleState(now = Date.now()): JungleStoredState {
|
||
return createStoredState(
|
||
JUNGLE_TREASURE_CONFIG.tiers.map((tier) => tier.isPaid ? 0 : 1),
|
||
{},
|
||
0,
|
||
now + JUNGLE_TREASURE_DURATION_MS,
|
||
now,
|
||
{
|
||
activityType: "personal",
|
||
periodKey: "",
|
||
startsAt: now,
|
||
firstTriggered: true,
|
||
lastCalendarPeriodKey: "",
|
||
},
|
||
);
|
||
}
|
||
|
||
/** 只处理当前 JSON 字符串状态；无状态时创建默认 7 天数据。 */
|
||
export function normalizeStoredJungleState(raw: unknown, now = Date.now()): JungleStoredState {
|
||
const value = parseUnknownValue(raw);
|
||
const defaultState = createDefaultJungleState(now);
|
||
if (!value || Array.isArray(value) || !Array.isArray(value.tierStates)) {
|
||
return defaultState;
|
||
}
|
||
|
||
const expiresAt = toPositiveTimestamp(value.expiresAt);
|
||
if (!expiresAt) {
|
||
return defaultState;
|
||
}
|
||
|
||
const tierStates = [...defaultState.tierStates];
|
||
for (let index = 0; index < JUNGLE_TREASURE_TOTAL_TIERS; index++) {
|
||
const configuredTier = JUNGLE_TREASURE_CONFIG.tiers[index];
|
||
const state = toTierState(value.tierStates[index]);
|
||
if (state !== null) {
|
||
tierStates[index] = configuredTier.isPaid ? state : (state === 2 ? 2 : 1);
|
||
}
|
||
else {
|
||
tierStates[index] = defaultState.tierStates[index];
|
||
}
|
||
}
|
||
|
||
return createStoredState(
|
||
tierStates,
|
||
normalizePaidOrderNos(value),
|
||
toNonNegativeInteger(value.revision),
|
||
expiresAt,
|
||
toNonNegativeInteger(value.updatedAt) || now,
|
||
{
|
||
activityType: value.activityType === "calendar" ? "calendar" : "personal",
|
||
periodKey: normalizePeriodKey(value.periodKey),
|
||
startsAt: toPositiveTimestamp(value.startsAt)
|
||
|| Math.max(1, expiresAt - JUNGLE_TREASURE_DURATION_MS),
|
||
// 任何已有 Jungle 状态都视为首次独立活动已经触发。
|
||
firstTriggered: true,
|
||
lastCalendarPeriodKey: normalizePeriodKey(value.lastCalendarPeriodKey),
|
||
},
|
||
);
|
||
}
|
||
|
||
export function isCurrentJungleState(raw: unknown): boolean {
|
||
const value = parseUnknownValue(raw);
|
||
return Boolean(
|
||
value
|
||
&& !Array.isArray(value)
|
||
&& value.activityId === JUNGLE_TREASURE_ACTIVITY_ID
|
||
&& value.configVersion === JUNGLE_TREASURE_CONFIG_VERSION
|
||
&& (value.activityType === "personal" || value.activityType === "calendar")
|
||
&& typeof value.periodKey === "string"
|
||
&& toPositiveTimestamp(value.startsAt) > 0
|
||
&& value.firstTriggered === true
|
||
&& typeof value.lastCalendarPeriodKey === "string"
|
||
&& Array.isArray(value.tierStates)
|
||
&& value.tierStates.length === JUNGLE_TREASURE_TOTAL_TIERS
|
||
&& value.tierStates.every((item: unknown) => toTierState(item) !== null)
|
||
&& toPositiveTimestamp(value.expiresAt) > 0
|
||
);
|
||
}
|
||
|
||
/** 用户表中按 JSON 字符串保存，避免 Laf 数据面板展开 51 项状态数组。 */
|
||
export function serializeJungleState(state: JungleStoredState): string {
|
||
return JSON.stringify(state);
|
||
}
|
||
|
||
export function getJunglePaidTierByProductId(productId: unknown): JungleTierConfig | null {
|
||
const normalizedProductId = String(productId || "").trim();
|
||
if (!normalizedProductId) {
|
||
return null;
|
||
}
|
||
return JUNGLE_TREASURE_CONFIG.tiers.find(
|
||
(tier) => tier.isPaid && tier.productId === normalizedProductId,
|
||
) || null;
|
||
}
|
||
|
||
/** 返回当前正在进行的月历窗口；窗口外返回 null。 */
|
||
export function getCurrentJungleCalendarPeriod(
|
||
now = Date.now(),
|
||
config: JungleCalendarConfig = JUNGLE_TREASURE_CALENDAR_CONFIG,
|
||
): JungleCalendarPeriod | null {
|
||
if (!isValidJungleCalendarConfig(config) || !Number.isFinite(now) || now <= 0) {
|
||
return null;
|
||
}
|
||
|
||
const offsetMs = config.timezoneOffsetMinutes * 60 * 1000;
|
||
const localNow = new Date(now + offsetMs);
|
||
let year = localNow.getUTCFullYear();
|
||
let month = localNow.getUTCMonth();
|
||
let startsAt = Date.UTC(
|
||
year,
|
||
month,
|
||
config.dayOfMonth,
|
||
config.startHour,
|
||
config.startMinute,
|
||
) - offsetMs;
|
||
if (now < startsAt) {
|
||
month--;
|
||
if (month < 0) {
|
||
month = 11;
|
||
year--;
|
||
}
|
||
startsAt = Date.UTC(
|
||
year,
|
||
month,
|
||
config.dayOfMonth,
|
||
config.startHour,
|
||
config.startMinute,
|
||
) - offsetMs;
|
||
}
|
||
|
||
const expiresAt = startsAt + config.durationMs;
|
||
if (now < startsAt || now >= expiresAt) {
|
||
return null;
|
||
}
|
||
return {
|
||
key: `${year}-${String(month + 1).padStart(2, "0")}`,
|
||
startsAt,
|
||
expiresAt,
|
||
};
|
||
}
|
||
|
||
export function isValidJungleCalendarConfig(
|
||
config: JungleCalendarConfig = JUNGLE_TREASURE_CALENDAR_CONFIG,
|
||
): boolean {
|
||
return Boolean(
|
||
config
|
||
&& typeof config.enabled === "boolean"
|
||
&& Number.isInteger(config.dayOfMonth)
|
||
&& config.dayOfMonth >= 1
|
||
&& config.dayOfMonth <= 28
|
||
&& Number.isInteger(config.startHour)
|
||
&& config.startHour >= 0
|
||
&& config.startHour <= 23
|
||
&& Number.isInteger(config.startMinute)
|
||
&& config.startMinute >= 0
|
||
&& config.startMinute <= 59
|
||
&& Number.isInteger(config.timezoneOffsetMinutes)
|
||
&& Math.abs(config.timezoneOffsetMinutes) <= 14 * 60
|
||
&& Number.isFinite(config.durationMs)
|
||
&& config.durationMs > 0
|
||
&& Array.isArray(config.testUserIds)
|
||
&& config.testUserIds.every((uid) => typeof uid === "string" && Boolean(uid.trim()))
|
||
);
|
||
}
|
||
|
||
/** 全服开关关闭时，仅后端代码白名单中的用户可开启月历活动。 */
|
||
export function isJungleCalendarEnabledForUser(
|
||
userId: unknown,
|
||
config: JungleCalendarConfig = JUNGLE_TREASURE_CALENDAR_CONFIG,
|
||
): boolean {
|
||
if (!isValidJungleCalendarConfig(config)) {
|
||
return false;
|
||
}
|
||
if (config.enabled) {
|
||
return true;
|
||
}
|
||
const normalizedUserId = String(userId || "").trim();
|
||
return Boolean(
|
||
normalizedUserId
|
||
&& config.testUserIds.some((uid) => uid.trim() === normalizedUserId),
|
||
);
|
||
}
|
||
|
||
/** C 方案：只统计第一处未解锁付费档之前尚未领取的档位。 */
|
||
export function hasBlockingJungleClaims(raw: unknown, now = Date.now()): boolean {
|
||
const state = normalizeStoredJungleState(raw, now);
|
||
for (const tierState of state.tierStates) {
|
||
if (tierState === 0) {
|
||
break;
|
||
}
|
||
if (tierState === 1) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/** 到期结算只领取第一处未解锁付费档之前的 state=1 档位。 */
|
||
export function settleExpiredJungleTiers(
|
||
raw: unknown,
|
||
now = Date.now(),
|
||
): JungleExpiredSettlementResult {
|
||
const state = normalizeStoredJungleState(raw, now);
|
||
const rewards = createEmptyRewardTotals();
|
||
if (now < state.expiresAt) {
|
||
return { ok: false, claimedTierIds: [], rewards, message: "Jungle 活动尚未结束" };
|
||
}
|
||
|
||
const tierStates = [...state.tierStates];
|
||
const claimedTierIds: number[] = [];
|
||
for (let index = 0; index < tierStates.length; index++) {
|
||
const tierState = tierStates[index];
|
||
if (tierState === 0) {
|
||
break;
|
||
}
|
||
if (tierState !== 1) {
|
||
continue;
|
||
}
|
||
tierStates[index] = 2;
|
||
claimedTierIds.push(index + 1);
|
||
for (const reward of JUNGLE_TREASURE_CONFIG.tiers[index].rewards) {
|
||
rewards[reward.type] += reward.count;
|
||
}
|
||
}
|
||
|
||
if (claimedTierIds.length === 0) {
|
||
return { ok: false, claimedTierIds, rewards, message: "当前没有可结算的 Jungle 奖励" };
|
||
}
|
||
|
||
return {
|
||
ok: true,
|
||
claimedTierIds,
|
||
rewards,
|
||
state: createStoredState(
|
||
tierStates,
|
||
state.paidOrderNos,
|
||
state.revision + 1,
|
||
state.expiresAt,
|
||
now,
|
||
getStoredStateMetadata(state),
|
||
),
|
||
};
|
||
}
|
||
|
||
/**
|
||
* read 调用时解析玩家应看到的活动。无历史状态优先创建首次独立活动；
|
||
* 已有状态结束后，只有月历窗口内且边界时未被旧活动阻挡才创建统一周期。
|
||
*/
|
||
export function resolveJungleActivity(
|
||
raw: unknown,
|
||
now = Date.now(),
|
||
options: JungleActivityResolutionOptions = {},
|
||
): JungleActivityResolution {
|
||
const config = options.calendarConfig || JUNGLE_TREASURE_CALENDAR_CONFIG;
|
||
const allowCalendarStart = options.allowCalendarStart !== false;
|
||
if (!hasStoredJungleValue(raw)) {
|
||
return {
|
||
available: true,
|
||
changed: true,
|
||
state: createDefaultJungleState(now),
|
||
reason: "personal_started",
|
||
};
|
||
}
|
||
|
||
let state = normalizeStoredJungleState(raw, now);
|
||
let changed = !isCurrentJungleState(raw) || typeof raw !== "string";
|
||
if (now < state.expiresAt) {
|
||
return { available: true, changed, state, reason: "active" };
|
||
}
|
||
|
||
const period = getCurrentJungleCalendarPeriod(now, config);
|
||
if (hasBlockingJungleClaims(state, now)) {
|
||
if (period && state.lastCalendarPeriodKey !== period.key) {
|
||
state = markCalendarPeriodHandled(state, period.key, now);
|
||
changed = true;
|
||
}
|
||
return { available: true, changed, state, reason: "claim_only" };
|
||
}
|
||
|
||
if (!isValidJungleCalendarConfig(config)) {
|
||
return { available: false, changed, state, reason: "invalid_calendar_config" };
|
||
}
|
||
if (!period) {
|
||
return { available: false, changed, state, reason: "outside_calendar_window" };
|
||
}
|
||
if (state.lastCalendarPeriodKey === period.key) {
|
||
return { available: false, changed, state, reason: "calendar_period_handled" };
|
||
}
|
||
if (state.expiresAt > period.startsAt) {
|
||
state = markCalendarPeriodHandled(state, period.key, now);
|
||
return { available: false, changed: true, state, reason: "blocked_at_calendar_start" };
|
||
}
|
||
if (!isJungleCalendarEnabledForUser(options.calendarUserId, config)) {
|
||
state = markCalendarPeriodHandled(state, period.key, now);
|
||
return { available: false, changed: true, state, reason: "calendar_disabled" };
|
||
}
|
||
if (!allowCalendarStart) {
|
||
return { available: false, changed, state, reason: "calendar_start_not_allowed" };
|
||
}
|
||
|
||
return {
|
||
available: true,
|
||
changed: true,
|
||
state: createCalendarJungleState(period, state, now),
|
||
reason: "calendar_started",
|
||
};
|
||
}
|
||
|
||
/** Jungle 下单只校验订单创建瞬间是否仍处于活动倒计时内。 */
|
||
export function isJungleActivityPurchasable(raw: unknown, now = Date.now()): boolean {
|
||
const value = parseUnknownValue(raw);
|
||
if (!value || Array.isArray(value) || !Array.isArray(value.tierStates)) {
|
||
return false;
|
||
}
|
||
const state = normalizeStoredJungleState(value, now);
|
||
return now >= state.startsAt && now < state.expiresAt;
|
||
}
|
||
|
||
export function unlockJungleTierByProductId(
|
||
raw: unknown,
|
||
productId: unknown,
|
||
outTradeNo = "",
|
||
now = Date.now(),
|
||
): JungleUnlockResult {
|
||
const tier = getJunglePaidTierByProductId(productId);
|
||
if (!tier) {
|
||
return { ok: false, changed: false, message: "未找到对应的 Jungle 付费档位" };
|
||
}
|
||
|
||
// Laf 可能暂时使用共享函数的旧类型缓存，这里按实际返回结构读取新字段。
|
||
const state: any = normalizeStoredJungleState(raw, now);
|
||
const stateExpiresAt = Number(state["expiresAt"]);
|
||
const tierStates = [...state.tierStates];
|
||
const paidOrderNos = { ...state.paidOrderNos };
|
||
let changed = false;
|
||
|
||
if (tierStates[tier.id - 1] === 0) {
|
||
tierStates[tier.id - 1] = 1;
|
||
changed = true;
|
||
}
|
||
if (outTradeNo && !paidOrderNos[String(tier.id)]) {
|
||
paidOrderNos[String(tier.id)] = outTradeNo;
|
||
changed = true;
|
||
}
|
||
|
||
return {
|
||
ok: true,
|
||
changed,
|
||
tierId: tier.id,
|
||
state: changed
|
||
? createStoredState(
|
||
tierStates,
|
||
paidOrderNos,
|
||
state.revision + 1,
|
||
stateExpiresAt,
|
||
now,
|
||
getStoredStateMetadata(state),
|
||
)
|
||
: state,
|
||
};
|
||
}
|
||
|
||
/** 活动中保持原单档规则；活动过期后禁止越过第一处未解锁付费档。 */
|
||
export function claimJungleTier(raw: unknown, rawTierId: unknown, now = Date.now()): JungleClaimResult {
|
||
const tierId = Number(rawTierId);
|
||
if (!Number.isInteger(tierId) || tierId < 1 || tierId > JUNGLE_TREASURE_TOTAL_TIERS) {
|
||
return { ok: false, message: "礼包档位编号不合法" };
|
||
}
|
||
|
||
const state: any = normalizeStoredJungleState(raw, now);
|
||
const stateExpiresAt = Number(state["expiresAt"]);
|
||
const currentState = state.tierStates[tierId - 1];
|
||
if (currentState === 0) {
|
||
return { ok: false, tierId, message: "该付费档位尚未解锁" };
|
||
}
|
||
if (currentState === 2) {
|
||
return { ok: false, tierId, message: "该档位已经领取" };
|
||
}
|
||
if (now >= stateExpiresAt) {
|
||
const firstLockedIndex = state.tierStates.indexOf(0);
|
||
if (firstLockedIndex >= 0 && tierId - 1 > firstLockedIndex) {
|
||
return { ok: false, tierId, message: "活动已结束，该档位位于未解锁付费档之后" };
|
||
}
|
||
}
|
||
|
||
const tierStates = [...state.tierStates];
|
||
tierStates[tierId - 1] = 2;
|
||
return {
|
||
ok: true,
|
||
tierId,
|
||
paidOrderNo: state.paidOrderNos[String(tierId)] || "",
|
||
state: createStoredState(
|
||
tierStates,
|
||
state.paidOrderNos,
|
||
state.revision + 1,
|
||
stateExpiresAt,
|
||
now,
|
||
getStoredStateMetadata(state),
|
||
),
|
||
};
|
||
}
|
||
|
||
function createTier(
|
||
id: number,
|
||
price: number,
|
||
rewards: JungleRewardConfig[],
|
||
productId = "",
|
||
priceTemporary = false,
|
||
): JungleTierConfig {
|
||
const isPaid = price > 0;
|
||
if (isPaid && !productId) {
|
||
throw new Error(`[JungleTreasureConfig] 第 ${id} 档为付费档，必须配置 productId`);
|
||
}
|
||
if (!rewards.length || rewards.length > 5) {
|
||
throw new Error(`[JungleTreasureConfig] 第 ${id} 档奖励数量必须为 1 至 5`);
|
||
}
|
||
return {
|
||
id,
|
||
price,
|
||
isPaid,
|
||
productId: isPaid ? productId : "",
|
||
...(priceTemporary ? { priceTemporary: true } : {}),
|
||
rewards,
|
||
};
|
||
}
|
||
|
||
function validateTierOrder(tiers: JungleTierConfig[]): void {
|
||
if (tiers.length !== JUNGLE_TREASURE_TOTAL_TIERS) {
|
||
throw new Error(`[JungleTreasureConfig] 应配置 ${JUNGLE_TREASURE_TOTAL_TIERS} 档，实际为 ${tiers.length} 档`);
|
||
}
|
||
tiers.forEach((tier, index) => {
|
||
if (tier.id !== index + 1) {
|
||
throw new Error(`[JungleTreasureConfig] 第 ${index + 1} 个配置的 id 必须为 ${index + 1}`);
|
||
}
|
||
});
|
||
}
|
||
|
||
function createStoredState(
|
||
tierStates: JungleTierState[],
|
||
paidOrderNos: Record<string, string>,
|
||
revision: number,
|
||
expiresAt: number,
|
||
updatedAt: number,
|
||
metadata?: Partial<Pick<
|
||
JungleStoredState,
|
||
"activityType" | "periodKey" | "startsAt" | "firstTriggered" | "lastCalendarPeriodKey"
|
||
>>,
|
||
): JungleStoredState {
|
||
return {
|
||
activityId: JUNGLE_TREASURE_ACTIVITY_ID,
|
||
configVersion: JUNGLE_TREASURE_CONFIG_VERSION,
|
||
activityType: metadata?.activityType === "calendar" ? "calendar" : "personal",
|
||
periodKey: normalizePeriodKey(metadata?.periodKey),
|
||
startsAt: toPositiveTimestamp(metadata?.startsAt)
|
||
|| Math.max(1, expiresAt - JUNGLE_TREASURE_DURATION_MS),
|
||
firstTriggered: metadata?.firstTriggered !== false,
|
||
lastCalendarPeriodKey: normalizePeriodKey(metadata?.lastCalendarPeriodKey),
|
||
tierStates,
|
||
paidOrderNos: { ...paidOrderNos },
|
||
revision,
|
||
expiresAt,
|
||
updatedAt,
|
||
};
|
||
}
|
||
|
||
function createEmptyRewardTotals(): JungleRewardTotals {
|
||
return {
|
||
coin: 0,
|
||
freeze: 0,
|
||
hammer: 0,
|
||
magic_wand: 0,
|
||
infinite_health: 0,
|
||
};
|
||
}
|
||
|
||
function createCalendarJungleState(
|
||
period: JungleCalendarPeriod,
|
||
previousState: JungleStoredState,
|
||
now: number,
|
||
): JungleStoredState {
|
||
return createStoredState(
|
||
JUNGLE_TREASURE_CONFIG.tiers.map((tier) => tier.isPaid ? 0 : 1),
|
||
{},
|
||
previousState.revision + 1,
|
||
period.expiresAt,
|
||
now,
|
||
{
|
||
activityType: "calendar",
|
||
periodKey: period.key,
|
||
startsAt: period.startsAt,
|
||
firstTriggered: true,
|
||
lastCalendarPeriodKey: period.key,
|
||
},
|
||
);
|
||
}
|
||
|
||
function markCalendarPeriodHandled(
|
||
state: JungleStoredState,
|
||
periodKey: string,
|
||
now: number,
|
||
): JungleStoredState {
|
||
return createStoredState(
|
||
[...state.tierStates],
|
||
state.paidOrderNos,
|
||
state.revision + 1,
|
||
state.expiresAt,
|
||
now,
|
||
{
|
||
...getStoredStateMetadata(state),
|
||
lastCalendarPeriodKey: periodKey,
|
||
},
|
||
);
|
||
}
|
||
|
||
function getStoredStateMetadata(state: JungleStoredState) {
|
||
return {
|
||
activityType: state.activityType,
|
||
periodKey: state.periodKey,
|
||
startsAt: state.startsAt,
|
||
firstTriggered: state.firstTriggered,
|
||
lastCalendarPeriodKey: state.lastCalendarPeriodKey,
|
||
};
|
||
}
|
||
|
||
function hasStoredJungleValue(raw: unknown): boolean {
|
||
return raw !== undefined && raw !== null && !(typeof raw === "string" && !raw.trim());
|
||
}
|
||
|
||
function normalizePaidOrderNos(value: any): Record<string, string> {
|
||
const result: Record<string, string> = {};
|
||
if (!value || Array.isArray(value) || !value.paidOrderNos || typeof value.paidOrderNos !== "object") {
|
||
return result;
|
||
}
|
||
for (const tier of JUNGLE_TREASURE_CONFIG.tiers) {
|
||
if (!tier.isPaid) {
|
||
continue;
|
||
}
|
||
const orderNo = String(value.paidOrderNos[String(tier.id)] || "").trim();
|
||
if (orderNo) {
|
||
result[String(tier.id)] = orderNo;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function parseUnknownValue(raw: unknown): any {
|
||
if (Array.isArray(raw) || (raw && typeof raw === "object")) {
|
||
return raw;
|
||
}
|
||
if (typeof raw !== "string" || !raw.trim()) {
|
||
return null;
|
||
}
|
||
try {
|
||
return JSON.parse(raw);
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function toTierState(value: unknown): JungleTierState | null {
|
||
const state = Number(value);
|
||
return state === 0 || state === 1 || state === 2 ? state : null;
|
||
}
|
||
|
||
function toNonNegativeInteger(value: unknown): number {
|
||
const numberValue = Number(value);
|
||
return Number.isInteger(numberValue) && numberValue >= 0 ? numberValue : 0;
|
||
}
|
||
|
||
function toPositiveTimestamp(value: unknown): number {
|
||
const numberValue = Number(value);
|
||
return Number.isFinite(numberValue) && numberValue > 0 ? Math.floor(numberValue) : 0;
|
||
}
|
||
|
||
function normalizePeriodKey(value: unknown): string {
|
||
const periodKey = String(value || "").trim();
|
||
return /^\d{4}-\d{2}$/.test(periodKey) ? periodKey : "";
|
||
}
|