gym-manage/gym-manage-web/src/api/groupCourse.api.ts

import request from '@/utils/request'

// ==================== 团课课程 ====================

export interface GroupCourse {
  id?: number
  courseName: string
  coachId?: number | string
  coachName?: string
  courseType?: number
  startTime: string
  endTime: string
  maxMembers?: number
  currentMembers?: number
  status?: string
  actualStartTime?: string
  actualEndTime?: string
  location?: string
  coverImage?: string
  description?: string
  storedValueAmount?: number
  qrCodePath?: string
  createBy?: string
  updateBy?: string
  createdAt?: string
  updatedAt?: string
}

export interface GroupCoursePageRequest {
  page: number
  size: number
  keyword?: string
  status?: string
  courseType?: number
  coachId?: number | string
  startTime?: string
  endTime?: string
  sortBy?: string
  sortOrder?: 'asc' | 'desc'
}

export interface PageResponse<T> {
  content: T[]
  totalElements: number
  totalPages: number
  size: number
  number: number
  first: boolean
  last: boolean
}

export const groupCourseApi = {
  getAll: () =>
    request.get<GroupCourse[]>('/groupCourse/list'),

  getPage: (params: GroupCoursePageRequest) =>
    request.post<PageResponse<GroupCourse>>('/groupCourse/page', params),

  getById: (id: number) =>
    request.get<GroupCourse>(`/groupCourse/${id}`),

  getDetailById: (id: number) =>
    request.get<GroupCourse>(`/groupCourse/${id}/detail`),

  create: (data: GroupCourse) =>
    request.post<GroupCourse>('/groupCourse', data),

  update: (id: number, data: GroupCourse) =>
    request.put<GroupCourse>(`/groupCourse/${id}`, data),

  delete: (id: number) =>
    request.delete<void>(`/groupCourse/${id}`),

  cancel: (id: number) =>
    request.post<void>(`/groupCourse/${id}/cancel`),

  search: (params: any) =>
    request.post<GroupCourse[]>('/groupCourse/search', params),

  checkCoachConflict: (params: {
    coachId: number | string
    startTime: string
    endTime: string
    excludeCourseId?: number | string
  }) =>
    request.post<{
      success: boolean
      hasConflict: boolean
      conflicts: GroupCourse[]
    }>('/groupCourse/check-coach-conflict', params),
}

// ==================== 团课类型 ====================

export interface GroupCourseType {
  id?: number
  typeName: string
  baseDifficulty?: number
  description?: string
  category?: string
  createBy?: string
  updateBy?: string
  createdAt?: string
  updatedAt?: string
}

export interface GroupCourseTypePageRequest {
  page: number
  size: number
  keyword?: string
  category?: string
  sort?: string
  order?: 'asc' | 'desc'
}

export interface CourseLabelPageRequest {
  page: number
  size: number
  keyword?: string
  sort?: string
  order?: 'asc' | 'desc'
}

export const groupCourseTypeApi = {
  getAll: () =>
    request.get<GroupCourseType[]>('/groupCourse/types'),

  search: (params: any) =>
    request.get<GroupCourseType[]>('/groupCourse/types/search', { params }),

  getCategories: () =>
    request.get<string[]>('/groupCourse/types/categories'),

  getByCategory: (category: string) =>
    request.get<GroupCourseType[]>(`/groupCourse/types/category/${encodeURIComponent(category)}`),

  getById: (id: number) =>
    request.get<GroupCourseType>(`/groupCourse/types/${id}`),

  getPage: (params: GroupCourseTypePageRequest) =>
    request.post<PageResponse<GroupCourseType>>('/groupCourse/types/page', params),

  create: (data: GroupCourseType) =>
    request.post<GroupCourseType>('/groupCourse/types', data),

  update: (id: number, data: GroupCourseType) =>
    request.put<GroupCourseType>(`/groupCourse/types/${id}`, data),

  delete: (id: number) =>
    request.delete<void>(`/groupCourse/types/${id}`),
}

// ==================== 团课标签 ====================

