zoneModel updated Structure modified for the API

src/shared/connect/mongoose.ts

@@ -1,10 +1,11 @@
 import mongoose, { Schema, Connection, Model } from "mongoose";
+import dotenv from "dotenv";
 
 interface ConnectionCache {
   [key: string]: Connection;
 }
-
 const connections: ConnectionCache = {};
+dotenv.config();
 
 const MainModel = <T>(
   db: string,
@@ -12,11 +13,11 @@ const MainModel = <T>(
   schema: Schema<T>,
   collectionName: string
 ): Model<T> => {
-  const db1_url = `${process.env.MONGO_URI}${db}`;
+  const db1_url = `${process.env.LOCAL_MONGO_URI}${db}`;
   const authOptions = {
-    user: process.env.MONGO_USER, // Correct username environment variable
-    pass: process.env.MONGO_PASSWORD, // Correct password environment variable
-    authSource: process.env.MONGO_AUTH_DB || 'admin', // Default to 'admin' if not provided
+    user: process.env.MONGO_USER,
+    pass: process.env.MONGO_PASSWORD,
+    authSource: process.env.MONGO_AUTH_DB || "admin",
     maxPoolSize: 50,
   };
   // Check if the connection already exists
@@ -30,13 +31,15 @@ const MainModel = <T>(
     // Cache the connection
     connections[db] = db1;
 
-    // Log connection success or handle errors
     db1.on("connected", () => {
       console.log(`Connected to MongoDB database: ${db}`);
     });
 
     db1.on("error", (err) => {
-      console.error(`MongoDB connection error for database ${db}:`, err.message);
+      console.error(
+        `MongoDB connection error for database ${db}:`,
+        err.message
+      );
     });
 
     return db1.model<T>(modelName, schema, collectionName);
@@ -47,4 +50,3 @@ const MainModel = <T>(
 };
 
 export default MainModel;
-

src/shared/model/assets/wallitems-Model.ts

@@ -1,34 +0,0 @@
-import mongoose, { Document, Schema } from 'mongoose';
-import MainModel from '../../connect/mongoose';
-// Interface for TypeScript with PascalCase
-export interface wallitems extends Document {
-    modeluuid: string;
-    modelname: string
-    type: string
-    csgposition: []
-    csgscale: []
-    position: []
-    quaternion: []
-    scale: []
-
-
-}
-
-// Define the Mongoose Schema
-const wallItemsSchema: Schema = new Schema({
-    modeluuid: { type: String, unique: true },
-    modelname: { type: String },
-    type: { type: String },
-    csgposition: { type: Array },
-    csgscale: { type: Array, },
-    position: { type: Array },
-    quaternion: { type: Array },
-    scale: { type: Array }
-});
-
-
-// export default wallItenmModel;
-const wallItenmModel = (db: string) => {
-    return MainModel(db, "wallitems", wallItemsSchema, "wallitems")
-};
-export default wallItenmModel;

src/shared/model/builder/assets/flooritems-Model.ts

@@ -1,21 +1,19 @@
-import mongoose, { Document, Schema } from 'mongoose';
-import MainModel from '../../connect/mongoose';
+import mongoose, { Document, Schema } from "mongoose";
+import MainModel from "../../../connect/mongoose.ts";
 
 // Interface for TypeScript with PascalCase
 export interface floorItenms extends Document {
   modeluuid: string;
   modelfileID: string;
-  modelname: string
-  isLocked: boolean
-  isVisible: boolean
-  position: []
+  modelname: string;
+  isLocked: boolean;
+  isVisible: boolean;
+  position: [];
   rotation: {
     x: number;
     y: number;
     z: number;
   };
-
-
 }
 
 // Define the Mongoose Schema
@@ -29,13 +27,12 @@ const floorItemsSchema: Schema = new Schema({
   rotation: {
     x: { type: Number, required: true },
     y: { type: Number, required: true },
-    z: { type: Number, required: true }
-  }
+    z: { type: Number, required: true },
+  },
 });
 
-
 // export default floorItemsModel;
 const floorItemsModel = (db: string) => {
-  return MainModel(db, "floorItems", floorItemsSchema, "floorItems")
+  return MainModel(db, "floorItems", floorItemsSchema, "floorItems");
 };
-export default floorItemsModel;
+export default floorItemsModel;

src/shared/model/builder/assets/wallitems-Model.ts

@@ -0,0 +1,31 @@
+import mongoose, { Document, Schema } from "mongoose";
+import MainModel from "../../../connect/mongoose.ts";
+// Interface for TypeScript with PascalCase
+export interface wallitems extends Document {
+  modeluuid: string;
+  modelname: string;
+  type: string;
+  csgposition: [];
+  csgscale: [];
+  position: [];
+  quaternion: [];
+  scale: [];
+}
+
+// Define the Mongoose Schema
+const wallItemsSchema: Schema = new Schema({
+  modeluuid: { type: String, unique: true },
+  modelname: { type: String },
+  type: { type: String },
+  csgposition: { type: Array },
+  csgscale: { type: Array },
+  position: { type: Array },
+  quaternion: { type: Array },
+  scale: { type: Array },
+});
+
+// export default wallItenmModel;
+const wallItenmModel = (db: string) => {
+  return MainModel(db, "wallitems", wallItemsSchema, "wallitems");
+};
+export default wallItenmModel;

src/shared/model/builder/camera/camera-Model.ts

@@ -1,5 +1,5 @@
-import mongoose, { Document, Schema } from 'mongoose';
-import MainModel from '../../connect/mongoose';
+import mongoose, { Document, Schema } from "mongoose";
+import MainModel from "../../../connect/mongoose.ts";
 
 // Interface for TypeScript with PascalCase
 export interface Camera extends Document {
@@ -8,17 +8,17 @@ export interface Camera extends Document {
     x: number;
     y: number;
     z: number;
-  }
+  };
   target: {
-    x: { type: Number, required: true },
-    y: { type: Number, required: true },
-    z: { type: Number, required: true }
-  }
+    x: { type: Number; required: true };
+    y: { type: Number; required: true };
+    z: { type: Number; required: true };
+  };
   rotation: {
-    x: { type: Number, required: true },
-    y: { type: Number, required: true },
-    z: { type: Number, required: true }
-  }
+    x: { type: Number; required: true };
+    y: { type: Number; required: true };
+    z: { type: Number; required: true };
+  };
 }
 
 // Define the Mongoose Schema
