homepage/src/widgets/jdownloader/proxy.js

/* eslint-disable no-underscore-dangle */
import crypto from "crypto";
import querystring from "querystring";

import { sha256, uniqueRid, validateRid, createEncryptionToken, decrypt, encrypt } from "./tools";

import getServiceWidget from "utils/config/service-helpers";
import { httpProxy } from "utils/proxy/http";
import createLogger from "utils/logger";

const proxyName = "jdownloaderProxyHandler";
const logger = createLogger(proxyName);

async function getWidget(req) {
  const { group, service } = req.query;
  if (!group || !service) {
    logger.debug("Invalid or missing service '%s' or group '%s'", service, group);
    return null;
  }
  const widget = await getServiceWidget(group, service);
  if (!widget) {
    logger.debug("Invalid or missing widget for service '%s' in group '%s'", service, group);
    return null;
  }

  return widget;
}

async function login(loginSecret, deviceSecret, params) {
  const rid = uniqueRid();
  const path = `/my/connect?${querystring.stringify({ ...params, rid })}`;

  const signature = crypto.createHmac("sha256", loginSecret).update(path).digest("hex");
  const url = `${new URL(`https://api.jdownloader.org${path}&signature=${signature}`)}`;

  const [status, contentType, data] = await httpProxy(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
  });

  if (status !== 200) {
    logger.error("HTTP %d communicating with jdownloader. Data: %s", status, data.toString());
    return [status, data];
  }

  try {
    const decryptedData = JSON.parse(decrypt(data.toString(), loginSecret));
    const sessionToken = decryptedData.sessiontoken;
    validateRid(decryptedData, rid);
    const serverEncryptionToken = createEncryptionToken(loginSecret, sessionToken);
    const deviceEncryptionToken = createEncryptionToken(deviceSecret, sessionToken);
    return [status, decryptedData, contentType, serverEncryptionToken, deviceEncryptionToken, sessionToken];
  } catch (e) {
    logger.error("Error decoding jdownloader API data. Data: %s", data.toString());
    return [status, null];
  }
}

async function getDevice(serverEncryptionToken, deviceName, params) {
  const rid = uniqueRid();
  const path = `/my/listdevices?${querystring.stringify({ ...params, rid })}`;
  const signature = crypto.createHmac("sha256", serverEncryptionToken).update(path).digest("hex");
  const url = `${new URL(`https://api.jdownloader.org${path}&signature=${signature}`)}`;

  const [status, , data] = await httpProxy(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
  });

  if (status !== 200) {
    logger.error("HTTP %d communicating with jdownloader. Data: %s", status, data.toString());
    return [status, data];
  }

  try {
    const decryptedData = JSON.parse(decrypt(data.toString(), serverEncryptionToken));
    const filteredDevice = decryptedData.list.filter((device) => device.name === deviceName);
    return [status, filteredDevice[0].id];
  } catch (e) {
    logger.error("Error decoding jdownloader API data. Data: %s", data.toString());
    return [status, null];
  }
}

function createBody(rid, query, params) {
  const baseBody = {
    apiVer: 1,
    rid,
    url: query,
  };
  return params ? { ...baseBody, params: [JSON.stringify(params)] } : baseBody;
}

async function queryPackages(deviceEncryptionToken, deviceId, sessionToken, params) {
  const rid = uniqueRid();
  const body = encrypt(JSON.stringify(createBody(rid, "/downloadsV2/queryPackages", params)), deviceEncryptionToken);
  const url = `${new URL(
    `https://api.jdownloader.org/t_${encodeURI(sessionToken)}_${encodeURI(deviceId)}/downloadsV2/queryPackages`,
  )}`;
  const [status, , data] = await httpProxy(url, {
    method: "POST",
    body,
  });

  if (status !== 200) {
    logger.error("HTTP %d communicating with jdownloader. Data: %s", status, data.toString());
    return [status, data];
  }

  try {
    const decryptedData = JSON.parse(decrypt(data.toString(), deviceEncryptionToken));
    return decryptedData.data;
  } catch (e) {
    logger.error("Error decoding JDRss jdownloader data. Data: %s", data.toString());
    return [status, null];
  }
}

export default async function jdownloaderProxyHandler(req, res) {
  const widget = await getWidget(req);

  if (!widget) {
    return res.status(400).json({ error: "Invalid proxy service type" });
  }
  logger.debug("Getting data from JDRss API");
  const { username } = widget;
  const { password } = widget;

  const appKey = "homepage";
  const loginSecret = sha256(`${username}${password}server`);
  const deviceSecret = sha256(`${username}${password}device`);
  const email = username;

  const loginData = await login(loginSecret, deviceSecret, {
    appKey,
    email,
  });

  const deviceData = await getDevice(loginData[3], widget.client, {
    sessiontoken: loginData[5],
  });

  const packageStatus = await queryPackages(loginData[4], deviceData[1], loginData[5], {
    bytesLoaded: true,
    bytesTotal: true,
    comment: false,
    enabled: true,
    eta: false,
    priority: false,
    finished: true,
    running: true,
    speed: true,
    status: true,
    childCount: false,
    hosts: false,
    saveTo: false,
    maxResults: -1,
    startAt: 0,
  });

  let totalLoaded = 0;
  let totalBytes = 0;
  let totalSpeed = 0;
  packageStatus.forEach((file) => {
    totalBytes += file.bytesTotal;
    totalLoaded += file.bytesLoaded;
    if (file.finished !== true && file.speed) {
      totalSpeed += file.speed;
    }
  });

  const data = {
    downloadCount: packageStatus.length,
    bytesRemaining: totalBytes - totalLoaded,
    totalBytes,
    totalSpeed,
  };

  return res.send(data);
}