junma-api/src/services/team.service.ts

import { Repository, Like } from 'typeorm'
import { FastifyInstance } from 'fastify'
import { Team } from '../entities/team.entity'
import { PaginationResponse } from '../dto/common.dto'
import { CreateTeamBody, UpdateTeamBody, ListTeamQuery } from '../dto/team.dto'
import { UserService } from './user.service'
import { UserRole } from '../entities/user.entity'

export class TeamService {
  private teamRepository: Repository<Team>
  private userService: UserService

  constructor(app: FastifyInstance) {
    this.teamRepository = app.dataSource.getRepository(Team)
    this.userService = new UserService(app)
  }

  async create(data: CreateTeamBody, creatorId: number): Promise<Team> {
    const { password, ...teamData } = data

    const existingUser = await this.userService.findByName(teamData.name)
    if (existingUser) {
      throw new Error('团队已存在')
    }

    const userPassword = password || 'password123'
    const createdUser = await this.userService.create(userPassword, teamData.name, UserRole.TEAM, creatorId)

    const team = this.teamRepository.create({
      ...teamData,
      userId: createdUser.id
    })
    const savedTeam = await this.teamRepository.save(team)

    return savedTeam
  }

  async findById(id: number): Promise<Team> {
    return this.teamRepository.findOneOrFail({ where: { id } })
  }

  async findAll(query: ListTeamQuery): Promise<PaginationResponse<Team>> {
    const { page, size, id, name, userId } = query
    console.log(query)

    const where: any = {}

    if (id) {
      where.id = id
    }

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

    if (userId) {
      where.userId = userId
    }

    const [teams, total] = await this.teamRepository.findAndCount({
      where,
      skip: (Number(page) || 0) * (Number(size) || 20),
      take: Number(size) || 20,
      order: { createdAt: 'DESC' }
    })

    return {
      content: teams,
      metadata: {
        total: Number(total),
        page: Number(page) || 0,
        size: Number(size) || 20
      }
    }
  }

  async update(data: UpdateTeamBody): Promise<Team> {
    const { id, ...updateData } = data
    await this.teamRepository.update(id, updateData)
    return this.findById(id)
  }

  async delete(id: number): Promise<void> {
    await this.teamRepository.delete(id)
  }

  async updateRevenue(id: number, amount: number, type: 'total' | 'today'): Promise<Team> {
    const team = await this.findById(id)

    if (type === 'total') {
      team.totalRevenue = Number(team.totalRevenue) + amount
    } else {
      team.todayRevenue = Number(team.todayRevenue) + amount
    }

    return this.teamRepository.save(team)
  }

  async getStatistics(): Promise<{
    totalTeams: number
    totalRevenue: number
    todayRevenue: number
    averageCommissionRate: number
    allTeams: Array<{ id: number; name: string; totalRevenue: number; todayRevenue: number }>
  }> {
    const teams = await this.teamRepository.find({
      select: ['id', 'name', 'totalRevenue', 'todayRevenue', 'commissionRate']
    })

    const statistics = {
      totalTeams: teams.length,
      totalRevenue: 0,
      todayRevenue: 0,
      averageCommissionRate: 0,
      allTeams: [] as Array<{ id: number; name: string; totalRevenue: number; todayRevenue: number }>
    }

    let totalCommissionRate = 0

    teams.forEach(team => {
      statistics.totalRevenue += Number(team.totalRevenue)
      statistics.todayRevenue += Number(team.todayRevenue)
      totalCommissionRate += Number(team.commissionRate)
    })

    statistics.averageCommissionRate = teams.length > 0 ? totalCommissionRate / teams.length : 0

    statistics.allTeams = teams
      .sort((a, b) => Number(b.totalRevenue) - Number(a.totalRevenue))
      .map(team => ({
        id: team.id,
        name: team.name,
        totalRevenue: Number(team.totalRevenue),
        todayRevenue: Number(team.todayRevenue)
      }))

    return statistics
  }

  async getTeamStatistics(userId: number): Promise<Team> {
    return this.teamRepository.findOneOrFail({ where: { userId } })
  }

  async getTeams(): Promise<Array<{ id: number; name: string; userId: number }>> {
    return await this.teamRepository.find({
      select: ['id', 'name', 'userId']
    })
  }

  async findByUserId(userId: number): Promise<{ id: number; name: string; userId: number }> {
    return this.teamRepository.findOneOrFail({ select: ['id', 'name', 'userId'], where: { userId } })
  }
}