@geode/opengeodeweb-front 9.11.0-rc.7 → 9.11.0-rc.9

package/utils/default_styles.js

@@ -0,0 +1,246 @@
+// Global variables
+
+const points_defaultVisibility = true
+const edges_defaultVisibility = true
+const polygons_defaultVisibility = true
+const polyhedra_defaultVisibility = true
+const points_defaultSize = 10
+const points_defaultColor = { r: 20, g: 20, b: 20 }
+const edges_defaultSize = 5
+const edges_defaultColor = { r: 20, g: 20, b: 20 }
+const polygons_defaultColor = { r: 255, g: 255, b: 255 }
+const polyhedra_defaultColor = { r: 255, g: 255, b: 255 }
+
+const corners_defaultVisibility = true
+const lines_defaultVisibility = true
+const surfaces_defaultVisibility = true
+const blocks_defaultVisibility = true
+const lines_defaultColor = { r: 20, g: 20, b: 20 }
+
+// Mesh functions
+const meshPointsDefaultStyle = (
+  visibility = points_defaultVisibility,
+  size = points_defaultSize,
+  color = points_defaultColor,
+) => {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      color,
+      vertex: null,
+    },
+    size,
+  }
+}
+
+const meshEdgesDefaultStyle = (
+  visibility = edges_defaultVisibility,
+  size = edges_defaultSize,
+  color = edges_defaultColor,
+) => {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      color,
+    },
+    size,
+  }
+}
+
+const meshPolygonsDefaultStyle = (
+  visibility = polygons_defaultVisibility,
+  color = polygons_defaultColor,
+) => {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      color,
+      textures: null,
+      polygon: null,
+      vertex: null,
+    },
+  }
+}
+
+const meshPolyhedraDefaultStyle = (
+  visibility = polyhedra_defaultVisibility,
+  color = polyhedra_defaultColor,
+) => {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      color,
+      polyhedron: null,
+      vertex: null,
+    },
+  }
+}
+
+const pointSet_defaultStyle = () => {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(),
+  }
+}
+
+const edgedCurve_defaultStyle = () => {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(),
+  }
+}
+
+const surface_defaultStyle = (visibility = true) => {
+  return {
+    visibility,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    polygons: meshPolygonsDefaultStyle(),
+  }
+}
+
+const solid_defaultStyle = () => {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    polygons: meshPolygonsDefaultStyle(),
+    polyhedra: meshPolyhedraDefaultStyle(),
+  }
+}
+
+// Model functions
+const modelCornersDefaultStyle = (visibility = corners_defaultVisibility) => {
+  return { visibility }
+}
+const modelLinesDefaultStyle = (
+  visibility = lines_defaultVisibility,
+  color = lines_defaultColor,
+) => {
+  return { visibility, color }
+}
+const modelSurfacesDefaultStyle = (visibility = surfaces_defaultVisibility) => {
+  return { visibility }
+}
+const modelBlocksDefaultStyle = (visibility = blocks_defaultVisibility) => {
+  return { visibility }
+}
+const modelPointsDefaultStyle = (
+  visibility = points_defaultVisibility,
+  size,
+) => {
+  return { visibility, size }
+}
+const modelEdgesDefaultStyle = (visibility = edges_defaultVisibility) => {
+  return { visibility }
+}
+
+const brep_defaultStyle = () => {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    blocks: modelBlocksDefaultStyle(),
+    points: modelPointsDefaultStyle(false, points_defaultSize),
+    edges: modelEdgesDefaultStyle(false, edges_defaultSize),
+  }
+}
+
+const crossSection_defaultStyle = () => {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    points: modelPointsDefaultStyle(false, points_defaultSize),
+    edges: modelEdgesDefaultStyle(false, edges_defaultSize),
+  }
+}
+
+const structuralModel_defaultStyle = () => {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    blocks: modelBlocksDefaultStyle(),
+    points: modelPointsDefaultStyle(false, points_defaultSize),
+    edges: modelEdgesDefaultStyle(false, edges_defaultSize),
+  }
+}
+
+const section_defaultStyle = () => {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    points: modelPointsDefaultStyle(false, points_defaultSize),
+    edges: modelEdgesDefaultStyle(false, edges_defaultSize),
+  }
+}
+
+const implicitCrossSection_defaultStyle = () => {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    points: modelPointsDefaultStyle(false, points_defaultSize),
+    edges: modelEdgesDefaultStyle(false, edges_defaultSize),
+  }
+}
+
+const implicitStructuralModel_defaultStyle = () => {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    blocks: modelBlocksDefaultStyle(),
+    points: modelPointsDefaultStyle(false, points_defaultSize),
+    edges: modelEdgesDefaultStyle(false, edges_defaultSize),
+  }
+}
+
+const default_styles = () => {
+  return {
+    BRep: brep_defaultStyle(),
+    CrossSection: crossSection_defaultStyle(),
+    EdgedCurve2D: edgedCurve_defaultStyle(),
+    EdgedCurve3D: edgedCurve_defaultStyle(),
+    Graph: {},
+    HybridSolid3D: solid_defaultStyle(),
+    ImplicitCrossSection: implicitCrossSection_defaultStyle(),
+    ImplicitStructuralModel: implicitStructuralModel_defaultStyle(),
+    LightRegularGrid2D: surface_defaultStyle(),
+    LightRegularGrid3D: solid_defaultStyle(),
+    PointSet2D: pointSet_defaultStyle(),
+    PointSet3D: pointSet_defaultStyle(),
+    PolygonalSurface2D: surface_defaultStyle(),
+    PolygonalSurface3D: surface_defaultStyle(),
+    PolyhedralSolid3D: solid_defaultStyle(),
+    RasterImage2D: {},
+    RasterImage3D: {},
+    RegularGrid2D: surface_defaultStyle(),
+    RegularGrid3D: solid_defaultStyle(),
+    Section: section_defaultStyle(),
+    StructuralModel: structuralModel_defaultStyle(),
+    TetrahedralSolid3D: solid_defaultStyle(),
+    TriangulatedSurface2D: surface_defaultStyle(),
+    TriangulatedSurface3D: surface_defaultStyle(),
+    VertexSet: {},
+  }
+}
+
+function getDefaultStyle(type) {
+  return default_styles()[type]
+}
+
+export { getDefaultStyle }

