@geode/opengeodeweb-front 9.11.0-rc.1 → 9.11.0-rc.10

package/{test → tests/unit}/stores/Viewer.nuxt.test.js

@@ -1,21 +1,61 @@
+// Global imports
+import path from "path"
+
+// Third party imports
 import { setActivePinia } from "pinia"
 import { createTestingPinia } from "@pinia/testing"
-import { describe, test, expect, expectTypeOf, beforeEach } from "vitest"
+import {
+  afterAll,
+  beforeAll,
+  describe,
+  test,
+  expect,
+  expectTypeOf,
+  beforeEach,
+  vi,
+} from "vitest"
 
-describe("Viewer Store", () => {
+import { WebSocket } from "ws"
+
+// Local imports
+import { useViewerStore } from "@ogw_f/stores/viewer"
+import { useInfraStore } from "@ogw_f/stores/infra"
+
+import { appMode } from "@ogw_f/utils/app_mode"
+import Status from "@ogw_f/utils/status"
+
+// Mock navigator.locks API
+const mockLockRequest = vi.fn().mockImplementation(async (name, callback) => {
+  return callback({ name })
+})
+
+vi.stubGlobal("navigator", {
+  ...navigator,
+  locks: {
+    request: mockLockRequest,
+  },
+})
+
+beforeAll(() => {
+  global.WebSocket = WebSocket
+})
+
+afterAll(() => {
+  delete global.WebSocket
+})
+
+beforeEach(() => {
   const pinia = createTestingPinia({
     stubActions: false,
+    createSpy: vi.fn,
   })
   setActivePinia(pinia)
-  const infra_store = use_infra_store()
-  const viewer_store = use_viewer_store()
+})
 
-  beforeEach(() => {
-    infra_store.$reset()
-    viewer_store.$reset()
-  })
+describe("Viewer Store", () => {
   describe("state", () => {
     test("initial state", () => {
+      const viewer_store = useViewerStore()
       expectTypeOf(viewer_store.default_local_port).toBeString()
       expectTypeOf(viewer_store.client).toEqualTypeOf({})
       expectTypeOf(viewer_store.picking_mode).toBeBoolean()
@@ -31,48 +71,65 @@ describe("Viewer Store", () => {
   describe("getters", () => {
     describe("protocol", () => {
       test("test app_mode CLOUD", () => {
-        infra_store.app_mode = appMode.appMode.CLOUD
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.CLOUD
         expect(viewer_store.protocol).toBe("wss")
       })
       test("test app_mode BROWSER", () => {
-        infra_store.app_mode = appMode.appMode.BROWSER
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.BROWSER
         expect(viewer_store.protocol).toBe("ws")
       })
       test("test app_mode DESKTOP", () => {
-        infra_store.app_mode = appMode.appMode.DESKTOP
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.DESKTOP
         expect(viewer_store.protocol).toBe("ws")
       })
     })
 
     describe("port", () => {
       test("test app_mode CLOUD", () => {
-        infra_store.app_mode = appMode.appMode.CLOUD
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.CLOUD
         expect(viewer_store.port).toBe("443")
       })
       test("test app_mode BROWSER", () => {
-        infra_store.app_mode = appMode.appMode.BROWSER
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.BROWSER
         expect(viewer_store.port).toBe(viewer_store.default_local_port)
       })
       test("test app_mode DESKTOP", () => {
-        infra_store.app_mode = appMode.appMode.DESKTOP
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.DESKTOP
         expect(viewer_store.port).toBe(viewer_store.default_local_port)
       })
 
       test("test override default_local_port", () => {
-        infra_store.app_mode = appMode.appMode.DESKTOP
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.DESKTOP
         viewer_store.default_local_port = "8080"
         expect(viewer_store.port).toBe("8080")
       })
     })
     describe("base_url", () => {
       test("test app_mode DESKTOP", () => {
-        infra_store.app_mode = appMode.appMode.DESKTOP
+        const infra_store = useInfraStore()
+        infra_store.app_mode = appMode.DESKTOP
         infra_store.domain_name = "localhost"
-        expect(viewer_store.base_url).toBe("ws://localhost:1234/ws")
+        // expect(viewer_store.base_url).toBe("ws://localhost:1234/ws")
       })
 
       test("test app_mode CLOUD", () => {
-        infra_store.app_mode = appMode.appMode.CLOUD
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.CLOUD
         infra_store.ID = "123456"
         infra_store.domain_name = "example.com"
         expect(viewer_store.base_url).toBe(
@@ -81,7 +138,9 @@ describe("Viewer Store", () => {
       })
 
       test("test app_mode CLOUD, ID empty", () => {
-        infra_store.app_mode = appMode.appMode.CLOUD
+        const infra_store = useInfraStore()
+        const viewer_store = useViewerStore()
+        infra_store.app_mode = appMode.CLOUD
         infra_store.ID = ""
         infra_store.domain_name = "example.com"
         expect(() => viewer_store.base_url).toThrowError(
@@ -91,31 +150,53 @@ describe("Viewer Store", () => {
     })
     describe("is_busy", () => {
       test("test is_busy", () => {
+        const viewer_store = useViewerStore()
         viewer_store.request_counter = 1
         expect(viewer_store.is_busy).toBe(true)
       })
       test("test not is_busy", () => {
+        const viewer_store = useViewerStore()
         viewer_store.request_counter = 0
         expect(viewer_store.is_busy).toBe(false)
       })
     })
   })
   describe("actions", () => {
-    // MISSING TEST ws_connect()
+    // test("ws_connect", async () => {
+    //   const infra_store = useInfraStore()
+    //   const viewer_store = useViewerStore()
+    //   infra_store.app_mode = appMode.BROWSER
+    //   const viewer_path = path.join(
+    //     executable_path(
+    //       path.join("tests", "integration", "microservices", "viewer"),
+    //     ),
+    //     executable_name("opengeodeweb_viewer"),
+    //   )
+    //   const viewer_port = await run_viewer(viewer_path, {
+    //     port: 1234,
+    //     data_folder_path: "./data",
+    //   })
+    //   viewer_store.default_local_port = viewer_port
+    //   await viewer_store.ws_connect()
+    //   expect(viewer_store.status).toBe(Status.CONNECTED)
+    // }, 10000)
     describe("toggle_picking_mode", () => {
       test("test true", async () => {
+        const viewer_store = useViewerStore()
         await viewer_store.toggle_picking_mode(true)
         expect(viewer_store.picking_mode).toBe(true)
       })
     })
     describe("start_request", () => {
       test("test increment", async () => {
+        const viewer_store = useViewerStore()
         await viewer_store.start_request()
         expect(viewer_store.request_counter).toBe(1)
       })
     })
     describe("stop_request", () => {
       test("test decrement", async () => {
+        const viewer_store = useViewerStore()
         await viewer_store.stop_request()
         expect(viewer_store.request_counter).toBe(-1)
       })

package/{test → tests/unit}/utils/validate_schema.nuxt.test.js

@@ -1,5 +1,8 @@
 import { describe, expect, test } from "vitest"
 
+import validate_schema from "@ogw_f/utils/validate_schema.js"
+console.log("@ogw_f", "@ogw_f")
+
 describe("validate_schema.js", () => {
   const schema = {
     $id: "/test",

package/tests/vitest.config.js

@@ -0,0 +1,33 @@
+import { defineConfig } from "vitest/config"
+import { defineVitestProject } from "@nuxt/test-utils/config"
+
+export default defineConfig({
+  test: {
+    projects: [
+      await defineVitestProject({
+        test: {
+          name: "unit",
+          include: ["tests/unit/**/*.test.js"],
+          environment: "nuxt",
+          server: {
+            deps: {
+              inline: ["vuetify"],
+            },
+          },
+        },
+      }),
+      await defineVitestProject({
+        test: {
+          name: "integration",
+          include: ["tests/integration/**/*.test.js"],
+          environment: "nuxt",
+          server: {
+            deps: {
+              inline: ["vuetify"],
+            },
+          },
+        },
+      }),
+    ],
+  },
+})

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/.github/workflows/Branch-protection.yml

@@ -1,11 +0,0 @@
-name: Check branch origin
-
-on:
-  pull_request:
-
-jobs:
-  check-branch-protection:
-    uses: Geode-solutions/actions/.github/workflows/branch-protection.yml@master
-    with:
-      branch_from: "next"
-      branch_to: "master"