pulse-signage/src/player/playlist.js

const crypto = require('crypto');
const fs = require('fs');
const path = require('path');

function createPlayerPlaylistService(options) {
  const pool = options && options.pool ? options.pool : null;
  const common = options && options.common ? options.common : null;
  const snapshotDir = options && options.snapshotDir ? options.snapshotDir : null;

  if (!pool) {
    throw new Error('pool is required');
  }
  if (!common) {
    throw new Error('common is required');
  }

  function getSnapshotFilePath(slug) {
    if (!snapshotDir) {
      return null;
    }
    const normalizedSlug = String(slug || '').trim();
    if (!normalizedSlug) {
      return null;
    }
    return path.join(snapshotDir, `${normalizedSlug}.json`);
  }

  async function readSnapshot(slug) {
    const filePath = getSnapshotFilePath(slug);
    if (!filePath) {
      return null;
    }
    try {
      const raw = await fs.promises.readFile(filePath, 'utf8');
      const parsed = JSON.parse(raw);
      if (!parsed || typeof parsed !== 'object') {
        return null;
      }
      return parsed;
    } catch (error) {
      if (error && error.code === 'ENOENT') {
        return null;
      }
      return null;
    }
  }

  async function writeSnapshot(slug, payload) {
    const filePath = getSnapshotFilePath(slug);
    if (!filePath) {
      return;
    }
    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
    await fs.promises.writeFile(filePath, JSON.stringify(payload, null, 2), 'utf8');
  }

  async function buildScreenPlaylist(slug) {
    try {
      const [screenRows] = await pool.query('SELECT id, name, slug, playlist_id, created_at, modified_at, created_by, modified_by FROM screens WHERE slug = ?', [slug]);
      if (!screenRows.length) {
        return { screen: null, playlist: null, slides: [], rssFeeds: [], apiSources: [] };
      }

      const screen = screenRows[0];
      if (!screen.playlist_id) {
        const payloadWithoutPlaylist = {
          screen: screen,
          playlist: null,
          slides: [],
          revision: getPlaylistRevision(screen, null, [], [], [], [], [])
        };
        await writeSnapshot(slug, payloadWithoutPlaylist);
        return payloadWithoutPlaylist;
      }

            const [playlistRows] = await pool.query('SELECT id, name, fade_between_slides, skip_unavailable_rtmp, created_at, modified_at, created_by, modified_by FROM playlists WHERE id = ?', [screen.playlist_id]);
      const playlist = playlistRows[0] || null;
      const [slideRows] = await pool.query(`
         SELECT sl.id, sl.title, sl.body, sl.template_id, sl.content_json, sl.media_path, sl.media_type, sl.created_at, sl.modified_at,
           ps.position, ps.duration_seconds AS duration_seconds, ps.use_video_duration, ps.schedule_mode, ps.schedule_start_datetime, ps.schedule_end_datetime, ps.schedule_start_time, ps.schedule_end_time, ps.schedule_days_json,
               st.name AS template_name, cs.name AS canvas_size_name, cs.width AS canvas_size_width, cs.height AS canvas_size_height, cs.width AS canvas_width, cs.height AS canvas_height
        FROM playlist_slides ps
        JOIN slides sl ON sl.id = ps.slide_id
        LEFT JOIN slide_templates st ON st.id = sl.template_id
        LEFT JOIN canvas_sizes cs ON cs.id = st.canvas_size_id
        WHERE ps.playlist_id = ?
        ORDER BY ps.position ASC, ps.id ASC
      `, [screen.playlist_id]);

      const templateIds = slideRows
        .filter(function (slide) { return slide.template_id; })
        .map(function (slide) { return slide.template_id; });
      const templatesById = {};
      let templateRows = [];
      let regionRows = [];
      if (templateIds.length) {
        [templateRows] = await pool.query(`
                SELECT st.id, st.name, st.canvas_size_id, st.background_image_path, st.background_color, st.created_at, st.modified_at,
                 cs.name AS canvas_size_name, cs.width AS canvas_size_width, cs.height AS canvas_size_height, cs.width AS canvas_width, cs.height AS canvas_height
          FROM slide_templates st
          LEFT JOIN canvas_sizes cs ON cs.id = st.canvas_size_id
          WHERE st.id IN (?)
        `, [templateIds]);
        [regionRows] = await pool.query('SELECT id, template_id, region_key, region_type, label, font_family, lock_ratio, x, y, width, height, z_index, created_at, modified_at, created_by, modified_by FROM slide_template_regions WHERE template_id IN (?) ORDER BY template_id ASC, z_index ASC, id ASC', [templateIds]);
        templateRows.forEach(function (template) {
          template.regions = regionRows.filter(function (region) { return region.template_id === template.id; });
          templatesById[template.id] = template;
        });
      }

      function getVideoRegionDurationSeconds(contentJson) {
        if (!contentJson) {
          return null;
        }

        try {
          const parsed = common.parseJsonSafe(contentJson) || {};
          if (!parsed || typeof parsed !== 'object') {
            return null;
          }

          const videoRegion = Object.keys(parsed).map(function (key) { return parsed[key]; }).find(function (region) {
            return region && typeof region === 'object' && String(region.type || '').trim().toLowerCase() === 'video' && Number(region.duration_seconds || 0) > 0;
          });

          const duration = Math.round(Number(videoRegion && videoRegion.duration_seconds || 0) * 1000) / 1000;
          return Number.isFinite(duration) && duration > 0 ? duration : null;
        } catch (_error) {
          return null;
        }
      }

      const slides = slideRows.map(function (slide) {
        const storedDuration = Number(slide.duration_seconds || 0);
        const videoDuration = slide.use_video_duration ? getVideoRegionDurationSeconds(slide.content_json) : null;
        const videoCacheBust = String(slide.modified_at || slide.content_json || slide.id || '');
        const content = common.parseJsonSafe(slide.content_json) || {};
        Object.keys(content).forEach(function (key) {
          const region = content[key];
          if (region && typeof region === 'object' && String(region.type || '').trim().toLowerCase() === 'video') {
            region.cache_bust = videoCacheBust;
          }
        });
        return {
          id: slide.id,
          title: slide.title,
          body: slide.body,
          modified_at: slide.modified_at,
          duration_seconds: videoDuration || storedDuration,
          use_video_duration: Boolean(slide.use_video_duration),
          schedule_mode: slide.schedule_mode,
          schedule_start_datetime: slide.schedule_start_datetime,
          schedule_end_datetime: slide.schedule_end_datetime,
          schedule_start_time: slide.schedule_start_time,
          schedule_end_time: slide.schedule_end_time,
          schedule_days_json: slide.schedule_days_json,
          media_url: slide.media_path,
          media_type: slide.media_type,
          kind: common.mediaKind(slide.media_path),
          template_id: slide.template_id,
          template: slide.template_id ? templatesById[slide.template_id] || null : null,
          content: content
        };
      });

      let rssFeeds = [];
      if (typeof common.fetchRssFeedsData === 'function' && typeof common.fetchRssFeedItemsByFeedId === 'function') {
        const rssData = await common.fetchRssFeedsData(pool);
        const feedRows = Array.isArray(rssData && rssData.rssFeeds) ? rssData.rssFeeds : [];
        rssFeeds = await Promise.all(feedRows.map(async function (feed) {
          const items = await common.fetchRssFeedItemsByFeedId(pool, feed.id);
          return Object.assign({}, feed, { items: items.map(function (item) {
            return typeof common.normalizeRssFeedItem === 'function' ? common.normalizeRssFeedItem(item) : item;
          }) });
        }));
      }

      let apiSources = [];
      if (typeof common.fetchApiSourcesData === 'function') {
        const apiData = await common.fetchApiSourcesData(pool);
        const sourceRows = Array.isArray(apiData && apiData.apiSources) ? apiData.apiSources : [];
        apiSources = sourceRows.map(function (source) {
          return Object.assign({}, source, {
            responseJson: common.parseJsonSafe ? common.parseJsonSafe(source.last_response_json) : null
          });
        });
      }

      const revision = getPlaylistRevision(screen, playlist, slideRows, templateRows, regionRows, rssFeeds, apiSources);
      const payload = { screen: screen, playlist: playlist, slides: slides, rssFeeds: rssFeeds, apiSources: apiSources, revision: revision };
      await writeSnapshot(slug, payload);
      return payload;
    } catch (error) {
      const snapshot = await readSnapshot(slug);
      if (snapshot) {
        return snapshot;
      }
      throw error;
    }
  }

  function updatePlaylistRevisionHash(hash, value) {
    hash.update(String(value === null || value === undefined ? '' : value));
    hash.update('\0');
  }

  function getPlaylistRevision(screen, playlist, slideRows, templateRows, regionRows, rssFeeds, apiSources) {
    const hash = crypto.createHash('sha1');

    updatePlaylistRevisionHash(hash, screen && screen.id);
    updatePlaylistRevisionHash(hash, screen && screen.playlist_id);
    updatePlaylistRevisionHash(hash, screen && screen.modified_at);

    updatePlaylistRevisionHash(hash, playlist && playlist.id);
    updatePlaylistRevisionHash(hash, playlist && playlist.modified_at);
    updatePlaylistRevisionHash(hash, playlist && playlist.fade_between_slides);
    updatePlaylistRevisionHash(hash, playlist && playlist.skip_unavailable_rtmp);

    (Array.isArray(slideRows) ? slideRows : []).forEach(function (slide) {
      updatePlaylistRevisionHash(hash, slide.id);
      updatePlaylistRevisionHash(hash, slide.title);
      updatePlaylistRevisionHash(hash, slide.body);
      updatePlaylistRevisionHash(hash, slide.template_id);
      updatePlaylistRevisionHash(hash, slide.content_json);
      updatePlaylistRevisionHash(hash, slide.media_path);
      updatePlaylistRevisionHash(hash, slide.media_type);
      updatePlaylistRevisionHash(hash, slide.modified_at);
      updatePlaylistRevisionHash(hash, slide.position);
      updatePlaylistRevisionHash(hash, slide.duration_seconds);
      updatePlaylistRevisionHash(hash, slide.use_video_duration);
      updatePlaylistRevisionHash(hash, slide.schedule_mode);
      updatePlaylistRevisionHash(hash, slide.schedule_start_datetime);
      updatePlaylistRevisionHash(hash, slide.schedule_end_datetime);
      updatePlaylistRevisionHash(hash, slide.schedule_start_time);
      updatePlaylistRevisionHash(hash, slide.schedule_end_time);
      updatePlaylistRevisionHash(hash, slide.schedule_days_json);
    });

    (Array.isArray(templateRows) ? templateRows : []).forEach(function (template) {
      updatePlaylistRevisionHash(hash, template.id);
      updatePlaylistRevisionHash(hash, template.name);
      updatePlaylistRevisionHash(hash, template.canvas_size_id);
      updatePlaylistRevisionHash(hash, template.canvas_size_width);
      updatePlaylistRevisionHash(hash, template.canvas_size_height);
      updatePlaylistRevisionHash(hash, template.background_image_path);
      updatePlaylistRevisionHash(hash, template.background_color);
      updatePlaylistRevisionHash(hash, template.modified_at);
    });

    (Array.isArray(regionRows) ? regionRows : []).forEach(function (region) {
      updatePlaylistRevisionHash(hash, region.id);
      updatePlaylistRevisionHash(hash, region.template_id);
      updatePlaylistRevisionHash(hash, region.region_key);
      updatePlaylistRevisionHash(hash, region.region_type);
      updatePlaylistRevisionHash(hash, region.label);
      updatePlaylistRevisionHash(hash, region.font_family);
      updatePlaylistRevisionHash(hash, region.x);
      updatePlaylistRevisionHash(hash, region.y);
      updatePlaylistRevisionHash(hash, region.width);
      updatePlaylistRevisionHash(hash, region.height);
      updatePlaylistRevisionHash(hash, region.z_index);
      updatePlaylistRevisionHash(hash, region.modified_at);
    });

    updatePlaylistRevisionHash(hash, JSON.stringify(rssFeeds || []));
    updatePlaylistRevisionHash(hash, JSON.stringify(apiSources || []));

    return hash.digest('hex');
  }

  return {
    buildScreenPlaylist: buildScreenPlaylist
  };
}

module.exports = {
  createPlayerPlaylistService: createPlayerPlaylistService
};