qiangdanxitong/frontend/src/api/rewardRule.ts

import request from '@/utils/request'
import type { Result, PageResult } from '@/api/types'

// 奖励规则接口类型
export interface RewardRule {
  id: number
  name: string
  description: string
  ruleType: 'daily' | 'weekly' | 'monthly' | 'task' | 'rating'
  triggerCondition: {
    type: string
    operator: string
    value: number
  }
  rewardType: 'score' | 'badge' | 'both'
  rewardScore: number
  rewardBadge?: any
  scope: 'all' | 'designer' | 'department'
  scopeDeptIds?: number[]
  enabled: number
  cronExpression?: string
  lastExecuteTime?: string
  priority: number
  triggerCount?: number
  totalBudget?: number
  usedBudget?: number
  maxTimesPerUser?: number
  startTime?: string
  endTime?: string
  creatorId: number
  createTime: string
  updateTime: string
}

// 奖励发放记录
export interface RewardRecord {
  id: number
  userId: number
  ruleId: number
  ruleName: string
  rewardType: string
  rewardValue: string
  triggerData: string
  createTime: string
  userName?: string
  userAvatar?: string
}

// 用户徽章
export interface UserBadge {
  id: number
  userId: number
  badgeCode: string
  badgeName: string
  badgeIcon: string
  badgeColor: string
  description: string
  sourceType: string
  sourceId: number
  createTime: string
}

// 徽章定义
export interface BadgeDefinition {
  id: number
  badgeCode: string
  badgeName: string
  badgeIcon: string
  badgeColor: string
  description: string
  category: string
  sortOrder: number
  enabled: number
}

// 用户称号
export interface UserTitle {
  id: number
  userId: number
  titleCode: string
  titleName: string
  titleColor: string
  description: string
  isActive: number
  expireTime: string
  sourceType: string
  sourceId: number
  createTime: string
}

// 称号定义
export interface TitleDefinition {
  id: number
  titleCode: string
  titleName: string
  titleColor: string
  description: string
  category: string
  sortOrder: number
  enabled: number
}

// 奖励统计
export interface RewardStats {
  totalCount: number
  totalScore: number
  userCount: number
  hitRate: number
  ruleRanking: Array<{ ruleId: number; ruleName: string; triggerCount: number }>
  userRanking: Array<{ userId: number; userName: string; userAvatar: string; totalScore: number }>
  dailyTrend: Array<{ date: string; count: number; totalScore: number }>
}

export interface RewardRuleCreateRequest {
  name: string
  description?: string
  ruleType: string
  triggerCondition: string
  rewardType: string
  rewardScore: number
  scope: string
  scopeDeptIds?: string
  priority?: number
}

// ==================== 奖励规则 API ====================

/**
 * 创建奖励规则
 */
export function createRewardRule(data: RewardRuleCreateRequest): Promise<RewardRule> {
  return request.post<Result<RewardRule>>('/reward-rules', data)
    .then(res => res.data)
}

/**
 * 更新奖励规则
 */
export function updateRewardRule(id: number, data: Partial<RewardRuleCreateRequest>): Promise<RewardRule> {
  return request.put<Result<RewardRule>>(`/reward-rules/${id}`, data)
    .then(res => res.data)
}

/**
 * 启用规则
 */
export function enableRewardRule(id: number): Promise<void> {
  return request.post<Result<void>>(`/reward-rules/${id}/enable`)
    .then(res => res.data)
}

/**
 * 禁用规则
 */
export function disableRewardRule(id: number): Promise<void> {
  return request.post<Result<void>>(`/reward-rules/${id}/disable`)
    .then(res => res.data)
}

/**
 * 删除规则
 */
export function deleteRewardRule(id: number): Promise<void> {
  return request.delete<Result<void>>(`/reward-rules/${id}`)
    .then(res => res.data)
}

/**
 * 获取规则列表
 */
export function getRewardRuleList(params: {
  page?: number
  pageSize?: number
  ruleType?: string
}): Promise<PageResult<RewardRule>> {
  return request.get<Result<PageResult<RewardRule>>>('/reward-rules', { params })
    .then(res => res.data)
}

/**
 * 获取规则详情
 */
export function getRewardRuleById(id: number): Promise<RewardRule> {
  return request.get<Result<RewardRule>>(`/reward-rules/${id}`)
    .then(res => res.data)
}

