bodyshop/server/media/media.js

const path = require("path");
const _ = require("lodash");
const logger = require("../utils/logger");
const client = require("../graphql-client/graphql-client").client;
const queries = require("../graphql-client/queries");

require("dotenv").config({
  path: path.resolve(process.cwd(), `.env.${process.env.NODE_ENV || "development"}`)
});

var cloudinary = require("cloudinary").v2;
cloudinary.config(process.env.CLOUDINARY_URL);

exports.createSignedUploadURL = (req, res) => {
  logger.log("media-signed-upload", "DEBUG", req.user.email, null, null);
  res.send(cloudinary.utils.api_sign_request(req.body, process.env.CLOUDINARY_API_SECRET));
};

exports.downloadFiles = (req, res) => {
  const { ids } = req.body;
  logger.log("media-bulk-download", "DEBUG", req.user.email, ids, null);

  const url = cloudinary.utils.download_zip_url({
    public_ids: ids,
    flatten_folders: true
  });
  res.send(url);
};

exports.deleteFiles = async (req, res) => {
  const { ids } = req.body;
  const types = _.groupBy(ids, (x) => DetermineFileType(x.type));

  logger.log("media-bulk-delete", "DEBUG", req.user.email, ids, null);

  const returns = [];
  if (types.image) {
    //delete images

    returns.push(
      await cloudinary.api.delete_resources(
        types.image.map((x) => x.key),
        { resource_type: "image" }
      )
    );
  }
  if (types.video) {
    //delete images  returns.push(
    returns.push(
      await cloudinary.api.delete_resources(
        types.video.map((x) => x.key),
        { resource_type: "video" }
      )
    );
  }
  if (types.raw) {
    //delete images  returns.push(
    returns.push(
      await cloudinary.api.delete_resources(
        types.raw.map((x) => `${x.key}.${x.extension}`),
        { resource_type: "raw" }
      )
    );
  }

  // Delete it on apollo.
  const successfulDeletes = [];
  returns.forEach((resType) => {
    Object.keys(resType.deleted).forEach((key) => {
      if (resType.deleted[key] === "deleted" || resType.deleted[key] === "not_found") {
        successfulDeletes.push(key.replace(/\.[^/.]+$/, ""));
      }
    });
  });

  try {
    const result = await client.request(queries.DELETE_MEDIA_DOCUMENTS, {
      ids: ids.filter((i) => successfulDeletes.includes(i.key)).map((i) => i.id)
    });

    res.send({ returns, result });
  } catch (error) {
    logger.log("media-delete-error", "ERROR", req.user.email, null, [
      { ids, error: error.message || JSON.stringify(error) }
    ]);

    res.json({ error });
  }
};

exports.renameKeys = async (req, res) => {
  const { documents, tojobid } = req.body;
  logger.log("media-bulk-rename", "DEBUG", req.user.email, null, documents);

  const proms = [];
  documents.forEach((d) => {
    proms.push(
      (async () => {
        try {
          const res = {
            id: d.id,
            ...(await cloudinary.uploader.rename(d.from, d.to, {
              resource_type: DetermineFileType(d.type)
            }))
          };
          return res;
        } catch (error) {
          return { id: d.id, from: d.from, error: error };
        }
      })()
    );
  });

  let result;

  result = await Promise.all(proms);
  const errors = [];
  result
    .filter((d) => d.error)
    .forEach((d) => {
      errors.push(d);
    });

  let mutations = "";

  result
    .filter((d) => !d.error)
    .forEach((d, idx) => {
      //Create mutation text

      mutations =
        mutations +
        `
  update_doc${idx}:update_documents_by_pk(pk_columns: { id: "${d.id}" }, _set: {key: "${d.public_id}", jobid: "${tojobid}"}){
    id
   }
   `;
    });

  if (mutations !== "") {
    const mutationResult = await client.request(`mutation {
        ${mutations}
      }`);
    res.json({ errors, mutationResult });
  } else {
    res.json({ errors: "No images were succesfully moved on remote server. " });
  }
};

//Also needs to be updated in upload utility and mobile app.
function DetermineFileType(filetype) {
  if (!filetype) return "auto";
  else if (filetype.startsWith("image")) return "image";
  else if (filetype.startsWith("video")) return "video";
  else if (filetype.startsWith("application/pdf")) return "image";
  else if (filetype.startsWith("application")) return "raw";

  return "auto";
}