WMS_PDA/src/pages/index/index.vue
zm2000 b95ac35d39 fix(ui): 修复真机加粗失效并统一 PDA 页面字号与布局
- 库存盘点:font-weight 600 统一改为 bold,修复真机无加粗效果
- 库存盘点:移除右上角「...」操作菜单,改为「完成盘点」「空库位」直接按钮
- 库存盘点:顶部标题栏字号统一 36rpx,搜索输入框字号 34rpx,提示字号 28→30rpx
- 拦截登记:顶部导航重构为自定义 header(返回/标题/输入框开关/重置)
- 拦截登记:搜索框改为 u-search 圆角样式并新增「搜索」按钮
- 拦截登记:信息面板标签 32→36rpx、值 32→40rpx,与搜索框间隔调整为 60rpx
- 拦截登记:拦截失败提示优化,区分「非拦截订单」等文案
- 库位查询:标题/搜索/计数半格样式调整,浅色背景深色文字、下划线强调
- 其他:page-nav 右侧宽度改 min-width;首页/个人中心弹窗圆角 24→20rpx;多处标题字号 32→36rpx
2026-11-09 17:59:23 +08:00

2436 lines
66 KiB
Vue
Raw Blame History

This file contains ambiguous Unicode characters

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.

<template>
<view class="pda-home">
<view class="status_bar">
</view>
<view class="compact-header">
<!-- 通知数据:与「通知信息」弹窗同源(noticeStatItems) -->
<view class="stat-strip" v-if="noticeStatItems.length" @click="openNoticePopup">
<view class="stat-item" v-for="item in noticeStatItems" :key="item.label">
<text class="stat-item__value">{{ item.value }}</text>
<text class="stat-item__label">{{ item.label }}</text>
</view>
</view>
<!-- 通知跑马灯 -->
<view class="org-switcher">
<view class="news-wrapper" @click="openNoticePopup">
<view class="news-pill">
<view class="news-pill__icon">
<u-icon name="bell-fill" size="14" color="#FF8C42"></u-icon>
</view>
<view class="news-pill__body">
<view class="news-marquee">
<view class="news-marquee__track" :class="{ 'is-paused': !pageVisible }" :style="{ animationDuration: marqueeDuration }">
<text class="news-marquee__text">{{ noticeText }}</text>
<text class="news-marquee__text">{{ noticeText }}</text>
</view>
</view>
</view>
<u-icon class="news-pill__arrow" name="arrow-right" size="12" color="#FFA94D"></u-icon>
</view>
</view>
</view>
</view>
<!-- 主内容区 -->
<view class="main-scroll">
<!-- 快捷入口区域 -->
<view class="quick-section">
<view class="section-title-bar">
<view class="title-left">
<view class="title-accent"></view>
<text class="section-title">常用功能</text>
<text class="drag-tip" v-if="quickActions.length > 0 && !quickActionRemoveMode">长按排序</text>
</view>
<view class="title-right">
<text v-if="quickActionRemoveMode" class="done-btn" @click="exitQuickActionRemoveMode">完成</text>
<text v-else-if="quickActions.length > 0" class="manage-btn" @click="enterQuickActionRemoveMode">管理</text>
<view class="edit-btn" @click="toEditPage">
<text class="edit-btn__text">全部功能</text>
<u-icon name="arrow-right" size="14" color="#2979ff" style="margin-left: 6rpx;"></u-icon>
</view>
</view>
</view>
<!-- 3行3列的快捷入口网格(每页 9 个) -->
<view class="quick-grid-container">
<!-- 上一页按钮 -->
<view class="nav-arrow left-arrow" @click="prevPage" :class="{ disabled: currentPage === 1 }">
<u-icon name="arrow-left" size="20" color="#666"></u-icon>
</view>
<!-- 网格内容 -->
<view class="quick-grid-wrapper" @touchstart="handleWrapperTouchStart" @touchmove="handleWrapperTouchMove" @touchend="handleWrapperTouchEnd" @touchcancel="handleWrapperTouchEnd">
<!-- 首次加载骨架屏,避免出现一大片空白 -->
<view class="skeleton-grid" v-if="isLoading && !quickActions.length">
<view class="skeleton-item" v-for="n in pageSize" :key="`skeleton-${n}`">
<view class="skeleton-icon"></view>
<view class="skeleton-text"></view>
</view>
</view>
<!-- 空状态提示 -->
<view class="empty-state" v-else-if="!isLoading && quickActions.length === 0">
<u-icon name="grid" size="80" color="#ccc"></u-icon>
<text class="empty-text">暂无可用功能</text>
<text class="empty-hint">请联系仓库管理员检查授权</text>
<text class="empty-retry" @click.stop="retryLoad">重新加载</text>
</view>
<view v-else class="quick-page-shell">
<view class="grid-page" :id="`grid-page-${currentPage - 1}`">
<view
class="grid-item grid-slot"
v-for="slot in renderPageSlots"
:key="slot.key"
:class="[
`page-slot-${currentPage - 1}`,
{
'drag-placeholder': slot.action && isDraggingItem(slot.action),
'drag-disabled': dragState.active,
'empty-item': !slot.action
}
]">
<template v-if="slot.action">
<view
class="grid-item-touch-layer"
@longpress.stop.prevent="handleQuickActionLongPress($event, slot.action, currentPage - 1, slot.index)"
@click.stop.prevent="handleGridItemClick(slot.action)"
></view>
<view
v-if="quickActionRemoveMode"
class="remove-action-btn"
@click.stop="removeQuickAction(slot.action)"
>
<text class="remove-action-icon">{{ removeActionIconGlyph }}</text>
</view>
<view class="grid-item-content">
<view class="item-icon-box" :style="{ background: (slot.action.color || '#2979ff') + '15', color: slot.action.color || '#2979ff' }">
<image
v-if="slot.action.isImageIcon"
class="item-icon-image"
:src="slot.action.resolvedIconSource"
mode="aspectFit"
></image>
<text v-else class="item-icon-font" :style="{ color: slot.action.color || '#2979ff' }">{{ slot.action.resolvedIconGlyph || fallbackIconGlyph }}</text>
</view>
<text class="item-name">{{ slot.action.name || '未命名菜单' }}</text>
<u-badge v-if="Number(slot.action.badge || 0) > 0" :count="Number(slot.action.badge || 0)" size="mini"
type="error" :offset="[-3, 3]" class="item-badge"></u-badge>
</view>
</template>
</view>
</view>
</view>
<view
v-show="dragState.active"
class="drag-preview"
:style="dragPreviewStyle"
>
<text v-if="quickActionRemoveMode" class="preview-remove-action-icon">{{ removeActionIconGlyph }}</text>
<view class="item-icon-box" :style="{ background: (dragPreviewSnapshot.color || '#2979ff') + '15', color: dragPreviewSnapshot.color || '#2979ff' }">
<image
v-if="dragPreviewSnapshot.isImageIcon"
class="item-icon-image"
:src="dragPreviewSnapshot.resolvedIconSource"
mode="aspectFit"
></image>
<text v-else class="item-icon-font" :style="{ color: dragPreviewSnapshot.color || '#2979ff' }">{{ dragPreviewSnapshot.resolvedIconGlyph || fallbackIconGlyph }}</text>
</view>
<text class="item-name" v-text="dragPreviewSnapshot.name || '未命名菜单'"></text>
</view>
</view>
<!-- 下一页按钮 -->
<view class="nav-arrow right-arrow" @click="nextPage"
:class="{ disabled: currentPage === totalPages }">
<u-icon name="arrow-right" size="20" color="#666"></u-icon>
</view>
</view>
<!-- 分页指示器 -->
<view class="pagination-dots" v-if="totalPages > 1">
<view v-for="n in totalPages" :key="n" class="pagination-dot"
:class="{ active: n === currentPage }"></view>
</view>
</view>
<!-- 加载状态 -->
<view class="loading-state" v-if="isLoading">
<text class="loading-text">加载中...</text>
</view>
</view>
<!-- 移除撤销提示 -->
<view v-if="undoAction && undoAction.item" class="undo-bar">
<text class="undo-bar__text">已移出「{{ undoAction.item.name }}」</text>
<text class="undo-bar__btn" @click.stop="undoRemoveAction">撤销</text>
</view>
<!-- 通知信息弹窗 -->
<u-popup :show="showNoticePopup" mode="bottom" round="20" :closeable="true" :safeAreaInsetBottom="true" @close="closeNoticePopup">
<view class="notice-popup">
<view class="notice-popup__header">
<text class="notice-popup__title">通知信息</text>
</view>
<scroll-view scroll-y class="notice-popup__body">
<view class="notice-popup__grid">
<view v-for="item in noticeStatItems" :key="item.label" class="notice-popup__item">
<text class="notice-popup__value">{{ item.value }}</text>
<text class="notice-popup__label">{{ item.label }}</text>
</view>
</view>
</scroll-view>
</view>
</u-popup>
<!-- 退出应用确认弹窗 -->
<view v-if="$store.state.app.exitConfirmVisible" class="exit-app-mask" @click="cancelExitApp">
<view class="exit-app-dialog" @click.stop>
<view class="exit-app-icon">
<u-icon name="info-circle" size="60" color="#f0ad4e"></u-icon>
</view>
<text class="exit-app-title">退出应用</text>
<text class="exit-app-desc">您确定要退出应用吗?</text>
<view class="exit-app-actions">
<u-button plain text="取消" @click="cancelExitApp"></u-button>
<u-button type="error" text="退出" @click="confirmExitApp"></u-button>
</view>
</view>
</view>
</view>
</template>
<script>
import uviewIcons from '@/uni_modules/uview-ui/components/u-icon/icons.js'
const VALID_UVIEW_ICON_NAMES = new Set(
Object.keys(uviewIcons || {}).map(key => String(key).replace(/^uicon-/, ''))
)
// 常用功能配色:按菜单 key 取模,保证同一菜单每次刷新颜色一致
const MENU_COLOR_POOL = [
'#FF6B6B', '#4ECDC4', '#FFD166', '#06D6A0', '#118AB2',
'#EF476F', '#26547C', '#7209B7', '#3A86FF', '#FB5607',
'#8338EC', '#2EC4B6'
]
// 看板统计相关的菜单识别(后台菜单名可能调整,保留关键字兜底)
const isReviewShippingMenuName = name => name === '散单复核发货' ||
name === '订单复核' ||
(name.includes('复核') && name.includes('发货'))
const isScatterReviewShippingMenuName = name => name === '散单复核发货' ||
name === '订单复核' ||
(name.includes('散单') && name.includes('复核') && name.includes('发货'))
const isOrderPickingMenuName = name => name === '订单拣货' ||
(name.includes('订单') && name.includes('拣货'))
const isClaimShippingMenuName = name => name === '领取快递面单' ||
(name.includes('领取') && name.includes('面单'))
/**
* 常用功能菜单 → 页面路由。
* 顺序敏感:按数组顺序命中即返回(与原 if/else 链保持一致)。
* names 精确匹配、all 需同时包含、any 命中任一、test 自定义判断;
* paths 按 component/path 命中;block 只提示不跳转。
*/
const MENU_ROUTE_RULES = [
{
block: '该功能只支持在商品查询页面使用!',
paths: ['/pages/work/storage/relocation', '/pages/work/product/itemMaint'],
names: ['移库作业', '商品信息维护']
},
{ path: '/pages/work/storage/random-storage', names: ['随机入库'], all: ['随机', '入库'] },
{ path: '/pages/warehouse/locationInquiry', names: ['库位查询'], all: ['库位', '查询'] },
{ path: '/pages/warehouse/inventoryTransfer', names: ['移库记录'], all: ['移库', '记录'] },
{ path: '/pages/warehouse/inventoryCount', names: ['库存盘点'], all: ['库存', '盘点'], any: ['盘点'] },
{ path: '/pages/work/product/query', names: ['商品查询'], all: ['商品', '查询'] },
{ path: '/pages/work/order/picking', test: isOrderPickingMenuName },
{ path: '/pages/work/order/scatter-wave-strategy', names: ['散单波次策略'], all: ['散单', '波次'] },
{ path: '/pages/work/order/gBWaveStrategy', names: ['团购波次策略'], all: ['团购', '波次'] },
{ path: '/pages/work/order/order-review', test: isScatterReviewShippingMenuName },
{ path: '/pages/work/order/scatter-picking-detail', names: ['散单拣货详情'], all: ['散单', '拣货', '详情'] },
{ path: '/pages/work/order/groupon-picking-detail', names: ['团购拣货详情'], all: ['团购', '拣货', '详情'] },
{ path: '/pages/packing/labelReprint', names: ['面单补打'], all: ['面单', '补打'] },
{ path: '/pages/work/order/interceptionLog', names: ['拦截登记'] },
{ path: '/pages/work/order/pickingRecord', names: ['拣货记录'], all: ['拣货', '记录'] }
]
export default {
data() {
return {
isLoading: true,
currentPage: 1,
userInfo: {},
dashboardStats: null,
hasReviewShippingMenu: false,
hasOrderPickingMenu: false,
hasClaimShippingMenu: false,
unclaimedWaveCount: 0,
showNoticePopup: false,
quickActions: [],
// 每页 9 个:3 列 × 3 行
pageSize: 9,
pageVisible: true,
undoAction: null,
FIXED_MENU_KEY: 'fixed_home_menus',
dragState: {
active: false,
item: null,
key: '',
originalIndex: -1,
pageIndex: -1,
hoverIndex: -1,
previewX: 0,
previewY: 0,
slotRects: [],
pageRect: null
},
dragPreviewSnapshot: null,
isSavingOrder: false,
quickActionRemoveMode: false,
suppressItemClick: false,
dragPageSwitching: false,
dragPageSnapshot: [],
wrapperGesture: {
startX: 0,
startY: 0,
deltaX: 0,
deltaY: 0,
startTime: 0
}
}
},
computed: {
normalizedQuickActions() {
return Array.isArray(this.quickActions)
? this.quickActions.filter(Boolean).map(item => this.normalizeAction(item))
: [];
},
displayQuickActions() {
if (!this.dragState.active || !this.dragState.key) {
return this.normalizedQuickActions;
}
const sourceActions = this.normalizedQuickActions;
const sourceIndex = sourceActions.findIndex(item => this.getMenuKey(item) === this.dragState.key);
const targetIndex = this.dragState.hoverIndex;
if (sourceIndex < 0 || targetIndex < 0) {
return sourceActions;
}
const projected = [...sourceActions];
const [dragItem] = projected.splice(sourceIndex, 1);
if (!dragItem) {
return sourceActions;
}
projected.splice(Math.min(targetIndex, projected.length), 0, dragItem);
return projected.filter(Boolean);
},
// 分页后的快捷入口
paginatedActions() {
const pages = [];
for (let i = 0; i < this.displayQuickActions.length; i += this.pageSize) {
pages.push(this.displayQuickActions.slice(i, i + this.pageSize));
}
return pages;
},
currentPageItems() {
return (this.paginatedActions[this.currentPage - 1] || []).filter(Boolean);
},
safeCurrentPageSlots() {
const items = this.currentPageItems
.map(item => this.normalizeAction(item))
.filter(Boolean)
.slice(0, this.pageSize);
return Array.from({ length: this.pageSize }, (_, index) => {
const action = items[index] || null;
return {
index,
action,
key: action ? this.getMenuKey(action) : `empty-slot-${this.currentPage}-${index}`
};
});
},
renderPageSlots() {
if (this.dragState.active && Array.isArray(this.dragPageSnapshot) && this.dragPageSnapshot.length) {
return this.dragPageSnapshot;
}
return this.safeCurrentPageSlots;
},
fallbackIconGlyph() {
return uviewIcons['uicon-grid'] || '\ue673';
},
removeActionIconGlyph() {
return uviewIcons['uicon-minus-circle-fill'] || '\ue652';
},
totalPages() {
return Math.ceil(this.displayQuickActions.length / this.pageSize) || 1;
},
dragPreviewStyle() {
return {
left: `${this.dragState.previewX}px`,
top: `${this.dragState.previewY}px`
};
},
// 公告与看板弹窗的唯一数据源,避免两处重复拼装同一套统计规则
noticeStats() {
const stats = this.dashboardStats || null;
const showUnclaimed = this.hasClaimShippingMenu && this.hasOrderPickingMenu;
if (!stats && !showUnclaimed) {
return [];
}
const f = this.formatStatNumber;
const items = [];
if (stats) {
items.push({ label: '今日订单', value: f(stats.todayOrders) });
}
if (showUnclaimed) {
items.push({ label: '未领料波次', value: f(this.unclaimedWaveCount) });
}
if (stats && showUnclaimed) {
items.push({ label: '未拣货', value: f(stats.unpickedOrders) });
}
if (stats && this.hasReviewShippingMenu) {
items.push({ label: '已复核', value: f(stats.recheckedOrders) });
}
return items;
},
noticeText() {
const items = this.noticeStats;
if (!items.length) {
return '欢迎使用PDA仓库管理系统';
}
return items.map(item => `${item.label} ${item.value}`).join(',');
},
// 滚动时长:按文字长度估算,保证滚动速度稳定
marqueeDuration() {
const len = String(this.noticeText || '').length;
return `${Math.max(8, len * 0.4)}s`;
},
noticeStatItems() {
return this.noticeStats;
}
},
async onLoad() {
this.dragPreviewSnapshot = this.createDefaultDragPreviewSnapshot();
// onLoad 之后紧接的首次 onShow 会立刻触发,跳过它避免首屏重复请求
this._skipNextShow = true;
await this.loadUserInfo();
},
onShow() {
this.pageVisible = true;
// 首页顶部为深色渐变,状态栏文字/图标需改为白色(真机 App 端)
this.setAppStatusBarStyle('light');
if (this._skipNextShow) {
this._skipNextShow = false;
return;
}
// 返回首页时静默刷新,不闪烁加载态
this.loadUserInfo({ silent: true });
},
onHide() {
// 离开页面时暂停跑马灯动画,避免后台持续占用渲染
this.pageVisible = false;
// 其他页面状态栏底色为白色,离开首页时恢复深色文字/图标
this.setAppStatusBarStyle('dark');
},
onUnload() {
this.unbindGlobalDragListeners();
this.clearUndoTimer();
},
methods: {
// 取消退出应用
cancelExitApp() {
this.$store.commit('app/hideExitConfirm');
},
// 确认退出应用
confirmExitApp() {
// #ifdef APP-PLUS
plus.runtime.quit();
// #endif
// #ifndef APP-PLUS
this.$store.commit('app/hideExitConfirm');
// #endif
},
// 设置真机状态栏文字/图标颜色与底色(light=白色文字/蓝色底,dark=深色文字/白色底);非 App 端自动忽略
setAppStatusBarStyle(style) {
// #ifdef APP-PLUS
try {
if (typeof plus !== 'undefined' && plus.navigator) {
if (plus.navigator.setStatusBarStyle) {
plus.navigator.setStatusBarStyle(style);
}
// 首页顶部为深色渐变,状态栏底色需与页面顶部一致,让页面背景“包含”系统状态栏
if (plus.navigator.setStatusBarBackground) {
plus.navigator.setStatusBarBackground(style === 'light' ? '#106eff' : '#ffffff');
}
}
} catch (e) {
console.warn('[index] 设置状态栏样式失败:', e);
}
// #endif
},
async getLatestUserInfo() {
try {
const latestUser = await this.$store.dispatch('getUserInfo');
// 不再输出完整用户对象(可能含登录凭证),只保留用于排查的关键信息
console.log(
'[index] 用户信息已更新:',
latestUser?.store_name || '',
'菜单数:',
Array.isArray(latestUser?.menus) ? latestUser.menus.length : 0
);
if (latestUser && typeof latestUser === 'object') {
this.userInfo = latestUser;
return latestUser;
}
} catch (error) {
console.warn('拉取最新用户信息失败,回退本地用户缓存:', error);
}
const fallbackUser = this.$store.getters.user || this.userInfo || null;
if (fallbackUser && typeof fallbackUser === 'object') {
this.userInfo = fallbackUser;
return fallbackUser;
}
return null;
},
createDefaultDragPreviewSnapshot() {
return {
name: '未命名菜单',
color: '#2979ff',
isImageIcon: false,
resolvedIconName: 'grid',
resolvedIconSource: 'grid',
resolvedIconGlyph: this.fallbackIconGlyph || uviewIcons['uicon-grid'] || '\ue673'
};
},
createDragPreviewSnapshot(action) {
const normalized = this.normalizeAction(action);
if (!normalized) {
return this.createDefaultDragPreviewSnapshot();
}
const name = this.sanitizeText(normalized.name, '未命名菜单');
const color = this.sanitizeText(normalized.color, '#2979ff');
const rawSource = this.sanitizeText(normalized.resolvedIconSource, 'grid');
const isImageIcon = Boolean(normalized.isImageIcon) && rawSource.includes('/');
const resolvedIconName = isImageIcon
? 'grid'
: this.sanitizeText(normalized.resolvedIconName, 'grid');
const resolvedIconGlyph = this.sanitizeText(
normalized.resolvedIconGlyph,
uviewIcons[`uicon-${resolvedIconName}`] || this.fallbackIconGlyph || uviewIcons['uicon-grid'] || '\ue673'
);
return {
name,
color,
isImageIcon,
resolvedIconName,
resolvedIconSource: isImageIcon ? rawSource : resolvedIconName,
resolvedIconGlyph
};
},
sanitizeText(value, fallback = '') {
const text = String(value ?? '').trim();
if (!text || text === 'undefined' || text === 'null') {
return fallback;
}
return text;
},
normalizeAction(action) {
if (!action || typeof action !== 'object' || Array.isArray(action)) {
return null;
}
// 已归一化的对象直接复用,避免渲染链路里反复做字符串处理
if (action.__normalized === true) {
return action;
}
const name = this.sanitizeText(action.name || action.meta?.title, '未命名菜单');
const rawIcon = this.sanitizeText(action.icon || action.meta?.icon, 'grid');
const color = this.sanitizeText(action.color, '#2979ff');
const path = this.sanitizeText(action.path);
const component = this.sanitizeText(action.component);
const id = this.sanitizeText(action.id || action.menuId || component || path || name);
const isImageIcon = String(rawIcon).includes('/');
const resolvedIconName = isImageIcon
? rawIcon
: (() => {
const iconName = this.sanitizeText(rawIcon, 'grid').replace(/^uicon-/, '');
return VALID_UVIEW_ICON_NAMES.has(iconName) ? iconName : 'grid';
})();
const resolvedIconGlyph = isImageIcon
? (uviewIcons['uicon-grid'] || '\ue673')
: (uviewIcons[`uicon-${resolvedIconName}`] || uviewIcons['uicon-grid'] || '\ue673');
const normalized = {
...action,
id,
name,
icon: rawIcon,
color,
badge: Number(action.badge || 0),
path,
component,
resolvedIconName,
resolvedIconSource: resolvedIconName,
resolvedIconGlyph,
isImageIcon
};
// 非枚举标记:不会被 JSON 序列化,因此不会污染保存到本地的配置
Object.defineProperty(normalized, '__normalized', {
value: true,
enumerable: false
});
return normalized;
},
buildPageSlots(pageIndex, actions = this.displayQuickActions) {
const sourceActions = Array.isArray(actions)
? actions.map(item => this.normalizeAction(item)).filter(Boolean)
: [];
const start = Math.max(pageIndex, 0) * this.pageSize;
const items = sourceActions.slice(start, start + this.pageSize);
return Array.from({ length: this.pageSize }, (_, index) => {
const action = items[index] || null;
return {
index,
action,
key: action ? this.getMenuKey(action) : `drag-empty-slot-${pageIndex}-${index}`
};
});
},
refreshDragPageSnapshot(pageIndex = this.currentPage - 1) {
this.dragPageSnapshot = this.buildPageSlots(pageIndex);
},
ensureCurrentPageInRange() {
const maxPage = Math.max(this.totalPages, 1);
if (this.currentPage > maxPage) {
this.currentPage = maxPage;
}
if (this.currentPage < 1) {
this.currentPage = 1;
}
},
// silent: true 时不切换整页加载态,用于返回首页 / 切换主体后的静默刷新
async loadUserInfo({ silent = false } = {}) {
// 菜单加载会决定看板统计是否展示,必须先完成
await this.refreshQuickActions({ silent });
// 两个统计接口互不依赖,并行请求
await Promise.all([
this.loadDashboardStats(),
this.loadUnclaimedWaveCount()
]);
},
// 刷新快捷入口
async refreshQuickActions({ silent = false } = {}) {
if (!silent) {
this.isLoading = true;
}
try {
const latestUser = await this.getLatestUserInfo();
if (!latestUser) {
console.log('用户信息不可用,快捷入口置空');
this.hasReviewShippingMenu = false;
this.hasOrderPickingMenu = false;
this.quickActions = [];
this.ensureCurrentPageInRange();
return;
}
// 1. 获取用户当前可用的菜单
const userMenus = this.getUserMenus(latestUser);
const latestActions = this.processMenus(userMenus, null);
// 识别用户是否拥有复核发货 / 订单拣货功能菜单,用于展示看板统计
this.detectDashboardMenus(latestActions);
// 2. 从Vuex获取已固定的菜单
const savedFixedMenus = await this.$store.dispatch('setting/getValue', this.FIXED_MENU_KEY);
const hasSavedConfig = Array.isArray(savedFixedMenus);
// 3. 如果存在已保存的常用配置(包括空数组),优先按配置展示
if (hasSavedConfig) {
const validFixedMenus = this.validateAndFilterMenus(savedFixedMenus, latestActions);
console.log('按已保存常用菜单展示:', validFixedMenus);
this.quickActions = validFixedMenus.map(item => this.normalizeAction(item)).filter(Boolean);
this.ensureCurrentPageInRange();
return;
}
// 4. 如果没有有效的固定菜单,检查用户菜单
if (userMenus && userMenus.length > 0) {
console.log('从用户菜单生成快捷入口:', userMenus);
// 首次登录默认带出全部菜单,并将商品查询前置
const defaultQuickActions = this.prioritizeDefaultQuickActions(latestActions);
this.quickActions = defaultQuickActions.map(item => this.normalizeAction(item)).filter(Boolean);
await this.saveQuickActionsOrder();
} else {
// 5. 如果还是没有菜单,返回空数组
console.log('用户没有可用菜单');
this.quickActions = [];
}
this.ensureCurrentPageInRange();
} catch (error) {
console.error('刷新快捷入口失败:', error);
// 弱网 / 接口异常时保留已展示的菜单,避免把本地常用配置清空
this.ensureCurrentPageInRange();
if (!this.quickActions.length) {
uni.showToast({
title: '常用功能加载失败,请重试',
icon: 'none',
duration: 2000
});
}
} finally {
this.isLoading = false;
}
},
// 根据用户菜单识别看板相关功能(复核发货 / 订单拣货 / 领取快递面单)
detectDashboardMenus(actions) {
const list = Array.isArray(actions) ? actions.filter(Boolean) : [];
let hasReviewShipping = false;
let hasOrderPicking = false;
let hasClaimShipping = false;
list.forEach((item) => {
const name = this.sanitizeText(item?.name);
if (!name) {
return;
}
if (!hasReviewShipping && isReviewShippingMenuName(name)) {
hasReviewShipping = true;
}
if (!hasOrderPicking && isOrderPickingMenuName(name)) {
hasOrderPicking = true;
}
if (!hasClaimShipping && isClaimShippingMenuName(name)) {
hasClaimShipping = true;
}
});
this.hasReviewShippingMenu = hasReviewShipping;
this.hasOrderPickingMenu = hasOrderPicking;
this.hasClaimShippingMenu = hasClaimShipping;
},
// 加载仓库/货主看板统计
async loadDashboardStats() {
if (!this.hasReviewShippingMenu && !this.hasOrderPickingMenu) {
this.dashboardStats = null;
return;
}
try {
const response = await this.$http('dashboard.storeStats', {}, '', false);
if (response && response.flag === 'success' && response.data) {
this.dashboardStats = response.data;
} else {
this.dashboardStats = null;
}
} catch (error) {
console.warn('[index] 看板统计加载失败:', error);
this.dashboardStats = null;
}
},
// 加载「未领料波次」数量(order.wave.confirmPrintUnclaimedWaveCount)
// 仅同时拥有「领取快递面单」与「订单拣货」菜单时展示
async loadUnclaimedWaveCount() {
if (!this.hasClaimShippingMenu || !this.hasOrderPickingMenu) {
this.unclaimedWaveCount = 0;
return;
}
try {
const res = await this.$http(
'order.wave.confirmPrintUnclaimedWaveCount',
{},
'',
false
);
const data = (res && res.data && typeof res.data === 'object' && !Array.isArray(res.data))
? res.data
: {};
const payload = { ...(res || {}), ...data };
const count = Number(payload.count);
this.unclaimedWaveCount = Number.isFinite(count) ? count : 0;
} catch (error) {
console.warn('[index] 未领料波次数量加载失败:', error);
this.unclaimedWaveCount = 0;
}
},
formatStatNumber(value) {
const num = Number(value);
return Number.isFinite(num) ? num : '--';
},
prioritizeDefaultQuickActions(actions) {
const source = Array.isArray(actions) ? actions.filter(Boolean) : [];
if (!source.length) {
return [];
}
// 用户权限菜单超过一页时,按固定优先级取前 pageSize 个(默认 3×3 = 9 个)
if (source.length > this.pageSize) {
const defaultMenuNames = [
'收货作业',
'商品查询',
'订单拣货',
'散单波次策略',
'团购波次策略',
'散单拣货详情',
'团购拣货详情',
'订单复核',
'随机入库',
'移库作业'
];
const selectedKeys = new Set();
const prioritized = [];
defaultMenuNames.forEach((targetName) => {
const matched = source.find((item) => {
const menuName = this.sanitizeText(item?.name || item?.meta?.title);
const key = this.getMenuKey(item);
return key && !selectedKeys.has(key) && menuName === targetName;
});
if (matched) {
const key = this.getMenuKey(matched);
selectedKeys.add(key);
prioritized.push(matched);
}
});
const remaining = source.filter((item) => {
const key = this.getMenuKey(item);
return key && !selectedKeys.has(key);
});
return [...prioritized, ...remaining].slice(0, this.pageSize);
}
// 不足一页时,商品查询置顶,其余全部显示
const selectedKeys = new Set();
const prioritized = [];
const goodsQuery = source.find((item) => {
const menuName = this.sanitizeText(item?.name || item?.meta?.title);
const key = this.getMenuKey(item);
return key && menuName === '商品查询';
});
if (goodsQuery) {
const key = this.getMenuKey(goodsQuery);
selectedKeys.add(key);
prioritized.push(goodsQuery);
}
const remaining = source.filter((item) => {
const key = this.getMenuKey(item);
return key && !selectedKeys.has(key);
});
return [...prioritized, ...remaining];
},
// 辅助方法:验证和过滤菜单权限
validateAndFilterMenus(fixedMenus, latestActions) {
if (!Array.isArray(fixedMenus) || !Array.isArray(latestActions)) return [];
const actionMap = new Map();
latestActions.forEach(action => {
actionMap.set(this.getMenuKey(action), action);
});
return fixedMenus
.map(fixedMenu => {
const matched = actionMap.get(this.getMenuKey(fixedMenu));
if (!matched) return null;
return this.normalizeAction({
...matched,
...fixedMenu,
name: matched.name,
path: matched.path,
component: matched.component,
icon: matched.icon || fixedMenu.icon,
id: matched.id || fixedMenu.id
});
})
.filter(Boolean);
},
getMenuKey(menu) {
return this.sanitizeText(
menu?.component ||
menu?.path ||
menu?.id ||
menu?.menuId ||
menu?.name ||
'',
''
);
},
getTouchPoint(event) {
const fallbackPoint = event?.detail?.x || event?.detail?.y
? {
pageX: event.detail.x,
pageY: event.detail.y
}
: null;
const touch = event?.touches?.[0] || event?.changedTouches?.[0] || fallbackPoint;
return {
x: Number(touch?.pageX || touch?.clientX || 0),
y: Number(touch?.pageY || touch?.clientY || 0)
};
},
bindGlobalDragListeners() {
if (typeof window === 'undefined' || this._globalDragListenersBound) {
return;
}
this._globalTouchMoveHandler = (event) => {
if (!this.dragState.active) {
return;
}
if (typeof event.preventDefault === 'function') {
event.preventDefault();
}
this.onDragMove(event);
};
this._globalTouchEndHandler = (event) => {
if (!this.dragState.active) {
return;
}
this.endDrag(event);
};
window.addEventListener('touchmove', this._globalTouchMoveHandler, { passive: false });
window.addEventListener('touchend', this._globalTouchEndHandler, { passive: false });
window.addEventListener('touchcancel', this._globalTouchEndHandler, { passive: false });
this._globalDragListenersBound = true;
},
unbindGlobalDragListeners() {
if (typeof window === 'undefined' || !this._globalDragListenersBound) {
return;
}
window.removeEventListener('touchmove', this._globalTouchMoveHandler);
window.removeEventListener('touchend', this._globalTouchEndHandler);
window.removeEventListener('touchcancel', this._globalTouchEndHandler);
this._globalTouchMoveHandler = null;
this._globalTouchEndHandler = null;
this._globalDragListenersBound = false;
},
enterQuickActionRemoveMode() {
if (this.dragState.active) {
return;
}
this.quickActionRemoveMode = true;
},
exitQuickActionRemoveMode() {
this.quickActionRemoveMode = false;
},
handleQuickActionLongPress(event, item, pageIndex, index) {
if (!item || this.dragState.active) {
return;
}
// 长按只负责排序;移除必须在标题栏「管理」里显式开启,避免误删
this.onGridItemLongPress(event, item, pageIndex, index);
},
onGridItemLongPress(event, item, pageIndex, index) {
if (this.dragState.active) {
return;
}
const point = this.getTouchPoint(event);
this.startDragWithPoint(item, pageIndex, index, point);
},
async removeQuickAction(item) {
const targetKey = this.getMenuKey(item);
if (!targetKey) {
return;
}
const removeIndex = this.quickActions.findIndex(action => this.getMenuKey(action) === targetKey);
const nextActions = this.quickActions.filter(action => this.getMenuKey(action) !== targetKey);
if (nextActions.length === this.quickActions.length) {
return;
}
this.quickActions = nextActions;
this.ensureCurrentPageInRange();
if (!this.quickActions.length) {
this.quickActionRemoveMode = false;
}
this.showUndoBar(this.normalizeAction(item), removeIndex);
await this.saveQuickActionsOrder();
const tools = this.$tools;
if (tools && typeof tools.speakText === 'function') {
try {
const task = tools.speakText('已移出常用功能');
if (task && typeof task.catch === 'function') {
task.catch(error => {
console.warn('[HomeIndex] 语音播报失败:', error);
});
}
} catch (error) {
console.warn('[HomeIndex] 语音播报异常:', error);
}
}
},
showUndoBar(item, index) {
if (!item) {
return;
}
this.clearUndoTimer();
this.undoAction = {
item,
index: Math.max(index, 0)
};
this._undoTimer = setTimeout(() => {
this.undoAction = null;
this._undoTimer = null;
}, 3000);
},
clearUndoTimer() {
if (this._undoTimer) {
clearTimeout(this._undoTimer);
this._undoTimer = null;
}
},
async undoRemoveAction() {
const undo = this.undoAction;
if (!undo || !undo.item) {
return;
}
this.clearUndoTimer();
this.undoAction = null;
const undoKey = this.getMenuKey(undo.item);
if (!undoKey || this.quickActions.some(action => this.getMenuKey(action) === undoKey)) {
return;
}
const nextActions = [...this.quickActions];
const insertIndex = Math.min(Math.max(undo.index, 0), nextActions.length);
nextActions.splice(insertIndex, 0, undo.item);
this.quickActions = nextActions;
this.ensureCurrentPageInRange();
await this.saveQuickActionsOrder();
},
handleWrapperTouchStart(event) {
if (this.dragState.active) {
return;
}
const point = this.getTouchPoint(event);
this.wrapperGesture = {
startX: point.x,
startY: point.y,
deltaX: 0,
deltaY: 0,
startTime: Date.now()
};
},
handleWrapperTouchMove(event) {
if (!this.dragState.active) {
const point = this.getTouchPoint(event);
this.wrapperGesture.deltaX = point.x - this.wrapperGesture.startX;
this.wrapperGesture.deltaY = point.y - this.wrapperGesture.startY;
return;
}
// 拖动中同一次 touchmove 也会命中全局监听,这里跳过避免重复计算
if (this._globalDragListenersBound) {
return;
}
if (typeof event?.preventDefault === 'function') {
event.preventDefault();
}
if (typeof event?.stopPropagation === 'function') {
event.stopPropagation();
}
this.onDragMove(event);
},
handleWrapperTouchEnd() {
if (this.dragState.active) {
this.endDrag();
return;
}
const { deltaX, deltaY, startTime } = this.wrapperGesture;
const duration = startTime ? (Date.now() - startTime) : 0;
if (duration > 0 && duration < 320 && Math.abs(deltaX) > 50 && Math.abs(deltaX) > Math.abs(deltaY) + 12) {
if (deltaX < 0 && this.currentPage < this.totalPages) {
this.currentPage += 1;
} else if (deltaX > 0 && this.currentPage > 1) {
this.currentPage -= 1;
}
}
this.wrapperGesture = {
startX: 0,
startY: 0,
deltaX: 0,
deltaY: 0,
startTime: 0
};
},
isDraggingItem(item) {
return this.dragState.active && this.getMenuKey(item) === this.dragState.key;
},
async captureCurrentPageSlots(pageIndex) {
return new Promise((resolve) => {
const query = uni.createSelectorQuery().in(this);
query.select(`#grid-page-${pageIndex}`).boundingClientRect();
query.selectAll(`.page-slot-${pageIndex}`).boundingClientRect();
query.exec((res) => {
resolve({
pageRect: res?.[0] || null,
slotRects: res?.[1] || []
});
});
});
},
async startDragWithPoint(item, pageIndex, index, startPoint) {
if (!item || this.dragState.active || this.quickActions.length <= 1) {
return;
}
const point = startPoint || { x: 0, y: 0 };
this.suppressItemClick = true;
const safeItem = this.normalizeAction(item);
const originalIndex = this.quickActions.findIndex(action => this.getMenuKey(action) === this.getMenuKey(safeItem));
this.dragPreviewSnapshot = this.createDragPreviewSnapshot(safeItem);
this.dragState = {
active: true,
item: safeItem,
key: this.getMenuKey(safeItem),
originalIndex,
pageIndex,
hoverIndex: originalIndex >= 0 ? originalIndex : (pageIndex * this.pageSize + index),
previewX: (point.x || 0) - 60,
previewY: (point.y || 0) - 60,
slotRects: [],
pageRect: null
};
this.refreshDragPageSnapshot(pageIndex);
this.bindGlobalDragListeners();
const { pageRect, slotRects } = await this.captureCurrentPageSlots(pageIndex);
if (!this.dragState.active) {
return;
}
if (pageRect && slotRects && slotRects.length) {
const slotRect = slotRects[index] || slotRects[0];
const dragStartPoint = (point.x || point.y)
? point
: {
x: (slotRect?.left || 0) + ((slotRect?.width || 0) / 2),
y: (slotRect?.top || 0) + ((slotRect?.height || 0) / 2)
};
this.dragState = {
...this.dragState,
previewX: dragStartPoint.x - ((slotRect?.width || 120) / 2),
previewY: dragStartPoint.y - ((slotRect?.height || 120) / 2),
slotRects,
pageRect
};
}
},
getPageAbsoluteIndex(pageIndex, slotIndex) {
const pageStart = pageIndex * this.pageSize;
return Math.min(pageStart + Math.max(slotIndex, 0), this.quickActions.length - 1);
},
async switchDragPage(targetPageIndex, point) {
if (!this.dragState.active || this.dragPageSwitching) {
return false;
}
if (targetPageIndex < 0 || targetPageIndex >= this.totalPages || targetPageIndex === this.dragState.pageIndex) {
return false;
}
this.dragPageSwitching = true;
const fallbackIndex = targetPageIndex < this.dragState.pageIndex
? Math.min(((targetPageIndex + 1) * this.pageSize) - 1, this.quickActions.length - 1)
: Math.min(targetPageIndex * this.pageSize, this.quickActions.length - 1);
let nextHoverIndex = fallbackIndex;
const preciseSlotIndex = this.findClosestSlotIndex(point);
if (preciseSlotIndex >= 0) {
nextHoverIndex = this.getPageAbsoluteIndex(targetPageIndex, preciseSlotIndex);
}
this.dragState = {
...this.dragState,
pageIndex: targetPageIndex,
hoverIndex: nextHoverIndex
};
this.currentPage = targetPageIndex + 1;
this.refreshDragPageSnapshot(targetPageIndex);
await this.$nextTick();
await new Promise(resolve => setTimeout(resolve, 16));
const { pageRect, slotRects } = await this.captureCurrentPageSlots(targetPageIndex);
if (pageRect && slotRects && slotRects.length) {
this.dragState = {
...this.dragState,
pageRect,
slotRects
};
const refreshedSlotIndex = this.findClosestSlotIndex(point);
if (refreshedSlotIndex >= 0) {
this.dragState.hoverIndex = this.getPageAbsoluteIndex(targetPageIndex, refreshedSlotIndex);
this.refreshDragPageSnapshot(targetPageIndex);
}
}
this.dragPageSwitching = false;
return true;
},
async maybeSwitchDragPage(point) {
if (this.dragPageSwitching) {
return true;
}
const pageRect = this.dragState.pageRect;
if (!pageRect) {
return false;
}
const edgeThreshold = 50;
if (point.x <= pageRect.left + edgeThreshold && this.dragState.pageIndex > 0) {
return this.switchDragPage(this.dragState.pageIndex - 1, point);
}
if (point.x >= pageRect.right - edgeThreshold && this.dragState.pageIndex < this.totalPages - 1) {
return this.switchDragPage(this.dragState.pageIndex + 1, point);
}
return false;
},
findClosestSlotIndex(point) {
const { slotRects } = this.dragState;
if (!Array.isArray(slotRects) || !slotRects.length) {
return -1;
}
let closestIndex = -1;
let minDistance = Infinity;
slotRects.forEach((rect, index) => {
if (!rect) {
return;
}
const inside = point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.bottom;
if (inside) {
closestIndex = index;
minDistance = 0;
return;
}
if (minDistance === 0) {
return;
}
const centerX = rect.left + rect.width / 2;
const centerY = rect.top + rect.height / 2;
const distance = Math.pow(point.x - centerX, 2) + Math.pow(point.y - centerY, 2);
if (distance < minDistance) {
minDistance = distance;
closestIndex = index;
}
});
return closestIndex;
},
reorderQuickActions(dragKey, targetIndex) {
const fromIndex = this.quickActions.findIndex(item => this.getMenuKey(item) === dragKey);
if (fromIndex < 0) {
return;
}
const maxIndex = Math.max(this.quickActions.length - 1, 0);
const safeTargetIndex = Math.min(Math.max(targetIndex, 0), maxIndex);
if (fromIndex === safeTargetIndex) {
return;
}
const nextActions = [...this.quickActions];
const [movedItem] = nextActions.splice(fromIndex, 1);
if (!movedItem) {
return;
}
nextActions.splice(safeTargetIndex, 0, movedItem);
this.quickActions = nextActions.filter(Boolean);
this.ensureCurrentPageInRange();
},
async onDragMove(event) {
if (!this.dragState.active) {
return;
}
if (typeof event?.preventDefault === 'function') {
event.preventDefault();
}
const point = this.getTouchPoint(event);
this.dragState.previewX = point.x - 60;
this.dragState.previewY = point.y - 60;
const switched = await this.maybeSwitchDragPage(point);
if (switched) {
return;
}
const slotIndex = this.findClosestSlotIndex(point);
if (slotIndex < 0) {
return;
}
const pageStart = this.dragState.pageIndex * this.pageSize;
const targetIndex = Math.min(pageStart + slotIndex, this.quickActions.length - 1);
// 只在目标格子变化时才重建页面快照,避免每个 touchmove 都重算
if (this.dragState.hoverIndex === targetIndex) {
return;
}
this.dragState.hoverIndex = targetIndex;
this.refreshDragPageSnapshot(this.dragState.pageIndex);
},
async saveQuickActionsOrder() {
if (this.isSavingOrder) {
// 保存中又发生变更:标记待保存,本轮结束后补存最新顺序
this._pendingSaveOrder = true;
return;
}
this.isSavingOrder = true;
try {
const normalizedActions = this.quickActions.map(item => this.normalizeAction(item)).filter(Boolean);
this.quickActions = normalizedActions;
await this.$store.dispatch('setting/setValue', {
key: this.FIXED_MENU_KEY,
value: normalizedActions
});
} catch (error) {
console.error('保存常用功能排序失败:', error);
uni.showToast({
title: '排序保存失败',
icon: 'none'
});
} finally {
this.isSavingOrder = false;
if (this._pendingSaveOrder) {
this._pendingSaveOrder = false;
this.saveQuickActionsOrder();
}
}
},
async endDrag() {
if (!this.dragState.active) {
this.unbindGlobalDragListeners();
return;
}
const finalHoverIndex = this.dragState.hoverIndex >= 0
? this.dragState.hoverIndex
: this.dragState.originalIndex;
if (finalHoverIndex >= 0 && finalHoverIndex !== this.dragState.originalIndex) {
this.reorderQuickActions(this.dragState.key, finalHoverIndex);
}
if (finalHoverIndex >= 0) {
this.currentPage = Math.floor(finalHoverIndex / this.pageSize) + 1;
}
this.ensureCurrentPageInRange();
this.dragState = {
active: false,
item: null,
key: '',
originalIndex: -1,
pageIndex: -1,
hoverIndex: -1,
previewX: 0,
previewY: 0,
slotRects: [],
pageRect: null
};
this.dragPreviewSnapshot = this.createDefaultDragPreviewSnapshot();
this.dragPageSnapshot = [];
this.dragPageSwitching = false;
this.unbindGlobalDragListeners();
this.suppressItemClick = false;
await this.saveQuickActionsOrder();
},
handleGridItemClick(item) {
if (this.dragState.active || this.suppressItemClick || this.quickActionRemoveMode) {
return;
}
this.toPath(item);
},
// 获取用户菜单
getUserMenus(userData = null) {
const user = userData || this.userInfo || this.$store.getters.user;
if (!user) return [];
// 从用户信息中获取菜单
return user.menus || user.permissions || [];
},
// 处理菜单数据:展平一级子菜单 → 过滤有效项 → 可选数量限制 → 统一格式
processMenus(menus, limit = null) {
if (!Array.isArray(menus)) {
return [];
}
const allChildren = [];
menus.forEach((item) => {
if (item && Array.isArray(item.children)) {
allChildren.push(...item.children);
}
});
let validMenus = allChildren.filter(menu =>
menu &&
menu.component &&
menu.component !== 'Layout' &&
menu.meta &&
menu.meta.title
);
// limit 为 null/0 时不限制数量
if (typeof limit === 'number' && limit > 0) {
validMenus = validMenus.slice(0, limit);
}
return validMenus.map(menu => ({
id: menu.id || menu.menuId || menu.component || menu.path || menu.meta?.title || '',
name: menu.meta?.title || '未命名菜单',
path: menu.path || '',
component: menu.component || '',
permissions: menu.permissions || [],
icon: menu.meta?.icon || '',
color: this.pickMenuColor(menu.component || menu.path || menu.id || menu.meta?.title || ''),
isFixed: true
}));
},
// 同一菜单始终得到同一颜色,避免每次刷新配色乱跳
pickMenuColor(key) {
const text = String(key || '');
let hash = 0;
for (let i = 0; i < text.length; i += 1) {
hash = ((hash * 31) + text.charCodeAt(i)) % 100000007;
}
return MENU_COLOR_POOL[hash % MENU_COLOR_POOL.length];
},
showStoreSelector() {
if (!this.userInfo.employees || this.userInfo.employees.length <= 1) {
return;
}
// 提取店铺名称列表
const storeList = this.userInfo.employees.map(emp => emp.store_name);
uni.showActionSheet({
itemList: storeList,
success: (res) => {
const selectedIndex = res.tapIndex;
if (selectedIndex >= 0 && selectedIndex < this.userInfo.employees.length) {
const selectedEmployee = this.userInfo.employees[selectedIndex];
this.handleStoreSwitch(selectedEmployee);
}
},
fail: (err) => {
console.log('用户取消选择', err);
}
});
},
async handleStoreSwitch(selectedEmployee) {
uni.showLoading({
title: '切换中...',
mask: true
});
try {
await this.$store.dispatch('changeEmployee', selectedEmployee.id);
await this.loadUserInfo({ silent: true });
} catch (error) {
console.error('切换主体失败:', error);
uni.showToast({
title: '切换失败,请重试',
icon: 'none'
});
} finally {
uni.hideLoading();
}
},
// 按 component/path + 菜单名解析目标路由,规则表见 MENU_ROUTE_RULES
resolveMenuRoute(item) {
const name = String(item?.name || '').trim();
const normalizedPath = this.normalizeMenuPath(item);
for (let i = 0; i < MENU_ROUTE_RULES.length; i += 1) {
const rule = MENU_ROUTE_RULES[i];
if (Array.isArray(rule.paths) && normalizedPath && rule.paths.includes(normalizedPath)) {
return rule;
}
if (this.matchesMenuRule(name, rule)) {
return rule;
}
}
return null;
},
matchesMenuRule(name, rule) {
if (typeof rule.test === 'function') {
return Boolean(rule.test(name));
}
if (Array.isArray(rule.names) && rule.names.includes(name)) {
return true;
}
if (Array.isArray(rule.all) && rule.all.every(key => name.includes(key))) {
return true;
}
if (Array.isArray(rule.any) && rule.any.some(key => name.includes(key))) {
return true;
}
return false;
},
normalizeMenuPath(item) {
const rawPath = item?.component || item?.path || '';
return rawPath ? (rawPath.startsWith('/') ? rawPath : `/${rawPath}`) : '';
},
toPath(item) {
const rule = this.resolveMenuRoute(item);
if (rule && rule.block) {
uni.showToast({
title: rule.block,
icon: 'none',
duration: 2500
});
return;
}
const targetPath = (rule && rule.path) ? rule.path : this.normalizeMenuPath(item);
if (!targetPath) {
uni.showToast({
title: '功能暂未开放',
icon: 'none',
duration: 1500
});
return;
}
this.$tools.routerTo(targetPath);
},
openNoticePopup() {
if (!this.noticeStatItems.length) {
return;
}
this.showNoticePopup = true;
},
closeNoticePopup() {
this.showNoticePopup = false;
},
toEditPage() {
uni.navigateTo({
url: '/pages/home/edit-quick-actions'
});
},
retryLoad() {
if (this.isLoading) {
return;
}
this.loadUserInfo();
},
prevPage() {
if (this.dragState.active) {
return;
}
if (this.currentPage > 1) {
this.currentPage--;
}
},
nextPage() {
if (this.dragState.active) {
return;
}
if (this.currentPage < this.totalPages) {
this.currentPage++;
}
}
}
}
</script>
<style lang="scss" scoped>
// 本地静态字体(原为 https://at.alicdn.com/font_2225171_8kdcwk4po24.ttf)
@font-face {
font-family: 'uicon-iconfont';
src: url('~@/static/fonts/uicon-iconfont.ttf') format('truetype');
}
// 首页各面板之间统一垂直间隔(数据面板 → 走马灯 → 常用功能 两段一致)
$home-panel-gap: 24rpx;
.pda-home {
display: flex;
flex-direction: column;
/* App 端 webview 高度已扣除原生 tabBar,100vh 即为 tabBar 顶边以上高度 */
min-height: 100vh;
/* #ifdef H5 */
/* H5 的 100vh 包含 tabBar 区域,扣除底部导航高度,避免内容被 tabBar 遮挡 */
min-height: calc(100vh - var(--window-bottom, 0px));
/* #endif */
// 顶部蓝色向下逐渐过渡到页面浅蓝,形成层次
background: linear-gradient(
180deg,
#106eff 0%,
#3d80ff 240rpx,
#a9c8ff 480rpx,
#f2f8ff 760rpx
);
}
// 状态栏区域使用与首页顶部渐变起点一致的纯色,保证页面背景“包含”系统状态栏(覆盖 App.vue 中全局的白色 .status_bar)
.pda-home > .status_bar {
flex-shrink: 0;
background: #106eff;
}
// 紧凑型头部(透明,叠在页面顶部渐变上)
.compact-header {
position: relative;
padding: 16rpx 24rpx 0;
// 数据条与跑马灯之间的间距(数据条被 v-if 隐藏时自动失效)
.stat-strip + .org-switcher {
margin-top: $home-panel-gap;
}
.org-switcher {
display: flex;
align-items: center;
.news-wrapper {
flex: 1;
min-width: 0;
overflow: hidden;
.news-pill {
display: flex;
align-items: center;
height: 72rpx;
padding: 0 18rpx;
background: #ffffff;
border: 1rpx solid transparent;
border-radius: 36rpx;
box-shadow: 0 4rpx 12rpx rgba(6, 45, 120, 0.10);
box-sizing: border-box;
overflow: hidden;
&__icon {
flex-shrink: 0;
display: flex;
align-items: center;
margin-right: 10rpx;
}
&__arrow {
flex-shrink: 0;
margin-left: 10rpx;
}
&__body {
flex: 1;
min-width: 0;
overflow: hidden;
.news-marquee {
width: 100%;
height: 72rpx;
display: flex;
align-items: center;
overflow: hidden;
&__track {
display: inline-flex;
align-items: center;
white-space: nowrap;
will-change: transform;
animation: news-marquee-scroll 12s linear infinite;
}
&__track.is-paused {
animation-play-state: paused;
}
&__text {
display: inline-block;
white-space: nowrap;
padding-right: 60rpx;
font-size: 26rpx;
color: #ff8c42;
}
}
}
}
}
}
// 顶部导航栏:通知信息弹窗的数据内容
.stat-strip {
display: flex;
align-items: stretch;
.stat-item {
flex: 1;
min-width: 0;
height: 140rpx;
box-sizing: border-box;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
padding: 20rpx 8rpx;
background: rgba(255, 255, 255, 0.18);
backdrop-filter: blur(12rpx);
-webkit-backdrop-filter: blur(12rpx);
border: 1rpx solid rgba(255, 255, 255, 0.2);
border-radius: 14rpx;
& + .stat-item {
margin-left: 12rpx;
}
&:active {
background: rgba(255, 255, 255, 0.3);
}
&__value {
font-size: 36rpx;
font-weight: bold;
color: #ffffff;
line-height: 1.1;
font-variant-numeric: tabular-nums;
}
&__label {
margin-top: 14rpx;
max-width: 100%;
font-size: 22rpx;
color: rgba(255, 255, 255, 0.88);
line-height: 1.2;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
}
}
}
// 顶部公告无缝滚动
@keyframes news-marquee-scroll {
from {
transform: translateX(0);
}
to {
transform: translateX(-50%);
}
}
// 骨架屏呼吸
@keyframes skeleton-pulse {
0%, 100% {
opacity: 1;
}
50% {
opacity: 0.45;
}
}
// 主内容区:父级高度由内容撑开,保留纵向滚动能力,避免小屏裁切
.main-scroll {
flex: 1;
min-height: 0;
overflow-y: auto;
-webkit-overflow-scrolling: touch;
}
// 快捷入口区域(按内容高度显示,不再强制撑到 tabBar)
.quick-section {
padding: 20rpx 20rpx 12rpx;
background: #ffffff;
margin: $home-panel-gap 20rpx 20rpx;
border-radius: 20rpx;
box-shadow: 0 6rpx 24rpx rgba(15, 23, 42, 0.05);
.section-title-bar {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 30rpx;
padding-bottom: 12rpx;
border-bottom: 1rpx solid #f2f4f7;
.title-left {
display: flex;
align-items: center;
min-width: 0;
.title-accent {
width: 6rpx;
height: 28rpx;
border-radius: 3rpx;
background: #2979ff;
margin-right: 12rpx;
}
.section-title {
font-size: 32rpx;
font-weight: 600;
color: #1f2329;
}
.drag-tip {
margin-left: 12rpx;
font-size: 24rpx;
color: #a8adb5;
}
}
.title-right {
display: flex;
align-items: center;
flex-shrink: 0;
.done-btn,
.manage-btn {
font-size: 30rpx;
font-weight: 500;
color: #2979ff;
padding: 10rpx 16rpx;
border-radius: 10rpx;
&:active {
background: #f0f7ff;
}
}
.edit-btn {
display: flex;
align-items: center;
margin-left: 16rpx;
padding: 10rpx 20rpx;
border-radius: 28rpx;
background: #f2f7ff;
line-height: 1;
&:active {
background: #e6f0ff;
}
.edit-btn__text {
font-size: 30rpx;
font-weight: 500;
color: #2979ff;
line-height: 1;
}
.u-icon {
margin-left: 6rpx;
}
}
}
}
}
// 网格容器
.quick-grid-container {
display: flex;
align-items: center;
margin-bottom: 4rpx;
.nav-arrow {
flex: 0 0 48rpx;
width: 48rpx;
height: 96rpx;
display: flex;
align-items: center;
justify-content: center;
border-radius: 24rpx;
background: #f5f7fa;
&:active:not(.disabled) {
background: #e9edf3;
}
&.disabled {
opacity: 0.3;
}
}
.quick-grid-wrapper {
flex: 1;
display: flex;
flex-direction: column;
align-items: center;
position: relative;
.quick-page-shell {
width: 100%;
min-height: 0;
}
.grid-page {
display: grid;
grid-template-columns: repeat(3, 1fr);
// 3 列 × 3 行,每页 9 个
grid-template-rows: repeat(3, auto);
gap: 10rpx;
padding: 0 10rpx;
.grid-item {
// 预留两行名称的高度(图标 92 + 间距 8 + 两行名称 90),
// 保证 1 行 / 2 行名称时卡片高度一致,避免换行后卡片长高把底部挤出可视区
min-height: 190rpx;
box-sizing: border-box;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
position: relative;
border-radius: 16rpx;
transition: transform 0.18s ease, opacity 0.18s ease, background 0.18s ease;
.grid-item-touch-layer {
position: absolute;
left: 0;
top: 0;
right: 0;
bottom: 0;
z-index: 3;
background: transparent;
}
.remove-action-btn {
position: absolute;
top: 8rpx;
right: 8rpx;
z-index: 4;
width: 40rpx;
height: 40rpx;
display: flex;
align-items: center;
justify-content: center;
.remove-action-icon {
font-family: 'uicon-iconfont' !important;
font-size: 44rpx;
line-height: 1;
font-style: normal;
font-weight: normal;
color: #ff4d4f;
display: block;
}
}
.grid-item-content {
position: relative;
z-index: 1;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
width: 100%;
height: 100%;
pointer-events: none;
}
.item-icon-box {
width: 92rpx;
height: 92rpx;
border-radius: 18rpx;
display: flex;
align-items: center;
justify-content: center;
margin-bottom: 8rpx;
.item-icon-image {
width: 48rpx;
height: 48rpx;
}
.item-icon-font {
font-family: 'uicon-iconfont' !important;
font-size: 54rpx;
line-height: 1;
font-style: normal;
font-weight: normal;
display: block;
}
.drag-icon-placeholder {
width: 44rpx;
height: 44rpx;
display: grid;
grid-template-columns: repeat(2, 1fr);
grid-template-rows: repeat(2, 1fr);
gap: 6rpx;
&__dot {
width: 100%;
height: 100%;
background: currentColor;
border-radius: 8rpx;
display: block;
opacity: 0.72;
}
}
}
.item-name {
max-width: 100%;
// 名称区固定按两行占位(32rpx × 1.4 × 2 ≈ 90rpx),避免换行后撑高整格
min-height: 90rpx;
font-size: 32rpx;
font-weight: bold;
color: #333;
text-align: center;
line-height: 1.4;
padding: 0 6rpx;
word-break: break-all;
display: -webkit-box;
-webkit-box-orient: vertical;
-webkit-line-clamp: 2;
line-clamp: 2;
overflow: hidden;
}
.item-badge {
position: absolute;
top: 4rpx;
right: 4rpx;
}
&:active {
background: #f8f9fa;
}
&.drag-placeholder {
opacity: 0.2;
transform: scale(0.92);
}
&.drag-disabled {
transition: none;
}
&.empty-item {
opacity: 0;
}
}
}
.drag-preview {
position: fixed;
z-index: 999;
width: 140rpx;
height: 164rpx;
border-radius: 12rpx;
background: rgba(255, 255, 255, 0.96);
box-shadow: 0 12rpx 32rpx rgba(0, 0, 0, 0.16);
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
pointer-events: none;
transform: scale(1.05);
.preview-remove-action-icon {
position: absolute;
top: 8rpx;
right: 8rpx;
font-family: 'uicon-iconfont' !important;
font-size: 44rpx;
line-height: 1;
font-style: normal;
font-weight: normal;
color: #ff4d4f;
display: block;
}
.item-icon-box {
width: 92rpx;
height: 92rpx;
border-radius: 18rpx;
display: flex;
align-items: center;
justify-content: center;
margin-bottom: 8rpx;
.item-icon-image {
width: 48rpx;
height: 48rpx;
}
.item-icon-font {
font-family: 'uicon-iconfont' !important;
font-size: 54rpx;
line-height: 1;
font-style: normal;
font-weight: normal;
display: block;
}
}
.item-name {
max-width: 100%;
font-size: 32rpx;
font-weight: bold;
color: #333;
text-align: center;
line-height: 1.4;
padding: 0 4rpx;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
}
}
}
// 分页指示器
.pagination-dots {
display: flex;
justify-content: center;
align-items: center;
margin-top: 16rpx;
.pagination-dot {
width: 8rpx;
height: 8rpx;
border-radius: 4rpx;
background: #dfe3e8;
margin: 0 5rpx;
transition: width 0.2s ease, background 0.2s ease;
&.active {
background: #2979ff;
width: 24rpx;
}
}
}
// 首次加载骨架屏
.skeleton-grid {
width: 100%;
display: grid;
grid-template-columns: repeat(3, 1fr);
grid-template-rows: repeat(3, auto);
gap: 10rpx;
padding: 0 10rpx;
box-sizing: border-box;
.skeleton-item {
// 与真实格子(两行名称预留后 190rpx)保持一致,避免加载完成时卡片高度跳变
min-height: 190rpx;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
}
.skeleton-icon {
width: 92rpx;
height: 92rpx;
border-radius: 18rpx;
margin-bottom: 8rpx;
background: #eef1f5;
animation: skeleton-pulse 1.2s ease-in-out infinite;
}
.skeleton-text {
width: 108rpx;
height: 28rpx;
border-radius: 14rpx;
background: #eef1f5;
animation: skeleton-pulse 1.2s ease-in-out infinite;
}
}
// 加载状态
.loading-state {
padding: 100rpx 0;
display: flex;
flex-direction: column;
align-items: center;
.loading-text {
margin-top: 20rpx;
color: #909399;
font-size: 24rpx;
}
}
// 空状态提示
.empty-state {
padding: 80rpx 0;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
.empty-text {
display: block;
font-size: 32rpx;
color: #999;
margin-top: 30rpx;
margin-bottom: 15rpx;
}
.empty-hint {
display: block;
font-size: 28rpx;
color: #ccc;
}
.empty-retry {
display: block;
margin-top: 24rpx;
padding: 14rpx 36rpx;
font-size: 28rpx;
color: #2979ff;
border: 1rpx solid #2979ff;
border-radius: 8rpx;
}
}
// 移除撤销条
.undo-bar {
position: fixed;
left: 40rpx;
right: 40rpx;
bottom: 140rpx;
z-index: 1200;
display: flex;
align-items: center;
justify-content: space-between;
padding: 20rpx 28rpx;
background: rgba(51, 51, 51, 0.92);
border-radius: 12rpx;
box-shadow: 0 8rpx 24rpx rgba(0, 0, 0, 0.18);
&__text {
flex: 1;
min-width: 0;
font-size: 28rpx;
color: #ffffff;
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
&__btn {
flex-shrink: 0;
margin-left: 24rpx;
font-size: 30rpx;
font-weight: 600;
color: #4d9bff;
}
}
// 看板统计弹窗
.notice-popup {
padding: 32rpx 30rpx 40rpx;
&__header {
display: flex;
align-items: center;
justify-content: center;
margin-bottom: 30rpx;
padding-bottom: 24rpx;
border-bottom: 1rpx solid #f0f0f0;
}
&__title {
font-size: 38rpx;
font-weight: 600;
color: #333;
}
&__body {
max-height: 60vh;
}
&__grid {
display: flex;
flex-wrap: wrap;
margin: -12rpx;
}
&__item {
width: calc(33.333% - 24rpx);
margin: 12rpx;
background: #f6f8fb;
border-radius: 16rpx;
padding: 32rpx 12rpx;
display: flex;
flex-direction: column;
align-items: center;
box-sizing: border-box;
box-shadow: 0 2rpx 8rpx rgba(0, 0, 0, 0.03);
}
&__value {
font-size: 44rpx;
font-weight: 600;
color: #2979ff;
margin-bottom: 10rpx;
}
&__label {
font-size: 34rpx;
color: #909399;
}
}
/* 退出应用确认弹窗 */
.exit-app-mask {
position: fixed;
left: 0;
top: 0;
right: 0;
bottom: 0;
background: rgba(0, 0, 0, 0.48);
display: flex;
align-items: center;
justify-content: center;
z-index: 9999;
padding: 60rpx;
box-sizing: border-box;
}
.exit-app-dialog {
width: 100%;
max-width: 620rpx;
background: #fff;
border-radius: 20rpx;
padding: 40rpx 36rpx 36rpx;
box-sizing: border-box;
box-shadow: 0 24rpx 80rpx rgba(0, 0, 0, 0.18);
display: flex;
flex-direction: column;
align-items: center;
}
.exit-app-icon {
display: flex;
align-items: center;
justify-content: center;
}
.exit-app-title {
display: block;
text-align: center;
margin-top: 30rpx;
font-size: 36rpx;
font-weight: 600;
color: #303133;
}
.exit-app-desc {
display: block;
text-align: center;
margin-top: 16rpx;
font-size: 34rpx;
line-height: 1.6;
color: #606266;
}
.exit-app-actions {
display: flex;
width: 100%;
margin-top: 40rpx;
}
.exit-app-actions ::v-deep .u-button {
flex: 1;
height: 80rpx;
}
.exit-app-actions ::v-deep .u-button__text,
.exit-app-actions ::v-deep .u-button__loading-text {
font-size: 36rpx !important;
}
.exit-app-actions ::v-deep .u-button + .u-button {
margin-left: 20rpx;
}
</style>