汉秋
703078352c
将最低部署版本降至 iOS 16，以 ObservableObject 替换 @Observable，新增导航与 UI 兼容层，并补充登录冒烟 UI 测试。 Co-authored-by: Cursor <cursoragent@cursor.com>
883 lines
40 KiB
Swift
883 lines
40 KiB
Swift
//
|
||
// QueueManagementViewModels.swift
|
||
// suixinkan
|
||
//
|
||
// Created by Codex on 2026/6/25.
|
||
//
|
||
|
||
import Foundation
|
||
import Combine
|
||
import Photos
|
||
import SwiftUI
|
||
import UIKit
|
||
|
||
@MainActor
|
||
/// 排队管理列表 ViewModel，负责打卡点门禁、列表分页、动作和实时事件。
|
||
final class QueueManagementViewModel: ObservableObject {
|
||
@Published var loading = false
|
||
@Published var loadingMore = false
|
||
@Published var items: [QueueItem] = []
|
||
@Published var scenicSpots: [ScenicSpotItem] = []
|
||
@Published var selectedSpotId: Int?
|
||
@Published var selectedListType: QueueListType = .queueing
|
||
@Published var queueCount = 0
|
||
@Published var avgWaitMin = 0.0
|
||
@Published var totalCount = 0
|
||
@Published var hasMore = false
|
||
@Published var page = 1
|
||
@Published var lastSyncTimeText = "--"
|
||
@Published var queueGatePassed = false
|
||
@Published var selectedSpotName = "--"
|
||
@Published var showStartShootingButton = true
|
||
@Published var autoCallAheadCount = 0
|
||
@Published var quickCallButtonEnabled = false
|
||
@Published var prepareCallButtonEnabled = false
|
||
@Published var remoteCallAnnouncement: ScenicQueueRemoteCallAnnouncement?
|
||
@Published var errorMessage: String?
|
||
|
||
private let pageSize = 10
|
||
private let socketClient = ScenicQueueSocketClient()
|
||
@Published private var realtimeSpotId: Int?
|
||
@Published private var realtimeScenicId: Int?
|
||
@Published private var currentUserId: String?
|
||
@Published private var currentScenicId: Int?
|
||
@Published private var pendingRemoteCalledRecordIds = Set<Int64>()
|
||
@Published private var handledRemoteCallEventIds = Set<String>()
|
||
|
||
/// 待处理排队数量。
|
||
var pendingCount: Int {
|
||
items.filter { $0.status < 7 && !$0.statusText.contains("完成") }.count
|
||
}
|
||
|
||
/// 平均等待时间文案。
|
||
var avgWaitMinText: String {
|
||
avgWaitMin.rounded() == avgWaitMin ? "\(Int(avgWaitMin))" : String(format: "%.1f", avgWaitMin)
|
||
}
|
||
|
||
/// 当前打卡点名称。
|
||
var currentSpotName: String {
|
||
scenicSpots.first(where: { $0.id == selectedSpotId })?.name
|
||
?? selectedSpotName.nonEmptyOrDefault(queueGatePassed ? "--" : "未设置打卡点")
|
||
}
|
||
|
||
/// 重新加载排队数据。没有已保存打卡点时只展示设置引导，不自动选第一个。
|
||
func reload(api: any ScenicQueueServing, scenicId: Int?, userId: String?, spots: [ScenicSpotItem]) async {
|
||
guard let scenicId else {
|
||
reset()
|
||
return
|
||
}
|
||
|
||
loading = true
|
||
errorMessage = nil
|
||
defer { loading = false }
|
||
|
||
currentUserId = userId
|
||
currentScenicId = scenicId
|
||
scenicSpots = spots
|
||
|
||
let savedSpotId = ScenicQueueSettingsStore.selectedSpotId(userId: userId, scenicId: scenicId)
|
||
if let savedSpotId, spots.isEmpty || spots.contains(where: { $0.id == savedSpotId }) {
|
||
selectedSpotId = savedSpotId
|
||
selectedSpotName = ScenicQueueSettingsStore.selectedSpotName(userId: userId, scenicId: scenicId)
|
||
.nonEmptyOrDefault(spots.first(where: { $0.id == savedSpotId })?.name ?? "--")
|
||
queueGatePassed = true
|
||
await syncQueueSettingFromServerIfMatchesLocal(api: api, userId: userId, scenicId: scenicId, spotId: savedSpotId)
|
||
refreshShootingCallConfig(userId: userId, scenicId: scenicId, spotId: savedSpotId)
|
||
} else {
|
||
selectedSpotId = nil
|
||
selectedSpotName = "--"
|
||
queueGatePassed = false
|
||
clearQueueData()
|
||
return
|
||
}
|
||
|
||
do {
|
||
try await loadPage(api: api, scenicId: scenicId, userId: userId, page: 1)
|
||
} catch {
|
||
clearQueueData()
|
||
errorMessage = error.localizedDescription
|
||
}
|
||
}
|
||
|
||
/// 切换列表类型并加载第一页。
|
||
func selectListType(_ type: QueueListType, api: any ScenicQueueServing, scenicId: Int?, userId: String?) async {
|
||
guard selectedListType != type else { return }
|
||
selectedListType = type
|
||
await reloadCurrentSpot(api: api, scenicId: scenicId, userId: userId)
|
||
}
|
||
|
||
/// 重新加载当前打卡点列表。
|
||
func reloadCurrentSpot(api: any ScenicQueueServing, scenicId: Int?, userId: String?) async {
|
||
guard let scenicId else { return }
|
||
loading = true
|
||
errorMessage = nil
|
||
defer { loading = false }
|
||
do {
|
||
try await loadPage(api: api, scenicId: scenicId, userId: userId, page: 1)
|
||
} catch {
|
||
clearQueueData()
|
||
errorMessage = error.localizedDescription
|
||
}
|
||
}
|
||
|
||
/// 加载下一页。
|
||
func loadMore(api: any ScenicQueueServing, scenicId: Int?, userId: String?) async {
|
||
guard let scenicId, hasMore, !loadingMore else { return }
|
||
loadingMore = true
|
||
defer { loadingMore = false }
|
||
do {
|
||
try await loadPage(api: api, scenicId: scenicId, userId: userId, page: page + 1)
|
||
} catch {
|
||
errorMessage = error.localizedDescription
|
||
}
|
||
}
|
||
|
||
/// 叫号，成功后仅本地标记为已叫号。
|
||
func callQueue(api: any ScenicQueueServing, id: Int64) async throws {
|
||
let data = try await api.scenicQueueCall(id: id)
|
||
markQueueCalled(id: id, statusText: data.statusText)
|
||
}
|
||
|
||
/// 标记过号并刷新列表。
|
||
func passQueue(api: any ScenicQueueServing, scenicId: Int?, userId: String?, id: Int64) async throws {
|
||
_ = try await api.scenicQueuePass(id: id)
|
||
items.removeAll { $0.id == id }
|
||
queueCount = max(queueCount - 1, 0)
|
||
await reloadCurrentSpot(api: api, scenicId: scenicId, userId: userId)
|
||
}
|
||
|
||
/// 标记完成并刷新列表。
|
||
func finishQueue(api: any ScenicQueueServing, scenicId: Int?, userId: String?, id: Int64) async throws -> ScenicQueueFinishData {
|
||
let data = try await api.scenicQueueFinish(id: id)
|
||
items.removeAll { $0.id == id }
|
||
queueCount = max(queueCount - 1, 0)
|
||
await reloadCurrentSpot(api: api, scenicId: scenicId, userId: userId)
|
||
return data
|
||
}
|
||
|
||
/// 重新排队并切回当前排队列表。
|
||
func requeue(api: any ScenicQueueServing, scenicId: Int?, userId: String?, id: Int64, operatorId: Int) async throws {
|
||
try await api.scenicQueueRequeueInsertBefore(recordId: id, operatorId: operatorId)
|
||
selectedListType = .queueing
|
||
await reloadCurrentSpot(api: api, scenicId: scenicId, userId: userId)
|
||
}
|
||
|
||
/// 标记用户身份/限制排队。
|
||
func userMark(api: any ScenicQueueServing, scenicId: Int?, userId: String?, request: ScenicQueueUserMarkRequest) async throws {
|
||
try await api.scenicQueueUserMark(request)
|
||
await reloadCurrentSpot(api: api, scenicId: scenicId, userId: userId)
|
||
}
|
||
|
||
/// 启动页面前台实时监听。
|
||
func startRealtime(api: any ScenicQueueServing, scenicId: Int?, userId: String?) async {
|
||
guard queueGatePassed, let scenicId, let scenicSpotId = selectedSpotId else {
|
||
stopRealtime()
|
||
return
|
||
}
|
||
guard realtimeScenicId != scenicId || realtimeSpotId != scenicSpotId else { return }
|
||
stopRealtime()
|
||
do {
|
||
let token = try await api.socketToken().socketToken.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !token.isEmpty else { return }
|
||
realtimeScenicId = scenicId
|
||
realtimeSpotId = scenicSpotId
|
||
socketClient.connect(socketToken: token, scenicSpotId: scenicSpotId) { [weak self] message in
|
||
Task { @MainActor in
|
||
await self?.handleSocketMessage(message, api: api, scenicId: scenicId, userId: userId)
|
||
}
|
||
}
|
||
} catch {
|
||
errorMessage = error.localizedDescription
|
||
}
|
||
}
|
||
|
||
/// 停止页面实时监听。
|
||
func stopRealtime() {
|
||
socketClient.disconnect()
|
||
realtimeScenicId = nil
|
||
realtimeSpotId = nil
|
||
pendingRemoteCalledRecordIds.removeAll()
|
||
handledRemoteCallEventIds.removeAll()
|
||
}
|
||
|
||
/// 当前拍摄预计时长秒数。
|
||
var shootingDurationSeconds: Int {
|
||
guard let scenicId = currentScenicId, let selectedSpotId,
|
||
let snapshot = ScenicQueueSettingsStore.settingsSnapshot(userId: currentUserId, scenicId: scenicId, spotId: selectedSpotId)
|
||
else {
|
||
return max(UserDefaults.standard.integer(forKey: ScenicQueueLocalSettings.photoEstimateSecondsKey), 0)
|
||
}
|
||
return max(snapshot.shootMinute * 60 + snapshot.shootSecond, 0)
|
||
}
|
||
|
||
private func handleSocketMessage(_ message: ScenicQueueSocketMessage, api: any ScenicQueueServing, scenicId: Int, userId: String?) async {
|
||
guard message.isScenicQueueEvent,
|
||
let params = message.data?.params,
|
||
let changedSpotId = params.scenicSpotId,
|
||
let selectedSpotId,
|
||
changedSpotId == Int64(selectedSpotId)
|
||
else { return }
|
||
|
||
switch message.data?.action {
|
||
case ScenicQueueSocketMessage.queueUpdatedAction:
|
||
await reloadCurrentSpot(api: api, scenicId: scenicId, userId: userId)
|
||
case ScenicQueueSocketMessage.ticketCalledAction:
|
||
await handleRemoteTicketCalled(params: params, api: api, scenicId: scenicId, userId: userId)
|
||
default:
|
||
return
|
||
}
|
||
}
|
||
|
||
private func handleRemoteTicketCalled(params: ScenicQueueSocketParams, api: any ScenicQueueServing, scenicId: Int, userId: String?) async {
|
||
guard let recordId = params.recordId, recordId > 0 else { return }
|
||
if let operatorUid = params.operatorUid,
|
||
let myUid = Int64(userId ?? ""),
|
||
operatorUid == myUid {
|
||
return
|
||
}
|
||
let eventId = params.eventId?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
|
||
if !eventId.isEmpty, !handledRemoteCallEventIds.insert(eventId).inserted {
|
||
return
|
||
}
|
||
pendingRemoteCalledRecordIds.insert(recordId)
|
||
guard let selectedSpotId else { return }
|
||
_ = try? await api.scenicQueueStats(scenicId: scenicId, scenicSpotId: selectedSpotId)
|
||
let tickets = (try? await loadQueueingTickets(api: api, scenicId: scenicId, scenicSpotId: selectedSpotId)) ?? []
|
||
if selectedListType == .queueing {
|
||
items = tickets
|
||
totalCount = max(totalCount, tickets.count)
|
||
hasMore = tickets.count < totalCount
|
||
}
|
||
consumePendingRemoteCalledTickets(from: tickets)
|
||
await reloadCurrentSpot(api: api, scenicId: scenicId, userId: userId)
|
||
}
|
||
|
||
private func loadQueueingTickets(api: any ScenicQueueServing, scenicId: Int, scenicSpotId: Int) async throws -> [QueueItem] {
|
||
let home = try await api.scenicQueueHome(
|
||
scenicId: scenicId,
|
||
scenicSpotId: scenicSpotId,
|
||
type: QueueListType.queueing.rawValue,
|
||
page: 1,
|
||
pageSize: pageSize
|
||
)
|
||
return home.list?.list ?? []
|
||
}
|
||
|
||
private func consumePendingRemoteCalledTickets(from tickets: [QueueItem]) {
|
||
guard let ticket = tickets.first(where: {
|
||
pendingRemoteCalledRecordIds.contains($0.id) && ($0.isCalled == 1 || $0.status == 1 || $0.statusText.contains("已叫号"))
|
||
}) else {
|
||
return
|
||
}
|
||
pendingRemoteCalledRecordIds.remove(ticket.id)
|
||
remoteCallAnnouncement = ScenicQueueRemoteCallAnnouncement(id: ticket.id, queueCode: ticket.queueCode)
|
||
}
|
||
|
||
private func loadPage(api: any ScenicQueueServing, scenicId: Int, userId: String?, page targetPage: Int) async throws {
|
||
guard let scenicSpotId = selectedSpotId else { return }
|
||
let home = try await api.scenicQueueHome(
|
||
scenicId: scenicId,
|
||
scenicSpotId: scenicSpotId,
|
||
type: selectedListType.rawValue,
|
||
page: targetPage,
|
||
pageSize: pageSize
|
||
)
|
||
let stats = (try? await api.scenicQueueStats(scenicId: scenicId, scenicSpotId: scenicSpotId)) ?? ScenicQueueStatsData()
|
||
let block = home.list
|
||
let nextList = block?.list ?? []
|
||
|
||
if targetPage <= 1 {
|
||
items = nextList
|
||
} else {
|
||
items.append(contentsOf: nextList)
|
||
}
|
||
page = targetPage
|
||
totalCount = block?.total ?? items.count
|
||
hasMore = page * pageSize < totalCount
|
||
queueCount = stats.queueCount
|
||
avgWaitMin = stats.avgWaitMin
|
||
let syncText = stats.time.isEmpty ? (home.time ?? "") : stats.time
|
||
lastSyncTimeText = syncText.isEmpty ? "--" : syncText
|
||
refreshShootingCallConfig(userId: userId, scenicId: scenicId, spotId: scenicSpotId)
|
||
}
|
||
|
||
private func markQueueCalled(id: Int64, statusText: String) {
|
||
let trimmedStatus = statusText.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
items = items.map { item in
|
||
guard item.id == id else { return item }
|
||
return ScenicQueueTicket(
|
||
id: item.id,
|
||
queueCode: item.queueCode,
|
||
mobile: item.mobile,
|
||
status: max(item.status, 1),
|
||
statusText: trimmedStatus.nonEmptyOrDefault(item.statusText.contains("已叫号") ? item.statusText : "已叫号"),
|
||
waitMin: item.waitMin,
|
||
aheadCount: item.aheadCount,
|
||
isCalled: 1,
|
||
createdAt: item.createdAt,
|
||
calledAt: item.calledAt,
|
||
expiredAt: item.expiredAt,
|
||
finishedAt: item.finishedAt,
|
||
queueBanLabel: item.queueBanLabel,
|
||
identityTag: item.identityTag,
|
||
queueTime: item.queueTime,
|
||
queueCountToday: item.queueCountToday,
|
||
uid: item.uid,
|
||
markAsPhotog: item.markAsPhotog,
|
||
markAsFreelancePhotog: item.markAsFreelancePhotog,
|
||
isMissRequeue: item.isMissRequeue,
|
||
missRequeueText: item.missRequeueText
|
||
)
|
||
}
|
||
}
|
||
|
||
private func reset() {
|
||
stopRealtime()
|
||
loading = false
|
||
loadingMore = false
|
||
scenicSpots = []
|
||
selectedSpotId = nil
|
||
selectedSpotName = "--"
|
||
queueGatePassed = false
|
||
selectedListType = .queueing
|
||
currentScenicId = nil
|
||
clearQueueData()
|
||
}
|
||
|
||
private func clearQueueData() {
|
||
loadingMore = false
|
||
items = []
|
||
queueCount = 0
|
||
avgWaitMin = 0
|
||
totalCount = 0
|
||
hasMore = false
|
||
page = 1
|
||
lastSyncTimeText = "--"
|
||
}
|
||
|
||
private func refreshShootingCallConfig(userId: String?, scenicId: Int, spotId: Int) {
|
||
let snapshot = ScenicQueueSettingsStore.settingsSnapshot(userId: userId, scenicId: scenicId, spotId: spotId) ?? ScenicQueueSettingsSnapshot()
|
||
showStartShootingButton = snapshot.showStartShootingButton
|
||
autoCallAheadCount = min(max(snapshot.autoCallAheadCount, 0), 5)
|
||
quickCallButtonEnabled = snapshot.quickCallButtonEnabled
|
||
prepareCallButtonEnabled = snapshot.prepareCallButtonEnabled
|
||
}
|
||
|
||
private func syncQueueSettingFromServerIfMatchesLocal(api: any ScenicQueueServing, userId: String?, scenicId: Int, spotId: Int) async {
|
||
guard let data = try? await api.scenicQueueSetting(scenicId: scenicId, scenicSpotId: spotId),
|
||
data.exists,
|
||
let setting = data.setting
|
||
else { return }
|
||
if let settingScenicId = setting.scenicId, settingScenicId != scenicId { return }
|
||
if let settingSpotId = setting.scenicSpotId, settingSpotId != spotId { return }
|
||
|
||
let local = ScenicQueueSettingsStore.settingsSnapshot(userId: userId, scenicId: scenicId, spotId: spotId) ?? ScenicQueueSettingsSnapshot()
|
||
let snapshot = ScenicQueueSettingsSnapshot(
|
||
shootMinute: min(max(setting.photoEstimateMin, 0), 30),
|
||
shootSecond: min(max(setting.photoEstimateSec, 0), 59),
|
||
firstAheadCount: min(max(setting.firstNoticeThresholdPos, 0), 50),
|
||
firstSms: setting.firstNoticeSmsEnabled == 1,
|
||
firstPhone: setting.firstNoticeCallEnabled == 1,
|
||
secondAheadCount: min(max(setting.secondNoticeThresholdPos, 0), 50),
|
||
secondSms: setting.secondNoticeSmsEnabled == 1,
|
||
secondPhone: setting.secondNoticeCallEnabled == 1,
|
||
broadcastIntervalSec: ScenicQueueSettingsViewModel.coercedBroadcastInterval(setting.countdownBroadcastIntervalSec),
|
||
countdownThresholdSec: ScenicQueueSettingsViewModel.coercedCountdownThreshold(setting.countdownReadableThresholdSec),
|
||
queueDistanceMeter: min(max(setting.queueDistanceMeter, 0), 9_999_990),
|
||
queueTakeLimit: min(max(setting.queueTakeLimit, 0), 999_999),
|
||
missCallRequeueOffset: min(max(setting.missCallRequeueOffset, 1), 9_999),
|
||
showStartShootingButton: (setting.showStartShootButton ?? (local.showStartShootingButton ? 1 : 0)) == 1,
|
||
autoCallAheadCount: min(max(setting.autoCallNextCount ?? local.autoCallAheadCount, 0), 5),
|
||
quickCallButtonEnabled: local.quickCallButtonEnabled,
|
||
prepareCallButtonEnabled: local.prepareCallButtonEnabled,
|
||
businessOpen: setting.status == 1,
|
||
businessStartTime: setting.businessStartTime,
|
||
businessEndTime: setting.businessEndTime
|
||
)
|
||
ScenicQueueSettingsStore.saveSettingsSnapshot(snapshot, userId: userId, scenicId: scenicId, spotId: spotId)
|
||
ScenicQueueSettingsStore.saveSelectedSpot(
|
||
id: spotId,
|
||
name: setting.scenicSpotName.nonEmptyOrDefault(selectedSpotName),
|
||
userId: userId,
|
||
scenicId: scenicId
|
||
)
|
||
if !setting.remark.isEmpty, setting.remark != "A0001" {
|
||
ScenicQueueSettingsStore.saveCustomTtsText(setting.remark, userId: userId, scenicId: scenicId, spotId: spotId)
|
||
}
|
||
let voices = setting.voiceBroadcasts
|
||
.sorted { $0.sortOrder < $1.sortOrder }
|
||
.map { $0.content.trimmingCharacters(in: .whitespacesAndNewlines) }
|
||
.filter { !$0.isEmpty }
|
||
if !voices.isEmpty {
|
||
ScenicQueueSettingsStore.savePresetVoices(Array(voices.prefix(5)), userId: userId, scenicId: scenicId, spotId: spotId)
|
||
}
|
||
selectedSpotName = setting.scenicSpotName.nonEmptyOrDefault(selectedSpotName)
|
||
}
|
||
}
|
||
|
||
@MainActor
|
||
/// 排队设置 ViewModel，负责设置读取、校验、保存、二维码和日志。
|
||
final class ScenicQueueSettingsViewModel: ObservableObject {
|
||
@Published var loading = false
|
||
@Published var message: String?
|
||
@Published var scenicSpots: [ScenicSpotItem] = []
|
||
@Published var selectedSpotId: Int?
|
||
@Published var photoEstimateMin = "0"
|
||
@Published var photoEstimateSec = "30"
|
||
@Published var firstAhead = "0"
|
||
@Published var firstSms = false
|
||
@Published var firstPhone = false
|
||
@Published var secondAhead = "0"
|
||
@Published var secondSms = false
|
||
@Published var secondPhone = false
|
||
@Published var broadcastIntervalSec = "50"
|
||
@Published var countdownThresholdSec = "15"
|
||
@Published var maxQueueRangeKm = "0.00"
|
||
@Published var localQueueLimit = "0"
|
||
@Published var localPassDelay = "1"
|
||
@Published var showStartShootingButton = true
|
||
@Published var autoCallAheadCount = "0"
|
||
@Published var queueOpen = true
|
||
@Published var businessStartTime = ScenicQueueSettingsViewModel.businessTime(hour: 10, minute: 0)
|
||
@Published var businessEndTime = ScenicQueueSettingsViewModel.businessTime(hour: 20, minute: 0)
|
||
@Published var customTtsText = ""
|
||
@Published var presetVoices: [String] = []
|
||
@Published var quickCallButtonEnabled = false
|
||
@Published var prepareCallButtonEnabled = false
|
||
@Published var logs: [ScenicQueueSettingChangeLogItem] = []
|
||
@Published var qrcodeURL = ""
|
||
|
||
private let speaker = ScenicQueueSpeechService()
|
||
@Published private var currentUserId: String?
|
||
@Published private var currentScenicId: Int?
|
||
|
||
/// 加载设置。设置页允许自动选中第一个打卡点。
|
||
func load(api: any ScenicQueueServing, scenicId: Int?, userId: String?, spots: [ScenicSpotItem]) async {
|
||
guard let scenicId else {
|
||
resetSettingsState()
|
||
message = "请先选择景区"
|
||
return
|
||
}
|
||
currentUserId = userId
|
||
currentScenicId = scenicId
|
||
scenicSpots = spots
|
||
message = nil
|
||
loading = true
|
||
defer { loading = false }
|
||
logs = []
|
||
|
||
let savedSpotId = ScenicQueueSettingsStore.selectedSpotId(userId: userId, scenicId: scenicId)
|
||
selectedSpotId = savedSpotId.flatMap { id in spots.first(where: { $0.id == id })?.id ?? id } ?? selectedSpotId ?? spots.first?.id
|
||
guard selectedSpotId != nil else { return }
|
||
await loadSelectedSpotSetting(api: api, scenicId: scenicId, userId: userId)
|
||
}
|
||
|
||
/// 加载当前选中打卡点设置。
|
||
func loadSelectedSpotSetting(api: any ScenicQueueServing, scenicId: Int?, userId: String?) async {
|
||
guard let scenicId, let selectedSpotId else { return }
|
||
currentUserId = userId
|
||
currentScenicId = scenicId
|
||
presetVoices = ScenicQueueSettingsStore.presetVoices(userId: userId, scenicId: scenicId, spotId: selectedSpotId)
|
||
let savedCustomText = ScenicQueueSettingsStore.customTtsText(userId: userId, scenicId: scenicId, spotId: selectedSpotId)
|
||
if !savedCustomText.isEmpty, savedCustomText != "A0001" {
|
||
customTtsText = savedCustomText
|
||
}
|
||
if let snapshot = ScenicQueueSettingsStore.settingsSnapshot(userId: userId, scenicId: scenicId, spotId: selectedSpotId) {
|
||
apply(snapshot)
|
||
}
|
||
do {
|
||
let setting = try await api.scenicQueueSetting(scenicId: scenicId, scenicSpotId: selectedSpotId)
|
||
if setting.exists, let item = setting.setting {
|
||
apply(item)
|
||
ScenicQueueSettingsStore.saveSettingsSnapshot(makeSnapshot(), userId: userId, scenicId: scenicId, spotId: selectedSpotId)
|
||
}
|
||
} catch {
|
||
message = error.localizedDescription
|
||
}
|
||
}
|
||
|
||
/// 加载设置变更日志。
|
||
func loadSettingChangeLogs(api: any ScenicQueueServing, scenicId: Int?) async {
|
||
guard let scenicId else {
|
||
message = "请先选择景区"
|
||
return
|
||
}
|
||
do {
|
||
let data = try await api.scenicQueueSettingChangeLog(scenicId: scenicId, scenicSpotId: selectedSpotId, page: 1, pageSize: 20)
|
||
logs = data.list
|
||
} catch {
|
||
message = error.localizedDescription
|
||
}
|
||
}
|
||
|
||
/// 获取排队二维码 URL。
|
||
func fetchQRCode(api: any ScenicQueueServing, scenicId: Int?) async throws -> String {
|
||
guard let scenicId else { throw APIError.networkFailed("请先选择景区") }
|
||
guard let selectedSpotId else { throw APIError.networkFailed("请选择打卡点") }
|
||
let data = try await api.scenicQueueShootQueueQRCode(scenicId: scenicId, scenicSpotId: selectedSpotId)
|
||
let url = data.qrcodeUrl.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !url.isEmpty else { throw APIError.networkFailed("服务端未返回二维码图片地址") }
|
||
qrcodeURL = url
|
||
return url
|
||
}
|
||
|
||
/// 保存二维码图片到系统相册。
|
||
func saveQRCodeToPhotoLibrary(qrcodeURL: String) async throws {
|
||
let trimmed = qrcodeURL.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !trimmed.isEmpty else {
|
||
throw APIError.networkFailed("服务端未返回二维码图片地址")
|
||
}
|
||
let status = await PHPhotoLibrary.requestAuthorization(for: .addOnly)
|
||
guard status == .authorized || status == .limited else {
|
||
throw APIError.networkFailed("请在系统设置中允许保存图片到相册")
|
||
}
|
||
let image = try await loadQRCodeImage(from: trimmed)
|
||
try await PHPhotoLibrary.shared().performChanges {
|
||
PHAssetChangeRequest.creationRequestForAsset(from: image)
|
||
}
|
||
}
|
||
|
||
/// 保存排队设置。
|
||
func save(api: any ScenicQueueServing, scenicId: Int?, userId: String?) async throws {
|
||
guard let scenicId else { throw APIError.networkFailed("请先选择景区") }
|
||
guard let selectedSpotId else { throw APIError.networkFailed("请选择打卡点") }
|
||
currentUserId = userId
|
||
currentScenicId = scenicId
|
||
let min = try AppFormValidator.rangedInteger(photoEstimateMin, name: "拍摄时长分钟", range: 0...30)
|
||
let sec = try AppFormValidator.rangedInteger(photoEstimateSec, name: "拍摄时长秒", range: 0...59)
|
||
guard min > 0 || sec > 0 else { throw APIError.networkFailed("拍摄时长须大于 0") }
|
||
let first = try AppFormValidator.rangedInteger(firstAhead, name: "第一次通知阈值", range: 0...50)
|
||
let second = try AppFormValidator.rangedInteger(secondAhead, name: "第二次通知阈值", range: 0...50)
|
||
try AppFormValidator.validateQueueNoticeThresholds(first: first, second: second)
|
||
let interval = try AppFormValidator.rangedInteger(broadcastIntervalSec, name: "播报间隔时间", range: 40...60)
|
||
let countdown = try AppFormValidator.rangedInteger(countdownThresholdSec, name: "进入读秒倒计时阈值", range: 10...30)
|
||
let autoCallAhead = try AppFormValidator.rangedInteger(autoCallAheadCount, name: "自动叫号后续几位", range: 0...5)
|
||
maxQueueRangeKm = try normalizedMaxQueueRangeForDisplay()
|
||
let queueDistanceMeter = try queueDistanceMeterForSubmit()
|
||
let queueTakeLimit = try AppFormValidator.rangedInteger(localQueueLimit, name: "排队次数限制", range: 0...999_999)
|
||
let missCallRequeueOffset = try AppFormValidator.rangedInteger(localPassDelay, name: "过号顺延", range: 1...9_999)
|
||
guard customTtsText.trimmingCharacters(in: .whitespacesAndNewlines).count <= 255 else {
|
||
throw APIError.networkFailed("自定义播报文本最多 255 个字")
|
||
}
|
||
|
||
loading = true
|
||
defer { loading = false }
|
||
try await api.scenicQueueSaveSetting(ScenicQueueSaveSettingRequest(
|
||
scenicId: scenicId,
|
||
scenicSpotId: selectedSpotId,
|
||
photoEstimateMin: min,
|
||
photoEstimateSec: sec,
|
||
firstNoticeThresholdPos: first,
|
||
firstNoticeSmsEnabled: firstSms ? 1 : 0,
|
||
firstNoticeCallEnabled: firstPhone ? 1 : 0,
|
||
secondNoticeThresholdPos: second,
|
||
secondNoticeSmsEnabled: secondSms ? 1 : 0,
|
||
secondNoticeCallEnabled: secondPhone ? 1 : 0,
|
||
countdownBroadcastIntervalSec: interval,
|
||
countdownReadableThresholdSec: countdown,
|
||
queueDistanceMeter: queueDistanceMeter,
|
||
queueTakeLimit: queueTakeLimit,
|
||
missCallRequeueOffset: missCallRequeueOffset,
|
||
showStartShootButton: showStartShootingButton ? 1 : 0,
|
||
autoCallNextCount: autoCallAhead,
|
||
businessStartTime: Self.businessTimePayload(businessStartTime),
|
||
businessEndTime: Self.businessTimePayload(businessEndTime),
|
||
voiceBroadcasts: voiceBroadcastsForSavePayload(),
|
||
status: queueOpen ? 1 : 0,
|
||
remark: customTtsText.trimmingCharacters(in: .whitespacesAndNewlines).nilIfEmpty
|
||
))
|
||
let spotName = scenicSpots.first(where: { $0.id == selectedSpotId })?.name ?? ""
|
||
ScenicQueueSettingsStore.saveSelectedSpot(id: selectedSpotId, name: spotName, userId: userId, scenicId: scenicId)
|
||
saveTimingSnapshot(min: min, sec: sec, interval: interval, countdown: countdown)
|
||
saveShootingCallSettings(autoCallAhead: autoCallAhead)
|
||
saveCustomTextLocally()
|
||
ScenicQueueSettingsStore.savePresetVoices(presetVoices, userId: userId, scenicId: scenicId, spotId: selectedSpotId)
|
||
ScenicQueueSettingsStore.saveSettingsSnapshot(makeSnapshot(
|
||
min: min,
|
||
sec: sec,
|
||
first: first,
|
||
second: second,
|
||
interval: interval,
|
||
countdown: countdown,
|
||
queueDistanceMeter: queueDistanceMeter,
|
||
queueTakeLimit: queueTakeLimit,
|
||
missCallRequeueOffset: missCallRequeueOffset,
|
||
autoCallAhead: autoCallAhead
|
||
), userId: userId, scenicId: scenicId, spotId: selectedSpotId)
|
||
}
|
||
|
||
/// 保存自定义文本为本地预设。
|
||
func saveCustomTextAsPreset() {
|
||
let text = customTtsText.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard text.count <= 255 else {
|
||
message = "自定义播报文本最多 255 个字"
|
||
return
|
||
}
|
||
saveCustomTextLocally()
|
||
if !text.isEmpty, !presetVoices.contains(text), presetVoices.count < 5 {
|
||
presetVoices.append(text)
|
||
}
|
||
if let scenicId = currentScenicId, let selectedSpotId {
|
||
ScenicQueueSettingsStore.savePresetVoices(presetVoices, userId: currentUserId, scenicId: scenicId, spotId: selectedSpotId)
|
||
}
|
||
}
|
||
|
||
/// 更新最大排队范围输入。
|
||
func updateMaxQueueRange(_ value: String) {
|
||
maxQueueRangeKm = AppFormValidator.sanitizedMoneyInput(value, maxDecimalPlaces: 2)
|
||
}
|
||
|
||
/// 播放测试音。
|
||
func playTestSound() {
|
||
speaker.speak("蓝牙音响测试音，请确认外放音量是否合适。")
|
||
}
|
||
|
||
/// 播放自定义播报文本。
|
||
func playCustomText() {
|
||
let text = customTtsText.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !text.isEmpty else {
|
||
message = "请输入要播报的文字"
|
||
return
|
||
}
|
||
speaker.speak(text)
|
||
}
|
||
|
||
/// 删除预设语音。
|
||
func deletePresetVoice(at index: Int) {
|
||
guard presetVoices.indices.contains(index) else { return }
|
||
presetVoices.remove(at: index)
|
||
}
|
||
|
||
private func resetSettingsState() {
|
||
loading = false
|
||
scenicSpots = []
|
||
selectedSpotId = nil
|
||
photoEstimateMin = "0"
|
||
photoEstimateSec = "30"
|
||
firstAhead = "0"
|
||
firstSms = false
|
||
firstPhone = false
|
||
secondAhead = "0"
|
||
secondSms = false
|
||
secondPhone = false
|
||
broadcastIntervalSec = "50"
|
||
countdownThresholdSec = "15"
|
||
maxQueueRangeKm = "0.00"
|
||
localQueueLimit = "0"
|
||
localPassDelay = "1"
|
||
showStartShootingButton = true
|
||
autoCallAheadCount = "0"
|
||
queueOpen = true
|
||
businessStartTime = Self.businessTime(hour: 10, minute: 0)
|
||
businessEndTime = Self.businessTime(hour: 20, minute: 0)
|
||
customTtsText = ""
|
||
logs = []
|
||
presetVoices = []
|
||
quickCallButtonEnabled = false
|
||
prepareCallButtonEnabled = false
|
||
qrcodeURL = ""
|
||
}
|
||
|
||
private func apply(_ setting: ScenicQueueSettingItem?) {
|
||
guard let setting else { return }
|
||
if let spotId = setting.scenicSpotId { selectedSpotId = spotId }
|
||
photoEstimateMin = "\(setting.photoEstimateMin)"
|
||
photoEstimateSec = "\(setting.photoEstimateSec)"
|
||
firstAhead = "\(setting.firstNoticeThresholdPos)"
|
||
firstSms = setting.firstNoticeSmsEnabled == 1
|
||
firstPhone = setting.firstNoticeCallEnabled == 1
|
||
secondAhead = "\(setting.secondNoticeThresholdPos)"
|
||
secondSms = setting.secondNoticeSmsEnabled == 1
|
||
secondPhone = setting.secondNoticeCallEnabled == 1
|
||
broadcastIntervalSec = "\(Self.coercedBroadcastInterval(setting.countdownBroadcastIntervalSec))"
|
||
countdownThresholdSec = "\(Self.coercedCountdownThreshold(setting.countdownReadableThresholdSec))"
|
||
maxQueueRangeKm = Self.queueDistanceDisplay(meters: setting.queueDistanceMeter)
|
||
localQueueLimit = "\(min(max(setting.queueTakeLimit, 0), 999_999))"
|
||
localPassDelay = "\(min(max(setting.missCallRequeueOffset, 1), 9_999))"
|
||
if let showStartShootButton = setting.showStartShootButton { showStartShootingButton = showStartShootButton == 1 }
|
||
if let autoCallNextCount = setting.autoCallNextCount { autoCallAheadCount = "\(min(max(autoCallNextCount, 0), 5))" }
|
||
queueOpen = setting.status == 1
|
||
businessStartTime = Self.parseBusinessTime(setting.businessStartTime, fallback: Self.businessTime(hour: 10, minute: 0))
|
||
businessEndTime = Self.parseBusinessTime(setting.businessEndTime, fallback: Self.businessTime(hour: 20, minute: 0))
|
||
if !setting.remark.isEmpty, setting.remark != "A0001" { customTtsText = setting.remark }
|
||
let voices = setting.voiceBroadcasts
|
||
.sorted { $0.sortOrder < $1.sortOrder }
|
||
.map { $0.content.trimmingCharacters(in: .whitespacesAndNewlines) }
|
||
.filter { !$0.isEmpty }
|
||
if !voices.isEmpty { presetVoices = Array(voices.prefix(5)) }
|
||
}
|
||
|
||
private func apply(_ snapshot: ScenicQueueSettingsSnapshot) {
|
||
photoEstimateMin = "\(min(max(snapshot.shootMinute, 0), 30))"
|
||
photoEstimateSec = "\(min(max(snapshot.shootSecond, 0), 59))"
|
||
firstAhead = "\(min(max(snapshot.firstAheadCount, 0), 50))"
|
||
firstSms = snapshot.firstSms
|
||
firstPhone = snapshot.firstPhone
|
||
secondAhead = "\(min(max(snapshot.secondAheadCount, 0), 50))"
|
||
secondSms = snapshot.secondSms
|
||
secondPhone = snapshot.secondPhone
|
||
broadcastIntervalSec = "\(Self.coercedBroadcastInterval(snapshot.broadcastIntervalSec))"
|
||
countdownThresholdSec = "\(Self.coercedCountdownThreshold(snapshot.countdownThresholdSec))"
|
||
maxQueueRangeKm = Self.queueDistanceDisplay(meters: snapshot.queueDistanceMeter)
|
||
localQueueLimit = "\(min(max(snapshot.queueTakeLimit, 0), 999_999))"
|
||
localPassDelay = "\(min(max(snapshot.missCallRequeueOffset, 1), 9_999))"
|
||
showStartShootingButton = snapshot.showStartShootingButton
|
||
autoCallAheadCount = "\(min(max(snapshot.autoCallAheadCount, 0), 5))"
|
||
quickCallButtonEnabled = snapshot.quickCallButtonEnabled
|
||
prepareCallButtonEnabled = snapshot.prepareCallButtonEnabled
|
||
queueOpen = snapshot.businessOpen
|
||
businessStartTime = Self.parseBusinessTime(snapshot.businessStartTime, fallback: Self.businessTime(hour: 10, minute: 0))
|
||
businessEndTime = Self.parseBusinessTime(snapshot.businessEndTime, fallback: Self.businessTime(hour: 20, minute: 0))
|
||
}
|
||
|
||
private func normalizedMaxQueueRangeForDisplay() throws -> String {
|
||
let normalized = AppFormValidator.normalizedMoneyForSubmit(maxQueueRangeKm)
|
||
guard !normalized.isEmpty,
|
||
normalized.range(of: #"^\d+(\.\d{1,2})?$"#, options: .regularExpression) != nil,
|
||
let value = Decimal(string: normalized, locale: Locale(identifier: "en_US_POSIX"))
|
||
else {
|
||
throw APIError.networkFailed("允许排队的最大范围格式不正确")
|
||
}
|
||
let max = Decimal(999_999) / Decimal(100)
|
||
guard value >= 0, value <= max else {
|
||
throw APIError.networkFailed("允许排队的最大范围须在 0～9999.99")
|
||
}
|
||
return String(format: "%.2f", NSDecimalNumber(decimal: value).doubleValue)
|
||
}
|
||
|
||
private func queueDistanceMeterForSubmit() throws -> Int {
|
||
_ = try normalizedMaxQueueRangeForDisplay()
|
||
let value = Decimal(string: maxQueueRangeKm, locale: Locale(identifier: "en_US_POSIX")) ?? 0
|
||
return NSDecimalNumber(decimal: value * Decimal(1000)).intValue
|
||
}
|
||
|
||
private func loadQRCodeImage(from text: String) async throws -> UIImage {
|
||
if let url = URL(string: text), ["http", "https"].contains(url.scheme?.lowercased()) {
|
||
let (data, _) = try await URLSession.shared.data(from: url)
|
||
if let image = UIImage(data: data) { return image }
|
||
}
|
||
if let generated = Self.generateQRCode(from: text) { return generated }
|
||
throw APIError.networkFailed("二维码图片生成失败")
|
||
}
|
||
|
||
private static func generateQRCode(from string: String) -> UIImage? {
|
||
let filter = CIFilter.qrCodeGenerator()
|
||
filter.message = Data(string.utf8)
|
||
guard let outputImage = filter.outputImage else { return nil }
|
||
let transformed = outputImage.transformed(by: CGAffineTransform(scaleX: 8, y: 8))
|
||
let context = CIContext()
|
||
guard let cgImage = context.createCGImage(transformed, from: transformed.extent) else { return nil }
|
||
return UIImage(cgImage: cgImage)
|
||
}
|
||
|
||
private func saveTimingSnapshot(min: Int, sec: Int, interval: Int, countdown: Int) {
|
||
UserDefaults.standard.set(max(min * 60 + sec, 0), forKey: ScenicQueueLocalSettings.photoEstimateSecondsKey)
|
||
UserDefaults.standard.set(interval, forKey: ScenicQueueLocalSettings.broadcastIntervalSecondsKey)
|
||
UserDefaults.standard.set(countdown, forKey: ScenicQueueLocalSettings.countdownThresholdSecondsKey)
|
||
}
|
||
|
||
private func saveShootingCallSettings(autoCallAhead: Int) {
|
||
UserDefaults.standard.set(showStartShootingButton, forKey: ScenicQueueLocalSettings.showStartShootingButtonKey)
|
||
UserDefaults.standard.set(autoCallAhead, forKey: ScenicQueueLocalSettings.autoCallAheadCountKey)
|
||
UserDefaults.standard.set(quickCallButtonEnabled, forKey: ScenicQueueLocalSettings.quickCallButtonEnabledKey)
|
||
UserDefaults.standard.set(prepareCallButtonEnabled, forKey: ScenicQueueLocalSettings.prepareCallButtonEnabledKey)
|
||
}
|
||
|
||
private func saveCustomTextLocally() {
|
||
ScenicQueueSettingsStore.saveCustomTtsText(customTtsText, userId: currentUserId, scenicId: currentScenicId, spotId: selectedSpotId)
|
||
}
|
||
|
||
private func voiceBroadcastsForSavePayload() -> [ScenicQueueVoiceBroadcastItem] {
|
||
Array(presetVoices
|
||
.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
|
||
.filter { !$0.isEmpty }
|
||
.prefix(5)
|
||
.enumerated()
|
||
.map { index, content in ScenicQueueVoiceBroadcastItem(content: content, sortOrder: index + 1) })
|
||
}
|
||
|
||
private func makeSnapshot(
|
||
min: Int? = nil,
|
||
sec: Int? = nil,
|
||
first: Int? = nil,
|
||
second: Int? = nil,
|
||
interval: Int? = nil,
|
||
countdown: Int? = nil,
|
||
queueDistanceMeter: Int? = nil,
|
||
queueTakeLimit: Int? = nil,
|
||
missCallRequeueOffset: Int? = nil,
|
||
autoCallAhead: Int? = nil
|
||
) -> ScenicQueueSettingsSnapshot {
|
||
ScenicQueueSettingsSnapshot(
|
||
shootMinute: min ?? (Int(photoEstimateMin) ?? 0),
|
||
shootSecond: sec ?? (Int(photoEstimateSec) ?? 30),
|
||
firstAheadCount: first ?? (Int(firstAhead) ?? 0),
|
||
firstSms: firstSms,
|
||
firstPhone: firstPhone,
|
||
secondAheadCount: second ?? (Int(secondAhead) ?? 0),
|
||
secondSms: secondSms,
|
||
secondPhone: secondPhone,
|
||
broadcastIntervalSec: interval ?? (Int(broadcastIntervalSec) ?? 50),
|
||
countdownThresholdSec: countdown ?? (Int(countdownThresholdSec) ?? 15),
|
||
queueDistanceMeter: queueDistanceMeter ?? ((Decimal(string: maxQueueRangeKm) ?? 0) as NSDecimalNumber).intValue * 1000,
|
||
queueTakeLimit: queueTakeLimit ?? (Int(localQueueLimit) ?? 0),
|
||
missCallRequeueOffset: missCallRequeueOffset ?? (Int(localPassDelay) ?? 1),
|
||
showStartShootingButton: showStartShootingButton,
|
||
autoCallAheadCount: autoCallAhead ?? (Int(autoCallAheadCount) ?? 0),
|
||
quickCallButtonEnabled: quickCallButtonEnabled,
|
||
prepareCallButtonEnabled: prepareCallButtonEnabled,
|
||
businessOpen: queueOpen,
|
||
businessStartTime: Self.businessTimePayload(businessStartTime),
|
||
businessEndTime: Self.businessTimePayload(businessEndTime)
|
||
)
|
||
}
|
||
|
||
static func coercedBroadcastInterval(_ raw: Int) -> Int {
|
||
(40...60).contains(raw) ? raw : 50
|
||
}
|
||
|
||
static func coercedCountdownThreshold(_ raw: Int) -> Int {
|
||
(10...30).contains(raw) ? raw : 15
|
||
}
|
||
|
||
static func businessTime(hour: Int, minute: Int) -> Date {
|
||
Calendar.current.date(from: DateComponents(hour: hour, minute: minute)) ?? Date()
|
||
}
|
||
|
||
static func parseBusinessTime(_ raw: String, fallback: Date) -> Date {
|
||
let text = raw.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !text.isEmpty else { return fallback }
|
||
for format in ["HH:mm", "HH:mm:ss"] {
|
||
let formatter = DateFormatter()
|
||
formatter.locale = Locale(identifier: "en_US_POSIX")
|
||
formatter.dateFormat = format
|
||
if let date = formatter.date(from: text) { return date }
|
||
}
|
||
return fallback
|
||
}
|
||
|
||
static func businessTimePayload(_ date: Date) -> String {
|
||
let formatter = DateFormatter()
|
||
formatter.locale = Locale(identifier: "en_US_POSIX")
|
||
formatter.dateFormat = "HH:mm"
|
||
return formatter.string(from: date)
|
||
}
|
||
|
||
private static func queueDistanceDisplay(meters: Int) -> String {
|
||
let clamped = min(max(meters, 0), 9_999_990)
|
||
return String(format: "%.2f", Double(clamped) / 1000)
|
||
}
|
||
}
|
||
|
||
private extension String {
|
||
var nilIfEmpty: String? {
|
||
let text = trimmingCharacters(in: .whitespacesAndNewlines)
|
||
return text.isEmpty ? nil : text
|
||
}
|
||
|
||
func nonEmptyOrDefault(_ fallback: String) -> String {
|
||
let text = trimmingCharacters(in: .whitespacesAndNewlines)
|
||
return text.isEmpty ? fallback : text
|
||
}
|
||
}
|