1186 lines
42 KiB
TypeScript
1186 lines
42 KiB
TypeScript
import { Server, Socket } from 'socket.io';
|
|
import { EVENTS } from './events.ts';
|
|
import { createCamera } from '../services/camera/camera-Controller.ts';
|
|
import { setEnvironment } from '../services/environments/environments-controller.ts';
|
|
import { deleteFloorItems, setFloorItems } from '../services/assets/flooritem-Controller.ts';
|
|
import { deleteWallItems, setWallItems } from '../services/assets/wallitem-Controller.ts';
|
|
import { deleteLineItems, deleteLinPoiteItems, updateLineItems, createLineItems, deleteLayer } from '../services/lines/line-Controller.ts';
|
|
import { activeUserOffline, activeUsers, } from '../services/users/user-controller.ts';
|
|
import { deleteZone, setZone } from '../services/lines/zone-controller.ts';
|
|
import { addPanel, panelClear, panelDelete, panelLocked } from '../services/visualization/panel-Services.ts';
|
|
import { addWidget, Widgetdelete } from '../services/visualization/widget-Services.ts';
|
|
import { addfloat, deletefloat, duplicatefloat } from '../services/visualization/floatWidget-Service.ts';
|
|
import { addTemplate, addTemplateZone, TemplateZoneDelete } from '../services/visualization/templateServices.ts';
|
|
import { deleteAssetModel, replaceEventDatas, setAssetModel } from '../services/assets/asset-Controller.ts';
|
|
import { add3Dwidget, delete3Dwidget, update3D } from '../services/visualization/3dWidget-Service.ts';
|
|
|
|
|
|
|
|
|
|
const cameraHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false) => {
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
|
|
case EVENTS.setCamera: {
|
|
result = await createCamera(data);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.cameraUpdateResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// case EVENTS.deleteWidget: {
|
|
// const result = await Widgetdelete(data)
|
|
// if (result) {
|
|
// // console.log('result?.success: ', result.organization);
|
|
// const responseEvent = EVENTS.widgetDeleteResponse
|
|
// // console.log('responseEvent: ', responseEvent);
|
|
// const organization = result?.organization
|
|
// // console.log('organization: ', organization);
|
|
// // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
// // console.log('emitTarget: ', emitTarget);
|
|
// if (organization) {
|
|
// socket.emit(responseEvent, {
|
|
// success: result.success,
|
|
// message: result.message,
|
|
// data: result.data,
|
|
// error: result.error || null,
|
|
// socketId: socket.id,
|
|
// organization,
|
|
// });
|
|
// } else {
|
|
// console.warn(`Organization missing in response for event: ${event}`);
|
|
// }
|
|
// }
|
|
// break
|
|
// }
|
|
|
|
|
|
}
|
|
}
|
|
const EnvironmentHandleEvent = async (event: string, socket: Socket, data: any, io: any) => {
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.setenvironment: {
|
|
result = await setEnvironment(data);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.EnvironmentUpdateResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// case EVENTS.deleteWidget: {
|
|
// const result = await Widgetdelete(data)
|
|
// if (result) {
|
|
// // console.log('result?.success: ', result.organization);
|
|
// const responseEvent = EVENTS.widgetDeleteResponse
|
|
// // console.log('responseEvent: ', responseEvent);
|
|
// const organization = result?.organization
|
|
// // console.log('organization: ', organization);
|
|
// // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
// // console.log('emitTarget: ', emitTarget);
|
|
// if (organization) {
|
|
// socket.emit(responseEvent, {
|
|
// success: result.success,
|
|
// message: result.message,
|
|
// data: result.data,
|
|
// error: result.error || null,
|
|
// socketId: socket.id,
|
|
// organization,
|
|
// });
|
|
// } else {
|
|
// console.warn(`Organization missing in response for event: ${event}`);
|
|
// }
|
|
// }
|
|
// break
|
|
// }
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
const floorItemsHandleEvent = async (event: string, socket: Socket, data: any, io: any) => {
|
|
switch (event) {
|
|
|
|
case EVENTS.setFloorItems: {
|
|
const result = await setFloorItems(data);
|
|
// console.log('result: ', result);
|
|
if (result.success) {
|
|
io.emit(EVENTS.FloorItemsUpdateResponse, {
|
|
success: true || false,
|
|
message: result.message,
|
|
data: result.data,
|
|
socketId: socket.id,
|
|
organization: result.organization
|
|
|
|
});
|
|
|
|
} else {
|
|
// Emit error response
|
|
socket.emit(EVENTS.floorItemError, {
|
|
success: false,
|
|
message: result.message,
|
|
error: result.error,
|
|
socketId: socket.id,
|
|
organization: result.organization
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case EVENTS.deleteFloorItems: {
|
|
const result = await deleteFloorItems(data);
|
|
// console.log('result: ', result);
|
|
if (result.success) {
|
|
|
|
|
|
io.emit(EVENTS.FloorItemsDeleteResponse, {
|
|
success: true || false,
|
|
message: result.message,
|
|
data: result.data,
|
|
socketId: socket.id,
|
|
organization: result.organization
|
|
|
|
});
|
|
|
|
} else {
|
|
// Emit error response
|
|
socket.emit(EVENTS.floorItemError, {
|
|
success: false,
|
|
message: result.message,
|
|
error: result.error,
|
|
socketId: socket.id,
|
|
organization: result.organization
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// console.error(`Unhandled event type: ${event}`);
|
|
}
|
|
}
|
|
const wallItemsHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.setWallItems: {
|
|
result = await setWallItems(data);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.wallItemsUpdateResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.deleteWallItems: {
|
|
const result = await deleteWallItems(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.wallItemsDeleteResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
// console.log('organization: ', organization);
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
// console.log('emitTarget: ', emitTarget);
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
}
|
|
const lineHandleEvent =async (event: string, socket: Socket, data: any,io:any) => {
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.createLine: {
|
|
result = await createLineItems(data);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.createLineResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.updateLine: {
|
|
const result = await updateLineItems(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.updateLineResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
// console.log('organization: ', organization);
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
// console.log('emitTarget: ', emitTarget);
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.deleteLine: {
|
|
const result = await deleteLineItems(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.deleteLineResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
// console.log('organization: ', organization);
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
// console.log('emitTarget: ', emitTarget);
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.deletePoint: {
|
|
const result = await deleteLinPoiteItems(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.deletePointResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
default:
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
const userStatus =async (event: string, socket: Socket, data: any,io:any) => {
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.connection: {
|
|
result = await activeUsers(data);
|
|
// console.log('result: ', result);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.userConnect
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.disconnect: {
|
|
const result = await activeUserOffline(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.userDisConnect
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || "disconnectError",
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
}
|
|
const zoneHandleEvent = async (event: string, socket: Socket, data: any, io: any) => {
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.setZone: {
|
|
result = await setZone(data);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.zoneUpdateResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.deleteZone: {
|
|
const result = await deleteZone(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.ZoneDeleteResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
const panelHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false) => {
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.addPanel: {
|
|
result = await addPanel(data);
|
|
if (result) {
|
|
const responseEvent = EVENTS.panelUpdateResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
// console.log('emitTarget: ', emitTarget);
|
|
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error,
|
|
socketId: socket.id,
|
|
organization: result.organization,
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case EVENTS.deletePanel: {
|
|
const result = await panelDelete(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.PanelDeleteResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.clearPanel: {
|
|
const result = await panelClear(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.PanelClearResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.lockedPanel: {
|
|
const result = await panelLocked(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.PanelLockedResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
const widgetHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false,callback:any) => {
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.addWidget: {
|
|
result = await addWidget(data,callback);
|
|
// console.log('result: ', result);
|
|
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.widgetUpdateResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.deleteWidget: {
|
|
const result = await Widgetdelete(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.widgetDeleteResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
}
|
|
const floatHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false,callback:any) => {
|
|
// console.log('data: ', data);
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.addFloat: {
|
|
result = await addfloat(data);
|
|
// console.log('result: ', result);
|
|
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.floatUpdateResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.deleteFloat: {
|
|
const result = await deletefloat(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.floatDeleteResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.duplicatefloat: {
|
|
const result = await duplicatefloat(data,callback)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.duplicatefloatUpdateResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
default:
|
|
return;
|
|
}
|
|
|
|
}
|
|
const templateHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false) => {
|
|
// console.log('data: ', data);
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.addTemplate: {
|
|
result = await addTemplate(data);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.templateUpdateResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.addTemplateZone: {
|
|
const result = await addTemplateZone(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.addTemplateZoneResponse
|
|
// console.log('responseEvent: ', responseEvent
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.deleteTemplate: {
|
|
const result = await TemplateZoneDelete(data)
|
|
if (result) {
|
|
// console.log('result?.success: ', result.organization);
|
|
const responseEvent = EVENTS.TemplateDeleteResponse
|
|
// console.log('responseEvent: ', responseEvent);
|
|
const organization = result?.organization
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
}
|
|
const Widget3DHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false,callback:any ) => {
|
|
// console.log('data: ', data);
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.add3DWidget: {
|
|
result = await add3Dwidget(data,callback);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.widget3DUpdateResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.update3dPosition: {
|
|
result = await update3D(data);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.update3dPositionResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case EVENTS.delete3DWidget: {
|
|
result = await delete3Dwidget(data);
|
|
|
|
if (result) {
|
|
const responseEvent = EVENTS.widget3DDeleteResponse
|
|
const organization = result?.organization
|
|
// const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
if (organization) {
|
|
socket.to(organization).emit(responseEvent, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
}
|
|
break
|
|
}
|
|
|
|
// case EVENTS.deleteWidget: {
|
|
// const result = await Widgetdelete(data)
|
|
// if (result) {
|
|
// // console.log('result?.success: ', result.organization);
|
|
// const responseEvent = EVENTS.widgetDeleteResponse
|
|
// // console.log('responseEvent: ', responseEvent);
|
|
// const organization = result?.organization
|
|
// // console.log('organization: ', organization);
|
|
// // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
// // console.log('emitTarget: ', emitTarget);
|
|
// if (organization) {
|
|
// socket.emit(responseEvent, {
|
|
// success: result.success,
|
|
// message: result.message,
|
|
// data: result.data,
|
|
// error: result.error || null,
|
|
// socketId: socket.id,
|
|
// organization,
|
|
// });
|
|
// } else {
|
|
// console.warn(`Organization missing in response for event: ${event}`);
|
|
// }
|
|
// }
|
|
// break
|
|
// }
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
}
|
|
const modelAssetHandleEvent = async (event: string, socket: Socket, data: any, namespace: any, notifySender: boolean = false) => {
|
|
// console.log('data: ', data);
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
|
|
let result;
|
|
switch (event) {
|
|
case EVENTS.setAssetModel:
|
|
result = await setAssetModel(data);
|
|
if (result) emitEventResponse(socket, result.organization, EVENTS.assetUpdateResponse, result);
|
|
break;
|
|
case EVENTS.deleteAssetModel:
|
|
result = await deleteAssetModel(data);
|
|
if (result) emitEventResponse(socket, result.organization, EVENTS.assetDeleteResponse, result);
|
|
break;
|
|
case EVENTS.assetEventData:
|
|
result = await replaceEventDatas(data);
|
|
if (result) emitEventResponse(socket, result.organization, EVENTS.assetEventDataResponse, result);
|
|
break;
|
|
// case EVENTS.setAssetModel: {
|
|
// result = await setAssetModel(data);
|
|
|
|
// if (result) {
|
|
// const responseEvent = EVENTS.assetUpdateResponse
|
|
// const organization = result?.organization
|
|
// // const emitTarget = notifySender ? socket.in(organization) : socket.to(organization);
|
|
// // console.log(`👀 Active sockets in room:`, namespace.adapter.rooms.get(organization));
|
|
// if (organization) {
|
|
// socket.to(organization).emit(responseEvent, {
|
|
// success: result.success,
|
|
// message: result.message,
|
|
// data: result.data,
|
|
// error: result.error || null,
|
|
// socketId: socket.id,
|
|
// organization,
|
|
// });
|
|
// } else {
|
|
// console.warn(`Organization missing in response for event: ${event}`);
|
|
// }
|
|
// }
|
|
// break
|
|
// }
|
|
// case EVENTS.deleteAssetModel: {
|
|
// const result = await deleteAssetModel(data)
|
|
// if (result) {
|
|
// // console.log('result?.success: ', result.organization);
|
|
// const responseEvent = EVENTS.assetDeleteResponse
|
|
// // console.log('responseEvent: ', responseEvent);
|
|
// const organization = result?.organization
|
|
// if (organization) {
|
|
// socket.to(organization).emit(responseEvent, {
|
|
// success: result.success,
|
|
// message: result.message,
|
|
// data: result.data,
|
|
// error: result.error || null,
|
|
// socketId: socket.id,
|
|
// organization,
|
|
// });
|
|
// } else {
|
|
// console.warn(`Organization missing in response for event: ${event}`);
|
|
// }
|
|
// }
|
|
// break
|
|
// }
|
|
// case EVENTS.assetEventData: {
|
|
// const result = await replaceEventDatas(data)
|
|
// if (result) {
|
|
// // console.log('result?.success: ', result.organization);
|
|
// const responseEvent = EVENTS.assetEventDataResponse
|
|
// // console.log('responseEvent: ', responseEvent);
|
|
// const organization = result?.organization
|
|
// if (organization) {
|
|
// socket.to(organization).emit(responseEvent, {
|
|
// success: result.success,
|
|
// message: result.message,
|
|
// data: result.data,
|
|
// error: result.error || null,
|
|
// socketId: socket.id,
|
|
// organization,
|
|
// });
|
|
// } else {
|
|
// console.warn(`Organization missing in response for event: ${event}`);
|
|
// }
|
|
// }
|
|
// break
|
|
// }
|
|
default:
|
|
return;
|
|
}
|
|
|
|
}
|
|
const simulationHandleEvent = async (event: string, socket: Socket, data: any,) => {
|
|
// console.log('data: ', data);
|
|
if (!data?.organization) {
|
|
console.warn(`Missing organization for event: ${event}`);
|
|
return;
|
|
}
|
|
let result;
|
|
try {
|
|
switch (event) {
|
|
case EVENTS.setAssetModel:
|
|
result = await addTemplate(data);
|
|
if (result) emitEventResponse(socket, result.organization, EVENTS.zoneUpdateResponse, result);
|
|
break;
|
|
default:
|
|
console.warn(`❌ Unknown event received: ${event}`);
|
|
}
|
|
} catch (error) {
|
|
console.error(`❌ Error handling event ${event}:`, error);
|
|
|
|
}
|
|
|
|
}
|
|
const emitEventResponse = (socket: Socket, organization: string, event: string, result: any) => {
|
|
if (organization) {
|
|
socket.to(organization).emit(event, {
|
|
success: result.success,
|
|
message: result.message,
|
|
data: result.data,
|
|
error: result.error || null,
|
|
socketId: socket.id,
|
|
organization,
|
|
});
|
|
} else {
|
|
console.warn(`Organization missing in response for event: ${event}`);
|
|
}
|
|
};
|
|
|
|
export const initSocketServer = (httpServer: any) => {
|
|
const io = new Server(httpServer, {
|
|
cors: {
|
|
origin: '*', // Allow CORS for all origins (adjust in production)
|
|
methods: ['GET', 'POST'],
|
|
},
|
|
});
|
|
|
|
|
|
// Listen for new connections
|
|
// io.on(EVENTS.connection, (socket: Socket) => {
|
|
// // console.log(`New client connected: ${socket.id}`);
|
|
// // console.log(socket.handshake.auth);
|
|
// userStatus(EVENTS.connection, socket, socket.handshake.auth, io);
|
|
// // console.log('socket.handshake.auth: ', socket.handshake.auth);
|
|
|
|
// // Handle all incoming events with the handleEvent function
|
|
// socket.onAny((event: string, data: any,) => {
|
|
// cameraHandleEvent(event, socket, data, io);
|
|
// EnvironmentHandleEvent(event, socket, data, io);
|
|
// floorItemsHandleEvent(event, socket, data, io);
|
|
// wallItemsHandleEvent(event, socket, data, io);
|
|
// lineHandleEvent(event, socket, data, io);
|
|
// zoneHandleEvent(event, socket, data, io);
|
|
|
|
|
|
// });
|
|
// socket.on(EVENTS.disconnect, (reason: string) => {
|
|
// // console.log(`Client disconnected: ${socket.id}, Reason: ${reason}`);
|
|
// // console.log(socket.handshake.auth);
|
|
// userStatus(EVENTS.disconnect, socket, socket.handshake.auth, io);
|
|
// // Perform cleanup or other necessary actions
|
|
// });
|
|
// });
|
|
// 🔹 Create different namespaces
|
|
const namespaces = {
|
|
// camera: io.of("/camera"),
|
|
// environment: io.of("/environment"),
|
|
// floorItems: io.of("/floorItems"),
|
|
// wallItems: io.of("/wallItems"),
|
|
// line: io.of("/line"),
|
|
// zone: io.of("/zone"),
|
|
Builder: io.of('/Builder'),
|
|
visualization: io.of('/Visualization'),
|
|
// widget:io.of('/widget')
|
|
};
|
|
|
|
// const onlineUsers = new Map<string, Set<string>>();
|
|
const onlineUsers: { [organization: string]: Set<string> } = {};
|
|
|
|
|
|
const handleNamespace = (namespaceName: string, namespace: any, ...eventHandlers: Function[]) => {
|
|
|
|
namespace.on("connection", (socket: Socket) => {
|
|
// console.log(`✅ Client connected to ${namespaceName}: ${socket.id}`);
|
|
// Extract organization from query parameters
|
|
|
|
// const organization = socket.handshake.query.organization as string;
|
|
// const email = socket.handshake.query.email as string;
|
|
const {organization,email} = socket.handshake.auth
|
|
// console.log(`🔍 Received organization: ${organization}`);
|
|
|
|
if (organization) {
|
|
socket.join(organization);
|
|
// console.log(`🔹 Socket ${socket.id} joined room: ${organization}`);
|
|
}
|
|
// Handle all events
|
|
if (organization && email) {
|
|
if (!onlineUsers[organization]) {
|
|
onlineUsers[organization] = new Set();
|
|
}
|
|
onlineUsers[organization].add(socket.id);
|
|
// console.log('onlineUsers: ', onlineUsers);
|
|
|
|
// console.log(`✅ User ${email} joined ${organization}. Active users:`, onlineUsers[organization]);
|
|
}
|
|
|
|
userStatus(EVENTS.connection, socket, socket.handshake.auth, socket);
|
|
|
|
socket.onAny((event: string, data: any ,callback:any) => {
|
|
eventHandlers.forEach(handler => handler(event, socket, data, namespace,io,callback));
|
|
});
|
|
|
|
// Handle disconnection
|
|
socket.on("disconnect", () => {
|
|
onlineUsers[organization]?.delete(socket.id);
|
|
if (onlineUsers[organization]?.size === 0) delete onlineUsers[organization];
|
|
userStatus(EVENTS.disconnect, socket, socket.handshake.auth, socket);
|
|
// console.log(`❌ User ${email} disconnected. Remaining:`, onlineUsers[organization]);
|
|
// console.log(`❌ Client disconnected from ${namespaceName}: ${socket.id}, Reason: ${reason}`);
|
|
});
|
|
|
|
// Handle reconnection (Auto rejoin)
|
|
socket.on("reconnect", (attempt: number) => {
|
|
// console.log(`🔄 Socket ${socket.id} reconnected to ${namespaceName} (Attempt ${attempt})`);
|
|
if (organization) {
|
|
socket.join(organization);
|
|
// console.log(`♻️ Rejoined room: ${organization}`);
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
|
|
// 🔹 Apply namespace handlers
|
|
// handleNamespace("camera", namespaces.camera, cameraHandleEvent);
|
|
// handleNamespace("environment", namespaces.environment, EnvironmentHandleEvent);
|
|
// handleNamespace("floorItems", namespaces.floorItems, floorItemsHandleEvent);
|
|
// handleNamespace("wallItems", namespaces.wallItems, wallItemsHandleEvent);
|
|
// handleNamespace("line", namespaces.line, lineHandleEvent);
|
|
// handleNamespace("zone", namespaces.zone, zoneHandleEvent);
|
|
// handleNamespace("visualization", namespaces.panel, panelHandleEvent);
|
|
// handleNamespace("widget", namespaces.visualization, widgetHandleEvent);
|
|
handleNamespace("Builder", namespaces.Builder, userStatus,modelAssetHandleEvent, cameraHandleEvent, EnvironmentHandleEvent, wallItemsHandleEvent, lineHandleEvent,zoneHandleEvent);
|
|
handleNamespace("Visualization", namespaces.visualization, panelHandleEvent, widgetHandleEvent, floatHandleEvent, templateHandleEvent,Widget3DHandleEvent);
|
|
|
|
return io;
|
|
};
|