/**
 * 获取启用的规则
 */
export function getEnabledRewardRules(): Promise<RewardRule[]> {
  return request.get<Result<RewardRule[]>>('/reward-rules/enabled')
    .then(res => res.data)
}

/**
 * 初始化默认规则
 */
export function initDefaultRewardRules(): Promise<void> {
  return request.post<Result<void>>('/reward-rules/init')
    .then(res => res.data)
}

// ==================== 奖励统计 API ====================

/**
 * 获取奖励统计数据
 * @param period today/week/month
 */
export function getRewardStats(period: string = 'month'): Promise<RewardStats> {
  return request.get<Result<RewardStats>>('/reward-rules/stats', { params: { period } })
    .then(res => res.data)
}

// ==================== 奖励记录 API ====================

/**
 * 获取奖励发放记录
 */
export function getRewardRecords(params: {
  page?: number
  pageSize?: number
  userId?: number
  ruleId?: number
  rewardType?: string
  startTime?: string
  endTime?: string
}): Promise<PageResult<RewardRecord>> {
  return request.get<Result<PageResult<RewardRecord>>>('/reward-rules/records', { params })
    .then(res => res.data)
}

/**
 * 获取我的奖励记录
 */
export function getMyRewardRecords(params: {
  page?: number
  pageSize?: number
}): Promise<PageResult<RewardRecord>> {
  return request.get<Result<PageResult<RewardRecord>>>('/reward-rules/records/my', { params })
    .then(res => res.data)
}

// ==================== 徽章 API ====================

/**
 * 获取所有可用徽章
 */
export function getAllBadges(): Promise<BadgeDefinition[]> {
  return request.get<Result<BadgeDefinition[]>>('/reward-rules/badges')
    .then(res => res.data)
}

/**
 * 获取用户徽章
 */
export function getUserBadges(userId: number): Promise<UserBadge[]> {
  return request.get<Result<UserBadge[]>>(`/reward-rules/users/${userId}/badges`)
    .then(res => res.data)
}

/**
 * 获取我的徽章
 */
export function getMyBadges(): Promise<UserBadge[]> {
  return request.get<Result<UserBadge[]>>('/reward-rules/badges/my')
    .then(res => res.data)
}

// ==================== 称号 API ====================

/**
 * 获取所有可用称号
 */
export function getAllTitles(): Promise<TitleDefinition[]> {
  return request.get<Result<TitleDefinition[]>>('/reward-rules/titles')
    .then(res => res.data)
}

/**
 * 获取用户称号
 */
export function getUserTitles(userId: number): Promise<UserTitle[]> {
  return request.get<Result<UserTitle[]>>(`/reward-rules/users/${userId}/titles`)
    .then(res => res.data)
}

/**
 * 获取我的称号
 */
export function getMyTitles(): Promise<UserTitle[]> {
  return request.get<Result<UserTitle[]>>('/reward-rules/titles/my')
    .then(res => res.data)
}

/**
 * 设置激活称号
 */
export function setActiveTitle(titleId?: number): Promise<void> {
  return request.put<Result<void>>('/reward-rules/titles/active', null, {
    params: { titleId }
  }).then(res => res.data)
}

/**
 * 获取我的激活称号
 */
export function getMyActiveTitle(): Promise<UserTitle | null> {
  return request.get<Result<UserTitle | null>>('/reward-rules/titles/active')
    .then(res => res.data)
}

// 规则类型选项
export const RULE_TYPE_OPTIONS = [
  { value: 'daily', label: '每日奖励' },
  { value: 'weekly', label: '每周奖励' },
  { value: 'monthly', label: '每月奖励' },
  { value: 'task', label: '任务奖励' },
  { value: 'rating', label: '好评奖励' },
]

// 触发条件类型
export const TRIGGER_TYPE_OPTIONS = [
  { value: 'task_count', label: '完成任务数' },
  { value: 'five_star_count', label: '五星好评数' },
  { value: 'rating', label: '任务评分' },
]

// 比较运算符
export const OPERATOR_OPTIONS = [
  { value: '>=', label: '大于等于' },
  { value: '>', label: '大于' },
  { value: '==', label: '等于' },
  { value: '<=', label: '小于等于' },
  { value: '<', label: '小于' },
]