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

assetmodel creation and adding for namespace socket

Browse Source
This commit is contained in:
sabarinathan
2025-04-01 13:27:25 +05:30
parent d8d9a7c837
commit 5db6153bb9
13 changed files with 1241 additions and 828 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,6 +1,6 @@
import * as express from "express"; import * as express from "express";
import { widget3dService } from "../controller/visualization/3dWidgetService.ts"; import { widget3dService } from "../controller/visualization/3dWidgetService.ts";
const router = express.Router(); const router = express.Router();
router.post("/3dwidget/save", widget3dService.add3Dwidget); router.post("/3dwidget/save", widget3dService.add3Dwidget);
router.get("/3dwidgetData/:zoneId/:organization", widget3dService.get3Dwiget); router.get("/3dwidgetData/:zoneId/:organization", widget3dService.get3Dwiget);
export default router; export default router;

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

@@ -1,106 +1,106 @@
import { Request, Response } from "express"; import { Request, Response } from "express";
import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts"; import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
import widget3dModel from "../../../shared/model/vizualization/3dwidget.ts"; import widget3dModel from "../../../shared/model/vizualization/3dwidget.ts";
export class widget3dService { export class widget3dService {
static async add3Dwidget(req: Request, res: Response): Promise<any> { static async add3Dwidget(req: Request, res: Response): Promise<any> {
try { try {
const { organization, widget, zoneId } = req.body; const { organization, widget, zoneId } = req.body;
const existingZone = await zoneSchema(organization).findOne({ const existingZone = await zoneSchema(organization).findOne({
zoneId: zoneId, zoneId: zoneId,
isArchive: false, isArchive: false,
}); });
if (!existingZone) if (!existingZone)
return res.status(404).json({ message: "Zone not found" }); return res.status(404).json({ message: "Zone not found" });
const existing3Dwidget = await widget3dModel(organization).findOne({ const existing3Dwidget = await widget3dModel(organization).findOne({
widgetID: widget.id, widgetID: widget.id,
isArchive: false, isArchive: false,
}); });
if (existing3Dwidget) { if (existing3Dwidget) {
const update3dwidget = await widget3dModel( const update3dwidget = await widget3dModel(
organization organization
).findOneAndUpdate( ).findOneAndUpdate(
{ {
widgetID: widget.id, widgetID: widget.id,
zoneId: zoneId, zoneId: zoneId,
isArchive: false, isArchive: false,
}, },
{ position: widget.position }, { position: widget.position },
{ upsert: true, new: true } { upsert: true, new: true }
); );
if (update3dwidget) if (update3dwidget)
return res return res
.status(200) .status(200)
.json({ message: "widget update successfully" }); .json({ message: "widget update successfully" });
else return res.send("Widget not updated"); else return res.send("Widget not updated");
} }
const newWidget3d = await widget3dModel(organization).create({ const newWidget3d = await widget3dModel(organization).create({
widgetName: widget.type, widgetName: widget.type,
widgetID: widget.id, widgetID: widget.id,
position: widget.position, position: widget.position,
zoneId, zoneId,
}); });
if (newWidget3d) if (newWidget3d)
return res.status(201).json({ message: "Widget created successfully" }); return res.status(201).json({ message: "Widget created successfully" });
} catch (error: any) { } catch (error: any) {
return res.status(500).send(error.message); return res.status(500).send(error.message);
} }
} }
static async get3Dwiget(req: Request, res: Response): Promise<any> { static async get3Dwiget(req: Request, res: Response): Promise<any> {
try { try {
const { organization, zoneId } = req.params; const { organization, zoneId } = req.params;
const existingZone = await zoneSchema(organization).findOne({ const existingZone = await zoneSchema(organization).findOne({
zoneId: zoneId, zoneId: zoneId,
isArchive: false, isArchive: false,
}); });
if (!existingZone) return res.send("Zone not found"); if (!existingZone) return res.send("Zone not found");
const widgetData = await widget3dModel(organization).find({ const widgetData = await widget3dModel(organization).find({
zoneId: zoneId, zoneId: zoneId,
isArchive: false, isArchive: false,
}); });
if (!widgetData || widgetData.length === 0) { if (!widgetData || widgetData.length === 0) {
return res.json([]); return res.json([]);
} }
const zonebasedWidget = widgetData.map((widget) => ({ const zonebasedWidget = widgetData.map((widget) => ({
Data: { Data: {
measurements: widget.Data?.measurements || {}, measurements: widget.Data?.measurements || {},
duration: widget.Data?.duration || "1h", duration: widget.Data?.duration || "1h",
}, },
type: widget.widgetName, type: widget.widgetName,
id: widget.widgetID, id: widget.widgetID,
position: widget.position, position: widget.position,
})); }));
return res.status(200).json(zonebasedWidget); return res.status(200).json(zonebasedWidget);
} catch (error: any) { } catch (error: any) {
return res.status(500).send(error.message); return res.status(500).send(error.message);
} }
} }
// static async update3Dposition(req: Request, res: Response): Promise<any> { // static async update3Dposition(req: Request, res: Response): Promise<any> {
// try { // try {
// const { organization, id, position, zoneId } = req.body; // const { organization, id, position, zoneId } = req.body;
// const existing3Dwidget = await widget3dModel(organization).findOne({ // const existing3Dwidget = await widget3dModel(organization).findOne({
// widgetID: id, // widgetID: id,
// isArchive: false, // isArchive: false,
// }); // });
// if (existing3Dwidget) { // if (existing3Dwidget) {
// const update3dwidget = await widget3dModel( // const update3dwidget = await widget3dModel(
// organization // organization
// ).findOneAndUpdate( // ).findOneAndUpdate(
// { // {
// widgetID: id, // widgetID: id,
// zoneId: zoneId, // zoneId: zoneId,
// isArchive: false, // isArchive: false,
// }, // },
// { position: position }, // { position: position },
// { upsert: true, new: true } // { upsert: true, new: true }
// ); // );
// if (update3dwidget) // if (update3dwidget)
// return res.status(200).send("widget update successfully"); // return res.status(200).send("widget update successfully");
// } else { // } else {
// return res.status(404).send("widget not found"); // return res.status(404).send("widget not found");
// } // }
// } catch (error: any) { // } catch (error: any) {
// return res.status(500).send(error.message); // return res.status(500).send(error.message);
// } // }
// } // }
} }

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

