peertube-plugin-transposer-connector/server/controller/transposerController.js

Transposer connector is a PeerTube language tool plugin to transcribe and translate with Whisper

const initTransposerController = (router, peertubeHelpers, settingsManager) => {
  router.post("/transposer/translate/:videoId", async (req, res) => {
    try {
      const { videoId } = req.params;

      if (!videoId || isNaN(videoId)) {
        return res
          .status(400)
          .json({ success: false, message: "Invalid videoId provided" });
      }

      // Extract auth header from the request
      const authHeader = req.headers.authorization;

      const translationResult = await triggerTransposer(
        videoId,
        peertubeHelpers,
        settingsManager,
        authHeader
      );

      res.json({ success: translationResult });
    } catch (error) {
      console.error(error);
      res.status(500).send("Internal Server Error");
    }
  });

  async function triggerTransposer(
    videoId,
    peertubeHelpers,
    settingsManager,
    authHeader
  ) {
    try {
      var webserverUrl = peertubeHelpers.config.getWebserverUrl();
      const settings = await settingsManager.getSettings([
        "trigger-transcription-and-translation",
      ]);

      if (!webserverUrl) {
        console.warn("webserverUrl is missing");
        return false;
      }

      if (!settings["trigger-transcription-and-translation"]) {
        console.warn(
          "trigger-transcription-and-translation setting is missing"
        );
        return false;
      }

      // Get video details to extract the language using auth header
      let video;
      try {
        const headers = {
          Accept: "application/json",
        };

        // Add auth header if available
        if (authHeader) {
          headers["Authorization"] = authHeader;
        }

        const response = await fetch(
          `${webserverUrl}/api/v1/videos/${videoId}`,
          {
            headers: headers,
          }
        );

        if (!response.ok) {
          throw new Error(`Failed to fetch video info: ${response.status}`);
        }
        video = await response.json();
      } catch (error) {
        console.error(`Error fetching video data: ${error}`);
        return false;
      }

      const language = video.language?.id;
      var fileDownloadUrl = video.files?.[0]?.fileDownloadUrl;

      if (!fileDownloadUrl) {
        const videoFiles = await getVideoFiles(videoId, peertubeHelpers);
        if (videoFiles.length === 0) {
          console.log(`No video file found for video "${videoId}", skipping.`);
          return false;
        }

        console.log(
          `Sending transcription for video "${videoId}" to Peertube Adapter`
        );

        const { url } = videoFiles[0];
        fileDownloadUrl = url;
      } else {
        console.log(`using fileDownloadUrl`);
      }

      console.log(`Video URL: ${fileDownloadUrl}`);

      const triggerUrl = settings["trigger-transcription-and-translation"];

      await triggerTranscriptionAndTranslation(
        videoId,
        fileDownloadUrl,
        language,
        triggerUrl,
        webserverUrl
      );

      console.log("Transcription and translation triggered successfully");
      return true;
    } catch (error) {
      console.error(
        `Failed to trigger transcription and translation: ${error}`
      );
      return false;
    }
  }

  async function getVideoFiles(id, peertubeHelpers) {
    peertubeHelpers.logger.info(`Fetching video files for video ID: ${id}`);

    const videoFilesData = await peertubeHelpers.videos.getFiles(id);
    if (!videoFilesData) {
      peertubeHelpers.logger.info(
        `No video files data returned for video ID: ${id}`
      );
      return [];
    }
    const webVideoFiles = videoFilesData.webVideo?.videoFiles || [];
    const hlsVideoFiles = videoFilesData.hls?.videoFiles || [];

    if (webVideoFiles.length === 0 && hlsVideoFiles.length === 0) {
      peertubeHelpers.logger.info(`No video files found for video ID: ${id}`);
      return [];
    }

    const combinedVideoFiles = webVideoFiles.concat(hlsVideoFiles);

    const sortedVideoFiles = combinedVideoFiles.sort(
      ({ size: sizeA }, { size: sizeB }) => sizeA - sizeB
    );

    peertubeHelpers.logger.info(
      `Sorted video files for video ID ${id}:`,
      sortedVideoFiles
    );

    return sortedVideoFiles;
  }

  function triggerTranscriptionAndTranslation(
    videoId,
    downloadUrl,
    language,
    triggerUrl,
    webserverUrl
  ) {
    if (!triggerUrl) {
      return;
    }

    peertubeHelpers.logger.info("triggerUrl:", triggerUrl);

    let body = {
      videoId: videoId,
      url: downloadUrl,
      peertubeInstanceBaseDomain: webserverUrl,
    };

    if (language) {
      body.language = language;
    }

    fetch(`${triggerUrl}/transcribe-and-translate/video`, {
      method: "POST",
      headers: {
        Accept: "application/json",
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    })
      .then((response) => {
        if (!response.ok) {
          response.json().then((json_error) => {
            throw new Error(
              `HTTP error! status: ${response.status} and message ${json_error.message}`
            );
          });
        }

        return response.json();
      })
      .then((data) => {
        peertubeHelpers.logger.info(
          `json result from server ${
            data.success ? "successful" : "unsuccessful"
          }`
        );
      })
      .catch((error) => {
        peertubeHelpers.logger.info(
          `Failed to report transcription done (for translation) "${error}", skipping.`
        );
      });
  }
};

module.exports = {
  initTransposerController,
};