diff --git a/.env b/.env index e08b164..c8ef4e5 100644 --- a/.env +++ b/.env @@ -1,10 +1,10 @@ -MONGO_URI=mongodb://127.0.0.1:27017/ -MONGO_USER=mydata -MONGO_PASSWORD=mongodb@hexr2002 -MONGO_AUTH_DB=admin -# MONGO_USER=admin -# MONGO_PASSWORD=admin321 +# MONGO_URI=mongodb://192.168.0.111/ +# MONGO_USER=mydata +# MONGO_PASSWORD=mongodb@hexr2002 # MONGO_AUTH_DB=admin -# MONGO_URI=mongodb://mongo/ +MONGO_USER=admin +MONGO_PASSWORD=admin321 +MONGO_AUTH_DB=admin +MONGO_URI=mongodb://mongo/ API_PORT=5000 -SOCKET_PORT=8001 \ No newline at end of file +SOCKET_PORT=8000 \ No newline at end of file diff --git a/src/api-server/Routes/assetfloorRoutes.ts b/src/api-server/Routes/assetfloorRoutes.ts new file mode 100644 index 0000000..06a1570 --- /dev/null +++ b/src/api-server/Routes/assetfloorRoutes.ts @@ -0,0 +1,7 @@ +import * as express from "express"; +import { assetsFloorservice } from "../controller/simulation/assetsFloorservice.ts"; +const router = express.Router(); +router.post("/setasset", assetsFloorservice.setFloorassets); +router.get("/floorAssets/:organization", assetsFloorservice.getFloorItems); +// router.get("/pointData/:modelfileID/:organization", assetsFloorservice.gettypePoints); +export default router; diff --git a/src/api-server/Routes/assetpointRoutes.ts b/src/api-server/Routes/assetpointRoutes.ts new file mode 100644 index 0000000..402c27b --- /dev/null +++ b/src/api-server/Routes/assetpointRoutes.ts @@ -0,0 +1,6 @@ +import * as express from "express"; +import { pointService } from "../controller/assets/pointService.ts"; +const router = express.Router(); +router.post("/pointSchema", pointService.addPoints); +router.get("/pointData/:modelfileID/:organization", pointService.gettypePoints); +export default router; diff --git a/src/api-server/Routes/widgetRoute.ts b/src/api-server/Routes/widgetRoute.ts index e5ce9e3..0731940 100644 --- a/src/api-server/Routes/widgetRoute.ts +++ b/src/api-server/Routes/widgetRoute.ts @@ -135,6 +135,7 @@ const router = express.Router(); * description: Server error */ router.post("/widget/save", widgetService.addWidget); +router.patch("/widget/:widgetID", widgetService.updatewidget); router.patch("/widget/delete", widgetService.deleteWidget); router.get( "/WidgetData/:widgetID/:organization", diff --git a/src/api-server/Routes/zoneRoutes.ts b/src/api-server/Routes/zoneRoutes.ts index db79667..e1dd2af 100644 --- a/src/api-server/Routes/zoneRoutes.ts +++ b/src/api-server/Routes/zoneRoutes.ts @@ -320,6 +320,8 @@ router.post("/zone/save", Zoneservice.addandUpdateZone); //Zone create and updat */ router.get("/zones/:sceneID", Zoneservice.allZones); +router.get("/pageZodeData", Zoneservice.vizAllDatas); + /** * @swagger * /ZoneVisualization/{zoneId}: diff --git a/src/api-server/app.ts b/src/api-server/app.ts index 61067c2..82d96c4 100644 --- a/src/api-server/app.ts +++ b/src/api-server/app.ts @@ -1,41 +1,44 @@ -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' -import linesRoutes from './Routes/lines-Routes.ts' -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 panelRouter from './Routes/panelRoutes.ts' -import widgetRouter from './Routes/widgetRoute.ts' - +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"; +import linesRoutes from "./Routes/lines-Routes.ts"; +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 panelRouter from "./Routes/panelRoutes.ts"; +import widgetRouter from "./Routes/widgetRoute.ts"; +import assetpointRouter from "./Routes/assetpointRoutes.ts"; +import assetfloorRoutes from "./Routes/assetfloorRoutes.ts"; const app = express(); app.use(cors()); app.use(express.json()); dotenv.config(); -app.get('/', (req, res) => { - res.send('Hello, I am Major-Dwinzo API!'); - }); +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' }); -}) -app.use('/api/v1', cameraRoutes); -app.use('/api/v1', environmentsRoutes); -app.use('/api/v1', linesRoutes); -app.use('/api/v1', flooritemRoutes); -app.use('/api/v1', WallitemRoutes); -app.use('/api/v1', userRoutes); -app.use('/api/v1', shareRoutes); +app.get("/health", (req, res) => { + res.status(200).json({ message: "Server is running" }); +}); +app.use("/api/v1", cameraRoutes); +app.use("/api/v1", environmentsRoutes); +app.use("/api/v1", linesRoutes); +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', panelRouter); -app.use('/api/v2', widgetRouter); +//update +app.use("/api/v2", zoneRoutes2); //updates +app.use("/api/v2", panelRouter); +app.use("/api/v2", widgetRouter); +app.use("/api/v2", assetpointRouter); +app.use("/api/v2", assetfloorRoutes); export default app; diff --git a/src/api-server/controller/assets/pointService.ts b/src/api-server/controller/assets/pointService.ts new file mode 100644 index 0000000..a26beca --- /dev/null +++ b/src/api-server/controller/assets/pointService.ts @@ -0,0 +1,137 @@ +import { Request, Response } from "express"; +import pointModel from "../../../shared/model/builder/assets/assetPoint-Model.ts"; + +export class pointService { + static async addPoints(req: Request, res: Response): Promise { + const { type, modelfileID, organization } = req.body; + + if (!["Conveyor", "Vehicle"].includes(type)) { + return res.status(400).json({ message: "Invalid type requested" }); + } + + try { + if (type === "Conveyor") { + const pointsData = await pointModel(organization).findOne({ + modelfileID: modelfileID, + type: type, + }); + if (pointsData) return res.send("Data already exists"); + const createData = await pointModel(organization).create({ + type: "Conveyor", + modelfileID: "672a090f80d91ac979f4d0bd", + points: [ + { + uuid: "point1UUID", + position: [0, 0.85, 2.2], + rotation: [0, 0, 0], + actions: [ + { + uuid: "randomUUID", + name: "Action 1", + type: "Inherit", + material: "Inherit", + delay: "Inherit", + spawnInterval: "Inherit", + isUsed: false, + }, + ], + triggers: [], + // connections: { + // source: { pathUUID: "modelUUID", pointUUID: "point1UUID" }, + // targets: [], + // }, + }, + { + uuid: "point1UUID", + position: [0, 0.85, 0], + rotation: [0, 0, 0], + actions: [ + { + uuid: "randomUUID", + name: "Action 1", + type: "Inherit", + material: "Inherit", + delay: "Inherit", + spawnInterval: "Inherit", + isUsed: false, + }, + ], + triggers: [], + // connections: { + // source: { pathUUID: "modelUUID", pointUUID: "point1UUID" }, + // targets: [], + // }, + }, + { + uuid: "point1UUID", + position: [0, 0.85, -2.2], + rotation: [0, 0, 0], + actions: [ + { + uuid: "randomUUID", + name: "Action 1", + type: "Inherit", + material: "Inherit", + delay: "Inherit", + spawnInterval: "Inherit", + isUsed: false, + }, + ], + triggers: [], + // connections: { + // source: { pathUUID: "modelUUID", pointUUID: "point1UUID" }, + // targets: [], + // }, + }, + ], + speed: 1, + }); + } + // else if (type === "Vehicle") { + // // responseData = { + // // type: "Vehicle", + // // points: { + // // uuid: "point1UUID", + // // position: [10, 20, 30], + // // rotation: [0, 0, 0], + // // actions: [ + // // { + // // uuid: "randomUUID", + // // name: "Action 1", + // // type: "Inherit", + // // material: "Inherit", + // // delay: "Inherit", + // // spawnInterval: "Inherit", + // // isUsed: false, + // // }, + // // ], + // // triggers: [], + // // connections: { + // // source: { pathUUID: "modelUUID", pointUUID: "point1UUID" }, + // // targets: [], + // // }, + // // }, + // // speed: 1, + // // }; + // } + + res.status(200).json({ message: "point created successfully" }); + } catch (error) { + res.status(500).json({ message: "Server error", error }); + } + } + + static async gettypePoints(req: Request, res: Response): Promise { + const { modelfileID, organization } = req.params; + try { + const getData = await pointModel(organization) + .findOne({ + modelfileID: modelfileID, + }) + .select("-_id -__v -createdAt -updatedAt"); + res.send(getData); + } catch (error) { + res.status(500).json({ message: "Server error", error }); + } + } +} diff --git a/src/api-server/controller/lines/zoneService.ts b/src/api-server/controller/lines/zoneService.ts index 425a2ea..61ba019 100644 --- a/src/api-server/controller/lines/zoneService.ts +++ b/src/api-server/controller/lines/zoneService.ts @@ -6,8 +6,7 @@ export class Zoneservice { static async addandUpdateZone(req: Request, res: Response): Promise { const organization = req.body.organization; const zoneDatas = req.body.zonesdata; - - console.log('organization: ', organization); + try { const existingZone = await zoneSchema(organization).findOne({ zoneId: zoneDatas.zoneId, @@ -90,6 +89,7 @@ export class Zoneservice { } } + //single zode panel and widget data static async singleZonePanelDatas(req: Request, res: Response): Promise { const organization = req.query.organization; const zoneId = req.params.zoneId; @@ -97,10 +97,12 @@ export class Zoneservice { try { const existingZone = await zoneSchema(organization) .findOne({ - zoneId: req.params.zoneId, + zoneId: zoneId, isArchive: false, }) - .select("panelOrder zoneName zonePoints lockedPanel"); + .select( + "panelOrder zoneName zonePoints lockedPanel zoneId viewPortCenter viewPortposition" + ); if (!existingZone) { return res.send({ message: "Zone not found for the UUID" }); } else { @@ -131,6 +133,9 @@ export class Zoneservice { const objectData = { zoneName, + viewPortposition: existingZone.viewPortposition, + zoneId: existingZone.zoneId, + viewPortCenter: existingZone.viewPortCenter, activeSides: existingZone.panelOrder || [], panelOrder: existingZone.panelOrder || [], lockedPanels: existingZone.lockedPanel || [], @@ -145,13 +150,75 @@ export class Zoneservice { } } + //page full zone Datas with panel and widget + static async vizAllDatas(req: Request, res: Response): Promise { + const organization = req.query.organization; + try { + const existingZones = await zoneSchema(organization) + .find({ + isArchive: false, + }) + .select( + "panelOrder zoneName zonePoints lockedPanel zoneId viewPortCenter viewPortposition" + ); + if (!existingZones) { + return res.send({ message: "Zone not found for the UUID" }); + } else { + const response = await Promise.all( + existingZones.map(async (zone) => { + // Fetch all panels associated with the current zone + const panelData = await panelSchema(organization).find({ + zoneId: zone._id, + isArchive: false, + }); + + // Fetch widgets for each panel + const widgets = await Promise.all( + panelData.map(async (panel) => { + const widgetDataArray = await widgetSchema(organization).find({ + panelID: panel._id, + isArchive: false, + }); + + return widgetDataArray.map((widget) => ({ + id: widget.widgetID, + type: widget.elementType, + title: widget.widgetName, + panel: widget.widgetside, + data: widget.Data || [], + })); + }) + ); + + return { + zoneName: zone.zoneName, + zoneId: zone.zoneId, + viewPortposition: zone.viewPortposition, + viewPortCenter: zone.viewPortCenter, + activeSides: zone.panelOrder || [], + panelOrder: zone.panelOrder || [], + lockedPanels: zone.lockedPanel || [], + points: zone.zonePoints || [], + widgets: widgets.flat(), + }; + }) + ); + + return res.status(200).json(response); + } + } catch (error: any) { + return res.status(500).send(error.message); + } + } + + //only for the name and zoneID static async allZones(req: Request, res: Response): Promise { const organization = req.query.organization; const sceneID = req.params.sceneID || "scene123"; try { const Allzones = await zoneSchema(organization) .find({ sceneID: sceneID, isArchive: false }) - .select("zoneName sceneID zoneId"); + .select("zoneName zoneId"); if (!Allzones || Allzones.length === 0) { return res.status(404).json({ message: "Zone not found for the UUID" }); @@ -165,9 +232,7 @@ export class Zoneservice { static async ZoneData(req: Request, res: Response): Promise { try { const organization = req.query.organization; - console.log("organization: ", organization); const zoneId = req.params.zoneId; - console.log("zoneId: ", zoneId); const findZone = await zoneSchema(organization).findOne({ zoneId: zoneId, }); diff --git a/src/api-server/controller/simulation/assetsFloorservice.ts b/src/api-server/controller/simulation/assetsFloorservice.ts new file mode 100644 index 0000000..5cfbbad --- /dev/null +++ b/src/api-server/controller/simulation/assetsFloorservice.ts @@ -0,0 +1,211 @@ +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"; + +export class assetsFloorservice { + static async setFloorassets(req: Request, res: Response) { + try { + const { + modeluuid, + modelname, + position, + modelfileID, + rotation, + isLocked, + isVisible, + organization, + points, + } = req.body; + + const findvalue = await assetModel(organization).findOne({ + modeluuid: modeluuid, + modelname: modelname, + }); + + if (findvalue) { + const updatevalue = await assetModel(organization).findOneAndUpdate( + { modeluuid: modeluuid, modelname: modelname }, + { + position: position, + rotation: rotation, + isVisible: isVisible, + isLocked: isLocked, + }, + { new: true } + ); + res.status(201).json(updatevalue); + } else { + // const newValue = await assetModel(organization).create({ + // modeluuid, + // modelfileID, + // modelname, + // position, + // rotation, + // isLocked, + // isVisible, + // points, + // }); + + // for (const point of points) { + // // Create actions if they exist + // for (const action of point.actions || []) { + // const actionData = await actionModel(organization).create({ + // pointsUUID: point.uuid, + // actionUUID: action.uuid, + // eventData: { + // uuid: action.uuid, + // type: action.type, + // material: action.material, + // delay: action.delay, + // spawn_Interval: action.spawnInterval, + // }, + // }); + + // // Push action ID to point + // newValue.points + // .find((p: any) => p.uuid === point.uuid) + // ?.actions.push(actionData._id); + // } + + // // Create triggers if they exist + // for (const trigger of point.triggers || []) { + // const triggerData = await triggerModel(organization).create({ + // pointsUUID: point.uuid, + // actionUUID: trigger.uuid, + // triggerData: { + // type: trigger.type, + // }, + // }); + + // // Push trigger ID to point + // newValue.points + // .find((p: any) => p.uuid === point.uuid) + // ?.triggers.push(triggerData._id); + // } + // } + + // // Save the updated document + // await newValue.save(); + + // res.status(201).json(newValue); + + let pointRefs = []; + + for (const point of points) { + let actionRefs = []; + let triggerRefs = []; + + // Store Actions (Events) + if (point.actions && point.actions.length > 0) { + for (const action of point.actions) { + const actionDoc = await actionModel(organization).create({ + pointsUUID: point.uuid, + actionUUID: action.uuid, + isArchive: false, + eventData: [action], // Store the action data + }); + await actionDoc.save(); + actionRefs.push(actionDoc._id); // Store reference + } + } + + // Store Triggers + if (point.triggers && point.triggers.length > 0) { + for (const trigger of point.triggers) { + const triggerDoc = await triggerModel(organization).create({ + pointsUUID: point.uuid, + actionUUID: trigger.uuid, + isArchive: false, + triggerData: [trigger], // Store trigger data + }); + await triggerDoc.save(); + triggerRefs.push(triggerDoc._id); // Store reference + } + } + + // Store the Point document + pointRefs.push({ + uuid: point.uuid, + position: point.position, + rotation: point.rotation, + actions: actionRefs, + triggers: triggerRefs, + }); + } + + // Store the main asset document + const assetDoc = await assetModel(organization).create({ + modeluuid, + modelname, + position, + modelfileID, + rotation, + isLocked, + isVisible, + points: pointRefs, + }); + + await assetDoc.save(); + 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) { + try { + const { organization } = req.params; + const findValue = await assetModel(organization) + .find() + .select("-_id -__v") + .populate({ + path: "points.actions", + select: "-_id", + populate: { + path: "eventData", + select: "uuid type -_id", + }, + }) + .populate({ + path: "points.triggers", + select: "-_id", + populate: { + path: "triggerData", + select: "uuid type -_id", + }, + }); + if (!findValue) { + res.status(200).json("floorItems 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 deleteFloorItems(req: Request, res: Response) { + try { + const { modeluuid, modelname, organization } = req.body; + + const findValue = await assetModel(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 flooritems:", error); + res.status(500).json({ error: "Failed to get flooritems" }); + } + } +} diff --git a/src/api-server/controller/visualization/panelService.ts b/src/api-server/controller/visualization/panelService.ts index b544032..3e41a91 100644 --- a/src/api-server/controller/visualization/panelService.ts +++ b/src/api-server/controller/visualization/panelService.ts @@ -6,9 +6,7 @@ import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts"; export class panelService { static async AddPanel(req: Request, res: Response): Promise { try { - console.log('req.body: ', req.body); const organization = req.body.organization; - console.log('organization: ', organization); const zoneId = req.body.zoneId; const panelName = req.body.panelName; const panelOrder = req.body.panelOrder; @@ -57,8 +55,7 @@ export class panelService { // const IDdata = createdPanels.map((ID: any) => { // return ID._id; // }); - console.log("IDdata: ", createdPanels); - createdPanels + createdPanels; return res.status(201).json({ message: "Panels created successfully", panelID: createdPanels, @@ -69,7 +66,7 @@ export class panelService { } static async deletePanel(req: Request, res: Response): Promise { try { - const { organization, panelID, zoneId } = req.body; + const { organization, panelName, zoneId } = req.body; const existingZone = await zoneSchema(organization).findOne({ zoneId: zoneId, isArchive: false, @@ -78,17 +75,17 @@ export class panelService { return res.status(404).json({ message: "Zone not found" }); const existingPanel = await panelSchema(organization).findOne({ zoneId: zoneId, - _id: panelID, + panelName: panelName, isArchive: false, }); if (!existingPanel) return res.status(409).json({ message: "Panel Already Deleted" }); const updatePanel = await panelSchema(organization).updateOne( - { _id: panelID, isArchive: false }, + { _id: existingPanel._id, isArchive: false }, { $set: { isArchive: true } } ); const existingWidgets = await widgetSchema(organization).find({ - panelID: panelID, + panelID: existingPanel._id, isArchive: false, }); diff --git a/src/api-server/controller/visualization/widgetService.ts b/src/api-server/controller/visualization/widgetService.ts index 2d1f6ed..6cd9734 100644 --- a/src/api-server/controller/visualization/widgetService.ts +++ b/src/api-server/controller/visualization/widgetService.ts @@ -6,50 +6,48 @@ export class widgetService { try { const { organization, - panelID, - widgetName, - widgetOrder, - type, - widgetID, - panel, - Data, + // panel, + zoneId, + widget, } = req.body; const existingPanel = await panelSchema(organization).findOne({ - _id: panelID, + panelName: widget.panel, + zoneId: zoneId, isArchive: false, }); if (!existingPanel) - return res.status(404).json({ message: "PanelID not found" }); + return res.status(404).json({ message: "panelName not found" }); - if (existingPanel.panelName === panel) { + if (existingPanel.panelName === widget.panel) { const existingWidget = await widgetSchema(organization).findOne({ - panelID: panelID, - widgetID: widgetID, + panelID: existingPanel._id, + widgetID: widget.id, isArchive: false, - widgetOrder: widgetOrder, + // widgetOrder: widget.widgetOrder, }); - if (existingWidget) + if (existingWidget) { return res .status(409) .json({ message: "Widget already exist for the widgetID" }); + } const newWidget = await widgetSchema(organization).create({ - widgetID: widgetID, - elementType: type, - widgetOrder: widgetOrder, - widgetName: widgetName, - panelID: panelID, - widgetside: panel, - Data: { - measurements: Data.measurements || {}, - duration: Data.duration || "1hr", - }, + widgetID: widget.id, + elementType: widget.type, + // widgetOrder: widgetOrder, + widgetName: widget.widgetName, + panelID: existingPanel._id, + widgetside: widget.panel, + // Data: { + // measurements: widget.Data.measurements || {}, + // duration: widget.Data.duration || "1hr", + // }, }); if (newWidget) { existingPanel.widgets.push(newWidget._id); await existingPanel.save(); return res.status(201).json({ message: "Widget created successfully", - widgetID: newWidget._id, + // widgetID: newWidget._id, }); } } @@ -63,13 +61,13 @@ export class widgetService { try { const { widgetID, organization } = req.body; const findWidget = await widgetSchema(organization).findOne({ - _id: widgetID, + widgetID: widgetID, isArchive: false, }); if (!findWidget) return res.status(409).json({ message: "Widget already deleted" }); const widgetData = await widgetSchema(organization).updateOne( - { _id: widgetID, isArchive: false }, + { _id: findWidget._id, isArchive: false }, { $set: { isArchive: true } } ); @@ -92,7 +90,7 @@ export class widgetService { isArchive: false, }); - if (panelData.widgets.includes(widgetID)) { + if (panelData.widgets.includes(findWidget._id)) { panelData.widgets = panelData.widgets.filter( (widget: any) => widget !== findWidget._id ); @@ -105,6 +103,48 @@ export class widgetService { } } + static async updatewidget(req: Request, res: Response): Promise { + 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 { const { organization, widgetID } = req.params; try { diff --git a/src/shared/connect/mongoose.ts b/src/shared/connect/mongoose.ts index 5986cd7..ead358d 100644 --- a/src/shared/connect/mongoose.ts +++ b/src/shared/connect/mongoose.ts @@ -16,7 +16,7 @@ const MainModel = ( const authOptions = { user: process.env.MONGO_USER, // Correct username environment variable pass: process.env.MONGO_PASSWORD, // Correct password environment variable - authSource: process.env.MONGO_AUTH_DB || 'admin', // Default to 'admin' if not provided + authSource: process.env.MONGO_AUTH_DB || "admin", // Default to 'admin' if not provided maxPoolSize: 50, }; @@ -24,9 +24,9 @@ const MainModel = ( if (connections[db]) { return connections[db].model(modelName, schema, collectionName); } - + try { - const db1 = mongoose.createConnection(db1_url,authOptions); + const db1 = mongoose.createConnection(db1_url, authOptions); // Cache the connection connections[db] = db1; @@ -37,7 +37,10 @@ const MainModel = ( }); db1.on("error", (err) => { - console.error(`MongoDB connection error for database ${db}:`, err.message); + console.error( + `MongoDB connection error for database ${db}:`, + err.message + ); }); return db1.model(modelName, schema, collectionName); @@ -48,4 +51,3 @@ const MainModel = ( }; export default MainModel; - diff --git a/src/shared/model/builder/assets/asset-Model.ts b/src/shared/model/builder/assets/asset-Model.ts index c8caddc..400ea70 100644 --- a/src/shared/model/builder/assets/asset-Model.ts +++ b/src/shared/model/builder/assets/asset-Model.ts @@ -1,6 +1,16 @@ import mongoose, { Document, Schema } from "mongoose"; import MainModel from "../../../connect/mongoose.ts"; +interface IAction { + uuid: string; + name: string; + type: string; + material: string; + delay: string; + spawnInterval: string; + isUsed: boolean; +} + // Interface for TypeScript with PascalCase export interface assetData extends Document { modeluuid: string; @@ -42,16 +52,16 @@ const assetDataSchema: Schema = new Schema({ uuid: { type: String }, position: { type: Array }, rotation: { type: Array }, - actions: [{ type: mongoose.Schema.Types.ObjectId, ref: "Widget" }], - triggers: [{ type: mongoose.Schema.Types.ObjectId, ref: "Widget" }], + actions: [{ type: mongoose.Schema.Types.ObjectId, ref: "Actions" }], + triggers: [{ type: mongoose.Schema.Types.ObjectId, ref: "Triggers" }], }, ], isLocked: { type: Boolean }, isVisible: { type: Boolean }, rotation: { - x: { type: Number, required: true }, - y: { type: Number, required: true }, - z: { type: Number, required: true }, + x: { type: Number }, + y: { type: Number }, + z: { type: Number }, }, }); diff --git a/src/shared/model/builder/assets/assetPoint-Model.ts b/src/shared/model/builder/assets/assetPoint-Model.ts new file mode 100644 index 0000000..5197e01 --- /dev/null +++ b/src/shared/model/builder/assets/assetPoint-Model.ts @@ -0,0 +1,80 @@ +import mongoose, { Schema, Document } from "mongoose"; +import MainModel from "../../../connect/mongoose.ts"; + +interface IAction { + uuid: string; + name: string; + type: string; + material: string; + delay: string; + spawnInterval: string; + isUsed: boolean; +} + +// interface IConnection { +// source: { pathUUID: string; pointUUID: string }; +// targets: string[]; +// } + +interface IPoint { + uuid: string; + position: number[]; + rotation: number[]; + actions: IAction[]; + triggers: string[]; + // connections: IConnection; +} + +interface IBaseModel extends Document { + modelfileID: string; + type: "Conveyor" | "Vehicle"; + points: IPoint[] | IPoint; + speed: number; +} + +// Base Schema +const PointSchema = new Schema({ + uuid: { type: String, required: true }, + position: { type: [Number], required: true }, + rotation: { type: [Number], required: true }, + actions: [ + { + uuid: { type: String, default: "" }, + name: { type: String, required: true }, + type: { type: String, required: true }, + material: { type: String, required: true }, + delay: { type: String, required: true }, + spawnInterval: { type: String, required: true }, + isUsed: { type: Boolean, required: true }, + }, + ], + triggers: { type: [String], default: [] }, + // connections: { + // source: { + // pathUUID: { type: String, required: true }, + // pointUUID: { type: String, required: true }, + // }, + // targets: { type: [String], default: [] }, + // }, +}); + +const BaseSchema = new Schema( + { + modelfileID: { type: String }, + type: { type: String, enum: ["Conveyor", "Vehicle"] }, + points: { + type: Schema.Types.Mixed, + required: true, + }, + speed: { type: Number }, + }, + { discriminatorKey: "type", timestamps: true } +); + +const pointModel = (db: string) => { + return MainModel(db, "Points", BaseSchema, "Points"); +}; +export default pointModel; + +// const pointModel = mongoose.model("Points", BaseSchema, "Points"); +// export default pointModel; diff --git a/src/shared/model/builder/assets/pointSchema.ts b/src/shared/model/builder/assets/pointSchema.ts deleted file mode 100644 index a38e8fa..0000000 --- a/src/shared/model/builder/assets/pointSchema.ts +++ /dev/null @@ -1,59 +0,0 @@ -import mongoose, { Document, Schema } from "mongoose"; -import MainModel from "../../../connect/mongoose.ts"; - -// Interface for TypeScript with PascalCase -export interface Points extends Document { - modelfileID: string; - points: { - uuid: string; - position: number[]; - rotation: number[]; - actions: string[]; - triggers: string[]; - }[]; -} -const defaultPoints = [ - { - uuid: "", - position: [0, 1.25, 3.3], - rotation: [0, 0, 0], - actions: [], - triggers: [], - }, - { - uuid: "", - position: [0, 1.25, 3.3], - rotation: [0, 0, 0], - actions: [], - triggers: [], - }, - { - uuid: "", - position: [0, 1.25, 3.3], - rotation: [0, 0, 0], - actions: [], - triggers: [], - }, -]; -// Define the Mongoose Schema -const pointSchema: Schema = new Schema({ - modelfileID: { type: String, required: true }, - points: { - type: [ - { - uuid: { type: String }, - position: { type: [Number], default: [0, 1.25, 3.3] }, - rotation: { type: [Number], default: [0, 0, 0] }, - actions: { type: [String], default: [] }, - triggers: { type: [String], default: [] }, - }, - ], - default: defaultPoints, - }, -}); - -const pointModel = (db: string) => { - return MainModel(db, "Points", pointSchema, "Points"); -}; - -export default pointModel; diff --git a/src/shared/model/simulation/actionmodel.ts b/src/shared/model/simulation/actionmodel.ts index 13ec2f6..7b77ff5 100644 --- a/src/shared/model/simulation/actionmodel.ts +++ b/src/shared/model/simulation/actionmodel.ts @@ -19,7 +19,6 @@ const eventSchema: Schema = new Schema( pointsUUID: { type: String }, isArchive: { type: Boolean, default: false }, actionUUID: { type: String }, - sceneID: { type: String }, eventData: [ { uuid: { type: String }, @@ -34,6 +33,6 @@ const eventSchema: Schema = new Schema( ); const actionModel = (db: any) => { - return MainModel(db, "Events", eventSchema, "Events"); + return MainModel(db, "Actions", eventSchema, "Actions"); }; export default actionModel; diff --git a/src/shared/model/vizualization/widgemodel.ts b/src/shared/model/vizualization/widgemodel.ts index e0ba874..ec4bf70 100644 --- a/src/shared/model/vizualization/widgemodel.ts +++ b/src/shared/model/vizualization/widgemodel.ts @@ -14,7 +14,7 @@ export interface widget extends Document { isArchive: boolean; panelID: mongoose.Types.ObjectId; Data: { - measurement: Record; + measurement: [any]; duration: string; }; } @@ -29,10 +29,7 @@ const widgetSchema: Schema = new Schema( fontFamily: { type: String }, fontStyle: { type: String }, Data: { - measurements: { - type: Object, - default: {}, - }, + measurements: { type: Array, default: [] }, duration: { type: String, default: "1hr" }, }, fontWeight: { type: String },