Dwinzo-Beta/Dwinzo-Backend-V0.0
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Latest Project, Trash and setting API and sockets along with the Model clearance

Browse Source
This commit is contained in:
Nivetharamesh
2025-05-17 10:12:18 +05:30
parent c64e5ea8b5
commit 0b30a8aeaa
66 changed files with 1109 additions and 2351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/api-server/Dockerfile
View File

@@ -3,7 +3,7 @@ ARG NODE_VERSION=lts
FROM node:${NODE_VERSION}-alpine AS development
# Use production node environment by default.
ENV NODE_ENV development
ENV NODE_ENV = development
WORKDIR /usr/src/app

12
src/api-server/Routes/assetfloorRoutes.ts
View File

@@ -1,12 +1,12 @@
import * as express from "express";
import { assetsFloorservice } from "../controller/simulation/assetsFloorservice.ts";
import { AssetsFloorService } from "../controller/simulation/assetsFloorservice.ts";
const router = express.Router();
router.post("/setasset", assetsFloorservice.setFloorassets);
router.get("/floorAssets/:organization", assetsFloorservice.getFloorItems);
router.post("/setasset", AssetsFloorService.setFloorassets);
router.get("/floorAssets/:organization", AssetsFloorService.getFloorItems);
router.patch(
"/updateFloorAssets",
assetsFloorservice.updateAssetPositionRotation
AssetsFloorService.updateAssetPositionRotation
);
router.patch("/eventDataUpdate", assetsFloorservice.replaceEventDatas);
// router.get("/pointData/:modelfileID/:organization", assetsFloorservice.gettypePoints);
router.patch("/eventDataUpdate", AssetsFloorService.replaceEventDatas);
// router.get("/pointData/:modelfileID/:organization", AssetsFloorService.gettypePoints);
export default router;

6
src/api-server/Routes/assetpointRoutes.ts
View File

@@ -1,6 +1,6 @@
import * as express from "express";
import { pointService } from "../controller/assets/pointService.ts";
import { PointService } from "../controller/assets/pointService.ts";
const router = express.Router();
router.post("/pointSchema", pointService.addPoints);
router.get("/pointData/:modelfileID/:organization", pointService.gettypePoints);
router.post("/pointSchema", PointService.addPoints);
router.get("/pointData/:modelfileID/:organization", PointService.gettypePoints);
export default router;

8
src/api-server/Routes/camera-Routes.ts
View File

@@ -1,11 +1,11 @@
import express from 'express';
import { camera } from '../controller/camera/camera-Services.ts';
import { Camera } from '../controller/camera/camera-Services.ts';
const router = express.Router();
router.post('/setCamera',camera.createCamera)
router.get('/getCamera/:organization/:userId',camera.getCamera)
router.get('/activeCameras/:organization',camera.onlineActiveDatas)
router.post('/setCamera',Camera.createCamera)
router.get('/getCamera/:organization/:userId',Camera.getCamera)
router.get('/activeCameras/:organization',Camera.onlineActiveDatas)
export default router;

6
src/api-server/Routes/environments-Routes.ts
View File

@@ -1,9 +1,9 @@
import express from 'express';
import { environment } from '../controller/environments/environments-Services.ts';
import { Environment } from '../controller/environments/environments-Services.ts';
const router = express.Router();
router.post('/setEvironments',environment.setEnvironment)
router.get('/findEnvironments/:organization/:userId',environment.getEnvironment)
router.post('/setEvironments',Environment.setEnvironment)
router.get('/findEnvironments/:organization/:userId',Environment.getEnvironment)
export default router;

10
src/api-server/Routes/floadWidgetRoute.ts
View File

@@ -1,14 +1,14 @@
import * as express from "express";
import { floatWidgetService } from "../controller/visualization/floatWidgetService.ts";
import { FloatWidgetService } from "../controller/visualization/FloatWidgetService.ts";
const router = express.Router();
router.post("/floatwidget/save", floatWidgetService.addfloatWidget);
router.patch("/floatwidget/delete", floatWidgetService.deletefloatWidget);
router.post("/floatwidget/save", FloatWidgetService.addfloatWidget);
router.patch("/floatwidget/delete", FloatWidgetService.deletefloatWidget);
router.get(
"/floadData/:zoneId/:organization",
floatWidgetService.getfloatWidget
FloatWidgetService.getfloatWidget
);
router.get(
"/A_floatWidget/:floatWidgetID/:organization",
floatWidgetService.getsinglefloatWidget
FloatWidgetService.getsinglefloatWidget
);
export default router;

15
src/api-server/Routes/flooritem-Routes.ts
View File

@@ -1,12 +1,11 @@
import express from 'express';
import { floorItems } from '../controller/assets/flooritem-Services.ts';
import { assetsFloorservice } from '../controller/simulation/assetsFloorservice.ts';
import express from "express";
import { FloorItems } from "../controller/assets/flooritem-Services.ts";
import { AssetsFloorService } from "../controller/simulation/assetsFloorservice.ts";
const router = express.Router();
router.post('/setfloorItems',floorItems.setFloorItems)
router.get('/findfloorItems/:organization',floorItems.getFloorItems)
router.post("/setfloorItems", FloorItems.setFloorItems);
router.get("/findfloorItems/:organization", FloorItems.getFloorItems);
// router.delete('/deletefloorItem',floorItems.deleteFloorItems)
router.delete('/deletefloorItem',assetsFloorservice.deleteFloorItems)
router.delete("/deletefloorItem", AssetsFloorService.deleteFloorItems);
export default router;
export default router;

20
src/api-server/Routes/lines-Routes.ts
View File

@@ -1,14 +1,12 @@
import express from 'express';
import { lines } from '../controller/lines/line-Services.ts';
import express from "express";
import { Lines } from "../controller/lines/line-Services.ts";
const router = express.Router();
router.post('/setLine',lines.setLines)
router.post('/updatePoint',lines.updateLines)
router.get('/findLines/:organization',lines.getLines)
router.delete('/deleteLine',lines.deleteLineItems)
router.delete('/deletePoint',lines.deleteLinPoiteItems)
router.post('/deleteLayer',lines.deleteLayer)
router.post("/setLine", Lines.setLines);
router.post("/updatePoint", Lines.updateLines);
router.get("/findLines/:organization", Lines.getLines);
router.delete("/deleteLine", Lines.deleteLineItems);
router.delete("/deletePoint", Lines.deleteLinPoiteItems);
router.post("/deleteLayer", Lines.deleteLayer);
export default router;
export default router;

8
src/api-server/Routes/panelRoutes.ts
View File

@@ -1,5 +1,5 @@
import * as express from "express";
import { panelService } from "../controller/visualization/panelService.ts";
import { PanelService } from "../controller/visualization/PanelService.ts";
const router = express.Router();
/**
* @swagger
@@ -101,7 +101,7 @@ const router = express.Router();
* 500:
* description: Server error
*/
router.post("/panel/save", panelService.AddPanel);
router.post("/panel/save", PanelService.AddPanel);
/**
* @swagger
@@ -135,8 +135,8 @@ router.post("/panel/save", panelService.AddPanel);
* 500:
* description: Server error
*/
router.patch("/panel/delete", panelService.deletePanel);
router.patch("/clearpanel", panelService.clearPanel);
router.patch("/panel/delete", PanelService.deletePanel);
router.patch("/clearpanel", PanelService.clearPanel);
// router.get("/zone/:sceneID", Zoneservice.allZones);
export default router;

6
src/api-server/Routes/productFlowRouts.ts
View File

@@ -1,6 +0,0 @@
// import * as express from "express";
// import { productFlowservice } from "../controller/simulation/productFlowservice.ts";
// const router = express.Router();
// router.post("/createProduct", productFlowservice.setproductFlow);
// router.get("/productFlowList/:organization", productFlowservice.productpathsList);
// export default router;

18
src/api-server/Routes/productRoutes.ts
View File

@@ -1,11 +1,13 @@
import * as express from "express";
import { productFlowservice } from "../controller/simulation/productService.ts";
import { ProductFlowservice } from "../controller/simulation/productService.ts";
const productRouter = express.Router();
productRouter.post("/UpsertProductOrEvent", productFlowservice.productAdd);
productRouter.get("/productData", productFlowservice.getProductDatas);
productRouter.patch("/EventDataDelete", productFlowservice.EventDataDelete);
productRouter.patch("/productDataDelete", productFlowservice.productDataDelete);
productRouter.get("/AllProducts/:organization", productFlowservice.AllProductDatas);
productRouter.patch("/productRename", productFlowservice.productRename);
productRouter.post("/UpsertProductOrEvent", ProductFlowservice.productAdd);
productRouter.get("/productData", ProductFlowservice.getProductDatas);
productRouter.patch("/EventDataDelete", ProductFlowservice.EventDataDelete);
productRouter.patch("/productDataDelete", ProductFlowservice.productDataDelete);
productRouter.get(
"/AllProducts/:organization",
ProductFlowservice.AllProductDatas
);
productRouter.patch("/productRename", ProductFlowservice.productRename);
export default productRouter;

6
src/api-server/Routes/share-Routes.ts
View File

@@ -1,11 +1,11 @@
import express from 'express';
import { share } from '../controller/share/share-Controller.ts';
import { Share } from '../controller/share/share-Controller.ts';
const router = express.Router();
router.post('/shareUser',share.shareUser)
router.get('/findshareUsers',share.findshareUser)
router.post('/shareUser',Share.shareUser)
router.get('/findshareUsers',Share.findshareUser)
export default router;

10
src/api-server/Routes/templateRoutes.ts
View File

@@ -1,12 +1,12 @@
import * as express from "express";
import { templateService } from "../controller/visualization/templateService.ts";
import { TemplateService } from "../controller/visualization/templateService.ts";
const router = express.Router();
router.post("/template/save", templateService.AddTemplate);
router.get("/templateData/:organization", templateService.GetAllTemplates);
router.post("/TemplatetoZone", templateService.AddToZone);
router.post("/template/save", TemplateService.AddTemplate);
router.get("/templateData/:organization", TemplateService.GetAllTemplates);
router.post("/TemplatetoZone", TemplateService.AddToZone);
router.patch(
"/TemplateDelete/:templateID/:organization",
templateService.Deletezone
TemplateService.Deletezone
); //delete zone
export default router;

9
src/api-server/Routes/user-Routes.ts
View File

@@ -1,10 +1,9 @@
import express from 'express';
import { user } from '../controller/user-Controller.ts';
import express from "express";
import { User } from "../controller/user-Controller.ts";
const router = express.Router();
router.post('/signup',user.signup)
router.post('/login',user.login)
router.post("/signup", User.signup);
router.post("/login", User.login);
export default router;

14
src/api-server/Routes/wallItems-Routes.ts
View File

@@ -1,11 +1,9 @@
import express from 'express';
import { wallItems } from '../controller/assets/wallitem-Services.ts';
import express from "express";
import { WallItems } from "../controller/assets/wallitem-Services.ts";
const router = express.Router();
router.post('/setWallItems',wallItems.setWallItems)
router.get('/findWallItems/:organization',wallItems.getWallItems)
router.delete('/deleteWallItem',wallItems.deleteWallItems)
router.post("/setWallItems", WallItems.setWallItems);
router.get("/findWallItems/:organization", WallItems.getWallItems);
router.delete("/deleteWallItem", WallItems.deleteWallItems);
export default router;
export default router;

12
src/api-server/Routes/widget3dRoutes.ts
View File

@@ -1,9 +1,9 @@
import * as express from "express";
import { widget3dService } from "../controller/visualization/3dWidgetService.ts";
import { Widget3dService } from "../controller/visualization/3dWidgetService.ts";
const router = express.Router();
router.post("/3dwidget/save", widget3dService.add3Dwidget);
router.get("/3dwidgetData/:zoneId/:organization", widget3dService.get3Dwiget);
router.get("/widget3D/:id/:organization", widget3dService.getSingle3Dwidget);
router.patch("/widget3D/delete", widget3dService.delete3Dwidget);
router.patch("/modifyPR/widget3D", widget3dService.update3DpositionRotation);
router.post("/3dwidget/save", Widget3dService.add3Dwidget);
router.get("/3dwidgetData/:zoneId/:organization", Widget3dService.get3Dwiget);
router.get("/widget3D/:id/:organization", Widget3dService.getSingle3Dwidget);
router.patch("/widget3D/delete", Widget3dService.delete3Dwidget);
router.patch("/modifyPR/widget3D", Widget3dService.update3DpositionRotation);
export default router;

10
src/api-server/Routes/widgetRoute.ts
View File

@@ -1,5 +1,5 @@
import * as express from "express";
import { widgetService } from "../controller/visualization/widgetService.ts";
import { WidgetService } from "../controller/visualization/widgetService.ts";
const router = express.Router();
/**
* @swagger
@@ -134,11 +134,11 @@ const router = express.Router();
* 500:
* description: Server error
*/
router.post("/widget/save", widgetService.addWidget);
router.patch("/widget/:widgetID", widgetService.updatewidget);
router.patch("/delete/widget", widgetService.deleteWidget);
router.post("/widget/save", WidgetService.addWidget);
router.patch("/widget/:widgetID", WidgetService.updatewidget);
router.patch("/delete/widget", WidgetService.deleteWidget);
router.get(
"/WidgetData/:widgetID/:organization",
widgetService.getDatafromWidget
WidgetService.getDatafromWidget
);
export default router;

14
src/api-server/Routes/zone-Routes.ts
View File

@@ -1,14 +0,0 @@
import express from 'express';
import { zone } from '../controller/lines/zone-Services.ts';
const router = express.Router();
router.post('/setZone',zone.setZone)
router.delete('/deleteZone',zone.deleteZone)
router.get('/findZones/:organization',zone.getZones)
// router.get('/A_zone/:zoneId/:organization',zone.ZoneData)
export default router;

18
src/api-server/Routes/zoneRoutes.ts
View File

