Home Reference Source

cables_dev/cables_electron/src/utils/ops_util.js

  1. import { utilProvider, SharedOpsUtil } from "cables-shared-api";
  2. import path from "path";
  3. import mkdirp from "mkdirp";
  4. import fs from "fs";
  5. import projectsUtil from "./projects_util.js";
  6. import filesUtil from "./files_util.js";
  8. class OpsUtil extends SharedOpsUtil
  9. {
  11.     validateAndFormatOpCode(code)
  12.     {
  13.         return {
  14.             "formatedCode": this._helperUtil.removeTrailingSpaces(code),
  15.             "error": false,
  16.             "message": null
  17.         };
  18.     }
  20.     isCoreOp(opName)
  21.     {
  22.         if (!opName || this.isLocalOp(opName)) return false;
  23.         const opsDir = this._cables.getCoreOpsPath();
  24.         const opDir = this.getOpSourceDir(opName);
  25.         return opDir.startsWith(opsDir);
  26.     }
  28.     addPermissionsToOps(opDocs, user, teams = [], project = null)
  29.     {
  30.         if (!opDocs) return opDocs;
  31.         opDocs.forEach((opDoc) =>
  32.         {
  33.             const file = this.getOpAbsoluteFileName(opDoc.name);
  34.             opDoc.allowEdit = true;
  35.             if (file)
  36.             {
  37.                 try
  38.                 {
  39.                     fs.accessSync(file, fs.constants.R_OK | fs.constants.W_OK);
  40.                     opDoc.allowEdit = true;
  41.                 }
  42.                 catch (e)
  43.                 {
  44.                     // not allowed to read/write
  45.                     opDoc.allowEdit = false;
  46.                 }
  47.             }
  48.         });
  49.         return opDocs;
  50.     }
  52.     userHasWriteRightsOp(user, opName, teams = [], project = null, ignoreAdmin = false)
  53.     {
  54.         if (!user) return false;
  55.         if (!opName) return false;
  56.         if (!opName.startsWith(this.PREFIX_OPS)) return false;
  57.         if (opName.indexOf("..") > -1) return false;
  58.         if (opName.indexOf(" ") > -1) return false;
  59.         if (opName.startsWith(".")) return false;
  60.         if (opName.endsWith(".")) return false;
  62.         const validName = this.isOpNameValid(opName);
  63.         if (!validName) return false;
  65.         const file = this.getOpAbsoluteFileName(opName);
  66.         if (file)
  67.         {
  68.             if (fs.existsSync(file))
  69.             {
  70.                 try
  71.                 {
  72.                     fs.accessSync(file, fs.constants.R_OK | fs.constants.W_OK);
  73.                     return true;
  74.                 }
  75.                 catch (e)
  76.                 {
  77.                     // not allowed to read/write
  78.                     return false;
  79.                 }
  80.             }
  81.             else if (this._cables.inPackage(file))
  82.             {
  83.                 return false;
  84.             }
  85.             else
  86.             {
  87.                 return true;
  88.             }
  89.         }
  90.         return true;
  91.     }
  93.     getOpAbsolutePath(opName)
  94.     {
  95.         return projectsUtil.getAbsoluteOpDirFromHierarchy(opName);
  96.     }
  98.     getOpSourceDir(opName, relative = false)
  99.     {
  100.         if (!opName) return null;
  101.         if (relative) return super.getOpSourceDir(opName, relative);
  102.         return projectsUtil.getAbsoluteOpDirFromHierarchy(opName);
  103.     }
  105.     getOpTargetDir(opName, relative = false)
  106.     {
  107.         let targetDir = "";
  108.         if (relative)
  109.         {
  110.             if (opName.endsWith(".")) opName = opName.substring(0, opName.length - 1);
  111.             return path.join(opName, "/");
  112.         }
  113.         else
  114.         {
  115.             targetDir = projectsUtil.getAbsoluteOpDirFromHierarchy(opName);
  116.         }
  117.         return targetDir;
  118.     }
  120.     getOpSourceNoHierarchy(opName, relative = false)
  121.     {
  122.         return super.getOpSourceDir(opName, relative);
  123.     }
  125.     getOpRenameConsequences(newName, oldName, targetDir = null)
  126.     {
  127.         return [];
  128.     }
  130.     /**
  131.      * @typedef {Object} OpRenameProblems
  132.      * @property {String} [source_does_not_exist]
  133.      * @property {String} [overruled_by_other_op]
  134.      * @property {String} [namespace_empty]
  135.      * @property {String} [patch_op_illegal_namespace]
  136.      * @property {String} [name_ends_with_dot]
  137.      * @property {String} [name_ends_with_underscore]
  138.      * @property {String} [name_not_op_namespace]
  139.      * @property {String} [target_exists]
  140.      * @property {String} [name_taken]
  141.      * @property {String} [name_too_short]
  142.      * @property {String} [name_contains_doubledot]
  143.      * @property {String} [name_contains_illegal_characters]
  144.      * @property {String} [patch_op_rename_illegal]
  145.      * @property {String} [namespace_starts_with_numbers]
  146.      * @property {String} [namespace_starts_with_whitespace]
  147.      * @property {String} [namespace_starts_with_dash]
  148.      * @property {String} [namespace_not_uppercase]
  149.      * @property {String} [op_used_elsewhere]
  150.      * @property {String} [no_rights_target]
  151.      * @property {String} [no_rights_source]
  152.      * @property {String} [not_found_source]
  153.      * @property {String} [bad_op_hierarchy]
  154.      * @property {String} [overruled_by_other_op]
  155.      * @property {String} [illegal_ops]
  156.      * @property {String} [version_suggestion]
  157.      */
  159.     /**
  160.      * @returns {OpRenameProblems}
  161.      */
  162.     getOpRenameProblems(newName, oldName, userObj, teams = [], newOpProject = null, oldOpProject = null, opUsages = [], checkUsages = true, targetDir = null)
  163.     {
  164.         const problems = super.getOpRenameProblems(newName, oldName, userObj, teams, newOpProject, oldOpProject, opUsages, checkUsages);
  165.         if (problems.no_rights_target && targetDir)
  166.         {
  167.             if (fs.existsSync(targetDir))
  168.             {
  169.                 try
  170.                 {
  171.                     fs.accessSync(targetDir, fs.constants.R_OK | fs.constants.W_OK);
  172.                     delete problems.no_rights_target;
  173.                 }
  174.                 catch (e)
  175.                 {
  176.                     // not allowed to read/write
  177.                 }
  178.             }
  179.             else
  180.             {
  181.                 try
  182.                 {
  183.                     mkdirp.sync(targetDir);
  184.                     delete problems.no_rights_target;
  185.                 }
  186.                 catch (e)
  187.                 {
  188.                     // not allowed to create targetDir
  189.                 }
  190.             }
  191.         }
  192.         if (problems.target_exists && targetDir)
  193.         {
  194.             const newOpDir = path.join(targetDir, this.getOpTargetDir(newName, true), this.getOpFileName(newName));
  195.             if (!fs.existsSync(newOpDir))
  196.             {
  197.                 delete problems.target_exists;
  198.                 const existingOpDir = this.getOpSourceDir(newName);
  199.                 problems.overruled_by_other_op = "The new Op would conflict with the Op at:<br/> <a onclick=\"CABLESUILOADER.talkerAPI.send('openDir', { 'dir': '" + existingOpDir + "'});\">" + existingOpDir + "</a>";
  200.             }
  201.         }
  202.         return problems;
  203.     }
  205.     getOpAssetPorts(op, includeLibraryAssets = false)
  206.     {
  207.         const assetPorts = [];
  208.         if (!op) return assetPorts;
  209.         if (!op.portsIn) return assetPorts;
  211.         for (let i = 0; i < op.portsIn.length; i++)
  212.         {
  213.             const port = op.portsIn[i];
  214.             if (
  215.                 port.value &&
  216.                 typeof port.value == "string" &&
  217.                 port.name &&
  218.                 port.value.length &&
  219.                 (port.display === "file" ||
  220.                     port.name.toLowerCase().indexOf("file") > -1 ||
  221.                     port.name.toLowerCase().indexOf("url") > -1 ||
  222.                     // port names in cubemapfromtextures !
  223.                     port.name.toLowerCase().indexOf("posx") > -1 ||
  224.                     port.name.toLowerCase().indexOf("posy") > -1 ||
  225.                     port.name.toLowerCase().indexOf("posz") > -1 ||
  226.                     port.name.toLowerCase().indexOf("negx") > -1 ||
  227.                     port.name.toLowerCase().indexOf("negy") > -1 ||
  228.                     port.name.toLowerCase().indexOf("negz") > -1)
  229.             )
  230.             {
  231.                 if (!port.value.toLowerCase().startsWith("/assets/library"))
  232.                 {
  233.                     assetPorts.push(port);
  234.                 }
  235.                 else if (includeLibraryAssets)
  236.                 {
  237.                     assetPorts.push(port);
  238.                 }
  239.             }
  240.         }
  241.         return assetPorts;
  242.     }
  244.     getOpNameByAbsoluteFileName(fileName)
  245.     {
  246.         if (!fileName) return "";
  247.         const parts = path.parse(fileName);
  248.         if (parts && parts.name) return parts.name;
  249.         return "";
  250.     }
  252.     updateOpCode(opName, author, code)
  253.     {
  254.         filesUtil.unregisterOpChangeListeners([opName]);
  255.         const newCode = super.updateOpCode(opName, author, code);
  256.         setTimeout(() =>
  257.         {
  258.             filesUtil.registerOpChangeListeners([opName]);
  259.         }, 1000);
  260.         return newCode;
  261.     }
  263.     getOpNpmPackages(opName)
  264.     {
  265.         let toInstall = [];
  266.         const opDoc = this._docsUtil.getDocForOp(opName);
  267.         if (opDoc && opDoc.hasOwnProperty("dependencies"))
  268.         {
  269.             const npmDeps = opDoc.dependencies.filter((dep) => { return dep.type === "npm"; });
  270.             npmDeps.forEach((npmDep) =>
  271.             {
  272.                 if (npmDep.src)
  273.                 {
  274.                     if (!toInstall.includes(npmDep.src))
  275.                     {
  276.                         toInstall.push(npmDep.src);
  277.                     }
  278.                 }
  279.             });
  280.         }
  281.         return toInstall;
  282.     }
  284.     renameToCoreOp(oldName, newName, currentUser, cb = null)
  285.     {
  286.         let oldOpDir = this.getOpSourceDir(oldName);
  287.         let newOpDir = oldOpDir.replace(oldName, newName);
  288.         return this._renameOp(oldName, newName, currentUser, true, true, false, oldOpDir, newOpDir, cb);
  289.     }
  291.     renameToExtensionOp(oldName, newName, currentUser, cb = null)
  292.     {
  293.         let oldOpDir = this.getOpSourceDir(oldName);
  294.         let newOpDir = oldOpDir.replace(oldName, newName);
  295.         return this._renameOp(oldName, newName, currentUser, true, true, false, oldOpDir, newOpDir, cb);
  296.     }
  298.     renameToTeamOp(oldName, newName, currentUser, cb = null)
  299.     {
  300.         let oldOpDir = this.getOpSourceDir(oldName);
  301.         let newOpDir = oldOpDir.replace(oldName, newName);
  302.         return this._renameOp(oldName, newName, currentUser, false, true, false, oldOpDir, newOpDir, cb);
  303.     }
  305.     renameToUserOp(oldName, newName, currentUser, cb = null)
  306.     {
  307.         let oldOpDir = this.getOpSourceDir(oldName);
  308.         let newOpDir = oldOpDir.replace(oldName, newName);
  309.         return this._renameOp(oldName, newName, currentUser, false, true, false, oldOpDir, newOpDir, cb);
  310.     }
  312.     renameToPatchOp(oldName, newName, currentUser, removeOld, newId, cb = null)
  313.     {
  314.         let oldOpDir = this.getOpSourceDir(oldName);
  315.         let newOpDir = oldOpDir.replace(oldName, newName);
  316.         return this._renameOp(oldName, newName, currentUser, false, removeOld, newId, oldOpDir, newOpDir, cb);
  317.     }
  319.     getPatchOpNamespace(opName)
  320.     {
  321.         return this.getNamespace(opName);
  322.     }
  324.     getPatchOpsNamespaceForProject(proj)
  325.     {
  326.         return this.PREFIX_LOCAL_OPS;
  327.     }
  329.     userHasReadRightsOp(user, opName, teams = null, project = null, opOwner = null)
  330.     {
  331.         return true;
  332.     }
  334.     getCollectionName(opName)
  335.     {
  336.         if (!opName) return null;
  337.         if (opName.startsWith(this.PREFIX_LOCAL_OPS)) return this.PREFIX_LOCAL_OPS;
  338.         return super.getCollectionName(opName);
  339.     }
  340. }
  341. export default new OpsUtil(utilProvider);