Home Reference Source

cables_dev/cables_electron/src/electron/electron_api.js

  1. // eslint-disable-next-line import/no-extraneous-dependencies
  2. import { app, ipcMain, net, shell } from "electron";
  3. import fs from "fs";
  4. import path from "path";
  5. import mkdirp from "mkdirp";
  6. import { promisify } from "util";
  8. import jsonfile from "jsonfile";
  9. import sanitizeFileName from "sanitize-filename";
  10. import { utilProvider } from "cables-shared-api";
  11. import { createRequire } from "module";
  12. import cables from "../cables.js";
  13. import logger from "../utils/logger.js";
  14. import doc from "../utils/doc_util.js";
  15. import helper from "../utils/helper_util.js";
  16. import opsUtil from "../utils/ops_util.js";
  17. import subPatchOpUtil from "../utils/subpatchop_util.js";
  18. import settings from "./electron_settings.js";
  19. import projectsUtil from "../utils/projects_util.js";
  20. import electronApp from "./main.js";
  21. import filesUtil from "../utils/files_util.js";
  22. import libsUtil from "../utils/libs_util.js";
  23. import HtmlExportElectron from "../export/export_html_electron.js";
  24. import PatchExportElectron from "../export/export_patch_electron.js";
  26. class ElectronApi
  27. {
  28.     constructor()
  29.     {
  30.         this._log = logger;
  31.     }
  33.     init()
  34.     {
  35.         ipcMain.handle("talkerMessage", async (event, cmd, data, topicConfig = {}) =>
  36.         {
  37.             try
  38.             {
  39.                 return this.talkerMessage(cmd, data, topicConfig);
  40.             }
  41.             catch (e)
  42.             {
  43.                 return this.error(e.message, e);
  44.             }
  45.         });
  47.         ipcMain.handle("documentChanged", async (event, _cmd, data) =>
  48.         {
  49.             return electronApp.editorWindow.setDocumentEdited(true);
  50.         });
  52.         ipcMain.on("platformSettings", (event, _cmd, _data) =>
  53.         {
  54.             settings.data.buildInfo = settings.getBuildInfo();
  55.             settings.data.openFullscreen = electronApp.openFullscreen();
  56.             settings.data.maximizeRenderer = electronApp.maximizeRenderer();
  57.             event.returnValue = settings.data;
  58.         });
  60.         ipcMain.on("cablesConfig", (event, _cmd, _data) =>
  61.         {
  62.             event.returnValue = cables.getConfig();
  63.         });
  65.         ipcMain.on("getStartupLog", (event, _cmd, _data) =>
  66.         {
  67.             event.returnValue = this._log.startUpLog || [];
  68.         });
  70.         ipcMain.on("getOpDir", (event, data) =>
  71.         {
  72.             let opName = opsUtil.getOpNameById(data.opId);
  73.             if (!opName) opName = data.opName;
  74.             event.returnValue = opsUtil.getOpAbsolutePath(opName);
  75.         });
  77.         ipcMain.on("getOpModuleDir", (event, data) =>
  78.         {
  79.             let opName = opsUtil.getOpNameById(data.opId);
  80.             if (!opName) opName = data.opName;
  81.             const opDir = opsUtil.getOpAbsolutePath(opName);
  82.             event.returnValue = path.join(opDir, "node_modules", data.moduleName);
  83.         });
  85.         ipcMain.on("getOpModuleLocation", (event, data) =>
  86.         {
  87.             let opName = opsUtil.getOpNameById(data.opId);
  88.             if (!opName) opName = data.opName;
  89.             const opDir = opsUtil.getOpAbsolutePath(opName);
  90.             const moduleDir = path.join(opDir, "node_modules");
  91.             const moduleRequire = createRequire(moduleDir);
  92.             if (moduleRequire)
  93.             {
  94.                 try
  95.                 {
  96.                     let location = moduleRequire.resolve(data.moduleName);
  97.                     if (data.asUrl) location = helper.pathToFileURL(location);
  98.                     event.returnValue = location;
  99.                 }
  100.                 catch (e)
  101.                 {
  102.                     this._log.error(data.moduleName + " " + moduleDir);
  103.                     event.returnValue = null;
  104.                 }
  105.             }
  106.             else
  107.             {
  108.                 event.returnValue = null;
  109.             }
  110.         });
  112.         ipcMain.on("getOpModules", (event, data) =>
  113.         {
  114.             let deps = [];
  115.             if (!data.opName) return [];
  116.             const opName = data.opName;
  117.             const opDocFile = opsUtil.getOpAbsoluteJsonFilename(opName);
  118.             if (fs.existsSync(opDocFile))
  119.             {
  120.                 let opDoc = jsonfile.readFileSync(opDocFile);
  121.                 if (opDoc)
  122.                 {
  123.                     deps = opDoc.dependencies || [];
  124.                 }
  125.             }
  126.             event.returnValue = deps.filter((dep) => { return dep.type === "npm"; }).map((dep) => { return dep.src[0]; });
  127.         });
  128.     }
  130.     async talkerMessage(cmd, data, topicConfig = {})
  131.     {
  132.         let response = null;
  133.         if (!cmd) return this.error("UNKNOWN_COMMAND", null, "warn");
  134.         if (typeof this[cmd] === "function")
  135.         {
  136.             if (topicConfig.needsProjectFile)
  137.             {
  138.                 const projectFile = settings.getCurrentProjectFile();
  139.                 if (!projectFile)
  140.                 {
  141.                     const newName = data ? data.name : projectsUtil.getNewProjectName();
  142.                     const newProjectFile = await electronApp.saveProjectFileDialog(newName);
  143.                     if (newProjectFile)
  144.                     {
  145.                         let patchData = null;
  146.                         let currentProject = settings.getCurrentProject();
  147.                         if (cmd === "savePatch" && data)
  148.                         {
  149.                             patchData = data;
  150.                         }
  151.                         projectsUtil.writeProjectToFile(newProjectFile, currentProject, patchData);
  152.                         this.loadProject(newProjectFile);
  153.                     }
  154.                     else
  155.                     {
  156.                         return this.error("CANCELLED", null, "info");
  157.                     }
  158.                 }
  159.             }
  160.             return this[cmd](data);
  161.         }
  162.         else
  163.         {
  164.             this._log.warn("no method for talkerMessage", cmd);
  165.         }
  166.         return response;
  167.     }
  169.     getOpInfo(data)
  170.     {
  171.         const opName = opsUtil.getOpNameById(data.opName) || data.opName;
  173.         let warns = [];
  174.         try
  175.         {
  176.             const currentProject = settings.getCurrentProject();
  177.             if (currentProject)
  178.             {
  179.                 let opDocs = projectsUtil.getOpDocsInProjectDirs(currentProject);
  180.                 opDocs = opDocs.filter((opDoc) => { return opDoc.name === opName; });
  181.                 opDocs.forEach((opDoc) =>
  182.                 {
  183.                     if (opDoc.overrides)
  184.                     {
  185.                         opDoc.overrides.forEach((override) =>
  186.                         {
  187.                             warns.push({
  188.                                 "type": "project",
  189.                                 "id": "",
  190.                                 "text": "<a onclick=\"CABLESUILOADER.talkerAPI.send('openDir', { 'dir': '" + override + "'});\"><span class=\"icon icon-folder\"></span> this op overrides another op</a>"
  191.                             });
  192.                         });
  193.                     }
  194.                 });
  195.             }
  197.             warns = warns.concat(opsUtil.getOpCodeWarnings(opName));
  199.             if (opsUtil.isOpNameValid(opName))
  200.             {
  201.                 const result = { "warns": warns };
  202.                 result.attachmentFiles = opsUtil.getAttachmentFiles(opName);
  204.                 const opDocs = doc.getDocForOp(opName);
  205.                 let changelogEntries = [];
  206.                 if (opDocs && opDocs.changelog)
  207.                 {
  208.                     // copy array to not modify reference
  209.                     changelogEntries = changelogEntries.concat(opDocs.changelog);
  210.                     if (data.sort === "asc")
  211.                     {
  212.                         changelogEntries.sort((a, b) => { return a.date - b.date; });
  213.                     }
  214.                     else
  215.                     {
  216.                         changelogEntries.sort((a, b) => { return b.date - a.date; });
  217.                     }
  218.                     const numChangelogEntries = data.cl || 5;
  219.                     result.changelog = changelogEntries.slice(0, numChangelogEntries);
  220.                 }
  221.                 return this.success("OK", result, true);
  222.             }
  223.             else
  224.             {
  225.                 const result = { "warns": [] };
  226.                 result.attachmentFiles = [];
  227.                 return this.success("OK", result, true);
  228.             }
  229.         }
  230.         catch (e)
  231.         {
  232.             this._log.warn("error when getting opinfo", opName, e.message);
  233.             const result = { "warns": warns };
  234.             result.attachmentFiles = [];
  235.             return this.success("OK", result, true);
  236.         }
  237.     }
  239.     async savePatch(patch)
  240.     {
  241.         const currentProject = settings.getCurrentProject();
  242.         const currentProjectFile = settings.getCurrentProjectFile();
  244.         const re = {
  245.             "msg": "PROJECT_SAVED"
  246.         };
  247.         currentProject.updated = Date.now();
  248.         currentProject.updatedByUser = settings.getCurrentUser().username;
  249.         projectsUtil.writeProjectToFile(currentProjectFile, currentProject, patch);
  250.         this.loadProject(currentProjectFile);
  251.         re.updated = currentProject.updated;
  252.         re.updatedByUser = currentProject.updatedByUser;
  253.         return this.success("OK", re, true);
  254.     }
  256.     async patchCreateBackup()
  257.     {
  258.         const re = {
  259.             "msg": "BACKUP_CREATED"
  260.         };
  261.         const currentProject = settings.getCurrentProject();
  262.         const projectFile = await electronApp.saveProjectFileDialog();
  263.         if (!projectFile)
  264.         {
  265.             logger.info("no backup file chosen");
  266.             return this.error("no backup file chosen", null, "info");
  267.         }
  269.         const backupProject = projectsUtil.getBackup(currentProject);
  270.         fs.writeFileSync(projectFile, JSON.stringify(backupProject));
  271.         return this.success("OK", re, true);
  272.     }
  274.     getPatch()
  275.     {
  276.         const patchPath = settings.getCurrentProjectFile();
  277.         const currentUser = settings.getCurrentUser();
  278.         let currentProject = settings.getCurrentProject();
  279.         if (patchPath && fs.existsSync(patchPath))
  280.         {
  281.             currentProject = fs.readFileSync(patchPath);
  282.             currentProject = JSON.parse(currentProject.toString("utf-8"));
  283.             if (!currentProject.hasOwnProperty("userList")) currentProject.userList = [currentUser];
  284.             if (!currentProject.hasOwnProperty("teams")) currentProject.teams = [];
  285.         }
  286.         else
  287.         {
  288.             if (!currentProject)
  289.             {
  290.                 const newProject = projectsUtil.generateNewProject(settings.getCurrentUser());
  291.                 this.loadProject(patchPath, newProject);
  292.                 currentProject = newProject;
  293.             }
  294.         }
  295.         currentProject.allowEdit = true;
  296.         currentProject.summary = currentProject.summary || {};
  297.         currentProject.summary.title = currentProject.name;
  298.         currentProject.summary.allowEdit = true;
  299.         return this.success("OK", currentProject, true);
  300.     }
  302.     getPatchSummary()
  303.     {
  304.         return this.success("OK", projectsUtil.getSummary(settings.getCurrentProject()));
  305.     }
  307.     async newPatch()
  308.     {
  309.         await electronApp.openPatch(null, false);
  310.         return this.success("OK", true, true);
  311.     }
  313.     fileUpload(data)
  314.     {
  315.         const target = cables.getAssetPath();
  316.         if (!data.fileStr) return;
  317.         if (!data.filename)
  318.         {
  319.             return;
  320.         }
  321.         let saveAs = data.filename;
  322.         if (!path.isAbsolute(data.filename)) saveAs = path.join(target, path.join("/", data.filename));
  323.         const buffer = Buffer.from(data.fileStr.split(",")[1], "base64");
  324.         fs.writeFileSync(saveAs, buffer);
  325.         return this.success("OK", { "filename": path.basename(saveAs) }, true);
  326.     }
  328.     async getAllProjectOps()
  329.     {
  330.         const currentUser = settings.getCurrentUser();
  331.         const project = settings.getCurrentProject();
  333.         let opDocs = [];
  335.         if (!project)
  336.         {
  337.             return this.success("OK", opDocs, true);
  338.         }
  340.         let projectOps = [];
  341.         let projectNamespaces = [];
  342.         let usedOpIds = [];
  343.         // add all ops that are used in the toplevel of the project, save them as used
  344.         project.ops.forEach((projectOp) =>
  345.         {
  346.             projectOps.push((opsUtil.getOpNameById(projectOp.opId)));
  347.             usedOpIds.push(projectOp.opId);
  348.         });
  350.         // add all ops in any of the project op directory
  351.         const otherDirsOps = projectsUtil.getOpDocsInProjectDirs(project, true, true).map((opDoc) => { return opDoc.name; });
  352.         projectOps = projectOps.concat(otherDirsOps);
  354.         // now we should have all the ops that are used in the project, walk subPatchOps
  355.         // recursively to get their opdocs
  356.         const subPatchOps = subPatchOpUtil.getOpsUsedInSubPatches(project);
  357.         subPatchOps.forEach((subPatchOp) =>
  358.         {
  359.             const opName = opsUtil.getOpNameById(subPatchOp.opId);
  360.             const nsName = opsUtil.getCollectionNamespace(opName);
  361.             projectOps.push(opName);
  362.             if (opsUtil.isCollection(nsName)) projectNamespaces.push(nsName);
  363.             usedOpIds.push(subPatchOp.opId);
  364.         });
  366.         projectOps = helper.uniqueArray(projectOps);
  367.         usedOpIds = helper.uniqueArray(usedOpIds);
  368.         projectNamespaces = helper.uniqueArray(projectNamespaces);
  369.         const coreOpDocs = doc.getOpDocs();
  370.         projectOps.forEach((opName) =>
  371.         {
  372.             let opDoc = doc.getDocForOp(opName, coreOpDocs);
  373.             if (opDoc)
  374.             {
  375.                 if (!opDoc.name) opDoc.name = opName;
  376.                 opDocs.push(opDoc);
  377.             }
  378.         });
  380.         // get opdocs for all the collected ops
  381.         opDocs = opsUtil.addOpDocsForCollections(projectNamespaces, opDocs);
  382.         opDocs.forEach((opDoc) =>
  383.         {
  384.             if (usedOpIds.includes(opDoc.id)) opDoc.usedInProject = true;
  385.         });
  387.         opDocs = opsUtil.addPermissionsToOps(opDocs, currentUser, [], project);
  388.         opDocs = opsUtil.addVersionInfoToOps(opDocs);
  390.         opDocs = doc.makeReadable(opDocs);
  391.         return this.success("OK", opDocs, true);
  392.     }
  394.     async getOpDocsAll()
  395.     {
  396.         const currentUser = settings.getCurrentUser();
  397.         const currentProject = settings.getCurrentProject();
  398.         let opDocs = doc.getOpDocs(true, true);
  399.         opDocs = opDocs.concat(doc.getCollectionOpDocs("Ops.Extension.Standalone", currentUser));
  400.         opDocs = opDocs.concat(projectsUtil.getOpDocsInProjectDirs(currentProject, true, true));
  401.         const cleanDocs = doc.makeReadable(opDocs);
  402.         opsUtil.addPermissionsToOps(cleanDocs, null);
  404.         const extensions = await doc.getAllExtensionDocs(true, true);
  405.         const libs = projectsUtil.getAvailableLibs(currentProject);
  406.         const coreLibs = projectsUtil.getCoreLibs();
  408.         return this.success("OK", {
  409.             "opDocs": cleanDocs,
  410.             "extensions": extensions,
  411.             "teamNamespaces": [],
  412.             "libs": libs,
  413.             "coreLibs": coreLibs
  414.         }, true);
  415.     }
  417.     async getOpDocs(data)
  418.     {
  419.         const opName = opsUtil.getOpNameById(data) || data;
  420.         if (!opName)
  421.         {
  422.             return {};
  423.         }
  424.         const result = {};
  425.         result.opDocs = [];
  427.         const opDoc = doc.getDocForOp(opName);
  428.         result.content = "No docs yet...";
  430.         const opDocs = [];
  431.         if (opDoc)
  432.         {
  433.             const currentProject = settings.getCurrentProject();
  434.             const projectOps = projectsUtil.getOpDocsInProjectDirs(currentProject);
  435.             const projectOp = projectOps.find((op) => { return op.name === opName; });
  436.             if (projectOp)
  437.             {
  438.                 opDocs.push(projectOp);
  439.             }
  440.             else
  441.             {
  442.                 opDocs.push(opDoc);
  443.             }
  444.             if (opDoc.dependencies)
  445.             {
  446.                 const opPackages = opsUtil.getOpNpmPackages(opName);
  447.                 const packageDir = opsUtil.getOpAbsolutePath(opName);
  448.                 result.dependenciesOutput = await electronApp.installPackages(packageDir, opPackages, opName);
  449.             }
  450.             result.opDocs = doc.makeReadable(opDocs);
  451.             result.opDocs = opsUtil.addVersionInfoToOps(opDocs);
  452.             result.opDocs = opsUtil.addPermissionsToOps(result.opDocs, null);
  453.             return this.success("OK", result, true);
  454.         }
  455.         else
  456.         {
  457.             let text = "Could not find op with id " + data + " in:";
  458.             const footer = "Try adding other directories via 'Manage Op Directories' after loading the patch.";
  459.             const reasons = [];
  461.             const errorVars = {
  462.                 "text": text,
  463.                 "footer": footer,
  464.                 "reasons": reasons,
  465.                 "hideEnvButton": true
  466.             };
  468.             const currentProject = settings.getCurrentProject();
  469.             const projectOpDirs = projectsUtil.getProjectOpDirs(currentProject, true);
  470.             projectOpDirs.forEach((projectOpDir) =>
  471.             {
  472.                 const link = "<a onclick=\"CABLESUILOADER.talkerAPI.send('openDir', { 'dir': '" + projectOpDir + "'});\"><span class=\"icon icon-folder\"></span> " + projectOpDir + "</a>";
  473.                 reasons.push(link);
  474.             });
  476.             if (net.isOnline())
  477.             {
  478.                 const getOpEnvironmentDocs = promisify(opsUtil.getOpEnvironmentDocs.bind(opsUtil));
  479.                 try
  480.                 {
  481.                     const envDocs = await getOpEnvironmentDocs(data);
  482.                     if (envDocs && envDocs.environments && envDocs.environments.length > 0)
  483.                     {
  484.                         const otherEnvName = envDocs.environments[0];
  485.                         errorVars.editorLink = "https://" + otherEnvName + "/op/" + envDocs.name;
  486.                         errorVars.otherEnvButton = "Visit " + otherEnvName;
  488.                         text = "Could not find <a href=\"" + errorVars.editorLink + "\" target=\"_blank\">" + envDocs.name + "</a> in:";
  490.                         envDocs.environments.forEach((envName) =>
  491.                         {
  492.                             const opLink = "https://" + envName + "/op/" + envDocs.name;
  493.                             reasons.push("Found <a href=\"" + opLink + "\" target=\"_blank\">" + envDocs.name + "</a> on " + envName);
  494.                         });
  495.                     }
  496.                     errorVars.text = text;
  497.                     errorVars.reasons = reasons;
  498.                     errorVars.hideEnvButton = false;
  499.                 }
  500.                 catch (e)
  501.                 { // something went wrong, no internet or something, this is informational anyhow}
  502.                 }
  503.             }
  505.             return this.error("OP_NOT_FOUND", errorVars, "warn");
  506.         }
  507.     }
  509.     saveOpCode(data)
  510.     {
  511.         const opName = opsUtil.getOpNameById(data.opname);
  512.         const code = data.code;
  513.         let returnedCode = code;
  515.         const format = opsUtil.validateAndFormatOpCode(code);
  516.         if (format.error)
  517.         {
  518.             const {
  519.                 line,
  520.                 message
  521.             } = format.message;
  522.             this._log.info({
  523.                 line,
  524.                 message
  525.             });
  526.             return {
  527.                 "error": {
  528.                     line,
  529.                     message
  530.                 }
  531.             };
  532.         }
  533.         const formatedCode = format.formatedCode;
  534.         if (data.format || opsUtil.isCoreOp(opName))
  535.         {
  536.             returnedCode = formatedCode;
  537.         }
  538.         returnedCode = opsUtil.updateOpCode(opName, settings.getCurrentUser(), returnedCode);
  539.         doc.updateOpDocs(opName);
  541.         return this.success("OK", { "opFullCode": returnedCode }, true);
  542.     }
  544.     getOpCode(data)
  545.     {
  546.         const opName = opsUtil.getOpNameById(data.opId || data.opname);
  547.         if (opsUtil.opExists(opName))
  548.         {
  549.             filesUtil.registerOpChangeListeners([opName]);
  550.             let code = opsUtil.getOpCode(opName);
  551.             return this.success("OK", {
  552.                 "name": opName,
  553.                 "id": data.opId,
  554.                 "code": code
  555.             }, true);
  556.         }
  557.         else
  558.         {
  559.             let code = "//empty file...";
  560.             return this.success("OK", {
  561.                 "name": opName,
  562.                 "id": null,
  563.                 "code": code
  564.             }, true);
  565.         }
  566.     }
  568.     async opAttachmentAdd(data)
  569.     {
  570.         const opName = opsUtil.getOpNameById(data.opname) || data.opname;
  571.         const attName = data.name;
  572.         const p = opsUtil.addAttachment(opName, "att_" + attName, "hello attachment");
  573.         this._log.info("created attachment!", p);
  574.         doc.updateOpDocs(opName);
  575.         this.success("OK");
  576.     }
  578.     async opAttachmentDelete(data)
  579.     {
  580.         const opName = opsUtil.getOpNameById(data.opname) || data.opname;
  581.         const attName = data.name;
  582.         opsUtil.deleteAttachment(opName, attName);
  583.         this.success("OK");
  584.     }
  586.     async opAddCoreLib(data)
  587.     {
  588.         const opName = opsUtil.getOpNameById(data.opname) || data.opname;
  589.         const libName = sanitizeFileName(data.name);
  590.         const opFilename = opsUtil.getOpJsonPath(data.opname);
  591.         const libFilename = cables.getCoreLibsPath() + libName;
  592.         const existsLib = fs.existsSync(libFilename + ".js");
  593.         if (!existsLib)
  594.         {
  595.             this.error("LIB_NOT_FOUND");
  596.             return;
  597.         }
  599.         try
  600.         {
  601.             const obj = jsonfile.readFileSync(opFilename);
  602.             obj.coreLibs = obj.coreLibs || [];
  604.             if (obj.coreLibs.indexOf(libName) === -1) obj.coreLibs.push(libName);
  606.             try
  607.             {
  608.                 jsonfile.writeFileSync(opFilename, obj, {
  609.                     "encoding": "utf-8",
  610.                     "spaces": 4
  611.                 });
  612.                 doc.updateOpDocs(opName);
  613.                 this.success("OK", {});
  614.             }
  615.             catch (writeErr)
  616.             {
  617.                 this.error("WRITE_ERROR");
  618.             }
  619.         }
  620.         catch (err)
  621.         {
  622.             this.error("UNKNOWN_ERROR");
  623.         }
  624.     }
  626.     async opAddLib(data)
  627.     {
  628.         const opName = opsUtil.getOpNameById(data.opname) || data.opname;
  629.         const libName = sanitizeFileName(data.name);
  631.         const filename = opsUtil.getOpJsonPath(opName);
  633.         const libExists = libsUtil.libExists(libName);
  634.         if (!libExists)
  635.         {
  636.             this.error("LIB_NOT_FOUND", 400);
  637.             return;
  638.         }
  640.         try
  641.         {
  642.             const obj = jsonfile.readFileSync(filename);
  643.             obj.libs = obj.libs || [];
  645.             if (obj.libs.indexOf(libName) === -1) obj.libs.push(libName);
  647.             try
  648.             {
  649.                 jsonfile.writeFileSync(filename, obj, {
  650.                     "encoding": "utf-8",
  651.                     "spaces": 4
  652.                 });
  653.                 doc.updateOpDocs(opName);
  654.                 this.success("OK");
  655.             }
  656.             catch (writeErr)
  657.             {
  658.                 this.error("WRITE_ERROR", 500);
  659.             }
  660.         }
  661.         catch (err)
  662.         {
  663.             this.error("UNKNOWN_ERROR", 500);
  664.         }
  665.     }
  667.     async opRemoveLib(data)
  668.     {
  669.         const opName = opsUtil.getOpNameById(data.opname) || data.opname;
  670.         const libName = sanitizeFileName(data.name);
  672.         const filename = opsUtil.getOpJsonPath(opName);
  674.         try
  675.         {
  676.             const obj = jsonfile.readFileSync(filename);
  677.             obj.libs = obj.libs || [];
  679.             if (obj.libs.includes(libName)) obj.libs = obj.libs.filter((lib) => { return lib !== libName; });
  681.             try
  682.             {
  683.                 jsonfile.writeFileSync(filename, obj, {
  684.                     "encoding": "utf-8",
  685.                     "spaces": 4
  686.                 });
  687.                 doc.updateOpDocs(opName);
  688.                 this.success("OK");
  689.             }
  690.             catch (writeErr)
  691.             {
  692.                 this.error("WRITE_ERROR", 500);
  693.             }
  694.         }
  695.         catch (err)
  696.         {
  697.             this.error("UNKNOWN_ERROR", 500);
  698.         }
  699.     }
  701.     async opRemoveCoreLib(data)
  702.     {
  703.         const opName = opsUtil.getOpNameById(data.opname) || data.opname;
  704.         const libName = sanitizeFileName(data.name);
  705.         const opFilename = opsUtil.getOpJsonPath(opName);
  707.         try
  708.         {
  709.             const obj = jsonfile.readFileSync(opFilename);
  710.             obj.coreLibs = obj.coreLibs || [];
  712.             if (obj.coreLibs.includes(libName)) obj.coreLibs = obj.coreLibs.filter((lib) => { return lib !== libName; });
  714.             try
  715.             {
  716.                 jsonfile.writeFileSync(opFilename, obj, {
  717.                     "encoding": "utf-8",
  718.                     "spaces": 4
  719.                 });
  720.                 doc.updateOpDocs(opName);
  721.                 this.success("OK");
  722.             }
  723.             catch (writeErr)
  724.             {
  725.                 this.error("WRITE_ERROR", 500);
  726.             }
  727.         }
  728.         catch (err)
  729.         {
  730.             this.error("UNKNOWN_ERROR", 500);
  731.         }
  732.     }
  734.     async opAttachmentGet(data)
  735.     {
  736.         const opName = opsUtil.getOpNameById(data.opname) || data.opname;
  737.         const attName = data.name;
  738.         const content = opsUtil.getAttachment(opName, attName);
  739.         return this.success("OK", { "content": content }, true);
  740.     }
  742.     async getCollectionOpDocs(data)
  743.     {
  744.         let opDocs = [];
  745.         const collectionName = data.name;
  746.         const currentUser = settings.getCurrentUser();
  747.         if (collectionName)
  748.         {
  749.             const opNames = opsUtil.getCollectionOpNames(collectionName, true);
  750.             opDocs = opsUtil.addOpDocsForCollections(opNames, opDocs);
  751.             opDocs = opsUtil.addVersionInfoToOps(opDocs);
  752.             opDocs = opsUtil.addPermissionsToOps(opDocs, currentUser);
  753.         }
  754.         return this.success("OK", { "opDocs": doc.makeReadable(opDocs) }, true);
  755.     }
  757.     getBuildInfo()
  758.     {
  759.         return this.success("OK", settings.getBuildInfo(), true);
  760.     }
  762.     formatOpCode(data)
  763.     {
  764.         const code = data.code;
  765.         if (code)
  766.         {
  767.             // const format = opsUtil.validateAndFormatOpCode(code);
  768.             // if (format.error)
  769.             // {
  770.             //     const {
  771.             //         line,
  772.             //         message
  773.             //     } = format.message;
  774.             //     return {
  775.             //         "error": {
  776.             //             line,
  777.             //             message
  778.             //         }
  779.             //     };
  780.             // }
  781.             // else
  782.             // {
  783.             //     return {
  784.             //         "opFullCode": format.formatedCode,
  785.             //         "success": true
  786.             //     };
  787.             // }
  789.             return this.success("OK", {
  790.                 "opFullCode": code
  791.             }, true);
  792.         }
  793.         else
  794.         {
  795.             return this.success("OK", {
  796.                 "opFullCode": ""
  797.             }, true);
  798.         }
  799.     }
  801.     saveUserSettings(data)
  802.     {
  803.         if (data && data.settings)
  804.         {
  805.             settings.setUserSettings(data.settings);
  806.         }
  807.     }
  809.     checkProjectUpdated(data)
  810.     {
  811.         const project = settings.getCurrentProject();
  812.         if (project)
  813.         {
  814.             return this.success("OK", {
  815.                 "updated": null,
  816.                 "updatedByUser": project.updatedByUser,
  817.                 "buildInfo": project.buildInfo,
  818.                 "maintenance": false,
  819.                 "disallowSave": false
  820.             }, true);
  821.         }
  822.         else
  823.         {
  824.             return this.success("OK", {
  825.                 "updated": "",
  826.                 "updatedByUser": "",
  827.                 "buildInfo": settings.getBuildInfo(),
  828.                 "maintenance": false,
  829.                 "disallowSave": false
  830.             }, true);
  831.         }
  832.     }
  834.     getChangelog(data)
  835.     {
  836.         const obj = {};
  837.         obj.items = [];
  838.         obj.ts = Date.now();
  839.         return this.success("OK", obj, true);
  840.     }
  842.     opAttachmentSave(data)
  843.     {
  844.         let opName = data.opname;
  845.         if (opsUtil.isOpId(data.opname)) opName = opsUtil.getOpNameById(data.opname);
  846.         const result = opsUtil.updateAttachment(opName, data.name, data.content, false);
  847.         return this.success("OK", result, true);
  848.     }
  850.     setIconSaved()
  851.     {
  852.         let title = electronApp.editorWindow.getTitle();
  853.         const pos = title.lastIndexOf(" *");
  854.         let newTitle = title;
  855.         if (pos !== -1) newTitle = title.substring(0, pos);
  856.         electronApp.setDocumentEdited(false);
  857.         electronApp.editorWindow.setTitle(newTitle);
  858.     }
  860.     setIconUnsaved()
  861.     {
  862.         const title = electronApp.editorWindow.getTitle();
  863.         if (settings.getCurrentProject()) electronApp.setDocumentEdited(true);
  864.         electronApp.editorWindow.setTitle(title + " *");
  865.     }
  867.     saveScreenshot(data)
  868.     {
  869.         const currentProject = settings.getCurrentProject();
  870.         if (!currentProject || !data || !data.screenshot)
  871.         {
  872.             return this.error("NO_PROJECT");
  873.         }
  874.         currentProject.screenshot = data.screenshot;
  875.         projectsUtil.writeProjectToFile(settings.getCurrentProjectFile(), currentProject);
  876.         return this.success("OK", { "msg": "OK" }, true);
  877.     }
  879.     getFilelist(data)
  880.     {
  881.         let files;
  882.         switch (data.source)
  883.         {
  884.         case "patch":
  885.             files = filesUtil.getPatchFiles();
  886.             break;
  887.         case "lib":
  888.             files = filesUtil.getLibraryFiles();
  889.             break;
  890.         default:
  891.             files = [];
  892.             break;
  893.         }
  894.         return this.success("OK", files, true);
  895.     }
  897.     getFileDetails(data)
  898.     {
  899.         let filePath = helper.fileURLToPath(data.filename);
  900.         const fileDb = filesUtil.getFileDb(filePath, settings.getCurrentProject(), settings.getCurrentUser(), new Date().getTime());
  901.         return this.success("OK", filesUtil.getFileInfo(fileDb), true);
  902.     }
  904.     getLibraryFileInfo(data)
  905.     {
  906.         const fileName = filesUtil.realSanitizeFilename(data.filename);
  907.         const fileCategory = filesUtil.realSanitizeFilename(data.fileCategory);
  909.         const filePath = path.join(fileCategory, fileName);
  910.         const libraryPath = cables.getAssetLibraryPath();
  911.         const finalPath = path.join(libraryPath, filePath);
  913.         if (!fs.existsSync(finalPath))
  914.         {
  915.             return this.success("OK", {}, true);
  916.         }
  917.         else
  918.         {
  919.             const infoFileName = finalPath + ".fileinfo.json";
  920.             let filename = "";
  922.             if (fs.existsSync(infoFileName)) filename = infoFileName;
  924.             if (filename === "")
  925.             {
  926.                 return this.success("OK", {}, true);
  927.             }
  928.             else
  929.             {
  930.                 const fileInfo = JSON.parse(fs.readFileSync(filename));
  931.                 return this.success("OK", fileInfo, true);
  932.             }
  933.         }
  934.     }
  936.     checkOpName(data)
  937.     {
  938.         const opDocs = doc.getOpDocs(false, false);
  939.         const newName = encodeURIComponent(data.v);
  940.         const sourceName = data.sourceName || null;
  941.         const currentUser = settings.getCurrentUser();
  942.         const project = settings.getCurrentProject();
  943.         const fromRename = data.rename;
  944.         const result = this._getFullRenameResponse(opDocs, newName, sourceName, currentUser, project, true, fromRename, data.opTargetDir);
  945.         result.checkedName = newName;
  946.         return this.success("OK", result, true);
  947.     }
  949.     getRecentPatches()
  950.     {
  951.         const recents = settings.getRecentProjects();
  952.         const result = [];
  953.         for (let i = 0; i < recents.length; i++)
  954.         {
  955.             const recentProject = recents[i];
  956.             let screenShot = recentProject.screenshot;
  957.             if (!screenShot)
  958.             {
  959.                 screenShot = projectsUtil.getScreenShotFileName(recentProject, "png");
  960.                 if (!fs.existsSync(screenShot)) screenShot = path.join(cables.getUiDistPath(), "/img/placeholder_dark.png");
  961.             }
  962.             result[i] = recentProject;
  963.             result[i].thumbnail = screenShot;
  964.         }
  965.         return this.success("OK", result.slice(0, 10), true);
  966.     }
  968.     async opCreate(data)
  969.     {
  970.         let opName = data.opname;
  971.         const currentUser = settings.getCurrentUser();
  972.         const opDocDefaults = {
  973.             "layout": data.layout,
  974.             "libs": data.libs,
  975.             "coreLibs": data.coreLibs
  976.         };
  977.         let targetDir = data.opTargetDir;
  978.         if (!targetDir)
  979.         {
  980.             const projectOpDirs = projectsUtil.getOpDirs(settings.getCurrentProject());
  981.             if (projectOpDirs && projectOpDirs.length > 0)
  982.             {
  983.                 targetDir = projectOpDirs[0].dir;
  984.             }
  985.         }
  986.         const result = opsUtil.createOp(opName, currentUser, data.code, opDocDefaults, data.attachments, targetDir);
  987.         filesUtil.registerOpChangeListeners([opName]);
  988.         projectsUtil.invalidateProjectCaches();
  990.         return this.success("OK", result, true);
  991.     }
  993.     opUpdate(data)
  994.     {
  995.         let opName = data.opname;
  996.         if (opsUtil.isOpId(data.opname)) opName = opsUtil.getOpNameById(data.opname);
  997.         const currentUser = settings.getCurrentUser();
  998.         const result = opsUtil.updateOp(currentUser, opName, data.update, { "formatCode": data.formatCode });
  999.         return this.success("OK", { "data": result }, true);
  1000.     }
  1002.     opSaveLayout(data)
  1003.     {
  1004.         const layout = data.layout;
  1005.         const opName = opsUtil.getOpNameById(data.opname) || layout.name;
  1006.         return this.success("OK", opsUtil.saveLayout(opName, layout), true);
  1007.     }
  1009.     opSetSummary(data)
  1010.     {
  1011.         const opName = opsUtil.getOpNameById(data.opId) || data.name;
  1012.         let summary = data.summary || "";
  1013.         if (summary === "No Summary") summary = "";
  1014.         const opDocFile = opsUtil.getOpAbsoluteJsonFilename(opName);
  1015.         if (fs.existsSync(opDocFile))
  1016.         {
  1017.             let opDoc = jsonfile.readFileSync(opDocFile);
  1018.             if (opDoc)
  1019.             {
  1020.                 opDoc.summary = summary;
  1021.                 opDoc = doc.cleanOpDocData(opDoc);
  1022.                 jsonfile.writeFileSync(opDocFile, opDoc, {
  1023.                     "encoding": "utf-8",
  1024.                     "spaces": 4
  1025.                 });
  1026.                 doc.updateOpDocs();
  1027.             }
  1028.             return this.success("OK", opDoc, true);
  1029.         }
  1030.         else
  1031.         {
  1032.             return this.error("UNKNOWN_OP", null, "error");
  1033.         }
  1034.     }
  1036.     opClone(data)
  1037.     {
  1038.         const newName = data.name;
  1039.         const oldName = opsUtil.getOpNameById(data.opname) || data.opname;
  1040.         const currentUser = settings.getCurrentUser();
  1041.         const cloned = opsUtil.cloneOp(oldName, newName, currentUser, data.opTargetDir);
  1042.         projectsUtil.invalidateProjectCaches();
  1043.         return this.success("OK", cloned, true);
  1044.     }
  1046.     opRename(data)
  1047.     {
  1048.         projectsUtil.invalidateProjectCaches();
  1050.         const oldId = data.opname;
  1051.         const newName = data.name;
  1052.         const oldName = opsUtil.getOpNameById(oldId);
  1054.         const currentUser = settings.getCurrentUser();
  1055.         const currentProject = settings.getCurrentProject();
  1056.         let opNamespace = opsUtil.getNamespace(newName);
  1058.         const opDocs = doc.getOpDocs(false, false);
  1059.         const renameResults = this._getFullRenameResponse(opDocs, newName, oldName, currentUser, currentProject, opsUtil.isPrivateOp(newName), true);
  1060.         if (!oldName)
  1061.         {
  1062.             renameResults.problems.push("No name for source op given.");
  1063.         }
  1065.         const result = renameResults;
  1066.         result.title = "rename - " + oldName + " - " + newName;
  1067.         result.objName = newName;
  1068.         result.oldName = oldName;
  1069.         result.opId = oldId;
  1070.         result.opname = oldName;
  1071.         result.opNamespace = opNamespace;
  1072.         result.newopname = newName;
  1073.         result.shortname = opsUtil.getOpShortName(newName);
  1074.         result.oldShortName = opsUtil.getOpShortName(oldName);
  1075.         const versions = opsUtil.getOpVersionNumbers(oldName, opDocs);
  1076.         result.otherVersions = versions.length > 1 ? versions.filter((v) => { return v.name !== oldName; }) : [];
  1077.         result.renamePossible = renameResults.problems.length === 0;
  1079.         if (Object.keys(renameResults.problems).length > 0)
  1080.         {
  1081.             result.problems = Object.values(renameResults.problems);
  1082.             return this.success("PROBLEMS", result);
  1083.         }
  1085.         const start = Date.now();
  1087.         result.user = currentUser;
  1088.         result.showresult = true;
  1090.         let renameSuccess = false;
  1091.         if (opsUtil.isUserOp(newName))
  1092.         {
  1093.             renameSuccess = opsUtil.renameToUserOp(oldName, newName, currentUser);
  1094.         }
  1095.         else if (opsUtil.isTeamOp(newName))
  1096.         {
  1097.             renameSuccess = opsUtil.renameToTeamOp(oldName, newName, currentUser);
  1098.         }
  1099.         else if (opsUtil.isExtensionOp(newName))
  1100.         {
  1101.             renameSuccess = opsUtil.renameToExtensionOp(oldName, newName, currentUser);
  1102.         }
  1103.         else if (opsUtil.isPatchOp(newName))
  1104.         {
  1105.             renameSuccess = opsUtil.renameToPatchOp(oldName, newName, currentUser, true, false);
  1106.         }
  1107.         else
  1108.         {
  1109.             renameSuccess = opsUtil.renameToCoreOp(oldName, newName, currentUser);
  1110.         }
  1112.         projectsUtil.invalidateProjectCaches();
  1114.         if (!renameSuccess)
  1115.         {
  1116.             return this.error("ERROR", 500);
  1117.         }
  1118.         else
  1119.         {
  1120.             this._log.verbose("*" + currentUser.username + " finished after " + Math.round((Date.now() - start) / 1000) + " seconds ");
  1121.             return this.success("OK", result);
  1122.         }
  1123.     }
  1125.     opDelete(data)
  1126.     {
  1127.         const opName = opsUtil.getOpNameById(data.opId) || data.opName;
  1128.         opsUtil.deleteOp(opName);
  1129.         return this.success("OP_DELETED", { "opNames": [opName] });
  1130.     }
  1132.     async _installOpDependencies(opName)
  1133.     {
  1134.         const results = [];
  1135.         if (opName)
  1136.         {
  1137.             const targetDir = opsUtil.getOpAbsolutePath(opName);
  1138.             const opPackages = opsUtil.getOpNpmPackages(opName);
  1139.             if (opPackages.length === 0)
  1140.             {
  1141.                 const nodeModulesDir = path.join(targetDir, "node_modules");
  1142.                 if (fs.existsSync(nodeModulesDir)) fs.rmSync(nodeModulesDir, { "recursive": true });
  1143.                 results.push({
  1144.                     "stdout": "nothing to install",
  1145.                     "packages": []
  1146.                 });
  1147.                 return this.success("EMPTY", results, false);
  1148.             }
  1149.             else
  1150.             {
  1151.                 const npmResults = await electronApp.installPackages(targetDir, opPackages, opName);
  1152.                 if (npmResults.stderr)
  1153.                 {
  1154.                     return this.error("NPM_ERROR", npmResults, "error");
  1155.                 }
  1156.                 else
  1157.                 {
  1158.                     return this.success("OK", npmResults);
  1159.                 }
  1160.             }
  1161.         }
  1162.         else
  1163.         {
  1164.             results.push({
  1165.                 "stdout": "nothing to install",
  1166.                 "packages": []
  1167.             });
  1168.             return this.success("EMPTY", results, false);
  1169.         }
  1170.     }
  1172.     async installProjectDependencies()
  1173.     {
  1174.         const currentProject = settings.getCurrentProject();
  1175.         if (!currentProject)
  1176.         {
  1177.             return this.error("UNSAVED_PROJECT", [{
  1178.                 "stdout": "please save your project first",
  1179.                 "packages": []
  1180.             }]);
  1181.         }
  1183.         const results = [];
  1184.         let projectPackages = {};
  1185.         currentProject.ops.forEach((op) =>
  1186.         {
  1187.             const opName = opsUtil.getOpNameById(op.opId);
  1188.             if (opName)
  1189.             {
  1190.                 const targetDir = opsUtil.getOpAbsolutePath(opName);
  1191.                 const opPackages = opsUtil.getOpNpmPackages(opName);
  1192.                 if (opPackages.length > 0)
  1193.                 {
  1194.                     if (!projectPackages.hasOwnProperty(targetDir)) projectPackages[targetDir] = [];
  1195.                     projectPackages[targetDir] = {
  1196.                         "opName": opName,
  1197.                         "packages": opPackages
  1198.                     };
  1199.                 }
  1200.             }
  1201.         });
  1202.         if (Object.keys(projectPackages).length === 0)
  1203.         {
  1204.             results.push({
  1205.                 "stdout": "nothing to install",
  1206.                 "packages": []
  1207.             });
  1208.             return this.success("EMPTY", results, false);
  1209.         }
  1210.         else
  1211.         {
  1212.             const allNpmInstalls = [];
  1213.             for (let targetDir in projectPackages)
  1214.             {
  1215.                 const opData = projectPackages[targetDir];
  1216.                 allNpmInstalls.push(electronApp.installPackages(targetDir, opData.packages, opData.opName));
  1217.             }
  1219.             const npmResults = await Promise.all(allNpmInstalls);
  1220.             if (npmResults.some((result) => { return result.error; }))
  1221.             {
  1222.                 return this.error("NPM_ERROR", npmResults, "error");
  1223.             }
  1224.             else
  1225.             {
  1226.                 return this.success("OK", npmResults);
  1227.             }
  1228.         }
  1229.     }
  1231.     async addOpPackage(data)
  1232.     {
  1233.         const currentProjectDir = settings.getCurrentProjectDir();
  1234.         const targetDir = data.targetDir || currentProjectDir;
  1235.         const npmResults = await electronApp.addOpPackage(targetDir, data.package);
  1236.         return this.success("OK", npmResults);
  1237.     }
  1239.     async openDir(options = {})
  1240.     {
  1241.         await shell.openPath(options.dir || app.getPath("home"));
  1242.         return this.success("OK", {}, true);
  1243.     }
  1245.     async openOpDir(options)
  1246.     {
  1247.         const opName = opsUtil.getOpNameById(options.opId) || options.opName;
  1248.         if (!opName) return;
  1249.         const opDir = opsUtil.getOpAbsoluteFileName(opName);
  1250.         if (opDir)
  1251.         {
  1252.             shell.showItemInFolder(opDir);
  1253.             return this.success("OK", {}, true);
  1254.         }
  1255.     }
  1257.     async openProjectDir()
  1258.     {
  1259.         const projectFile = settings.getCurrentProjectFile();
  1260.         if (projectFile)
  1261.         {
  1262.             shell.showItemInFolder(projectFile);
  1263.             return this.success("OK", {});
  1264.         }
  1265.     }
  1267.     async openFileManager(data)
  1268.     {
  1269.         let assetPath = helper.fileURLToPath(data.url, true);
  1270.         if (fs.existsSync(assetPath))
  1271.         {
  1272.             const stats = fs.statSync(assetPath);
  1273.             if (stats.isDirectory())
  1274.             {
  1275.                 shell.openPath(assetPath);
  1276.                 return this.success("OK", {});
  1277.             }
  1278.             else
  1279.             {
  1280.                 shell.showItemInFolder(assetPath);
  1281.                 return this.success("OK", {});
  1282.             }
  1283.         }
  1284.         else
  1285.         {
  1286.             shell.openPath(cables.getAssetPath());
  1287.             return this.success("OK", {});
  1288.         }
  1289.     }
  1291.     async selectFile(data)
  1292.     {
  1293.         if (data)
  1294.         {
  1295.             let pickedFile = null;
  1296.             let filters = [{
  1297.                 "name": "All Files",
  1298.                 "extensions": ["*"]
  1299.             }];
  1300.             if (data.filter)
  1301.             {
  1302.                 if (Array.isArray(data.filter))
  1303.                 {
  1304.                     filters.unshift({
  1305.                         "name": "Filtered",
  1306.                         "extensions": data.filter
  1307.                     });
  1308.                 }
  1309.                 else
  1310.                 {
  1311.                     filters.unshift({
  1312.                         "name": data.filter.charAt(0).toUpperCase() + data.filter.slice(1),
  1313.                         "extensions": filesUtil.FILETYPES[data.filter] || ["*"]
  1314.                     });
  1315.                 }
  1317.             }
  1318.             if (data.url)
  1319.             {
  1320.                 let assetUrl = helper.fileURLToPath(data.url, true);
  1321.                 pickedFile = await electronApp.pickFileDialog(assetUrl, false, filters);
  1322.             }
  1323.             else
  1324.             {
  1325.                 let file = data.dir;
  1326.                 pickedFile = await electronApp.pickFileDialog(file, false, filters);
  1327.             }
  1328.             const assetPath = cables.getAssetPath();
  1329.             pickedFile = pickedFile.replace(assetPath, "./");
  1330.             let pickedFileUrl = pickedFile;
  1331.             if (!pickedFile.startsWith("./")) pickedFileUrl = helper.pathToFileURL(pickedFile);
  1332.             return this.success("OK", pickedFileUrl, true);
  1333.         }
  1334.         else
  1335.         {
  1336.             return this.error("NO_FILE_SELECTED", null, "info");
  1337.         }
  1338.     }
  1340.     async selectDir(data)
  1341.     {
  1342.         const pickedFileUrl = await electronApp.pickDirDialog(data.dir);
  1343.         return this.success("OK", pickedFileUrl, true);
  1344.     }
  1346.     checkNumAssetPatches()
  1347.     {
  1348.         return this.success("OK", {
  1349.             "assets": [],
  1350.             "countPatches": 0,
  1351.             "countOps": 0
  1352.         }, true);
  1353.     }
  1355.     async saveProjectAs(data)
  1356.     {
  1357.         const projectFile = await electronApp.saveProjectFileDialog(data.name);
  1358.         if (!projectFile)
  1359.         {
  1360.             return this.error("no project dir chosen", null, "info");
  1361.         }
  1363.         let collaborators = [];
  1364.         let usersReadOnly = [];
  1366.         const currentUser = settings.getCurrentUser();
  1367.         const origProject = settings.getCurrentProject() || projectsUtil.generateNewProject(currentUser);
  1368.         origProject._id = helper.generateRandomId();
  1369.         origProject.name = path.basename(projectFile);
  1370.         origProject.summary = origProject.summary || {};
  1371.         origProject.summary.title = origProject.name;
  1372.         origProject.userId = currentUser._id;
  1373.         origProject.cachedUsername = currentUser.username;
  1374.         origProject.created = Date.now();
  1375.         origProject.cloneOf = origProject._id;
  1376.         origProject.updated = Date.now();
  1377.         origProject.users = collaborators;
  1378.         origProject.usersReadOnly = usersReadOnly;
  1379.         origProject.visibility = "private";
  1380.         origProject.shortId = helper.generateShortId(origProject._id, Date.now());
  1381.         let patch = {};
  1382.         if (data.dataB64) patch.dataB64 = data.dataB64;
  1383.         projectsUtil.writeProjectToFile(projectFile, origProject, patch);
  1384.         this.loadProject(projectFile);
  1385.         electronApp.reload();
  1386.         return this.success("OK", origProject, true);
  1387.     }
  1389.     async gotoPatch(data)
  1390.     {
  1391.         let project = null;
  1392.         let projectFile = null;
  1393.         if (data && data.id)
  1394.         {
  1395.             projectFile = settings.getRecentProjectFile(data.id);
  1396.             if (projectFile) project = settings.getProjectFromFile(projectFile);
  1397.         }
  1398.         if (project && projectFile)
  1399.         {
  1400.             electronApp.openPatch(projectFile);
  1401.             return this.success("OK", true, true);
  1402.         }
  1403.         else
  1404.         {
  1405.             const file = await electronApp.pickProjectFileDialog();
  1406.             return this.success("OK", { "projectFile": file });
  1407.         }
  1408.     }
  1410.     updateFile(data)
  1411.     {
  1412.         this._log.info("file edit...");
  1413.         if (!data || !data.fileName)
  1414.         {
  1415.             return this.error("UNKNOWN_FILE");
  1416.         }
  1418.         const newPath = helper.fileURLToPath(data.fileName, true);
  1419.         if (!fs.existsSync(newPath)) mkdirp.sync(newPath);
  1420.         try
  1421.         {
  1422.             if (fs.existsSync(newPath))
  1423.             {
  1424.                 this._log.info("delete old file ", newPath);
  1425.                 fs.unlinkSync(newPath);
  1426.             }
  1427.         }
  1428.         catch (e)
  1429.         {}
  1431.         this._log.info("edit file", newPath);
  1433.         fs.writeFileSync(newPath, data.content);
  1434.         return this.success("OK", { "filename": newPath }, true);
  1435.     }
  1437.     getProjectOpDirs()
  1438.     {
  1439.         const currentProject = settings.getCurrentProject();
  1440.         const dirInfos = projectsUtil.getOpDirs(currentProject);
  1442.         const opDirs = {};
  1443.         if (currentProject && currentProject.ops)
  1444.         {
  1445.             currentProject.ops.forEach((op) =>
  1446.             {
  1447.                 const opName = opsUtil.getOpNameById(op.opId);
  1448.                 const opPath = opsUtil.getOpAbsolutePath(opName);
  1449.                 if (opPath)
  1450.                 {
  1451.                     if (!opDirs.hasOwnProperty(opPath)) opDirs[opPath] = 0;
  1452.                     opDirs[opPath]++;
  1453.                 }
  1454.             });
  1455.         }
  1457.         dirInfos.forEach((dirInfo) =>
  1458.         {
  1459.             if (!dirInfo.hasOwnProperty("numUsedOps")) dirInfo.numUsedOps = 0;
  1460.             for (const opDir in opDirs)
  1461.             {
  1462.                 const count = opDirs[opDir];
  1463.                 if (opDir.startsWith(dirInfo.dir))
  1464.                 {
  1465.                     dirInfo.numUsedOps += count;
  1466.                 }
  1467.             }
  1468.         });
  1470.         return this.success("OK", dirInfos);
  1471.     }
  1473.     async addProjectOpDir()
  1474.     {
  1475.         let currentProject = settings.getCurrentProject();
  1476.         if (!currentProject) return this.error("Please save your project before adding op directories", null, "warn");
  1477.         const opDir = await electronApp.pickOpDirDialog();
  1478.         if (opDir)
  1479.         {
  1480.             currentProject = projectsUtil.addOpDir(currentProject, opDir, true);
  1481.             projectsUtil.writeProjectToFile(settings.getCurrentProjectFile(), currentProject);
  1482.         }
  1483.         return this.success("OK", projectsUtil.getProjectOpDirs(currentProject, true));
  1484.     }
  1486.     async removeProjectOpDir(dirName)
  1487.     {
  1488.         let currentProject = settings.getCurrentProject();
  1489.         if (!currentProject || !dirName) return this.success("OK", projectsUtil.getProjectOpDirs(currentProject, true));
  1490.         dirName = path.resolve(dirName);
  1491.         currentProject = projectsUtil.removeOpDir(currentProject, dirName);
  1493.         projectsUtil.writeProjectToFile(settings.getCurrentProjectFile(), currentProject);
  1494.         return this.success("OK", projectsUtil.getProjectOpDirs(currentProject, true));
  1495.     }
  1497.     saveProjectOpDirOrder(order)
  1498.     {
  1499.         let currentProject = settings.getCurrentProject();
  1500.         if (!currentProject || !order) return this.error("NO_PROJECT", null, "warn");
  1501.         currentProject = projectsUtil.reorderOpDirs(currentProject, order);
  1502.         return this.success("OK", projectsUtil.getProjectOpDirs(currentProject, true));
  1503.     }
  1505.     setProjectName(options)
  1506.     {
  1507.         const oldFile = settings.getCurrentProjectFile();
  1508.         let project = settings.getCurrentProject();
  1509.         project.name = options.name;
  1510.         const newFile = path.join(settings.getCurrentProjectDir(), projectsUtil.getProjectFileName(project));
  1511.         project.name = path.basename(newFile);
  1512.         project.summary = project.summary || {};
  1513.         project.summary.title = project.name;
  1514.         fs.renameSync(oldFile, newFile);
  1515.         settings.replaceInRecentProjects(oldFile, newFile);
  1516.         projectsUtil.writeProjectToFile(newFile, project);
  1517.         this.loadProject(newFile);
  1518.         const summary = projectsUtil.getSummary(settings.getCurrentProject());
  1519.         electronApp.updateTitle();
  1520.         return this.success("OK", {
  1521.             "name": project.name,
  1522.             "summary": summary
  1523.         });
  1524.     }
  1526.     cycleFullscreen()
  1527.     {
  1528.         electronApp.cycleFullscreen();
  1529.     }
  1531.     collectAssets()
  1532.     {
  1533.         const currentProject = settings.getCurrentProject();
  1534.         const assetPorts = projectsUtil.getProjectAssetPorts(currentProject, true);
  1536.         const oldNew = {};
  1537.         let projectAssetPath = cables.getAssetPath();
  1538.         projectAssetPath = path.join(projectAssetPath, "assets");
  1539.         if (!fs.existsSync(projectAssetPath)) mkdirp.sync(projectAssetPath);
  1540.         assetPorts.forEach((assetPort) =>
  1541.         {
  1542.             const portValue = assetPort.value;
  1543.             let oldFile = helper.fileURLToPath(portValue, true);
  1544.             if (!helper.isLocalAssetPath(oldFile) && !oldNew.hasOwnProperty(portValue) && fs.existsSync(oldFile))
  1545.             {
  1546.                 const baseName = path.basename(oldFile);
  1547.                 const newName = projectsUtil.findNewAssetFilename(projectAssetPath, baseName);
  1548.                 const newLocation = path.join(projectAssetPath, newName);
  1549.                 fs.copyFileSync(oldFile, newLocation);
  1550.                 // cant use path.join here since we need to keep the ./
  1551.                 oldNew[assetPort.value] = projectsUtil.getAssetPathUrl(currentProject._id) + newName;
  1552.             }
  1553.         });
  1554.         return this.success("OK", oldNew);
  1555.     }
  1557.     collectOps()
  1558.     {
  1559.         const currentProject = settings.getCurrentProject();
  1560.         const movedOps = {};
  1561.         const allOpNames = [];
  1562.         if (currentProject && currentProject.ops)
  1563.         {
  1564.             currentProject.ops.forEach((op) =>
  1565.             {
  1566.                 const opName = opsUtil.getOpNameById(op.opId);
  1567.                 allOpNames.push(opName);
  1568.                 if (!movedOps.hasOwnProperty(opName))
  1569.                 {
  1570.                     const opPath = opsUtil.getOpAbsolutePath(opName);
  1571.                     if (!opPath.startsWith(cables.getOpsPath()))
  1572.                     {
  1573.                         const targetPath = opsUtil.getOpTargetDir(opName, true);
  1574.                         const newOpLocation = path.join(cables.getProjectOpsPath(true), targetPath);
  1575.                         if (opPath !== newOpLocation)
  1576.                         {
  1577.                             fs.cpSync(opPath, newOpLocation, { "recursive": true });
  1578.                             movedOps[opName] = newOpLocation;
  1579.                         }
  1580.                     }
  1581.                 }
  1582.             });
  1583.         }
  1584.         filesUtil.registerOpChangeListeners(allOpNames, true);
  1585.         return this.success("OK", movedOps);
  1586.     }
  1588.     loadProject(projectFile, newProject = null, rebuildCache = true)
  1589.     {
  1590.         let project = newProject;
  1591.         if (projectFile)
  1592.         {
  1593.             project = settings.getProjectFromFile(projectFile);
  1594.             if (project)
  1595.             {
  1596.                 settings.setProject(projectFile, project);
  1597.                 if (rebuildCache) projectsUtil.invalidateProjectCaches();
  1598.                 // add ops in project dirs to lookup
  1599.                 projectsUtil.getOpDocsInProjectDirs(project, false, false, true);
  1600.                 filesUtil.registerAssetChangeListeners(project, true);
  1601.                 if (project.ops)
  1602.                 {
  1603.                     const opNames = [];
  1604.                     project.ops.forEach((op) =>
  1605.                     {
  1606.                         const opName = opsUtil.getOpNameById(op.opId);
  1607.                         if (opName)
  1608.                         {
  1609.                             opNames.push(opName);
  1610.                         }
  1611.                     });
  1612.                     filesUtil.registerOpChangeListeners(opNames);
  1613.                 }
  1614.             }
  1615.         }
  1616.         else
  1617.         {
  1618.             settings.setProject(null, null);
  1619.             projectsUtil.getOpDocsInProjectDirs(project);
  1620.         }
  1621.         electronApp.updateTitle();
  1622.     }
  1624.     async addOpDependency(options)
  1625.     {
  1626.         let opName = options.opName;
  1627.         if (opsUtil.isOpId(opName)) opName = opsUtil.getOpNameById(opName);
  1628.         if (!options.opName || !options.type) return this.error("INVALID_DATA");
  1630.         const dep = this._getOpDepFromRequest({ "body": options });
  1631.         const added = opsUtil.addOpDependency(opName, dep);
  1632.         if (added)
  1633.         {
  1634.             this._log.info("added dependency!", opName, dep.src);
  1635.             doc.updateOpDocs(opName);
  1636.             return await this._installOpDependencies(opName);
  1637.         }
  1638.         else
  1639.         {
  1640.             return this.error("FAILED_TO_ADD_DEPENDENCY");
  1641.         }
  1642.     }
  1644.     async removeOpDependency(options)
  1645.     {
  1646.         if (!options.opName || !options.type) return this.error("INVALID_DATA");
  1647.         let opName = options.opName;
  1648.         if (opsUtil.isOpId(opName)) opName = opsUtil.getOpNameById(opName);
  1649.         const opDocFile = opsUtil.getOpAbsoluteJsonFilename(opName);
  1650.         if (fs.existsSync(opDocFile))
  1651.         {
  1652.             let opDoc = jsonfile.readFileSync(opDocFile);
  1653.             if (opDoc)
  1654.             {
  1655.                 const newDeps = [];
  1656.                 const deps = opDoc.dependencies || [];
  1657.                 deps.forEach((dep) =>
  1658.                 {
  1659.                     if (dep.src !== options.src) newDeps.push(dep);
  1660.                 });
  1661.                 opDoc.dependencies = newDeps;
  1662.                 const libPath = path.join(opsUtil.getOpAbsolutePath(opName), options.src);
  1663.                 if (fs.existsSync(libPath)) fs.unlinkSync(libPath);
  1664.                 if (opDoc.dependencies) jsonfile.writeFileSync(opDocFile, opDoc, opsUtil.OPJSON_FORMAT);
  1665.                 doc.updateOpDocs(opName);
  1666.                 await this._installOpDependencies(opName);
  1667.                 return this.success("OK");
  1668.             }
  1669.             else
  1670.             {
  1671.                 return this.error("OP_NOT_FOUND");
  1672.             }
  1673.         }
  1674.         else
  1675.         {
  1676.             return this.error("OP_NOT_FOUND");
  1677.         }
  1678.     }
  1680.     async createFile(data)
  1681.     {
  1682.         let file = data.name;
  1683.         let pickedFileUrl = await electronApp.saveFileDialog(file);
  1684.         if (pickedFileUrl)
  1685.         {
  1686.             fs.writeFileSync(pickedFileUrl, "");
  1687.             return this.success("OK", pickedFileUrl, true);
  1688.         }
  1689.         else
  1690.         {
  1691.             return this.success("NO_DIR_CHOSEN", null, true);
  1692.         }
  1693.     }
  1695.     async exportPatch()
  1696.     {
  1697.         const service = new HtmlExportElectron(utilProvider);
  1699.         const exportPromise = promisify(service.doExport.bind(service));
  1701.         try
  1702.         {
  1703.             const result = await exportPromise(settings.getCurrentProject());
  1704.             return this.success("OK", result);
  1705.         }
  1706.         catch (e)
  1707.         {
  1708.             return this.error("ERROR", e);
  1709.         }
  1710.     }
  1712.     async exportPatchBundle()
  1713.     {
  1714.         const service = new PatchExportElectron(utilProvider);
  1716.         const exportPromise = promisify(service.doExport.bind(service));
  1718.         try
  1719.         {
  1720.             const result = await exportPromise(settings.getCurrentProject());
  1721.             return this.success("OK", result);
  1722.         }
  1723.         catch (e)
  1724.         {
  1725.             return this.error("ERROR", e);
  1726.         }
  1727.     }
  1729.     async uploadFileToOp(params)
  1730.     {
  1731.         const fileName = params.filename;
  1732.         const opId = params.opId;
  1733.         const dataUrl = params.fileStr;
  1735.         const opName = opsUtil.getOpNameById(opId);
  1737.         if (fileName && opId && dataUrl && opName)
  1738.         {
  1739.             let data = atob(dataUrl.split(",")[1]);
  1740.             let buffer = Buffer.from(data);
  1742.             const newFileName = opsUtil.addOpDependencyFile(opName, fileName, buffer);
  1743.             if (newFileName)
  1744.             {
  1745.                 this._log.info("added op file!", opName, newFileName);
  1746.                 doc.updateOpDocs(opName);
  1747.                 return this.success("OK", { "filename": newFileName }, true);
  1748.             }
  1749.             else
  1750.             {
  1751.                 return this.error("FAILED_TO_ADD_DEPENDENCY");
  1752.             }
  1753.         }
  1754.         else
  1755.         {
  1756.             return this.error("ERROR", {
  1757.                 "fileName": fileName,
  1758.                 "opId": opId,
  1759.                 "opName": opName
  1760.             });
  1761.         }
  1762.     }
  1764.     errorReport(report)
  1765.     {
  1766.         try
  1767.         {
  1768.             const communityUrl = cables.getCommunityUrl();
  1769.             if (cables.sendErrorReports() && communityUrl)
  1770.             {
  1771.                 try
  1772.                 {
  1773.                     const errorReportSend = net.request({
  1774.                         "url": path.join(communityUrl, "/api/errorReport"),
  1775.                         "method": "POST"
  1776.                     });
  1777.                     delete report.url;
  1778.                     delete report.file;
  1779.                     if (report.log)
  1780.                     {
  1781.                         report.log.forEach((log) =>
  1782.                         {
  1783.                             if (log.errorStack)
  1784.                             {
  1785.                                 log.errorStack.forEach((stack) =>
  1786.                                 {
  1787.                                     if (stack.fileName)
  1788.                                     {
  1789.                                         stack.fileName = path.basename(stack.fileName);
  1790.                                     }
  1791.                                     if (stack.source)
  1792.                                     {
  1793.                                         delete stack.source;
  1794.                                     }
  1795.                                 });
  1796.                             }
  1797.                         });
  1798.                     }
  1799.                     report.username = "electron";
  1800.                     errorReportSend.setHeader("Content-Type", "application/json");
  1801.                     errorReportSend.write(JSON.stringify(report), "utf-8");
  1802.                     errorReportSend.end();
  1803.                 }
  1804.                 catch (e)
  1805.                 {
  1806.                     this._log.debug("failed to send error report", e);
  1807.                 }
  1808.             }
  1809.         }
  1810.         catch (e)
  1811.         {
  1812.             this._log.info("failed to parse error report", e);
  1813.         }
  1814.         this.success("OK");
  1815.     }
  1817.     success(msg, data = null, raw = false)
  1818.     {
  1819.         if (raw)
  1820.         {
  1821.             if (data && typeof data === "object") data.success = true;
  1822.             return data;
  1823.         }
  1824.         else
  1825.         {
  1826.             return {
  1827.                 "success": true,
  1828.                 "msg": msg,
  1829.                 "data": data || {}
  1830.             };
  1831.         }
  1832.     }
  1834.     error(msg, data = null, level = "warn")
  1835.     {
  1836.         const error = {
  1837.             "error": true,
  1838.             "msg": msg,
  1839.             "level": level
  1840.         };
  1841.         if (data) error.data = data;
  1842.         return error;
  1843.     }
  1845.     _getFullRenameResponse(opDocs, newName, oldName, currentUser, project = null, ignoreVersionGap = false, fromRename = false, targetDir = false)
  1846.     {
  1847.         let opNamespace = opsUtil.getNamespace(newName, true);
  1848.         let oldOpNamespace = opsUtil.getNamespace(oldName, true);
  1850.         let availableNamespaces = [];
  1852.         if (project)
  1853.         {
  1854.             const projectOpDocs = projectsUtil.getOpDocsInProjectDirs(project);
  1855.             availableNamespaces = projectOpDocs.map((opDoc) => { return opsUtil.getNamespace(opDoc.name, true); });
  1856.         }
  1858.         availableNamespaces = availableNamespaces.map((availableNamespace) => { return availableNamespace.endsWith(".") ? availableNamespace : availableNamespace + "."; });
  1859.         availableNamespaces = helper.uniqueArray(availableNamespaces);
  1860.         availableNamespaces = availableNamespaces.sort((a, b) => { return a.localeCompare(b); });
  1861.         if (opNamespace && !availableNamespaces.includes(opNamespace)) availableNamespaces.unshift(opNamespace);
  1862.         if (oldOpNamespace && !availableNamespaces.includes(oldOpNamespace)) availableNamespaces.unshift(oldOpNamespace);
  1864.         availableNamespaces = availableNamespaces.filter((availableNamespace) => { return availableNamespace.startsWith(opsUtil.PREFIX_OPS); });
  1866.         let suggestedNamespaces = [...availableNamespaces];
  1867.         if (project)
  1868.         {
  1869.             suggestedNamespaces.unshift(opsUtil.getPatchOpsNamespaceForProject(project));
  1870.         }
  1871.         suggestedNamespaces.unshift("Your namespaces..");
  1872.         suggestedNamespaces = suggestedNamespaces.map((suggestedNamespace) => { return opsUtil.getNamespace(suggestedNamespace, true); });
  1873.         suggestedNamespaces = helper.uniqueArray(suggestedNamespaces);
  1875.         const result = {
  1876.             "namespaces": suggestedNamespaces,
  1877.             "problems": [],
  1878.             "consequences": [],
  1879.             "action": "Rename"
  1880.         };
  1882.         if (!newName)
  1883.         {
  1884.             result.problems.push("No name for new op given.");
  1885.             return result;
  1886.         }
  1888.         if (fromRename) targetDir = opsUtil.getOpSourceDir(oldName);
  1889.         const problems = opsUtil.getOpRenameProblems(newName, oldName, currentUser, [], null, null, [], true, targetDir);
  1890.         const hints = {};
  1891.         const consequences = opsUtil.getOpRenameConsequences(newName, oldName, targetDir);
  1893.         let newOpDocs = opDocs;
  1894.         if (!opsUtil.isCoreOp(newName)) newOpDocs = doc.getCollectionOpDocs(newName, currentUser);
  1896.         const nextOpName = opsUtil.getNextVersionOpName(newName, newOpDocs);
  1897.         const nextShort = opsUtil.getOpShortName(nextOpName);
  1898.         let nextVersion = null;
  1899.         let suggestVersion = false;
  1901.         if (problems.target_exists)
  1902.         {
  1903.             suggestVersion = true;
  1904.         }
  1906.         if (!ignoreVersionGap)
  1907.         {
  1908.             const wantedVersion = opsUtil.getVersionFromOpName(newName);
  1909.             const currentHighest = opsUtil.getHighestVersionNumber(newName, newOpDocs);
  1911.             const versionTolerance = currentHighest ? 1 : 2;
  1912.             if ((wantedVersion - versionTolerance) > currentHighest)
  1913.             {
  1914.                 hints.version_gap = "Gap in version numbers!";
  1915.                 suggestVersion = true;
  1916.             }
  1917.         }
  1919.         if (problems.illegal_ops)
  1920.         {
  1921.             suggestVersion = false;
  1922.         }
  1924.         if (problems.namespace_missing_parts && opsUtil.isLocalOp(newName))
  1925.         {
  1926.             delete problems.namespace_missing_parts;
  1927.         }
  1929.         if (!fromRename && oldName)
  1930.         {
  1931.             const hierarchyProblem = opsUtil.getNamespaceHierarchyProblem(oldName, newName);
  1932.             if (hierarchyProblem)
  1933.             {
  1934.                 problems.bad_op_hierarchy = hierarchyProblem;
  1935.                 suggestVersion = false;
  1936.             }
  1937.         }
  1939.         if (suggestVersion)
  1940.         {
  1941.             const text = "Try creating a new version <a class='button-small versionSuggestion' data-short-name='" + nextShort + "' data-next-name='" + nextOpName + "'>" + nextOpName + "</a>";
  1942.             nextVersion = {
  1943.                 "fullName": nextOpName,
  1944.                 "namespace": opsUtil.getNamespace(nextOpName),
  1945.                 "shortName": nextShort
  1946.             };
  1947.             if (problems.target_exists)
  1948.             {
  1949.                 problems.version_suggestion = text;
  1950.             }
  1951.             else
  1952.             {
  1953.                 hints.version_suggestion = text;
  1954.             }
  1955.         }
  1957.         result.problems = Object.values(problems);
  1958.         result.hints = Object.values(hints);
  1959.         result.consequences = Object.values(consequences);
  1960.         if (nextVersion) result.nextVersion = nextVersion;
  1961.         return result;
  1962.     }
  1964.     _getOpDepFromRequest(req)
  1965.     {
  1966.         const validTypes = ["commonjs", "module", "npm", "op", "lib", "corelib"];
  1967.         const data = req.body;
  1968.         const dep = {};
  1969.         if (data.src) dep.src = data.src.trim();
  1970.         if (data.type && validTypes.includes(data.type.trim())) dep.type = data.type.trim();
  1971.         if (data.export && dep.type === "module") dep.export = data.export.trim();
  1972.         return dep;
  1973.     }
  1974. }
  1976. export default new ElectronApi();