@@ -1,5 +1,6 @@
import * as express from "express";
import { Zoneservice } from "../controller/lines/zoneService.ts";
import { ZoneService } from "../controller/lines/zoneService.ts";
const router = express.Router();
/**
* @swagger
@@ -245,7 +246,7 @@ const router = express.Router();
* type: string
* example: "Internal server error"
*/
router.post("/zone/save", Zoneservice.addandUpdateZone); //Zone create and update for the points
router.post("/zone/save", ZoneService.addandUpdateZone); //Zone create and update for the points
/**
* @swagger
@@ -318,9 +319,9 @@ router.post("/zone/save", Zoneservice.addandUpdateZone); //Zone create and updat
* value:
* message: "Zone not found for the UUID"
*/
router.get("/zones/:sceneID", Zoneservice.allZones);
router.get("/zones/:sceneID", ZoneService.allZones);
router.get("/pageZodeData", Zoneservice.vizAllDatas);
router.get("/pageZodeData", ZoneService.vizAllDatas);
/**
* @swagger
@@ -414,7 +415,7 @@ router.get("/pageZodeData", Zoneservice.vizAllDatas);
* example:
* error: "Internal Server Error"
*/
router.get("/ZoneVisualization/:zoneId", Zoneservice.singleZonePanelDatas);
router.get("/ZoneVisualization/:zoneId", ZoneService.singleZonePanelDatas);
/**
* @swagger
@@ -483,7 +484,7 @@ router.get("/ZoneVisualization/:zoneId", Zoneservice.singleZonePanelDatas);
* value:
* message: "Zone not found"
*/
router.get("/A_zone/:zoneId/:organization", Zoneservice.ZoneData);
router.get("/A_zone/:zoneId/:organization", ZoneService.ZoneData);
/**
* @swagger
@@ -536,7 +537,6 @@ router.get("/A_zone/:zoneId/:organization", Zoneservice.ZoneData);
* type: string
* example: "Internal Server Error"
*/
router.patch("/zone/:zoneId", Zoneservice.deleteAZone); //delete Zone
// router.get("/zone/:sceneID", Zoneservice.allZones);
router.patch("/zones/lockedPanels", Zoneservice.lockedPanel);
router.patch("/zone/:zoneId", ZoneService.deleteAZone); //delete Zone
router.patch("/zones/lockedPanels", ZoneService.lockedPanel);
export default router;

8
src/api-server/app.ts
View File

@@ -1,6 +1,5 @@
import express from "express";
import cors from "cors";
import connectDB from "../shared/connect/mongoose.ts";
import dotenv from "dotenv";
import cameraRoutes from "./Routes/camera-Routes.ts";
import environmentsRoutes from "./Routes/environments-Routes.ts";
@@ -9,8 +8,7 @@ import flooritemRoutes from "./Routes/flooritem-Routes.ts";
import WallitemRoutes from "./Routes/wallItems-Routes.ts";
import userRoutes from "./Routes/user-Routes.ts";
import shareRoutes from "./Routes/share-Routes.ts";
import zoneRoutes from "./Routes/zone-Routes.ts";
import zoneRoutes2 from "./Routes/zoneRoutes.ts"; //update
import zoneRoutes from "./Routes/zoneRoutes.ts"; //update
import panelRouter from "./Routes/panelRoutes.ts";
import widgetRouter from "./Routes/widgetRoute.ts";
import assetpointRouter from "./Routes/assetpointRoutes.ts";
@@ -64,7 +62,6 @@ dotenv.config();
app.get("/", (req, res) => {
res.send("Hello, I am Major-Dwinzo API!");
});
// connectDB();
app.get("/health", (req, res) => {
res.status(200).json({ message: "Server is running" });
});
@@ -76,9 +73,8 @@ app.use("/api/v1", flooritemRoutes);
app.use("/api/v1", WallitemRoutes);
app.use("/api/v1", userRoutes);
app.use("/api/v1", shareRoutes);
app.use("/api/v2", zoneRoutes);
//update
app.use("/api/v2", zoneRoutes2); //updates
app.use("/api/v2", zoneRoutes); //updates
app.use("/api/v2", panelRouter);
app.use("/api/v2", widgetRouter);
app.use("/api/v2", assetpointRouter);

3
src/api-server/controller/assets/flooritem-Services.ts
View File

