junma-api/src/services/sys-config.service.ts

import { FastifyInstance } from 'fastify'
import { Like, Repository, Not } from 'typeorm'
import Decimal from 'decimal.js'
import { SysConfig } from '../entities/sys-config.entity'
import {
  CreateSysConfigBody,
  UpdateSysConfigBody,
  CreateTeamConfigBody,
  UpdateTeamConfigBody,
  ListTeamConfigQuery
} from '../dto/sys-config.dto'
import { ConfigType } from '../entities/sys-config.entity'
import { User, UserRole } from '../entities/user.entity'
import { Team } from '../entities/team.entity'
import { TeamMembers } from '../entities/team-members.entity'

export class SysConfigService {
  private app: FastifyInstance
  private sysConfigRepository: Repository<SysConfig>
  private userRepository: Repository<User>
  private teamRepository: Repository<Team>
  private teamMembersRepository: Repository<TeamMembers>

  constructor(app: FastifyInstance) {
    this.app = app
    this.sysConfigRepository = app.dataSource.getRepository(SysConfig)
    this.userRepository = app.dataSource.getRepository(User)
    this.teamRepository = app.dataSource.getRepository(Team)
    this.teamMembersRepository = app.dataSource.getRepository(TeamMembers)
  }

  async getSysConfig(name: string, teamId?: number) {
    const where: any = { name }
    if (teamId !== undefined) {
      where.teamId = teamId
    }
    const sysConfig = await this.sysConfigRepository.findOneOrFail({ where })
    return sysConfig
  }

  async maxTransferAmount(defaultAmount: Decimal) {
    const sysConfig = await this.sysConfigRepository.findOne({ where: { name: 'max_transfer_amount' } })
    if (sysConfig) {
      return new Decimal(sysConfig.value)
    }
    await this.sysConfigRepository.save({ name: 'max_transfer_amount', value: defaultAmount.toString() })
    return defaultAmount
  }

  async replaceType(defaultValue: number) {
    try {
      const sysConfig = await this.sysConfigRepository.findOne({ where: { name: 'replace_type' } })
      if (sysConfig) {
        return Number(sysConfig.value)
      }
      await this.sysConfigRepository.save({ name: 'replace_type', value: defaultValue.toString() })
    } catch (e) {
      this.app.log.error(e, 'get replaceType error')
    }
    return defaultValue
  }

  async getSensitiveWords() {
    try {
      const config = await this.sysConfigRepository.findOne({ where: { name: 'sensitive_words' } })
      if (config) {
        return { value: config.value }
      }
    } catch (e) {
      this.app.log.error(e, 'get sensitiveWords error')
    }
    return null
  }

  async updateSensitiveWords(words: string) {
    try {
      const config = await this.sysConfigRepository.findOne({ where: { name: 'sensitive_words' } })
      if (config) {
        config.value = words
        const sysConfig = await this.sysConfigRepository.save(config)
        return {
          value: sysConfig.value
        }
      }
      await this.sysConfigRepository.save({ name: 'sensitive_words', value: words })
    } catch (e) {
      this.app.log.error(e, 'update sensitiveWords error')
    }
  }

  async create(data: CreateSysConfigBody) {
    const where: any = { name: data.name }
    if (data.teamId !== undefined) {
      where.teamId = data.teamId
    }
    const existingConfig = await this.sysConfigRepository.findOne({ where })
    if (existingConfig) {
        throw new Error('操作失败')
    }
    const config = this.sysConfigRepository.create(data)
    return await this.sysConfigRepository.save(config)
  }

  async update(name: string, data: UpdateSysConfigBody, teamId?: number) {
    const config = await this.getSysConfig(name, teamId)
    Object.assign(config, data)
    return await this.sysConfigRepository.save(config)
  }

  async delete(name: string, teamId?: number) {
    const config = await this.getSysConfig(name, teamId)
    return await this.sysConfigRepository.remove(config)
  }

  async list(page: number = 0, size: number = 20, name?: string, type?: ConfigType, teamId?: number) {
    const where: any = {
      name: Not('sensitive_words')
    }

    if (name) {
      where.name = Like(`%${name}%`)
    }

    if (type) {
      where.type = type
    }

    if (teamId !== undefined) {
      where.teamId = teamId
    }

    const [data, total] = await this.sysConfigRepository.findAndCount({
      where,
      skip: page * size,
      take: size,
      order: {
        id: 'ASC'
      }
    })

    return {
      data,
      meta: {
        page,
        size,
        total,
        totalPages: Math.ceil(total / size)
      }
    }
  }

  async getConfigTypes() {
    return Object.values(ConfigType)
  }