package/utils/local.js

@@ -0,0 +1,180 @@
+// Node.js imports
+import fs from "fs"
+import path from "path"
+import child_process from "child_process"
+
+// Third party imports
+import pkg from "electron"
+const { app, dialog } = pkg
+import { getPort } from "get-port-please"
+import pidtree from "pidtree"
+import isElectron from "is-electron"
+
+import { fileURLToPath } from "url"
+
+const __filename = fileURLToPath(import.meta.url) // get the resolved path to the file
+const __dirname = path.dirname(__filename) // get the name of the directory
+console.log("__dirname", __dirname)
+
+// Global variables
+var processes = []
+
+function venv_script_path(root_path, microservice_path) {
+  const venv_path = path.join(root_path, microservice_path, "venv")
+  var script_path
+  if (process.platform === "win32") {
+    script_path = path.join(venv_path, "Scripts")
+  } else {
+    script_path = path.join(venv_path, "bin")
+  }
+  return script_path
+}
+
+function executable_path(microservice_path, root_path = null) {
+  if (root_path != null) return venv_script_path(root_path, microservice_path)
+  if (isElectron()) {
+    if (app.isPackaged) {
+      return process.resourcesPath
+    }
+    return venv_script_path(app.getAppPath(), microservice_path)
+  }
+  return venv_script_path(process.cwd(), microservice_path)
+}
+
+function executable_name(name) {
+  if (process.platform === "win32") {
+    return name + ".exe"
+  }
+  return name
+}
+
+function create_path(path) {
+  if (!fs.existsSync(path)) {
+    fs.mkdir(path, (err) => {
+      if (err) {
+        return console.error(err)
+      }
+      console.log(`${path} directory created successfully!`)
+    })
+  }
+  return path
+}
+
+async function get_available_port(port) {
+  const available_port = await getPort({ port, host: "localhost" })
+  console.log("available_port", available_port)
+  return available_port
+}
+
+async function kill_processes() {
+  console.log("kill_processes", processes)
+  await processes.forEach(async function (proc) {
+    console.log(`Process ${proc} will be killed!`)
+    try {
+      process.kill(proc)
+    } catch (error) {
+      console.log(`${error} Process ${proc} could not be killed!`)
+    }
+  })
+}
+
+function register_children_processes(proc) {
+  pidtree(proc.pid, { root: true }, function (err, pids) {
+    if (err) console.log("err", err)
+    processes.push(...pids)
+  })
+}
+
+async function run_script(
+  command,
+  args,
+  expected_response,
+  timeout_seconds = 30,
+) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      reject("Timed out after " + timeout_seconds + " seconds")
+    }, timeout_seconds * 1000)
+    const child = child_process.spawn(command, args, {
+      encoding: "utf8",
+      shell: true,
+    })
+    register_children_processes(child)
+
+    // You can also use a variable to save the output for when the script closes later
+    child.stderr.setEncoding("utf8")
+    child.on("error", (error) => {
+      dialog.showMessageBox({
+        title: "Title",
+        type: "warning",
+        message: "Error occured.\r\n" + error,
+      })
+    })
+    child.stdout.setEncoding("utf8")
+    child.stdout.on("data", (data) => {
+      //Here is the output
+      data = data.toString()
+      if (data.includes(expected_response)) {
+        register_children_processes(child)
+        resolve(child)
+      }
+      console.log(data)
+    })
+    child.stderr.setEncoding("utf8")
+    child.stderr.on("data", (data) => {
+      console.log(data)
+    })
+
+    child.on("close", (_code) => {
+      //Here you can get the exit code of the script
+      console.log("Child Process exited with code " + _code)
+    })
+    child.on("kill", () => {
+      console.log("Child Process killed")
+    })
+    child.name = command.replace(/^.*[\\/]/, "")
+  })
+}
+
+async function run_back(port, data_folder_path) {
+  return new Promise(async (resolve, reject) => {
+    const back_command = path.join(
+      executable_path(path.join("microservices", "back")),
+      executable_name("vease-back"),
+    )
+    const back_port = await get_available_port(port)
+    const back_args = [
+      "--port " + back_port,
+      "--data_folder_path " + data_folder_path,
+      "--allowed_origin http://localhost:*",
+      "--timeout " + 0,
+    ]
+    await run_script(back_command, back_args, "Serving Flask app")
+    resolve(back_port)
+  })
+}
+
+async function run_viewer(viewer_path, args = { port, data_folder_path }) {
+  return new Promise(async (resolve, reject) => {
+    const viewer_port = await get_available_port(args.port)
+    const viewer_args = [
+      "--port " + viewer_port,
+      "--data_folder_path " + args.data_folder_path,
+      "--timeout " + 0,
+    ]
+    await run_script(viewer_path, viewer_args, "Starting factory")
+    resolve(viewer_port)
+  })
+}
+
+export {
+  create_path,
+  executable_name,
+  executable_path,
+  get_available_port,
+  kill_processes,
+  register_children_processes,
+  run_script,
+  run_back,
+  run_viewer,
+}

package/vitest.config.js

@@ -1,13 +0,0 @@
-import { defineVitestConfig } from "@nuxt/test-utils/config"
-
-export default defineVitestConfig({
-  test: {
-    environment: "nuxt",
-    globals: true,
-    server: {
-      deps: {
-        inline: ["vuetify"],
-      },
-    },
-  },
-})