@@ -1,7 +1,7 @@
import { Request, Response } from "express";
import floorItemsModel from "../../../shared/model/assets/flooritems-Model.ts";
export class floorItems {
export class FloorItems {
static async setFloorItems(req: Request, res: Response) {
try {
const {
@@ -57,7 +57,6 @@ export class floorItems {
static async getFloorItems(req: Request, res: Response) {
try {
const { organization } = req.params;
// console.log('req.params: ', req.params);
const findValue = await floorItemsModel(organization).find();
if (!findValue) {

2
src/api-server/controller/assets/pointService.ts
View File

@@ -74,7 +74,7 @@ interface IPointStaticMachine extends IPointBase {
targets: { modelUUID: string; pointUUID: string }[];
};
}
export class pointService {
export class PointService {
static async addPoints(req: Request, res: Response): Promise<any> {
const { type, modelfileID, organization } = req.body;

148
src/api-server/controller/assets/wallitem-Services.ts
View File

@@ -1,80 +1,92 @@
import { Request, Response } from "express";
import wallItenmModel from "../../../shared/model/assets/wallitems-Model.ts";
import wallItemModel from "../../../shared/model/builder/assets/wallitems-Model.ts";
export class WallItems {
static async setWallItems(req: Request, res: Response) {
try {
const {
modelUuid,
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
organization,
} = req.body;
export class wallItems {
static async setWallItems(req: Request, res: Response) {
try {
const { modelUuid, modelName, position, type, csgposition,csgscale,quaternion,scale,organization } = req.body
const findvalue = await wallItemModel(organization).findOne({
modelUuid: modelUuid,
});
const findvalue = await wallItenmModel(organization).findOne({ modelUuid: modelUuid})
if (findvalue) {
const updatevalue = await wallItenmModel(organization).findOneAndUpdate(
{ modelUuid: modelUuid },
{
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
},
{ new: true } // Return the updated document
);
res.status(201).json(updatevalue);
if (findvalue) {
const updatevalue = await wallItemModel(organization).findOneAndUpdate(
{ modelUuid: modelUuid },
{
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
},
{ new: true } // Return the updated document
);
res.status(201).json(updatevalue);
} else {
const newValue = await wallItemModel(organization).create({
modelUuid,
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
});
} else {
const newValue = await wallItenmModel(organization).create({ modelUuid,modelName, position, type, csgposition,csgscale,quaternion,scale });
res.status(201).json(newValue);
}
res.status(201).json(newValue);
}
// Send response with the created document
} catch (error) {
console.error('Error creating wallitems:', error);
res.status(500).json({ message: "Failed to create wallitems" });
}
// Send response with the created document
} catch (error) {
console.error("Error creating wallitems:", error);
res.status(500).json({ message: "Failed to create wallitems" });
}
static async getWallItems(req: Request, res: Response) {
try {
const { organization } = req.params;
}
static async getWallItems(req: Request, res: Response) {
try {
const { organization } = req.params;
const findValue = await wallItenmModel
(organization).find()
if (!findValue) {
res.status(200).json("wallitems not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error('Error get wallitems:', error);
res.status(500).json({ error: "Failed to get wallitems" });
}
const findValue = await wallItemModel(organization).find();
if (!findValue) {
res.status(200).json("wallitems not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error("Error get wallitems:", error);
res.status(500).json({ error: "Failed to get wallitems" });
}
static async deleteWallItems(req: Request, res: Response) {
try {
const { modelUuid,modelName,organization } = req.body;
}
static async deleteWallItems(req: Request, res: Response) {
try {
const { modelUuid, modelName, organization } = req.body;
const findValue = await wallItenmModel
(organization).findOneAndDelete({modelUuid:modelUuid,modelName:modelName})
if (!findValue) {
res.status(200).json("user not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error('Error get wallitems:', error);
res.status(500).json({ error: "Failed to get wallitems" });
}
const findValue = await wallItemModel(organization).findOneAndDelete({
modelUuid: modelUuid,
modelName: modelName,
});
if (!findValue) {
res.status(200).json("user not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error("Error get wallitems:", error);
res.status(500).json({ error: "Failed to get wallitems" });
}
}
}

164
src/api-server/controller/camera/camera-Services.ts
View File

@@ -2,88 +2,96 @@ import { Request, Response } from "express";
import cameraModel from "../../../shared/model/camera/camera-Model.ts";
import userModel from "../../../shared/model/user-Model.ts";
export class camera {
static async createCamera(req: Request, res: Response) {
try {
const { userId, position, target, rotation,organization } = req.body
export class Camera {
static async createCamera(req: Request, res: Response) {
try {
const { userId, position, target, rotation, organization } = req.body;
const findCamera = await cameraModel(organization).findOne({ userId: userId })
if (findCamera) {
const updateCamera = await cameraModel(organization).findOneAndUpdate(
{ userId: userId }, { position: position, target: target,rotation:rotation }, { new: true });
res.status(201).json(updateCamera);
const findCamera = await cameraModel(organization).findOne({
userId: userId,
});
} else {
const newCamera = await cameraModel(organization).create({ userId, position, target,rotation });
res.status(201).json(newCamera);
}
// Send response with the created document
} catch (error) {
console.error('Error creating camera:', error);
res.status(500).json({message:"Failed to create camera"});
}
}
static async getCamera(req: Request, res: Response) {
try {
const { userId, organization } = req.params;
// if (!userId) {
// res.status(201).json("User data is insufficient");
// }
const findCamera = await cameraModel(organization).findOne({ userId: userId })
if (!findCamera) {
res.status(200).json("user not found");
} else {
res.status(201).json(findCamera);
}
} catch (error) {
console.error('Error get camera:', error);
res.status(500).json({ error: "Failed to get camera" });
}
}
static async onlineActiveDatas(req: Request, res: Response) {
const {organization } = req.params;
try {
const findactiveUsers = await userModel(organization).find({activeStatus:"online"})
const cameraDataPromises = findactiveUsers.map(async (activeUser:any) => {
const cameraData = await cameraModel(organization)
.findOne({ userId: activeUser._id })
.select("position target rotation -_id");
if (cameraData) {
return {
position: cameraData.position,
target: cameraData.target,
rotation:cameraData.rotation,
userData: {
_id: activeUser._id,
userName: activeUser.userName,
email: activeUser.email,
activeStatus: activeUser.activeStatus,
},
};
}
// Return null if no camera data is found for the user
return null;
if (findCamera) {
const updateCamera = await cameraModel(organization).findOneAndUpdate(
{ userId: userId },
{ position: position, target: target, rotation: rotation },
{ new: true }
);
res.status(201).json(updateCamera);
} else {
const newCamera = await cameraModel(organization).create({
userId,
position,
target,
rotation,
});
const cameraDatas = (await Promise.all(cameraDataPromises)).filter((singledata:any) => singledata !== null);
res.status(201).json(newCamera);
}
res.status(200).send({ cameraDatas });
} catch (error:any) {
res.status(500).send(error);
}
// Send response with the created document
} catch (error) {
console.error("Error creating camera:", error);
res.status(500).json({ message: "Failed to create camera" });
}
}
static async getCamera(req: Request, res: Response) {
try {
const { userId, organization } = req.params;
const findCamera = await cameraModel(organization).findOne({
userId: userId,
});
if (!findCamera) {
res.status(200).json("user not found");
} else {
res.status(201).json(findCamera);
}
} catch (error) {
console.error("Error get camera:", error);
res.status(500).json({ error: "Failed to get camera" });
}
}
static async onlineActiveDatas(req: Request, res: Response) {
const { organization } = req.params;
try {
const findactiveUsers = await userModel(organization).find({
activeStatus: "online",
});
const cameraDataPromises = findactiveUsers.map(
async (activeUser: any) => {
const cameraData = await cameraModel(organization)
.findOne({ userId: activeUser._id })
.select("position target rotation -_id");
if (cameraData) {
return {
position: cameraData.position,
target: cameraData.target,
rotation: cameraData.rotation,
userData: {
_id: activeUser._id,
userName: activeUser.userName,
email: activeUser.email,
activeStatus: activeUser.activeStatus,
},
};
}
// Return null if no camera data is found for the user
return null;
}
);
const cameraDatas = (await Promise.all(cameraDataPromises)).filter(
(singledata: any) => singledata !== null
);
res.status(200).send({ cameraDatas });
} catch (error: any) {
res.status(500).send(error);
}
}
}

2
src/api-server/controller/environments/environments-Services.ts
View File

@@ -1,7 +1,7 @@
import { Request, Response } from "express";
import environmentModel from "../../../shared/model/environments/environments-Model.ts";
export class environment {
export class Environment {
static async setEnvironment(req: Request, res: Response) {
try {
const {

225
src/api-server/controller/lines/line-Services.ts
View File

@@ -1,125 +1,116 @@
import { Request, Response } from "express";
import lineModel from "../../../shared/model/lines/lines-Model.ts";
export class lines {
static async setLines(req: Request, res: Response) {
try {
const {organization,layer,line,type}=req.body
const newLine = await lineModel(organization).create({ layer,line,type });
res.status(201).json(newLine);
// Send response with the created document
} catch (error) {
console.error('Error creating Lines:', error);
res.status(500).json({message:"Failed to create Lines"});
}
export class Lines {
static async setLines(req: Request, res: Response) {
try {
const { organization, layer, line, type } = req.body;
const newLine = await lineModel(organization).create({
layer,
line,
type,
});
res.status(201).json(newLine);
// Send response with the created document
} catch (error) {
console.error("Error creating Lines:", error);
res.status(500).json({ message: "Failed to create Lines" });
}
static async updateLines(req: Request, res: Response) {
try {
const {organization,uuid,position,}=req.body
// const findLine = await lineModel(organization).find({ 'line.uuid': uuid });
// Update the position of the line matching the uuid
}
static async updateLines(req: Request, res: Response) {
try {
const { organization, uuid, position } = req.body;
// const findLine = await lineModel(organization).find({ 'line.uuid': uuid });
// Update the position of the line matching the uuid
const updateResult = await lineModel(organization).updateMany(
{ "line.uuid": uuid }, // Filter: Find the line with the given uuid
{ $set: { "line.$.position": position } } // Update the position and type
);
res.status(201).json(updateResult);
// Send response with the created document
} catch (error) {
console.error("Error creating Lines:", error);
res.status(500).json({ message: "Failed to create Lines" });
}
}
static async getLines(req: Request, res: Response) {
try {
const { organization } = req.params;
const findValue = await lineModel(organization).find();
if (!findValue) {
res.status(200).json("user not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error("Error get Lines:", error);
res.status(500).json({ error: "Failed to get Lines" });
}
}
static async deleteLineItems(req: Request, res: Response) {
try {
const { organization, layer, line, type } = req.body;
const inputUuids = line.map((item: any) => item.uuid);
const findValue = await lineModel(organization).findOneAndDelete({
"line.uuid": { $all: inputUuids },
});
if (!findValue) {
res.status(200).json("data not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error("Error delete Lines:", error);
res.status(500).json({ error: "Failed to delete Lines" });
}
}
static async deleteLinPoiteItems(req: Request, res: Response) {
try {
const { organization, layer, uuid, type } = req.body;
const findValue = await lineModel(organization).deleteMany({
"line.uuid": uuid,
});
if (!findValue) {
res.status(200).json("data not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error("Error delete Lines:", error);
res.status(500).json({ error: "Failed to delete Lines" });
}
}
static async deleteLayer(req: Request, res: Response) {
try {
const { organization, layer } = req.body;
const findValue = await lineModel(organization).find({ layer: layer });
if (!findValue) {
res.status(200).json("data not found");
} else {
await lineModel(organization).deleteMany({ layer: layer });
const updateResult = await lineModel(organization).updateMany(
{ 'line.uuid': uuid }, // Filter: Find the line with the given uuid
{ $set: { 'line.$.position': position } } // Update the position and type
{ layer: { $gt: layer } },
{ $inc: { layer: -1 } }
);
res.status(201).json(updateResult);
// Send response with the created document
} catch (error) {
console.error('Error creating Lines:', error);
res.status(500).json({message:"Failed to create Lines"});
}
}
static async getLines(req: Request, res: Response) {
try {
const { organization } = req.params;
const findValue = await lineModel(organization).find()
if (!findValue) {
res.status(200).json("user not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error('Error get Lines:', error);
res.status(500).json({ error: "Failed to get Lines" });
}
}
static async deleteLineItems(req: Request, res: Response) {
try {
const {organization,layer,line,type}=req.body
const inputUuids = line.map((item: any) => item.uuid);
// const findValue = await lineModel(organization).findOneAndDelete({
// line: { $elemMatch: { uuid: { $in: inputUuids } } },
// });
const findValue = await lineModel(organization).findOneAndDelete({
"line.uuid": { $all: inputUuids } // Ensure all UUIDs are present in the `line` key
});
if (!findValue) {
res.status(200).json("data not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error('Error delete Lines:', error);
res.status(500).json({ error: "Failed to delete Lines" });
}
}
static async deleteLinPoiteItems(req: Request, res: Response) {
try {
const {organization,layer,uuid,type}=req.body
const findValue = await lineModel(organization).deleteMany({ 'line.uuid': uuid })
if (!findValue) {
res.status(200).json("data not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error('Error delete Lines:', error);
res.status(500).json({ error: "Failed to delete Lines" });
}
}
static async deleteLayer(req: Request, res: Response) {
try {
const {organization,layer}=req.body
// Fetch the documents with the specified layer value
const findValue = await lineModel(organization).find({ layer: layer });
if (!findValue) {
res.status(200).json("data not found");
} else {
await lineModel(organization).deleteMany({ layer: layer });
// console.log(`Documents with layer ${layer} have been deleted.`);
// Update documents with layer greater than -1
const updateResult = await lineModel(organization).updateMany(
{ layer: { $gt:layer} },
{ $inc: { layer: -1 } } // Example operation: decrementing layer by 1
);
res.status(201).json(updateResult);
}
} catch (error) {
console.error('Error delete Lines:', error);
res.status(500).json({ error: "Failed to delete Lines" });
}
res.status(201).json(updateResult);
}
} catch (error) {
console.error("Error delete Lines:", error);
res.status(500).json({ error: "Failed to delete Lines" });
}
}
}

88
src/api-server/controller/lines/zone-Services.ts
View File

@@ -1,88 +0,0 @@
import { Request, Response } from "express";
import zoneModel from "../../../shared/model/lines/zone-Model.ts";
export class zone {
static async setZone(req: Request, res: Response) {
try {
const { organization, userId, zoneData } = req.body
// console.log('req.body: ', req.body);
const zoneId = zoneData.zoneId
const points = zoneData.points
const zoneName = zoneData.zoneName
const layer = zoneData.layer
const viewPortCenter = zoneData.viewPortCenter
const viewPortposition = zoneData.viewPortposition
const findZoneId = await zoneModel(organization).findOne({ zoneId: zoneId })
if (findZoneId) {
const updateZone = await zoneModel(organization).findOneAndUpdate(
{ zoneId: zoneId }, { points: points, viewPortposition: viewPortposition, viewPortCenter: viewPortCenter }, { new: true }
).select("-_id -__v")
res.status(201).json({ message: 'zone updated', data: updateZone, organization: organization })
} else {
const zoneCreate = await zoneModel(organization).create({
zoneId, createBy: userId, zoneName: zoneName, points, layer, viewPortCenter, viewPortposition
})
const createdZone = await zoneModel(organization)
.findById(zoneCreate._id)
.select('-_id -__v')
.lean();
res.status(201).json({ message: 'zone created', data: createdZone, organization: organization })
}
} catch (error) {
console.log('error: ', error);
res.status(500).json({ message: 'Zone not found', error })
}
}
static async deleteZone(req: Request, res: Response) {
try {
const { organization, userId, zoneId } = req.body
const findZoneId = await zoneModel(organization).findOne({ zoneId: zoneId })
if (findZoneId) {
const deleteZone = await zoneModel(organization).findOneAndDelete(
{ zoneId: zoneId, createBy: userId }
).select("-_id -__v")
res.status(201).json({ message: 'zone deleted', data: deleteZone, organization: organization })
} else {
res.status(500).json({ message: 'Invalid zone ID' })
}
} catch (error) {
console.log('error: ', error);
res.status(500).json({ message: 'Zone not found', error })
}
}
static async getZones(req: Request, res: Response) {
try {
const { organization, userId } = req.params
const findZoneId = await zoneModel(organization)
.find()
.select("zoneId zoneName layer points viewPortCenter viewPortposition -_id");
if (!findZoneId) {
res.status(500).json({ message: 'Invalid zone' })
}
res.status(201).json({ data: findZoneId, organization: organization })
} catch (error) {
console.log('error: ', error);
res.status(500).json({ message: 'Zone not found', error })
}
}
static async ZoneData(req: Request, res: Response): Promise<any> {
try {
const organization = req.params.organization;
const zoneId = req.params.zoneId;
const findZone = await zoneModel(organization)
.findOne({ zoneId: zoneId })
// .select("zoneName");
console.log("findZone: ", findZone);
if (findZone) return res.status(200).json(findZone);
} catch (error: any) {
return res.status(500).send(error.message);
}
}
}

2
src/api-server/controller/lines/zoneService.ts
View File

@@ -2,7 +2,7 @@ import { Request, Response } from "express";
import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
export class Zoneservice {
export class ZoneService {
static async addandUpdateZone(req: Request, res: Response): Promise<any> {
try {
const organization = req.body.organization;

59
src/api-server/controller/newassets/wallcontroller.ts Normal file
View File

@@ -0,0 +1,59 @@
import { Request, Response } from "express";
import { WallItems } from "../../../shared/services/wall/wallItemservice.ts";
import { error } from "console";
export const WallSetup = async (req: Request, res: Response): Promise<void> => {
try {
const {
modelUuid,
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
organization,
} = req.body;
if (
!modelUuid ||
!modelName ||
!position ||
!type ||
!csgscale ||
!csgposition ||
!quaternion ||
!scale ||
!organization
) {
res.status(400).json({
message: "All fields are required!",
});
return;
}
const result = await WallItems.setWallItems({
modelUuid,
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
organization,
});
switch (result.state) {
case "Updated successfully":
res.status(201).json(result.data);
break;
case "wall Item created successfully":
res.status(201).json(result.data);
break;
default:
res.status(500).json(error);
break;
}
} catch (error: unknown) {
res.status(500).json({ message: "Unknown error" });
}
};

75
src/api-server/controller/share/share-Controller.ts
View File

@@ -1,43 +1,46 @@
import { Request, Response } from "express";
import userModel from "../../../shared/model/user-Model.ts";
export class Share {
static async shareUser(req: Request, res: Response) {
try {
const { email, isShare, organization } = req.body;
export class share {
static async shareUser(req: Request, res: Response) {
try {
const { email, isShare, organization } = req.body
const findValue = await userModel(organization).findOneAndUpdate(
{ email: email },
{ isShare: isShare },
{ new: true }
);
const findValue = await userModel(organization).findOneAndUpdate({email:email},{isShare:isShare},{new:true})
res.status(201).json({message:"scene shared successfully",data:findValue});
if (!findValue) {
res.status(404).json({message:"Not found"})
}
// Send response with the created document
} catch (error) {
console.error('Error creating Share:', error);
res.status(500).json({message:"Failed to create Share"});
}
res
.status(201)
.json({ message: "scene shared successfully", data: findValue });
if (!findValue) {
res.status(404).json({ message: "Not found" });
}
// Send response with the created document
} catch (error) {
console.error("Error creating Share:", error);
res.status(500).json({ message: "Failed to create Share" });
}
static async findshareUser(req: Request, res: Response) {
try {
const organization = req.query.organization as string;
const findValue = await userModel(organization).find({}).select("isShare email userName -_id")
// console.log('findValue: ', findValue);
res.status(201).json({message:"scene shared datas",data:findValue});
if (!findValue) {
res.status(404).json({message:"Not found"})
}
// Send response with the created document
} catch (error) {
console.error('Error Share:', error);
res.status(500).json({message:"Failed to Share datas "});
}
}
}
static async findshareUser(req: Request, res: Response) {
try {
const organization = req.query.organization as string;
const findValue = await userModel(organization)
.find({})
.select("isShare email userName -_id");
res.status(201).json({ message: "scene shared datas", data: findValue });
if (!findValue) {
res.status(404).json({ message: "Not found" });
}
// Send response with the created document
} catch (error) {
console.error("Error Share:", error);
res.status(500).json({ message: "Failed to Share datas " });
}
}
}

241
src/api-server/controller/simulation/assetsFloorservice.ts
View File

@@ -1,182 +1,9 @@
import { Request, Response } from "express";
import assetModel from "../../../shared/model/builder/assets/asset-Model.ts";
import actionModel from "../../../shared/model/simulation/actionmodel.ts";
import triggerModel from "../../../shared/model/simulation/triggersmodel.ts";
import pointModel from "../../../shared/model/builder/assets/assetPoint-Model.ts";
import EventsDataModel from "../../../shared/model/simulation/eventsDataModel.ts";
export class assetsFloorservice {
// static async setFloorassets(req: Request, res: Response): Promise<any> {
// try {
// const {
// modelUuid,
// modelName,
// position,
// modelfileID,
// rotation,
// isLocked,
// isVisible,
// organization,
// eventData,
// } = req.body;
// console.log("req.body: ", req.body);
// const findvalue = await assetModel(organization).findOne({
// modelUuid,
// // modelName,
// isArchive: false,
// });
// const checkpointType = await pointModel(organization).findOne({
// modelfileID: modelfileID,
// isArchive: false,
// });
// if (findvalue) {
// const updatevalue = await assetModel(organization).findOneAndUpdate(
// { modelUuid, isArchive: false },
// {
// modelName: modelName,
// position,
// rotation,
// isVisible,
// isLocked,
// },
// { new: true }
// );
// return res.status(201).json(updatevalue);
// } else {
// let assetData: any = {
// modelUuid,
// modelName,
// position,
// modelfileID,
// rotation,
// isLocked,
// isVisible,
// };
// console.log("eventData: ", eventData);
// if (eventData) {
// if (eventData.type === "Conveyor") {
// assetData.speed = eventData.speed;
// } else if (eventData.type === "Vehicle") {
// assetData.speed = eventData.points.speed;
// if (!eventData.points) {
// return res
// .status(400)
// .json({ message: "Vehicle points must be a single object" });
// }
// // if (eventData.points.rotation) {
// // return res.status(400).json({
// // message: "Rotation is not allowed for Vehicle points",
// // });
// // }
// if (eventData.points.triggers) {
// return res.status(400).json({
// message: "triggers is not allowed for Vehicle points",
// });
// }
// }
// // else if(eventData.type === "ArmBot"){
// // assetData.speed = eventData.position;
// // }else if(eventData.type === "StaticMachine"){
// // assetData.speed = eventData.position;
// // }
// assetData.points = eventData.points;
// assetData.type = eventData.type;
// }
// const assetDoc = await assetModel(organization).create(assetData);
// await assetDoc.save();
// return res.status(201).json({
// message: "Model stored successfully",
// modelId: assetDoc._id,
// });
// }
// } catch (error) {
// console.error("Error creating flooritems:", error);
// res.status(500).json({ message: "Failed to create flooritems" });
// }
// }
// static async getFloorItems(req: Request, res: Response): Promise<any> {
// try {
// const { organization } = req.params;
// const findValues = await assetModel(organization)
// .find({ isArchive: false })
// .select("-_id -isArchive");
// if (!findValues || findValues.length === 0) {
// return res.status(200).json({ message: "floorItems not found" });
// }
// const response = findValues.map((item) => {
// // console.log("item: ", item);
// // console.log("item: ", item.type);
// // console.log('findValues: ', findValues);
// // console.log("item.points: ", item.points);
// const responseItem: any = {
// modelUuid: item.modelUuid,
// modelName: item.modelName,
// position: item.position,
// rotation: item.rotation,
// modelfileID: item.modelfileID,
// isLocked: item.isLocked,
// isVisible: item.isVisible,
// };
// if (item.type === "Conveyor" && item.points.length > 0) {
// responseItem.eventData = {
// speed: item.speed,
// points: item.points,
// type: item.type,
// };
// }
// if (item.type === "Vehicle" && item.points) {
// responseItem.eventData = {
// type: item.type,
// points: item.points,
// };
// }
// if (item.type === "ArmBot" && item.points) {
// responseItem.eventData = {
// type: item.type,
// points: item.points,
// };
// }
// if (item.type === "StaticMachine" && item.points) {
// responseItem.eventData = {
// type: item.type,
// points: item.points,
// };
// }
// return responseItem;
// });
// return res.status(200).json(response);
// } catch (error) {
// res.status(500).json({ error: "Failed to get flooritems" });
// }
// }
// static async deleteFloorItems(req: Request, res: Response): Promise<any> {
// try {
// const { modelUuid, modelName, organization } = req.body;
// const findValue = await assetModel(organization).findOneAndDelete({
// modelUuid: modelUuid,
// modelName: modelName,
// isArchive: false,
// });
// if (!findValue) {
// res.status(200).json("user not found");
// } else {
// res.status(201).json(findValue);
// }
// } catch (error) {
// res.status(500).json({ error: "Failed to get flooritems" });
// }
// }
export class AssetsFloorService {
static async updateAssetPositionRotation(
req: Request,
res: Response
@@ -186,11 +13,11 @@ export class assetsFloorservice {
modelUuid,
modelName,
position,
modelfileID,
rotation,
isLocked,
isVisible,
organization,
// modelfileID, //optional
// eventData, // Optional
} = req.body;
@@ -244,7 +71,6 @@ export class assetsFloorservice {
return res.status(500).send(error.message);
}
}
//update setfoolrassets//getFloorItems//deleteFloorItems.........
static async setFloorassets(req: Request, res: Response): Promise<any> {
try {
const {
@@ -265,7 +91,7 @@ export class assetsFloorservice {
// modelName,
isArchive: false,
});
const checkpointType = await pointModel(organization).findOne({
await pointModel(organization).findOne({
modelfileID: modelfileID,
isArchive: false,
});
@@ -292,10 +118,9 @@ export class assetsFloorservice {
rotation,
isLocked,
isVisible,
eventData
eventData,
};
console.log("eventData: ", eventData);
if (eventData) {
if (eventData.type === "Conveyor") {
assetData.speed = eventData.speed;
@@ -306,24 +131,12 @@ export class assetsFloorservice {
.status(400)
.json({ message: "Vehicle points must be a single object" });
}
// if (eventData.points.rotation) {
// return res.status(400).json({
// message: "Rotation is not allowed for Vehicle points",
// });
// }
if (eventData.points.triggers) {
return res.status(400).json({
message: "triggers is not allowed for Vehicle points",
});
}
}
// else if(eventData.type === "ArmBot"){
// assetData.speed = eventData.position;
// }else if(eventData.type === "StaticMachine"){
// assetData.speed = eventData.position;
// }
assetData.points = eventData.points;
assetData.type = eventData.type;
}
@@ -352,10 +165,6 @@ export class assetsFloorservice {
}
const response = findValues.map((item) => {
// console.log("item: ", item);
// console.log("item: ", item.type);
// console.log('findValues: ', findValues);
// console.log("item.points: ", item.points);
const responseItem: any = {
modelUuid: item.modelUuid,
modelName: item.modelName,
@@ -366,36 +175,9 @@ export class assetsFloorservice {
isVisible: item.isVisible,
eventData: item.eventData,
};
// if (item.type === "Conveyor" && item.points.length > 0) {
// responseItem.eventData = {
// speed: item.speed,
// points: item.points,
// type: item.type,
// };
// }
// if (item.type === "Vehicle" && item.points) {
// responseItem.eventData = {
// type: item.type,
// points: item.points,
// };
// }
// if (item.type === "ArmBot" && item.points) {
// responseItem.eventData = {
// type: item.type,
// points: item.points,
// };
// }
// if (item.type === "StaticMachine" && item.points) {
// responseItem.eventData = {
// type: item.type,
// points: item.points,
// };
// }
return responseItem;
});
// console.log('response: ', response);
return res.status(200).json(response);
} catch (error) {
res.status(500).json({ error: "Failed to get flooritems" });
@@ -404,36 +186,35 @@ export class assetsFloorservice {
static async deleteFloorItems(req: Request, res: Response): Promise<any> {
try {
const { modelUuid, modelName, organization } = req.body;
console.log('req.body:', req.body);
const asset = await assetModel(organization).findOne({
modelUuid,
modelName,
isArchive: false,
});
if (!asset) {
return res.status(404).json({ message: "Model not found" });
}
const archivedAsset = await assetModel(organization).findOneAndUpdate(
{ modelUuid, modelName },
{ $set: { isArchive: true } },
{ new: true }
);
if (!archivedAsset) {
return res.status(500).json({ message: "Failed to archive asset" });
}
const updatedEvents = await EventsDataModel(organization).updateMany(
{ modelUuid },
{ $set: { isArchive: true } }
);
console.log("Archived asset:", archivedAsset);
console.log("Updated events:", updatedEvents.modifiedCount);
return res.status(200).json({ message: "delete Asset successfully" });
} catch (error) {
console.error("Error deleting floor items:", error);

249
src/api-server/controller/simulation/productFlowservice.ts
View File

@@ -1,249 +0,0 @@
// import { Request, Response } from "express";
// // import assetModel from "../../../shared/model/assets/flooritems-Model.ts";
// import assetModel from "../../../shared/model/builder/assets/asset-Model.ts";
// import actionModel from "../../../shared/model/simulation/actionmodel.ts";
// import triggerModel from "../../../shared/model/simulation/triggersmodel.ts";
// import productFlowModel from "../../../shared/model/simulation/ProductFlowmodel.ts";
// export class productFlowservice {
// static async setproductFlow(req: Request, res: Response): Promise<any> {
// try {
// const {
// productName,
// modelUuid,
// modelName,
// eventData,
// organization,
// productID,
// } = req.body;
// // Validate required fields
// if (!modelUuid || !modelName || !organization) {
// return res.status(400).json({ message: "Missing required fields" });
// }
// // Check if asset exists
// const existingAsset = await assetModel(organization).findOne({
// modelUuid: modelUuid,
// isArchive: false,
// });
// if (!existingAsset) {
// return res.status(404).json({ message: "Asset not found for the ID" });
// }
// // Prepare point references
// let pointRefs: any[] = [];
// if (eventData?.points && Array.isArray(eventData.points)) {
// for (const point of eventData.points) {
// let actionRefs: any[] = [];
// let triggerRefs: any[] = [];
// // Process actions
// if (Array.isArray(point.actions)) {
// for (const action of point.actions) {
// const actionDoc = await actionModel(organization).create({
// pointsUUID: point.uuid,
// isArchive: false,
// uuid: action.uuid,
// name: action.name,
// type: action.type,
// material: action.material || null,
// delay: action.delay || null,
// spawn_Interval: action.spawn_Interval || null,
// });
// actionRefs.push({
// _id: actionDoc._id,
// ...action,
// });
// }
// }
// // Process triggers
// if (Array.isArray(point.triggers)) {
// for (const trigger of point.triggers) {
// const triggerDoc = await triggerModel(organization).create({
// pointsUUID: point.uuid,
// isArchive: false,
// uuid: trigger.uuid,
// name: trigger.name,
// type: trigger.type,
// bufferTime: trigger.bufferTime || null,
// });
// triggerRefs.push({
// _id: triggerDoc._id,
// ...trigger,
// });
// }
// }
// pointRefs.push({
// pointuuid: point.uuid,
// position: point.position || [],
// rotation: point.rotation || [],
// actions: actionRefs,
// triggers: triggerRefs,
// connections: point.connections || null,
// });
// }
// }
// // Check if product flow exists
// const existingproductData = await productFlowModel(organization).findOne({
// _id: productID,
// });
// let result;
// if (existingproductData) {
// // Update existing product flow
// result = await productFlowModel(organization).findOneAndUpdate(
// { _id: productID },
// {
// $push: {
// ProductData: {
// AssetName: modelName,
// Assetuuid: modelUuid,
// paths: {
// Points: pointRefs,
// },
// isArchive: false,
// },
// },
// },
// { new: true }
// );
// } else {
// // Create new product flow
// result = await productFlowModel(organization).create({
// _id: productID,
// productName: productName,
// ProductData: [
// {
// AssetName: modelName,
// Assetuuid: modelUuid,
// paths: {
// Points: pointRefs,
// },
// isArchive: false,
// },
// ],
// eventType: eventData?.type || null,
// speed: eventData?.speed || null,
// });
// }
// res.status(201).json({
// message: "Product flow processed successfully",
// data: result,
// });
// } catch (error) {
// console.error("Error creating flooritems:", error);
// res.status(500).json({ message: "Failed to create flooritems" });
// }
// }
// static async pointActionList(req: Request, res: Response): Promise<any> {}
// static async productpathsList(req: Request, res: Response): Promise<any> {
// try {
// const { organization } = req.params;
// const productFlowList = await productFlowModel(organization)
// .find()
// .select("ProductData productName -_id")
// .exec();
// const formattedData = await Promise.all(
// productFlowList.map(async (item) => ({
// productName: item.productName,
// paths: await Promise.all(
// item.ProductData.map(async (data: any) => ({
// Points: await Promise.all(
// data.paths.Points.map(async (point: any) => {
// const actions = await actionModel(organization)
// .find({ _id: { $in: point.actions } })
// .select(
// "-_id -pointsUUID -isArchive -createdAt -updatedAt -__v"
// )
// .lean();
// const triggers = await triggerModel(organization)
// .find({ _id: { $in: point.triggers } })
// .select(
// "-_id -pointsUUID -isArchive -createdAt -updatedAt -__v"
// )
// .lean();
// return {
// connections: point.connections || null,
// pointuuid: point.pointuuid,
// actions: actions,
// triggers: triggers,
// position: point.position,
// rotation: point.rotation,
// };
// })
// ),
// }))
// ),
// }))
// );
// return res.status(200).json(formattedData);
// } catch (error) {
// console.error("Error get flooritems:", error);
// res.status(500).json({ error: "Failed to get flooritems" });
// }
// }
// // static async deleteFloorItems(req: Request, res: Response): Promise<any> {
// // try {
// // const { modelUuid, modelName, organization } = req.body;
// // const findValue = await assetModel(organization).findOneAndDelete({
// // modelUuid: modelUuid,
// // modelName: modelName,
// // isArchive: false,
// // });
// // if (!findValue) {
// // res.status(200).json("user not found");
// // } else {
// // res.status(201).json(findValue);
// // }
// // } catch (error) {
// // console.error("Error get flooritems:", error);
// // res.status(500).json({ error: "Failed to get flooritems" });
// // }
// // }
// // static async updateAssetPositionRotation(
// // req: Request,
// // res: Response
// // ): Promise<any> {
// // try {
// // const {
// // modelUuid,
// // modelName,
// // position,
// // modelfileID,
// // rotation,
// // isLocked,
// // isVisible,
// // organization,
// // // eventData, // Optional
// // } = req.body;
// // const existingAsset = await assetModel(organization).findOne({
// // modelUuid: modelUuid,
// // isArchive: false,
// // });
// // if (!existingAsset) return res.send("Asset not found");
// // const updateAsset = await assetModel(organization).updateMany(
// // { modelUuid: modelUuid, modelName: modelName, isArchive: false },
// // {
// // position: position,
// // rotation: rotation,
// // isVisible: isVisible,
// // isLocked: isLocked,
// // }
// // );
// // if (updateAsset)
// // return res.status(200).json({ message: "Asset updated successfully" });
// // } catch (error: any) {
// // return res.send(error.message);
// // }
// // }
// // static async updateActionsDatas(req: Request, res: Response) {}
// }

441
src/api-server/controller/simulation/productService.ts
View File

@@ -2,256 +2,237 @@ import { Request, Response } from "express";
import ProductModel from "../../../shared/model/simulation/productModel.ts";
import EventsDataModel from "../../../shared/model/simulation/eventsDataModel.ts";
export class productFlowservice {
static async productAdd(req: Request, res: Response): Promise<any> {
try {
const { productName, productId, eventDatas, organization } = req.body;
if (!organization) {
return res
.json({ message: "organization not found" });
export class ProductFlowservice {
static async productAdd(req: Request, res: Response): Promise<any> {
try {
const { productName, productId, eventDatas, organization } = req.body;
if (!organization) {
return res.json({ message: "organization not found" });
}
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
});
if (existingProduct) {
const existingEventData = await EventsDataModel(organization).findOne({
productId: productId,
modelUuid: eventDatas.modelUuid,
isArchive: false,
});
if (existingEventData) {
await EventsDataModel(organization).findOneAndUpdate(
{
modelUuid: eventDatas.modelUuid,
productId: productId,
isArchive: false,
},
{
modelUuid: eventDatas?.modelUuid,
modelName: eventDatas?.modelName,
position: eventDatas?.position,
rotation: eventDatas?.rotation,
type: eventDatas?.type,
speed: eventDatas?.speed,
point: eventDatas?.point,
points: eventDatas?.points,
}
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
})
if (existingProduct) {
const existingEventData = await EventsDataModel(organization).findOne(
{
productId: productId,
modelUuid: eventDatas.modelUuid,
isArchive: false,
})
if (existingEventData) {
const updateEventData = await EventsDataModel(organization).findOneAndUpdate(
{
modelUuid: eventDatas.modelUuid,
productId: productId,
isArchive: false,
}
, {
modelUuid: eventDatas?.modelUuid,
modelName: eventDatas?.modelName,
position: eventDatas?.position,
rotation: eventDatas?.rotation,
type: eventDatas?.type,
speed: eventDatas?.speed,
point: eventDatas?.point,
points: eventDatas?.points,
})
return res
.status(200)
.json({ message: "EventData updated successfully" });
} else {
const addEventData = await EventsDataModel(organization).create({
productId: productId,
modelUuid: eventDatas?.modelUuid,
modelName: eventDatas?.modelName,
position: eventDatas?.position,
rotation: eventDatas?.rotation,
type: eventDatas?.type,
speed: eventDatas?.speed,
point: eventDatas?.point,
points: eventDatas?.points
})
return res
.status(201)
.json({ message: "EventData add successfully" });
}
} else {
const newProduct = await ProductModel(organization).create({
productId: productId,
productName: productName
})
if (newProduct) {
if (eventDatas) {
const addEventData = await EventsDataModel(organization).create({
productId: productId,
modelUuid: eventDatas?.modelUuid,
modelName: eventDatas?.modelName,
position: eventDatas?.position,
rotation: eventDatas?.rotation,
type: eventDatas?.type,
speed: eventDatas?.speed,
point: eventDatas?.point,
points: eventDatas?.points,
})
}
}
return res
.status(201)
.json({ message: "Product created successfully" });
}
} catch (error) {
res.status(500).json({ message: "Failed to create product" });
);
return res
.status(200)
.json({ message: "EventData updated successfully" });
} else {
await EventsDataModel(organization).create({
productId: productId,
modelUuid: eventDatas?.modelUuid,
modelName: eventDatas?.modelName,
position: eventDatas?.position,
rotation: eventDatas?.rotation,
type: eventDatas?.type,
speed: eventDatas?.speed,
point: eventDatas?.point,
points: eventDatas?.points,
});
return res
.status(201)
.json({ message: "EventData add successfully" });
}
}
static async getProductDatas(req: Request, res: Response): Promise<any> {
try {
const { productId, organization } = req.query
if (typeof productId !== "string" || typeof organization !== "string") {
return res.status(400).json({ message: "Missing or invalid query parameters" });
}
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
})
if (!existingProduct)
return res.status(404).json({ message: "Product not found" });
const existingEventDatas = await EventsDataModel(organization).find({ productId: productId }).select("-productId")
return res
.status(200)
.json(existingEventDatas);
} catch (error) {
res.status(500).json({ message: "Failed to get product" });
} else {
const newProduct = await ProductModel(organization).create({
productId: productId,
productName: productName,
});
if (newProduct) {
if (eventDatas) {
await EventsDataModel(organization).create({
productId: productId,
modelUuid: eventDatas?.modelUuid,
modelName: eventDatas?.modelName,
position: eventDatas?.position,
rotation: eventDatas?.rotation,
type: eventDatas?.type,
speed: eventDatas?.speed,
point: eventDatas?.point,
points: eventDatas?.points,
});
}
}
return res
.status(201)
.json({ message: "Product created successfully" });
}
} catch (error) {
res.status(500).json({ message: "Failed to create product" });
}
static async productDataDelete(req: Request, res: Response): Promise<any> {
try {
const { productId, organization } = req.query
if (typeof productId !== "string" || typeof organization !== "string") {
return res.status(400).json({ message: "Missing or invalid query parameters" });
}
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
})
}
static async getProductDatas(req: Request, res: Response): Promise<any> {
try {
const { productId, organization } = req.query;
if (typeof productId !== "string" || typeof organization !== "string") {
return res
.status(400)
.json({ message: "Missing or invalid query parameters" });
}
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
});
if (!existingProduct)
return res.status(404).json({ message: "Product not found" });
if (!existingProduct)
return res.status(404).json({ message: "Product not found" });
const productDelete = await ProductModel(organization).findOneAndUpdate(
{ productId: productId },
{
isArchive: true,
}, { new: true }
)
const existingEventDatas = await EventsDataModel(organization).find({ productId: productId })
if (existingEventDatas) {
for (const event of existingEventDatas) {
await EventsDataModel(organization).updateMany(
{ productId },
{ $set: { isArchive: true } }
);
}
}
return res.status(201).json({ message: "product deleted successfully" });
} catch (error) {
res.status(500).json({ message: "Failed to delete product" });
}
const existingEventDatas = await EventsDataModel(organization)
.find({ productId: productId })
.select("-productId");
return res.status(200).json(existingEventDatas);
} catch (error) {
res.status(500).json({ message: "Failed to get product" });
}
static async EventDataDelete(req: Request, res: Response): Promise<any> {
try {
const { productId, organization, modelUuid } = req.body
}
static async productDataDelete(req: Request, res: Response): Promise<any> {
try {
const { productId, organization } = req.query;
if (typeof productId !== "string" || typeof organization !== "string") {
return res
.status(400)
.json({ message: "Missing or invalid query parameters" });
}
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
});
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
})
if (!existingProduct)
return res.status(404).json({ message: "Product not found" });
const existingEventDatas = await EventsDataModel(organization).findOneAndUpdate(
{ productId: productId, modelUuid: modelUuid }, {
isArchive: true,
}, { new: true }
)
return res.status(201).json({ message: "EventData deleted successfully" });
} catch (error) {
res.status(500).json({ message: "Failed to delete Eventdata" });
}
if (!existingProduct)
return res.status(404).json({ message: "Product not found" });
await ProductModel(organization).findOneAndUpdate(
{ productId: productId },
{
isArchive: true,
},
{ new: true }
);
const existingEventDatas = await EventsDataModel(organization).find({
productId: productId,
});
if (existingEventDatas) {
// for (const event of existingEventDatas) {
await EventsDataModel(organization).updateMany(
{ productId },
{ $set: { isArchive: true } }
);
// }
}
return res.status(201).json({ message: "product deleted successfully" });
} catch (error) {
res.status(500).json({ message: "Failed to delete product" });
}
static async AllProductDatas(req: Request, res: Response): Promise<any> {
try {
const { organization } = req.params
}
static async EventDataDelete(req: Request, res: Response): Promise<any> {
try {
const { productId, organization, modelUuid } = req.body;
if (!organization) {
return res
.json({ message: "organization not found" });
}
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
});
const existingProduct = await ProductModel(organization).find({
isArchive: false,
})
if (!existingProduct) {
return res.status(404).json({ message: 'No products found' });
}
const result = [];
if (!existingProduct)
return res.status(404).json({ message: "Product not found" });
for (const product of existingProduct) {
// Fetch events data for each product, excluding productId field
const eventDatas = await EventsDataModel(organization)
.find({ productId: product.productId, isArchive: false })
.select("-productId -isArchive -createdAt -updatedAt -__v -_id");
// Combine product and event data
result.push({
// product: {
productName: product.productName,
productId: product.productId,
eventDatas,
// },
});
}
// Return combined data
return res.status(200).json(result);
} catch (error) {
res.status(500).json({ message: "Failed to get Allproduct" });
}
await EventsDataModel(organization).findOneAndUpdate(
{ productId: productId, modelUuid: modelUuid },
{
isArchive: true,
},
{ new: true }
);
return res
.status(201)
.json({ message: "EventData deleted successfully" });
} catch (error) {
res.status(500).json({ message: "Failed to delete Eventdata" });
}
static async productRename(req: Request, res: Response): Promise<any> {
}
static async AllProductDatas(req: Request, res: Response): Promise<any> {
try {
const { organization } = req.params;
try {
const { productId, productName, organization } = req.body
if (!organization) {
return res.json({ message: "organization not found" });
}
const existingProduct = await ProductModel(organization).find({
isArchive: false,
});
if (!existingProduct) {
return res.status(404).json({ message: "No products found" });
}
const result = [];
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
})
for (const product of existingProduct) {
const eventDatas = await EventsDataModel(organization)
.find({ productId: product.productId, isArchive: false })
.select("-productId -isArchive -createdAt -updatedAt -__v -_id");
if (!existingProduct)
return res.status(404).json({ message: "Product not found" });
const productDelete = await ProductModel(organization).findOneAndUpdate(
{ productId: productId },
{
productName: productName,
}, { new: true }
)
return res.status(201).json({ message: "product Rename successfully" });
} catch (error) {
res.status(500).json({ message: "Failed to product Rename" });
}
result.push({
// product: {
productName: product.productName,
productId: product.productId,
eventDatas,
// },
});
}
return res.status(200).json(result);
} catch (error) {
res.status(500).json({ message: "Failed to get Allproduct" });
}
}
static async productRename(req: Request, res: Response): Promise<any> {
try {
const { productId, productName, organization } = req.body;
const existingProduct = await ProductModel(organization).findOne({
productId: productId,
isArchive: false,
});
if (!existingProduct)
return res.status(404).json({ message: "Product not found" });
await ProductModel(organization).findOneAndUpdate(
{ productId: productId },
{
productName: productName,
},
{ new: true }
);
return res.status(201).json({ message: "product Rename successfully" });
} catch (error) {
res.status(500).json({ message: "Failed to product Rename" });
}
}
}

31
src/api-server/controller/user-Controller.ts
View File

@@ -1,12 +1,9 @@
import { Request, Response } from "express";
import { Server } from 'http';
import userModel from "../../shared/model/user-Model.ts";
import { isSharedArrayBuffer } from "util/types";
import {hashGenerate,hashValidator} from "../../shared/security/Hasing.ts"
// import {hashGenerate} from '../security/Hasing'
let serverAlive = true;
export class user {
export class User {
static async signup(req: Request, res: Response) {
try {
let role;
@@ -43,7 +40,6 @@ export class user {
try {
let role;
const { email, password,organization } = req.body;
// console.log(' req.body: ', req.body);
const existingMail = await userModel(organization).findOne({
email:email
@@ -57,7 +53,6 @@ export class user {
password,
hashedpassword
)
// console.log('checkpassword: ', checkpassword);
if (checkpassword) {
// const tokenValidation=await tokenGenerator(existingMail.email)
res.status(200).send({
@@ -77,27 +72,5 @@ export class user {
res.status(500).send(error);
}
}
// static async checkserverHealth(server:Server,organization: string){
// try {
// if (server.listening) {
// console.log('Server is running');
// serverAlive = true;
// // Update all users to online status
// } else {
// // await userModel(organization).updateMany({}, { activeStatus: "offline" }); // Replace `activeStatus` with your actual field
// throw new Error('Server is not running');
// }
// } catch (error:any) {
// console.error('Server health check failed:', error.message);
// serverAlive = false;
// // Update all users to offline status
// // await userModel(organization).updateMany({}, { activeStatus: "offline" });
// }
// }
}
// export const startHealthCheck = (server: Server, organization: string) => {
// setInterval(() => user.checkserverHealth(server, organization), 5000);
// };

2
src/api-server/controller/visualization/3dWidgetService.ts
View File

@@ -1,7 +1,7 @@
import { Request, Response } from "express";
import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
import widget3dModel from "../../../shared/model/vizualization/3dwidget.ts";
export class widget3dService {
export class Widget3dService {
static async add3Dwidget(req: Request, res: Response): Promise<any> {
try {
const { organization, widget, zoneId } = req.body;

67
src/api-server/controller/visualization/floatWidgetService.ts
View File

@@ -1,7 +1,7 @@
import { Request, Response } from "express";
import floatWidgetModel from "../../../shared/model/vizualization/floatWidget.ts";
import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
export class floatWidgetService {
export class FloatWidgetService {
static async addfloatWidget(req: Request, res: Response): Promise<any> {
try {
const { organization, widget, zoneId } = req.body;
@@ -19,9 +19,7 @@ export class floatWidgetService {
zoneId: zoneId,
});
if (existingFloatWidget) {
const updateFloatWidget = await floatWidgetModel(
organization
).findOneAndUpdate(
await floatWidgetModel(organization).findOneAndUpdate(
{
floatWidgetID: widget.id,
isArchive: false,
@@ -141,65 +139,4 @@ export class floatWidgetService {
return res.status(500).send(error.message);
}
}
// static async updatewidget(req: Request, res: Response): Promise<any> {
// try {
// const { organization, widgetID, values } = req.body;
// const findwidget = await widgetSchema(organization).findOne({
// widgetID: widgetID,
// isArchive: false,
// });
// if (!findwidget)
// return res.status(404).send({ message: "Data not found" });
// const updateData = {
// widgetName: values.widgetName,
// widgetSide: values.widgetSide, // Fixed typo from widgetside to widgetSide
// elementType: values.type,
// Data: {
// measurement: values.Data.measurement,
// duration: values.Data.duration,
// },
// elementColor: values.color,
// fontFamily: values.fontFamily,
// fontStyle: values.fontStyle,
// fontWeight: values.fontWeight,
// isArchive: false,
// };
// const changedWidget = await widgetSchema(organization).findOneAndUpdate(
// { widgetID: widgetID, isArchive: false },
// updateData,
// {
// new: true,
// upsert: true,
// setDefaultsOnInsert: true,
// }
// );
// return res.status(200).json({
// message: "Widget updated successfully",
// });
// } catch (error: any) {
// return res.status(500).send(error.message);
// }
// }
// static async getDatafromWidget(req: Request, res: Response): Promise<any> {
// const { organization, widgetID } = req.params;
// try {
// const existingWidget = await widgetSchema(organization)
// .findOne({
// widgetID: widgetID,
// isArchive: false,
// })
// .select("Data -_id");
// const Datastructure = {
// measurements: existingWidget.Data.measurements || {},
// duration: existingWidget.Data.duration || "1h",
// };
// if (existingWidget) return res.status(200).json({ Data: Datastructure });
// } catch (error: any) {
// return res.status(500).send(error.message);
// }
// }
}

17
src/api-server/controller/visualization/panelService.ts
View File

@@ -3,12 +3,12 @@ import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
export class panelService {
export class PanelService {
static async AddPanel(req: Request, res: Response): Promise<any> {
try {
const organization = req.body.organization;
const zoneId = req.body.zoneId;
const panelName = req.body.panelName;
// const panelName = req.body.panelName;
const panelOrder = req.body.panelOrder;
const findZone = await zoneSchema(organization).findOne({
zoneId: zoneId,
@@ -18,7 +18,7 @@ export class panelService {
if (!findZone) {
return res.status(404).json({ message: "Zone not found" });
}
const updatezone = await zoneSchema(organization).findOneAndUpdate(
await zoneSchema(organization).findOneAndUpdate(
{ zoneId: zoneId, isArchive: false },
{ panelOrder: panelOrder },
{ new: true }
@@ -52,10 +52,6 @@ export class panelService {
message: "No new panels were created. All panels already exist.",
});
}
// const IDdata = createdPanels.map((ID: any) => {
// return ID._id;
// });
createdPanels;
return res.status(201).json({
message: "Panels created successfully",
panelID: createdPanels,
@@ -66,7 +62,6 @@ export class panelService {
}
static async deletePanel(req: Request, res: Response): Promise<any> {
try {
console.log("req.body: ", req.body);
const { organization, panelName, zoneId } = req.body;
const existingZone = await zoneSchema(organization).findOne({
zoneId: zoneId,
@@ -81,7 +76,7 @@ export class panelService {
});
if (!existingPanel)
return res.status(409).json({ message: "Panel Already Deleted" });
const updatePanel = await panelSchema(organization).findOneAndUpdate(
await panelSchema(organization).findOneAndUpdate(
{ _id: existingPanel._id, isArchive: false },
{ isArchive: true },
{ new: true }
@@ -96,12 +91,11 @@ export class panelService {
}
if (existingZone.panelOrder.includes(existingPanel.panelName)) {
const index1 = existingZone.panelOrder.indexOf(existingPanel.panelName);
existingZone.panelOrder.indexOf(existingPanel.panelName);
const zonepanelname = await zoneSchema(organization).updateOne(
{ _id: existingZone._id },
{ $pull: { panelOrder: existingPanel.panelName } }
);
console.log("zonepanelname: ", zonepanelname);
}
return res.status(200).json({ message: "Panel deleted successfully" });
@@ -111,7 +105,6 @@ export class panelService {
}
static async clearPanel(req: Request, res: Response): Promise<any> {
try {
console.log("req.body;: ", req.body);
const { organization, panelName, zoneId } = req.body;
const existingZone = await zoneSchema(organization).findOne({
zoneId: zoneId,

4
src/api-server/controller/visualization/templateService.ts
View File

@@ -5,7 +5,7 @@ import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
import floatWidgetModel from "../../../shared/model/vizualization/floatWidget.ts";
export class templateService {
export class TemplateService {
static async AddTemplate(req: Request, res: Response): Promise<any> {
try {
const {
@@ -18,7 +18,6 @@ export class templateService {
// snapshot,
// floatWidgets,
} = req.body;
// console.log("req.body: ", req.body);
const existingTemplate = await templateModel(organization).findOne({
templateID: template.id,
isArchive: false,
@@ -181,7 +180,6 @@ export class templateService {
}
static async Deletezone(req: Request, res: Response): Promise<any> {
try {
console.log("req.params: ", req.params);
const { organization, templateID } = req.params;
const existingTemplate = await templateModel(organization).findOne({
templateID: templateID,

16
src/api-server/controller/visualization/widgetService.ts
View File

@@ -2,11 +2,9 @@ import { Request, Response } from "express";
import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
export class widgetService {
export class WidgetService {
static async addWidget(req: Request, res: Response): Promise<any> {
try {
// console.log("req.body: ", req.body);
console.log("req.body: ", req.body);
const {
organization,
// panel,
@@ -34,7 +32,6 @@ export class widgetService {
isArchive: false,
// widgetOrder: widget.widgetOrder,
});
// console.log('existingWidget: ', widget.data.measurements);
if (existingWidget) {
const updateWidget = await widgetSchema(
organization
@@ -58,16 +55,13 @@ export class widgetService {
},
{ upsert: true, new: true } // Upsert: create if not exists, new: return updated document
);
console.log("updateWidget: ", updateWidget);
if (!updateWidget) {
return res.json({ message: "Widget update unsuccessful" });
}
return res
.status(200)
.json({ message: "Widget updated successfully" });
// return res
// .status(409)
// .json({ message: "Widget already exist for the widgetID" });
}
const newWidget = await widgetSchema(organization).create({
widgetID: widget.id,
@@ -100,7 +94,6 @@ export class widgetService {
static async deleteWidget(req: Request, res: Response): Promise<any> {
try {
const { widgetID, organization, zoneId } = req.body;
console.log(" req.body: ", req.body);
const findWidget = await widgetSchema(organization).findOne({
zoneId: zoneId,
widgetID: widgetID,
@@ -115,7 +108,7 @@ export class widgetService {
if (widgetData) {
// Find all widgets in the same panel and sort them by widgetOrder
const widgets = await widgetSchema(organization).find({
await widgetSchema(organization).find({
panelID: findWidget.panelID,
zoneId: zoneId,
isArchive: false,
@@ -146,7 +139,6 @@ export class widgetService {
static async updatewidget(req: Request, res: Response): Promise<any> {
try {
console.log("req.body: ", req.body);
const { organization, widgetID, values } = req.body;
const findwidget = await widgetSchema(organization).findOne({
widgetID: widgetID,
@@ -169,7 +161,7 @@ export class widgetService {
isArchive: false,
};
const changedWidget = await widgetSchema(organization).findOneAndUpdate(
await widgetSchema(organization).findOneAndUpdate(
{ widgetID: widgetID, isArchive: false },
updateData,
{

3
src/api-server/main.ts
View File

@@ -1,10 +1,8 @@
import app from './app.ts';
import http from 'http';
import ip from 'ip';
// import { startHealthCheck } from './controller/user-Controller';
import swaggerUi from 'swagger-ui-express';
import mongoAdminCreation from '../shared/security/mongosecurity.ts';
import fs from 'fs';
const server = http.createServer(app);
@@ -34,6 +32,5 @@ const PORT = process.env.API_PORT
server.listen(PORT, () => {
console.log(`API-Server running on http://localhost:${PORT}`);
console.log(`Swagger UI available at http://localhost:${PORT}/api-docs`);
// console.log(`Server is also accessible on IP address: ${ip.address()}`);
});

52
src/shared/model/assets/flooritems-Model.ts
View File

@@ -1,57 +1,35 @@
import mongoose, { Document, Schema } from 'mongoose';
import MainModel from '../../connect/mongoose.ts';
import { Document, Schema } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
// Interface for TypeScript with PascalCase
export interface floorItenms extends Document {
export interface FloorItems 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
const floorItemsSchema: Schema = new Schema({
modelUuid: { type: String },
modelfileID: { type: String },
modelName: { type: String },
position: { type: Array},
isLocked:{type:Boolean},
isVisible:{type:Boolean},
position: { type: Array },
isLocked: { type: Boolean },
isVisible: { type: Boolean },
rotation: {
x: { type: Number, required: true },
y: { type: Number, required: true },
z: { type: Number, required: true }
}
z: { type: Number, required: true },
},
});
// Model for MongoDB collection
// const cameraModel = model<Camera>("Camera", cameraSchema);
// export default cameraModel;
// const floorItemsModel = (db: string) => {
// const mongoUrl = process.env.MONGO_URI || '';
// if (!mongoUrl) {
// throw new Error('MONGO_URI environment variable is not set');
// }
// // Connect to the database
// const dbConnection = mongoose.createConnection(mongoUrl, {
// dbName: db, // Specify the database name here
// serverSelectionTimeoutMS: 30000,
// });
// return dbConnection.model<floorItenms>('floorItenms', floorItenmsSchema,`floorItenms`);
// }
// export default floorItemsModel;
const floorItemsModel = (db:string) => {
return MainModel(db, "floorItems", floorItemsSchema, "floorItems")
const floorItemsModel = (db: string) => {
return MainModel(db, "floorItems", floorItemsSchema, "floorItems");
};
export default floorItemsModel;
export default floorItemsModel;

48
src/shared/model/assets/wallitems-Model.ts
View File

@@ -1,48 +0,0 @@
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
modelfileID: string;
type: string
csgposition: []
csgscale: []
position: []
quaternion: []
scale: []
}
// Define the Mongoose Schema
const wallItemsSchema: Schema = new Schema({
modelUuid: { type: String},
modelfileID: { type: String},
modelName: { type: String},
type: { type: String },
csgposition: { type: Array},
csgscale: { type: Array,},
position: { type: Array },
quaternion: { type: Array},
scale: { type: Array}
});
// const wallItenmModel = (db: string) => {
// const mongoUrl = process.env.MONGO_URI || '';
// if (!mongoUrl) {
// throw new Error('MONGO_URI environment variable is not set');
// }
// // Connect to the database
// const dbConnection = mongoose.createConnection(mongoUrl, {
// dbName: db, // Specify the database name here
// serverSelectionTimeoutMS: 30000,
// });
// return dbConnection.model<wallitenms>('wallitenms', wallItenmsSchema, `wallitenms`);
// }
// export default wallItenmModel;
const wallItenmModel = (db:string) => {
return MainModel(db, "wallitems", wallItemsSchema, "wallitems")
};
export default wallItenmModel;

99
src/shared/model/builder/assets/asset-Model.ts
View File

@@ -1,4 +1,4 @@
import mongoose, { Document, Schema } from "mongoose";
import { Document, Schema } from "mongoose";
import MainModel from "../../../connect/mongoose.ts";
interface ICommonBase {
@@ -18,7 +18,7 @@ interface IPoint extends ICommonBase {
rotation: [number, number, number];
};
}
export interface assetData extends Document {
export interface AssetData extends Document {
modelUuid: string;
modelfileID: string;
modelName: string;
@@ -43,7 +43,6 @@ const assetDataSchema: Schema = new Schema({
modelfileID: { type: String },
modelName: { type: String },
type: { type: String },
// points: { type: Schema.Types.Mixed },
position: { type: Array },
rotation: {
x: { type: Number },
@@ -58,101 +57,7 @@ const assetDataSchema: Schema = new Schema({
},
});
// export default floorItemsModel;
const assetModel = (db: string) => {
return MainModel(db, "Assets", assetDataSchema, "Assets");
};
export default assetModel;
// import mongoose, { Document, Schema } from "mongoose";
// import MainModel from "../../../connect/mongoose.ts";
// export interface assetData extends Document {
// modelUuid: string;
// modelfileID: string;
// modelName: string;
// isLocked: boolean;
// type: string;
// isVisible: boolean;
// isArchive: false;
// // position: [];
// // rotation: {
// // x: number;
// // y: number;
// // z: number;
// // };
// points: {
// uuid: string;
// position: [];
// rotation: [];
// actions: [mongoose.Types.ObjectId];
// triggers: [mongoose.Types.ObjectId];
// connections: {
// source: {
// modelUUID: string;
// pointUUID: string;
// };
// targets: [
// {
// modelUUID: string;
// pointUUID: string;
// }
// ];
// }[];
// }[];
// position: [];
// // rotation: [];
// rotation: {
// x: number;
// y: number;
// z: number;
// };
// speed: number | string;
// }
// // Define the Mongoose Schema
// const assetDataSchema: Schema = new Schema({
// isArchive: { type: Boolean, default: false },
// modelUuid: { type: String },
// modelfileID: { type: String },
// modelName: { type: String },
// type: { type: String },
// // assetPosition: { type: Array },
// points: [
// {
// uuid: { type: String },
// position: { type: Array },
// rotation: { type: Array },
// actions: [{ type: mongoose.Schema.Types.ObjectId, ref: "Actions" }],
// triggers: [{ type: mongoose.Schema.Types.ObjectId, ref: "Triggers" }],
// connections: {
// source: {
// modelUUID: { type: String },
// pointUUID: { type: String },
// },
// targets: [
// {
// modelUUID: { type: String },
// pointUUID: { type: String },
// },
// ],
// },
// },
// ],
// position: { type: Array },
// // rotation: { type: Array},
// rotation: {
// x: { type: Number },
// y: { type: Number },
// z: { type: Number },
// },
// speed: { type: Schema.Types.Mixed },
// isLocked: { type: Boolean },
// isVisible: { type: Boolean },
// });
// // export default floorItemsModel;
// const assetModel = (db: string) => {
// return MainModel(db, "Assets", assetDataSchema, "Assets");
// };
// export default assetModel;

341
src/shared/model/builder/assets/assetPoint-Model.ts
View File

@@ -1,31 +1,6 @@
import mongoose, { Schema, Document } from "mongoose";
import { Schema, Document } from "mongoose";
import MainModel from "../../../connect/mongoose.ts";
// Common Interfaces
// interface ITriggerConveyor {
// uuid: string;
// name: string;
// type: string;
// isUsed: boolean;
// bufferTime: number;
// }
// interface ITriggerVehicle {
// uuid: string;
// name: string;
// type: string;
// isUsed: boolean;
// }
// interface IConnectionConveyor {
// source: { modelUUID: string; pointUUID: string };
// targets: { modelUUID: string; pointUUID: string }[];
// }
// interface IConnectionVehicle {
// source: { modelUUID: string; pointUUID: string };
// targets: { modelUUID: string; pointUUID: string }[];
// }
// Point Types
interface IPointBase {
uuid: string;
position: number[];
@@ -127,322 +102,8 @@ const PointSchema = new Schema<IPointModel>(
{ timestamps: true }
);
// Model Creation
const pointModel = (db: string) => {
return MainModel(db, "Points", PointSchema, "Points");
};
export default pointModel;
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// import mongoose, { Schema, Document } from "mongoose";
// import MainModel from "../../../connect/mongoose.ts";
// interface IActionConveyor {
// uuid: string;
// name: string;
// type: string;
// material: string;
// delay: number | string;
// spawnInterval: number | string;
// spawnMaterial: string;
// isUsed: boolean;
// hitCount: number;
// start: string;
// end: string;
// buffer: number;
// }
// interface ITriggers {
// uuid: string;
// name: string;
// type: string;
// isUsed: boolean;
// bufferTime: number;
// }
// interface IConnection {
// source: { modelUUID: string; pointUUID: string };
// targets: { modelUUID: string; pointUUID: string }[];
// }
// interface IActionVehicle {
// uuid: string;
// name: string;
// type: string;
// isUsed: boolean;
// hitCount: number;
// start: string;
// end: string;
// buffer: number;
// }
// interface IPointConveyor {
// uuid: string;
// position: number[];
// rotation: number[];
// actions: IActionConveyor[];
// triggers: ITriggers[];
// connections: IConnection;
// }
// interface IPointVehicle {
// uuid: string;
// position: number[];
// actions: IActionVehicle[];
// triggers: ITriggers[];
// connections: IConnection;
// }
// interface IBaseModel extends Document {
// modelfileID: string;
// type: "Conveyor" | "Vehicle";
// points: IPointConveyor[] | IPointVehicle;
// }
// const PointconveyorSchema = new Schema<IPointConveyor>({
// uuid: { type: String, required: true },
// position: { type: [Number] },
// rotation: { type: [Number] },
// actions: [
// {
// uuid: { type: String, default: "" },
// name: { type: String },
// type: { type: String },
// material: { type: String },
// delay: { type: Schema.Types.Mixed },
// spawnInterval: { type: Schema.Types.Mixed },
// spawnMaterial: { type: String },
// isUsed: { type: Boolean },
// },
// ],
// triggers: [
// {
// uuid: { type: String, default: "" },
// name: { type: String },
// type: { type: String },
// bufferTime: { type: Number },
// isUsed: { type: Boolean },
// },
// ],
// connections: {
// source: {
// modelUUID: { type: String },
// pointUUID: { type: String },
// },
// targets: [
// {
// modelUUID: { type: String },
// pointUUID: { type: String },
// },
// ],
// },
// });
// const PointvehicleSchema = new Schema<IPointVehicle>({
// uuid: { type: String, required: true },
// position: { type: [Number] },
// actions: [
// {
// uuid: { type: String, default: "" },
// name: { type: String },
// type: { type: String },
// isUsed: { type: Boolean },
// hitCount: { type: String },
// start: { type: String },
// end: { type: String },
// buffer: { type: String },
// },
// ],
// triggers: [
// {
// uuid: { type: String, default: "" },
// name: { type: String },
// type: { type: String },
// bufferTime: { type: Number },
// isUsed: { type: Boolean },
// },
// ],
// connections: {
// source: {
// modelUUID: { type: String },
// pointUUID: { type: String },
// },
// targets: [
// {
// modelUUID: { type: String },
// pointUUID: { type: String },
// },
// ],
// },
// });
// const BaseSchema = new Schema<IBaseModel>(
// {
// modelfileID: { type: String },
// type: { type: String, enum: ["Conveyor", "Vehicle"] },
// points: {
// type: Schema.Types.Mixed,
// required: true,
// },
// },
// { discriminatorKey: "type", timestamps: true }
// );
// const pointModel = (db: string) => {
// const BasePointModel = MainModel(db, "Points", BaseSchema, "Points");
// const ConveyorModel = BasePointModel.discriminator(
// "Conveyor",
// new Schema({
// points: [PointconveyorSchema],
// })
// );
// const VehicleModel = BasePointModel.discriminator(
// "Vehicle",
// new Schema({
// points: PointvehicleSchema,
// })
// );
// return { ConveyorModel, VehicleModel };
// };
// export default pointModel;
// ===
// const pointModel = (db: string) => {
// const BasePointModel =
// mongoose.models.Points || MainModel(db, "Points", BaseSchema, "Points");
// if (!BasePointModel.discriminators?.Conveyor) {
// BasePointModel.discriminator(
// "Conveyor",
// new Schema({
// points: [PointconveyorSchema],
// })
// );
// }
// if (!BasePointModel.discriminators?.Vehicle) {
// BasePointModel.discriminator(
// "Vehicle",
// new Schema({
// points: PointvehicleSchema,
// })
// );
// }
// const ConveyorModel =
// mongoose.models.Conveyor || BasePointModel.discriminators?.Conveyor;
// const VehicleModel =
// mongoose.models.Vehicle || BasePointModel.discriminators?.Vehicle;
// return { ConveyorModel, VehicleModel, BasePointModel };
// };
// export default pointModel;
// ===========================================
// ===
// import mongoose, { Schema, Document } from "mongoose";
// import MainModel from "../../../connect/mongoose.ts";
// interface IAction {
// uuid: string;
// name: string;
// type: string;
// material: string;
// delay: number | string;
// spawnInterval: number | string;
// spawnMaterial: string;
// isUsed: boolean;
// hitCount: number;
// start: string;
// end: string;
// buffer: number;
// }
// interface ITriggers {
// uuid: string;
// name: string;
// type: string;
// isUsed: boolean;
// bufferTime: number;
// }
// interface IConnection {
// source: { modelUUID: string; pointUUID: string };
// targets: { modelUUID: string; pointUUID: string }[];
// }
// interface IPoint {
// uuid: string;
// position: number[];
// rotation: number[];
// actions: IAction[];
// triggers: ITriggers[];
// connections: IConnection;
// }
// interface IBaseModel extends Document {
// modelfileID: string;
// type: "Conveyor" | "Vehicle";
// points: IPoint[] | IPoint;
// }
// const PointSchema = new Schema<IPoint>({
// uuid: { type: String, required: true },
// position: { type: [Number] },
// rotation: { type: [Number] },
// actions: [
// {
// uuid: { type: String, default: "" },
// name: { type: String },
// type: { type: String },
// material: { type: String },
// delay: { type: String },
// spawnInterval: { type: String },
// spawnMaterial: { type: String },
// isUsed: { type: Boolean },
// hitCount: { type: String },
// start: { type: String },
// end: { type: String },
// buffer: { type: String },
// },
// ],
// triggers: [
// {
// uuid: { type: String, default: "" },
// name: { type: String },
// type: { type: String },
// bufferTime: { type: Number },
// isUsed: { type: Boolean },
// },
// ],
// connections: {
// source: {
// modelUUID: { type: String },
// pointUUID: { type: String },
// },
// targets: [
// {
// modelUUID: { type: String },
// pointUUID: { type: String },
// },
// ],
// },
// });
// // Base Schema
// const BaseSchema = new Schema<IBaseModel>(
// {
// modelfileID: { type: String },
// type: { type: String, enum: ["Conveyor", "Vehicle"] },
// points: {
// type: Schema.Types.Mixed,
// required: true,
// },
// },
// { discriminatorKey: "type", timestamps: true }
// );
// const pointModel = (db: string) => {
// return MainModel(db, "Points", BaseSchema, "Points");
// };
// export default pointModel;

11
src/shared/model/builder/assets/wallitems-Model.ts
View File

@@ -1,7 +1,6 @@
import mongoose, { Document, Schema } from "mongoose";
import { Document, Schema } from "mongoose";
import MainModel from "../../../connect/mongoose.ts";
// Interface for TypeScript with PascalCase
export interface wallitems extends Document {
export interface WallItems extends Document {
modelUuid: string;
modelName: string;
type: string;
@@ -12,7 +11,6 @@ export interface wallitems extends Document {
scale: [];
}
// Define the Mongoose Schema
const wallItemsSchema: Schema = new Schema({
modelUuid: { type: String, unique: true },
modelName: { type: String },
@@ -24,8 +22,7 @@ const wallItemsSchema: Schema = new Schema({
scale: { type: Array },
});
// export default wallItenmModel;
const wallItenmModel = (db: string) => {
const wallItemModel = (db: string) => {
return MainModel(db, "wallitems", wallItemsSchema, "wallitems");
};
export default wallItenmModel;
export default wallItemModel;

5
src/shared/model/builder/camera/camera-Model.ts
View File

@@ -1,7 +1,6 @@
import mongoose, { Document, Schema } from "mongoose";
import { Document, Schema } from "mongoose";
import MainModel from "../../../connect/mongoose.ts";
// Interface for TypeScript with PascalCase
export interface Camera extends Document {
userId: string;
position: {
@@ -21,7 +20,6 @@ export interface Camera extends Document {
};
}
// Define the Mongoose Schema
const cameraSchema: Schema = new Schema({
userId: { type: String },
position: {
@@ -41,7 +39,6 @@ const cameraSchema: Schema = new Schema({
},
});
// export default cameraModel
const cameraModel = (db: string) => {
return MainModel(db, "Camera", cameraSchema, "Camera");
};

24
src/shared/model/builder/environments/environments-Model.ts
View File

@@ -1,24 +0,0 @@
import mongoose, { Document, Schema } from 'mongoose';
import MainModel from '../../../connect/mongoose.ts';
// Interface for TypeScript with PascalCase
export interface environment extends Document {
userId: string;
roofVisibility: boolean
wallVisibility: boolean
}
// Define the Mongoose Schema
const environmentSchema: Schema = new Schema({
userId: { type: String, unique: true },
roofVisibility: { type: Boolean, default: false },
wallVisibility: { type: Boolean, default: false },
shadowVisibility: { type: Boolean, default: false },
});
// export default environmentModel;
const environmentModel = (db: string) => {
return MainModel(db, "environments", environmentSchema, "environments")
};
export default environmentModel;

5
src/shared/model/builder/lines/lines-Model.ts
View File

@@ -1,4 +1,4 @@
import mongoose, { Document, Schema } from "mongoose";
import mongoose from "mongoose";
import MainModel from "../../../connect/mongoose.ts";
const positionSchema = new mongoose.Schema({
x: { type: Number }, // Optional position fields
@@ -6,20 +6,17 @@ const positionSchema = new mongoose.Schema({
z: { type: Number },
});
// Define a schema for the individual line
const Vector3 = new mongoose.Schema({
position: { type: positionSchema, required: false }, // Optional position
uuid: { type: String, required: false }, // Optional uuid
});
// Define the main schema
const LineSchema = new mongoose.Schema({
layer: { type: Number, required: true }, // Layer is mandatory
line: { type: [Vector3], required: true }, // Array of line objects
type: { type: String, required: false }, // Optional type
});
// export default lineModel;
const lineModel = (db: string) => {
return MainModel(db, "lines", LineSchema, "lines");
};

37
src/shared/model/builder/lines/zone-Model.ts
View File

@@ -1,40 +1,5 @@
// 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;
import mongoose, { Schema, Document, model } from "mongoose";
import { Schema, Document } from "mongoose";
import MainModel from "../../../connect/mongoose.ts";
export interface Zone extends Document {

78
src/shared/model/camera/camera-Model.ts
View File

@@ -1,87 +1,45 @@
import mongoose, { Document, Schema } from 'mongoose';
import MainModel from '../../connect/mongoose.ts';
import { Document, Schema } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
// Interface for TypeScript with PascalCase
export interface Camera extends Document {
userId: string;
position: {
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
const cameraSchema: Schema = new Schema({
userId: { type: String },
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 },
},
});
// Model for MongoDB collection
// const cameraModel = model<Camera>("Camera", cameraSchema);
// export default cameraModel;
// const cameraModel = (db: string) => {
// const mongoUrl = process.env.MONGO_URI || '';
// if (!mongoUrl) {
// throw new Error('MONGO_URI environment variable is not set');
// }
// // Connect to the database
// const dbConnection = mongoose.createConnection(mongoUrl, {
// dbName: db, // Specify the database name here
// serverSelectionTimeoutMS: 30000,
// });
// return dbConnection.model<Camera>('Camera', cameraSchema,`Camera`);
// }
// export default cameraModel;
// const cameraModel = (db: string) => {
// const mongoUrl = process.env.MONGO_URI || '';
// if (!mongoUrl) {
// throw new Error('MONGO_URI environment variable is not set');
// }
// const dbConnection = mongoose.createConnection(mongoUrl, {
// dbName: db,
// serverSelectionTimeoutMS: 60000, // Increased timeout
// });
// dbConnection.on('error', (err) => {
// console.error(`MongoDB connection error for database ${db}:`, err);
// });
// dbConnection.once('open', () => {
// console.log(`Connected to MongoDB database: ${db}`);
// });
// return dbConnection.model<Camera>('Camera', cameraSchema, 'Camera');
// };
// export default cameraModel
const cameraModel = (db:string) => {
return MainModel(db, "Camera", cameraSchema, "Camera")
const cameraModel = (db: string) => {
return MainModel(db, "Camera", cameraSchema, "Camera");
};
export default cameraModel;
export default cameraModel;

25
src/shared/model/environments/environments-Model.ts
View File

@@ -1,7 +1,7 @@
import mongoose, { Document, Schema } from "mongoose";
import { Document, Schema } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
// Interface for TypeScript with PascalCase
export interface environment extends Document {
export interface Environment extends Document {
userId: string;
roofVisibility: boolean;
wallVisibility: boolean;
@@ -10,7 +10,6 @@ export interface environment extends Document {
limitDistance: boolean;
}
// Define the Mongoose Schema
const environmentSchema: Schema = new Schema({
userId: { type: String, unique: true },
roofVisibility: { type: Boolean, default: false },
@@ -20,24 +19,6 @@ const environmentSchema: Schema = new Schema({
limitDistance: { type: Boolean, default: true },
});
// Model for MongoDB collection
// const cameraModel = model<Camera>("Camera", cameraSchema);
// export default cameraModel;
// const environmentModel = (db: string) => {
// const mongoUrl = process.env.MONGO_URI || '';
// if (!mongoUrl) {
// throw new Error('MONGO_URI environment variable is not set');
// }
// // Connect to the database
// const dbConnection = mongoose.createConnection(mongoUrl, {
// dbName: db, // Specify the database name here
// serverSelectionTimeoutMS: 30000,
// });
// return dbConnection.model<environment>('environments', environmentSchema,`environments`);
// }
// export default environmentModel;
const environmentModel = (db: string) => {
return MainModel(db, "environments", environmentSchema, "environments");
};

2
src/shared/model/project/project-model.ts
View File

@@ -18,7 +18,7 @@ export interface Project extends Document {
const projectSchema: Schema = new Schema(
{
projectUuid: { type: String },
projectName: { type: String },
projectName: { type: String },
thumbnail: { type: String },
isArchive: { type: Boolean, default: false },
createdBy: { type: Schema.Types.ObjectId, ref: "user" },

7
src/shared/model/simulation/actionmodel.ts
View File

@@ -1,12 +1,9 @@
import mongoose, { Schema, Document, model } from "mongoose";
import { Schema, Document } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
export interface Action extends Document {
pointsUUID: string;
// actionUUID: string;
isArchive: string;
// sceneID: string;
// eventData: {
uuid: string;
name: string;
type: string;
@@ -19,13 +16,11 @@ export interface Action extends Document {
start: string;
end: string;
buffer: number;
// };
}
const actionSchema: Schema = new Schema(
{
pointsUUID: { type: String },
isArchive: { type: Boolean, default: false },
// actionUUID: { type: String },
uuid: { type: String, default: "" },
name: { type: String },
type: { type: String },

273
src/shared/model/simulation/eventsDataModel.ts
View File

@@ -1,179 +1,182 @@
// models/Product.ts
import mongoose, { Schema, Document, Types } from "mongoose";
import { Schema, Document } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
interface AssetEventSchema {
modelUuid: string;
modelName: string;
position: [number, number, number];
rotation: [number, number, number];
state: "idle" | "running" | "stopped" | "disabled" | "error";
};
modelUuid: string;
modelName: string;
position: [number, number, number];
rotation: [number, number, number];
state: "idle" | "running" | "stopped" | "disabled" | "error";
}
interface TriggerSchema {
triggerUuid: string;
triggerName: string;
triggerType: "onComplete" | "onStart" | "onStop" | "delay" | "onError";
delay: number;
triggeredAsset: {
triggeredModel: { modelName: string, modelUuid: string };
triggeredPoint: { pointName: string, pointUuid: string };
triggeredAction: { actionName: string, actionUuid: string };
} | null;
triggerUuid: string;
triggerName: string;
triggerType: "onComplete" | "onStart" | "onStop" | "delay" | "onError";
delay: number;
triggeredAsset: {
triggeredModel: { modelName: string; modelUuid: string };
triggeredPoint: { pointName: string; pointUuid: string };
triggeredAction: { actionName: string; actionUuid: string };
} | null;
}
interface ConveyorPointSchema {
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
action: {
actionUuid: string;
actionName: string;
actionType: "default" | "spawn" | "swap" | "despawn";
material: string;
delay: number | "inherit";
spawnInterval: number | "inherit";
spawnCount: number | "inherit";
triggers: TriggerSchema[];
};
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
action: {
actionUuid: string;
actionName: string;
actionType: "default" | "spawn" | "swap" | "despawn";
material: string;
delay: number | "inherit";
spawnInterval: number | "inherit";
spawnCount: number | "inherit";
triggers: TriggerSchema[];
};
}
interface VehiclePointSchema {
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
action: {
actionUuid: string;
actionName: string;
actionType: "travel";
material: string | null;
unLoadDuration: number;
loadCapacity: number;
pickUpPoint: { x: number; y: number, z: number } | null;
unLoadPoint: { x: number; y: number, z: number } | null;
triggers: TriggerSchema[];
};
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
action: {
actionUuid: string;
actionName: string;
actionType: "travel";
material: string | null;
unLoadDuration: number;
loadCapacity: number;
pickUpPoint: { x: number; y: number; z: number } | null;
unLoadPoint: { x: number; y: number; z: number } | null;
triggers: TriggerSchema[];
};
}
interface RoboticArmPointSchema {
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
actions: {
actionUuid: string;
actionName: string;
actionType: "pickAndPlace";
process: { startPoint: [number, number, number]; endPoint: [number, number, number] };
triggers: TriggerSchema[];
}[];
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
actions: {
actionUuid: string;
actionName: string;
actionType: "pickAndPlace";
process: {
startPoint: [number, number, number];
endPoint: [number, number, number];
};
triggers: TriggerSchema[];
}[];
}
interface MachinePointSchema {
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
action: {
actionUuid: string;
actionName: string;
actionType: "process";
processTime: number;
swapMaterial: string;
triggers: TriggerSchema[];
};
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
action: {
actionUuid: string;
actionName: string;
actionType: "process";
processTime: number;
swapMaterial: string;
triggers: TriggerSchema[];
};
}
interface StoragePointSchema {
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
action: {
actionUuid: string;
actionName: string;
actionType: "storage";
materials: { materialName: string; materialId: string; }[];
storageCapacity: number;
};
uuid: string;
position: [number, number, number];
rotation: [number, number, number];
action: {
actionUuid: string;
actionName: string;
actionType: "storage";
materials: { materialName: string; materialId: string }[];
storageCapacity: number;
};
}
interface ConveyorEventSchema extends AssetEventSchema {
type: "transfer";
speed: number;
points: ConveyorPointSchema[];
type: "transfer";
speed: number;
points: ConveyorPointSchema[];
}
interface VehicleEventSchema extends AssetEventSchema {
type: "vehicle";
speed: number;
point: VehiclePointSchema;
type: "vehicle";
speed: number;
point: VehiclePointSchema;
}
interface RoboticArmEventSchema extends AssetEventSchema {
type: "roboticArm";
speed: number;
point: RoboticArmPointSchema;
type: "roboticArm";
speed: number;
point: RoboticArmPointSchema;
}
interface MachineEventSchema extends AssetEventSchema {
type: "machine";
// speed: number;
point: MachinePointSchema;
type: "machine";
// speed: number;
point: MachinePointSchema;
}
interface StorageEventSchema extends AssetEventSchema {
type: "storageUnit";
// speed: number;
point: StoragePointSchema;
type: "storageUnit";
// speed: number;
point: StoragePointSchema;
}
interface IPointModel extends Document {
modelUuid:String,
modelName:String,
position:String,
rotation:String,
state:String,
productId:String,
isArchive:boolean,
type: "transfer" | "vehicle" | "roboticArm" | "machine" |"storageUnit";
modelUuid: String;
modelName: String;
position: String;
rotation: String;
state: String;
productId: String;
isArchive: boolean;
type: "transfer" | "vehicle" | "roboticArm" | "machine" | "storageUnit";
speed: number;
point: VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema
points: ConveyorEventSchema[]
point:
| VehicleEventSchema
| RoboticArmEventSchema
| MachineEventSchema
| StorageEventSchema;
points: ConveyorEventSchema[];
}
// type EventsSchema = ConveyorEventSchema | VehicleEventSchema | RoboticArmEventSchema | MachineEventSchema | StorageEventSchema;
const BaseEventSchema = new Schema<IPointModel>(
{
modelUuid: { type: String, required: true },
modelName: { type: String, required: true },
position: { type: [Number], required: true },
rotation: { type: [Number], required: true },
speed: { type: Number,},
state: {
type: String,
enum: ["idle", "running", "stopped", "disabled", "error"],
default: "idle"
},
type: {
type: String,
required: true,
enum: ["transfer", "vehicle", "roboticArm", "machine", "storageUnit"]
},
point:{
type:Schema.Types.Mixed,
},
points:{
type:Schema.Types.Mixed,
},
productId: { type:String,required: true },
isArchive: { type: Boolean, default: false }
{
modelUuid: { type: String, required: true },
modelName: { type: String, required: true },
position: { type: [Number], required: true },
rotation: { type: [Number], required: true },
speed: { type: Number },
state: {
type: String,
enum: ["idle", "running", "stopped", "disabled", "error"],
default: "idle",
},
{ discriminatorKey: "type", timestamps: true }
);
const EventsDataModel = (db: string) => {
return MainModel(db, "EventDatas", BaseEventSchema, "EventDatas");
};
export default EventsDataModel;
type: {
type: String,
required: true,
enum: ["transfer", "vehicle", "roboticArm", "machine", "storageUnit"],
},
point: {
type: Schema.Types.Mixed,
},
points: {
type: Schema.Types.Mixed,
},
productId: { type: String, required: true },
isArchive: { type: Boolean, default: false },
},
{ discriminatorKey: "type", timestamps: true }
);
const EventsDataModel = (db: string) => {
return MainModel(db, "EventDatas", BaseEventSchema, "EventDatas");
};
export default EventsDataModel;

97
src/shared/model/simulation/productFlowmodel.ts
View File

@@ -1,97 +0,0 @@
// import mongoose, { Schema, Document, model } from "mongoose";
// import MainModel from "../../connect/mongoose.ts";
// export interface ProductFlow extends Document {
// productName: string;
// ProductData: [
// {
// AssetName: string;
// Assetuuid: string;
// paths: {
// Points: [
// {
// pointuuid: string;
// actions: [mongoose.Types.ObjectId];
// triggers: [mongoose.Types.ObjectId];
// position: [];
// rotation: [number];
// connections: {
// source: {
// // modelUUID: { type: String };
// pointUUID: string;
// };
// targets: [
// {
// // modelUUID: { type: String };
// pointUUID: string;
// }
// ];
// };
// }
// ];
// // endPoint: {
// // pointuuid: string;
// // actions: [mongoose.Types.ObjectId];
// // triggers: [mongoose.Types.ObjectId];
// // position: [];
// // rotation: [];
// // };
// };
// isArchive: false;
// }
// ];
// isArchive: false;
// }
// const productFlowSchema: Schema = new Schema(
// {
// productName: { type: String },
// ProductData: [
// {
// AssetName: { type: String },
// Assetuuid: { type: String },
// paths: {
// Points: [
// {
// pointuuid: { type: String },
// actions: [
// { type: mongoose.Schema.Types.ObjectId, ref: "Actions" },
// ],
// triggers: [
// { type: mongoose.Schema.Types.ObjectId, ref: "Triggers" },
// ],
// connections: {
// source: {
// // modelUUID: { type: String };
// pointUUID: { type: String },
// },
// targets: [
// {
// // modelUUID: { type: String };
// pointUUID: { type: String },
// },
// ],
// },
// position: { type: Array },
// rotation: {
// type: [Number],
// validate: {
// validator: function (value: number[]) {
// return value && value.length > 0; // Ensures it's only stored if it has values
// },
// message: "Rotation array should not be empty",
// },
// },
// },
// ],
// },
// isArchive: { type: Boolean, default: false },
// },
// ],
// },
// { timestamps: true }
// );
// const productFlowModel = (db: any) => {
// return MainModel(db, "ProductFlow", productFlowSchema, "ProductFlow");
// };
// export default productFlowModel;

10
src/shared/model/simulation/productModel.ts
View File

@@ -1,24 +1,20 @@
import mongoose, { Schema, Document, model } from "mongoose";
import { Schema, Document } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
export interface product extends Document {
export interface Product extends Document {
productName: string;
productId: string;
eventsData: [];
isArchive: boolean;
}
// Product Schema
const ProductSchema = new Schema({
productName: { type: String, required: true },
productId: { type: String, required: true },
isArchive: { type: Boolean, default: false },
});
const ProductModel = (db: string) => {
return MainModel(db, "Product", ProductSchema, "Product");
};
export default ProductModel;
export default ProductModel;

2
src/shared/model/simulation/triggersmodel.ts
View File

@@ -1,4 +1,4 @@
import mongoose, { Schema, Document, model } from "mongoose";
import { Schema, Document } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
export interface Trigger extends Document {

22
src/shared/model/user-Model.ts
View File

@@ -1,4 +1,4 @@
import mongoose, { Document, Schema } from "mongoose";
import { Document, Schema } from "mongoose";
import MainModel from "../connect/mongoose.ts";
export interface User extends Document {
userName: String;
@@ -48,24 +48,8 @@ const signupschema: Schema = new Schema({
default: [],
},
});
// const userModel = (db: string) => {
// const mongoUrl = process.env.MONGO_URI || "";
// if (!mongoUrl) {
// throw new Error("MONGO_URI environment variable is not set");
// }
// // Connect to the database
// const dbConnection = mongoose.createConnection(mongoUrl, {
// dbName: db, // Specify the database name here
// serverSelectionTimeoutMS: 30000,
// });
// // Return the model
// return dbConnection.model("Users", signupschema, "Users");
// };
// export default userModel;
const userModel = (db: string) => {
return MainModel(db, "Users", signupschema, "Users");
const userModel = (db:string) => {
return MainModel(db, "Users", signupschema, "Users")
};
export default userModel;

2
src/shared/model/vizualization/3dwidget.ts
View File

@@ -1,4 +1,4 @@
import mongoose, { Schema, Document, model } from "mongoose";
import { Schema, Document, model } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
export interface Widget3d extends Document {

4
src/shared/model/vizualization/floatWidget.ts
View File

@@ -1,7 +1,7 @@
import mongoose, { Schema, Document, model } from "mongoose";
import { Schema, Document, model } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
export interface floatingWidget extends Document {
export interface FloatingWidget extends Document {
className: string;
iconName: string;
header: string;

4
src/shared/model/vizualization/panelmodel.ts
View File

@@ -1,8 +1,7 @@
import mongoose, { Schema, Document, model } from "mongoose";
import mongoose, { Schema, Document } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
export interface Panel extends Document {
// zoneId: mongoose.Types.ObjectId;
zoneId: string;
panelName: string;
widgets: [mongoose.Types.ObjectId];
@@ -10,7 +9,6 @@ export interface Panel extends Document {
}
const panelSchema: Schema = new Schema(
{
// zoneId: { type: mongoose.Schema.Types.ObjectId, ref: "Zone" },
zoneId: { type: String },
panelName: { type: String },
widgets: [{ type: mongoose.Schema.Types.ObjectId, ref: "Widget" }],

2
src/shared/model/vizualization/templatemodel.ts
View File

@@ -1,4 +1,4 @@
import mongoose, { Schema, Document, model } from "mongoose";
import { Schema, Document } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
export interface Template extends Document {

2
src/shared/model/vizualization/widgemodel.ts
View File

@@ -1,4 +1,4 @@
import mongoose, { Schema, Document, model } from "mongoose";
import mongoose, { Schema, Document } from "mongoose";
import MainModel from "../../connect/mongoose.ts";
export interface widget extends Document {

1
src/shared/services/project/project-Services.ts
View File

@@ -1,6 +1,5 @@
import projectModel from "../../model/project/project-model.ts";
import userModel from "../../model/user-Model.ts";
import { Types } from "mongoose";
import versionModel from "../../model/version/versionModel.ts";
import {
existingProject,

115
src/shared/services/wall/wallItemservice.ts Normal file
View File

@@ -0,0 +1,115 @@
import { Request, Response } from "express";
import wallItemModel from "../../../shared/model/builder/assets/wallitems-Model.ts";
interface IWallSetupData {
modelUuid: string;
modelName: string;
type: string;
csgposition: [];
csgscale: [];
position: [];
quaternion: [];
scale: [];
organization: string;
}
interface IWallItemResult {
data: {};
state: string;
}
export class WallItems {
static async setWallItems(data: IWallSetupData): Promise<IWallItemResult> {
try {
const {
modelUuid,
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
organization,
} = data;
const findvalue = await wallItemModel(organization).findOne({
modelUuid: modelUuid,
});
if (findvalue) {
const updatevalue = await wallItemModel(organization).findOneAndUpdate(
{ modelUuid: modelUuid },
{
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
},
{ new: true } // Return the updated document
);
return {
state: "Updated successfully",
data: updatevalue,
};
// res.status(201).json(updatevalue);
} else {
const newValue = await wallItemModel(organization).create({
modelUuid,
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
});
return {
state: "wall Item created successfully",
data: newValue,
};
// res.status(201).json(newValue);
}
// Send response with the created document
} catch (error:unknown) {
const err = error as Error;
console.error("Error creating wallitems:", error);
return { state: "Failed to create wallitems", data: { message: err.message } };
// return { state: "Failed to create wallitems", data: error } };
// res.status(500).json({ message: "Failed to create wallitems" });
}
}
static async getWallItems(req: Request, res: Response) {
try {
const { organization } = req.params;
const findValue = await wallItemModel(organization).find();
if (!findValue) {
res.status(200).json("wallitems not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error("Error get wallitems:", error);
res.status(500).json({ error: "Failed to get wallitems" });
}
}
static async deleteWallItems(req: Request, res: Response) {
try {
const { modelUuid, modelName, organization } = req.body;
const findValue = await wallItemModel(organization).findOneAndDelete({
modelUuid: modelUuid,
modelName: modelName,
});
if (!findValue) {
res.status(200).json("user not found");
} else {
res.status(201).json(findValue);
}
} catch (error) {
console.error("Error get wallitems:", error);
res.status(500).json({ error: "Failed to get wallitems" });
}
}
}

141
src/socket-server/services/assets/wallitem-Controller.ts
View File

@@ -1,60 +1,99 @@
import { Request, Response } from "express";
import wallItenmModel from "../../../shared/model/assets/wallitems-Model.ts";
import wallItemModel from "../../../shared/model/builder/assets/wallitems-Model.ts";
export const setWallItems = async (data: any) => {
try {
const { modelUuid,modelfileID, modelName, position, type, csgposition, csgscale, quaternion, scale, organization } = data
try {
const {
modelUuid,
modelfileID,
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
organization,
} = data;
const findvalue = await wallItenmModel(organization).findOne({ modelUuid: modelUuid })
if (findvalue) {
const updatevalue = await wallItenmModel(organization).findOneAndUpdate(
{ modelUuid: modelUuid },
{
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
},
{ new: true } // Return the updated document
);
return { success: true, message: 'wallIitem updated', data: updatevalue, organization: organization }
} else {
const newValue = await wallItenmModel(organization).create({ modelUuid,modelfileID, modelName, position, type, csgposition, csgscale, quaternion, scale });
return { success: true, message: 'wallIitem created', data: newValue, organization: organization }
}
// Send response with the created document
} catch (error) {
console.error('Error creating wallIitem:', error);
return { success: false, message: 'Error creating or updating camera', error }
const findvalue = await wallItemModel(organization).findOne({
modelUuid: modelUuid,
});
if (findvalue) {
const updatevalue = await wallItemModel(organization).findOneAndUpdate(
{ modelUuid: modelUuid },
{
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
},
{ new: true } // Return the updated document
);
return {
success: true,
message: "wallIitem updated",
data: updatevalue,
organization: organization,
};
} else {
const newValue = await wallItemModel(organization).create({
modelUuid,
modelfileID,
modelName,
position,
type,
csgposition,
csgscale,
quaternion,
scale,
});
return {
success: true,
message: "wallIitem created",
data: newValue,
organization: organization,
};
}
}
// Send response with the created document
} catch (error) {
console.error("Error creating wallIitem:", error);
return {
success: false,
message: "Error creating or updating camera",
error,
};
}
};
export const deleteWallItems = async (data: any) => {
try {
const { modelUuid, modelName, organization } = data;
const findValue = await wallItenmModel(organization).findOneAndDelete({ modelUuid: modelUuid, modelName: modelName })
if (!findValue) {
return { success: false, message: 'model not found', organization: organization }
} else {
return { success: true, message: 'wallitem deleted', data: findValue, organization: organization }
}
} catch (error) {
console.error('Error get wallitem:', error);
return { success: false, message: 'Failed to delete wallitem', error }
try {
const { modelUuid, modelName, organization } = data;
const findValue = await wallItemModel(organization).findOneAndDelete({
modelUuid: modelUuid,
modelName: modelName,
});
if (!findValue) {
return {
success: false,
message: "model not found",
organization: organization,
};
} else {
return {
success: true,
message: "wallitem deleted",
data: findValue,
organization: organization,
};
}
}
} catch (error) {
console.error("Error get wallitem:", error);
return { success: false, message: "Failed to delete wallitem", error };
}
};