592 lines
22 KiB
JavaScript
592 lines
22 KiB
JavaScript
const { version: appVersion } = require('#root/package.json');
|
|
|
|
const VERSIONED_MIGRATIONS = [
|
|
{
|
|
version: '2.1.0',
|
|
label: 'v2.1.0 player registry schema',
|
|
run: async function (pool) {
|
|
// Keep the player registry as the source of truth for device metadata.
|
|
if (!(await columnExists(pool, 'd_players', 'public_base_url'))) {
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS d_players (
|
|
device_id VARCHAR(128) PRIMARY KEY,
|
|
public_base_url VARCHAR(512) NULL,
|
|
internal_base_url VARCHAR(512) NULL,
|
|
last_seen_at TIMESTAMP NULL,
|
|
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
modified_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
}
|
|
|
|
// Store the player pointer on screens so we can resolve the player without needing a player-side screen_id.
|
|
// This is the singleton-player shortcut; a multi-player model should make this relational instead of hardcoded to '1'.
|
|
if (!(await columnExists(pool, 'd_screens', 'player_id'))) {
|
|
await pool.query("ALTER TABLE d_screens ADD COLUMN player_id VARCHAR(128) NOT NULL DEFAULT '1' AFTER playlist_id");
|
|
} else {
|
|
await pool.query("UPDATE d_screens SET player_id = '1' WHERE player_id IS NULL OR player_id <> '1'");
|
|
|
|
const [playerColumnNullableRows] = await pool.query(
|
|
`SELECT COUNT(*) AS nullable_count
|
|
FROM information_schema.COLUMNS
|
|
WHERE TABLE_SCHEMA = DATABASE()
|
|
AND TABLE_NAME = 'd_screens'
|
|
AND COLUMN_NAME = 'player_id'
|
|
AND IS_NULLABLE = 'YES'`
|
|
);
|
|
if (Number(playerColumnNullableRows && playerColumnNullableRows[0] && playerColumnNullableRows[0].nullable_count) > 0) {
|
|
await pool.query("ALTER TABLE d_screens MODIFY COLUMN player_id VARCHAR(128) NOT NULL DEFAULT '1' AFTER playlist_id");
|
|
}
|
|
}
|
|
|
|
const [screenPlayerUniqueRows] = await pool.query(
|
|
`SELECT COUNT(*) AS index_count
|
|
FROM information_schema.STATISTICS
|
|
WHERE TABLE_SCHEMA = DATABASE()
|
|
AND TABLE_NAME = 'd_screens'
|
|
AND INDEX_NAME = 'uq_screens_player_id'`
|
|
);
|
|
if (Number(screenPlayerUniqueRows && screenPlayerUniqueRows[0] && screenPlayerUniqueRows[0].index_count) > 0) {
|
|
await pool.query('ALTER TABLE d_screens DROP INDEX uq_screens_player_id');
|
|
}
|
|
|
|
// Recreate the screen-to-player foreign key after the column exists and legacy data is copied over.
|
|
await ensureForeignKey(pool, 'd_screens', 'fk_screens_player', 'player_id', 'd_players', 'device_id', 'RESTRICT');
|
|
|
|
if (await columnExists(pool, 'c_template_regions', 'font_family')) {
|
|
await pool.query('ALTER TABLE c_template_regions DROP COLUMN font_family');
|
|
}
|
|
|
|
}
|
|
},
|
|
{
|
|
version: '2.1.1',
|
|
label: 'v2.1.1 API source schema',
|
|
run: async function (pool) {
|
|
await ensureColumn(pool, 'i_api_sources', 'auth_method', "VARCHAR(32) NOT NULL DEFAULT 'none'", 'api_url');
|
|
await ensureColumn(pool, 'i_api_sources', 'auth_username', 'VARCHAR(255) NULL', 'auth_method');
|
|
await ensureColumn(pool, 'i_api_sources', 'auth_password', 'MEDIUMTEXT NULL', 'auth_username');
|
|
await ensureColumn(pool, 'i_api_sources', 'auth_bearer_token', 'MEDIUMTEXT NULL', 'auth_password');
|
|
await ensureColumn(pool, 'i_api_sources', 'auth_header_name', 'VARCHAR(255) NULL', 'auth_bearer_token');
|
|
await ensureColumn(pool, 'i_api_sources', 'auth_header_value', 'MEDIUMTEXT NULL', 'auth_header_name');
|
|
await ensureColumn(pool, 'i_api_sources', 'items_path', 'VARCHAR(255) NULL', 'auth_header_value');
|
|
}
|
|
},
|
|
{
|
|
version: '2.2.0',
|
|
label: 'v2.2.0 announcement schema',
|
|
run: async function (pool) {
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS d_announcements (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
message TEXT NOT NULL,
|
|
short_label VARCHAR(255) NOT NULL DEFAULT '',
|
|
announcement_type VARCHAR(32) NOT NULL DEFAULT 'lower-third',
|
|
color_key VARCHAR(32) NOT NULL DEFAULT 'primary',
|
|
icon_key VARCHAR(64) NOT NULL DEFAULT 'megaphone-fill',
|
|
duration_seconds INT NULL,
|
|
expires_at TIMESTAMP NULL,
|
|
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
created_by INT NULL,
|
|
modified_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
modified_by INT NULL,
|
|
INDEX idx_announcements_expires_at (expires_at),
|
|
INDEX idx_announcements_modified_at (modified_at)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
}
|
|
},
|
|
{
|
|
version: '2.4.0',
|
|
label: 'v2.4.0 playlist schedule rules schema',
|
|
run: async function (pool) {
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS c_playlist_slide_schedule_rules (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
playlist_slide_id INT NOT NULL,
|
|
position INT NOT NULL DEFAULT 0,
|
|
start_datetime DATETIME NULL,
|
|
end_datetime DATETIME NULL,
|
|
start_time TIME NULL,
|
|
end_time TIME NULL,
|
|
schedule_days_json JSON NULL,
|
|
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
created_by INT NULL,
|
|
modified_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
modified_by INT NULL,
|
|
CONSTRAINT fk_playlist_slide_schedule_rules_slide FOREIGN KEY (playlist_slide_id) REFERENCES c_playlist_slides(id) ON DELETE CASCADE,
|
|
INDEX idx_playlist_slide_schedule_rules_slide_position (playlist_slide_id, position)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
const legacyColumnNames = [
|
|
'schedule_mode',
|
|
'schedule_start_datetime',
|
|
'schedule_end_datetime',
|
|
'schedule_start_time',
|
|
'schedule_end_time',
|
|
'schedule_days_json',
|
|
'schedule_rules_json'
|
|
];
|
|
const existingLegacyColumns = [];
|
|
for (const columnName of legacyColumnNames) {
|
|
if (await columnExists(pool, 'c_playlist_slides', columnName)) {
|
|
existingLegacyColumns.push(columnName);
|
|
}
|
|
}
|
|
|
|
const selectColumns = ['id'].concat(existingLegacyColumns).join(', ');
|
|
const [legacyRows] = await pool.query('SELECT ' + selectColumns + ' FROM c_playlist_slides');
|
|
|
|
for (const row of legacyRows) {
|
|
const rules = normalizeLegacyScheduleRules(row);
|
|
if (rules.length) {
|
|
for (let index = 0; index < rules.length; index += 1) {
|
|
const rule = rules[index];
|
|
await pool.query(
|
|
'INSERT INTO c_playlist_slide_schedule_rules (playlist_slide_id, position, start_datetime, end_datetime, start_time, end_time, schedule_days_json, created_by, modified_by) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, NULL)',
|
|
[row.id, index, rule.start_datetime || null, rule.end_datetime || null, rule.start_time || null, rule.end_time || null, rule.schedule_days_json ? JSON.stringify(rule.schedule_days_json) : null]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
await dropColumnIfExists(pool, 'c_playlist_slides', 'schedule_rules_json');
|
|
await dropColumnIfExists(pool, 'c_playlist_slides', 'schedule_mode');
|
|
await dropColumnIfExists(pool, 'c_playlist_slides', 'schedule_start_datetime');
|
|
await dropColumnIfExists(pool, 'c_playlist_slides', 'schedule_end_datetime');
|
|
await dropColumnIfExists(pool, 'c_playlist_slides', 'schedule_start_time');
|
|
await dropColumnIfExists(pool, 'c_playlist_slides', 'schedule_end_time');
|
|
await dropColumnIfExists(pool, 'c_playlist_slides', 'schedule_days_json');
|
|
await pool.query(`
|
|
CREATE TABLE IF NOT EXISTS d_announcement_screens (
|
|
announcement_id INT NOT NULL,
|
|
screen_id INT NOT NULL,
|
|
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
created_by INT NULL,
|
|
modified_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
modified_by INT NULL,
|
|
PRIMARY KEY (announcement_id, screen_id),
|
|
INDEX idx_announcement_screens_screen_id (screen_id),
|
|
CONSTRAINT fk_announcement_screens_announcement FOREIGN KEY (announcement_id) REFERENCES d_announcements(id) ON DELETE CASCADE,
|
|
CONSTRAINT fk_announcement_screens_screen FOREIGN KEY (screen_id) REFERENCES d_screens(id) ON DELETE CASCADE
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
}
|
|
},
|
|
{
|
|
version: '2.4.2',
|
|
label: 'v2.4.2 playlist canvas id schema',
|
|
run: async function (pool) {
|
|
await ensureColumn(pool, 'c_playlists', 'canvas_id', 'INT NULL', 'skip_unavailable_rtmp');
|
|
await ensureForeignKey(pool, 'c_playlists', 'fk_playlists_canvas', 'canvas_id', 'c_canvas_sizes', 'id', 'SET NULL');
|
|
await ensureColumn(pool, 'c_playlist_slides', 'disable_audio', 'TINYINT(1) NOT NULL DEFAULT 1', 'use_video_duration');
|
|
await pool.query(`
|
|
UPDATE c_playlists p
|
|
JOIN (
|
|
SELECT ps.playlist_id,
|
|
COUNT(DISTINCT CONCAT(cs.width, 'x', cs.height)) AS signature_count,
|
|
MIN(CONCAT(cs.width, 'x', cs.height)) AS canvas_signature
|
|
FROM c_playlist_slides ps
|
|
JOIN c_slides sl ON sl.id = ps.slide_id
|
|
LEFT JOIN c_templates st ON st.id = sl.template_id
|
|
LEFT JOIN c_canvas_sizes cs ON cs.id = st.canvas_size_id
|
|
WHERE cs.width IS NOT NULL
|
|
AND cs.height IS NOT NULL
|
|
GROUP BY ps.playlist_id
|
|
) x ON x.playlist_id = p.id
|
|
JOIN c_canvas_sizes cs ON CONCAT(cs.width, 'x', cs.height) = x.canvas_signature
|
|
SET p.canvas_id = cs.id
|
|
WHERE (p.canvas_id IS NULL)
|
|
AND x.signature_count = 1
|
|
`);
|
|
}
|
|
},
|
|
{
|
|
version: '2.5.1',
|
|
label: 'v2.5.1 template animation json schema',
|
|
run: async function (pool) {
|
|
await ensureColumn(pool, 'c_template_regions', 'animation_json', 'JSON NULL', 'lock_ratio');
|
|
}
|
|
},
|
|
{
|
|
version: '2.6.2',
|
|
label: 'v2.6.2 player identity schema',
|
|
run: async function (pool) {
|
|
if (!(await columnExists(pool, 'd_players', 'device_id'))) {
|
|
await dropForeignKeyIfExists(pool, 'd_screens', 'player_id');
|
|
|
|
if (!(await columnExists(pool, 'd_players', 'identifier'))) {
|
|
await ensureColumn(pool, 'd_players', 'identifier', 'VARCHAR(128) NOT NULL UNIQUE', 'id');
|
|
}
|
|
if (!(await columnExists(pool, 'd_players', 'id'))) {
|
|
await ensureColumn(pool, 'd_players', 'id', 'INT NOT NULL AUTO_INCREMENT', null);
|
|
await pool.query('ALTER TABLE d_players ADD PRIMARY KEY (id)');
|
|
} else if (!(await columnIsAutoIncrement(pool, 'd_players', 'id'))) {
|
|
await pool.query('ALTER TABLE d_players MODIFY COLUMN id INT NOT NULL AUTO_INCREMENT');
|
|
}
|
|
await pool.query('ALTER TABLE d_screens MODIFY COLUMN player_id INT NULL AFTER playlist_id');
|
|
return;
|
|
}
|
|
|
|
await dropForeignKeyIfExists(pool, 'd_screens', 'player_id');
|
|
|
|
await pool.query('DROP TABLE IF EXISTS d_players_rebuild');
|
|
await pool.query(`
|
|
CREATE TABLE d_players_rebuild (
|
|
id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
|
identifier VARCHAR(128) NOT NULL UNIQUE,
|
|
public_base_url VARCHAR(512) NULL,
|
|
internal_base_url VARCHAR(512) NULL,
|
|
last_seen_at TIMESTAMP NULL,
|
|
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
|
modified_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
|
|
`);
|
|
|
|
await pool.query(`
|
|
INSERT INTO d_players_rebuild (identifier, public_base_url, internal_base_url, last_seen_at, created_at, modified_at)
|
|
SELECT DISTINCT
|
|
device_id AS identifier,
|
|
public_base_url,
|
|
internal_base_url,
|
|
last_seen_at,
|
|
created_at,
|
|
modified_at
|
|
FROM d_players
|
|
ORDER BY COALESCE(created_at, modified_at, device_id), device_id
|
|
`);
|
|
|
|
await pool.query('DROP TEMPORARY TABLE IF EXISTS d_player_id_map');
|
|
await pool.query(`
|
|
CREATE TEMPORARY TABLE d_player_id_map AS
|
|
SELECT old_players.device_id AS old_device_id, rebuilt_players.id AS new_player_id
|
|
FROM d_players old_players
|
|
JOIN d_players_rebuild rebuilt_players ON rebuilt_players.identifier = old_players.device_id
|
|
`);
|
|
|
|
await pool.query(
|
|
`UPDATE d_screens s
|
|
JOIN d_player_id_map m ON m.old_device_id = CAST(s.player_id AS CHAR)
|
|
SET s.player_id = m.new_player_id
|
|
WHERE s.player_id IS NOT NULL`
|
|
);
|
|
|
|
await pool.query('DROP TABLE d_players');
|
|
await pool.query('RENAME TABLE d_players_rebuild TO d_players');
|
|
|
|
await pool.query('ALTER TABLE d_screens MODIFY COLUMN player_id INT NULL AFTER playlist_id');
|
|
}
|
|
},
|
|
{
|
|
version: '2.6.3',
|
|
label: 'v2.6.3 screen-player fk removal',
|
|
run: async function (pool) {
|
|
await dropForeignKeyIfExists(pool, 'd_screens', 'player_id');
|
|
if (await columnExists(pool, 'd_screens', 'player_id')) {
|
|
await pool.query('ALTER TABLE d_screens MODIFY COLUMN player_id INT NULL AFTER playlist_id');
|
|
}
|
|
}
|
|
},
|
|
{
|
|
version: '2.6.4',
|
|
label: 'v2.6.4 drop screen player id',
|
|
run: async function (pool) {
|
|
await dropForeignKeyIfExists(pool, 'd_screens', 'player_id');
|
|
await dropColumnIfExists(pool, 'd_screens', 'player_id');
|
|
}
|
|
}
|
|
];
|
|
|
|
async function columnExists(pool, tableName, columnName) {
|
|
const [rows] = await pool.query(
|
|
`SELECT COUNT(*) AS column_count
|
|
FROM information_schema.COLUMNS
|
|
WHERE TABLE_SCHEMA = DATABASE()
|
|
AND TABLE_NAME = ?
|
|
AND COLUMN_NAME = ?`,
|
|
[tableName, columnName]
|
|
);
|
|
|
|
return Number(rows && rows[0] && rows[0].column_count) > 0;
|
|
}
|
|
|
|
async function columnIsAutoIncrement(pool, tableName, columnName) {
|
|
const [rows] = await pool.query(
|
|
`SELECT COUNT(*) AS auto_increment_count
|
|
FROM information_schema.COLUMNS
|
|
WHERE TABLE_SCHEMA = DATABASE()
|
|
AND TABLE_NAME = ?
|
|
AND COLUMN_NAME = ?
|
|
AND EXTRA LIKE '%auto_increment%'`,
|
|
[tableName, columnName]
|
|
);
|
|
|
|
return Number(rows && rows[0] && rows[0].auto_increment_count) > 0;
|
|
}
|
|
|
|
async function ensureColumn(pool, tableName, columnName, columnDefinition, afterColumn) {
|
|
if (await columnExists(pool, tableName, columnName)) {
|
|
return;
|
|
}
|
|
|
|
const afterClause = afterColumn ? ' AFTER ' + afterColumn : '';
|
|
try {
|
|
await pool.query('ALTER TABLE ' + tableName + ' ADD COLUMN ' + columnName + ' ' + columnDefinition + afterClause);
|
|
} catch (error) {
|
|
if (!error || (error.code !== 'ER_DUP_FIELDNAME' && error.errno !== 1060)) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
async function ensureForeignKey(pool, tableName, constraintName, columnName, referencedTable, referencedColumn, onDeleteAction) {
|
|
const [existingFkRows] = await pool.query(
|
|
`SELECT COUNT(*) AS fk_count
|
|
FROM information_schema.KEY_COLUMN_USAGE
|
|
WHERE TABLE_SCHEMA = DATABASE()
|
|
AND TABLE_NAME = ?
|
|
AND COLUMN_NAME = ?
|
|
AND REFERENCED_TABLE_NAME IS NOT NULL`,
|
|
[tableName, columnName]
|
|
);
|
|
|
|
if (Number(existingFkRows && existingFkRows[0] && existingFkRows[0].fk_count) > 0) {
|
|
return;
|
|
}
|
|
|
|
const [rows] = await pool.query(
|
|
`SELECT COUNT(*) AS fk_count
|
|
FROM information_schema.KEY_COLUMN_USAGE
|
|
WHERE TABLE_SCHEMA = DATABASE()
|
|
AND CONSTRAINT_NAME = ?`,
|
|
[constraintName]
|
|
);
|
|
|
|
if (Number(rows && rows[0] && rows[0].fk_count) > 0) {
|
|
return;
|
|
}
|
|
|
|
const fallbackNames = [
|
|
constraintName,
|
|
tableName + '_' + columnName + '_fk',
|
|
tableName + '_' + columnName + '_fk_2',
|
|
tableName + '_' + columnName + '_fk_3'
|
|
];
|
|
|
|
for (const candidateName of fallbackNames) {
|
|
try {
|
|
await pool.query('ALTER TABLE ' + tableName + ' ADD CONSTRAINT ' + candidateName + ' FOREIGN KEY (' + columnName + ') REFERENCES ' + referencedTable + '(' + referencedColumn + ') ON DELETE ' + onDeleteAction);
|
|
return;
|
|
} catch (error) {
|
|
if (!error || (error.code !== 'ER_FK_DUP_NAME' && error.errno !== 1826 && error.errno !== 121)) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async function dropForeignKeyIfExists(pool, tableName, columnName) {
|
|
const [rows] = await pool.query(
|
|
`SELECT CONSTRAINT_NAME AS constraint_name
|
|
FROM information_schema.KEY_COLUMN_USAGE
|
|
WHERE TABLE_SCHEMA = DATABASE()
|
|
AND TABLE_NAME = ?
|
|
AND COLUMN_NAME = ?
|
|
AND REFERENCED_TABLE_NAME IS NOT NULL
|
|
LIMIT 1`,
|
|
[tableName, columnName]
|
|
);
|
|
|
|
const constraintName = String(rows && rows[0] && rows[0].constraint_name || '').trim();
|
|
if (!constraintName) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
await pool.query('ALTER TABLE ' + tableName + ' DROP FOREIGN KEY ' + constraintName);
|
|
} catch (error) {
|
|
if (!error || (error.code !== 'ER_CANT_DROP_FIELD_OR_KEY' && error.errno !== 1091)) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
|
|
async function dropColumnIfExists(pool, tableName, columnName) {
|
|
if (await columnExists(pool, tableName, columnName)) {
|
|
try {
|
|
await pool.query('ALTER TABLE ' + tableName + ' DROP COLUMN ' + columnName);
|
|
} catch (error) {
|
|
if (!error || (error.code !== 'ER_CANT_DROP_FIELD_OR_KEY' && error.errno !== 1091)) {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function normalizeLegacyScheduleRules(row) {
|
|
const rules = [];
|
|
if (!row) {
|
|
return rules;
|
|
}
|
|
|
|
if (row.schedule_rules_json) {
|
|
try {
|
|
const parsed = JSON.parse(row.schedule_rules_json);
|
|
if (Array.isArray(parsed)) {
|
|
parsed.forEach(function (rule) {
|
|
const normalized = normalizeScheduleRule(rule);
|
|
if (normalized) {
|
|
rules.push(normalized);
|
|
}
|
|
});
|
|
return rules;
|
|
}
|
|
} catch (_error) {
|
|
// fall through to legacy columns
|
|
}
|
|
}
|
|
|
|
const mode = String(row.schedule_mode || 'always').trim().toLowerCase();
|
|
if (mode === 'dates' && row.schedule_start_datetime && row.schedule_end_datetime) {
|
|
rules.push({
|
|
start_datetime: formatMigrationDateTime(row.schedule_start_datetime),
|
|
end_datetime: formatMigrationDateTime(row.schedule_end_datetime)
|
|
});
|
|
return rules;
|
|
}
|
|
|
|
if (mode === 'times' && row.schedule_start_time && row.schedule_end_time) {
|
|
const days = normalizeMigrationDays(row.schedule_days_json);
|
|
const rule = {
|
|
start_time: formatMigrationTime(row.schedule_start_time),
|
|
end_time: formatMigrationTime(row.schedule_end_time)
|
|
};
|
|
if (days.length) {
|
|
rule.schedule_days_json = days;
|
|
}
|
|
rules.push(rule);
|
|
}
|
|
|
|
return rules;
|
|
}
|
|
|
|
function normalizeScheduleRule(rule) {
|
|
if (!rule || typeof rule !== 'object') {
|
|
return null;
|
|
}
|
|
const normalized = {};
|
|
if (rule.start_datetime) {
|
|
normalized.start_datetime = String(rule.start_datetime);
|
|
}
|
|
if (rule.end_datetime) {
|
|
normalized.end_datetime = String(rule.end_datetime);
|
|
}
|
|
if (rule.start_time) {
|
|
normalized.start_time = String(rule.start_time).slice(0, 5);
|
|
}
|
|
if (rule.end_time) {
|
|
normalized.end_time = String(rule.end_time).slice(0, 5);
|
|
}
|
|
if (Array.isArray(rule.schedule_days_json)) {
|
|
normalized.schedule_days_json = rule.schedule_days_json;
|
|
} else if (Array.isArray(rule.days)) {
|
|
normalized.schedule_days_json = rule.days;
|
|
}
|
|
return Object.keys(normalized).length ? normalized : null;
|
|
}
|
|
|
|
function formatMigrationDateTime(value) {
|
|
if (!value) {
|
|
return null;
|
|
}
|
|
const date = value instanceof Date ? value : new Date(value);
|
|
if (Number.isNaN(date.getTime())) {
|
|
return null;
|
|
}
|
|
const year = date.getFullYear();
|
|
const month = String(date.getMonth() + 1).padStart(2, '0');
|
|
const day = String(date.getDate()).padStart(2, '0');
|
|
const hours = String(date.getHours()).padStart(2, '0');
|
|
const minutes = String(date.getMinutes()).padStart(2, '0');
|
|
return year + '-' + month + '-' + day + 'T' + hours + ':' + minutes;
|
|
}
|
|
|
|
function formatMigrationTime(value) {
|
|
if (!value) {
|
|
return null;
|
|
}
|
|
return String(value).slice(0, 5);
|
|
}
|
|
|
|
function normalizeMigrationDays(value) {
|
|
let parsed = [];
|
|
if (Array.isArray(value)) {
|
|
parsed = value;
|
|
} else if (value) {
|
|
try {
|
|
const raw = typeof value === 'string' ? JSON.parse(value) : value;
|
|
parsed = Array.isArray(raw) ? raw : [];
|
|
} catch (_error) {
|
|
parsed = [];
|
|
}
|
|
}
|
|
|
|
return Array.from(new Set(parsed.map(function (day) {
|
|
return Number(day);
|
|
}).filter(function (day) {
|
|
return Number.isInteger(day) && day >= 0 && day <= 6;
|
|
}))).sort(function (left, right) {
|
|
return left - right;
|
|
});
|
|
}
|
|
|
|
function compareVersions(leftVersion, rightVersion) {
|
|
const leftParts = String(leftVersion || '0.0.0').split('.').map(function (value) {
|
|
return Number(value) || 0;
|
|
});
|
|
const rightParts = String(rightVersion || '0.0.0').split('.').map(function (value) {
|
|
return Number(value) || 0;
|
|
});
|
|
const length = Math.max(leftParts.length, rightParts.length);
|
|
for (let index = 0; index < length; index += 1) {
|
|
const leftPart = leftParts[index] || 0;
|
|
const rightPart = rightParts[index] || 0;
|
|
if (leftPart > rightPart) {
|
|
return 1;
|
|
}
|
|
if (leftPart < rightPart) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
async function runMigrations(pool, options) {
|
|
// Only run migrations that are newer than the installed schema version and not beyond the app version.
|
|
const targetVersion = String(appVersion || '0.0.0').trim();
|
|
const currentVersion = String(options && options.currentVersion || '0.0.0').trim();
|
|
const legacyPlayerSchemaPresent = await columnExists(pool, 'd_players', 'device_id');
|
|
const screenPlayerColumnPresent = await columnExists(pool, 'd_screens', 'player_id');
|
|
let effectiveCurrentVersion = currentVersion;
|
|
|
|
if (!legacyPlayerSchemaPresent && compareVersions(effectiveCurrentVersion, '2.1.0') < 0) {
|
|
effectiveCurrentVersion = '2.1.0';
|
|
}
|
|
|
|
if (!screenPlayerColumnPresent && compareVersions(effectiveCurrentVersion, '2.6.3') < 0) {
|
|
effectiveCurrentVersion = '2.6.3';
|
|
}
|
|
|
|
for (const migration of VERSIONED_MIGRATIONS) {
|
|
if (compareVersions(migration.version, effectiveCurrentVersion) > 0 && compareVersions(migration.version, targetVersion) <= 0) {
|
|
await migration.run(pool);
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
appVersion: appVersion,
|
|
runMigrations: runMigrations
|
|
};
|