@@ -27,23 +27,22 @@ const cameraSchema: Schema = new Schema({
   position: {
     x: { type: Number, required: true },
     y: { type: Number, required: true },
-    z: { type: Number, required: true }
+    z: { type: Number, required: true },
   },
   target: {
     x: { type: Number, required: true },
     y: { type: Number, required: true },
-    z: { type: Number, required: true }
+    z: { type: Number, required: true },
   },
   rotation: {
     x: { type: Number, required: true },
     y: { type: Number, required: true },
-    z: { type: Number, required: true }
-  }
+    z: { type: Number, required: true },
+  },
 });
 
-
 // export default cameraModel
 const cameraModel = (db: string) => {
-  return MainModel(db, "Camera", cameraSchema, "Camera")
+  return MainModel(db, "Camera", cameraSchema, "Camera");
 };
-export default cameraModel;
+export default cameraModel;

src/shared/model/builder/environments/environments-Model.ts

@@ -1,5 +1,5 @@
 import mongoose, { Document, Schema } from 'mongoose';
-import MainModel from '../../connect/mongoose';
+import MainModel from '../../../connect/mongoose.ts';
 // Interface for TypeScript with PascalCase
 export interface environment extends Document {
   userId: string;

src/shared/model/builder/lines/lines-Model.ts

@@ -1,8 +1,8 @@
 import mongoose, { Document, Schema } from "mongoose";
-import MainModel from "../../connect/mongoose";
+import MainModel from "../../../connect/mongoose.ts";
 const positionSchema = new mongoose.Schema({
-  x: { type: Number, }, // Optional position fields
-  y: { type: Number, },
+  x: { type: Number }, // Optional position fields
+  y: { type: Number },
   z: { type: Number },
 });
 
@@ -19,10 +19,8 @@ const LineSchema = new mongoose.Schema({
   type: { type: String, required: false }, // Optional type
 });
 
-
-
 // export default lineModel;
 const lineModel = (db: string) => {
-  return MainModel(db, "lines", LineSchema, "lines")
+  return MainModel(db, "lines", LineSchema, "lines");
 };
-export default lineModel;
+export default lineModel;

src/shared/model/builder/lines/zone-Model.ts

@@ -0,0 +1,35 @@
+import mongoose, { Schema, Document, model } from "mongoose";
+import MainModel from "../../../connect/mongoose.ts";
+
+export interface Zone extends Document {
+  zoneName: string;
+  // zoneUUID: string;
+  zonePoints: [];
+  centerPoints: [];
+  isArchive: boolean;
+  createdBy: string;
+  sceneID: string;
+  //   createdBy: mongoose.Types.ObjectId;
+  //   sceneID: mongoose.Types.ObjectId;
+  layer: number;
+}
+const zoneSchema: Schema = new Schema(
+  {
+    zoneName: { type: String },
+    // zoneUUID: { type: String },
+    createdBy: { type: String },
+    sceneID: { type: String },
+    layer: { type: Number },
+    centerPoints: { type: Array },
+    zonePoints: { type: Array },
+    isArchive: { type: Boolean, default: false },
+    // createdBy: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
+    // sceneID: { type: mongoose.Schema.Types.ObjectId, ref: "Scene" },
+  },
+  { timestamps: true }
+);
+
+const dataModel = (db: any) => {
+  return MainModel(db, "Zones", zoneSchema, "Zones");
+};
+export default dataModel;

src/shared/model/lines/zone-Model.ts

@@ -1,26 +0,0 @@
-import mongoose, { Document, ObjectId, Schema } from "mongoose";
-import MainModel from "../../connect/mongoose";
-export interface zoneSchema extends Document {
-    zoneId: string;
-    zoneName: string
-    createBy: mongoose.Types.ObjectId
-    points: []
-    layer: Number
-
-}
-
-// Define the Mongoose Schema
-const zoneSchema: Schema = new Schema({
-    zoneId: { type: String },
-    zoneName: { type: String },
-    createBy: { type: Schema.Types.ObjectId, ref: "Users", },
-    points: { type: Array },
-    layer: { type: Number, required: true },
-});
-
-
-// export default zoneModel;
-const zoneModel = (db: string) => {
-    return MainModel(db, "zones", zoneSchema, "zones")
-};
-export default zoneModel;

src/shared/model/user-Model.ts

@@ -1,5 +1,5 @@
 import mongoose, { Document, Schema } from "mongoose";
-import MainModel from "../connect/mongoose";
+import MainModel from "../connect/mongoose.ts";
 export interface User extends Document {
   userName: String;
   email: String;
@@ -7,9 +7,8 @@ export interface User extends Document {
 
   role: String;
   profilePicture: String;
-  isShare: Boolean,
-  activeStatus: string
-
+  isShare: Boolean;
+  activeStatus: string;
 }
 const signupschema: Schema = new Schema({
   userName: {
@@ -37,19 +36,17 @@ const signupschema: Schema = new Schema({
   },
   isShare: {
     type: Boolean,
-    default: false
+    default: false,
   },
   activeStatus: {
     type: String,
     enum: ["online", "offline"],
-    default: "offline"
-  }
-
+    default: "offline",
+  },
 });
 
-
 // export default userModel;
 const userModel = (db: string) => {
-  return MainModel(db, "Users", signupschema, "Users")
+  return MainModel(db, "Users", signupschema, "Users");
 };
-export default userModel;
+export default userModel;

src/shared/model/vizualization/panelmodel.ts

@@ -0,0 +1,43 @@
+import mongoose, { Schema, Document, model } from "mongoose";
+import MainModel from "../../connect/mongoose.ts";
+
+export interface Panel extends Document {
+  panelOriginalOrder: string[];
+  panelOrder: [
+    {
+      panelName: string;
+      isArchive: boolean;
+    }
+  ];
+  panelSide: string[];
+  lockedPanel: string[];
+  sceneID: string;
+  zoneID: mongoose.Types.ObjectId;
+  isArchive: boolean;
+  createdBy: string;
+  //   createdBy: mongoose.Types.ObjectId;
+}
+const panelSchema: Schema = new Schema(
+  {
+    panelOriginalOrder: {
+      type: [String],
+      enum: ["left", "right", "up", "down"],
+    },
+    panelOrder: [
+      { panelName: String, isArchive: { type: Boolean, default: false } },
+    ],
+    panelSide: { type: [String], enum: ["left", "right", "up", "down"] },
+    lockedPanel: { type: [String], enum: ["left", "right", "up", "down"] },
+    sceneID: { type: String },
+    zoneID: { type: mongoose.Schema.Types.ObjectId, ref: "Zone" },
+    isArchive: { type: Boolean, default: false },
+    createdBy: { type: String },
+    // createdBy: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
+  },
+  { timestamps: true }
+);
+
+const dataModel = (db: any) => {
+  return MainModel(db, "Panel", panelSchema, "Panel");
+};
+export default dataModel;

src/shared/model/vizualization/widgemodel.ts

@@ -0,0 +1,31 @@
+import mongoose, { Schema, Document, model } from "mongoose";
+import MainModel from "../../connect/mongoose.ts";
+
+export interface widget extends Document {
+  widgetName: string;
+  widgetType: string;
+  panelorderID: mongoose.Types.ObjectId;
+  isArchive: boolean;
+  //   zoneID: string;
+  zoneID: mongoose.Types.ObjectId;
+  sceneID: string;
+  //   sceneID: mongoose.Types.ObjectId;
+  Data: string[];
+}
+const widgetSchema: Schema = new Schema(
+  {
+    widgetName: { type: String },
+    widgetType: { type: String },
+    Data: { type: Array },
+    isArchive: { type: Boolean, default: false },
+    panelorderID: { type: mongoose.Schema.Types.ObjectId, ref: "Panel" },
+    zoneID: { type: mongoose.Schema.Types.ObjectId, ref: "Zone" },
+    sceneID: { type: String },
+  },
+  { timestamps: true }
+);
+
+const dataModel = (db: any) => {
+  return MainModel(db, "Widget", widgetSchema, "Widget");
+};
+export default dataModel;