@@ -33,8 +33,13 @@ export interface assetData extends Document {
]; ];
}[]; }[];
}[]; }[];
assetPosition: number[]; position: [];
assetRotation: number[]; // rotation: [];
rotation: {
x: number;
y: number;
z: number;
};
speed: number | string; speed: number | string;
} }
@@ -66,16 +71,16 @@ const assetDataSchema: Schema = new Schema({
}, },
}, },
], ],
assetPosition: { type: [Number] }, position: { type: Array},
assetRotation: { type: [Number] }, // rotation: { type: Array},
rotation: {
x: { type: Number },
y: { type: Number },
z: { type: Number },
},
speed: { type: Schema.Types.Mixed }, speed: { type: Schema.Types.Mixed },
isLocked: { type: Boolean }, isLocked: { type: Boolean },
isVisible: { type: Boolean }, isVisible: { type: Boolean },
// rotation: {
// x: { type: Number },
// y: { type: Number },
// z: { type: Number },
// },
}); });
// export default floorItemsModel; // export default floorItemsModel;

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

@@ -1,44 +1,44 @@
import mongoose, { Schema, Document, model } from "mongoose"; import mongoose, { Schema, Document, model } from "mongoose";
import MainModel from "../../connect/mongoose.ts"; import MainModel from "../../connect/mongoose.ts";
export interface floatingWidget extends Document { export interface floatingWidget extends Document {
className: string; className: string;
header: string; header: string;
floatWidgetID: string; floatWidgetID: string;
position: {}; position: {};
per: string; per: string;
value: string; value: string;
isArchive: boolean; isArchive: boolean;
zoneId: string; zoneId: string;
Data: { Data: {
measurements: {}; measurements: {};
duration: string; duration: string;
}; };
} }
const floatingWidgetSchema: Schema = new Schema( const floatingWidgetSchema: Schema = new Schema(
{ {
className: { type: String }, className: { type: String },
header: { type: String }, header: { type: String },
floatWidgetID: { type: String }, floatWidgetID: { type: String },
position: { type: Object }, position: { type: Object },
per: { type: String }, per: { type: String },
value: { type: String }, value: { type: String },
zoneId: { type: String }, zoneId: { type: String },
Data: { Data: {
measurements: { type: Object, default: {} }, measurements: { type: Object, default: {} },
duration: { type: String, default: "1h" }, duration: { type: String, default: "1h" },
}, },
isArchive: { type: Boolean, default: false }, isArchive: { type: Boolean, default: false },
}, },
{ timestamps: true } { timestamps: true }
); );
const floatWidgetModel = (db: any) => { const floatWidgetModel = (db: any) => {
return MainModel( return MainModel(
db, db,
"FloatingWidget", "FloatingWidget",
floatingWidgetSchema, floatingWidgetSchema,
"FloatingWidget" "FloatingWidget"
); );
}; };
export default floatWidgetModel; export default floatWidgetModel;

