383 lines
14 KiB
TypeScript
383 lines
14 KiB
TypeScript
import { get, post } from '../../utils/request/index'
|
|
import { leFuService } from '../../lefu/index'
|
|
import type { SyncUserData } from '../../lefu/index'
|
|
import { calcAge } from '../../utils/idCard/index'
|
|
|
|
/** 连接状态订阅句柄 */
|
|
let unsubDeviceConnect: (() => void) | null = null
|
|
let unsubDisconnected: (() => void) | null = null
|
|
/** 同步完成关闭弹框定时器 */
|
|
let syncCloseTimer: number | null = null
|
|
/** selectUserBySn/user 返回的单条结构 */
|
|
interface SysUserDevice {
|
|
id: string
|
|
userId: string
|
|
realname: string
|
|
height: number
|
|
birthday: string
|
|
sex: number
|
|
dataType: number
|
|
relationType: number | null
|
|
syncStatus?: number
|
|
}
|
|
|
|
/** 同步用的用户项 */
|
|
interface SyncUser {
|
|
id: string
|
|
userId: string
|
|
name: string
|
|
gender: number
|
|
age: number
|
|
height: number
|
|
sync: string
|
|
}
|
|
|
|
/** 展示用成员项 */
|
|
interface MemberItem {
|
|
id: string
|
|
userId: string
|
|
name: string
|
|
gender: string
|
|
age: number
|
|
height: number
|
|
sync: string
|
|
syncClass: string
|
|
}
|
|
|
|
/** 展示用分组 */
|
|
interface GroupItem {
|
|
title: string
|
|
members: MemberItem[]
|
|
}
|
|
|
|
/** 获取设备成员列表 */
|
|
const getDeviceMembers = (sn: string, userId: string) =>
|
|
get<SysUserDevice[]>('weighingScale/v3/selectUserBySn/user', { sn, userId })
|
|
|
|
/** 标记用户已同步到设备 */
|
|
const markSynced = (data: { sn: string; list: string[] }) =>
|
|
post('weighingScale/v6/markSynced', data, { loading: false })
|
|
|
|
/** equipment 页传入的目标设备 */
|
|
let targetDevice: { sn: string; deviceId: string; name: string; connected: boolean; connectDeviceInfo: string } | null = null
|
|
|
|
Page({
|
|
data: {
|
|
device: {
|
|
name: '智能体重秤',
|
|
status: false,
|
|
deviceId: '',
|
|
sn: ''
|
|
},
|
|
memberCount: 0,
|
|
hasData: false,
|
|
self: null as null | MemberItem,
|
|
groups: [] as GroupItem[],
|
|
syncShow: false,
|
|
syncPercent: 0,
|
|
syncStatus: ''
|
|
},
|
|
|
|
onLoad(options: Record<string, string>) {
|
|
targetDevice = {
|
|
sn: decodeURIComponent(options.sn || ''),
|
|
deviceId: decodeURIComponent(options.deviceId || ''),
|
|
name: decodeURIComponent(options.name || ''),
|
|
connected: options.status === 'true',
|
|
connectDeviceInfo: decodeURIComponent(options.connectDeviceInfo || ''),
|
|
}
|
|
this.setData({
|
|
'device.name': targetDevice.name || '智能体重秤',
|
|
'device.deviceId': targetDevice.deviceId,
|
|
'device.sn': targetDevice.sn,
|
|
'device.status': targetDevice.connected,
|
|
})
|
|
this._subscribeDeviceState()
|
|
this._loadMembers()
|
|
},
|
|
|
|
onUnload() {
|
|
unsubDeviceConnect?.()
|
|
unsubDisconnected?.()
|
|
unsubDeviceConnect = null
|
|
unsubDisconnected = null
|
|
if (syncCloseTimer !== null) { clearTimeout(syncCloseTimer); syncCloseTimer = null }
|
|
},
|
|
|
|
/** 订阅连接状态，实时同步设备卡（判断是否连接的目标设备） */
|
|
_subscribeDeviceState() {
|
|
unsubDeviceConnect?.()
|
|
unsubDisconnected?.()
|
|
unsubDeviceConnect = leFuService.onDeviceConnect(() => {
|
|
this.setData({ 'device.status': leFuService.lastRawDevice?.deviceId === targetDevice?.deviceId })
|
|
})
|
|
unsubDisconnected = leFuService.onDisconnected(() => {
|
|
this.setData({ 'device.status': false })
|
|
})
|
|
},
|
|
|
|
/** 拉取设备成员列表，映射到本人 + 员工/家庭用户分组 */
|
|
_loadMembers() {
|
|
if (!targetDevice?.sn) return
|
|
const userInfo = wx.getStorageSync('userInfo') as { userId?: string } | null
|
|
const userId = userInfo?.userId ?? ''
|
|
if (!userId) return
|
|
|
|
getDeviceMembers(targetDevice.sn, userId)
|
|
.then(res => {
|
|
const list = res.result
|
|
const toMember = (item: SysUserDevice): MemberItem => ({
|
|
id: item.id,
|
|
userId: item.userId,
|
|
name: item.realname,
|
|
gender: item.sex === 1 ? '男' : '女',
|
|
age: calcAge(item.birthday),
|
|
height: item.height,
|
|
sync: item.syncStatus === 1 ? '已同步' : '待同步',
|
|
syncClass: item.syncStatus === 1 ? 'done' : 'pending',
|
|
})
|
|
const self = list.find(m => m.relationType === 1)
|
|
this.setData({
|
|
self: self ? toMember(self) : null,
|
|
groups: [
|
|
{ title: '员工', members: list.filter(m => m.relationType !== 1 && m.dataType === 0).map(toMember) },
|
|
{ title: '家庭用户', members: list.filter(m => m.relationType !== 1 && m.dataType === 1).map(toMember) },
|
|
].filter(g => g.members.length),
|
|
memberCount: list.length,
|
|
hasData: list.length > 0,
|
|
})
|
|
})
|
|
.catch(() => {
|
|
wx.showToast({ title: '加载用户列表失败', icon: 'none' })
|
|
})
|
|
},
|
|
|
|
/** 校验是否连接的是目标设备：不是则弹框提示连接/取消 */
|
|
_ensureConnected(): boolean {
|
|
const connected = leFuService.isConnected && leFuService.lastRawDevice?.deviceId === targetDevice?.deviceId
|
|
if (connected) return true
|
|
this.setData({ 'device.status': false })
|
|
wx.showModal({
|
|
title: '未连接设备',
|
|
content: '请先连接该设备后再同步用户',
|
|
cancelText: '取消同步',
|
|
confirmText: '连接设备',
|
|
success: (res) => {
|
|
if (res.confirm) {
|
|
this._connectTargetDevice()
|
|
}
|
|
},
|
|
})
|
|
return false
|
|
},
|
|
|
|
/** 本页面扫描并连接目标设备 */
|
|
_connectTargetDevice() {
|
|
const targetDeviceId = targetDevice?.deviceId
|
|
if (!targetDeviceId) return
|
|
if (leFuService.isConnected) leFuService.disconnect()
|
|
|
|
wx.showLoading({ title: '连接中...', mask: true })
|
|
wx.openBluetoothAdapter({
|
|
success: () => {
|
|
let unsubList: (() => void) | null = null
|
|
let unsubConnect: (() => void) | null = null
|
|
const timer = setTimeout(() => {
|
|
unsubList?.()
|
|
unsubList = null
|
|
wx.hideLoading()
|
|
wx.showToast({ title: '未找到设备', icon: 'none' })
|
|
}, 15000)
|
|
|
|
unsubList = leFuService.onDevicesList((devices) => {
|
|
const matched = devices.find(d => d.raw.deviceId === targetDeviceId)
|
|
if (!matched) return
|
|
clearTimeout(timer)
|
|
unsubList?.()
|
|
unsubList = null
|
|
leFuService.stopScan()
|
|
leFuService.connect(matched.raw)
|
|
unsubConnect = leFuService.onDeviceConnect(() => {
|
|
unsubConnect?.()
|
|
unsubConnect = null
|
|
wx.hideLoading()
|
|
wx.setStorageSync('connectDeviceInfo', matched.raw)
|
|
this.setData({ 'device.status': true })
|
|
this.onTapSync()
|
|
})
|
|
})
|
|
leFuService.startScan()
|
|
},
|
|
fail: () => {
|
|
wx.hideLoading()
|
|
wx.showToast({ title: '蓝牙未开启', icon: 'none' })
|
|
},
|
|
})
|
|
},
|
|
|
|
/** 组装所有用户（本人第一个，作为主用户），性别：男=1 女=0 */
|
|
_buildAllUsers(): SyncUser[] {
|
|
const self = this.data.self
|
|
return [
|
|
...(self ? [{
|
|
id: self.id, userId: self.userId, name: self.name,
|
|
gender: self.gender === '男' ? 1 : 0,
|
|
age: self.age, height: self.height, sync: self.sync,
|
|
}] : []),
|
|
...this.data.groups.flatMap(g => g.members.map(m => ({
|
|
id: String(m.id), userId: m.userId, name: m.name,
|
|
gender: m.gender === '男' ? 1 : 0, age: m.age, height: m.height, sync: m.sync,
|
|
}))),
|
|
]
|
|
},
|
|
|
|
/** 同步完成后的统一处理：标记同步 + 更新列表状态 + 关闭弹框 */
|
|
_handleSyncSuccess(users: SyncUser[], successText: string) {
|
|
this.setData({ syncPercent: 100, syncStatus: '同步完成' })
|
|
wx.showToast({ title: successText, icon: 'success' })
|
|
const syncedIds = users.map(u => u.userId).filter(Boolean)
|
|
if (targetDevice?.sn && syncedIds.length) {
|
|
markSynced({ sn: targetDevice.sn, list: syncedIds })
|
|
.then(() => {
|
|
const syncedSet = new Set(syncedIds)
|
|
this.setData({
|
|
self: this.data.self && syncedSet.has(this.data.self.userId)
|
|
? { ...this.data.self, sync: '已同步', syncClass: 'done' }
|
|
: this.data.self,
|
|
groups: this.data.groups.map(g => ({
|
|
...g,
|
|
members: g.members.map(m => syncedSet.has(m.userId) ? { ...m, sync: '已同步', syncClass: 'done' } : m),
|
|
})),
|
|
})
|
|
})
|
|
.catch(() => {})
|
|
}
|
|
if (syncCloseTimer !== null) { clearTimeout(syncCloseTimer); syncCloseTimer = null }
|
|
syncCloseTimer = setTimeout(() => {
|
|
syncCloseTimer = null
|
|
this.setData({ syncShow: false })
|
|
}, 1000)
|
|
},
|
|
|
|
/** 同步用户至设备：只下发「待同步」的用户 */
|
|
onTapSync() {
|
|
if (!this._ensureConnected()) return
|
|
|
|
const allUsers = this._buildAllUsers()
|
|
if (!allUsers.length) {
|
|
wx.showToast({ title: '暂无用户可同步', icon: 'none' })
|
|
return
|
|
}
|
|
// 只下发「待同步」的用户
|
|
const pendingUsers = allUsers.filter(u => u.sync !== '已同步')
|
|
if (!pendingUsers.length) {
|
|
wx.showToast({ title: '没有需要同步的用户', icon: 'none' })
|
|
return
|
|
}
|
|
|
|
// 先读设备端主用户列表，判断设备是否已有主用户
|
|
leFuService.fetchDeviceUserIds()
|
|
.then((deviceUserIds) => this._syncUsers(pendingUsers, deviceUserIds))
|
|
.catch(() => {
|
|
wx.showToast({ title: '读取设备用户失败', icon: 'none' })
|
|
})
|
|
},
|
|
|
|
/** 根据设备端主用户情况组装并下发（一主九子，子用户挂在主用户下） */
|
|
_syncUsers(pendingUsers: SyncUser[], deviceUserIds: any) {
|
|
// dataFetchUserID 只返回主用户，非空表示设备已有主用户
|
|
const userIds = Array.isArray(deviceUserIds) ? deviceUserIds : [deviceUserIds].filter(Boolean)
|
|
const hasMainUser = userIds.length > 0
|
|
// 主用户 ID：已有主用户用设备端的，否则用第一个用户作为主用户
|
|
const mainUserId = hasMainUser ? String(userIds[0]) : pendingUsers[0].id
|
|
|
|
const syncDataList: SyncUserData[] = pendingUsers.map((user, index) => ({
|
|
userID: mainUserId,
|
|
userName: user.name,
|
|
memberID: hasMainUser ? user.id : (user.id === pendingUsers[0].id ? '' : user.id),
|
|
age: user.age,
|
|
gender: user.gender,
|
|
height: user.height,
|
|
isAthleteMode: 0,
|
|
deviceHeaderIndex: index,
|
|
currentWeight: '',
|
|
targetWeight: '',
|
|
idealWeight: '',
|
|
recentData: [],
|
|
}))
|
|
|
|
this.setData({ syncShow: true, syncPercent: 0, syncStatus: '正在同步信息，请勿离开...' })
|
|
leFuService.syncMembersToDevice(syncDataList, (current, total) => {
|
|
this.setData({
|
|
syncPercent: Math.round((current / total) * 100),
|
|
syncStatus: `正在同步 ${current}/${total}...`,
|
|
})
|
|
})
|
|
.then(() => this._handleSyncSuccess(pendingUsers, '用户同步成功'))
|
|
.catch((err: Error) => {
|
|
this.setData({ syncShow: false })
|
|
wx.showToast({ title: err.message || '同步失败，请重试', icon: 'none' })
|
|
})
|
|
},
|
|
|
|
/** 长按标题：清除设备用户信息并全部重新下发 */
|
|
onLongPressSectionTitle() {
|
|
if (!this._ensureConnected()) return
|
|
const allUsers = this._buildAllUsers()
|
|
if (!allUsers.length) {
|
|
wx.showToast({ title: '暂无用户可下发', icon: 'none' })
|
|
return
|
|
}
|
|
this._resendAllUsers(allUsers)
|
|
},
|
|
|
|
/** 清除设备用户后全部重新下发 */
|
|
_resendAllUsers(allUsers: SyncUser[]) {
|
|
const mainUser = allUsers[0]
|
|
const syncDataList: SyncUserData[] = allUsers.map((user, index) => ({
|
|
userID: mainUser.id,
|
|
userName: user.name,
|
|
memberID: user.id === mainUser.id ? '' : user.id,
|
|
age: user.age,
|
|
gender: user.gender,
|
|
height: user.height,
|
|
isAthleteMode: 0,
|
|
deviceHeaderIndex: index,
|
|
currentWeight: '',
|
|
targetWeight: '',
|
|
idealWeight: '',
|
|
recentData: [],
|
|
}))
|
|
|
|
this.setData({ syncShow: true, syncPercent: 0, syncStatus: '正在清空并重新下发...' })
|
|
leFuService.clearDeviceMembers()
|
|
.then(() => leFuService.syncMembersToDevice(syncDataList, (current, total) => {
|
|
this.setData({
|
|
syncPercent: Math.round((current / total) * 100),
|
|
syncStatus: `正在同步 ${current}/${total}...`,
|
|
})
|
|
}))
|
|
.then(() => this._handleSyncSuccess(allUsers, '重新下发成功'))
|
|
.catch((err: Error) => {
|
|
this.setData({ syncShow: false })
|
|
wx.showToast({ title: err.message || '重新下发失败', icon: 'none' })
|
|
})
|
|
},
|
|
|
|
/** 添加用户 */
|
|
onTapAddUser() {
|
|
const sn = targetDevice?.sn || ''
|
|
wx.navigateTo({ url: `/pages/addUser/addUser?sn=${encodeURIComponent(sn)}` })
|
|
},
|
|
|
|
/** 一键添加本人 */
|
|
onTapAddSelf() {
|
|
// 一键添加本人（待接入）
|
|
},
|
|
|
|
/** 添加新用户 */
|
|
onTapAddNew() {
|
|
wx.navigateTo({ url: '/pages/addUser/addUser' })
|
|
}
|
|
})
|