node_helper.js

var NodeHelper = require("node_helper");
const { google } = require("googleapis");
const promisify = require("util").promisify;
const fs = require("fs");
const readFile = promisify(fs.readFile);
const writeFile = promisify(fs.writeFile);
const unlink = promisify(fs.unlink);
const https = require("https");

const CACHE_FILE_PATH = ".cache";
const G_CREDENTIALS_FILE_PATH = "./secrets/credentials.json";
const G_TOKEN_FILE_PATH = "./secrets/token.json";

/** @typedef {import("google-auth-library").OAuth2ClientOptions} OAuth2ClientOptions */
/** @typedef {import("google-auth-library").OAuth2Client} OAuth2Client */
/** @typedef {import("google-auth-library").Credentials} Credentials */
/**
 * @typedef {Object} CredentialsInstalled
 * @property {OAuth2ClientOptions['clientId']} client_id - The client ID.
 * @property {OAuth2ClientOptions['projectId']} project_id - The project ID.
 * @property {string|null|undefined} auth_uri - The authorization URI.
 * @property {string|null|undefined} token_uri - The token URI.
 * @property {string|null|undefined} auth_provider_x509_cert_url - The auth provider x509 cert URL.
 * @property {OAuth2ClientOptions['clientSecret']} client_secret - The client secret.
 * @property {Array<string>|null|undefined} redirect_uris - The redirect URIs.
 */
/**
 * @typedef {Object} CredentialsFileData
 * @property {CredentialsInstalled} installed - The installed credentials.
 */

