307 lines
8.4 KiB
TypeScript
307 lines
8.4 KiB
TypeScript
import type { AffinityRule, AffinityLevel } from "./types"
|
|
import { mockResponse, type PaginatedResponse, type PaginationParams } from "./client"
|
|
|
|
// 模拟好感度规则数据
|
|
const mockAffinityRules: AffinityRule[] = [
|
|
{
|
|
id: "AFR001",
|
|
name: "每日登录",
|
|
description: "用户每日登录系统可获得好感度",
|
|
points: 10,
|
|
type: "日常活动",
|
|
status: "已启用",
|
|
},
|
|
{
|
|
id: "AFR002",
|
|
name: "赠送礼物",
|
|
description: "用户赠送礼物可获得好感度",
|
|
points: 20,
|
|
type: "互动活动",
|
|
status: "已启用",
|
|
},
|
|
{
|
|
id: "AFR003",
|
|
name: "完成任务",
|
|
description: "用户完成指定任务可获得好感度",
|
|
points: 15,
|
|
type: "任务活动",
|
|
status: "已启用",
|
|
},
|
|
{
|
|
id: "AFR004",
|
|
name: "参与活动",
|
|
description: "用户参与系统活动可获得好感度",
|
|
points: 30,
|
|
type: "特殊活动",
|
|
status: "已启用",
|
|
},
|
|
{
|
|
id: "AFR005",
|
|
name: "购买道具",
|
|
description: "用户购买道具可获得好感度",
|
|
points: 25,
|
|
type: "消费活动",
|
|
status: "未启用",
|
|
},
|
|
]
|
|
|
|
// 模拟好感度等级数据
|
|
const mockAffinityLevels: AffinityLevel[] = [
|
|
{
|
|
id: "AFL001",
|
|
level: 1,
|
|
name: "初识",
|
|
pointsRequired: 0,
|
|
rewards: ["基础表情包", "基础头像框"],
|
|
description: "刚刚认识洛天依，开始了解她的世界。",
|
|
},
|
|
{
|
|
id: "AFL002",
|
|
level: 2,
|
|
name: "相识",
|
|
pointsRequired: 100,
|
|
rewards: ["语音问候", "特殊表情包"],
|
|
description: "与洛天依有了初步的交流，开始建立友谊。",
|
|
},
|
|
{
|
|
id: "AFL003",
|
|
level: 3,
|
|
name: "熟悉",
|
|
pointsRequired: 300,
|
|
rewards: ["专属头像框", "房间装饰道具"],
|
|
description: "与洛天依建立了稳定的友谊，互相了解更多。",
|
|
},
|
|
{
|
|
id: "AFL004",
|
|
level: 4,
|
|
name: "亲密",
|
|
pointsRequired: 600,
|
|
rewards: ["专属服装", "专属互动动画"],
|
|
description: "与洛天依建立了深厚的友谊，成为了亲密的朋友。",
|
|
},
|
|
{
|
|
id: "AFL005",
|
|
level: 5,
|
|
name: "挚友",
|
|
pointsRequired: 1000,
|
|
rewards: ["限定服装", "专属歌曲", "特殊互动场景"],
|
|
description: "与洛天依建立了最亲密的关系，成为了无可替代的挚友。",
|
|
},
|
|
]
|
|
|
|
// 获取好感度规则列表
|
|
export const getAffinityRules = async (params?: PaginationParams): Promise<PaginatedResponse<AffinityRule>> => {
|
|
let filteredRules = [...mockAffinityRules]
|
|
|
|
// 搜索过滤
|
|
if (params?.search) {
|
|
const search = params.search.toLowerCase()
|
|
filteredRules = filteredRules.filter(
|
|
(rule) =>
|
|
rule.name.toLowerCase().includes(search) ||
|
|
rule.description.toLowerCase().includes(search) ||
|
|
rule.type.toLowerCase().includes(search),
|
|
)
|
|
}
|
|
|
|
// 排序
|
|
if (params?.sortBy) {
|
|
filteredRules.sort((a: any, b: any) => {
|
|
const aValue = a[params.sortBy!]
|
|
const bValue = b[params.sortBy!]
|
|
|
|
if (typeof aValue === "string" && typeof bValue === "string") {
|
|
return params.sortOrder === "desc" ? bValue.localeCompare(aValue) : aValue.localeCompare(bValue)
|
|
}
|
|
|
|
return params.sortOrder === "desc" ? bValue - aValue : aValue - bValue
|
|
})
|
|
}
|
|
|
|
// 分页
|
|
const page = params?.page || 1
|
|
const pageSize = params?.pageSize || 10
|
|
const startIndex = (page - 1) * pageSize
|
|
const paginatedRules = filteredRules.slice(startIndex, startIndex + pageSize)
|
|
|
|
return mockResponse({
|
|
items: paginatedRules,
|
|
total: filteredRules.length,
|
|
page,
|
|
pageSize,
|
|
totalPages: Math.ceil(filteredRules.length / pageSize),
|
|
})
|
|
}
|
|
|
|
// 获取单个好感度规则
|
|
export const getAffinityRule = async (id: string): Promise<AffinityRule> => {
|
|
const rule = mockAffinityRules.find((rule) => rule.id === id)
|
|
|
|
if (!rule) {
|
|
return mockResponse({} as AffinityRule, "好感度规则不存在")
|
|
}
|
|
|
|
return mockResponse(rule)
|
|
}
|
|
|
|
// 创建好感度规则
|
|
export const createAffinityRule = async (ruleData: Partial<AffinityRule>): Promise<AffinityRule> => {
|
|
// 生成新的好感度规则ID
|
|
const ruleId = "AFR" + String(mockAffinityRules.length + 1).padStart(3, "0")
|
|
|
|
const newRule: AffinityRule = {
|
|
id: ruleId,
|
|
name: ruleData.name || "",
|
|
description: ruleData.description || "",
|
|
points: ruleData.points || 0,
|
|
type: ruleData.type || "",
|
|
status: ruleData.status || "未启用",
|
|
}
|
|
|
|
mockAffinityRules.push(newRule)
|
|
|
|
return mockResponse(newRule)
|
|
}
|
|
|
|
// 更新好感度规则
|
|
export const updateAffinityRule = async (id: string, ruleData: Partial<AffinityRule>): Promise<AffinityRule> => {
|
|
const ruleIndex = mockAffinityRules.findIndex((rule) => rule.id === id)
|
|
|
|
if (ruleIndex === -1) {
|
|
return mockResponse({} as AffinityRule, "好感度规则不存在")
|
|
}
|
|
|
|
const updatedRule = {
|
|
...mockAffinityRules[ruleIndex],
|
|
...ruleData,
|
|
}
|
|
|
|
mockAffinityRules[ruleIndex] = updatedRule
|
|
|
|
return mockResponse(updatedRule)
|
|
}
|
|
|
|
// 删除好感度规则
|
|
export const deleteAffinityRule = async (id: string): Promise<boolean> => {
|
|
const ruleIndex = mockAffinityRules.findIndex((rule) => rule.id === id)
|
|
|
|
if (ruleIndex === -1) {
|
|
return mockResponse(false, "好感度规则不存在")
|
|
}
|
|
|
|
mockAffinityRules.splice(ruleIndex, 1)
|
|
|
|
return mockResponse(true)
|
|
}
|
|
|
|
// 获取好感度等级列表
|
|
export const getAffinityLevels = async (params?: PaginationParams): Promise<PaginatedResponse<AffinityLevel>> => {
|
|
let filteredLevels = [...mockAffinityLevels]
|
|
|
|
// 搜索过滤
|
|
if (params?.search) {
|
|
const search = params.search.toLowerCase()
|
|
filteredLevels = filteredLevels.filter(
|
|
(level) => level.name.toLowerCase().includes(search) || level.description.toLowerCase().includes(search),
|
|
)
|
|
}
|
|
|
|
// 排序
|
|
if (params?.sortBy) {
|
|
filteredLevels.sort((a: any, b: any) => {
|
|
const aValue = a[params.sortBy!]
|
|
const bValue = b[params.sortBy!]
|
|
|
|
if (typeof aValue === "string" && typeof bValue === "string") {
|
|
return params.sortOrder === "desc" ? bValue.localeCompare(aValue) : aValue.localeCompare(bValue)
|
|
}
|
|
|
|
return params.sortOrder === "desc" ? bValue - aValue : aValue - bValue
|
|
})
|
|
} else {
|
|
// 默认按等级排序
|
|
filteredLevels.sort((a, b) => a.level - b.level)
|
|
}
|
|
|
|
// 分页
|
|
const page = params?.page || 1
|
|
const pageSize = params?.pageSize || 10
|
|
const startIndex = (page - 1) * pageSize
|
|
const paginatedLevels = filteredLevels.slice(startIndex, startIndex + pageSize)
|
|
|
|
return mockResponse({
|
|
items: paginatedLevels,
|
|
total: filteredLevels.length,
|
|
page,
|
|
pageSize,
|
|
totalPages: Math.ceil(filteredLevels.length / pageSize),
|
|
})
|
|
}
|
|
|
|
// 获取单个好感度等级
|
|
export const getAffinityLevel = async (id: string): Promise<AffinityLevel> => {
|
|
const level = mockAffinityLevels.find((level) => level.id === id)
|
|
|
|
if (!level) {
|
|
return mockResponse({} as AffinityLevel, "好感度等级不存在")
|
|
}
|
|
|
|
return mockResponse(level)
|
|
}
|
|
|
|
// 创建好感度等级
|
|
export const createAffinityLevel = async (levelData: Partial<AffinityLevel>): Promise<AffinityLevel> => {
|
|
// 生成新的好感度等级ID
|
|
const levelId = "AFL" + String(mockAffinityLevels.length + 1).padStart(3, "0")
|
|
|
|
const newLevel: AffinityLevel = {
|
|
id: levelId,
|
|
level: levelData.level || mockAffinityLevels.length + 1,
|
|
name: levelData.name || "",
|
|
pointsRequired: levelData.pointsRequired || 0,
|
|
rewards: levelData.rewards || [],
|
|
description: levelData.description || "",
|
|
}
|
|
|
|
mockAffinityLevels.push(newLevel)
|
|
|
|
// 按等级排序
|
|
mockAffinityLevels.sort((a, b) => a.level - b.level)
|
|
|
|
return mockResponse(newLevel)
|
|
}
|
|
|
|
// 更新好感度等级
|
|
export const updateAffinityLevel = async (id: string, levelData: Partial<AffinityLevel>): Promise<AffinityLevel> => {
|
|
const levelIndex = mockAffinityLevels.findIndex((level) => level.id === id)
|
|
|
|
if (levelIndex === -1) {
|
|
return mockResponse({} as AffinityLevel, "好感度等级不存在")
|
|
}
|
|
|
|
const updatedLevel = {
|
|
...mockAffinityLevels[levelIndex],
|
|
...levelData,
|
|
}
|
|
|
|
mockAffinityLevels[levelIndex] = updatedLevel
|
|
|
|
// 按等级排序
|
|
mockAffinityLevels.sort((a, b) => a.level - b.level)
|
|
|
|
return mockResponse(updatedLevel)
|
|
}
|
|
|
|
// 删除好感度等级
|
|
export const deleteAffinityLevel = async (id: string): Promise<boolean> => {
|
|
const levelIndex = mockAffinityLevels.findIndex((level) => level.id === id)
|
|
|
|
if (levelIndex === -1) {
|
|
return mockResponse(false, "好感度等级不存在")
|
|
}
|
|
|
|
mockAffinityLevels.splice(levelIndex, 1)
|
|
|
|
return mockResponse(true)
|
|
}
|