feat: complete admin API integration

src/api/http.test.ts

@@ -1,6 +1,21 @@
 import axios, { AxiosHeaders } from 'axios'
-import { describe, expect, it } from 'vitest'
-import { ApiResponseError, getApiErrorDetails, unwrapApiResponse } from './http'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  ApiResponseError,
+  getApiErrorDetails,
+  http,
+  registerAuthRefreshHandler,
+  registerAuthSessionExpiredHandler,
+  unwrapApiResponse,
+} from './http'
+
+const originalAdapter = http.defaults.adapter
+
+afterEach(() => {
+  http.defaults.adapter = originalAdapter
+  registerAuthRefreshHandler(async () => { throw new Error('refresh handler is not configured') })
+  registerAuthSessionExpiredHandler(() => undefined)
+})
 
 describe('API error diagnostics', () => {
   it('keeps business request and trace identifiers when unwrapping fails', () => {
@@ -40,4 +55,29 @@ describe('API error diagnostics', () => {
       traceId: 'trace-2',
     })
   })
+
+  it('notifies session expiry once when concurrent 401 requests share a failed refresh', async () => {
+    const refresh = vi.fn(async () => { throw new Error('refresh token expired') })
+    const expired = vi.fn()
+    registerAuthRefreshHandler(refresh)
+    registerAuthSessionExpiredHandler(expired)
+    http.defaults.adapter = async (config) => {
+      throw new axios.AxiosError('Unauthorized', 'ERR_BAD_REQUEST', config, undefined, {
+        status: 401,
+        statusText: 'Unauthorized',
+        headers: {},
+        config,
+        data: { code: 'A0401', message: '登录状态已过期' },
+      })
+    }
+
+    const results = await Promise.allSettled([
+      http.get('/platform/v1/orders'),
+      http.get('/platform/v1/warehouses'),
+    ])
+
+    expect(results.every((result) => result.status === 'rejected')).toBe(true)
+    expect(refresh).toHaveBeenCalledTimes(1)
+    expect(expired).toHaveBeenCalledTimes(1)
+  })
 })

src/api/http.ts

