feat: api

zhengyiming

2025-02-17 9402749e7e8bd7d7be88084a55323c748ea02cc6

feat: api

 .env.development

@@ -1,5 +1,5 @@
# é¡¹ç›®æœ¬åœ°è¿è¡Œç«¯å£å·
VITE_PORT = 8388
VITE_PORT = 8188

# å¼€å‘环境读取配置文件路径
VITE_PUBLIC_PATH = /
@@ -22,4 +22,4 @@
VITE_OSS_URL_BUCKET = "waterdroptest2"
VITE_WEMAP_KEY = "T2UBZ-N563J-ZCHFF-XDOXN-VCH7S-CJB2T"

VITE_CLIENT_ORIGIN = "http://localhost:8388"
VITE_CLIENT_ORIGIN = "http://localhost:8188"

 config/openapi.json

@@ -2,7 +2,7 @@
  "config": [
    {
      "requestLibPath": "import { request } from '@/utils/request'",
      "schemaPath": "http://localhost:57190/swagger/v1/swagger.json",
      "schemaPath": "http://localhost:58190/swagger/v1/swagger.json",
      "serversPath": "./src/services"
    }
  ]

 src/hooks/useUser.ts

@@ -1,7 +1,6 @@
import { useUserStore } from '@/store/modules/user';
import { UserUtils } from '@bole-core/core';
// import * as userRoleServices from '@/services/api/UserRole';
import * as userServices from '@/services/api/User';
import { useQuery, useQueryClient } from '@tanstack/vue-query';

export function useIsSystemAdmin() {
@@ -23,17 +22,21 @@
}

export function useAllRoleList() {
  const { data: allRoleList, refetch } = useQuery({
    queryKey: ['userServices/getAllRoles'],
    queryFn: async () => {
      let res = await userServices.getAllRoles({ showLoading: false });
      return res;
    },
    placeholderData: () => [] as API.RoleInfo[],
  });
  // const { data: allRoleList, refetch } = useQuery({
  //   queryKey: ['userServices/getAllRoles'],
  //   queryFn: async () => {
  //     let res = await userServices.getAllRoles({ showLoading: false });
  //     return res;
  //   },
  //   placeholderData: () => [] as API.RoleInfo[],
  // });

  // return {
  //   allRoleList,
  //   refetch,
  // };
  return {
    allRoleList,
    refetch,
    allRoleList: [],
    refetch: () => {},
  };
}

 src/services/api/Account.ts

@@ -2,6 +2,400 @@
// @ts-ignore
import { request } from '@/utils/request';