module.exports = NodeHelper.create({
  config: {
    rootFolderId: null,
    maxFolders: 30,
    maxResults: 10,
    refreshDriveDelayInSeconds: 24 * 3600,
    refreshSlideShowIntervalInSeconds: 10,
    debug: false,
  },

  alreadySentPhotoIds: [], // Array of images already sent to the MM
  cache: {
    created: null,
    photos: [],
  },

  gDriveService: null, // Google Drive API Service

  broadcastTimer: null, // Timer for next image broadcast

  lastBroadcastDate: null,

  refreshCacheInProgress: false, // Is the cache currently refreshing ?

  suspended: false, // Is the module suspended

  start: async function () {
    await this.setupGoogleApiService();

    this.expressApp.use("/" + this.name + "/next", async (req, res, next) => {
      await this.broadcastRandomPhoto();
      res.send("Next photo requested");
    });

    this.expressApp.use("/" + this.name + "/stop", async (req, res, next) => {
      await this.stopSlideShow();
      res.send("Slideshow stopped");
    });

    this.expressApp.use("/" + this.name + "/play", async (req, res, next) => {
      this.startSlideShow();
      res.send("Slideshow started");
    });

    this.expressApp.use(
      "/" + this.name + "/cache/reset",
      async (req, res, next) => {
        await this.resetCache();
        await this.getPhotos();
        res.send({
          cache: this.cache,
        });
      },
    );

    this.expressApp.use(
      "/" + this.name + "/file/:photoId",
      async (req, res, next) => {
        let photoId = req.params.photoId;
        if ("random" === photoId) {
          photo = await this.getRandomPhoto();
          if (!photo) {
            next();
            return;
          }
          photoId = photo.id;
        }
        this.debug("Displaying photo with ID " + photoId);
        var response = await this.gDriveService.files.get({
          fileId: photoId,
          fields: "thumbnailLink",
        });
        var thumbnailLink = response.data.thumbnailLink.replace(
          "=s220",
          "=s" + this.config.maxWidth,
        );
        var proxy = https.request(thumbnailLink, function (proxyRes) {
          res.writeHead(proxyRes.statusCode, proxyRes.headers);
          proxyRes.pipe(res, {
            end: true,
          });
        });
        req.pipe(proxy, {
          end: true,
        });
      },
    );
  },

  socketNotificationReceived: async function (notification, payload) {
    this.debug("New notification received : " + notification);
    switch (notification) {
      case "INIT":
        this.config = payload;
        this.debug("DEBUG IS ACTIVE");
        this.debug(JSON.stringify(this.config, null, 2));
        await this.startSlideShow(true);
        break;
      case "REQUEST_NEW_IMAGE":
        if (!this.suspended) {
          await this.broadcastRandomPhoto();
        }
        break;
      case "STOP_SLIDESHOW":
        this.stopSlideShow();
        break;
      case "START_SLIDESHOW":
        await this.startSlideShow();
        break;
      case "SUSPEND":
        this.stopSlideShow();
        this.suspended = true;
        break;
      case "RESUME":
        this.suspended = false;
        await this.startSlideShow();
        break;
    }
  },

  startSlideShow: async function (firstLaunch) {
    this.debug("Starting slideshow. First time ? " + (firstLaunch === true));
    if (firstLaunch) {
      this.broadcastRandomPhoto();
    }
    if (this.config.playMode === "AUTO") {
      this.broadcastTimer = setInterval(
        async () => await this.broadcastRandomPhoto(),
        this.config.refreshSlideShowIntervalInSeconds * 1000,
      );
    }
  },

  stopSlideShow: function () {
    this.debug("Slidshow stopped");
    clearInterval(this.broadcastTimer);
  },

  broadcastNewPhoto: async function (photo) {
    this.sendSocketNotification("NEW_IMAGE", photo);
  },

  broadcastRandomPhoto: async function () {
    if (
      this.lastBroadcastDate == null ||
      new Date().getTime() - this.lastBroadcastDate.getTime() > 5000
    ) {
      // Prevent two notifications to request image change to quickly (5 s mini between each)
      let photo = await this.getRandomPhoto();
      if (!photo) {
        setTimeout(() => this.broadcastRandomPhoto(), 1000);
        return;
      }
      await this.broadcastNewPhoto(photo);
      this.lastBroadcastDate = new Date();
    } else {
      this.debug("Throttle detected, skip new image request");
    }
  },

  setupGoogleApiService: async function () {
    let { credentials, token } = await this.readAuthenticationFiles();
    const {
        installed: {
          client_id: clientId,
          client_secret: clientSecret,
          redirect_uris: redirectUris,
        },
      } = credentials,
      redirectUri = (redirectUris ?? [])[0];

    const oauth2Client = new google.auth.OAuth2({
      clientId,
      clientSecret,
      redirectUri,
    });
    oauth2Client.setCredentials(token);
    this.gDriveService = google.drive({ version: "v3", auth: oauth2Client });
  },

  log: function (message) {
    console.log(`${this.name} : ${message}`);
  },

  debug: function (message) {
    if (this.config.debug) {
      this.log(`[DEBUG] ${message}`);
    }
  },

  readAuthenticationFiles: function () {
    return new Promise((resolve, reject) => {
      Promise.all([
        readFile(`${this.path}/${G_CREDENTIALS_FILE_PATH}`),
        readFile(`${this.path}/${G_TOKEN_FILE_PATH}`),
      ])
        .then((values) => {
          var credentials = JSON.parse(values[0]);
          var token = JSON.parse(values[1]);
          resolve({ credentials, token });
        })
        .catch((reason) => {
          reject(reason);
        });
    });
  },

  cacheFileExists: function () {
    return fs.existsSync(`${this.path}/${CACHE_FILE_PATH}`);
  },

  loadCache: async function () {
    let content = await readFile(`${this.path}/${CACHE_FILE_PATH}`);
    this.cache = JSON.parse(content);
  },

  createCache: async function () {
    if (this.refreshCacheInProgress) {
      this.debug("Cache already being build, skip this request");
      return;
    }
    this.refreshCacheInProgress = true;
    let photos = await this.loadPhotos();
    this.cache = {
      created: new Date().getTime(),
      photos: photos,
    };
    await writeFile(
      `${this.path}/${CACHE_FILE_PATH}`,
      JSON.stringify(this.cache),
    );
    this.refreshCacheInProgress = false;
  },

  resetCache: async function () {
    this.cache.created = -1;
    await unlink(`${this.path}/${CACHE_FILE_PATH}`);
  },

  buildPhotoUrl: function (photo) {
    return photo.thumbnailLink.replace(
      "=s200",
      "=s" + this.config.minWidth.replace("px", ""),
    );
    //return photo.thumbnailLink;
  },

  getRandomPhoto: async function () {
    let photos = await this.getPhotos();
    if (!Array.isArray(photos) || photos.length === 0) return undefined;

    let randomIndex = Math.floor(Math.random() * photos.length);
    let randomPhoto = photos[randomIndex];
    if (!randomPhoto || !randomPhoto["id"]) return undefined;

    this.cache.photos.splice(randomIndex, 1);
    // If all photos are sent, reload cache from file
    if (this.cache.photos.length === 0) {
      await this.loadCache();
      this.alreadySentPhotoIds = [];
    }
    this.alreadySentPhotoIds.push(randomPhoto.id);
    return randomPhoto;
  },

  getPhotos: async function () {
    // Get cache if not already loaded and cache file exists (after a restart for example)
    if (!this.cache.created && this.cacheFileExists()) {
      this.log("No memory cache, loading it from disk");
      await this.loadCache();
    }

    // Check if need reload
    let needReload =
      !this.cache ||
      !this.cache.created ||
      (new Date().getTime() - (this.cache.created ?? 0)) / 1000 >
        this.config.refreshDriveDelayInSeconds;

    // (re)create the cache if missing or expired
    if (needReload) {
      this.log("No cache file, or expired, (re)creating it...");
      await this.createCache();
      this.cache.photos = await this.cache.photos.filter(
        (photo) => !this.alreadySentPhotoIds.includes(photo.id),
      );
    }

    return this.cache.photos;
  },

  walkFolders: async function (folderId, limits, alreadyWalked) {
    var folders = [];
    folders.push(folderId);

    // Store already analyzed folders
    if (!alreadyWalked) {
      alreadyWalked = [];
    }
    if (alreadyWalked.length > limits) {
      return folders;
    }

    // Add current folder
    alreadyWalked.push(folderId);

    // Query API
    const response = await this.gDriveService.files.list({
      q: `'${folderId}' in parents and mimeType = 'application/vnd.google-apps.folder'`,
      pageSize: 100,
    });
    if (response.data.files.length) {
      let subFolders =
        alreadyWalked.length + response.data.files.length < limits
          ? response.data.files
          : response.data.files.slice(0, limits - alreadyWalked.length);
      for (var entry of subFolders) {
        if (alreadyWalked.indexOf(entry.id) === -1) {
          var rec = await this.walkFolders(entry.id, limits, alreadyWalked);
          folders = folders.concat(rec);
        }
      }
    }

    if (alreadyWalked.length % 10 === 0) {
      this.debug(`${alreadyWalked.length} folders found`);
    }
    return folders;
  },

  buildMimeTypeQuery: function () {
    return "mimeType contains 'image/'";
  },

  searchPhotosByFolders: async function (folderIds) {
    let results = [];
    const maxFoldersPerQuery = 10;
    let iterations = Math.ceil(folderIds.length / maxFoldersPerQuery);

    for (let i = 0; i < iterations; i++) {
      this.debug(`Query for photos : iteration ${i + 1}`);

      // Build query
      let range = folderIds.slice(
        i * maxFoldersPerQuery,
        (i + 1) * maxFoldersPerQuery,
      );
      let parentsQuery = range
        .map((folderId) => `'${folderId}' in parents`)
        .join(" or ");
      let query = `(${parentsQuery}) and ${this.buildMimeTypeQuery()}`;

      // Run query
      let max = this.config.maxResults - results.length;
      let r = await this.searchPhotosByQuery(query, max);
      results = results.concat(r);
      if (results.length === this.config.maxResults) {
        break;
      }
    }
    return results;
  },

  searchPhotosByQuery: async function (query, max) {
    let results = [];
    let pageToken;
    do {
      const response = await this.gDriveService.files.list({
        q: query,
        fields:
          "nextPageToken,  files(id,name,imageMediaMetadata(width, height, rotation))",
        pageToken: pageToken,
      });
      pageToken = response.data.nextPageToken;
      let limit = Math.min(max - results.length, response.data.files.length);
      results = results.concat(response.data.files.splice(0, limit));
      if (limit < response.data.files.length) {
        pageToken = null;
      }
      this.debug(`${results.length} photos retrieved`);
    } while (pageToken);
    return results;
  },

  loadPhotos: async function () {
    let start = new Date();
    this.debug("Loading photos from Google Drive");

    try {
      let photos;
      if (!this.config.rootFolderId) {
        // Root => only query by mimetype
        this.debug("Root folder => search files over all gDrive");
        photos = await this.searchPhotosByQuery(
          this.buildMimeTypeQuery(),
          this.config.maxResults,
        );
      } else {
        // Root folder provided : must discover sub folders before
        this.debug(`Search subfolders of folder ${this.config.rootFolderId}`);
        let folderIds = await this.walkFolders(
          this.config.rootFolderId,
          this.config.maxFolders,
        ).catch(console.error);
        this.debug(
          `${folderIds.length} of maximum ${this.config.maxFolders} folders scanned`,
        );
        photos = await this.searchPhotosByFolders(folderIds);
      }
      this.log(
        `${photos.length} photos metadata retrieved in ${(new Date().getTime() - start.getTime()) / 1000} seconds`,
      );
      return photos;
    } catch (e) {
      const msg =
        e?.response?.data?.error_description || e?.message || String(e);
      this.log(`[MMM-GoogleDriveSlideShow] Google Drive load failed: ${msg}`);
      // Importante: no revientes el proceso
      return [];
    }
  },
});