export interface CourseLabel {
  id?: number
  labelName: string
  color?: string
  description?: string
  createBy?: string
  updateBy?: string
  createdAt?: string
  updatedAt?: string
}

export const courseLabelApi = {
  getAll: () =>
    request.get<CourseLabel[]>('/groupCourse/labels'),

  search: (params: any) =>
    request.get<CourseLabel[]>('/groupCourse/labels/search', { params }),

  getById: (id: number) =>
    request.get<CourseLabel>(`/groupCourse/labels/${id}`),

  getByTypeId: (typeId: number) =>
    request.get<CourseLabel[]>(`/groupCourse/types/${typeId}/labels`),

  getPage: (params: CourseLabelPageRequest) =>
    request.post<PageResponse<CourseLabel>>('/groupCourse/labels/page', params),

  create: (data: CourseLabel) =>
    request.post<CourseLabel>('/groupCourse/labels', data),

  update: (id: number, data: CourseLabel) =>
    request.put<CourseLabel>(`/groupCourse/labels/${id}`, data),

  delete: (id: number) =>
    request.delete<void>(`/groupCourse/labels/${id}`),

  addLabelsToType: (typeId: number, labelIds: number[]) =>
    request.post<void>(`/groupCourse/types/${typeId}/labels`, { labelIds }),

  removeLabelFromType: (typeId: number, labelId: number) =>
    request.delete<void>(`/groupCourse/types/${typeId}/labels/${labelId}`),

  clearLabelsFromType: (typeId: number) =>
    request.delete<void>(`/groupCourse/types/${typeId}/labels`),
}

// ==================== 团课推荐 ====================

export interface GroupCourseRecommend {
  id?: number
  courseId: number
  recommendTitle?: string
  recommendContent?: string
  recommendReason?: string
  priority?: number
  isActive?: boolean
  createBy?: string
  updateBy?: string
  createdAt?: string
  updatedAt?: string
}

export const groupCourseRecommendApi = {
  getAll: () =>
    request.get<GroupCourseRecommend[]>('/groupCourse/recommend/list'),

  getActive: () =>
    request.get<GroupCourseRecommend[]>('/groupCourse/recommend/active'),

  getById: (id: number) =>
    request.get<GroupCourseRecommend>(`/groupCourse/recommend/${id}`),

  getByCourseId: (courseId: number) =>
    request.get<GroupCourseRecommend[]>(`/groupCourse/recommend/course/${courseId}`),

  create: (data: GroupCourseRecommend) =>
    request.post<GroupCourseRecommend>('/groupCourse/recommend', data),

  update: (id: number, data: GroupCourseRecommend) =>
    request.put<GroupCourseRecommend>(`/groupCourse/recommend/${id}`, data),

  delete: (id: number) =>
    request.delete<void>(`/groupCourse/recommend/${id}`),

  enable: (id: number) =>
    request.post<void>(`/groupCourse/recommend/${id}/enable`),

  disable: (id: number) =>
    request.post<void>(`/groupCourse/recommend/${id}/disable`),
}

// ==================== 团课预约 ====================

export interface GroupCourseBooking {
  id?: number
  courseId: number
  memberId: number
  memberCardId: number
  bookingTime?: string
  status?: string
  cancelTime?: string
  courseName?: string
  courseStartTime?: string
  courseEndTime?: string
  location?: string
  createBy?: string
  updateBy?: string
  createdAt?: string
  updatedAt?: string
}

export const groupCourseBookingApi = {
  book: (data: GroupCourseBooking) =>
    request.post<GroupCourseBooking>('/groupCourse/book', data),

  cancel: (bookingId: number) =>
    request.post<void>(`/groupCourse/booking/${bookingId}/cancel`),

  getByMemberId: (memberId: number) =>
    request.get<GroupCourseBooking[]>(`/groupCourse/bookings/member/${memberId}`),

  getByCourseId: (courseId: number) =>
    request.get<GroupCourseBooking[]>(`/groupCourse/bookings/course/${courseId}`),

  getById: (bookingId: number) =>
    request.get<GroupCourseBooking>(`/groupCourse/bookings/${bookingId}`),
}