ai-table-pulgin/src/script/service.ts

/*global DingdocsScript*/
import type {} from 'dingtalk-docs-cool-app';
import axios from 'axios';

const BASE_URL = 'https://openapi.julefood.cn:8082/api';

interface UserInfo {
  userId: string;
  name?: string;
  avatar?: string;
  mobile?: string;
  jobnumber?: string;
  department?: number[];
  permissions?: string[];
  [key: string]: any;
}

interface LoginResponse {
  code: number;
  result: {
    user_info: string;
    expiration_time: string;
    token: string;
  };
  msg: string;
}

interface ApiParam {
  paramName: string;
  paramDesc: string;
  exampleValue?: string;
  valueList?: string[];
  value?: string;
}

interface ApiItem {
  id: string;
  apiName: string;
  url: string;
  description: string;
  aiTableId: string;
  aiTablename: string;
  apiParamAuth: ApiParam[];
}

interface ApiResponse {
  code: number;
  msg: string;
  data?: any;
}

const TOKEN_KEY = 'julefood_token';
const USER_INFO_KEY = 'julefood_user_info';

function saveToken(token: string): void {
  localStorage.setItem(TOKEN_KEY, token);
}

function getToken(): string {
  return localStorage.getItem(TOKEN_KEY) || '';
}

function removeToken(): void {
  localStorage.removeItem(TOKEN_KEY);
}

function saveUserInfo(userInfo: UserInfo): void {
  const jsonStr = JSON.stringify(userInfo);
  console.log('[DEBUG] saveUserInfo - saving:', jsonStr);
  localStorage.setItem(USER_INFO_KEY, jsonStr);
  const saved = localStorage.getItem(USER_INFO_KEY);
  console.log('[DEBUG] saveUserInfo - verified saved:', saved);
}

function getUserInfo(): UserInfo | null {
  const str = localStorage.getItem(USER_INFO_KEY);
  console.log('[DEBUG] getUserInfo - raw value:', str);
  if (!str) {
    console.warn('[DEBUG] getUserInfo - localStorage is empty');
    return null;
  }
  try {
    const result = JSON.parse(str);
    console.log('[DEBUG] getUserInfo - parsed userId:', result?.userId);
    return result;
  } catch (e) {
    console.error('[DEBUG] getUserInfo - JSON parse failed:', e);
    return null;
  }
}

function removeUserInfo(): void {
  localStorage.removeItem(USER_INFO_KEY);
}

function clearAuth(): void {
  removeToken();
  removeUserInfo();
}

const apiClient = axios.create({
  baseURL: BASE_URL,
  timeout: 30000,
  headers: {
    'Content-Type': 'application/json',
  },
});

apiClient.interceptors.request.use(
  (config) => {
    const token = getToken();
    if (token) {
      config.headers['token'] = token;
    }
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

apiClient.interceptors.response.use(
  (response) => response,
  (error) => {
    console.error('API 请求错误:', error);
    return Promise.reject(error);
  }
);

async function login(authCode: string): Promise<UserInfo> {
  const response = await axios.post<LoginResponse>(
    `${BASE_URL}/sys_user/ddh5/login`,
    {
      code: authCode,
      app_id: 'dingqo0h82jhq5ewv9ow'
    },
    { timeout: 30000 }
  );
  
  if (response.data.code === 200) {
    const token = response.data.result.token;
    saveToken(token);
    
    const userInfoStr = response.data.result.user_info;
    let userInfo: UserInfo;
    try {
      const parsedUserInfo = JSON.parse(userInfoStr);
      userInfo = {
        userId: parsedUserInfo.userid || parsedUserInfo.id || '',
        name: parsedUserInfo.name || '',
        avatar: parsedUserInfo.avatar,
        mobile: parsedUserInfo.mobile,
        jobnumber: parsedUserInfo.jobnumber,
        department: parsedUserInfo.department,
        permissions: parsedUserInfo.permissions,
        ...parsedUserInfo
      };
    } catch (e) {
      console.error('解析用户信息失败:', e);
      userInfo = { userId: '', name: '用户' };
    }
    saveUserInfo(userInfo);
    return userInfo;
  } else {
    throw new Error(response.data.msg || '登录失败');
  }
}

async function getApiList(): Promise<ApiItem[]> {
  const userInfo = getUserInfo();
  const userId = userInfo?.userId || '';
  const response = await apiClient.get('/auth/user/api_asset', {
    params: { userId }
  });
  const applyList = response.data?.data || [];
  
  const uniqueMap = new Map();
  applyList.forEach((item: any) => {
    const apiId = item.apiId;
    if (!uniqueMap.has(apiId) && item.status !== 2) {
      uniqueMap.set(apiId, item);
    }
  });
  
  return Array.from(uniqueMap.values());
}

async function callApi(apiItem: Record<string, any>): Promise<ApiResponse> {
  const params = { ...apiItem };
  params.apiParamAuth = params.apiParamAuth.map((p: any) => ({
    paramName: p.paramName,
    value: p.value
  }));
  
  const userInfo = getUserInfo();
  params.userId = userInfo?.userId || '';
  console.log('[DEBUG] callApi - userId:', params.userId, 'userInfo:', userInfo);

  const response = await apiClient.post('/ding/add', params);
  return response.data;
}

async function getDocumentInfo() {
  try {
    const base = DingdocsScript.base;
    
    const uuid = (base as any).getDentryUuid?.() || (base as any).getDocUuid?.() || (base as any).getUuid?.() || '';
    const sheets = (base as any).getSheets?.() || (base as any).getSheetList?.() || [];
    const activeSheet = (base as any).getActiveSheet?.() || (base as any).getCurrentSheet?.();
    const currentSheet = (activeSheet as any)?.getName?.() || (activeSheet as any)?.name || '';
    
    return {
      uuid: uuid || '',
      sheetsCount: sheets.length,
      currentSheet
    };
  } catch (error: any) {
    return {
      uuid: '',
      sheetsCount: 0,
      currentSheet: ''
    };
  }
}

DingdocsScript.registerScript('login', login);
DingdocsScript.registerScript('getToken', getToken);
DingdocsScript.registerScript('getApiList', getApiList);
DingdocsScript.registerScript('callApi', callApi);
DingdocsScript.registerScript('getDocumentInfo', getDocumentInfo);
DingdocsScript.registerScript('clearAuth', clearAuth);

export {};