fix typos

routes/repository.js

@@ -0,0 +1,338 @@
+const ofs = require("fs");
+const fs = require("fs").promises;
+
+const express = require("express");
+const gh = require("parse-github-url");
+const arrayEquals = require("array-equal");
+
+const connection = require("./connection");
+const githubUtils = require("../utils/github");
+const db = require("../utils/database");
+const repoUtils = require("../utils/repository");
+const config = require("../config");
+
+const router = express.Router();
+
+// user needs to be connected for all user API
+router.use(connection.ensureAuthenticated);
+
+router.get("/:repoId/", async (req, res) => {
+  try {
+    const repository = await repoUtils.getAnonymizedRepoDetails(
+      req.params.repoId,
+      req.user
+    );
+    if (repository) {
+      return res.json(repository);
+    }
+    res.status(404).send("repo_not_found");
+  } catch (error) {
+    res.status(500).send(error);
+  }
+});
+
+// update a repository
+router.post("/:repoId/", async (req, res) => {
+  const repoUpdate = req.body;
+
+  let repoConfig = await repoUtils.getConfig(req.params.repoId);
+  if (repoConfig == null) {
+    return res.status(500).json({ error: "repo_not_found" });
+  }
+  if (repoConfig.owner != req.user.username) {
+    return res.status(401).json({ error: "not_authorized" });
+  }
+  if (!repoUpdate.branch) {
+    return res.status(500).json({ error: "branch_not_specified" });
+  }
+  if (!repoUpdate.options) {
+    return res.status(500).json({ error: "options_not_provided" });
+  }
+  if (!Array.isArray(repoUpdate.terms)) {
+    return res.status(500).send({ error: "invalid_terms_format" });
+  }
+
+  const details = await repoUtils.getRepoDetails({
+    repoConfig,
+    force: true,
+    token: req.user.accessToken,
+  });
+  if (repoConfig.options.mode == "download") {
+    // details.size is in kilobytes
+    if (details.size > config.MAX_REPO_SIZE) {
+      return res.status(500).send({ error: "invalid_mode" });
+    }
+  }
+
+  try {
+    if (repoUpdate.commit != repoConfig.commit) {
+      repoUpdate.anonymizeDate = new Date();
+      await repoUtils.removeRepository(repoConfig);
+    }
+    if (
+      !arrayEquals(repoUpdate.terms, repoConfig.terms) ||
+      repoUpdate.options.link != repoConfig.options.link ||
+      repoUpdate.options.image != repoConfig.options.image
+    ) {
+      repoUpdate.anonymizeDate = new Date();
+      if (ofs.existsSync(repoUtils.getAnonymizedPath(repoConfig.repoId))) {
+        await fs.rm(repoUtils.getAnonymizedPath(repoConfig.repoId), {
+          recursive: true,
+          force: true,
+        });
+      }
+    }
+    const data = {
+      terms: repoUpdate.terms,
+      branch: repoUpdate.branch,
+      commit: repoUpdate.commit,
+      options: {
+        expirationMode: repoUpdate.options.expirationMode,
+        expirationDate: repoUpdate.options.expirationDate,
+        update: repoUpdate.options.update,
+        image: repoUpdate.options.image,
+        pdf: repoUpdate.options.pdf,
+        notebook: repoUpdate.options.notebook,
+        loc: repoUpdate.options.loc,
+        link: repoUpdate.options.link,
+        mode: repoUpdate.options.mode,
+        page: repoUpdate.options.page,
+      },
+    };
+    if (repoConfig.options.page) {
+      data.options.pageSource = details.pageSource;
+    }
+    await db.get("anonymized_repositories").updateOne(
+      {
+        repoId: repoConfig.repoId,
+      },
+      {
+        $set: data,
+      }
+    );
+
+    repoConfig = await repoUtils.getConfig(repoUpdate.repoId);
+    await repoUtils.updateStatus(repoConfig, "preparing");
+
+    res.send("ok");
+    
+    await githubUtils.downloadRepoAndAnonymize(repoConfig);
+    await repoUtils.updateStatus(repoConfig, "ready");
+  } catch (error) {
+    console.error(error);
+    await repoUtils.updateStatus(repoConfig, "error", error);
+    return res.status(500).json({ error });
+  }
+});
+
+// refresh a repository
+router.post("/:repoId/refresh", async (req, res) => {
+  const repoConfig = await repoUtils.getConfig(req.params.repoId);
+  if (repoConfig == null) {
+    return res.status(500).json({ error: "repo_not_found" });
+  }
+  if (repoConfig.owner != req.user.username) {
+    return res.status(401).json({ error: "not_authorized" });
+  }
+  try {
+    await repoUtils.updateAnonymizedRepository(repoConfig);
+    return res.send("ok");
+  } catch (error) {
+    return res.status(500).json({ error });
+  }
+});
+
+// delete a repository
+router.delete("/:repoId/", async (req, res) => {
+  const repoConfig = await repoUtils.getConfig(req.params.repoId);
+  if (repoConfig == null) {
+    return res.status(500).json({ error: "repo_not_found" });
+  }
+  if (repoConfig.owner != req.user.username) {
+    return res.status(401).json({ error: "not_authorized" });
+  }
+  try {
+    await repoUtils.updateStatus(repoConfig, "removed");
+    await repoUtils.removeRepository(repoConfig);
+    console.log(`${req.params.repoId} is removed`);
+    return res.json("ok");
+  } catch (error) {
+    return res.status(500).json({ error });
+  }
+});
+
+// claim a repository
+router.post("/claim", async (req, res) => {
+  if (!req.body.repoId) {
+    return res.status(500).json({ error: "repoId_not_defined" });
+  }
+  if (!req.body.repoUrl) {
+    return res.status(500).json({ error: "repoUrl_not_defined" });
+  }
+
+  const repoConfig = await repoUtils.getConfig(req.body.repoId);
+  if (repoConfig == null) {
+    return res.status(500).json({ error: "repo_not_found" });
+  }
+
+  const repo = gh(req.body.repoUrl);
+  if (repoConfig.fullName != repo.repository) {
+    return res.status(500).json({ error: "repo_not_found" });
+  }
+
+  console.log(`${req.user.username} claims ${repoConfig.fullName}.`);
+  try {
+    await db
+      .get("anonymized_repositories")
+      .updateOne(
+        { repoId: repoConfig.repoId },
+        { $set: { owner: req.user.username } }
+      );
+    return res.send("Ok");
+  } catch (error) {
+    return res.status(500).json({ error });
+  }
+});
+
+router.get("/:owner/:repo/", async (req, res) => {
+  try {
+    const repository = await repoUtils.getRepoDetails({
+      owner: req.params.owner,
+      repo: req.params.repo,
+      token: req.user.accessToken,
+      force: req.query.force === "1",
+    });
+    if (repository) {
+      return res.json(repository);
+    }
+    res.status(404).send("repo_not_found");
+  } catch (error) {
+    res.status(500).send(error);
+  }
+});
+
+router.get("/:owner/:repo/branches", async (req, res) => {
+  try {
+    const repository = await repoUtils.getRepoBranches({
+      owner: req.params.owner,
+      repo: req.params.repo,
+      token: req.user.accessToken,
+      force: req.query.force === "1",
+    });
+    if (repository) {
+      return res.json(repository);
+    }
+    res.status(404).send("repo_not_found");
+  } catch (error) {
+    res.status(500).send(error);
+  }
+});
+
+router.get("/:owner/:repo/readme", async (req, res) => {
+  try {
+    const readme = await repoUtils.getRepoReadme({
+      owner: req.params.owner,
+      repo: req.params.repo,
+      token: req.user.accessToken,
+      force: req.query.force === "1",
+    });
+    if (readme) {
+      return res.send(readme);
+    }
+    res.status(404).send("repo_not_found");
+  } catch (error) {
+    res.status(500).send(error);
+  }
+});
+
+router.post("/", async (req, res) => {
+  const repoConfig = req.body;
+
+  const repository = await repoUtils.getConfig(repoConfig.repoId);
+  const cacheExist = ofs.existsSync(
+    repoUtils.getOriginalPath(repoConfig.repoId)
+  );
+  if (repository && cacheExist) {
+    return res.status(500).send({ error: "repoId_already_used" });
+  }
+  var validCharacters = /^[0-9a-zA-Z\-\_]+$/;
+  if (
+    !repoConfig.repoId.match(validCharacters) ||
+    repoConfig.repoId.length < 3
+  ) {
+    return res.status(500).send({ error: "invalid_repoId" });
+  }
+  if (!repoConfig.branch) {
+    return res.status(500).json({ error: "branch_not_specified" });
+  }
+  if (!repoConfig.options) {
+    return res.status(500).json({ error: "options_not_provided" });
+  }
+  if (!Array.isArray(repoConfig.terms)) {
+    return res.status(500).send({ error: "invalid_terms_format" });
+  }
+
+  await repoUtils.getRepoBranches({ repoConfig, token: req.user.accessToken });
+  const details = await repoUtils.getRepoDetails({
+    repoConfig,
+    token: req.user.accessToken,
+  });
+  if (repoConfig.options.mode == "download") {
+    // details.size is in kilobytes
+    if (details.size > config.MAX_REPO_SIZE) {
+      return res.status(500).send({ error: "non_supported_mode" });
+    }
+  }
+
+  const data = {
+    repoId: repoConfig.repoId,
+    fullName: repoConfig.fullName,
+    status: "preparing",
+    terms: repoConfig.terms,
+    owner: req.user.profile.username,
+    token: req.user.accessToken,
+    branch: repoConfig.branch,
+    conference: repoConfig.conference,
+    commit: repoConfig.commit
+      ? repoConfig.commit
+      : details.branches[repoConfig.branch].commit.sha,
+    anonymizeDate: new Date(),
+    options: {
+      expirationMode: repoConfig.options.expirationMode,
+      expirationDate: repoConfig.options.expirationDate,
+      update: repoConfig.options.update,
+      image: repoConfig.options.image,
+      pdf: repoConfig.options.pdf,
+      notebook: repoConfig.options.notebook,
+      loc: repoConfig.options.loc,
+      link: repoConfig.options.link,
+      mode: repoConfig.options.mode,
+      page: repoConfig.options.page,
+    },
+  };
+  if (repoConfig.options.page) {
+    data.options.pageSource = details.pageSource;
+  }
+  await db.get("anonymized_repositories").updateOne(
+    {
+      repoId: data.repoId,
+    },
+    {
+      $set: data,
+    },
+    { upsert: true }
+  );
+  res.send("ok");
+  try {
+    await githubUtils.downloadRepoAndAnonymize(data);
+    await repoUtils.updateStatus(repoConfig, "ready");
+  } catch (error) {
+    console.error(error);
+    await repoUtils.updateStatus(repoConfig, "error", "unable_to_anonymize");
+    return res
+      .status(500)
+      .json({ error: "unable_to_anonymize", message: error.message });
+  }
+});
+
+module.exports = router;