229
src/socket-server/services/assets/asset-Controller.ts
View File

@@ -1,102 +1,127 @@
import assetModel from "../../../shared/model/builder/assets/asset-Model.ts"; import assetModel from "../../../shared/model/builder/assets/asset-Model.ts";
import actionModel from "../../../shared/model/simulation/actionmodel.ts"; import actionModel from "../../../shared/model/simulation/actionmodel.ts";
import triggerModel from "../../../shared/model/simulation/triggersmodel.ts"; import triggerModel from "../../../shared/model/simulation/triggersmodel.ts";
export const setAssetModel = async (data: any) => { export const setAssetModel = async (data: any) => {
const {modeluuid, modelname,assetPosition, eventData,modelfileID,assetRotation,isLocked,isVisible,organization, }= data const {modeluuid, modelname,position,rotation, eventData,modelfileID,isLocked,isVisible,organization, }= data
console.log('data: ', data); console.log('data: ', data);
// const points=eventData.points // const position=data.position
// const speed=eventData.speed // const rotation=data.rotation
try { try {
const findvalue = await assetModel(organization).findOne({ const findvalue = await assetModel(organization).findOne({
modeluuid: modeluuid, modeluuid: modeluuid,
modelname: modelname, modelname: modelname,
}); });
if (findvalue) { if (findvalue) {
const updatevalue = await assetModel(organization).findOneAndUpdate( console.log('findvalue: ', findvalue);
{ modeluuid: modeluuid, modelname: modelname }, const updatevalue = await assetModel(organization).findOneAndUpdate(
{ { modeluuid: modeluuid, modelname: modelname },
assetPosition: assetPosition, {
assetRotation: assetRotation, position: position,
isVisible: isVisible, rotation: rotation,
isLocked: isLocked, isVisible: isVisible,
}, isLocked: isLocked,
{ new: true } },
); { new: true }
return { success: true, message: 'Model updated', data: updatevalue, organization: organization } );
} else { console.log('updatevalue: ', updatevalue);
let assetData: any = { return { success: true, message: 'Model updated successfully', data: updatevalue, organization: organization }
modeluuid, } else {
modelname, let assetData: any = {
assetPosition, modeluuid,
modelfileID, modelname,
assetRotation, position,
isLocked, modelfileID,
isVisible, rotation,
}; isLocked,
if (eventData) { isVisible,
let pointRefs: any[] = []; };
if (eventData) {
if (Array.isArray(eventData.points)) { let pointRefs: any[] = [];
for (const point of eventData.points) {
let actionRefs: any[] = []; if (Array.isArray(eventData.points)) {
let triggerRefs: any[] = []; for (const point of eventData.points) {
let actionRefs: any[] = [];
if (Array.isArray(point.actions)) { let triggerRefs: any[] = [];
for (const action of point.actions) {
const actionDoc = await actionModel(organization).create({ if (Array.isArray(point.actions)) {
pointsUUID: point.uuid, for (const action of point.actions) {
isArchive: false, const actionDoc = await actionModel(organization).create({
uuid: action.uuid, pointsUUID: point.uuid,
name: action.name, isArchive: false,
type: action.type, uuid: action.uuid,
material: action.material, name: action.name,
delay: action.delay, type: action.type,
spawn_Interval: action.spawn_Interval, material: action.material,
}); delay: action.delay,
await actionDoc.save(); spawn_Interval: action.spawn_Interval,
actionRefs.push(actionDoc._id); });
} await actionDoc.save();
} actionRefs.push(actionDoc._id);
}
if (Array.isArray(point.triggers)) { }
for (const trigger of point.triggers) {
const triggerDoc = await triggerModel(organization).create({ if (Array.isArray(point.triggers)) {
pointsUUID: point.uuid, for (const trigger of point.triggers) {
isArchive: false, const triggerDoc = await triggerModel(organization).create({
uuid: trigger.uuid, pointsUUID: point.uuid,
name: trigger.name, isArchive: false,
type: trigger.type, uuid: trigger.uuid,
bufferTime: trigger.bufferTime, name: trigger.name,
}); type: trigger.type,
await triggerDoc.save(); bufferTime: trigger.bufferTime,
triggerRefs.push(triggerDoc._id); });
} await triggerDoc.save();
} triggerRefs.push(triggerDoc._id);
}
pointRefs.push({ }
uuid: point.uuid,
position: point.position || [], pointRefs.push({
rotation: point.rotation || [], uuid: point.uuid,
actions: actionRefs, position: point.position || [],
triggers: triggerRefs, rotation: point.rotation || [],
}); actions: actionRefs,
} triggers: triggerRefs,
} });
}
assetData.speed = eventData.speed; }
assetData.type = eventData.type;
assetData.points = pointRefs; assetData.speed = eventData.speed;
} assetData.type = eventData.type;
assetData.points = pointRefs;
const assetDoc = await assetModel(organization).create(assetData); }
await assetDoc.save();
// await assetDoc.save(); const assetDoc = await assetModel(organization).create(assetData);
return { success: true, message:"Model stored successfully", data: assetDoc, organization: organization } await assetDoc.save();
} // await assetDoc.save();
} catch (error:any) { // if(assetDoc.)
console.error("Error creating flooritems:", error); const assetDatas={
return { success: false, message: error?.message || "Error occurred while ModelAsset", error, organization: organization } modeluuid:assetDoc.modeluuid,modelname:assetDoc.modelname,modelfileID:assetDoc.modelfileID,position:assetDoc.position,rotation:assetDoc.rotation,isLocked:assetDoc.isLocked,isVisible:assetDoc.isVisible
} ,eventData:{points:assetDoc.points,type:assetDoc.type,speed:assetDoc.speed}
} }
return { success: true, message:"Model created successfully", data: assetDatas, organization: organization }
}
} catch (error:any) {
// console.error("Error creating flooritems:", error);
return { success: false, message: error?.message || "Error occurred while ModelAsset", error, organization: organization }
}
}
export const deleteAssetModel = async (data: any)=>{
const { modeluuid,modelname,organization } = data;
try {
const findValue = await assetModel(organization).findOneAndDelete({modeluuid:modeluuid,modelname:modelname})
if (!findValue) {
return { success: false, message: 'model not found',organization:organization }
} else {
return { success: true, message: 'Model deleted successfully', data: findValue,organization:organization }
}
} catch (error) {
// console.error('Error get flooritems:', error);
return { success: false, message: 'Failed to delete asset', error,organization:organization }
}
}