@@ -43,14 +43,20 @@ export const http = axios.create({
 
 type RetryableRequestConfig = InternalAxiosRequestConfig & { _authRetry?: boolean }
 type AuthRefreshHandler = () => Promise<string>
+type AuthSessionExpiredHandler = () => void | Promise<void>
 
 let authRefreshHandler: AuthRefreshHandler | null = null
+let authSessionExpiredHandler: AuthSessionExpiredHandler | null = null
 let activeRefresh: Promise<string> | null = null
 
 export function registerAuthRefreshHandler(handler: AuthRefreshHandler) {
   authRefreshHandler = handler
 }
 
+export function registerAuthSessionExpiredHandler(handler: AuthSessionExpiredHandler) {
+  authSessionExpiredHandler = handler
+}
+
 http.interceptors.request.use((config) => {
   const token = localStorage.getItem('cc-admin-token')
   if (token) {
@@ -71,7 +77,16 @@ http.interceptors.response.use(
     config._authRetry = true
     try {
       if (!activeRefresh) {
-        activeRefresh = authRefreshHandler().finally(() => { activeRefresh = null })
+        activeRefresh = authRefreshHandler()
+          .catch(async (refreshError) => {
+            try {
+              await authSessionExpiredHandler?.()
+            } catch {
+              // 会话已清理，跳转失败不应覆盖原始认证错误。
+            }
+            throw refreshError
+          })
+          .finally(() => { activeRefresh = null })
       }
       const nextToken = await activeRefresh
       config.headers.Authorization = `Bearer ${nextToken}`

src/api/platformFirstLegOrders.test.ts

@@ -0,0 +1,72 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { http } from '@/api/http'
+import {
+  acceptPlatformFirstLegOrder,
+  addPlatformFirstLegOrderNote,
+  approvePlatformFirstLegOrder,
+  cancelPlatformFirstLegOrder,
+  completePlatformFirstLegOrder,
+  getPlatformFirstLegOrder,
+  listPlatformFirstLegOrders,
+  startPlatformFirstLegOrder,
+  updatePlatformFirstLegOrderExpress,
+} from './platformFirstLegOrders'
+
+vi.mock('@/api/http', () => ({
+  http: { get: vi.fn(), post: vi.fn(), put: vi.fn() },
+  unwrapApiResponse: <T>(response: { data: T }) => response.data,
+}))
+
+describe('platform first-leg order API', () => {
+  beforeEach(() => {
+    vi.mocked(http.get).mockReset()
+    vi.mocked(http.post).mockReset()
+    vi.mocked(http.put).mockReset()
+  })
+
+  it('queries a tenant-scoped order page with server pagination and filters', async () => {
+    const page = { records: [], page: 2, size: 20, total: 0, pages: 0 }
+    vi.mocked(http.get).mockResolvedValue({ code: '0', message: 'success', data: page })
+
+    await expect(listPlatformFirstLegOrders('10001', {
+      keyword: 'FL2026', status: 'SUBMITTED', createdFrom: '2026-07-01T00:00:00', createdTo: '2026-07-31T23:59:59', page: 2, size: 20,
+    })).resolves.toEqual(page)
+    expect(http.get).toHaveBeenCalledWith('/platform/v1/orders/first-leg', {
+      params: {
+        tenantId: '10001', keyword: 'FL2026', status: 'SUBMITTED', createdFrom: '2026-07-01T00:00:00', createdTo: '2026-07-31T23:59:59', page: 2, size: 20,
+      },
+    })
+  })
+
+  it('uses the platform lifecycle routes and target tenant query parameter', async () => {
+    vi.mocked(http.get).mockResolvedValue({ code: '0', message: 'success', data: { order: {} } })
+    vi.mocked(http.post).mockResolvedValue({ code: '0', message: 'success', data: null })
+
+    await getPlatformFirstLegOrder('10001', '90001')
+    await approvePlatformFirstLegOrder('10001', '90001')
+    await acceptPlatformFirstLegOrder('10001', '90001')
+    await startPlatformFirstLegOrder('10001', '90001')
+    await completePlatformFirstLegOrder('10001', '90001')
+    await cancelPlatformFirstLegOrder('10001', '90001', '客户取消')
+    await addPlatformFirstLegOrderNote('10001', '90001', '已联系客户确认')
+
+    expect(http.get).toHaveBeenCalledWith('/platform/v1/orders/first-leg/90001', { params: { tenantId: '10001' } })
+    expect(http.post).toHaveBeenNthCalledWith(1, '/platform/v1/orders/first-leg/90001/approve', undefined, { params: { tenantId: '10001' } })
+    expect(http.post).toHaveBeenNthCalledWith(2, '/platform/v1/orders/first-leg/90001/accept', undefined, { params: { tenantId: '10001' } })
+    expect(http.post).toHaveBeenNthCalledWith(3, '/platform/v1/orders/first-leg/90001/start', undefined, { params: { tenantId: '10001' } })
+    expect(http.post).toHaveBeenNthCalledWith(4, '/platform/v1/orders/first-leg/90001/complete', undefined, { params: { tenantId: '10001' } })
+    expect(http.post).toHaveBeenNthCalledWith(5, '/platform/v1/orders/first-leg/90001/cancel', { reason: '客户取消' }, { params: { tenantId: '10001' } })
+    expect(http.post).toHaveBeenNthCalledWith(6, '/platform/v1/orders/first-leg/90001/internal-notes', { content: '已联系客户确认' }, { params: { tenantId: '10001' } })
+  })
+
+  it('writes the backend express contract as names, not a guessed master-data ID', async () => {
+    vi.mocked(http.put).mockResolvedValue({ code: '0', message: 'success', data: null })
+
+    await updatePlatformFirstLegOrderExpress('10001', '90001', { expressCompany: '顺丰速运', expressTrackingNo: 'SF123456' })
+    expect(http.put).toHaveBeenCalledWith(
+      '/platform/v1/orders/first-leg/90001/express',
+      { expressCompany: '顺丰速运', expressTrackingNo: 'SF123456' },
+      { params: { tenantId: '10001' } },
+    )
+  })
+})

src/api/platformFirstLegOrders.ts

@@ -0,0 +1,171 @@
+import { http, unwrapApiResponse, type ApiEnvelope } from '@/api/http'
+
+export type PlatformFirstLegOrderStatus =
+  | 'DRAFT'
+  | 'SUBMITTED'
+  | 'APPROVED'
+  | 'ACCEPTED'
+  | 'REJECTED'
+  | 'CANCELLED'
+  | 'PROCESSING'
+  | 'COMPLETED'
+
+export interface PlatformFirstLegOrderResource {
+  id: number | string
+  tenantId: number | string
+  orderNo: string | null
+  customerId: number | string | null
+  customerName: string
+  status: PlatformFirstLegOrderStatus
+  transportMode: 'SEA' | 'AIR' | 'RAIL' | 'TRUCK'
+  tradeTerm: string | null
+  destinationCountryCode: string
+  destinationWarehouseId: number | string | null
+  destinationWarehouseName: string
+  expectedShipDate: string | null
+  customerRemark: string | null
+  pickupMethod: string
+  receivingWarehouseId: number | string
+  receivingWarehouseName: string
+  receivingWarehouseAddress: string | null
+  receivingTime: string | null
+  channelCode: string
+  channelName: string
+  taxMode: string
+  containerMode: string | null
+  customsInspection: boolean | null
+  destinationType: string
+  amazonWarehouseCode: string | null
+  shipmentId: string | null
+  referenceId: string | null
+  expressCompany: string | null
+  expressTrackingNo: string | null
+  createdAt: string
+  updatedAt: string
+}
+
+export interface PlatformFirstLegCargoResource {
+  id: number | string
+  itemNo: number
+  cargoName: string
+  cargoNameEn: string | null
+  packageType: string
+  packageCount: number
+  grossWeightKg: number
+  volumeCbm: number
+  totalQuantity: number | null
+  cargoRemark: string | null
+}
+
+export interface PlatformFirstLegPartyResource {
+  id: number | string
+  partyType: 'SENDER' | 'RECEIVER' | string
+  companyName: string
+  contactName: string
+  phone: string
+  email: string | null
+  countryCode: string
+  province: string | null
+  city: string
+  district: string | null
+  addressLine: string
+  postalCode: string | null
+}
+
+export interface PlatformOrderStatusHistoryResource {
+  id: number | string
+  fromStatus: PlatformFirstLegOrderStatus | null
+  toStatus: PlatformFirstLegOrderStatus
+  action: string
+  reason: string | null
+  operatorName: string | null
+  occurredAt: string
+}
+
+export interface PlatformOrderInternalNoteResource {
+  id: number | string
+  content: string
+  createdAt: string
+  createdBy: number | string | null
+}
+
+export interface PlatformFirstLegOrderDetailResource {
+  order: PlatformFirstLegOrderResource
+  cargoes: PlatformFirstLegCargoResource[]
+  parties: PlatformFirstLegPartyResource[]
+  internalNotes: PlatformOrderInternalNoteResource[]
+  statusHistory: PlatformOrderStatusHistoryResource[]
+}
+
+export interface PlatformFirstLegOrderPageResource {
+  records: PlatformFirstLegOrderResource[]
+  page: number
+  size: number
+  total: number
+  pages: number
+}
+
+export interface PlatformFirstLegOrderQuery {
+  keyword?: string
+  status?: PlatformFirstLegOrderStatus
+  customerId?: string
+  destinationWarehouseId?: string
+  createdFrom?: string
+  createdTo?: string
+  page: number
+  size: number
+}
+
+async function getData<T>(path: string, params?: Record<string, unknown>) {
+  const response = await http.get<ApiEnvelope<T>, ApiEnvelope<T>>(path, { params })
+  return unwrapApiResponse(response)
+}
+
+async function postData<T>(path: string, body?: unknown, params?: Record<string, unknown>) {
+  const response = await http.post<ApiEnvelope<T>, ApiEnvelope<T>>(path, body, { params })
+  return unwrapApiResponse(response)
+}
+
+export function listPlatformFirstLegOrders(tenantId: string, query: PlatformFirstLegOrderQuery) {
+  return getData<PlatformFirstLegOrderPageResource>('/platform/v1/orders/first-leg', { tenantId, ...query })
+}
+
+export function getPlatformFirstLegOrder(tenantId: string, orderId: string) {
+  return getData<PlatformFirstLegOrderDetailResource>(`/platform/v1/orders/first-leg/${orderId}`, { tenantId })
+}
+
+export function approvePlatformFirstLegOrder(tenantId: string, orderId: string) {
+  return postData<void>(`/platform/v1/orders/first-leg/${orderId}/approve`, undefined, { tenantId })
+}
+
+export function acceptPlatformFirstLegOrder(tenantId: string, orderId: string) {
+  return postData<void>(`/platform/v1/orders/first-leg/${orderId}/accept`, undefined, { tenantId })
+}
+
+export function startPlatformFirstLegOrder(tenantId: string, orderId: string) {
+  return postData<void>(`/platform/v1/orders/first-leg/${orderId}/start`, undefined, { tenantId })
+}
+
+export function completePlatformFirstLegOrder(tenantId: string, orderId: string) {
+  return postData<void>(`/platform/v1/orders/first-leg/${orderId}/complete`, undefined, { tenantId })
+}
+
+export function cancelPlatformFirstLegOrder(tenantId: string, orderId: string, reason: string) {
+  return postData<void>(`/platform/v1/orders/first-leg/${orderId}/cancel`, { reason }, { tenantId })
+}
+
+export function addPlatformFirstLegOrderNote(tenantId: string, orderId: string, content: string) {
+  return postData<number | string>(`/platform/v1/orders/first-leg/${orderId}/internal-notes`, { content }, { tenantId })
+}
+
+export function updatePlatformFirstLegOrderExpress(
+  tenantId: string,
+  orderId: string,
+  payload: { expressCompany: string; expressTrackingNo: string },
+) {
+  return http.put<ApiEnvelope<void>, ApiEnvelope<void>>(
+    `/platform/v1/orders/first-leg/${orderId}/express`,
+    payload,
+    { params: { tenantId } },
+  ).then(unwrapApiResponse)
+}

src/api/platformIam.test.ts

@@ -1,19 +1,24 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { http } from '@/api/http'
 import {
+  changePlatformRoleStatus,
   createPlatformPermission,
   createPlatformRole,
+  deletePlatformRole,
   downloadTenantQualification,
   listTenantQualifications,
+  listCurrentPlatformPermissionCodes,
   listPlatformPermissions,
   listPlatformRoles,
   qualificationFileName,
+  replacePlatformRolePermissions,
+  updatePlatformRole,
   type PlatformPermissionResource,
   type PlatformRoleResource,
 } from './platformIam'
 
 vi.mock('@/api/http', () => ({
-  http: { get: vi.fn(), post: vi.fn() },
+  http: { get: vi.fn(), post: vi.fn(), put: vi.fn(), delete: vi.fn() },
   unwrapApiResponse: <T>(response: { data: T }) => response.data,
 }))
 
@@ -26,6 +31,7 @@ const role: PlatformRoleResource = {
   roleType: 'SYSTEM',
   status: 'ACTIVE',
   description: '企业资料与入驻审核',
+  permissionIds: ['5100010'],
 }
 
 const permission: PlatformPermissionResource = {
@@ -46,6 +52,8 @@ describe('platform IAM roles', () => {
   beforeEach(() => {
     vi.mocked(http.get).mockReset()
     vi.mocked(http.post).mockReset()
+    vi.mocked(http.put).mockReset()
+    vi.mocked(http.delete).mockReset()
   })
 
   it('loads roles from the platform IAM prefix', async () => {
@@ -67,6 +75,21 @@ describe('platform IAM roles', () => {
     expect(http.post).toHaveBeenCalledWith('/platform/v1/iam/roles', payload)
   })
 
+  it('updates status, permissions, and deletes roles with the implemented IAM routes', async () => {
+    vi.mocked(http.put).mockResolvedValue({ code: '0', message: 'success', data: role })
+    vi.mocked(http.delete).mockResolvedValue({ code: '0', message: 'success', data: null })
+
+    await expect(updatePlatformRole(role.id, { roleName: '审核主管', description: '负责企业审核' })).resolves.toEqual(role)
+    await expect(changePlatformRoleStatus(role.id, 'DISABLED')).resolves.toEqual(role)
+    await expect(replacePlatformRolePermissions(role.id, ['5100010'])).resolves.toEqual(role)
+    await expect(deletePlatformRole(role.id)).resolves.toBeNull()
+
+    expect(http.put).toHaveBeenNthCalledWith(1, `/platform/v1/iam/roles/${role.id}`, { roleName: '审核主管', description: '负责企业审核' })
+    expect(http.put).toHaveBeenNthCalledWith(2, `/platform/v1/iam/roles/${role.id}/status`, { status: 'DISABLED' })
+    expect(http.put).toHaveBeenNthCalledWith(3, '/platform/v1/iam/roles/permissions', { roleId: role.id, permissionIds: ['5100010'] })
+    expect(http.delete).toHaveBeenCalledWith(`/platform/v1/iam/roles/${role.id}`)
+  })
+
   it('loads and creates permission resources under the platform IAM prefix', async () => {
     vi.mocked(http.get).mockResolvedValue({ code: '0', message: 'success', data: [permission] })
     vi.mocked(http.post).mockResolvedValue({ code: '0', message: 'success', data: permission })
@@ -86,6 +109,13 @@ describe('platform IAM roles', () => {
     expect(http.post).toHaveBeenCalledWith('/platform/v1/iam/permissions', payload)
   })
 
+  it('loads the current users permission snapshot without calling the role-management endpoint', async () => {
+    vi.mocked(http.get).mockResolvedValue({ code: '0', message: 'success', data: ['platform:warehouse:list'] })
+
+    await expect(listCurrentPlatformPermissionCodes()).resolves.toEqual(['platform:warehouse:list'])
+    expect(http.get).toHaveBeenCalledWith('/platform/v1/iam/authorization/permissions')
+  })
+
   it('loads qualifications for the selected tenant', async () => {
     const qualification = {
       id: 12,

src/api/platformIam.ts

@@ -44,14 +44,15 @@ export interface PlatformTenantQualification {
 }
 
 export interface PlatformRoleResource {
-  id: number
-  tenantId: number
+  id: number | string
+  tenantId: number | string
   appCode: 'PLATFORM'
   roleCode: string
   roleName: string
   roleType: 'SYSTEM' | 'CUSTOM' | string
   status: 'ACTIVE' | 'INACTIVE' | string
   description: string | null
+  permissionIds?: Array<number | string>
 }
 
 export interface CreatePlatformRoleRequest {
@@ -60,6 +61,11 @@ export interface CreatePlatformRoleRequest {
   description: string
 }
 
+export interface UpdatePlatformRoleRequest {
+  roleName: string
+  description: string
+}
+
 export interface CreatePlatformPermissionRequest {
   type: 'MENU' | 'BUTTON'
   code: string
@@ -80,10 +86,24 @@ async function postData<T>(path: string, body: unknown): Promise<T> {
   return unwrapApiResponse(response)
 }
 
+async function putData<T>(path: string, body: unknown): Promise<T> {
+  const response = await http.put<ApiEnvelope<T>, ApiEnvelope<T>>(path, body)
+  return unwrapApiResponse(response)
+}
+
+async function deleteData<T>(path: string): Promise<T> {
+  const response = await http.delete<ApiEnvelope<T>, ApiEnvelope<T>>(path)
+  return unwrapApiResponse(response)
+}
+
 export function listPlatformPermissions() {
   return getData<PlatformPermissionResource[]>('/platform/v1/iam/permissions')
 }
 
+export function listCurrentPlatformPermissionCodes() {
+  return getData<string[]>('/platform/v1/iam/authorization/permissions')
+}
+
 export function listEnterpriseReviews() {
   return getData<EnterpriseReview[]>('/platform/v1/iam/reviews')
 }
@@ -123,6 +143,22 @@ export function createPlatformRole(payload: CreatePlatformRoleRequest) {
   return postData<PlatformRoleResource>('/platform/v1/iam/roles', payload)
 }
 
+export function updatePlatformRole(roleId: number | string, payload: UpdatePlatformRoleRequest) {
+  return putData<PlatformRoleResource>(`/platform/v1/iam/roles/${roleId}`, payload)
+}
+
+export function changePlatformRoleStatus(roleId: number | string, status: 'ACTIVE' | 'DISABLED') {
+  return putData<PlatformRoleResource>(`/platform/v1/iam/roles/${roleId}/status`, { status })
+}
+
+export function deletePlatformRole(roleId: number | string) {
+  return deleteData<void>(`/platform/v1/iam/roles/${roleId}`)
+}
+
+export function replacePlatformRolePermissions(roleId: number | string, permissionIds: Array<number | string>) {
+  return putData<void>('/platform/v1/iam/roles/permissions', { roleId, permissionIds })
+}
+
 export function createPlatformPermission(payload: CreatePlatformPermissionRequest) {
   return postData<PlatformPermissionResource>('/platform/v1/iam/permissions', payload)
 }

src/api/platformWarehouses.test.ts

@@ -0,0 +1,92 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { http } from '@/api/http'
+import {
+  changePlatformWarehouseStatus,
+  createPlatformWarehouse,
+  getPlatformWarehouse,
+  listPlatformWarehouses,
+  updatePlatformWarehouse,
+  type SavePlatformWarehouseRequest,
+} from './platformWarehouses'
+
+vi.mock('@/api/http', () => ({
+  http: { get: vi.fn(), post: vi.fn(), put: vi.fn(), patch: vi.fn() },
+  unwrapApiResponse: <T>(response: { data: T }) => response.data,
+}))
+
+const payload: SavePlatformWarehouseRequest = {
+  tenantId: 10001,
+  warehouseCode: 'CN-YW-01',
+  warehouseName: '义乌收货仓',
+  warehouseType: 'DOMESTIC',
+  countryCode: 'CN',
+  timezone: 'Asia/Shanghai',
+  contactName: '仓库客服',
+  contactPhone: '0579-12345678',
+  contactEmail: null,
+  status: 'ACTIVE',
+  remark: null,
+  address: {
+    addressType: 'OPERATING',
+    countryCode: 'CN',
+    stateProvince: '浙江省',
+    city: '义乌市',
+    district: null,
+    postalCode: null,
+    addressLine1: '北苑街道 1 号库',
+    addressLine2: null,
+    latitude: null,
+    longitude: null,
+  },
+  capabilities: [{
+    capabilityCode: 'RECEIVING',
+    capabilityName: '收货服务',
+    enabled: true,
+    cutoffTime: null,
+    description: '周一至周六 08:30-18:00',
+  }],
+}
+
+describe('platform warehouse API', () => {
+  beforeEach(() => {
+    vi.mocked(http.get).mockReset()
+    vi.mocked(http.post).mockReset()
+    vi.mocked(http.put).mockReset()
+    vi.mocked(http.patch).mockReset()
+  })
+
+  it('lists and loads warehouse details for the target tenant', async () => {
+    const page = { records: [], page: 1, size: 200, total: 0, pages: 0 }
+    const detail = { warehouse: {}, addresses: [], capabilities: [] }
+    vi.mocked(http.get)
+      .mockResolvedValueOnce({ code: '0', message: 'success', data: page })
+      .mockResolvedValueOnce({ code: '0', message: 'success', data: detail })
+
+    await expect(listPlatformWarehouses(10001)).resolves.toEqual(page)
+    await expect(getPlatformWarehouse(10001, '19001')).resolves.toEqual(detail)
+    expect(http.get).toHaveBeenNthCalledWith(1, '/platform/v1/warehouse-admin', {
+      params: { tenantId: 10001, page: 1, size: 200 },
+    })
+    expect(http.get).toHaveBeenNthCalledWith(2, '/platform/v1/warehouse-admin/19001', {
+      params: { tenantId: 10001 },
+    })
+  })
+
+  it('uses the implemented create, update, and status routes', async () => {
+    vi.mocked(http.post).mockResolvedValue({ code: '0', message: 'success', data: '19001' })
+    vi.mocked(http.put).mockResolvedValue({ code: '0', message: 'success', data: null })
+    vi.mocked(http.patch).mockResolvedValue({ code: '0', message: 'success', data: null })
+
+    await expect(createPlatformWarehouse(payload)).resolves.toBe('19001')
+    await expect(updatePlatformWarehouse(10001, '19001', payload)).resolves.toBeNull()
+    await expect(changePlatformWarehouseStatus(10001, '19001', 'INACTIVE')).resolves.toBeNull()
+
+    expect(http.post).toHaveBeenCalledWith('/platform/v1/warehouse-admin', payload)
+    expect(http.put).toHaveBeenCalledWith('/platform/v1/warehouse-admin/19001', payload, {
+      params: { tenantId: 10001 },
+    })
+    expect(http.patch).toHaveBeenCalledWith('/platform/v1/warehouse-admin/19001/status', undefined, {
+      params: { tenantId: 10001, status: 'INACTIVE' },
+    })
+  })
+})

src/api/platformWarehouses.ts

@@ -0,0 +1,138 @@
+import { http, unwrapApiResponse, type ApiEnvelope } from '@/api/http'
+
+export type PlatformWarehouseStatus = 'ACTIVE' | 'INACTIVE'
+
+export interface PlatformWarehouseResource {
+  id: number | string
+  tenantId: number | string
+  warehouseCode: string
+  warehouseName: string
+  warehouseType: string
+  countryCode: string
+  timezone: string
+  contactName: string | null
+  contactPhone: string | null
+  contactEmail: string | null
+  status: PlatformWarehouseStatus
+  remark: string | null
+  createdAt?: string | null
+  updatedAt?: string | null
+}
+
+export interface PlatformWarehouseAddressResource {
+  id: number | string
+  tenantId: number | string
+  warehouseId: number | string
+  addressType: string
+  countryCode: string
+  stateProvince: string | null
+  city: string
+  district: string | null
+  postalCode: string | null
+  addressLine1: string
+  addressLine2: string | null
+  latitude: number | string | null
+  longitude: number | string | null
+}
+
+export interface PlatformWarehouseCapabilityResource {
+  id: number | string
+  tenantId: number | string
+  warehouseId: number | string
+  capabilityCode: string
+  capabilityName: string
+  enabled: boolean | null
+  cutoffTime: string | null
+  description: string | null
+}
+
+export interface PlatformWarehouseDetailResource {
+  warehouse: PlatformWarehouseResource
+  addresses: PlatformWarehouseAddressResource[]
+  capabilities: PlatformWarehouseCapabilityResource[]
+}
+
+export interface PlatformWarehousePage {
+  records: PlatformWarehouseResource[]
+  page: number
+  size: number
+  total: number
+  pages: number
+}
+
+export interface PlatformWarehouseAddressRequest {
+  addressType: string
+  countryCode: string
+  stateProvince: string | null
+  city: string
+  district: string | null
+  postalCode: string | null
+  addressLine1: string
+  addressLine2: string | null
+  latitude: number | string | null
+  longitude: number | string | null
+}
+
+export interface PlatformWarehouseCapabilityRequest {
+  capabilityCode: string
+  capabilityName: string
+  enabled: boolean
+  cutoffTime: string | null
+  description: string | null
+}
+
+export interface SavePlatformWarehouseRequest {
+  tenantId: number
+  warehouseCode: string
+  warehouseName: string
+  warehouseType: string
+  countryCode: string
+  timezone: string
+  contactName: string | null
+  contactPhone: string | null
+  contactEmail: string | null
+  status: PlatformWarehouseStatus
+  remark: string | null
+  address: PlatformWarehouseAddressRequest
+  capabilities: PlatformWarehouseCapabilityRequest[]
+}
+
+const basePath = '/platform/v1/warehouse-admin'
+
+export async function listPlatformWarehouses(tenantId: number, page = 1, size = 200) {
+  const response = await http.get<ApiEnvelope<PlatformWarehousePage>, ApiEnvelope<PlatformWarehousePage>>(basePath, {
+    params: { tenantId, page, size },
+  })
+  return unwrapApiResponse(response)
+}
+
+export async function getPlatformWarehouse(tenantId: number, warehouseId: number | string) {
+  const response = await http.get<ApiEnvelope<PlatformWarehouseDetailResource>, ApiEnvelope<PlatformWarehouseDetailResource>>(
+    `${basePath}/${warehouseId}`,
+    { params: { tenantId } },
+  )
+  return unwrapApiResponse(response)
+}
+
+export async function createPlatformWarehouse(payload: SavePlatformWarehouseRequest) {
+  const response = await http.post<ApiEnvelope<number | string>, ApiEnvelope<number | string>>(basePath, payload)
+  return unwrapApiResponse(response)
+}
+
+export async function updatePlatformWarehouse(tenantId: number, warehouseId: number | string, payload: SavePlatformWarehouseRequest) {
+  const response = await http.put<ApiEnvelope<null>, ApiEnvelope<null>>(`${basePath}/${warehouseId}`, payload, {
+    params: { tenantId },
+  })
+  return unwrapApiResponse(response)
+}
+
+export async function changePlatformWarehouseStatus(
+  tenantId: number,
+  warehouseId: number | string,
+  status: PlatformWarehouseStatus,
+) {
+  const response = await http.patch<ApiEnvelope<null>, ApiEnvelope<null>>(`${basePath}/${warehouseId}/status`, undefined, {
+    params: { tenantId, status },
+  })
+  return unwrapApiResponse(response)
+}