  // 获取用户的团队ID
  async getUserTeamId(userId: number, userRole: UserRole): Promise<number> {
    if (userRole === UserRole.ADMIN) {
      throw new Error('管理员不需要团队ID')
    }

    if (userRole === UserRole.USER) {
      throw new Error('普通用户无权限访问团队配置')
    }

    if (userRole === UserRole.TEAM) {
      // 队长从team表中获取teamId
      const team = await this.teamRepository.findOne({ where: { userId } })
      if (!team) {
        throw new Error('未找到该用户的团队信息')
      }
      return team.id
    } else {
      // 队员从team-members表中获取teamId
      const teamMember = await this.teamMembersRepository.findOne({ where: { userId } })
      if (!teamMember) {
        throw new Error('未找到该用户的团队成员信息')
      }
      return teamMember.teamId
    }
  }

  // 团队配置相关方法
  async createTeamConfig(data: CreateTeamConfigBody, userId: number, userRole: UserRole, adminTeamId?: number) {
    let teamId: number

    if (userRole === UserRole.ADMIN) {
      if (adminTeamId === undefined) {
        throw new Error('管理员操作团队配置时必须指定teamId')
      }
      teamId = adminTeamId
    } else {
      teamId = await this.getUserTeamId(userId, userRole)
    }

    const existingConfig = await this.sysConfigRepository.findOne({
      where: { name: data.name, teamId }
    })
    if (existingConfig) {
      throw new Error('该团队配置名称已存在')
    }

    const config = this.sysConfigRepository.create({ ...data, teamId })
    return await this.sysConfigRepository.save(config)
  }

  async updateTeamConfig(
    name: string,
    data: UpdateTeamConfigBody,
    userId: number,
    userRole: UserRole,
    adminTeamId?: number
  ) {
    let teamId: number

    if (userRole === UserRole.ADMIN) {
      if (adminTeamId === undefined) {
        throw new Error('管理员操作团队配置时必须指定teamId')
      }
      teamId = adminTeamId
    } else {
      teamId = await this.getUserTeamId(userId, userRole)
    }

    const config = await this.getSysConfig(name, teamId)
    Object.assign(config, data)
    return await this.sysConfigRepository.save(config)
  }

  async deleteTeamConfig(name: string, userId: number, userRole: UserRole, adminTeamId?: number) {
    let teamId: number

    if (userRole === UserRole.ADMIN) {
      if (adminTeamId === undefined) {
        throw new Error('管理员操作团队配置时必须指定teamId')
      }
      teamId = adminTeamId
    } else {
      teamId = await this.getUserTeamId(userId, userRole)
    }

    const config = await this.getSysConfig(name, teamId)
    return await this.sysConfigRepository.remove(config)
  }

  async getTeamConfig(name: string, userId: number, userRole: UserRole, adminTeamId?: number) {
    if (userRole === UserRole.ADMIN) {
      return await this.getSysConfig(name, adminTeamId)
    } else {
      const teamId = await this.getUserTeamId(userId, userRole)
      return await this.getSysConfig(name, teamId)
    }
  }

  async listTeamConfigs(query: ListTeamConfigQuery, userId: number, userRole: UserRole, adminTeamId?: number) {
    if (userRole === UserRole.ADMIN) {
      const { page = 0, size = 20, name, type } = query
      return await this.list(page, size, name, type, adminTeamId)
    } else {
      const teamId = await this.getUserTeamId(userId, userRole)
      const { page = 0, size = 20, name, type } = query
      return await this.list(page, size, name, type, teamId)
    }
  }

  async getUserTeamConfigs(userId?: number) {
    let teamId = 0
    if (userId) {
      const user = await this.userRepository.findOne({ where: { id: userId } })
      if (user) {
        const team = await this.teamRepository.findOne({ where: { userId: user.parentId } })
        if (team) {
          teamId = team.id
        }
      }
    }

    const configs = await this.sysConfigRepository.find({
      where: { teamId },
      select: ['name', 'value'],
      order: { id: 'ASC' }
    })

    return configs
  }

  // 创建团队默认配置
  async createDefaultTeamConfigs(teamId: number) {
    const defaultConfigs = [
      { name: 'hourly', value: '10', remark: '包时会员', type: ConfigType.Number },
      { name: 'daily', value: '20', remark: '包天会员', type: ConfigType.Number },
      { name: 'weekly', value: '60', remark: '包周会员', type: ConfigType.Number },
      { name: 'monthly', value: '80', remark: '包月会员', type: ConfigType.Number },
      { name: 'quarterly', value: '100', remark: '包季会员', type: ConfigType.Number },
      { name: 'yearly', value: '150', remark: '包年会员', type: ConfigType.Number },
      { name: 'lifetime', value: '300', remark: '终生会员', type: ConfigType.Number },
      { name: 'single', value: '10', remark: '单片价格', type: ConfigType.Number },
      { name: 'preview_duration', value: '30', remark: '试看时间(秒)', type: ConfigType.Number }
    ]

    const configs = defaultConfigs.map(config =>
      this.sysConfigRepository.create({
        ...config,
        teamId
      })
    )

    return await this.sysConfigRepository.save(configs)
  }
}