up
This commit is contained in:
@@ -0,0 +1,697 @@
|
||||
import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
|
||||
import { join } from 'node:path'
|
||||
import type { OnlineIntent, OnlineState } from '../src/types/online.js'
|
||||
import type { Report, ResultsSnapshot } from '../src/types/screen.js'
|
||||
import type { Controller } from './controller.js'
|
||||
import { PackageStore, packageKey } from './package-store.js'
|
||||
import { prepareScreenPackage } from './screen-package.js'
|
||||
import { parseResults } from './results.js'
|
||||
import {
|
||||
applyRemote,
|
||||
integer,
|
||||
object,
|
||||
parseRemote,
|
||||
send,
|
||||
text,
|
||||
type RemoteState,
|
||||
} from './remote-state.js'
|
||||
|
||||
export interface SecretStorage {
|
||||
available(): boolean
|
||||
encrypt(value: string): Buffer
|
||||
decrypt(value: Buffer): string
|
||||
}
|
||||
interface ScreenSession {
|
||||
id: string
|
||||
token: string
|
||||
gameId: number
|
||||
}
|
||||
interface Credentials {
|
||||
server: string
|
||||
access: string
|
||||
refresh: string
|
||||
screen: ScreenSession | null
|
||||
}
|
||||
class ApiError extends Error {
|
||||
constructor(public status: number) {
|
||||
super(
|
||||
status === 401
|
||||
? 'Сессия истекла. Войдите снова'
|
||||
: status === 403
|
||||
? 'Нет доступа к действию'
|
||||
: status === 400
|
||||
? 'Действие пока недоступно для этой игры'
|
||||
: `Ошибка сервера: HTTP ${status}`,
|
||||
)
|
||||
}
|
||||
}
|
||||
function serverURL(value: unknown): string {
|
||||
const url = new URL(text(value))
|
||||
if (
|
||||
!['http:', 'https:'].includes(url.protocol) ||
|
||||
url.username ||
|
||||
url.password ||
|
||||
url.search ||
|
||||
url.hash ||
|
||||
(url.pathname !== '/' && url.pathname !== '')
|
||||
)
|
||||
throw new Error('Укажите адрес HTTP(S) сервера без пути и параметров')
|
||||
return url.origin
|
||||
}
|
||||
function token(value: unknown): string {
|
||||
const s = text(value)
|
||||
if (!s || s.length > 16384 || /[\r\n]/.test(s))
|
||||
throw new Error('Сервер не вернул действующие токены')
|
||||
return s
|
||||
}
|
||||
export class Online {
|
||||
readonly state: OnlineState = {
|
||||
server: '',
|
||||
authenticated: false,
|
||||
remembered: false,
|
||||
busy: false,
|
||||
canCancel: false,
|
||||
games: [],
|
||||
screenId: null,
|
||||
connection: 'disabled',
|
||||
error: '',
|
||||
notice: '',
|
||||
progress: null,
|
||||
packagesRevision: 0,
|
||||
}
|
||||
private credentials: Credentials | null = null
|
||||
private screen: ScreenSession | null = null
|
||||
private generation = 0
|
||||
private refreshPromise: Promise<void> | null = null
|
||||
private writes: Promise<void> = Promise.resolve()
|
||||
private cancellation: AbortController | null = null
|
||||
private downloadKey: string | null = null
|
||||
private previous: RemoteState | null = null
|
||||
private pollBusy = false
|
||||
private pollSession = ''
|
||||
private initialSound = true
|
||||
private lastResults = -Infinity
|
||||
private resultsBusy = false
|
||||
private advanceBusy = false
|
||||
constructor(
|
||||
private directory: string,
|
||||
private packages: PackageStore,
|
||||
private controller: Controller,
|
||||
private secrets: SecretStorage,
|
||||
private fetchAPI: typeof fetch = fetch,
|
||||
) {
|
||||
controller.onMusicEnded = (report) => {
|
||||
void this.musicEnded(report)
|
||||
}
|
||||
}
|
||||
get blocksOutput() {
|
||||
return this.downloadKey !== null && this.downloadKey === this.controller.state.catalog.key
|
||||
}
|
||||
get busy() {
|
||||
return this.state.busy
|
||||
}
|
||||
snapshot(): OnlineState {
|
||||
return structuredClone(this.state)
|
||||
}
|
||||
private async atomic(name: string, data: string | Buffer) {
|
||||
await mkdir(this.directory, { recursive: true, mode: 0o700 })
|
||||
const path = join(this.directory, name)
|
||||
await writeFile(`${path}.tmp`, data, { mode: 0o600 })
|
||||
await rename(`${path}.tmp`, path)
|
||||
}
|
||||
private persistSecrets() {
|
||||
const data = this.credentials ? { ...this.credentials, screen: this.screen } : null
|
||||
this.state.remembered = !!data && this.secrets.available()
|
||||
let encrypted: Buffer | null = null
|
||||
try {
|
||||
if (this.state.remembered) encrypted = this.secrets.encrypt(JSON.stringify(data))
|
||||
} catch {
|
||||
this.state.remembered = false
|
||||
this.state.notice =
|
||||
'Не удалось сохранить вход средствами ОС. Сессия действует до закрытия приложения'
|
||||
}
|
||||
const write = this.writes.then(async () => {
|
||||
if (encrypted) await this.atomic('credentials.bin', encrypted)
|
||||
else await rm(join(this.directory, 'credentials.bin'), { force: true })
|
||||
})
|
||||
this.writes = write.catch(() => {})
|
||||
return write
|
||||
}
|
||||
async initialize() {
|
||||
try {
|
||||
const config = object(
|
||||
JSON.parse(await readFile(join(this.directory, 'selection.json'), 'utf8')),
|
||||
)
|
||||
if (config.server) this.state.server = serverURL(config.server)
|
||||
if (typeof config.key === 'string' && /^[a-f0-9]{64}$/.test(config.key))
|
||||
await this.select(config.key, false)
|
||||
} catch (error) {
|
||||
if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
|
||||
this.state.error = 'Не удалось восстановить выбранные материалы; выберите готовый пакет'
|
||||
}
|
||||
if (!this.secrets.available()) return
|
||||
try {
|
||||
const raw = object(
|
||||
JSON.parse(this.secrets.decrypt(await readFile(join(this.directory, 'credentials.bin')))),
|
||||
)
|
||||
const server = serverURL(raw.server)
|
||||
const c: Credentials = {
|
||||
server,
|
||||
access: token(raw.access),
|
||||
refresh: token(raw.refresh),
|
||||
screen: null,
|
||||
}
|
||||
if (raw.screen) {
|
||||
const s = object(raw.screen)
|
||||
c.screen = {
|
||||
id: String(integer(s.id, 1)),
|
||||
token: token(s.token),
|
||||
gameId: integer(s.gameId, 1),
|
||||
}
|
||||
}
|
||||
this.credentials = c
|
||||
this.state.server = server
|
||||
this.state.authenticated = true
|
||||
this.state.remembered = true
|
||||
const pkg = this.packages.list().find((p) => p.key === this.controller.state.catalog.key)
|
||||
if (c.screen && pkg?.package.server === server && pkg.package.game.id === c.screen.gameId) {
|
||||
this.screen = c.screen
|
||||
this.state.screenId = c.screen.id
|
||||
this.state.connection = 'waiting'
|
||||
this.initialSound = true
|
||||
}
|
||||
} catch (error) {
|
||||
if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
|
||||
this.state.error =
|
||||
'Сохранённый вход недоступен. Войдите снова; локальные материалы доступны'
|
||||
}
|
||||
}
|
||||
private async saveSelection() {
|
||||
await this.atomic(
|
||||
'selection.json',
|
||||
JSON.stringify({ server: this.state.server, key: this.controller.state.catalog.key }),
|
||||
)
|
||||
}
|
||||
async select(key: string | null, persist = true) {
|
||||
if (this.busy) throw new Error('Подождите завершения подготовки материалов')
|
||||
let pkg
|
||||
try {
|
||||
pkg = key === null ? null : await this.packages.verify(key)
|
||||
} catch (error) {
|
||||
if (key === this.controller.state.catalog.key) {
|
||||
this.detach()
|
||||
this.controller.selectPackage(null)
|
||||
await this.saveSelection()
|
||||
await this.persistSecrets()
|
||||
this.state.packagesRevision++
|
||||
}
|
||||
throw error
|
||||
}
|
||||
this.detach()
|
||||
this.controller.selectPackage(pkg)
|
||||
this.lastResults = -Infinity
|
||||
if (key) await this.restoreResults(key)
|
||||
if (persist) {
|
||||
await this.saveSelection()
|
||||
await this.persistSecrets()
|
||||
}
|
||||
}
|
||||
private detach() {
|
||||
this.generation++
|
||||
this.screen = null
|
||||
this.previous = null
|
||||
this.state.screenId = null
|
||||
this.state.connection = 'disabled'
|
||||
}
|
||||
private async raw(server: string, path: string, init: RequestInit = {}): Promise<Response> {
|
||||
try {
|
||||
return await this.fetchAPI(`${server}${path}`, {
|
||||
...init,
|
||||
redirect: 'error',
|
||||
credentials: 'omit',
|
||||
signal: AbortSignal.any([
|
||||
AbortSignal.timeout(30_000),
|
||||
...(init.signal ? [init.signal] : []),
|
||||
]),
|
||||
})
|
||||
} catch {
|
||||
throw new Error('Сервер недоступен или превышено время ожидания')
|
||||
}
|
||||
}
|
||||
private async json(response: Response): Promise<Record<string, unknown>> {
|
||||
if (!response.ok) throw new ApiError(response.status)
|
||||
try {
|
||||
return object(await response.json())
|
||||
} catch {
|
||||
throw new Error('Сервер вернул некорректный JSON')
|
||||
}
|
||||
}
|
||||
private async refresh(failed: string, generation: number) {
|
||||
if (this.credentials?.access !== failed) return
|
||||
if (this.refreshPromise) return this.refreshPromise
|
||||
const c = this.credentials!
|
||||
this.refreshPromise = (async () => {
|
||||
const response = await this.raw(c.server, '/api/auth/refresh', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ refreshToken: c.refresh }),
|
||||
})
|
||||
if (generation !== this.generation) throw new Error('Сессия изменилась')
|
||||
if (response.status === 401) {
|
||||
this.credentials = null
|
||||
this.state.authenticated = false
|
||||
await this.persistSecrets()
|
||||
throw new ApiError(401)
|
||||
}
|
||||
const result = await this.json(response)
|
||||
if (generation !== this.generation) throw new Error('Сессия изменилась')
|
||||
this.credentials = {
|
||||
...c,
|
||||
access: token(result.accessToken),
|
||||
refresh: token(result.refreshToken),
|
||||
}
|
||||
await this.persistSecrets()
|
||||
})().finally(() => {
|
||||
this.refreshPromise = null
|
||||
})
|
||||
return this.refreshPromise
|
||||
}
|
||||
private async authorized(path: string, init: RequestInit = {}) {
|
||||
const c = this.credentials
|
||||
const generation = this.generation
|
||||
if (!c) throw new ApiError(401)
|
||||
const request = (access: string) => {
|
||||
const headers = new Headers(init.headers)
|
||||
headers.set('Authorization', `Bearer ${access}`)
|
||||
return this.raw(c.server, path, { ...init, headers })
|
||||
}
|
||||
let response = await request(c.access)
|
||||
if (generation !== this.generation) throw new Error('Сессия изменилась')
|
||||
if (response.status === 401) {
|
||||
await response.body?.cancel()
|
||||
await this.refresh(c.access, generation)
|
||||
if (generation !== this.generation || !this.credentials) throw new ApiError(401)
|
||||
response = await request(this.credentials.access)
|
||||
if (response.status === 401) {
|
||||
this.credentials = null
|
||||
this.state.authenticated = false
|
||||
await this.persistSecrets()
|
||||
}
|
||||
}
|
||||
return response
|
||||
}
|
||||
private async api(path: string, body?: object, authorized = true, signal?: AbortSignal) {
|
||||
const init: RequestInit =
|
||||
body === undefined
|
||||
? { signal }
|
||||
: {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify(body),
|
||||
signal,
|
||||
}
|
||||
return this.json(
|
||||
authorized
|
||||
? await this.authorized(path, init)
|
||||
: await this.raw(this.state.server, path, init),
|
||||
)
|
||||
}
|
||||
async act(input: unknown): Promise<OnlineState> {
|
||||
const data = object(input)
|
||||
if (data.action === 'cancel') {
|
||||
this.cancellation?.abort()
|
||||
this.packages.cancel()
|
||||
return this.snapshot()
|
||||
}
|
||||
if (this.busy) throw new Error('Подождите завершения текущего действия')
|
||||
this.state.busy = true
|
||||
this.state.error = ''
|
||||
this.state.notice = ''
|
||||
try {
|
||||
await this.perform(data)
|
||||
} catch (error) {
|
||||
this.state.error = error instanceof Error ? error.message : 'Действие не выполнено'
|
||||
throw new Error(this.state.error)
|
||||
} finally {
|
||||
this.state.busy = false
|
||||
this.state.progress = null
|
||||
}
|
||||
return this.snapshot()
|
||||
}
|
||||
private async perform(data: Record<string, unknown>) {
|
||||
const action = data.action as OnlineIntent['action']
|
||||
switch (action) {
|
||||
case 'login': {
|
||||
const server = serverURL(data.server)
|
||||
const email = text(data.email).trim()
|
||||
const password = text(data.password)
|
||||
if (!email.includes('@') || email.length > 320 || !password || password.length > 4096)
|
||||
throw new Error('Укажите email и пароль')
|
||||
this.detach()
|
||||
this.credentials = null
|
||||
this.state.authenticated = false
|
||||
this.state.games = []
|
||||
await this.persistSecrets()
|
||||
this.state.server = server
|
||||
const response = await this.raw(server, '/api/auth/login', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ email, password }),
|
||||
})
|
||||
const result = await this.json(response)
|
||||
this.credentials = {
|
||||
server,
|
||||
access: token(result.accessToken),
|
||||
refresh: token(result.refreshToken),
|
||||
screen: null,
|
||||
}
|
||||
try {
|
||||
const me = object((await this.api('/api/users/me')).user)
|
||||
if (
|
||||
!Array.isArray(me.roles) ||
|
||||
!me.roles.some((r) => ['admin', 'organizer', 'author'].includes(String(r)))
|
||||
)
|
||||
throw new Error(
|
||||
'Для управления экраном нужны права организатора, автора или администратора',
|
||||
)
|
||||
} catch (error) {
|
||||
this.credentials = null
|
||||
await this.persistSecrets()
|
||||
throw error
|
||||
}
|
||||
this.state.authenticated = true
|
||||
await this.persistSecrets()
|
||||
await this.saveSelection()
|
||||
await this.loadGames()
|
||||
return
|
||||
}
|
||||
case 'logout':
|
||||
this.detach()
|
||||
this.credentials = null
|
||||
this.state.authenticated = false
|
||||
this.state.games = []
|
||||
await this.persistSecrets()
|
||||
return
|
||||
case 'games':
|
||||
return this.loadGames()
|
||||
case 'download':
|
||||
case 'check': {
|
||||
const gameId = integer(data.gameId, 1)
|
||||
const key = packageKey(this.state.server, gameId)
|
||||
if (
|
||||
action === 'download' &&
|
||||
key === this.controller.state.catalog.key &&
|
||||
this.controller.state.outputOpen
|
||||
)
|
||||
throw new Error('Закройте показ перед обновлением выбранной игры')
|
||||
if (!this.credentials) throw new ApiError(401)
|
||||
this.downloadKey = action === 'download' ? key : null
|
||||
this.cancellation = new AbortController()
|
||||
this.state.canCancel = true
|
||||
try {
|
||||
const description = await prepareScreenPackage(
|
||||
{
|
||||
server: this.state.server,
|
||||
gameId,
|
||||
token: this.credentials.access,
|
||||
signal: this.cancellation.signal,
|
||||
},
|
||||
(url, init) => {
|
||||
const parsed = new URL(String(url))
|
||||
if (parsed.origin !== this.state.server) throw new Error('Недопустимый сервер API')
|
||||
return this.authorized(parsed.pathname, init)
|
||||
},
|
||||
)
|
||||
if (action === 'check') {
|
||||
const previous = this.packages.list().find((p) => p.key === key)
|
||||
this.state.notice = !previous
|
||||
? 'Игра ещё не загружена'
|
||||
: previous.package.metadataVersion === description.metadataVersion
|
||||
? 'Описание не изменилось. Для проверки замены файлов по прежним адресам загрузите материалы повторно'
|
||||
: 'На сервере есть изменения. Загрузите материалы при закрытом показе'
|
||||
return
|
||||
}
|
||||
const pkg = await this.packages.download(description, {
|
||||
signal: this.cancellation.signal,
|
||||
onProgress: (p) => {
|
||||
this.state.progress = p
|
||||
},
|
||||
})
|
||||
this.state.packagesRevision++
|
||||
if (key === this.controller.state.catalog.key) {
|
||||
this.controller.selectPackage(pkg)
|
||||
this.previous = null
|
||||
await this.restoreResults(key)
|
||||
}
|
||||
this.state.notice = 'Материалы проверены и готовы к показу'
|
||||
} finally {
|
||||
this.cancellation = null
|
||||
this.state.canCancel = false
|
||||
this.downloadKey = null
|
||||
}
|
||||
return
|
||||
}
|
||||
case 'remove': {
|
||||
const key = text(data.key)
|
||||
if (!/^[a-f0-9]{64}$/.test(key)) throw new Error('Некорректный пакет')
|
||||
if (key === this.controller.state.catalog.key)
|
||||
throw new Error('Сначала выберите другой пакет или тестовый режим')
|
||||
await this.packages.remove(key)
|
||||
await rm(join(this.directory, `results-${key}.json`), { force: true })
|
||||
this.state.packagesRevision++
|
||||
return
|
||||
}
|
||||
case 'connect': {
|
||||
const pkg = this.packages.list().find((p) => p.key === this.controller.state.catalog.key)
|
||||
if (!pkg || pkg.package.server !== this.state.server)
|
||||
throw new Error('Выберите готовую игру с этого сервера')
|
||||
if (!this.credentials) throw new ApiError(401)
|
||||
this.detach()
|
||||
const result = await this.api('/api/screens', {}, false)
|
||||
const s: ScreenSession = {
|
||||
id: String(integer(result.screenID, 1)),
|
||||
token: token(result.accessToken),
|
||||
gameId: pkg.package.game.id,
|
||||
}
|
||||
await this.api(`/api/screens/${s.id}/bind`, {
|
||||
screenID: s.id,
|
||||
accessToken: s.token,
|
||||
gameID: s.gameId,
|
||||
})
|
||||
this.screen = s
|
||||
this.state.screenId = s.id
|
||||
this.state.connection = 'waiting'
|
||||
this.initialSound = true
|
||||
await this.persistSecrets()
|
||||
return
|
||||
}
|
||||
case 'disconnect':
|
||||
this.detach()
|
||||
await this.persistSecrets()
|
||||
return
|
||||
case 'sound':
|
||||
if (!this.screen) throw new Error('Сначала подключите управление')
|
||||
await this.api(`/api/screens/${this.screen.id}/sound`, {
|
||||
screenID: this.screen.id,
|
||||
soundEnabled: true,
|
||||
})
|
||||
return
|
||||
case 'results':
|
||||
return this.refreshResults()
|
||||
default:
|
||||
throw new Error('Неизвестное действие')
|
||||
}
|
||||
}
|
||||
private async loadGames() {
|
||||
const result = await this.api('/api/games')
|
||||
if (!Array.isArray(result.games ?? [])) throw new Error('Некорректный список игр')
|
||||
this.state.games = ((result.games ?? []) as unknown[]).map((value) => {
|
||||
const g = object(value)
|
||||
return { id: integer(g.ID, 1), name: text(g.name), status: text(g.status ?? '') }
|
||||
})
|
||||
}
|
||||
private async restoreResults(key: string) {
|
||||
try {
|
||||
this.controller.setResults(
|
||||
parseResults(
|
||||
JSON.parse(await readFile(join(this.directory, `results-${key}.json`), 'utf8')),
|
||||
key,
|
||||
),
|
||||
)
|
||||
} catch (error) {
|
||||
if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
|
||||
this.state.error = 'Сохранённые результаты недоступны; обновите снимок'
|
||||
}
|
||||
}
|
||||
async refreshResults() {
|
||||
if (this.resultsBusy) return
|
||||
const s = this.screen
|
||||
const key = this.controller.state.catalog.key
|
||||
if (!s || !key) throw new Error('Подключите экран к выбранной игре для получения результатов')
|
||||
const generation = this.generation
|
||||
this.resultsBusy = true
|
||||
this.lastResults = Date.now()
|
||||
try {
|
||||
const result = await this.api(
|
||||
'/api/screens/results',
|
||||
{ screenID: s.id, accessToken: s.token },
|
||||
false,
|
||||
)
|
||||
if (generation !== this.generation || key !== this.controller.state.catalog.key) return
|
||||
if (!Array.isArray(result.questions ?? []) || !Array.isArray(result.teams ?? []))
|
||||
throw new Error('Некорректные результаты')
|
||||
const snapshot: ResultsSnapshot = parseResults(
|
||||
{
|
||||
packageKey: key,
|
||||
capturedAt: new Date().toISOString(),
|
||||
questions: result.questions ?? [],
|
||||
teams: ((result.teams ?? []) as unknown[]).map((value) => {
|
||||
const row = object(value)
|
||||
const team = object(row.team)
|
||||
if (!Array.isArray(row.answers ?? [])) throw new Error('Некорректные ответы')
|
||||
return {
|
||||
id: text(team.ID),
|
||||
name: text(team.name),
|
||||
place: integer(row.place, 1),
|
||||
totalScore: integer(row.totalScore ?? 0, -2147483648),
|
||||
actionsCount: integer(row.actionsCount ?? 0),
|
||||
answers: ((row.answers ?? []) as unknown[]).map((value) => {
|
||||
const a = object(value)
|
||||
return {
|
||||
questionCode: text(a.questionCode),
|
||||
score: integer(a.score ?? 0, -2147483648),
|
||||
}
|
||||
}),
|
||||
}
|
||||
}),
|
||||
},
|
||||
key,
|
||||
)
|
||||
await this.atomic(`results-${key}.json`, JSON.stringify(snapshot))
|
||||
if (generation === this.generation && key === this.controller.state.catalog.key)
|
||||
this.controller.setResults(snapshot)
|
||||
} finally {
|
||||
this.resultsBusy = false
|
||||
}
|
||||
}
|
||||
async poll() {
|
||||
const s = this.screen
|
||||
const session = this.controller.state.session
|
||||
if (!s || !this.controller.state.outputOpen) {
|
||||
this.previous = null
|
||||
if (s) this.state.connection = 'waiting'
|
||||
return
|
||||
}
|
||||
if (this.pollBusy) return
|
||||
if (this.pollSession !== session) {
|
||||
this.previous = null
|
||||
this.pollSession = session
|
||||
}
|
||||
this.pollBusy = true
|
||||
const generation = this.generation
|
||||
try {
|
||||
const result = await this.api(
|
||||
'/api/screens/state',
|
||||
{ screenID: s.id, accessToken: s.token },
|
||||
false,
|
||||
AbortSignal.timeout(5000),
|
||||
)
|
||||
if (
|
||||
generation !== this.generation ||
|
||||
session !== this.controller.state.session ||
|
||||
!this.controller.state.outputOpen
|
||||
)
|
||||
return
|
||||
let next = parseRemote(result.state)
|
||||
if (next.gameId !== s.gameId) {
|
||||
this.detach()
|
||||
await this.persistSecrets()
|
||||
this.state.error =
|
||||
'Привязка экрана изменилась на сервере. Локальный показ сохранён; подключите управление заново'
|
||||
return
|
||||
}
|
||||
const previous = this.previous
|
||||
if (previous && next.version < previous.version)
|
||||
next = { ...previous, sound: next.sound, music: next.music }
|
||||
if (previous?.music && next.music && next.music.version < previous.music.version)
|
||||
next = { ...next, music: previous.music }
|
||||
this.previous = next
|
||||
if (this.state.connection === 'offline') this.state.error = ''
|
||||
this.state.connection = 'connected'
|
||||
if (!previous && this.initialSound) {
|
||||
this.initialSound = false
|
||||
send(this.controller, { action: 'mute', enabled: !next.sound })
|
||||
}
|
||||
if (previous) {
|
||||
try {
|
||||
applyRemote(this.controller, previous, next)
|
||||
} catch (error) {
|
||||
this.state.error = error instanceof Error ? error.message : 'Команда сервера не выполнена'
|
||||
}
|
||||
}
|
||||
if (this.controller.state.scene.mode === 6 && Date.now() - this.lastResults >= 5000)
|
||||
void this.refreshResults().catch((error) => {
|
||||
this.state.error =
|
||||
error instanceof Error ? error.message : 'Не удалось обновить результаты'
|
||||
})
|
||||
} catch (error) {
|
||||
if (generation !== this.generation || session !== this.controller.state.session) return
|
||||
this.previous = null
|
||||
if (error instanceof ApiError && error.status === 401) {
|
||||
this.detach()
|
||||
this.state.connection = 'expired'
|
||||
await this.persistSecrets().catch(() => {})
|
||||
} else this.state.connection = 'offline'
|
||||
this.state.error =
|
||||
error instanceof Error ? error.message : 'Не удалось получить состояние экрана'
|
||||
} finally {
|
||||
this.pollBusy = false
|
||||
}
|
||||
}
|
||||
async musicEnded(report: Report) {
|
||||
const m = this.previous?.music
|
||||
const c = this.controller.state.channels.music
|
||||
if (
|
||||
!this.screen ||
|
||||
!m ||
|
||||
this.advanceBusy ||
|
||||
this.state.connection !== 'connected' ||
|
||||
report.channel !== 'music' ||
|
||||
report.status !== 'ended' ||
|
||||
report.session !== this.controller.state.session ||
|
||||
report.operation !== c.operation ||
|
||||
c.desired !== 'playing' ||
|
||||
c.playlistId !== m.playlistId ||
|
||||
c.source?.id !== `track-${m.playlistId}-${m.trackId}` ||
|
||||
m.playback !== 2
|
||||
)
|
||||
return
|
||||
this.advanceBusy = true
|
||||
const generation = this.generation
|
||||
try {
|
||||
const result = await this.api(
|
||||
'/api/screens/music/advance',
|
||||
{ screenID: this.screen.id, accessToken: this.screen.token },
|
||||
false,
|
||||
AbortSignal.timeout(5000),
|
||||
)
|
||||
if (generation === this.generation && this.previous?.music?.version === m.version) {
|
||||
const music = parseRemote({ music: result.state }).music
|
||||
if (music) this.previous = { ...this.previous, music }
|
||||
}
|
||||
} catch {
|
||||
if (generation === this.generation) {
|
||||
this.previous = null
|
||||
this.state.connection = 'offline'
|
||||
this.state.error = 'Переход музыки выполнен локально; сервер не подтвердил обновление'
|
||||
}
|
||||
} finally {
|
||||
this.advanceBusy = false
|
||||
}
|
||||
}
|
||||
close() {
|
||||
this.cancellation?.abort()
|
||||
this.packages.cancel()
|
||||
this.detach()
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user