WEB/src/api/setting.warehouse/settingwarehouse.ts
yin 1a51150d2c feat(b2b): 新增 B2B 备货/提货作业流程,补全乡镇地址选择与列表排序
- 新增 B2B 作业接口:startB2bPrep / cancelB2bPrep / finishB2bPrep / pickupB2b /
  setB2bUrgent / cancelB2bUrgent;待处理与配送 B2B 页签新增「开始备货、备货完成、
  取消备货、确认提货、加急/取消加急」按钮
- 新增 B2bPrepFinishForm(必填备货备注 + 总箱数校验,完成后同步扣减库存)与
  use-b2b-actions 组合式:单行操作校验、确认弹窗、统一 loading 与成功后刷新
- 配送 B2B 页面复用配送页组件,增加 B2B 专用列与 ScanBox 字段,使用独立 cache-key
- 新增 utils/chinaStreet:按 area_code 提供乡镇/街道选项,pcas 四級数据懒加载并
  按区缓存;vite 将 pcas 单独拆为 vendor-china-division-street 块,避免与
  省市区数据合成大 chunk
- 新建订单预览行的「镇」改为街道下拉(支持输入新建),行政区数据按需加载;
  预览新增「只看异常 N 行」过滤
- 快递接口配置的市/区下拉增加缓存,避免预览表逐格重复遍历
- 退货签收登记列表支持排序白名单(id/scan_date/created_at/updated_at/waybill_code),
  重复登记提示补充加急与货主备注;货主签约页新增「发起签约」弹窗与筛选,
  店铺接口配置新增「对方主体ID」筛选项
- 移除 storeWarehouse 中未使用的 storeList / queryPrintQuantityLogs 接口
2026-11-18 18:05:41 +08:00

