Hooke / manulife-weapp

Go to a project
Toggle navigation Toggle navigation pinning
hookehuyr
a76451dc 1 parent 448c3df4

refactor: 移除离线预约功能并添加授权模式开关 

移除与离线预约相关的所有代码，包括缓存管理、轮询逻辑和弱网络提示模块
添加 ENABLE_AUTH_MODE 配置开关以控制授权功能的启用状态
简化网络超时处理逻辑，将弱网络弹窗改为 toast 提示
清理不再使用的示例页面和类型定义文件
Inline Side-by-side
Showing 11 changed files with 59 additions and 1083 deletions
/* eslint-disable */
/* prettier-ignore */
// @ts-nocheck
// Generated by unplugin-vue-components
// Read more: https://github.com/vuejs/core/pull/3399
export {}
declare module 'vue' {
export interface GlobalComponents {
IndexNav: typeof import('./src/components/indexNav.vue')['default']
Picker: typeof import('./src/components/time-picker-data/picker.vue')['default']
PosterBuilder: typeof import('./src/components/PosterBuilder/index.vue')['default']
QrCode: typeof import('./src/components/qrCode.vue')['default']
QrCodeSearch: typeof import('./src/components/qrCodeSearch.vue')['default']
RouterLink: typeof import('vue-router')['RouterLink']
RouterView: typeof import('vue-router')['RouterView']
}
}
......@@ -3,9 +3,8 @@
* @Template: 在此定义您的业务 API 接口地址
*/
import { fn, fetch } from '@/api/fn';
// import { fn, fetch } from '@/api/fn';
const Api = {}
// ==================== 业务 API 接口示例 ====================
// 请根据实际业务需求修改或添加接口
......
/*
* @Date: 2025-06-28 10:33:00
* @LastEditors: hookehuyr hookehuyr@gmail.com
* @LastEditTime: 2026-01-17 12:14:16
* @FilePath: /xyxBooking-weapp/src/app.js
* @LastEditTime: 2026-01-29 18:29:57
* @FilePath: /manulife-weapp/src/app.js
* @Description: 应用入口文件
*/
import { createApp } from 'vue'
......@@ -10,16 +10,6 @@ import { createPinia } from 'pinia'
import './utils/polyfill'
import './app.less'
import { saveCurrentPagePath, hasAuth, silentAuth, navigateToAuth } from '@/utils/authRedirect'
import Taro from '@tarojs/taro'
import { refresh_offline_booking_cache, has_offline_booking_cache } from '@/composables/useOfflineBookingCache'
import { is_usable_network, get_network_type } from '@/utils/network'
import { enable_offline_booking_cache_polling } from '@/composables/useOfflineBookingCachePolling'
import { weak_network_text, get_weak_network_modal_use_cache_options } from '@/utils/uiText'
// 记录是否已展示过网络异常提示弹窗
let has_shown_network_modal = false
// 记录上一次网络是否可用，用于识别“从可用变为不可用”的场景
let last_network_usable = null
const App = createApp({
// 对应 onLaunch
......@@ -37,163 +27,8 @@ const App = createApp({
saveCurrentPagePath(full_path)
}
/**
* @description 预加载离线预约记录数据（列表+详情）
* - 仅在有授权且网络可用时调用
* - 成功后将数据存储到本地缓存（key: OFFLINE_BOOKING_DATA）
* @returns {Promise<void>} 无返回值
*/
const preloadBookingData = async () => {
try {
await refresh_offline_booking_cache()
} catch (e) {
console.error('Preload booking cache failed', e)
}
}
/**
* @description 判断是否应该跳过网络异常提示弹窗
* - 仅在当前页面为离线预约列表/详情/核销码页时返回 true
* @returns {boolean} true=跳过提示，false=不跳过
*/
const should_skip_network_prompt = () => {
const pages = Taro.getCurrentPages ? Taro.getCurrentPages() : []
const current_page = pages && pages.length ? pages[pages.length - 1] : null
const current_route = String(current_page?.route || '')
if (!current_route) return false
if (current_route.includes('pages/offlineBookingList/index')) return true
if (current_route.includes('pages/offlineBookingDetail/index')) return true
if (current_route.includes('pages/offlineBookingCode/index')) return true
return false
}
/**
* @description 处理不良网络情况
* - 仅在当前页面未跳过提示弹窗时调用
* - 若有离线预约缓存，则展示弹窗询问是否使用缓存数据
* - 否则展示简单提示 toast
* @param {string} network_type 网络类型（wifi/4g/5g/3g/none/unknown）
* @returns {Promise<boolean>} true=需要中断后续启动流程，false=继续
*/
const handle_bad_network = async (network_type) => {
if (has_shown_network_modal) return false
if (should_skip_network_prompt()) return false
const is_none_network = network_type === 'none'
const is_weak_network = !is_usable_network(network_type)
if (!is_weak_network) return false
has_shown_network_modal = true
if (has_offline_booking_cache()) {
try {
const modal_res = await Taro.showModal(get_weak_network_modal_use_cache_options())
if (modal_res?.confirm) {
await Taro.reLaunch({ url: '/pages/offlineBookingList/index' })
return true
}
} catch (e) {
return is_none_network
}
} else {
try {
await Taro.showToast({ title: weak_network_text.toast_title, icon: 'none', duration: 2000 })
} catch (e) {
return is_none_network
}
}
return is_none_network
}
/**
* 监听网络状态变化
* - 当网络连接且有授权时，预加载离线预约记录数据
*/
Taro.onNetworkStatusChange((res) => {
const is_connected = res?.isConnected !== false
const network_type = res?.networkType || 'none'
const network_usable = is_connected && is_usable_network(network_type)
if (network_usable) {
has_shown_network_modal = false
last_network_usable = true
if (hasAuth()) preloadBookingData()
return
}
const should_prompt = last_network_usable === true || last_network_usable === null
last_network_usable = false
if (should_prompt) {
handle_bad_network(network_type)
}
return
})
/**
* @description 处理启动时的不良网络情况（只在启动阶段检查一次）
* - 网络不可用且有离线缓存：询问是否进入离线模式
* - 网络不可用且无缓存：toast 提示网络不佳
* @returns {Promise<boolean>} true=进入离线模式并中断启动，false=继续启动
*/
const handle_bad_network_on_launch = async () => {
/**
* 避免重复提示用户
* - 仅在首次启动时检查网络情况
* - 如果用户已展示过提示弹窗，则直接返回 false
*/
if (has_shown_network_modal) return false
const network_type = await get_network_type()
last_network_usable = is_usable_network(network_type)
return handle_bad_network(network_type)
}
/**
* @description 尝试在网络可用时预加载离线预约记录数据
* - 仅在有授权时调用
* @returns {void} 无返回值
*/
const try_preload_when_online = () => {
if (!hasAuth()) return
Taro.getNetworkType({
success: (res) => {
if (is_usable_network(res.networkType)) {
preloadBookingData()
}
}
})
}
/**
* @description 授权成功后的共用启动逻辑
* - 尝试在网络可用时预加载离线预约数据
* - 启动离线预约缓存轮询（会自行处理网络可用性与引用计数）
* @returns {void} 无返回值
*/
const bootstrap_after_auth = () => {
try_preload_when_online()
enable_offline_booking_cache_polling({ interval_ms: 2 * 1000 * 60 })
}
// 处理在启动时出现的不良网络情况
const should_stop = await handle_bad_network_on_launch()
// 如果用户选择进入离线模式，则直接返回
if (should_stop) return
/**
* 尝试在有授权时预加载离线预约记录数据
* - 若无授权，则尝试静默授权
* - 授权成功后调用 bootstrap_after_auth 启动共用逻辑
* - 授权失败则跳转至授权页面
*/
// 如果用户已授权，则直接调用 bootstrap_after_auth 启动共用逻辑
// 如果用户已授权，则不需要额外操作
if (hasAuth()) {
bootstrap_after_auth()
return
}
......@@ -202,8 +37,6 @@ const App = createApp({
try {
// 尝试静默授权
await silentAuth()
// 授权成功后调用 bootstrap_after_auth 启动共用逻辑
bootstrap_after_auth()
} catch (error) {
console.error('静默授权失败:', error)
// 授权失败则跳转至授权页面
......
/**
* 刷新离线预约记录缓存
* - 仅在有授权且网络可用时调用
* - 成功后将数据存储到本地缓存（key: OFFLINE_BOOKING_DATA）
* @param {boolean} force - 是否强制刷新，默认为 false
* @returns {Promise<void>}
*/
import Taro from '@tarojs/taro'
import { billOfflineAllAPI } from '@/api/index'
import { hasAuth } from '@/utils/authRedirect'
import { formatDatetime } from '@/utils/tools'
import { is_usable_network, get_network_type } from '@/utils/network'
export const OFFLINE_BOOKING_CACHE_KEY = 'OFFLINE_BOOKING_DATA'
let refresh_promise = null
/**
* @description 兼容不同后端结构：从预约记录中提取可用数据载荷
* - 部分接口会把字段塞到 bill.list 对象里，这里做一次展开合并
* @param {Object} bill 原始预约记录
* @returns {Object} 扁平化后的预约记录对象
*/
const extract_bill_payload = (bill) => {
if (!bill) return {}
const data = { ...bill }
const list = data.list
if (list && typeof list === 'object' && !Array.isArray(list)) {
return { ...list, ...data }
}
return data
}
/**
* @description 从预约记录中提取人员列表
* - 兼容不同字段名（person_list/bill_person_list/persons/qrcode_list/qr_list/detail_list）
* - 保证返回数组类型
* @param {Object} bill 预约记录
* @returns {Array} 人员列表
*/
const extract_person_list = (bill) => {
if (!bill) return []
/**
* 从预约记录中提取人员列表
* - 考虑不同字段名的情况（如 person_list, bill_person_list, persons, qrcode_list, qr_list, detail_list）
* - 确保返回的是数组类型
*/
const candidate =
(Array.isArray(bill.list) ? bill.list : null) ||
(Array.isArray(bill?.list?.list) ? bill.list.list : null) ||
bill.person_list ||
bill.bill_person_list ||
bill.persons ||
bill.qrcode_list ||
bill.qr_list ||
bill.detail_list ||
[]
return Array.isArray(candidate) ? candidate : []
}
/**
* @description 格式化预约记录项（统一字段与展示用时间）
* @param {Object} item 原始预约记录项
* @returns {Object} 格式化后的预约记录项
*/
const normalize_bill_item = (item) => {
const data = extract_bill_payload(item)
data.datetime = data.datetime || formatDatetime(data)
data.booking_time = data.booking_time || data.datetime
data.order_time = data.order_time || (data.created_time ? data.created_time.slice(0, -3) : '')
if (!data.person_name) {
const person_list = extract_person_list(item)
const first = person_list[0]
const name = first?.name || first?.person_name
if (name) data.person_name = name
}
return data
}
/**
* 获取离线预约记录缓存
* @returns {Array} 格式化后的预约记录项列表
*/
export const get_offline_booking_cache = () => {
try {
const data = Taro.getStorageSync(OFFLINE_BOOKING_CACHE_KEY)
return Array.isArray(data) ? data : []
} catch (e) {
return []
}
}
/**
* 检查是否存在离线预约记录缓存
* @returns {boolean} 是否存在缓存且非空
*/
export const has_offline_booking_cache = () => {
const list = get_offline_booking_cache()
return Array.isArray(list) && list.length > 0
}
/**
* 根据支付ID获取离线预约记录
* @param {*} pay_id 支付ID
* @returns {Object|null} 匹配的预约记录项或 null
*/
export const get_offline_booking_by_pay_id = (pay_id) => {
const list = get_offline_booking_cache()
const target_pay_id = String(pay_id || '')
return list.find((item) => String(item?.pay_id || '') === target_pay_id) || null
}
/**
* 获取预约记录中的人员列表
* @param {Object} bill - 预约记录项
* @returns {Array} 人员列表（包含姓名、身份证号、二维码等信息）
*/
export const get_offline_bill_person_list = (bill) => {
return extract_person_list(bill)
}
/**
* 构建预约记录中的二维码列表
* @param {Object} bill - 预约记录项
* @returns {Array} 二维码列表（包含姓名、身份证号、二维码、预约时间等信息）
*/
export const build_offline_qr_list = (bill) => {
const list = get_offline_bill_person_list(bill)
const datetime = bill?.datetime || formatDatetime(bill || {})
return list
.filter((item) => item && (item.qr_code || item.qrcode || item.qrCode) && (item.qr_code || item.qrcode || item.qrCode) !== '')
.map((item) => {
const begin_time = item.begin_time || bill?.begin_time
const end_time = item.end_time || bill?.end_time
const qr_code = item.qr_code || item.qrcode || item.qrCode
const name = item.name || item.person_name || item.real_name
const id_number = item.id_number || item.idcard || item.idCard || item.id
return {
name,
id_number,
qr_code,
begin_time,
end_time,
datetime: item.datetime || (begin_time && end_time ? formatDatetime({ begin_time, end_time }) : datetime),
pay_id: bill?.pay_id,
sort: 0,
}
})
}
/**
* 刷新离线预约记录缓存
* - 仅在有授权且网络可用时调用
* - 成功后将数据存储到本地缓存（key: OFFLINE_BOOKING_DATA）
* @param {boolean} force - 是否强制刷新，默认为 false. force 参数的核心作用是控制是否忽略 “正在进行的缓存请求”, 管的是 “是否允许重复发起请求”，不管 “请求能不能成功执行缓存”。
* @returns 不同情况返回值不一样
* - 成功时包含格式化后的预约记录项列表
* - 失败时包含错误信息（如网络错误、授权失败等）
*/
export const refresh_offline_booking_cache = async ({ force = false } = {}) => {
// 1. 检查是否有正在进行的刷新请求
// 2. 如果有，且 force 为 false，则直接返回该 Promise
// 3. 如果没有，或 force 为 true，则继续执行刷新逻辑
// 4. 刷新完成后，将结果存储到本地缓存（key: OFFLINE_BOOKING_CACHE_KEY）
// 5. 返回刷新结果 Promise
if (!hasAuth()) return { code: 0, data: null, msg: '未授权' }
if (refresh_promise && !force) return refresh_promise
// 核心逻辑：
// 1. 立刻触发异步逻辑，同时捕获 Promise 状态
// 2. 保证 refresh_promise 始终是 Promise 类型，适配 await
// 3. 隔离作用域，避免变量污染
// 加 () 是为了 “让异步逻辑立刻跑起来”，并把 “跑的结果（Promise）” 存起来，供后续复用和等待。
refresh_promise = (async () => {
const network_type = await get_network_type()
if (!is_usable_network(network_type)) {
return { code: 0, data: null, msg: '网络不可用' }
}
const { code, data, msg } = await billOfflineAllAPI()
if (code && Array.isArray(data)) {
// 过滤出状态为3（已完成）的记录
const normalized = data.map(normalize_bill_item).filter((item) => item && item.pay_id && item.status == 3)
if (normalized.length > 0) {
// TAG: 核心逻辑：将过滤后的记录存储到本地缓存
Taro.setStorageSync(OFFLINE_BOOKING_CACHE_KEY, normalized)
}
}
return { code, data, msg }
})()
try {
return await refresh_promise
} finally {
refresh_promise = null
}
}
/**
* @description: 轮询离线预约缓存
*/
import Taro from '@tarojs/taro'
import { refresh_offline_booking_cache } from '@/composables/useOfflineBookingCache'
import { get_network_type, is_usable_network } from '@/utils/network'
/**
* @description: 轮询状态
* @typedef {Object} PollingState
* @property {Number} timer_id 轮询定时器id
* @property {Boolean} running 是否正在轮询
* @property {Boolean} in_flight 是否正在刷新
* @property {Number} ref_count 引用计数
* @property {Boolean} app_enabled 是否启用应用
* @property {Object} last_options 最后一次选项
* @property {Boolean} network_usable 网络可用性
* @property {Boolean} has_network_listener 是否已注册网络监听器
* @property {Function} network_listener 网络监听器
* @property {Promise} network_listener_promise 网络监听器Promise
*
* 状态同步规则（app_enabled 与 ref_count）：
* - app_enabled = true 时，ref_count >= 1（至少有一个使用者）
* - app_enabled = false 时，ref_count = 0（无使用者）
* - enable_offline_booking_cache_polling 会设置 app_enabled = true
* - disable_offline_booking_cache_polling 会设置 app_enabled = false
* - acquire_polling_ref 会增加 ref_count
* - release_polling_ref 会减少 ref_count，降为0时触发清理
*/
/** @type {PollingState} */
const polling_state = {
timer_id: null, // 轮询定时器id
running: false, // 是否正在轮询
in_flight: false, // 是否正在刷新
ref_count: 0, // 引用计数
app_enabled: false, // 是否启用应用
last_options: null, // 最后一次选项
network_usable: null, // 网络可用性
has_network_listener: false, // 是否已注册网络监听器
network_listener: null, // 网络监听器
network_listener_promise: null, // 网络监听器Promise
}
/**
* @description: 规范化选项参数（纯函数，无副作用）
* @param {Object} options 选项
* @return {Object} 规范化后的选项
*/
const normalize_options = (options) => {
return options || {}
}
/**
* @description: 保存最后一次选项（用于网络恢复时重启轮询）
* @param {Object} options 选项
* @return {Object} 保存后的选项
*/
const save_last_options = (options) => {
if (options) polling_state.last_options = options
return polling_state.last_options
}
/**
* 这是异步编程中典型的飞行状态锁（In-Flight Lock） 模式，是异步防重的核心思维落地方式；
* 核心逻辑：执行前 “上锁” 标记 → 执行异步操作 → 无论成败都 “解锁” 重置标记，从根源避免重复执行；
* finally 块是关键保障：防止异步操作报错导致 “永久上锁”，确保后续调用能正常执行。
*/
/**
* @description: 刷新离线预约缓存一次
* @param {Object} options 选项
* @param {Boolean} options.force 是否强制刷新
*/
const run_refresh_once = async (options) => {
// 前置检查：不满足轮询条件时直接返回（网络不可用或无引用）
if (!should_run_polling()) return
// 核心防重复——如果正在刷新，直接返回
if (polling_state.in_flight) return
// 标记为"正在刷新"
polling_state.in_flight = true
try {
await refresh_offline_booking_cache({ force: !!options?.force })
} finally {
// 刷新完成后，标记为"刷新完成"
polling_state.in_flight = false
}
}
/**
* @description: 更新网络可用性
*/
const update_network_usable = async () => {
const type = await get_network_type()
polling_state.network_usable = is_usable_network(type)
}
/**
* @description: 判断是否需要运行轮询
* @return {Boolean} 是否需要运行轮询
*
* 返回 false 的条件：
* 1. ref_count <= 0：无使用者，无需轮询
* 2. network_usable === false：网络不可用，无需轮询
* 3. network_usable === null：网络状态未初始化，避免在无监听器时误判
*
* 返回 true 的条件：
* 1. ref_count > 0：至少有一个使用者
* 2. network_usable === true：网络可用
*/
const should_run_polling = () => {
if (polling_state.ref_count <= 0) return false
if (polling_state.network_usable === false) return false
if (polling_state.network_usable === null) return false
return true
}
/**
* @description: 确保网络监听器已注册
* @return {Promise<Boolean>} 是否注册成功（true=成功，false=失败）
*/
const ensure_network_listener = async () => {
/**
* 代码优先通过两个条件判断避免重复执行监听器逻辑
* 1. 有已注册的监听器直接返回
* 2. 有未完成的注册 Promise 则直接返回
*/
if (polling_state.has_network_listener) {
await update_network_usable()
return true
}
if (polling_state.network_listener_promise) {
await polling_state.network_listener_promise
// 等待注册完成后检查是否成功
return polling_state.has_network_listener
}
// 立即执行异步的监听器注册流程（标记状态→更新网络可用性→定义回调→注册监听）
polling_state.network_listener_promise = (async () => {
// 标记已注册网络监听器
polling_state.has_network_listener = true
// 初始化时更新网络可用性
await update_network_usable()
// 网络状态变化监听器, 网络状态变化时的处理逻辑，此时只是定义，不会立即执行
polling_state.network_listener = (res) => {
const is_connected = res?.isConnected !== false
const type = res?.networkType || 'unknown'
polling_state.network_usable = is_connected && is_usable_network(type)
// 改进：不再主动停止轮询，由 run_refresh_once 中的 should_run_polling() 前置检查控制
// 优势：
// 1. 避免网络恢复时需要额外的重启逻辑
// 2. 保持定时器稳定，避免频繁启动/停止
// 3. 网络不可用时，刷新操作会在 run_refresh_once 中被前置检查过滤掉
// 网络恢复时，确保轮询正在运行（处理之前因网络不可用而可能停止的轮询）
if (polling_state.network_usable && should_run_polling()) {
// 传入 restart: true，支持重启逻辑
// 使用 normalize_options 显式处理 null/undefined，语义更清晰
start_offline_booking_cache_polling({
...normalize_options(polling_state.last_options),
restart: true
})
}
}
try {
// 注册网络状态变化监听器
Taro.onNetworkStatusChange(polling_state.network_listener)
} catch (e) {
polling_state.has_network_listener = false
polling_state.network_listener = null
polling_state.network_usable = null
console.error('注册网络监听失败:', e)
}
})()
try {
// 等待网络监听器初始化完成
await polling_state.network_listener_promise
} finally {
// 等待注册流程完成后，强制清空 Promise 缓存（finally 块），保证下次执行逻辑时状态干净
polling_state.network_listener_promise = null
}
// 返回注册是否成功
return polling_state.has_network_listener
}
/**
* @description: 注销网络监听器
* 涉及字段：
* - has_network_listener：是否有注册网络监听器
* - ref_count：引用计数
* - network_listener：网络状态变化监听器
* - network_usable：网络可用性状态
*/
const teardown_network_listener = () => {
// 1. 前置校验：避免无效执行
// 如果没有注册网络监听器，直接返回
if (!polling_state.has_network_listener) return
// 如果有引用计数，说明有其他地方在使用轮询，不能注销监听器
if (polling_state.ref_count > 0) return
// 标记监听器已注销（核心状态更新）
polling_state.has_network_listener = false
// 解绑框架层面的监听器
if (polling_state.network_listener && typeof Taro.offNetworkStatusChange === 'function') {
try {
Taro.offNetworkStatusChange(polling_state.network_listener)
} catch (e) {
// 捕获解绑失败的异常（比如监听器已被手动解绑）
console.warn('注销网络监听器失败:', e)
}
}
// 手动清空本地引用（关键！无论解绑成功/失败都要做）
// 注销后，清空网络监听器引用，确保后续调用能正常工作
polling_state.network_listener = null
/**
* 核心目的：清空 network_usable = null 是为了让状态和监听器的生命周期完全同步 —— 监听器注销后，其产生的网络状态也必须失效，避免 “无监听器却有状态” 的矛盾；
* 关键作用：通过让 should_run_polling() 直接返回 false，杜绝基于过期状态启动轮询的可能；
* 设计思维：体现了 “状态闭环” 的工程化思想 —— 任何状态都要有明确的产生、更新、销毁逻辑，不残留 “脏数据” 干扰后续流程。
*/
// 清空网络可用性状态，确保后续判断逻辑能正常工作
// 清空衍生状态，避免脏数据
polling_state.network_usable = null
}
/**
* @description: 启动离线预约缓存轮询
* @param {Object} options 选项
* @param {Number} options.interval_ms 轮询间隔，单位毫秒
* @param {Boolean} options.immediate 是否立即刷新一次
* @param {Boolean} options.force 是否强制刷新（透传给 refresh_offline_booking_cache）
* @param {Boolean} options.restart 是否为重启操作（网络恢复时调用）
*/
const start_offline_booking_cache_polling = (options) => {
options = normalize_options(options)
if (!should_run_polling()) return // 不满足轮询条件直接返回
const interval_ms = Number(options?.interval_ms || 60000)
const is_restart = options?.restart === true
// 改进：区分首次启动和重启的防重逻辑
// 首次启动时，如果已经在轮询则直接返回（防重复启动）
// 重启时，需要清除旧定时器并重新建立（支持网络恢复时重启）
if (polling_state.running && !is_restart) return
// 如果是重启或定时器已存在，先清除旧定时器
if (is_restart && polling_state.timer_id) {
clearInterval(polling_state.timer_id)
polling_state.timer_id = null
}
polling_state.running = true // 标记为"正在轮询"
// 立即刷新一次，确保轮询开始时数据是最新的
if (options?.immediate !== false) {
run_refresh_once(options)
}
// 启动轮询定时器，按照指定间隔执行刷新操作
polling_state.timer_id = setInterval(() => {
run_refresh_once(options)
}, interval_ms)
}
/**
* @description: 停止离线预约缓存轮询
*/
const stop_offline_booking_cache_polling = () => {
if (polling_state.timer_id) {
clearInterval(polling_state.timer_id)
polling_state.timer_id = null
}
polling_state.running = false
}
/**
* 引用计数的核心作用
* 这两个函数实现了轮询功能的 “引用计数式资源管理”，本质是追踪有多少 “使用者 / 场景” 依赖这个轮询功能，从而决定是否启动 / 维持 / 停止轮询、注册 / 注销网络监听器，
* 核心目的是：
* - 避免轮询被重复启动、错误停止
* - 防止无使用者时仍占用资源（定时器、网络监听器）
* - 保证多场景共用轮询时的逻辑一致性
*/
/**
* @description: 增加轮询引用计数
* 核心动作：将全局的 ref_count 加 1，代表 "又多了一个场景需要使用轮询功能"。
* @param {Object} options 选项
*/
const acquire_polling_ref = (options) => {
save_last_options(options)
polling_state.ref_count += 1
// 改进：检查网络监听器注册结果，只有成功后才启动轮询
ensure_network_listener().then((success) => {
if (success && polling_state.last_options) {
start_offline_booking_cache_polling(polling_state.last_options)
}
})
}
/**
* @description: 减少轮询引用计数
* 核心动作：将 ref_count 减 1（且保证不会为负数），代表 “有一个场景不再需要轮询功能”。
*/
const release_polling_ref = () => {
polling_state.ref_count = Math.max(0, polling_state.ref_count - 1)
if (polling_state.ref_count === 0) {
// 引用计数降为0时，停止轮询并注销网络监听器
stop_offline_booking_cache_polling()
teardown_network_listener()
}
}
/**
* @description: 启用离线预约缓存轮询
* @param {Object} options 选项
* @param {Number} options.interval_ms 轮询间隔，单位毫秒
* @param {Boolean} options.immediate 是否立即刷新一次
* @param {Boolean} options.force 是否强制刷新（透传给 refresh_offline_booking_cache）
*/
export const enable_offline_booking_cache_polling = (options) => {
save_last_options(options)
/**
* 核心目的：对 app_enabled=true 的场景做兜底，确保轮询在 "已启用但异常停止" 时能被主动恢复，而非被动等待网络变化；
* 执行逻辑：先保证网络监听器（轮询的依赖）就绪，再尝试启动轮询，且利用 start_offline_booking_cache_polling 的幂等性避免重复；
* 设计思维：体现了 "主动调用需即时生效" 的用户体验考量，以及 "依赖前置检查" 的工程化思维 —— 先保证依赖（监听器）就绪，再执行核心操作（启动轮询）。
*/
if (polling_state.app_enabled) {
ensure_network_listener().then((success) => {
if (success && polling_state.last_options) {
start_offline_booking_cache_polling(polling_state.last_options)
}
})
return
}
polling_state.app_enabled = true
acquire_polling_ref(polling_state.last_options || {})
}
/**
* @description: 禁用离线预约缓存轮询
*/
export const disable_offline_booking_cache_polling = () => {
if (!polling_state.app_enabled) return
polling_state.app_enabled = false
release_polling_ref()
}
<template>
<view class="api-demo">
<nut-cell-group>
<nut-cell title="API 生成器演示" />
</nut-cell-group>
<!-- 用户信息模块 -->
<nut-cell-group title="用户模块">
<nut-cell>
<template #title>
<view>获取用户信息</view>
</template>
<template #link>
<nut-button
size="small"
type="primary"
@click="fetchUserInfo"
:loading="userLoading"
>
调用
</nut-button>
</template>
</nut-cell>
<nut-cell v-if="userInfo" title="用户数据">
<view class="user-info">
<text>姓名: {{ userInfo?.name || '-' }}</text>
<text>手机: {{ userInfo?.mobile || '-' }}</text>
</view>
</nut-cell>
</nut-cell-group>
<!-- 订单模块 -->
<nut-cell-group title="订单模块">
<nut-cell>
<template #title>
<view>获取订单列表</view>
</template>
<template #link>
<nut-button
size="small"
type="primary"
@click="fetchOrderList"
:loading="orderLoading"
>
调用
</nut-button>
</template>
</nut-cell>
<nut-cell v-if="orderList.length > 0" title="订单列表">
<view class="order-list">
<view
v-for="order in orderList"
:key="order.id"
class="order-item"
>
<text>订单号: {{ order.order_no }}</text>
<text>状态: {{ order.status }}</text>
<text>金额: ¥{{ order.total_amount }}</text>
</view>
</view>
</nut-cell>
<nut-cell>
<template #title>
<view>获取订单详情</view>
</template>
<template #link>
<nut-button
size="small"
type="primary"
@click="fetchOrderDetail"
:loading="detailLoading"
>
调用
</nut-button>
</template>
</nut-cell>
<nut-cell v-if="orderDetail" title="订单详情">
<view class="order-detail">
<text>订单号: {{ orderDetail.order_no }}</text>
<text>商品数: {{ orderDetail.items?.length || 0 }}</text>
</view>
</nut-cell>
</nut-cell-group>
<!-- 使用说明 -->
<nut-cell-group title="使用说明">
<nut-cell>
<view class="instructions">
<text>1. 点击上方按钮调用 API</text>
<text>2. API 文件位于 src/api/ 目录</text>
<text>3. 由 docs/api-specs/ 文档自动生成</text>
<text>4. 运行 pnpm api:generate 生成新 API</text>
</view>
</nut-cell>
</nut-cell-group>
</view>
</template>
<script setup>
import { ref } from 'vue';
import Taro from '@tarojs/taro';
import { getUserInfoAPI } from '@/api/user';
import { getListAPI, getDetailAPI } from '@/api/order';
// 用户模块
const userInfo = ref(null);
const userLoading = ref(false);
// 订单模块
const orderList = ref([]);
const orderLoading = ref(false);
const orderDetail = ref(null);
const detailLoading = ref(false);
/**
* 获取用户信息
*/
const fetchUserInfo = async () => {
userLoading.value = true;
try {
const result = await getUserInfoAPI();
if (result.code === 1) {
userInfo.value = result.data.user;
Taro.showToast({
title: '获取成功',
icon: 'success',
duration: 2000,
});
} else {
Taro.showToast({
title: result.msg || '获取失败',
icon: 'error',
duration: 2000,
});
}
} catch (error) {
console.error('获取用户信息失败:', error);
Taro.showToast({
title: '网络异常',
icon: 'error',
duration: 2000,
});
} finally {
userLoading.value = false;
}
};
/**
* 获取订单列表
*/
const fetchOrderList = async () => {
orderLoading.value = true;
try {
const result = await getListAPI({
page: 1,
pageSize: 10,
});
if (result.code === 1) {
orderList.value = result.data.list || [];
Taro.showToast({
title: '获取成功',
icon: 'success',
duration: 2000,
});
} else {
Taro.showToast({
title: result.msg || '获取失败',
icon: 'error',
duration: 2000,
});
}
} catch (error) {
console.error('获取订单列表失败:', error);
Taro.showToast({
title: '网络异常',
icon: 'error',
duration: 2000,
});
} finally {
orderLoading.value = false;
}
};
/**
* 获取订单详情
*/
const fetchOrderDetail = async () => {
detailLoading.value = true;
try {
const result = await getDetailAPI({
id: 123, // 示例订单ID
});
if (result.code === 1) {
orderDetail.value = result.data.order;
Taro.showToast({
title: '获取成功',
icon: 'success',
duration: 2000,
});
} else {
Taro.showToast({
title: result.msg || '获取失败',
icon: 'error',
duration: 2000,
});
}
} catch (error) {
console.error('获取订单详情失败:', error);
Taro.showToast({
title: '网络异常',
icon: 'error',
duration: 2000,
});
} finally {
detailLoading.value = false;
}
};
</script>
<style lang="less" scoped>
.api-demo {
padding: 20px;
background-color: #f5f5f5;
min-height: 100vh;
.user-info,
.order-list,
.order-detail,
.instructions {
display: flex;
flex-direction: column;
gap: 10px;
font-size: 14px;
color: #666;
text {
display: block;
}
}
.order-item {
padding: 10px;
background-color: #f9f9f9;
border-radius: 4px;
margin-bottom: 10px;
}
}
</style>
import Taro from '@tarojs/taro'
import { routerStore } from '@/stores/router'
import { buildApiUrl } from './tools'
import { ENABLE_AUTH_MODE } from './config'
// 改进：添加全局状态变量注释
/**
......@@ -58,6 +59,9 @@ export const saveCurrentPagePath = (custom_path) => {
* @returns {boolean} true=已存在 sessionid，false=需要授权
*/
export const hasAuth = () => {
// 如果禁用了授权模式，直接视为已授权
if (!ENABLE_AUTH_MODE) return true
try {
const sessionid = Taro.getStorageSync('sessionid')
return !!sessionid && sessionid !== ''
......@@ -93,6 +97,11 @@ const extractCookie = (response) => {
* @returns {Promise<{code:number,msg?:string,data?:any,cookie?:string}>} 授权结果（会把 cookie 写入 storage 的 sessionid）
*/
export const refreshSession = async (options) => {
// 如果禁用了授权模式，直接返回模拟成功
if (!ENABLE_AUTH_MODE) {
return { code: 1, msg: '授权模式已禁用', cookie: 'mock_session_id' }
}
const show_loading = options?.show_loading !== false
// 已有授权进行中时，直接复用同一个 Promise
......@@ -254,6 +263,9 @@ const NAVIGATING_RESET_DELAY_MS = 300
* @returns {Promise<void>} 无返回值
*/
export const navigateToAuth = async (return_path) => {
// 如果禁用了授权模式，直接返回不跳转
if (!ENABLE_AUTH_MODE) return
const pages = Taro.getCurrentPages()
const current_page = pages[pages.length - 1]
const current_route = current_page?.route
......
/*
* @Date: 2026-01-29 10:48:35
* @LastEditors: hookehuyr hookehuyr@gmail.com
* @LastEditTime: 2026-01-29 17:56:45
* @FilePath: /manulife-weapp/src/utils/config.js
* @Description: 文件描述
*/
/*
* @Description: 服务器环境配置
* @Template: 请根据实际项目修改 BASE_URL 和 REQUEST_DEFAULT_PARAMS
*/
......@@ -23,4 +30,11 @@ export const REQUEST_DEFAULT_PARAMS = {
client_name: 'YOUR_APP', // 🔧 修改为应用名称
}
/**
* @description 是否启用授权模式
* - true: 启用授权检查、自动跳转登录、401自动续期
* - false: 禁用所有授权相关功能（所有授权检查直接通过，不跳转登录页）
*/
export const ENABLE_AUTH_MODE = false
export default BASE_URL
......
/*
* @Date: 2022-09-19 14:11:06
* @LastEditors: hookehuyr hookehuyr@gmail.com
* @LastEditTime: 2026-01-13 21:29:43
* @FilePath: /xyxBooking-weapp/src/utils/request.js
* @LastEditTime: 2026-01-29 18:35:55
* @FilePath: /manulife-weapp/src/utils/request.js
* @Description: 简单axios封装，后续按实际处理
*/
// import axios from 'axios'
......@@ -11,8 +11,6 @@ import Taro from '@tarojs/taro'
// import qs from 'qs'
// import { strExist } from './tools'
import { refreshSession, saveCurrentPagePath, navigateToAuth } from './authRedirect'
import { has_offline_booking_cache } from '@/composables/useOfflineBookingCache'
import { get_weak_network_modal_no_cache_options } from '@/utils/uiText'
import { parseQueryString } from './tools'
// import { ProgressStart, ProgressEnd } from '@/components/axios-progress/progress';
......@@ -136,34 +134,22 @@ const should_handle_bad_network = async (error) => {
/**
* @description 处理请求超时/弱网错误
* - 优先：若存在离线预约记录缓存，直接跳转离线预约列表页
* - 否则：弹出弱网提示（统一文案由 uiText 管理）
* - 弹出弱网提示（统一文案由 uiText 管理）
* @returns {Promise<void>} 无返回值
*/
const handle_request_timeout = async () => {
if (has_shown_timeout_modal) return
has_shown_timeout_modal = true
const pages = Taro.getCurrentPages ? Taro.getCurrentPages() : []
const current_page = pages && pages.length ? pages[pages.length - 1] : null
const current_route = current_page?.route || ''
if (String(current_route).includes('pages/offlineBookingList/index')) return
// 若有离线预约记录缓存，则跳转至离线预约列表页
if (has_offline_booking_cache()) {
try {
await Taro.reLaunch({ url: '/pages/offlineBookingList/index' })
} catch (e) {
console.error('reLaunch offlineBookingList failed:', e)
}
return
}
// 否则提示用户检查网络连接
// 提示用户检查网络连接
try {
await Taro.showModal(get_weak_network_modal_no_cache_options())
await Taro.showToast({
title: '网络连接异常，请检查网络设置',
icon: 'none',
duration: 2000
})
} catch (e) {
console.error('show weak network modal failed:', e)
console.error('show weak network toast failed:', e)
}
}
......@@ -239,7 +225,7 @@ service.interceptors.response.use(
const res = response.data
// 401 未授权处理
if (res.code === 401) {
if (res.code === 401 && ENABLE_AUTH_MODE) {
const config = response?.config || {}
/**
* 避免死循环/重复重试：
......
/*
* @Date: 2026-01-13 21:28:45
* @LastEditors: hookehuyr hookehuyr@gmail.com
* @LastEditTime: 2026-01-15 19:24:57
* @FilePath: /xyxBooking-weapp/src/utils/uiText.js
* @Description: 弱网络提示文本
*/
/**
* @description 弱网/断网统一文案
* - toast/modal/banner 等入口统一引用，避免多处硬编码
*/
export const weak_network_text = {
title: '网络连接不畅',
toast_title: '网络连接不畅',
banner_desc: '网络开小差啦！请检查网络设置，或更换位置后重新进入小程序～',
offline_page_desc: '当前网络信号较弱，已自动为您切换至离线模式',
modal_no_cache_content: '当前网络信号较弱，暂无法使用小程序，请检查网络设置，或更换位置后重新进入小程序～',
modal_use_cache_content: '当前网络信号较弱，可使用已缓存的预约记录进入离线模式',
modal_go_offline_records_content: '当前网络信号较弱，是否进入离线预约记录？',
offline_mode_no_booking_toast: '当前为离线模式，无法预约',
confirm_ok: '知道了',
confirm_booking_records: '预约记录',
confirm_offline_records: '离线记录',
}
/**
* @description: 获取弱网络提示弹窗配置（无缓存）
* @returns {Object}
*/
export const get_weak_network_modal_no_cache_options = () => {
return {
title: weak_network_text.title,
content: weak_network_text.modal_no_cache_content,
confirmText: weak_network_text.confirm_ok,
showCancel: false,
}
}
/**
* @description: 获取弱网络提示弹窗配置（有缓存）
* @returns {Object}
*/
export const get_weak_network_modal_use_cache_options = () => {
return {
title: weak_network_text.title,
content: weak_network_text.modal_use_cache_content,
confirmText: weak_network_text.confirm_booking_records,
cancelText: weak_network_text.confirm_ok,
}
}
/**
* @description: 获取弱网络提示弹窗配置（进入离线预约记录）
* @returns {Object}
*/
export const get_weak_network_modal_go_offline_records_options = () => {
return {
title: weak_network_text.title,
content: weak_network_text.modal_go_offline_records_content,
confirmText: weak_network_text.confirm_offline_records,
cancelText: weak_network_text.confirm_ok,
}
}