match-vote-admin/src/services/api.ts

// @ts-ignore
/* eslint-disable */
import { request } from '@umijs/max';

/**
 * 文件上传接口
 * @param formData 上传的文件数据
 */
export async function uploadImage(formData: FormData) {
  return request<API.UploadResponse>(`${API_URL}/api/upload`, {
    method: 'POST',
    data: formData,
    // 上传文件时不需要 Content-Type，浏览器会自动设置
    requestType: 'form',
  });
}

/**
 * 获取球队信息
 */
export async function getTeamLogoByName(params: any) {
  return request<API.TeamResponse>(`${API_URL}/api/team`, {
    method: 'GET',
    params,
    skipErrorHandler: true,
  });
}

/**
 * 创建球队
 * @param params 创建球队的参数
 */
export async function createTeam(params: API.TeamItem) {
  return request<API.TeamResponse>(`${API_URL}/api/team`, {
    method: 'POST',
    data: params,
  });
}

// 预测 begin
export async function getPredictions(
  params: {
    current?: number;
    pageSize?: number;
  },
  options?: { [key: string]: any },
) {
  return request<API.PredictionList>(`${API_URL}/api/prediction`, {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

export async function searchPredictions(
  params: {
    current?: number;
    pageSize?: number;
    user?: string;
    match?: string;
    whoWillWin?: 'home' | 'away' | 'draw';
    firstTeamToScore?: 'home' | 'away' | 'no_goal';
    totalGoals?: number;
    pointsEarned?: number;
    // isCorrect?: boolean;
  },
  options?: { [key: string]: any },
) {
  return request<API.PredictionList>(`${API_URL}/api/prediction`, {
    method: 'GET',
    params: {
      action: 'searchPredictions',
      ...params,
    },
    ...(options || {}),
  });
}

export async function addPrediction(options?: { [key: string]: any }) {
  return request<API.PredictionList>(`${API_URL}/api/prediction`, {
    method: 'POST',
    data: {
      ...(options || {}),
    },
  });
}

export async function updatePrediction(id: string, options?: { [key: string]: any }) {
  console.log('Sending update request for id:', id);
  console.log('Update data:', options);
  return request<API.PredictionList>(`${API_URL}/api/prediction`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({
      id,
      ...(options || {}),
    }),
  });
}

export async function deletePrediction(id: string) {
  console.log('Sending delete request for id:', id);
  return request<API.PredictionList>(`${API_URL}/api/prediction?id=${id}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

export async function batchDeletePredictions(ids: string[]) {
  console.log('Sending batch delete request for ids:', ids);
  return request<API.PredictionList>(`${API_URL}/api/prediction?ids=${ids}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({ ids }),
  });
}
// 预测 end

// 赛事 begin
export async function getMatches(
  params: {
    current?: number;
    pageSize?: number;
    type?: 'football' | 'basketball'; // 添加类型参数
  },
  options?: { [key: string]: any },
) {
  return request<API.MatchList>(`${API_URL}/api/match?action=getMatches`, {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

export async function addMatch(type: 'football' | 'basketball', options?: { [key: string]: any }) {
  return request<API.MatchList>(`${API_URL}/api/match`, {
    method: 'POST',
    data: {
      type,
      ...(options || {}),
    },
  });
}

export async function updateMatch(
  id: string,
  type: 'football' | 'basketball',
  options?: { [key: string]: any },
) {
  return request<API.MatchList>(`${API_URL}/api/match`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({
      id,
      type,
      ...(options || {}),
    }),
  });
}

export async function deleteMatch(id: string) {
  console.log('Sending delete request for id:', id);
  return request<API.MatchList>(`${API_URL}/api/match?id=${id}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

export async function batchDeleteMatches(ids: string[]) {
  console.log('Sending batch delete request for ids:', ids);

  const idsString = ids.join(',');

  return request<API.MatchList>(`${API_URL}/api/match?ids=${idsString}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}
// 赛事 end

// 用户 begin

export async function getUsers(
  params: {
    current?: number;
    pageSize?: number;
  },
  options?: { [key: string]: any },
) {
  return request<API.UserList>(`${API_URL}/api/user`, {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

export async function addUser(options?: { [key: string]: any }) {
  return request<API.UserList>(`${API_URL}/api/user`, {
    method: 'POST',
    data: {
      method: 'add',
      ...(options || {}),
    },
  });
}

export async function updateUser(id: string, options?: { [key: string]: any }) {
  console.log('Sending update request for user id:', id);
  console.log('Update data:', options);
  return request<API.UserList>(`${API_URL}/api/user`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({
      id,
      ...(options || {}),
    }),
  });
}

export async function deleteUser(id: string) {
  console.log('Sending delete request for user id:', id);
  return request<API.UserList>(`${API_URL}/api/user?id=${id}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

export async function batchDeleteUsers(ids: string[]) {
  console.log('Sending batch delete request for user ids:', ids);

  const idsString = ids.join(',');

  return request<API.UserList>(`${API_URL}/api/user?ids=${idsString}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

//  一键清空用户积分
export async function oneClickClear() {
  return request<API.clearResult>(`${API_URL}/api/one-click-clear`, {
    method: 'POST',
  });
}

// 用户end

/** 登录接口 POST /api/login/account */
export async function login(body: API.LoginParams, options?: { [key: string]: any }) {
  return request<API.LoginResult>(`${API_URL}/api/auth/login`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

export async function register(body: API.LoginParams, options?: { [key: string]: any }) {
  return request<API.RegisterResult>(`${API_URL}/api/auth/register`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

// 修改积分历史
export async function updateUserPoints(userId: string, points: number, reason: string) {

  return request<API.PointHistoryResponse>(`${API_URL}/api/point-history`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({
      userId,
      points,
      reason,
    }),
  });
}

// 获取积分历史
export async function getUserPointHistory(
  params: {
    userId: string;
    current?: number;
    pageSize?: number;
  },
  options?: { [key: string]: any },
) {
  return request<API.PointHistoryList>(`${API_URL}/api/point-history`, {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

// 删除单个积分历史记录
export async function deletePointHistory(id: string) {
  console.log('发送删除请求，积分历史记录ID:', id);
  return request<API.PointHistoryList>(`${API_URL}/api/point-history?id=${id}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

// 批量删除积分历史记录
export async function batchDeletePointHistory(ids: string[]) {
  console.log('发送批量删除请求，积分历史记录IDs:', ids);
  const idsString = ids.join(',');
  return request<API.PointHistoryList>(`${API_URL}/api/point-history?ids=${idsString}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

export async function updatePredictionsForMatch(matchId: string) {
  return request<API.updatePredictionsForMatchRes>(`${API_URL}/api/updateForMatch`, {
    method: 'POST',
    data: { matchId },
  });
}

/** 退出登录接口 POST /api/login/outLogin */
export async function outLogin(options?: { [key: string]: any }) {
  return request<Record<string, any>>('/api/login/outLogin', {
    method: 'POST',
    ...(options || {}),
  });
}

//活动
export async function getActivity(
  params: {
    current?: number;
    pageSize?: number;
  },
  options?: { [key: string]: any },
) {
  return request<API.ActivityList>(`${API_URL}/api/activity`, {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

export async function createActivity(options?: { [key: string]: any }) {
  return request<API.ActivityList>(`${API_URL}/api/activity`, {
    method: 'POST',
    data: {
      ...(options || {}),
    },
  });
}

export async function updateActivity(id: string, options?: { [key: string]: any }) {
  console.log('Sending update request for activity id:', id);
  console.log('Update data:', options);
  return request<API.ActivityList>(`${API_URL}/api/activity`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({
      id,
      ...(options || {}),
    }),
  });
}

export async function deleteActivity(id: string) {
  console.log('Sending delete request for activity id:', id);
  return request<{ success: boolean }>(`${API_URL}/api/activity?id=${id}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

// 最新活动
export async function getNewActivities(
  params: {
    current?: number;
    pageSize?: number;
  },
  options?: { [key: string]: any },
) {
  return request<API.NewActivityList>(`${API_URL}/api/new-activities`, {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

export async function createNewActivity(options?: { [key: string]: any }) {
  return request<API.NewActivityList>(`${API_URL}/api/new-activities`, {
    method: 'POST',
    data: {
      ...(options || {}),
    },
  });
}

export async function updateNewActivity(id: string, options?: { [key: string]: any }) {
  console.log('Sending update request for new activity id:', id);
  console.log('Update data:', options);
  return request<API.NewActivityList>(`${API_URL}/api/new-activities`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({
      id,
      ...(options || {}),
    }),
  });
}

export async function deleteNewActivity(id: string) {
  console.log('Sending delete request for new activity id:', id);
  return request<{ success: boolean }>(`${API_URL}/api/new-activities?id=${id}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

// 积分项目接口
export async function getExchangeItems(
  params: {
    current?: number;
    pageSize?: number;
  },
  options?: { [key: string]: any },
) {
  return request<API.ExchangeItemList>(`${API_URL}/api/exchange-items`, {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

export async function createExchangeItem(options?: { [key: string]: any }) {
  return request<API.ExchangeItemList>(`${API_URL}/api/exchange-items`, {
    method: 'POST',
    data: {
      ...(options || {}),
    },
  });
}

export async function updateExchangeItem(id: string, options?: { [key: string]: any }) {
  console.log('Sending update request for exchange item id:', id);
  console.log('Update data:', options);
  return request<API.ExchangeItemList>(`${API_URL}/api/exchange-items`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({
      id,
      ...(options || {}),
    }),
  });
}

export async function deleteExchangeItem(id: string) {
  console.log('Sending delete request for exchange item id:', id);
  return request<{ success: boolean }>(`${API_URL}/api/exchange-items?id=${id}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}

// 积分历史接口
export async function getExchangeHistory(
  params: {
    current?: number;
    pageSize?: number;
  },
  options?: { [key: string]: any },
) {
  return request<API.ExchangeHistoryList>(`${API_URL}/api/exchange-history`, {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

export async function createExchangeHistory(options?: { [key: string]: any }) {
  return request<API.ExchangeHistoryList>(`${API_URL}/api/exchange-history`, {
    method: 'POST',
    data: {
      ...(options || {}),
    },
  });
}

export async function updateExchangeHistory(id: string, options?: { [key: string]: any }) {

  return request<API.ExchangeHistoryList>(`${API_URL}/api/exchange-history`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
    },
    data: JSON.stringify({
      id,
      ...(options || {}),
    }),
  });
}

export async function deleteExchangeHistory(id: string) {

  return request<{ success: boolean }>(`${API_URL}/api/exchange-history?id=${id}`, {
    method: 'DELETE',
    headers: {
      'Content-Type': 'application/json',
    },
  });
}