713 lines
31 KiB
TypeScript
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import request from '@/utils/request'
const v = '1.0'
/** HH:mm(24 小时制、两位补零) */
const HH_MM_PATTERN = /^([01]\d|2[0-3]):[0-5]\d$/
/**
* 自动出库单条规则(subject_config.auto_outbound_rules 的数组项)。
* 规则内所有条件为「与」关系;多条规则之间为「或」关系(任一命中即自动出库)。
* 固定前置条件(不可配置):已复核 recheck_status=fin + 已分配储位 storage_status=fin。
*/
export type SettingWarehouseAutoOutboundRule = {
/** 是否要求已打包(pack_status=fin),默认 true */
require_pack?: boolean
/** 是否要求已称重(wms_order_express.weighing_weight>0),默认 true */
require_weigh?: boolean
/** 是否要求已同步(sync_status=fin),默认 true */
require_sync?: boolean
/**
* 是否不出库当天复核订单(flag),默认 true;开启后按订单复核时间所在日计算:复核时间在「允许当天出库最后时间」之后的订单,
* 需等到该复核日的「放行时间」才自动出库;复核时间早于该最后时间、或为空的订单不受影响
*/
exclude_same_day_outbound?: boolean
/**
* 允许当天出库最后时间(HH:mm,默认 06:00,**当天内 00:00~23:59**,不支持 24:00);
* 复核时间早于该时间的订单不受「不出库当天订单」影响,**不能大于放行时间**;
* 想表达「当天复核的订单全天不出库」时设为 00:00(配合放行时间 23:59 = 过了零点后全部出库)
*/
same_day_outbound_deadline_time?: string
/**
* 放行时间(HH:mm,默认 22:00,**支持跨天 00:00~47:59**:24:00 之后的数字表示次日,如 27:00 = 次日 03:00);
* 到达该时刻后,该复核日被限制的订单放行。常用:23:59 = 当天不放、过了零点出库;27:00 = 到次日 03:00 才出库
*/
same_day_outbound_release_time?: string
}
/**
* 自动出库规则(subject_config.auto_outbound_rules):**数组**,空数组表示不自动出库任何订单。
* 每项规则独立判断,订单满足任意一条规则即自动出库;规则内条件为「与」关系。
* 固定前置条件(不可配置):已复核 recheck_status=fin + 已分配储位 storage_status=fin。
* ⚠️ 旧版本的对象结构(含 enabled/require_recheck/require_print/require_pick)已废弃不再兼容,**保存为非数组时后端返回 400**
*/
export type SettingWarehouseAutoOutboundRules = SettingWarehouseAutoOutboundRule[]
/** 规则中的布尔(flag)子项 */
export const AUTO_OUTBOUND_RULE_FLAG_KEYS = [
'require_pack',
'require_weigh',
'require_sync',
'exclude_same_day_outbound'
] as const
/** 规则中的 HH:mm 时间子项(缺省/空值回退默认,非空值原样保留交由后端校验) */
export const AUTO_OUTBOUND_RULE_TIME_KEYS = [
'same_day_outbound_deadline_time',
'same_day_outbound_release_time'
] as const
/** 新建规则时的默认值(与后端 normalizeAutoOutboundRule 口径一致) */
export const DEFAULT_AUTO_OUTBOUND_RULE: Required<SettingWarehouseAutoOutboundRule> = {
require_pack: true,
require_weigh: true,
require_sync: true,
exclude_same_day_outbound: true,
same_day_outbound_deadline_time: '06:00',
same_day_outbound_release_time: '22:00'
}
/** 收货未入库提醒配置(subject_config.receiving_pending_inbound_notice) */
export type SettingWarehouseReceivingPendingInboundNotice = {
/** 是否通知收货未入库(flag:0=关闭,1=开启;默认 0 关闭,非 0/1 等非法值报 400)。开启后定时任务才会在提醒时间执行 */
enabled?: boolean
/** 提醒时间,格式 HH:mm,默认 08:30,范围 00:00-23:59(含 10 分钟宽限,每天提醒一次);⚠️ 非法值报 400 */
notice_time?: string
/** 超时下限(小时):创建时间距今超过该值才提醒,默认 24,须为大于 0 的整数;⚠️ 非法值报 400 */
min_hours?: number
/** 超时上限(小时):距今小于该值才提醒(超过则不再提醒),默认 48,须为大于 min_hours 的整数;⚠️ 非法值报 400 */
max_hours?: number
/**
* 通知短语(消息第一行,仓库/客服群)。支持变量:{warehouse} 仓库名 / {warehouse_id} 仓库ID /
* {store} 货主名(未绑定为「未绑定货主」)/ {store_id} 货主ID / {count} 本批单数 /
* {min_hours} 超时下限 / {max_hours} 超时上限 / {date} 提醒日期(YYYY-MM-DD)/ {numbers} 本批收货单号;
* 未识别的占位符原样保留;短语后换行逐行列出明细(一行一条,最多 20 行),留空使用默认短语;最长 500 字符,超长报 400
*/
notice_template?: string
/** 通知短语(消息第一行,货主群)。变量同 notice_template,留空使用默认短语;最长 500 字符,超长报 400 */
store_notice_template?: string
}
/** 文档默认:receiving_pending_inbound_notice 各子项默认值 */
export const DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE: Required<SettingWarehouseReceivingPendingInboundNotice> = {
enabled: false,
notice_time: '08:30',
min_hours: 24,
max_hours: 48,
notice_template: '',
store_notice_template: ''
}
/** receiving_pending_inbound_notice 中的纯文本字段 */
export const RECEIVING_PENDING_INBOUND_NOTICE_TEXT_KEYS = [
'notice_template',
'store_notice_template'
] as const
/** 站内信推送失败自动重发配置(subject_config.inbox_push_retry) */
export type SettingWarehouseInboxPushRetry = {
/** 是否开启站内信推送失败自动重发(flag:0=关闭,1=开启;默认 0=关闭,需显式开启) */
enabled?: number
/** 重发时间范围(分钟,1-1440,默认 30):仅自动重发「失败时间在该范围内」的消息;仅在 enabled 开启时生效 */
window_minutes?: number
}
/** 文档默认:inbox_push_retry 各子项默认值 */
export const DEFAULT_INBOX_PUSH_RETRY: Required<SettingWarehouseInboxPushRetry> = {
enabled: 0,
window_minutes: 30
}
/** 仓库默认发件人/地址(subject_config 内,文档默认空字符串) */
export type SettingWarehouseSenderConfig = {
sender_name?: string
sender_tel?: string
province_name?: string
city_name?: string
district_name?: string
town_name?: string
address?: string
receiver_address?: string
}
export const WAREHOUSE_SENDER_FIELD_KEYS = [
'sender_name',
'sender_tel',
'province_name',
'city_name',
'district_name',
'town_name',
'address',
'receiver_address'
] as const
export const DEFAULT_WAREHOUSE_SENDER_FIELDS: Required<SettingWarehouseSenderConfig> = {
sender_name: '',
sender_tel: '',
province_name: '',
city_name: '',
district_name: '',
town_name: '',
address: '',
receiver_address: ''
}
/** 与 module setting.warehouse 文档 subject_config 对齐 */
export type SettingWarehouseSubjectConfig = SettingWarehouseSenderConfig & {
enable_external_express_code?: boolean
/** 是否启用自动出库(flag),默认 false(关闭);开启后按 auto_outbound_rules 扫描订单并自动标记出库 */
auto_outbound_enabled?: boolean
/** 自动出库规则数组,空数组表示不自动出库;满足任一规则即自动出库 */
auto_outbound_rules?: SettingWarehouseAutoOutboundRules
/** 散单打包最大时长,单位:分钟,默认 3 */
single_order_pack_max_minutes?: number
/** 团购打包最大时长,单位:分钟,默认 40 */
group_order_pack_max_minutes?: number
/**
* 大团购波次(wave_scope=1)打包中,扫描其他波次订单至少需等待「当前波次打包数 × 系数」秒,
* 单位:秒/单,默认 3,**必须大于 0**(用于 workbench 大团购波次打包时长闸门与倒计时);
* 非法值报 400:`subject_config.big_group_pack_coefficient 必须是大于 0 的数字`
*/
big_group_pack_coefficient?: number
/**
* 散单称重是否需要打包(flag,默认 false 关闭):开启后散单称重(订单波次范围 wave_scope 非 1 大团购/3 小团购)
* 须处于**打包中或已打包**(pack_status=padding/fin),未打包或打包异常时拒绝称重并返回错误。
* 仅接受布尔/like-flag(true/1/'1'/'true' → true;false/0/'0'/'false' → false),非法值报 400
*/
single_weigh_require_pack?: boolean
/** 拆包最大录制时长,单位:分钟,默认 5,min 1;超过上限时拆包提交的结束时间自动截断为开始时间+上限 */
return_unpack_max_record_minutes?: number
max_wave_quantity?: number
min_group_order_fetch_quantity?: number
max_notice_webhook_count?: number
default_express_code?: string
default_platform_code?: string
group_wave_prefix?: string
/** 自动分配快递排除备注:订单备注命中任一关键字时,跳过自动分配快递 */
auto_allocate_express_exclude_remarks?: string[]
/** 默认库位(库位ID,未配置时为 null;传入需属于当前仓库且未删除、已启用,否则报 400,传 null 清空) */
default_location_id?: number | null
/** 启用截单(flag:0=关闭,1=开启;默认 1)。启用后订单创建时间早于开始自动分配时间或超过截单时间(开始时间晚于截单时间时截单时间视为次日),不再自动分配快递和储位、不再自动加团 */
cutoff_order_enabled?: number
/** 开始自动分配时间,格式 HH:mm,默认 08:00,范围 00:00-23:59;早于该时间的订单与超过截单时间行为一致(不自动分配快递和储位、不自动加团);⚠️ 与截单时间相同(自动分配窗口为空)时报 400 */
allocate_start_time?: string
/** 截单时间,格式 HH:mm,默认 18:00,范围 00:00-23:59;作为最后允许自动分配的时间,开始时间晚于截单时间时截单时间视为次日(跨天窗口) */
cutoff_order_time?: string
/**
* 收货未入库提醒配置(默认关闭)。开启后每天按 notice_time 扫描「创建时间超过 min_hours 且不足 max_hours
* 仍未完成入库」的收货单:绑定货主的通知货主收货群(未配群回退仓库客服群),未绑定货主的通知仓库客服群
*/
receiving_pending_inbound_notice?: SettingWarehouseReceivingPendingInboundNotice
/**
* 自然日开始时间(业务日分界点),格式 HH:mm,默认 06:00,范围 00:00-23:59。
* 今日统计窗口为 [该时间点, 次日该时间点):当前时间早于今日该时间点时窗口从昨日该时间点开始
* (昨日该时间点后的订单视为今日);仓库面板趋势 trend 亦按此时间点分桶
*/
day_start_time?: string
/**
* 站内信推送失败自动重发配置(默认关闭)。开启后站内信回信/系统通知推送失败
* (如桥接离线返回 wx offline / qiwe offline)由定时任务每 3 分钟自动重发一次
*/
inbox_push_retry?: SettingWarehouseInboxPushRetry
[key: string]: unknown
}
export type SettingWarehouseSettingsPayload = {
warehouse_id: number
subject_config: SettingWarehouseSubjectConfig
}
export type SettingWarehouseSaveSettingsParams = {
subject_config: SettingWarehouseSubjectConfig
cache_warehouse_id?: number
cacheWarehouseId?: number
}
export type SettingWarehouseSaveSettingsPayload = SettingWarehouseSettingsPayload & {
cache_cleared_warehouse_id: number | null
}
function clonePlainObject<T extends Record<string, unknown>>(src: T): T {
return JSON.parse(JSON.stringify(src)) as T
}
/**
* 字段元信息 schema(只取归一化需要的部分)。来源二选一:
* - getFieldMeta 的 `list` / `item_keys`(原始 meta,读 `type` / `default` / `item_keys`);
* - 页面归一化后的表单字段(读 `type` / `defaultValue` / `itemFields`)。
* `type` 兼容 meta 原始值(flag / integer / string_array…)与页面归一化值(boolean / number…)。
*/
export type WarehouseSubjectFieldSchema = {
key: string
type?: string
/** meta 原始默认值 */
default?: unknown
/** 页面归一化后的默认值(优先) */
defaultValue?: unknown
/** 页面归一化后的子项 */
itemFields?: WarehouseSubjectFieldSchema[]
/** meta 原始子项 */
item_keys?: WarehouseSubjectFieldSchema[]
}
/** 取子项 schema(兼容 itemFields / item_keys 两种来源) */
function schemaChildren(field: WarehouseSubjectFieldSchema): WarehouseSubjectFieldSchema[] {
const children = field.itemFields ?? field.item_keys
return Array.isArray(children) ? children : []
}
function schemaFlagValue(value: unknown, fallback: unknown): boolean {
// 文档口径(like-flag):true/1/'1'/'true' → true;false/0/'0'/'false' → false
if (value === true || value === 1 || value === '1' || value === 'true') return true
if (value === false || value === 0 || value === '0' || value === 'false') return false
return fallback === true || fallback === 1 || fallback === '1' || fallback === 'true'
}
const SCHEMA_FLAG_TYPES = new Set(['flag', 'boolean', 'bool', 'switch'])
const SCHEMA_NUMBER_TYPES = new Set(['number', 'integer', 'int', 'float', 'decimal'])
/** 嵌套 object(如售后跟进时间)里代表「该类型默认值」的子键 */
const SCHEMA_DEFAULT_SUB_KEY = '_default'
/** 嵌套 object 叶子所在层级:缺省视作「未覆盖」,不注入 meta 默认值(留空 = 跟随服务端默认) */
const NESTED_LEAF_DEPTH = 3
function isPlainObjectValue(value: unknown): value is Record<string, unknown> {
return !!value && typeof value === 'object' && !Array.isArray(value)
}
/** 是否为「扁平标量」配置值(数字或非空字符串) */
function isScalarConfigValue(value: unknown): boolean {
if (typeof value === 'number') return Number.isFinite(value)
if (typeof value === 'string') return value.trim() !== ''
return false
}
/**
* 按字段 schema 归一化单个值;返回 undefined 表示该键不写入。
* depth 为当前字段在配置树中的层级(顶层字段 depth=1),用于区分「一级 object」与「嵌套 object」。
*/
function normalizeSchemaValue(
value: unknown,
field: WarehouseSubjectFieldSchema,
present: boolean,
depth = 1
): unknown {
const type = String(field.type ?? '').toLowerCase()
const fallback = field.defaultValue !== undefined ? field.defaultValue : field.default
const children = schemaChildren(field)
// flag / boolean:兼容 true|false、1|0、'1'|'0',非法或缺省回退默认
if (SCHEMA_FLAG_TYPES.has(type)) {
if (!present && (fallback === undefined || depth >= NESTED_LEAF_DEPTH)) return undefined
return schemaFlagValue(present ? value : fallback, fallback)
}
// number / integer:非法或缺省回退默认(无默认则不写入)
if (SCHEMA_NUMBER_TYPES.has(type)) {
// 嵌套 object 的叶子(如售后跟进时间的各子类型)缺省时视为「未覆盖」:不写入、不注入默认值
if (!present && depth >= NESTED_LEAF_DEPTH) return undefined
const num = Number(present ? value : fallback)
if (Number.isFinite(num)) return num
return fallback === undefined ? undefined : fallback
}
// object:只保留 schema(meta item_keys)里声明的子项,逐项递归
if (type === 'object') {
if (!children.length) return present ? value : fallback
// 后端可能用「扁平标量」表示该类型下所有子类型同值(等价于只设置 _default),
// 例如 after_sale_followup_hours.order = "24";必须优先识别,否则会被内层默认值覆盖。
if (present && isScalarConfigValue(value)) {
const defaultChild = children.find((child) => child.key === SCHEMA_DEFAULT_SUB_KEY)
if (!defaultChild) return value
const normalized = normalizeSchemaValue(value, defaultChild, true, depth + 1)
return normalized === undefined ? value : { [SCHEMA_DEFAULT_SUB_KEY]: normalized }
}
const source = isPlainObjectValue(value) ? value : isPlainObjectValue(fallback) ? fallback : null
// 嵌套 object(depth>=2)没有任何实际值时视为「未覆盖」:既不写入,也不注入内层默认值,
// 交给服务端按 meta 默认处理(页面据此显示为留空)。
if (!source) return depth >= 2 ? undefined : normalizeSchemaObject({}, children, depth + 1)
const normalized = normalizeSchemaObject(source, children, depth + 1)
// 嵌套 object 归一化后为空(子项均未覆盖)→ 不写入该键
if (depth >= 2 && Object.keys(normalized).length === 0) return undefined
return normalized
}
// array:逐项按子项 schema 归一化
if (type === 'array') {
const list = Array.isArray(value) ? value : Array.isArray(fallback) ? fallback : []
if (!children.length) return list
return list.map((item) =>
isPlainObjectValue(item) ? normalizeSchemaObject(item, children, depth + 1) : item
)
}
// string_array:字符串数组(去空去重)
if (type === 'string_array') {
const list = Array.isArray(value) ? value : Array.isArray(fallback) ? fallback : []
return list
.filter((v): v is string => typeof v === 'string' && v.trim() !== '')
.map((v) => v.trim())
}
// string / color / select / location:有值原样保留,缺省用默认
if (!present) return depth >= NESTED_LEAF_DEPTH ? undefined : fallback
return value
}
/** 按子项 schema 递归归一化对象(只保留 schema 中声明的子项);depth 为子项所在层级 */
function normalizeSchemaObject(
source: Record<string, unknown>,
children: WarehouseSubjectFieldSchema[],
depth = 1
): Record<string, unknown> {
const out: Record<string, unknown> = {}
for (const child of children) {
if (!child?.key) continue
const normalized = normalizeSchemaValue(source[child.key], child, child.key in source, depth)
if (normalized !== undefined) out[child.key] = normalized
}
return out
}
/**
* 按 schema 归一化顶层 object / array 字段的子项(子项集合以 meta item_keys 为准,避免前端硬编码漂移)。
* 顶层其它类型仍走各自既有归一化,不改动 flag 的 0/1 语义。
*/
function applySchemaToSubjectConfig(
config: Record<string, unknown>,
schema?: WarehouseSubjectFieldSchema[]
): void {
if (!Array.isArray(schema) || schema.length === 0) return
for (const field of schema) {
if (!field?.key) continue
const type = String(field.type ?? '').toLowerCase()
if (type !== 'object' && type !== 'array') continue
if (!schemaChildren(field).length) continue
const normalized = normalizeSchemaValue(config[field.key], field, field.key in config)
if (normalized !== undefined) config[field.key] = normalized
}
}
/** 归一化 getSettings / saveSettings 返回的 subject_config(补全文档默认项;传入 schema 时按 meta 归一化子项) */
export function normalizeWarehouseSubjectConfig(
raw: unknown,
schema?: WarehouseSubjectFieldSchema[]
): SettingWarehouseSubjectConfig {
const base =
raw && typeof raw === 'object' && !Array.isArray(raw)
? clonePlainObject(raw as Record<string, unknown>)
: ({} as Record<string, unknown>)
if (typeof base.enable_external_express_code !== 'boolean') {
base.enable_external_express_code = false
}
// 自动出库:auto_outbound_enabled(flag,顶层开关)+ auto_outbound_rules(规则数组)
// 不要再在这里按旧「对象结构」(enabled/require_recheck/require_print/require_pick)补齐子项——
// 那会把数组改写成对象,随后 applySchemaToSubjectConfig 按 meta 的 array 类型又回退成 [],
// 导致用户在页面上配置的规则保存时被静默清空。子项集合一律以 getFieldMeta 的 item_keys 为准。
for (const key of WAREHOUSE_SENDER_FIELD_KEYS) {
if (typeof base[key] !== 'string') {
base[key] = DEFAULT_WAREHOUSE_SENDER_FIELDS[key]
}
}
// 规范化 auto_allocate_express_exclude_remarks(string_array 类型)
const remarksRaw = base.auto_allocate_express_exclude_remarks
if (remarksRaw === null || remarksRaw === undefined || remarksRaw === '') {
base.auto_allocate_express_exclude_remarks = []
} else if (!Array.isArray(remarksRaw)) {
throw new Error('auto_allocate_express_exclude_remarks 必须是字符串数组')
} else {
base.auto_allocate_express_exclude_remarks = (remarksRaw as unknown[])
.filter((v): v is string => typeof v === 'string' && v.trim() !== '')
.map((v) => v.trim())
}
// 打包最大时长(分钟,须为大于 0 的整数;默认 散单 3 / 团购 40)
const singlePackMax = Number(base.single_order_pack_max_minutes)
base.single_order_pack_max_minutes =
Number.isFinite(singlePackMax) && singlePackMax > 0 ? Math.trunc(singlePackMax) : 3
const groupPackMax = Number(base.group_order_pack_max_minutes)
base.group_order_pack_max_minutes =
Number.isFinite(groupPackMax) && groupPackMax > 0 ? Math.trunc(groupPackMax) : 40
// 大团购打包系数(秒/单,默认 3,必须大于 0;允许小数,保留原值)
const bigGroupPackCoefficient = Number(base.big_group_pack_coefficient)
base.big_group_pack_coefficient =
Number.isFinite(bigGroupPackCoefficient) && bigGroupPackCoefficient > 0
? bigGroupPackCoefficient
: 3
// 散单称重是否需要打包(flag,默认 false 关闭;文档口径 like-flag:true/1/'1'/'true' → 开启)
const weighRequirePack = base.single_weigh_require_pack
base.single_weigh_require_pack =
weighRequirePack === true ||
weighRequirePack === 1 ||
weighRequirePack === '1' ||
weighRequirePack === 'true'
// 默认库位(库位ID,未配置时为 null)
const locIdRaw = base.default_location_id
if (locIdRaw === undefined || locIdRaw === null || locIdRaw === '') {
base.default_location_id = null
} else {
const locId = Number(locIdRaw)
base.default_location_id = Number.isFinite(locId) ? Math.trunc(locId) : null
}
// 启用截单(flag:0=关闭,1=开启;默认 1;兼容 boolean / 数字 / 字符串输入)
const cutoffRaw = base.cutoff_order_enabled
if (cutoffRaw === true || cutoffRaw === 1 || cutoffRaw === '1') {
base.cutoff_order_enabled = 1
} else if (cutoffRaw === false || cutoffRaw === 0 || cutoffRaw === '0') {
base.cutoff_order_enabled = 0
} else {
base.cutoff_order_enabled = 1
}
// 开始自动分配时间 / 截单时间(HH:mm,非法回退默认 08:00 / 18:00)
const allocTime = String(base.allocate_start_time ?? '')
base.allocate_start_time = HH_MM_PATTERN.test(allocTime) ? allocTime : '08:00'
const cutoffTime = String(base.cutoff_order_time ?? '')
base.cutoff_order_time = HH_MM_PATTERN.test(cutoffTime) ? cutoffTime : '18:00'
// 自然日开始时间(HH:mm,默认 06:00)。⚠️ saveSettings 文档未单列该入参,
// 故仅在已带合法字符串(getSettings 响应 / 表单)时归一化,避免凭空虚增字段
const dayStartRaw = base.day_start_time
if (typeof dayStartRaw === 'string' && dayStartRaw !== '') {
base.day_start_time = HH_MM_PATTERN.test(dayStartRaw) ? dayStartRaw : '06:00'
}
// 收货未入库提醒(enabled flag 兼容 boolean / 数字 / 字符串;notice_time 非法回退 08:30;
// min_hours 默认 24;max_hours 默认 48 且必须大于 min_hours)
const noticeRaw = base.receiving_pending_inbound_notice
const notice =
noticeRaw && typeof noticeRaw === 'object' && !Array.isArray(noticeRaw)
? { ...(noticeRaw as Record<string, unknown>) }
: ({} as Record<string, unknown>)
const noticeEnabled = notice.enabled
notice.enabled =
noticeEnabled === true || noticeEnabled === 1 || noticeEnabled === '1'
const noticeTime = String(notice.notice_time ?? '')
notice.notice_time = HH_MM_PATTERN.test(noticeTime)
? noticeTime
: DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE.notice_time
const minHours = Number(notice.min_hours)
notice.min_hours =
Number.isFinite(minHours) && minHours > 0
? Math.trunc(minHours)
: DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE.min_hours
const maxHours = Number(notice.max_hours)
notice.max_hours =
Number.isFinite(maxHours) && maxHours > (notice.min_hours as number)
? Math.trunc(maxHours)
: Math.max(
DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE.max_hours,
(notice.min_hours as number) + 1
)
for (const key of RECEIVING_PENDING_INBOUND_NOTICE_TEXT_KEYS) {
if (typeof notice[key] !== 'string') notice[key] = ''
}
base.receiving_pending_inbound_notice =
notice as SettingWarehouseReceivingPendingInboundNotice
// 站内信推送失败自动重发(enabled flag 0/1,默认 0;window_minutes 1-1440,默认 30)
const retryRaw = base.inbox_push_retry
const retry =
retryRaw && typeof retryRaw === 'object' && !Array.isArray(retryRaw)
? { ...(retryRaw as Record<string, unknown>) }
: ({} as Record<string, unknown>)
const retryEnabled = retry.enabled
retry.enabled =
retryEnabled === 1 || retryEnabled === '1' || retryEnabled === true ? 1 : 0
const retryWindow = Number(retry.window_minutes)
retry.window_minutes =
Number.isFinite(retryWindow) && retryWindow >= 1 && retryWindow <= 1440
? Math.trunc(retryWindow)
: DEFAULT_INBOX_PUSH_RETRY.window_minutes
base.inbox_push_retry = retry as SettingWarehouseInboxPushRetry
// 子项集合以 getFieldMeta 的 item_keys 为准(不再由前端硬编码子项 key):
// 后端给 object / array 字段改名或加子项时,只要页面把 meta 字段(含 itemFields)传进来,
// 读取与保存都会自动跟随,不会再出现「拉取的和提交的对不上」。
applySchemaToSubjectConfig(base, schema)
// 跨字段约束:max_hours 必须大于 min_hours(schema 无法表达,放 schema 之后兜底)
const finalNotice = base.receiving_pending_inbound_notice
if (finalNotice && typeof finalNotice === 'object' && !Array.isArray(finalNotice)) {
const finalObj = finalNotice as Record<string, unknown>
const minH = Number(finalObj.min_hours)
const maxH = Number(finalObj.max_hours)
const safeMin = Number.isFinite(minH) ? minH : 0
if (!Number.isFinite(maxH) || maxH <= safeMin) {
finalObj.max_hours = Math.max(
DEFAULT_RECEIVING_PENDING_INBOUND_NOTICE.max_hours,
safeMin + 1
)
}
}
return base as SettingWarehouseSubjectConfig
}
export function normalizeGetSettingsPayload(
raw: Record<string, unknown> | null | undefined,
schema?: WarehouseSubjectFieldSchema[]
): SettingWarehouseSettingsPayload {
const payload = raw && typeof raw === 'object' ? raw : {}
const warehouseId = Number(payload.warehouse_id)
return {
warehouse_id: Number.isFinite(warehouseId) ? warehouseId : 0,
subject_config: normalizeWarehouseSubjectConfig(payload.subject_config, schema)
}
}
/** 构造 saveSettings 请求体(仅 subject_config + 可选 cache 仓库 ID) */
export function buildSaveSettingsRequest(options: {
subject_config: SettingWarehouseSubjectConfig | Record<string, unknown>
cache_warehouse_id?: number | null
/** 字段元信息(页面归一化后的表单字段即可):用于按 item_keys 归一化 object / array 子项 */
schema?: WarehouseSubjectFieldSchema[]
}): SettingWarehouseSaveSettingsParams {
const body: SettingWarehouseSaveSettingsParams = {
subject_config: normalizeWarehouseSubjectConfig(options.subject_config, options.schema)
}
const cacheId = options.cache_warehouse_id
if (cacheId != null && Number.isFinite(cacheId) && cacheId > 0) {
body.cache_warehouse_id = Math.trunc(cacheId)
}
return body
}
export function normalizeSaveSettingsPayload(
raw: Record<string, unknown> | null | undefined,
schema?: WarehouseSubjectFieldSchema[]
): SettingWarehouseSaveSettingsPayload {
const base = normalizeGetSettingsPayload(raw, schema)
const cleared = raw?.cache_cleared_warehouse_id
const cacheCleared =
cleared === null || cleared === undefined
? null
: Number.isFinite(Number(cleared))
? Number(cleared)
: null
return {
...base,
cache_cleared_warehouse_id: cacheCleared
}
}
export function unwrapSettingWarehousePayload(
res: Record<string, unknown> | null | undefined
): Record<string, unknown> {
const payload = res?.data
if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
return payload as Record<string, unknown>
}
return (res ?? {}) as Record<string, unknown>
}
export function settingWarehouseGetSettings(
data: Record<string, unknown> = {}
): Promise<{ code?: number; message?: string; data?: SettingWarehouseSettingsPayload } & Record<string, unknown>> {
return request({
url: '/system',
method: 'post',
params: {
method: 'setting.warehouse.getSettings',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export function settingWarehouseGetFieldMeta(): Promise<any> {
return request({
url: '/system',
method: 'post',
params: {
method: 'setting.warehouse.getFieldMeta',
v,
timestamp: new Date().getTime()
},
data: {},
isSystemApi: true
} as any)
}
export function settingWarehouseSaveSettings(
data: SettingWarehouseSaveSettingsParams
): Promise<{ code?: number; message?: string; data?: SettingWarehouseSaveSettingsPayload } & Record<string, unknown>> {
return request({
url: '/system',
method: 'post',
params: {
method: 'setting.warehouse.saveSettings',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
/** 当前仓库已授权的微信小程序信息(setting.warehouse.getweChatApp 响应;字段名以后端为准,前端做多形态兼容) */
export type SettingWarehouseWeChatApp = {
warehouse_id?: number
/** 小程序 AppID */
app_id?: string
/** 小程序 AppSecret */
app_secret?: string
/** 小程序名称 */
nick_name?: string
/** 小程序原始ID(gh_ 开头) */
original_id?: string
/** 第三方平台授权码 */
authorization_code?: string
/** 授权时间 */
authorized_at?: string | null
updated_at?: string | null
[key: string]: unknown
}
/**
* 查询当前仓库已授权的微信小程序信息(微信小程序配置页使用)。
* 未授权时返回空配置(无小程序相关字段),前端据此提示「需要授权」并展示「去授权」入口。
*/
export function settingWarehouseGetWeChatApp(
data: Record<string, unknown> = {}
): Promise<
{ code?: number; message?: string; data?: SettingWarehouseWeChatApp } & Record<string, unknown>
> {
return request({
url: '/system',
method: 'post',
params: {
method: 'setting.warehouse.getweChatApp',
v,
timestamp: new Date().getTime()
},
data,
isSystemApi: true
} as any)
}
export const settingWarehouse = {
getSettings: settingWarehouseGetSettings,
getFieldMeta: settingWarehouseGetFieldMeta,
saveSettings: settingWarehouseSaveSettings,
getWeChatApp: settingWarehouseGetWeChatApp
}