/** æ ¹æ®æ‰‹æœºå·åˆ¤æ–­ç”¨æˆ·æ˜¯å¦å·²å­˜åœ¨ POST /api/Account/AnyUserByPhoneNumber */
export async function anyUserByPhoneNumber(
  body: API.AnyUserByPhoneNumberInput,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/Account/AnyUserByPhoneNumber', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** C端验证码登录 POST /api/Account/CClientPhoneMesssageCodeLogin */
export async function cClientPhoneMesssageCodeLogin(
  body: API.PhoneMesssageCodeLoginInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/CClientPhoneMesssageCodeLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** C端手机号验证码注册注册 POST /api/Account/CClientPhoneMesssageCodeRegister */
export async function cClientPhoneMesssageCodeRegister(
  body: API.PhoneMesssageCodeRegisterInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/CClientPhoneMesssageCodeRegister', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** ç”¨æˆ·æ ¹æ®å½“前密码修改密码 POST /api/Account/ChangePasswordFromCurrentPwd */
export async function changePasswordFromCurrentPwd(
  body: API.ChangePasswordFromCurrentPwdInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangePasswordFromCurrentPwd', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** ç”¨æˆ·æ ¹æ®æ‰‹æœºå·ä¿®æ”¹å¯†ç éªŒè¯ç  POST /api/Account/ChangePasswordFromPhoneNumber */
export async function changePasswordFromPhoneNumber(
  body: API.ChangePasswordFromPhoneNumberInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangePasswordFromPhoneNumber', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æœªç™»å½•ä¸‹æ ¹æ®æ‰‹æœºå·ä¿®æ”¹å¯†ç éªŒè¯ç (忘记密码) POST /api/Account/ChangePasswordWithNoLogin */
export async function changePasswordWithNoLogin(
  body: API.ChangePasswordFromPhoneNumberInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangePasswordWithNoLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** ä¿®æ”¹è´¦å· POST /api/Account/ChangeUserName */
export async function changeUserName(body: API.ChangeUserNameInput, options?: API.RequestConfig) {
  return request<number>('/api/Account/ChangeUserName', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** ç®¡ç†å‘˜æ›´æ”¹ç”¨æˆ·ç™»å½•æ‰‹æœºå· POST /api/Account/ChangeUserPhoneNumberForAdmin */
export async function changeUserPhoneNumberForAdmin(
  body: API.ChangePhoneNumberInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangeUserPhoneNumberForAdmin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** ç”¨æˆ·æ›´æ”¹ç™»å½•æ‰‹æœºå· POST /api/Account/ChangeUserPhoneNumberForUser */
export async function changeUserPhoneNumberForUser(
  body: API.ChangeUserPhoneNumberForUserInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangeUserPhoneNumberForUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** ç”Ÿæˆè´¦å· POST /api/Account/GenerateUserName */
export async function generateUserName(
  body: API.GenerateUserNameInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Account/GenerateUserName', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 POST /api/Account/GetOssSTS */
export async function getOssSTS(options?: API.RequestConfig) {
  return request<API.OssSTSReponse>('/api/Account/GetOssSTS', {
    method: 'POST',
    ...(options || {}),
  });
}

/** èŽ·å–扫码登录二维码信息 GET /api/Account/GetQrCodeForLogin */
export async function getQrCodeForLogin(options?: API.RequestConfig) {
  return request<API.QrCodeLogin>('/api/Account/GetQrCodeForLogin', {
    method: 'GET',
    ...(options || {}),
  });
}

/** èŽ·å–扫码登录结果 GET /api/Account/GetQrCodeLoginResult */
export async function getQrCodeLoginResult(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetQrCodeLoginResultParams,
  options?: API.RequestConfig
) {
  return request<API.WxMiniAppLoginInfo>('/api/Account/GetQrCodeLoginResult', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** ç”µå­ç­¾ç™»å½• POST /api/Account/GetTokenForUserSign */
export async function getTokenForUserSign(body: API.AccessRequestDto, options?: API.RequestConfig) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/GetTokenForUserSign', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 POST /api/Account/GetTokenForWeb */
export async function getTokenForWeb(body: API.AccessRequestDto, options?: API.RequestConfig) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/GetTokenForWeb', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** èŽ·å–微信小程序用户身份会话信息 GET /api/Account/GetWxIndentity */
export async function getWxIndentity(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWxIndentityParams,
  options?: API.RequestConfig
) {
  return request<API.WxMiniAppIndentityInfo>('/api/Account/GetWxIndentity', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** åˆ¤æ–­ç”¨æˆ·æ‰‹æœºå·æ˜¯å¦é‡å¤ GET /api/Account/IsRepeatByPhoneNumber */
export async function isRepeatByPhoneNumber(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIisRepeatByPhoneNumberParams,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/Account/IsRepeatByPhoneNumber', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** å¯†ç ç™»å½• POST /api/Account/PasswordLogin */
export async function passwordLogin(body: API.PasswordLoginInput, options?: API.RequestConfig) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/PasswordLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** éªŒè¯ç ç™»å½• POST /api/Account/PhoneMesssageCodeLogin */
export async function phoneMesssageCodeLogin(
  body: API.PhoneMesssageCodeLoginInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/PhoneMesssageCodeLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ‰‹æœºå·éªŒè¯ç æ³¨å†Œæ³¨å†Œ POST /api/Account/PhoneMesssageCodeRegister */
export async function phoneMesssageCodeRegister(
  body: API.PhoneMesssageCodeRegisterInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/PhoneMesssageCodeRegister', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** é‡ç½®å¯†ç å¹¶å‘送手机通知新密码 POST /api/Account/ResetPasswordWithMicroNotify */
export async function resetPasswordWithMicroNotify(
  body: API.ResetPasswordBaseInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ResetPasswordWithMicroNotify', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** å‘送登录注册短信验证码 POST /api/Account/SendPhoneMesssageCode */
export async function sendPhoneMesssageCode(
  body: API.SendPhoneMesssageCodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/SendPhoneMesssageCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** è§£ç»‘用户手机号 POST /api/Account/UnbindingUserPhoneNumber */
export async function unbindingUserPhoneNumber(
  body: API.UnbindingUserPhoneNumber,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/UnbindingUserPhoneNumber', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** è¯†åˆ«è¥ä¸šæ‰§ç…§ GET /api/Account/VatLicense */
export async function vatLicense(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIvatLicenseParams,
  options?: API.RequestConfig
) {
  return request<API.LicenseOcrModel>('/api/Account/VatLicense', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** å°ç¨‹åºæ‰‹æœºæŽˆæƒæ³¨å†Œç™»å½• POST /api/Account/WxMiniAppPhoneAuthLogin */
export async function wxMiniAppPhoneAuthLogin(
  body: API.WxMiniAppPhoneLoginInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/WxMiniAppPhoneAuthLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** å°ç¨‹åºæ‰«ç æ‰‹æœºæŽˆæƒæ³¨å†Œç™»å½• POST /api/Account/WxMiniAppPhoneAuthLoginFromScan */
export async function wxMiniAppPhoneAuthLoginFromScan(
  body: API.WxMiniAppPhoneAuthLoginFromScanInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/WxMiniAppPhoneAuthLoginFromScan', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** å·²æœ‰å°ç¨‹åºç”¨æˆ·ç¡®è®¤ç™»å½• GET /api/Account/WxMiniAppUserLogin */
export async function wxMiniAppUserLogin(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIwxMiniAppUserLoginParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/Account/WxMiniAppUserLogin', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** å·²æœ‰å°ç¨‹åºç”¨æˆ·æ‰«ç ç¡®è®¤ç™»å½• POST /api/Account/WxMiniAppUserLoginFromScan */
export async function wxMiniAppUserLoginFromScan(
  body: API.WxMiniAppUserLoginFromScanInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/WxMiniAppUserLoginFromScan', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 GET /api/accountAuth/GetCode */
export async function getCode(options?: API.RequestConfig) {
  return request<any>('/api/accountAuth/GetCode', {

 src/services/api/Common.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,45 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** èŽ·å–预览数据 GET /api/Common/GetPreViewCache */
export async function getPreViewCache(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPreViewCacheParams,
  options?: API.RequestConfig
) {
  return request<string>('/api/Common/GetPreViewCache', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** å‘送验证码 POST /api/Common/SendVerificationCode */
export async function sendVerificationCode(
  body: API.SendPhoneVerificationCodeByBusinessTypeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Common/SendVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** å†™å…¥é¢„览数据 POST /api/Common/SetPreViewCache */
export async function setPreViewCache(body: API.SetPreViewCacheInput, options?: API.RequestConfig) {
  return request<string>('/api/Common/SetPreViewCache', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/FlexWorker.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,105 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** å‘布/编辑任务 POST /api/FlexWorker/AddEidtFlexTask */
export async function addEidtFlexTask(body: API.AddEidtFlexTaskInput, options?: API.RequestConfig) {
  return request<number>('/api/FlexWorker/AddEidtFlexTask', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** ä»»åŠ¡åˆ é™¤ DELETE /api/FlexWorker/DeleteFlexTask */
export async function deleteFlexTask(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteFlexTaskParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/FlexWorker/DeleteFlexTask', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** B端小程序-获取任务管理(未安排/已安排) POST /api/FlexWorker/GetFlexTaskByArrange */
export async function getFlexTaskByArrange(
  body: API.GetFlexTaskListInput,
  options?: API.RequestConfig
) {
  return request<API.GetFlexTaskListOutputPageOutput>('/api/FlexWorker/GetFlexTaskByArrange', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** B端小程序-获取验收管理(待验收/已验收) POST /api/FlexWorker/GetFlexTaskByIsOverCheck */
export async function getFlexTaskByIsOverCheck(
  body: API.GetFlexTaskListInput,
  options?: API.RequestConfig
) {
  return request<API.GetFlexTaskListOutputPageOutput>('/api/FlexWorker/GetFlexTaskByIsOverCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** èŽ·å–招聘任务详情 GET /api/FlexWorker/GetFlexTaskDto */
export async function getFlexTaskDto(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetFlexTaskDtoParams,
  options?: API.RequestConfig
) {
  return request<API.GetFlexTaskDtoOutput>('/api/FlexWorker/GetFlexTaskDto', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** èŽ·å–招聘管理列表(发布中/已停止) POST /api/FlexWorker/GetFlexTaskList */
export async function getFlexTaskList(
  body: API.GetFlexTaskListByStatusInput,
  options?: API.RequestConfig
) {
  return request<API.GetFlexTaskListOutputPageOutput>('/api/FlexWorker/GetFlexTaskList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ›´æ–°æ‹›è˜ä»»åŠ¡å‘布状态 POST /api/FlexWorker/UpdateFlexTaskReleaseStatus */
export async function updateFlexTaskReleaseStatus(
  body: API.UpdateTaskReleaseStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/FlexWorker/UpdateFlexTaskReleaseStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/InsuranceClaim.ts

ÎļþÒÑɾ³ý

 src/services/api/InsuranceOrder.ts

ÎļþÒÑɾ³ý

 src/services/api/SearchSetting.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,86 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** æœç´¢ç®¡ç†--新建编辑 POST /api/SearchSetting/CreateOrEditSearchSetting */
export async function createOrEditSearchSetting(
  body: API.CreateOrEditSearchInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/SearchSetting/CreateOrEditSearchSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æœç´¢ç®¡ç†--禁用启用 POST /api/SearchSetting/EnableSearchSetting */
export async function enableSearchSetting(
  body: API.EnableSearchSettingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/SearchSetting/EnableSearchSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ ¹æ®èŽ·å¾—全部指定类型搜索条件 POST /api/SearchSetting/GetAllSearchSettingList */
export async function getAllSearchSettingList(
  body: API.GetSearchSettingListInput,
  options?: API.RequestConfig
) {
  return request<API.GetSearchSettingList[]>('/api/SearchSetting/GetAllSearchSettingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** èŽ·å–查询条件列表 GET /api/SearchSetting/GetSearchConditionList */
export async function getSearchConditionList(options?: API.RequestConfig) {
  return request<API.SearchConditionList[]>('/api/SearchSetting/GetSearchConditionList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** æœç´¢ç®¡ç†--列表 POST /api/SearchSetting/GetSearchSettingList */
export async function getSearchSettingList(
  body: API.GetSearchSettingListInput,
  options?: API.RequestConfig
) {
  return request<API.GetSearchSettingListPageOutput>('/api/SearchSetting/GetSearchSettingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ ¹æ®ç±»åž‹èŽ·å¾—指定类型搜索条件 POST /api/SearchSetting/GetTypeSearchSettingList */
export async function getTypeSearchSettingList(
  body: API.GetTypeSearchSettingListInput,
  options?: API.RequestConfig
) {
  return request<API.GetTypeSearchSettingList[]>('/api/SearchSetting/GetTypeSearchSettingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/User.ts

ÎļþÒÑɾ³ý

 src/services/api/UserResume.ts

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,134 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** æ­¤å¤„后端没有提供注释 GET /api/UserResume/GetUserResume */
export async function getUserResume(options?: API.RequestConfig) {
  return request<API.MyResumeOutput>('/api/UserResume/GetUserResume', {
    method: 'GET',
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 GET /api/UserResume/GetUserResumeCertificateDetailById */
export async function getUserResumeCertificateDetailById(
  // å åŠ ç”Ÿæˆçš„Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserResumeCertificateDetailByIdParams,
  options?: API.RequestConfig
) {
  return request<API.UserResumeCertificateDetailOutput>(
    '/api/UserResume/GetUserResumeCertificateDetailById',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** æ­¤å¤„后端没有提供注释 GET /api/UserResume/GetUserResumeCertificateList */
export async function getUserResumeCertificateList(options?: API.RequestConfig) {
  return request<API.UserResumeCertificateListOutput[]>(
    '/api/UserResume/GetUserResumeCertificateList',
    {
      method: 'GET',
      ...(options || {}),
    }
  );
}

/** æ­¤å¤„后端没有提供注释 GET /api/UserResume/GetUserResumeDetailInfo */
export async function getUserResumeDetailInfo(options?: API.RequestConfig) {
  return request<API.UserResumeDetailInfoOutput>('/api/UserResume/GetUserResumeDetailInfo', {
    method: 'GET',
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 GET /api/UserResume/GetUserResumeWorkExperience */
export async function getUserResumeWorkExperience(options?: API.RequestConfig) {
  return request<API.UserResumeWorkExperienceOutput>(
    '/api/UserResume/GetUserResumeWorkExperience',
    {
      method: 'GET',
      ...(options || {}),
    }
  );
}

/** æ­¤å¤„后端没有提供注释 POST /api/UserResume/SaveUserResumeBaseInfo */
export async function saveUserResumeBaseInfo(
  body: API.SaveUserResumeBaseInfoInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/UserResume/SaveUserResumeBaseInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 POST /api/UserResume/SaveUserResumeCertificate */
export async function saveUserResumeCertificate(
  body: API.SaveUserResumeCertificateInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/UserResume/SaveUserResumeCertificate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 POST /api/UserResume/SaveUserResumeDetailInfo */
export async function saveUserResumeDetailInfo(
  body: API.SaveUserResumeDetailInfoInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/UserResume/SaveUserResumeDetailInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 POST /api/UserResume/SaveUserResumeExpectationJob */
export async function saveUserResumeExpectationJob(
  body: API.SaveUserResumeExpectationJobInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/UserResume/SaveUserResumeExpectationJob', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** æ­¤å¤„后端没有提供注释 POST /api/UserResume/SaveUserResumeWorkExperience */
export async function saveUserResumeWorkExperience(
  body: API.SaveUserResumeWorkExperienceInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/UserResume/SaveUserResumeWorkExperience', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/index.ts

@@ -6,33 +6,35 @@
import * as AbpApplicationConfiguration from './AbpApplicationConfiguration';
import * as Account from './Account';
import * as BaseModule from './BaseModule';
import * as Common from './Common';
import * as Features from './Features';
import * as FlexWorker from './FlexWorker';
import * as IdentityRole from './IdentityRole';
import * as IdentityUser from './IdentityUser';
import * as IdentityUserLookup from './IdentityUserLookup';
import * as InsuranceClaim from './InsuranceClaim';
import * as InsuranceOrder from './InsuranceOrder';
import * as Permissions from './Permissions';
import * as PhoneMessage from './PhoneMessage';
import * as Profile from './Profile';
import * as SearchSetting from './SearchSetting';
import * as Tenant from './Tenant';
import * as User from './User';
import * as UserResume from './UserResume';
import * as Version from './Version';
export default {
  AbpApiDefinition,
  AbpApplicationConfiguration,
  Account,
  BaseModule,
  Common,
  Features,
  FlexWorker,
  IdentityRole,
  IdentityUser,
  IdentityUserLookup,
  InsuranceClaim,
  InsuranceOrder,
  Permissions,
  PhoneMessage,
  Profile,
  SearchSetting,
  Tenant,
  User,
  UserResume,
  Version,
};

 src/services/api/typings.d.ts

@@ -28,80 +28,26 @@
    implementFrom?: string;
  }

  interface AddInsuranceClaimAttachmentInput {
    /** æ–‡ä»¶åç§° */
    fileName?: string;
    /** æ–‡ä»¶åœ°å€ */
    url?: string;
    businessType?: InsuranceClaimAttachmentBusinessTypeEnum;
  }

  interface AddInsuranceClaimInput {
    /** æ¸ é“ */
    channel?: string;
    /** å§“名 */
    name: string;
    /** èº«ä»½è¯å· */
    idNumber: string;
    /** å·¥ç§ */
    workType: string;
    /** åŠ³åŠ¨åˆåŒå•ä½ */
    laborContractEnterprise: string;
    /** å®žé™…工作单位 */
    workEnterprise: string;
    /** ä¿é™©èµ·å§‹æ—¶é—´ */
    insuranceBeginTime: string;
    /** ä¿é™©ç»“束时间 */
    insuranceEndTime: string;
    /** å‚保机构 */
    insuredInstitution: string;
    /** æŠ•ä¿æ–¹æ¡ˆ */
    insuranceScheme: string;
    /** åœ¨èŒæ ‡è¯† */
    onJobFlag?: string;
    /** æ€§åˆ« */
    gender?: string;
    /** å¹´é¾„ */
    age?: number;
    /** ä¿è´¹é‡‘额 */
    premiumAmount?: number;
    /** å¢žå‡è´¹ç”¨ */
    incDecAmount?: number;
    /** ä¿å•id */
    insuranceOrderId?: string;
    /** æŠ¥æ¡ˆæ—¶é—´ */
    reportedTime: string;
    /** è”系电话 */
    contactNumber: string;
    /** å¤‡ç”¨è”系电话 */
    bakContactNumber?: string;
    /** äº‹æ•…类型 */
    accidentType: string;
    /** äº‹æ•…发生时间 */
    accidentTime: string;
    /** ä¼¤æ®‹æ¯”例 */
    disabilityRatio?: number;
    /** äº‹å‘地点 */
    accidentAddress: string;
    /** äº‹æ•…经过 */
    accidentProcess: string;
    claimResult?: InsuranceClaimResultEnum;
    /** ä¸‹æ¬¾é‡‘额 */
    downPaymentAmount?: number;
    /** ç†èµ”结果时间 */
    claimResultTime?: string;
    /** é™„件集合 */
    attachments?: AddInsuranceClaimAttachmentInput[];
  }

  interface AddInsuranceOrderMaterialInput {
    insuranceOrderId?: string;
    /** æ–‡ä»¶åç§° */
    fileName?: string;
    /** æ–‡ä»¶åœ°å€ */
    url?: string;
    /** ææ–™åç§° */
    materialName: string;
  interface AddEidtFlexTaskInput {
    taskId?: string;
    taskName?: string;
    feeType?: FlexTaskFeeTypeEnum;
    /** æœåŠ¡è´¹ å…ƒ/月 */
    fee?: number;
    settleType?: FlexTaskSettleTypeEnum;
    /** ç¦åˆ©Id */
    listAideIds?: string[];
    minAge?: number;
    maxAge?: number;
    sexType?: GenderTypeEnum;
    /** è¯ä¹¦Id */
    listCertionIds?: string[];
    provinceId?: string;
    cityId?: string;
    areaId?: string;
    address?: string;
    startDate?: string;
    endDate?: string;
  }

  interface AllSubModule {
@@ -110,6 +56,11 @@
    column?: ModuleColumnDto[];
  }

  interface AnyUserByPhoneNumberInput {
    /** æ‰‹æœºå· */
    phoneNumber: string;
  }

  interface APIaddOrEditModuleStatusParams {
    id?: string;
    isMenu?: number;
@@ -135,6 +86,10 @@
    id?: string;
  }

  interface APIdeleteFlexTaskParams {
    id?: string;
  }

  interface APIdeleteModuleButtonParams {
    id?: string;
  }
@@ -151,10 +106,6 @@
    id?: string;
  }

  interface APIdeleteRoleParams {
    id?: string;
  }

  interface APIdeleteTenantParams {
    id?: string;
  }
@@ -213,23 +164,7 @@
    moduleId?: string;
  }

  interface APIgetInsuranceClaimDetailByOrderIdParams {
    orderId?: string;
  }

  interface APIgetInsuranceClaimDetailParams {
    id?: string;
  }

  interface APIgetInsuranceClaimYearMonthCountListParams {
    year?: number;
  }

  interface APIgetInsuranceOrderDetailParams {
    id?: string;
  }

  interface APIgetInsuranceOrderMaterialListParams {
  interface APIgetFlexTaskDtoParams {
    id?: string;
  }

@@ -270,12 +205,17 @@
    id?: string;
  }

  interface APIgetRolesIdRolesParams {
    id: string;
  interface APIgetPreViewCacheParams {
    id?: string;
  }

  interface APIgetUserDetailParams {
    id?: string;
  interface APIgetQrCodeLoginResultParams {
    /** æ‰«ç ç™»å½•Id */
    uId?: string;
  }

  interface APIgetRolesIdRolesParams {
    id: string;
  }

  interface APIgetUserListByPhoneNumberParams {
@@ -293,6 +233,10 @@
    objectType?: number;
  }

  interface APIgetUserResumeCertificateDetailByIdParams {
    id?: string;
  }

  interface APIgetVersionModuleListParams {
    versionId?: string;
  }
@@ -301,6 +245,16 @@
    versionId?: string;
  }

  interface APIgetWxIndentityParams {
    /** ç”¨æˆ·ç™»å½•å‡­è¯ */
    code?: string;
    wxMiniApp?: WxMiniAppEnum;
  }

  interface APIisRepeatByPhoneNumberParams {
    phoneNumber?: string;
  }

  interface APIsearchParams {
    filter?: string;
    sorting?: string;
@@ -351,6 +305,16 @@
    id?: string;
  }

  interface APIvatLicenseParams {
    url?: string;
  }

  interface APIwxMiniAppUserLoginParams {
    /** ç”¨æˆ·ç™»å½•å‡­è¯ */
    code?: string;
    wxMiniApp?: WxMiniAppEnum;
  }

  interface ApplicationApiDescriptionModel {
    modules?: Record<string, any>;
    types?: Record<string, any>;
@@ -405,11 +369,35 @@
    objectId?: string;
  }

  interface ChangePasswordFromCurrentPwdInput {
    /** æ–°å¯†ç  */
    newPassword?: string;
    userId?: string;
    /** å½“前密码 */
    currentPassword: string;
  }

  interface ChangePasswordFromPhoneNumberInput {
    /** æ–°å¯†ç  */
    newPassword?: string;
    userId?: string;
    /** çŸ­ä¿¡éªŒè¯ç  */
    verificationCode: string;
    /** æ‰‹æœºå· */
    phoneNumber: string;
  }

  interface ChangePasswordInput {
    currentPassword?: string;
    newPassword: string;
  }

  interface ChangePhoneNumberInput {
    userId?: string;
    /** æ–°æ‰‹æœºå· */
    newPhoneNumber: string;
  }

  interface ChangeSortInput {
    id1?: string;
    sortCode1?: number;
@@ -418,6 +406,23 @@
    type?: number;
  }

  interface ChangeUserNameInput {
    /** æ–°è´¦å· */
    newUserName?: string;
    /** ç”¨æˆ·id */
    userId?: string;
  }

  interface ChangeUserPhoneNumberForUserInput {
    userId?: string;
    /** æ–°æ‰‹æœºå· */
    newPhoneNumber: string;
    /** å½“前密码 */
    currentPassword: string;
    /** çŸ­ä¿¡éªŒè¯ç  */
    verificationCode: string;
  }

  interface CheckLoginVerificationCodeInput {
    messageType?: string;
    phoneNumber: string;
@@ -428,6 +433,12 @@
    kind?: string;
  }

  interface ConditionInfo {
    id?: string;
    name?: string;
    sort?: number;
  }

  interface ControllerApiDescriptionModel {
    controllerName?: string;
    controllerGroupName?: string;
@@ -440,38 +451,16 @@
    type?: string;
  }

  interface CreateAccountInput {
    /** åç§° */
    name?: string;
    /** ç”¨æˆ·å */
    userName: string;
    /** å¤‡æ³¨ */
    remark?: string;
    /** å¯†ç  */
    password: string;
    /** æ‰‹æœºå· */
    phoneNumber?: string;
    /** æ¸ é“ */
    channel?: string;
    /** ç”¨æˆ·ç«¯Id */
    clientId?: string;
    /** è§’色 */
    roleNames?: string[];
  }

  interface CreateOrUpdateRoleInput {
    /** åç§° */
    name?: string;
    /** æŽ’序 */
    sequence?: number;
    /** éƒ¨é—¨Id */
    departmentId?: number;
    /** æ•°æ®èŒƒå›´ å…¨éƒ¨æ•°æ®100 ä¸ªäººæ•°æ® 10 */
    dataRange?: number;
    /** å¤‡æ³¨ */
    remark?: string;
    /** è§’色Id */
  interface CreateOrEditSearchInput {
    id?: string;
    parentId?: string;
    searchType: number;
    belongType?: number;
    name: string;
    sort: number;
    status: boolean;
    src?: string;
    isRecommend?: boolean;
  }

  interface CurrentCultureDto {
@@ -520,6 +509,11 @@
    longTimePattern?: string;
  }

  interface EnableSearchSettingInput {
    id: string;
    status: boolean;
  }

  interface EntityExtensionDto {
    properties?: Record<string, any>;
    configuration?: Record<string, any>;
@@ -614,19 +608,138 @@
    key?: string;
  }

  interface FlexTaskAideDto {
    id?: string;
    aideType?: FlexTaskAideEnum;
    name?: string;
  }

  type FlexTaskAideEnum = 10 | 20;

  type FlexTaskFeeTypeEnum = 10 | 20 | 30 | 40;

  type FlexTaskReleaseStatusEnum = 10 | 20;

  type FlexTaskSettleTypeEnum = 10 | 20 | 30;

  type GenderTypeEnum = 1 | 2;

  interface GenerateUserNameInput {
    /** æ‰‹æœºå· */
    phoneNumber: string;
  }

  interface GetFeatureListResultDto {
    groups?: FeatureGroupDto[];
  }

  interface GetFlexTaskDtoOutput {
    taskId?: string;
    taskName?: string;
    isArrange?: boolean;
    startDate?: string;
    endDate?: string;
    feeType?: FlexTaskFeeTypeEnum;
    feeTypeName?: string;
    settleType?: FlexTaskSettleTypeEnum;
    settleTypeName?: string;
    taskWeals?: FlexTaskAideDto[];
    taskCerts?: FlexTaskAideDto[];
    fee?: number;
    provinceId?: string;
    cityId?: string;
    areaId?: string;
    provinceName?: string;
    cityName?: string;
    areaName?: string;
    address?: string;
    creationDate?: string;
    minAge?: number;
    maxAge?: number;
    sexType?: GenderTypeEnum;
  }

  interface GetFlexTaskListByStatusInput {
    pageModel?: Pagination;
    releaseStatus?: FlexTaskReleaseStatusEnum;
  }

  interface GetFlexTaskListInput {
    pageModel?: Pagination;
    /** æ˜¯å¦å·²å®‰æŽ’任务 */
    isArrange?: boolean;
    /** æ˜¯å¦å·²éªŒæ”¶ */
    isOverCheck?: boolean;
  }

  interface GetFlexTaskListOutput {
    taskId?: string;
    taskName?: string;
    isArrange?: boolean;
    startDate?: string;
    endDate?: string;
    feeType?: FlexTaskFeeTypeEnum;
    feeTypeName?: string;
    settleType?: FlexTaskSettleTypeEnum;
    settleTypeName?: string;
    fee?: number;
    provinceName?: string;
    cityName?: string;
    areaName?: string;
    address?: string;
    applyWorkerCount?: number;
    creationDate?: string;
  }

  interface GetFlexTaskListOutputPageOutput {
    pageModel?: Pagination;
    objectData?: any;
    data?: GetFlexTaskListOutput[];
  }

  interface GetPermissionListResultDto {
    entityDisplayName?: string;
    groups?: PermissionGroupDto[];
  }

  interface GetRolesInput {
  interface GetSearchSettingList {
    id?: string;
    parentId?: string;
    parentName?: string;
    belongType?: number;
    name?: string;
    sort?: number;
    status?: boolean;
    clickCount?: number;
    src?: string;
    isRecommend?: boolean;
  }

  interface GetSearchSettingListInput {
    pageModel?: Pagination;
    /** æŸ¥è¯¢æ¡ä»¶ï¼šè§’色名称 */
    queryCondition?: string;
    searchType: number;
    belongType?: number;
    name?: string;
    isRecommend?: boolean;
    status?: boolean;
    parentId?: string;
  }

  interface GetSearchSettingListPageOutput {
    pageModel?: Pagination;
    objectData?: any;
    data?: GetSearchSettingList[];
  }

  interface GetTypeSearchSettingList {
    id?: string;
    name?: string;
    src?: string;
  }

  interface GetTypeSearchSettingListInput {
    searchType: number;
    belongType?: number;
  }

  interface IanaTimeZone {
@@ -765,233 +878,9 @@
    roleNames: string[];
  }

  interface ImportInsuranceOrderDataOutput {
    /** æ¸ é“ */
    channel: string;
    /** å§“名 */
    name: string;
    /** èº«ä»½è¯å· */
    idNumber: string;
    /** å·¥ç§ */
    workType: string;
    /** åŠ³åŠ¨åˆåŒå•ä½ */
    laborContractEnterprise: string;
    /** å®žé™…工作单位 */
    workEnterprise: string;
    /** ä¿é™©èµ·å§‹æ—¶é—´ */
    insuranceBeginTimeStr: string;
    /** ä¿é™©ç»“束时间 */
    insuranceEndTimeStr: string;
    insuranceEndTime?: string;
    insuranceBeginTime?: string;
    /** å‚保机构 */
    insuredInstitution: string;
    /** æŠ•ä¿æ–¹æ¡ˆ */
    insuranceScheme: string;
    /** åœ¨èŒæ ‡è¯† */
    onJobFlag: string;
    /** æ€§åˆ« */
    gender: string;
    /** å¹´é¾„ */
    ageStr: string;
    age?: number;
    /** èº«ä»½è¯æ ¡éªŒç»“æžœ */
    idCardCheckResult: string;
    /** èº«ä»½è¯é‡å¤æ ¡éªŒç»“æžœ */
    idCardRepeatResult: string;
    /** ä¿è´¹é‡‘额 */
    premiumAmountStr: string;
    /** å¢žå‡è´¹ç”¨ */
    incDecAmountStr: string;
    incDecAmount?: number;
    premiumAmount?: number;
    /** ä¸šåŠ¡å‘˜åç§° */
    salesmanName?: string;
    /** ä¿å•å· */
    orderNo?: string;
    /** ä¿å•å…³è”唯一字符串 */
    orderRelevanceStr?: string;
    /** ä¿å•æ ‡è¯†å­—段 */
    orderFlagStr?: string;
    /** å¼‚常消息 */
    erroMsg?: string;
  }

  type InsuranceClaimAttachmentBusinessTypeEnum = 10 | 20 | 30 | 40 | 50;

  interface InsuranceClaimAttachmentOutput {
    /** æ–‡ä»¶åç§° */
    fileName?: string;
    /** æ–‡ä»¶åœ°å€ */
    url?: string;
    businessType?: InsuranceClaimAttachmentBusinessTypeEnum;
  }

  interface InsuranceClaimDetailOutput {
  interface IdNameOutput {
    id?: string;
    /** æ¸ é“ */
    channel?: string;
    /** å§“名 */
    name?: string;
    /** èº«ä»½è¯å· */
    idNumber?: string;
    /** å·¥ç§ */
    workType?: string;
    /** åŠ³åŠ¨åˆåŒå•ä½ */
    laborContractEnterprise?: string;
    /** å®žé™…工作单位 */
    workEnterprise?: string;
    /** ä¿é™©èµ·å§‹æ—¶é—´ */
    insuranceBeginTime?: string;
    /** ä¿é™©ç»“束时间 */
    insuranceEndTime?: string;
    /** å‚保机构 */
    insuredInstitution?: string;
    /** æŠ•ä¿æ–¹æ¡ˆ */
    insuranceScheme?: string;
    /** åœ¨èŒæ ‡è¯† */
    onJobFlag?: string;
    /** è¡Œåˆ« */
    gender?: string;
    /** å¹´é¾„ */
    age?: number;
    /** ä¿è´¹é‡‘额 */
    premiumAmount?: number;
    /** å¢žå‡è´¹ç”¨ */
    incDecAmount?: number;
    /** ä¿å•id */
    insuranceOrderId?: string;
    /** æŠ¥æ¡ˆæ—¶é—´ */
    reportedTime?: string;
    /** è”系电话 */
    contactNumber?: string;
    /** å¤‡ç”¨è”系电话 */
    bakContactNumber?: string;
    /** äº‹æ•…类型 */
    accidentType?: string;
    /** äº‹æ•…发生时间 */
    accidentTime?: string;
    /** ä¼¤æ®‹æ¯”例 */
    disabilityRatio?: number;
    /** äº‹å‘地点 */
    accidentAddress?: string;
    /** äº‹æ•…经过 */
    accidentProcess?: string;
    claimResult?: InsuranceClaimResultEnum;
    /** ä¸‹æ¬¾é‡‘额 */
    downPaymentAmount?: number;
    /** ç†èµ”结果时间 */
    claimResultTime?: string;
    /** é™„件集合 */
    attachments?: InsuranceClaimAttachmentOutput[];
  }

  interface InsuranceClaimListOutput {
    id?: string;
    /** èº«ä»½è¯å· */
    idNumber?: string;
    /** å§“名 */
    name?: string;
    /** æŠ¥æ¡ˆæ—¶é—´ */
    reportedTime?: string;
    /** ä¿é™©èµ·å§‹æ—¶é—´ */
    insuranceBeginTime?: string;
    /** ä¿é™©ç»“束时间 */
    insuranceEndTime?: string;
    /** äº‹æ•…类型 */
    accidentType?: string;
    /** äº‹æ•…发生时间 */
    accidentTime?: string;
    /** ä¼¤æ®‹æ¯”例 */
    disabilityRatio?: number;
    /** ç†èµ”渠道 */
    claimChannel?: string;
    claimResult?: InsuranceClaimResultEnum;
    /** ä¸‹æ¬¾é‡‘额 */
    downPaymentAmount?: number;
    /** ç†èµ”结果时间 */
    claimResultTime?: string;
    /** ä¿å•id */
    insuranceOrderId?: string;
  }

  interface InsuranceClaimListOutputPageOutput {
    pageModel?: Pagination;
    objectData?: any;
    data?: InsuranceClaimListOutput[];
  }

  type InsuranceClaimResultEnum = 10 | 20 | 30;

  interface InsuranceClaimYearMonthCountListOutput {
    year?: number;
    month?: number;
    count?: number;
  }

  interface InsuranceOrderListOutput {
    id?: string;
    /** æ¸ é“ */
    channel?: string;
    /** å§“名 */
    name?: string;
    /** èº«ä»½è¯å· */
    idNumber?: string;
    /** å·¥ç§ */
    workType?: string;
    /** åŠ³åŠ¨åˆåŒå•ä½ */
    laborContractEnterprise?: string;
    /** å®žé™…工作单位 */
    workEnterprise?: string;
    /** ä¿é™©èµ·å§‹æ—¶é—´ */
    insuranceBeginTime?: string;
    /** ä¿é™©ç»“束时间 */
    insuranceEndTime?: string;
    /** å‚保机构 */
    insuredInstitution?: string;
    /** æŠ•ä¿æ–¹æ¡ˆ */
    insuranceScheme?: string;
    /** åœ¨èŒæ ‡è¯† */
    onJobFlag?: string;
    /** æ€§åˆ« */
    gender?: string;
    /** å¹´é¾„ */
    age?: number;
    /** èº«ä»½è¯æ ¡éªŒç»“æžœ */
    idCardCheckResult?: string;
    /** èº«ä»½è¯é‡å¤æ ¡éªŒç»“æžœ */
    idCardRepeatResult?: string;
    /** ä¿è´¹é‡‘额 */
    premiumAmount?: number;
    /** å¢žå‡è´¹ç”¨ */
    incDecAmount?: number;
    /** å¯¼å…¥æ¸ é“ */
    importChannel?: string;
    /** å¯¼å…¥æ—¥æœŸ */
    createTime?: string;
    isIndustrialInjury?: string;
    /** åˆ›å»ºäºº */
    creatorId?: string;
    /** ä¸šåŠ¡å‘˜åç§° */
    salesmanName?: string;
    /** ä¿å•å· */
    orderNo?: string;
    /** ä¿å•å…³è”唯一字符串 */
    orderRelevanceStr?: string;
  }

  interface InsuranceOrderListOutputPageOutput {
    pageModel?: Pagination;
    objectData?: any;
    data?: InsuranceOrderListOutput[];
  }

  interface InsuranceOrderMaterialListOutput {
    id?: string;
    /** æ–‡ä»¶åœ°å€ */
    url?: string;
    /** ææ–™åç§° */
    materialName?: string;
  }

  interface IStringValueType {
@@ -1021,6 +910,19 @@
    flagIcon?: string;
  }

  interface LicenseOcrModel {
    name?: string;
    cardNum?: string;
    address?: string;
    type?: string;
    dateFrom?: string;
    dateTo?: string;
    societyCode?: string;
    registerMoney?: string;
    businessRange?: string;
    legalPerson?: string;
  }

  interface LocalizableStringDto {
    name?: string;
    resource?: string;
@@ -1120,6 +1022,11 @@
    sequence?: number;
  }

  interface MyResumeOutput {
    resumeBaseInfo?: UserResumeBaseInfoOutput;
    resumeExpectationJob?: UserResumeExpectationJobOutput;
  }

  interface NameValue {
    name?: string;
    value?: string;
@@ -1177,7 +1084,7 @@
  }

  interface PasswordLoginInput {
    /** è´¦å· */
    /** ç™»å½•å */
    loginName: string;
    /** ç™»å½•å¯†ç  */
    password: string;
@@ -1198,6 +1105,22 @@
    permissions?: PermissionGrantInfoDto[];
  }

  interface PhoneMesssageCodeLoginInput {
    /** æ‰‹æœºå· */
    phoneNumber: string;
    /** éªŒè¯ç  */
    code: string;
    type?: UserTypeEnum;
  }

  interface PhoneMesssageCodeRegisterInput {
    /** æ‰‹æœºå· */
    phoneNumber: string;
    /** éªŒè¯ç  */
    code: string;
    type?: UserTypeEnum;
  }

  interface PhoneToken {
    phone?: string;
    phoneCode?: string;
@@ -1228,40 +1151,11 @@
    providerKey?: string;
  }

  interface QueryInsuranceClaimCountInput {
    year?: number;
    month?: number;
    /** ç†èµ”渠道 */
    claimChannel?: string;
  }

  interface QueryInsuranceClaimPageInput {
    pageModel?: Pagination;
    /** ç†èµ”渠道 */
    claimChannel?: string;
    /** åŠ³åŠ¨åˆåŒå•ä½ */
    laborContractEnterprise?: string;
    /** å®žé™…工作单位 */
    workEnterprise?: string;
    /** èº«ä»½è¯å· */
    idNumber?: string;
  }

  interface QueryInsuranceOrderListByOrderRelevanceInput {
    idIdNumber?: string;
    reportedTime?: string;
  }

  interface QueryInsuranceOrderPageInput {
    pageModel?: Pagination;
    beginCreationTime?: string;
    endCreationTime?: string;
    importChannel?: string;
  }

  interface QueryUserPageInput {
    pageModel?: Pagination;
    searchKey?: string;
  interface QrCodeLogin {
    /** æ‰«ç ç™»å½•Id */
    uId?: string;
    /** äºŒç»´ç åœ°å€ */
    url?: string;
  }

  interface RegisterDto {
@@ -1290,6 +1184,10 @@
    members?: string[];
  }

  interface ResetPasswordBaseInput {
    userId?: string;
  }

  interface ResetPasswordDto {
    userId?: string;
    resetToken: string;
@@ -1309,36 +1207,49 @@
    typeSimple?: string;
  }

  interface RoleEnableOrForbidInput {
    /** è§’色Id */
    id?: string;
    /** å¯ç”¨ï¼štrue，禁用：false */
    isEnable?: boolean;
  }

  interface RoleInfo {
    /** è§’色Id */
    id?: string;
    /** åç§° */
  interface SaveUserResumeBaseInfoInput {
    name?: string;
    /** æŽ’序 */
    sequence?: number;
    /** æ˜¯å¦å¯ç”¨ */
    isEnable?: boolean;
    /** éƒ¨é—¨Id */
    departmentId?: number;
    /** æ•°æ®èŒƒå›´ å…¨éƒ¨æ•°æ®ï¼š100   ä¸ªäººæ•°æ®ï¼š10 */
    dataRange?: number;
    /** è´¦å·æ•°é‡ */
    userCount?: number;
    /** å¤‡æ³¨ */
    remark?: string;
    socialIdentity?: string;
    educationalLevel?: string;
    residentProvinceCode?: number;
    residentCityCode?: number;
    residentProvinceName?: string;
    residentCityName?: string;
  }

  interface RoleInfoPageOutput {
    pageModel?: Pagination;
    objectData?: any;
    data?: RoleInfo[];
  interface SaveUserResumeCertificateInput {
    id?: string;
    certificateTypeId?: string;
    certificateNo?: string;
    beginTime?: string;
    endTime?: string;
    isPermanent?: boolean;
    certificateUnit?: string;
    certificateFrontImgUrl?: string;
    certificateBackImgUrl?: string;
  }

  interface SaveUserResumeDetailInfoInput {
    lifeCircleImgUrlList?: string[];
    height?: string;
    weight?: string;
  }

  interface SaveUserResumeExpectationJobInput {
    jobIdList?: string[];
    freeTime?: UserResumeFreeTimeEnum;
    jobSeekingStatus?: UserResumeJobSeekingStatusEnum;
  }

  interface SaveUserResumeWorkExperienceInput {
    workingSeniority?: string;
    workExperience?: string;
  }

  interface SearchConditionList {
    searchType?: number;
    belongType?: number;
    conditionList?: ConditionInfo[];
  }

  interface SendPasswordResetCodeDto {
@@ -1353,6 +1264,17 @@
    phoneNumber: string;
  }

  interface SendPhoneMesssageCodeInput {
    /** æ‰‹æœºå· */
    phoneNumber: string;
  }

  interface SendPhoneVerificationCodeByBusinessTypeInput {
    /** æ‰‹æœºå· */
    phoneNumber: string;
    businessType?: VerificationCodeBusinessTypeEnum;
  }

  interface SetMyModule {
    moduleId?: string;
    sequence?: number;
@@ -1362,6 +1284,10 @@
    moduleIds?: SetMyModule[];
  }

  interface SetPreViewCacheInput {
    preViewData?: string;
  }

  interface SetRoleUserInput {
    userId?: string[];
    roleId?: string;
@@ -1408,22 +1334,8 @@
    properties?: PropertyApiDescriptionModel[];
  }

  interface UpdateAccountInput {
    id?: string;
    /** åç§° */
    name?: string;
    /** ç”¨æˆ·å */
    userName: string;
    /** å¤‡æ³¨ */
    remark?: string;
    /** å¯†ç  */
    password?: string;
    /** æ‰‹æœºå· */
    phoneNumber?: string;
    /** æ¸ é“ */
    channel?: string;
    /** è§’色 */
    roleNames?: string[];
  interface UnbindingUserPhoneNumber {
    userId?: string;
  }

  interface UpdateFeatureDto {
@@ -1435,65 +1347,6 @@
    features?: UpdateFeatureDto[];
  }

  interface UpdateInsuranceClaimInput {
    /** æ¸ é“ */
    channel?: string;
    /** å§“名 */
    name: string;
    /** èº«ä»½è¯å· */
    idNumber: string;
    /** å·¥ç§ */
    workType: string;
    /** åŠ³åŠ¨åˆåŒå•ä½ */
    laborContractEnterprise: string;
    /** å®žé™…工作单位 */
    workEnterprise: string;
    /** ä¿é™©èµ·å§‹æ—¶é—´ */
    insuranceBeginTime: string;
    /** ä¿é™©ç»“束时间 */
    insuranceEndTime: string;
    /** å‚保机构 */
    insuredInstitution: string;
    /** æŠ•ä¿æ–¹æ¡ˆ */
    insuranceScheme: string;
    /** åœ¨èŒæ ‡è¯† */
    onJobFlag?: string;
    /** æ€§åˆ« */
    gender?: string;
    /** å¹´é¾„ */
    age?: number;
    /** ä¿è´¹é‡‘额 */
    premiumAmount?: number;
    /** å¢žå‡è´¹ç”¨ */
    incDecAmount?: number;
    /** ä¿å•id */
    insuranceOrderId?: string;
    /** æŠ¥æ¡ˆæ—¶é—´ */
    reportedTime: string;
    /** è”系电话 */
    contactNumber: string;
    /** å¤‡ç”¨è”系电话 */
    bakContactNumber?: string;
    /** äº‹æ•…类型 */
    accidentType: string;
    /** äº‹æ•…发生时间 */
    accidentTime: string;
    /** ä¼¤æ®‹æ¯”例 */
    disabilityRatio?: number;
    /** äº‹å‘地点 */
    accidentAddress: string;
    /** äº‹æ•…经过 */
    accidentProcess: string;
    claimResult?: InsuranceClaimResultEnum;
    /** ä¸‹æ¬¾é‡‘额 */
    downPaymentAmount?: number;
    /** ç†èµ”结果时间 */
    claimResultTime?: string;
    /** é™„件集合 */
    attachments?: AddInsuranceClaimAttachmentInput[];
    id?: string;
  }

  interface UpdatePassWordInput {
    id?: string;
    passWord?: string;
@@ -1523,6 +1376,11 @@
    phoneNumber?: string;
  }

  interface UpdateTaskReleaseStatusInput {
    taskId?: string;
    releaseStatus?: FlexTaskReleaseStatusEnum;
  }

  interface UserData {
    id?: string;
    tenantId?: string;
@@ -1545,48 +1403,64 @@
    items?: UserData[];
  }

  interface UserDetailOutput {
    id?: string;
    /** åç§° */
  interface UserResumeBaseInfoOutput {
    name?: string;
    /** ç”¨æˆ·å */
    userName?: string;
    /** å¤‡æ³¨ */
    remark?: string;
    /** æ‰‹æœºå· */
    phoneNumber?: string;
    /** æ¸ é“ */
    channel?: string;
    /** ç”¨æˆ·ç«¯Id */
    clientId?: string;
    /** è§’色 */
    roleNames?: string[];
    socialIdentity?: string;
    socialIdentityName?: string;
    educationalLevel?: string;
    educationalLevelName?: string;
    residentProvinceCode?: number;
    residentCityCode?: number;
    residentProvinceName?: string;
    residentCityName?: string;
  }

  interface UserListOutput {
  interface UserResumeCertificateDetailOutput {
    id?: string;
    /** åç§° */
    name?: string;
    /** ç”¨æˆ·å */
    userName?: string;
    /** å¤‡æ³¨ */
    remark?: string;
    /** æ‰‹æœºå· */
    phoneNumber?: string;
    /** æ¸ é“ */
    channel?: string;
    /** ç”¨æˆ·ç«¯Id */
    clientId?: string;
    /** è§’色 */
    roleNames?: string[];
    userResumeId?: string;
    certificateTypeId?: string;
    certificateNo?: string;
    beginTime?: string;
    endTime?: string;
    isPermanent?: boolean;
    certificateUnit?: string;
    certificateFrontImgUrl?: string;
    certificateBackImgUrl?: string;
  }

  interface UserListOutputPageOutput {
    pageModel?: Pagination;
    objectData?: any;
    data?: UserListOutput[];
  interface UserResumeCertificateListOutput {
    id?: string;
    certificateTypeId?: string;
    certificateTypeName?: string;
    userResumeId?: string;
  }

  interface UserResumeDetailInfoOutput {
    height?: string;
    weight?: string;
    lifeCircleImgUrlList?: string[];
  }

  interface UserResumeExpectationJobOutput {
    jobIdList?: IdNameOutput[];
    freeTime?: UserResumeFreeTimeEnum;
    jobSeekingStatus?: UserResumeJobSeekingStatusEnum;
  }

  type UserResumeFreeTimeEnum = 1 | 2 | 3 | 4 | 5;

  type UserResumeJobSeekingStatusEnum = 1 | 2 | 3;

  interface UserResumeWorkExperienceOutput {
    workingSeniority?: string;
    workExperience?: string;
  }

  type UserTypeEnum = 1 | 2;

  type VerificationCodeBusinessTypeEnum = 10 | 11 | 20 | 30 | 40 | 70 | 900 | 910 | 920;

  interface VersionCache {
    name?: string;
    departmentCount?: number;
@@ -1628,4 +1502,58 @@
  interface WindowsTimeZone {
    timeZoneId?: string;
  }

  type WxMiniAppEnum = 10;

  interface WxMiniAppIndentityInfo {
    /** ä¼šè¯å¯†é’¥ */
    sessionKey?: string;
    /** å°ç¨‹åºOpenId */
    openId?: string;
    /** ç”¨æˆ·åï¼ˆè¯¥å€¼ä¸ºç©ºåˆ™éœ€æ‰‹æœºæŽˆæƒç™»å½•ï¼Œä¸ä¸ºç©ºåˆ™å·²æœ‰è¯¥å°ç¨‹åºç”¨æˆ·ï¼‰ */
    userName?: string;
  }

  interface WxMiniAppLoginInfo {
    /** çŠ¶æ€ï¼š-10：二维码过期/登录时效过期，0：登录初始/二维码初生成，10：登录确认 */
    status?: number;
    /** ç”¨æˆ·å */
    userName?: string;
    accessToken?: IdentityModelTokenCacheItem;
  }

  interface WxMiniAppPhoneAuthLoginFromScanInput {
    /** ï¼ˆæ‰«ç ï¼‰ç™»å½•Id */
    uId: string;
    /** åŒ…括敏感数据在内的完整用户信息的加密数据 */
    encryptedData: string;
    /** åŠ å¯†ç®—法的初始向量 */
    iv: string;
    /** èŽ·å–会话密钥 */
    sessionKey: string;
    /** å°ç¨‹åºOpenId */
    openId: string;
    wxMiniApp?: WxMiniAppEnum;
  }

  interface WxMiniAppPhoneLoginInput {
    /** åŒ…括敏感数据在内的完整用户信息的加密数据 */
    encryptedData: string;
    /** åŠ å¯†ç®—法的初始向量 */
    iv: string;
    /** èŽ·å–会话密钥 */
    sessionKey: string;
    /** å°ç¨‹åºOpenId */
    openId: string;
    wxMiniApp?: WxMiniAppEnum;
  }

  interface WxMiniAppUserLoginFromScanInput {
    /** ï¼ˆæ‰«ç ï¼‰ç™»å½•Id */
    uId: string;
    /** ç”¨æˆ·å */
    userName: string;
    /** å°ç¨‹åºOpenId */
    openId: string;
  }
}

 src/store/modules/user.ts

@@ -4,7 +4,6 @@
import { resetRouter, router } from '@/router';
import { useTagsViewStoreHook } from './tagsView';
import * as accountServices from '@/services/api/Account';
import * as userServices from '@/services/api/User';
import { usePermissionStoreHook } from './permission';
import { getAccountInfoFromAccessToken, AccountInfo } from '@bole-core/core';
import { useClearSubModule } from '@/hooks';
@@ -64,7 +63,7 @@
    // ç”¨æˆ·ç™»å…¥
    loginByUsername(data: API.AccessRequestDto) {
      return new Promise<void>((resolve, reject) => {
        userServices
        accountServices
          .getTokenForWeb(data, { showLoading: false })
          .then((res) => {
            if (res) {

 src/utils/oss/index.ts

@@ -1,13 +1,13 @@
import { BoleOss } from '@bole-core/core';
import { loadEnv } from '@build/index';
import AliOSS from 'ali-oss';
import * as userServices from '@/services/api/User';
import * as accountServices from '@/services/api/Account';

export class OssManager {
  private static OssInstance: BoleOss;

  private static async getOssSTS() {
    return await userServices.getOssSTS({
    return await accountServices.getOssSTS({
      showLoading: false,
    });
  }

 src/views/Account/AccountManageList.vue

@@ -43,7 +43,7 @@
  useFormDialog,
} from '@bole-core/components';
import { useAccess } from '@/hooks';
import * as userServices from '@/services/api/User';
// import * as userServices from '@/services/api/User';
import { RoleClientType } from '@/constants';
import { Message, OrderInputType } from '@bole-core/core';
import AddOrEditAccountDialog from './components/AddOrEditAccountDialog.vue';
@@ -80,18 +80,19 @@
} = useTable(
  async ({ pageIndex, pageSize }, extraParamState) => {
    try {
      let params: API.QueryUserPageInput = {
        pageModel: {
          rows: pageSize,
          page: pageIndex,
          orderInput: extraParamState.orderInput,
        },
        searchKey: extraParamState.keyword,
      };
      let res = await userServices.getUserPage(params, {
        showLoading: !state.loading,
      });
      return res;
      // let params: API.QueryUserPageInput = {
      //   pageModel: {
      //     rows: pageSize,
      //     page: pageIndex,
      //     orderInput: extraParamState.orderInput,
      //   },
      //   searchKey: extraParamState.keyword,
      // };
      // let res = await userServices.getUserPage(params, {
      //   showLoading: !state.loading,
      // });
      // return res;
      return {};
    } catch (error) {}
  },
  {
@@ -141,27 +142,27 @@
async function handleAddOrEdit() {
  try {
    let isEdit = !!editForm.id;
    let params: API.CreateAccountInput = {
      name: editForm.name,
      userName: editForm.userName,
      remark: editForm.remark,
      password: editForm.password,
      phoneNumber: editForm.phoneNumber,
      channel: editForm.channel,
      // clientId: RoleClientType.RoleBackendClientId,
      roleNames: [editForm.roleName],
    };
    let res;
    if (isEdit) {
      (params as API.UpdateAccountInput).id = editForm.id;
      res = await userServices.updateAccount(params);
    } else {
      res = await userServices.createAccount(params);
    }
    if (res) {
      Message.successMessage('操作成功');
      getList(isEdit ? paginationState.pageIndex : 1);
    }
    // let params: API.CreateAccountInput = {
    //   name: editForm.name,
    //   userName: editForm.userName,
    //   remark: editForm.remark,
    //   password: editForm.password,
    //   phoneNumber: editForm.phoneNumber,
    //   channel: editForm.channel,
    //   // clientId: RoleClientType.RoleBackendClientId,
    //   roleNames: [editForm.roleName],
    // };
    // let res;
    // if (isEdit) {
    //   (params as API.UpdateAccountInput).id = editForm.id;
    //   res = await userServices.updateAccount(params);
    // } else {
    //   res = await userServices.createAccount(params);
    // }
    // if (res) {
    //   Message.successMessage('操作成功');
    //   getList(isEdit ? paginationState.pageIndex : 1);
    // }
  } catch (error) {}
}
</script>

 src/views/Permission/RoleManage.vue

@@ -46,7 +46,7 @@
  useFormDialog,
} from '@bole-core/components';
import { useAccess, useAllRoleList } from '@/hooks';
import * as userServices from '@/services/api/User';
// import * as userServices from '@/services/api/User';
import { Message, OrderInputType } from '@bole-core/core';
import AddOrEditRoleDialog from './components/AddOrEditRoleDialog.vue';
import { DataRangeEnum, DataRangeEnumText } from '@/constants';
@@ -101,25 +101,26 @@
} = useTable(
  async ({ pageIndex, pageSize }, extraParamState) => {
    try {
      let params: API.GetRolesInput = {
        pageModel: {
          rows: pageSize,
          page: pageIndex,
          orderInput: [{ property: 'sequence', order: OrderInputType.Asc }],
        },
        queryCondition: extraParamState.queryCondition,
      };
      let res = await userServices.getRoles(params, {
        showLoading: !state.loading,
      });
      return {
        data: res.data,
        pageModel: {
          rows: pageSize,
          page: pageIndex,
          totalCount: res.pageModel.totalCount,
        },
      };
      // let params: API.GetRolesInput = {
      //   pageModel: {
      //     rows: pageSize,
      //     page: pageIndex,
      //     orderInput: [{ property: 'sequence', order: OrderInputType.Asc }],
      //   },
      //   queryCondition: extraParamState.queryCondition,
      // };
      // let res = await userServices.getRoles(params, {
      //   showLoading: !state.loading,
      // });
      // return {
      //   data: res.data,
      //   pageModel: {
      //     rows: pageSize,
      //     page: pageIndex,
      //     totalCount: res.pageModel.totalCount,
      //   },
      // };
      return {};
    } catch (error) {}
  },
  {
@@ -156,54 +157,54 @@
async function handleAddOrEdit() {
  try {
    const isEdit = editForm.id;
    let params: API.CreateOrUpdateRoleInput = {
      name: editForm.name,
      remark: editForm.remark,
      dataRange: editForm.dataRange,
    };
    let res;
    if (isEdit) {
      params.id = editForm.id;
      res = await userServices.updateRole(params);
    } else {
      res = await userServices.createRole(params);
    }
    if (res) {
      Message.successMessage('操作成功');
      getList(isEdit ? paginationState.pageIndex : 1);
      refetch({ type: 'inactive' });
    }
    // let params: API.CreateOrUpdateRoleInput = {
    //   name: editForm.name,
    //   remark: editForm.remark,
    //   dataRange: editForm.dataRange,
    // };
    // let res;
    // if (isEdit) {
    //   params.id = editForm.id;
    //   res = await userServices.updateRole(params);
    // } else {
    //   res = await userServices.createRole(params);
    // }
    // if (res) {
    //   Message.successMessage('操作成功');
    //   getList(isEdit ? paginationState.pageIndex : 1);
    //   refetch({ type: 'inactive' });
    // }
  } catch (error) {}
}

async function handleDeleteRole(row: API.RoleInfo) {
  try {
    await Message.deleteMessage();
    let params = {
      id: row.id,
    };
    let res = await userServices.deleteRole(params);
    if (res) {
      Message.successMessage('操作成功');
      getList(paginationState.pageIndex);
      refetch({ type: 'inactive' });
    }
    // await Message.deleteMessage();
    // let params = {
    //   id: row.id,
    // };
    // let res = await userServices.deleteRole(params);
    // if (res) {
    //   Message.successMessage('操作成功');
    //   getList(paginationState.pageIndex);
    //   refetch({ type: 'inactive' });
    // }
  } catch (error) {}
}

async function roleEnableOrForbid(row: API.RoleInfo) {
  try {
    await Message.tipMessage(`是否${!row.isEnable ? '启用' : '禁用'}角色`);
    let res = await userServices.roleEnableOrForbid({
      id: row.id,
      isEnable: !row.isEnable,
    });
    if (res) {
      Message.successMessage('操作成功');
      getList(paginationState.pageIndex);
      refetch({ type: 'inactive' });
      return !!res;
    }
    // await Message.tipMessage(`是否${!row.isEnable ? '启用' : '禁用'}角色`);
    // let res = await userServices.roleEnableOrForbid({
    //   id: row.id,
    //   isEnable: !row.isEnable,
    // });
    // if (res) {
    //   Message.successMessage('操作成功');
    //   getList(paginationState.pageIndex);
    //   refetch({ type: 'inactive' });
    //   return !!res;
    // }
  } catch (error) {}
}