1
src/socket-server/services/camera/camera-Controller.ts
View File

@@ -4,7 +4,6 @@ import cameraModel from "../../../shared/model/camera/camera-Model.ts";
export const createCamera = async (data: any,) => { export const createCamera = async (data: any,) => {
const { userId, position, target, organization,rotation } = data const { userId, position, target, organization,rotation } = data
console.log('data: ', data);
try { try {

16
src/socket-server/services/lines/zone-controller.ts
View File

@@ -1,9 +1,7 @@
import zoneModel from "../../../shared/model/lines/zone-Model.ts"; import zoneModel from "../../../shared/model/builder/lines/zone-Model.ts";
export const setZone = async (data: any) => { export const setZone = async (data: any) => {
const { organization, userId, zoneData } = data
try { try {
const { organization, userId, zoneData } = data
console.log('data: ', data);
const zoneId = zoneData.zoneId const zoneId = zoneData.zoneId
const points = zoneData.points const points = zoneData.points
const zoneName = zoneData.zoneName const zoneName = zoneData.zoneName
@@ -18,7 +16,7 @@ export const setZone = async (data: any) => {
return { success: true, message: 'zone updated', data: updateZone, organization: organization } return { success: true, message: 'zone updated', data: updateZone, organization: organization }
} else { } else {
const zoneCreate = await zoneModel(organization).create({ const zoneCreate = await zoneModel(organization).create({
zoneId, createBy: userId, zoneName: zoneName, points, layer, viewPortCenter, viewPortposition zoneId, createdBy: userId, zoneName: zoneName, points, layer, viewPortCenter, viewPortposition
}) })
const createdZone = await zoneModel(organization) const createdZone = await zoneModel(organization)
.findById(zoneCreate._id) .findById(zoneCreate._id)
@@ -28,18 +26,18 @@ export const setZone = async (data: any) => {
} }
} catch (error) { } catch (error) {
console.log('error: ', error); console.log('error: ', error);
return { success: false, message: 'Zone not found', error } return { success: false, message: 'Zone not found', error , organization: organization}
} }
} }
export const deleteZone = async (data: any) => { export const deleteZone = async (data: any) => {
const { organization, userId, zoneId } = data
try { try {
const { organization, userId, zoneId } = data
const findZoneId = await zoneModel(organization).findOne({ zoneId: zoneId }) const findZoneId = await zoneModel(organization).findOne({ zoneId: zoneId })
if (findZoneId) { if (findZoneId) {
const deleteZone = await zoneModel(organization).findOneAndDelete( const deleteZone = await zoneModel(organization).findOneAndDelete(
{ zoneId: zoneId, createBy: userId } { zoneId: zoneId, createdBy: userId }
).select("-_id -__v") ).select("-_id -__v")
return { success: true, message: 'zone deleted', data: deleteZone, organization: organization } return { success: true, message: 'zone deleted', data: deleteZone, organization: organization }
} else { } else {
@@ -48,6 +46,6 @@ export const deleteZone = async (data: any) => {
} }
} catch (error) { } catch (error) {
console.log('error: ', error); console.log('error: ', error);
return { success: false, message: 'Zone not found', error } return { success: false, message: 'Zone not found', error, organization: organization }
} }
} }

38
src/socket-server/services/users/user-controller.ts
View File

@@ -3,6 +3,7 @@ import userModel from "../../../shared/model/user-Model.ts"
export const activeUsers = async (data: any) => { export const activeUsers = async (data: any) => {
const {organization}=data const {organization}=data
// console.log('data: ', data);
try { try {
if (data && data.email) { if (data && data.email) {
@@ -43,7 +44,7 @@ export const activeUsers = async (data: any) => {
// Handle the error or return a default value // Handle the error or return a default value
// Example: Return an error response if the email is invalid // Example: Return an error response if the email is invalid
return { success: false, message: 'Email is missing or invalid', } return { success: false, message: 'Email is missing or invalid', organization:organization }
// return res.status(400).send({ message: 'Email is missing or invalid' }); // return res.status(400).send({ message: 'Email is missing or invalid' });
} }
@@ -99,3 +100,38 @@ export const activeUserOffline = async (data: any) => {
// return { success: false, message: error} // return { success: false, message: error}
} }
} }
type OnlineUsersMap = Map<string, Set<string>>;
// export const addUserToOnlineList = async (
// organization: string,
// email: string,
// onlineUsers: OnlineUsersMap,
// socket: any,
// namespace: string
// ) => {
// if (!organization || !email) return;
// console.log('organization: ', organization);
// // Ensure the organization entry exists
// if (!onlineUsers.has(organization)) {
// onlineUsers.set(organization, new Set());
// }
// const findUser = await userModel(organization).findOne({email})
// if (!findUser) {
// return { success: false, message: "User not found", organization };
// }
// const userId = findUser._id;
// console.log(`🔍 Found user with ID: ${userId}`);
// // Add user to the online set
// onlineUsers.get(organization)!.add(userId);
// console.log(`✅ User ${userId} is online (Org: ${organization})`);
// // Emit updated online users list
// socket.emit("users:online", {
// organization,
// users: [...onlineUsers.get(organization)!],
// });
// };

116
src/socket-server/services/visualization/floatWidgetService.ts
View File

@@ -1,58 +1,58 @@
import floatWidgetModel from "../../../shared/model/vizualization/3dwidget.ts"; import floatWidgetModel from "../../../shared/model/vizualization/3dwidget.ts";
import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts"; import zoneSchema from "../../../shared/model/builder/lines/zone-Model.ts";
export const addfloat = async (data: any) => { export const addfloat = async (data: any) => {
const { organization, widget, zoneId } = data; const { organization, widget, zoneId } = data;
console.log('data: ', data); console.log('data: ', data);
try { try {
const existingZone = await zoneSchema(organization).findOne({ const existingZone = await zoneSchema(organization).findOne({
zoneId: zoneId, zoneId: zoneId,
isArchive: false, isArchive: false,
}); });
if (!existingZone) if (!existingZone)
return { success: false, message: "Zone not found for the zoneId", organization: organization } return { success: false, message: "Zone not found for the zoneId", organization: organization }
const existingFloatWidget = await floatWidgetModel(organization).findOne({ const existingFloatWidget = await floatWidgetModel(organization).findOne({
floatWidgetID: widget.id, floatWidgetID: widget.id,
isArchive: false, isArchive: false,
}); });
if (existingFloatWidget) { if (existingFloatWidget) {
const updateFloatWidget = await floatWidgetModel(organization).findOneAndUpdate( const updateFloatWidget = await floatWidgetModel(organization).findOneAndUpdate(
{ {
floatWidgetID: widget.id, floatWidgetID: widget.id,
isArchive: false, isArchive: false,
}, },
{ {
$set: { $set: {
// Data: { // Data: {
// // measurements: widget.Data.measurements || {}, // // measurements: widget.Data.measurements || {},
// duration: widget.Data.duration || "1h", // duration: widget.Data.duration || "1h",
// }, // },
position: widget.position, position: widget.position,
}, },
}, },
{ {
upsert: true, upsert: true,
new: true, new: true,
} }
); );
return { success: true, message: "Widget updated successfully", data: updateFloatWidget, organization: organization } return { success: true, message: "Widget updated successfully", data: updateFloatWidget, organization: organization }
} }
const newFloadWidget = await floatWidgetModel(organization).create({ const newFloadWidget = await floatWidgetModel(organization).create({
className: widget.className, className: widget.className,
header: widget.header, header: widget.header,
floatWidgetID: widget.id, floatWidgetID: widget.id,
position: widget.position, position: widget.position,
per: widget.per, per: widget.per,
value: widget.value, value: widget.value,
zoneId: zoneId, zoneId: zoneId,
}); });
if (newFloadWidget) { if (newFloadWidget) {
return { success: true, message: "FloatWidget created successfully", data: newFloadWidget, organization: organization } return { success: true, message: "FloatWidget created successfully", data: newFloadWidget, organization: organization }
} }
} catch (error: any) { } catch (error: any) {
return { success: false, message: error?.message || "Error occurred while float", error, organization: organization } return { success: false, message: error?.message || "Error occurred while float", error, organization: organization }
} }
} }

50
src/socket-server/services/visualization/templateServices.ts
View File

@@ -1,26 +1,26 @@
import templateModel from "../../../shared/model/vizualization/templatemodel.ts"; import templateModel from "../../../shared/model/vizualization/templatemodel.ts";
export const addTemplate = async (data: any) => { export const addTemplate = async (data: any) => {
const { organization, templateID, name, panelOrder, widgets, snapshot } =data; const { organization, templateID, name, panelOrder, widgets, snapshot } =data;
console.log('data: ', data); console.log('data: ', data);
try { try {
const existingTemplate = await templateModel(organization).findOne({ const existingTemplate = await templateModel(organization).findOne({
templateID: templateID, templateID: templateID,
isArchive: false, isArchive: false,
}); });
if (existingTemplate) if (existingTemplate)
return { success: false, message: "TemplateID alreay exists", organization: organization } return { success: false, message: "TemplateID alreay exists", organization: organization }
const newTemplate = await templateModel(organization).create({ const newTemplate = await templateModel(organization).create({
templateID, templateID,
name, name,
panelOrder, panelOrder,
widgets, widgets,
snapshot, snapshot,
}); });
if (newTemplate) if (newTemplate)
return { success: false, message: "Template saved successfully", data: newTemplate, organization: organization } return { success: false, message: "Template saved successfully", data: newTemplate, organization: organization }
} catch (error: any) { } catch (error: any) {
return { success: false, message: error?.message || "Error occurred while template", error, organization: organization } return { success: false, message: error?.message || "Error occurred while template", error, organization: organization }
} }
} }

236
src/socket-server/services/visualization/widget-Services.ts
View File

@@ -1,119 +1,119 @@
import panelSchema from "../../../shared/model/vizualization/panelmodel.ts"; import panelSchema from "../../../shared/model/vizualization/panelmodel.ts";
import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts"; import widgetSchema from "../../../shared/model/vizualization/widgemodel.ts";
export const addWidget = async (data: any) => { export const addWidget = async (data: any) => {
const { organization,panel,zoneId,widget,} = data const { organization,panel,zoneId,widget,} = data
console.log('data: ', data); console.log('data: ', data);
try { try {
const existingPanel = await panelSchema(organization).findOne({ const existingPanel = await panelSchema(organization).findOne({
panelName: widget.panel, panelName: widget.panel,
zoneId: zoneId, zoneId: zoneId,
isArchive: false, isArchive: false,
}); });
if (!existingPanel) if (!existingPanel)
return { success: false, message: "panelName not found",organization: organization} return { success: false, message: "panelName not found",organization: organization}
if (existingPanel.panelName === widget.panel) { if (existingPanel.panelName === widget.panel) {
const existingWidget = await widgetSchema(organization).findOne({ const existingWidget = await widgetSchema(organization).findOne({
panelID: existingPanel._id, panelID: existingPanel._id,
widgetID: widget.id, widgetID: widget.id,
isArchive: false, isArchive: false,
// widgetOrder: widget.widgetOrder, // widgetOrder: widget.widgetOrder,
}); });
if (existingWidget) { if (existingWidget) {
const updateWidget = await widgetSchema( const updateWidget = await widgetSchema(
organization organization
).findOneAndUpdate( ).findOneAndUpdate(
{ {
panelID: existingPanel._id, panelID: existingPanel._id,
widgetID: widget.id, widgetID: widget.id,
isArchive: false, isArchive: false,
}, },
{ {
$set: { $set: {
panelID: existingPanel._id, panelID: existingPanel._id,
widgetID: widget.id, widgetID: widget.id,
Data: { Data: {
measurements: widget.Data.measurements, measurements: widget.Data.measurements,
duration: widget.Data.duration, duration: widget.Data.duration,
}, },
isArchive: false, isArchive: false,
}, },
}, },
{ upsert: true, new: true } // Upsert: create if not exists, new: return updated document { upsert: true, new: true } // Upsert: create if not exists, new: return updated document
); );
return { success: false, message: "Widget updated successfully",data:updateWidget,organization: organization} return { success: false, message: "Widget updated successfully",data:updateWidget,organization: organization}
} }
const newWidget = await widgetSchema(organization).create({ const newWidget = await widgetSchema(organization).create({
widgetID: widget.id, widgetID: widget.id,
elementType: widget.type, elementType: widget.type,
// widgetOrder: widgetOrder, // widgetOrder: widgetOrder,
widgetName: widget.widgetName, widgetName: widget.widgetName,
panelID: existingPanel._id, panelID: existingPanel._id,
widgetside: widget.panel, widgetside: widget.panel,
// Data: { // Data: {
// measurements: widget.Data.measurements || {}, // measurements: widget.Data.measurements || {},
// duration: widget.Data.duration || "1hr", // duration: widget.Data.duration || "1hr",
// }, // },
}); });
if (newWidget) { if (newWidget) {
existingPanel.widgets.push(newWidget._id); existingPanel.widgets.push(newWidget._id);
await existingPanel.save(); await existingPanel.save();
return { success: true, message: "Widget already exist for the widgetID",data:existingPanel,organization: organization} return { success: true, message: "Widget already exist for the widgetID",data:existingPanel,organization: organization}
} }
} }
return { success: false, message: "Type mismatch",organization: organization} return { success: false, message: "Type mismatch",organization: organization}
} catch (error: any) { } catch (error: any) {
return { success: false, message: 'widge not found', error,organization: organization } return { success: false, message: 'widge not found', error,organization: organization }
} }
} }
export const Widgetdelete = async (data: any) => { export const Widgetdelete = async (data: any) => {
const { widgetID, organization } = data const { widgetID, organization } = data
console.log('data: ', data); console.log('data: ', data);
try { try {
const findWidget = await widgetSchema(organization).findOne({ const findWidget = await widgetSchema(organization).findOne({
widgetID: widgetID, widgetID: widgetID,
isArchive: false, isArchive: false,
}); });
if (!findWidget) if (!findWidget)
return { success: false, message: "Widget not found",organization: organization} return { success: false, message: "Widget not found",organization: organization}
const widgetData = await widgetSchema(organization).updateOne( const widgetData = await widgetSchema(organization).updateOne(
{ _id: findWidget._id, isArchive: false }, { _id: findWidget._id, isArchive: false },
{ $set: { isArchive: true } } { $set: { isArchive: true } }
); );
if (widgetData) { if (widgetData) {
// Find all widgets in the same panel and sort them by widgetOrder // Find all widgets in the same panel and sort them by widgetOrder
const widgets = await widgetSchema(organization).find({ const widgets = await widgetSchema(organization).find({
panelID: findWidget.panelID, panelID: findWidget.panelID,
isArchive: false, isArchive: false,
}); });
// .sort({ widgetOrder: 1 }); // .sort({ widgetOrder: 1 });
// Reassign widgetOrder values // Reassign widgetOrder values
// for (let i = 0; i < widgets.length; i++) { // for (let i = 0; i < widgets.length; i++) {
// widgets[i].widgetOrder = (i + 1).toString(); // Convert to string // widgets[i].widgetOrder = (i + 1).toString(); // Convert to string
// await widgets[i].save(); // await widgets[i].save();
// } // }
const panelData = await panelSchema(organization).findOne({ const panelData = await panelSchema(organization).findOne({
_id: findWidget.panelID, _id: findWidget.panelID,
isArchive: false, isArchive: false,
}); });
if (panelData.widgets.includes(findWidget._id)) { if (panelData.widgets.includes(findWidget._id)) {
const index1 = panelData.widgets.indexOf(findWidget._id); const index1 = panelData.widgets.indexOf(findWidget._id);
panelData.widgets.splice(index1, 1); panelData.widgets.splice(index1, 1);
} }
const panelDeletedata = await panelData.save(); const panelDeletedata = await panelData.save();
console.log('Widget deleted successfully: '); console.log('Widget deleted successfully: ');
return { success: false, message: "Widget deleted successfully",data:panelDeletedata,organization: organization} return { success: false, message: "Widget deleted successfully",data:panelDeletedata,organization: organization}
} }
} catch (error: any) { } catch (error: any) {
return { success: false, message: error?.message || "An unknown error occurred.", error ,organization: organization} return { success: false, message: error?.message || "An unknown error occurred.", error ,organization: organization}
} }
} }

8
src/socket-server/socket/events.ts
View File

@@ -2,8 +2,8 @@ export const EVENTS = {
connection: "connection", connection: "connection",
disconnect:"disconnect", disconnect:"disconnect",
//userActiveStatus //userActiveStatus
userConnect:"userConnectRespones", userConnect:"userConnectResponse",
userDisConnect:"userDisConnectRespones", userDisConnect:"userDisConnectResponse",
// Room management events // Room management events
joinRoom: 'joinRoom', joinRoom: 'joinRoom',
createroom: "createRoom", // When a client joins a room createroom: "createRoom", // When a client joins a room
@@ -73,4 +73,8 @@ export const EVENTS = {
//model-asset //model-asset
setAssetModel: "v2:model-asset:add", setAssetModel: "v2:model-asset:add",
assetUpdateRespones: "model-asset:response:updates", assetUpdateRespones: "model-asset:response:updates",
deleteAssetModel:"v2:model-asset:delete",
assetDeleteRespones: "model-asset:response:updates",
} }

1040
src/socket-server/socket/socketManager.ts
View File

File diff suppressed because it is too large Load Diff