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

Controller and routing for the Vizualtion and builder

Browse Source
This commit is contained in:
Nivetharamesh
2025-05-29 15:34:12 +05:30
parent bea6044b25
commit c38a698692
34 changed files with 2523 additions and 926 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,5 +1,5 @@
import * as express from "express";
import { PanelService } from "../controller/visualization/PanelService.ts";
import { PanelService } from "../controller/visualization/panelService.ts";
const router = express.Router();
/**
* @swagger

131
src/api-server/V1/v1Controllers/builderController/v1EnvironmentController.ts Normal file
View File

@@ -0,0 +1,131 @@
import { Response } from "express";
import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
import {
getEnvironment,
setEnvironment,
} from "../../../../shared/services/builder/EnvironmentService.ts";
export const SetEnvironmentController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const {
roofVisibility,
renderDistance,
limitDistance,
wallVisibility,
shadowVisibility,
projectId,
} = req.body;
if (
!organization ||
!userId ||
!roofVisibility ||
!wallVisibility ||
!renderDistance ||
!limitDistance ||
!shadowVisibility ||
!projectId
) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const data = {
roofVisibility,
wallVisibility,
shadowVisibility,
organization,
projectId,
userId,
renderDistance,
limitDistance,
};
const result = await setEnvironment(data);
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "environments updated":
res.status(200).json(result.data);
break;
case "Success":
res.status(201).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
console.log("error: ", error);
res.status(500).json({
message: "Unknown error",
});
}
};
export const GetEnvironmentController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId } = req.params;
if (!organization || !userId || !projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const data = {
organization,
projectId,
userId,
};
const result = await getEnvironment(data);
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "Environment Not found for the User":
res.status(404).json({
message: "Environment Not found for the User",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
console.log("error: ", error);
res.status(500).json({
message: "Unknown error",
});
}
};

277
src/api-server/V1/v1Controllers/builderController/v1LineController.ts
View File

@@ -0,0 +1,277 @@
import { Response } from "express";
import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
import {
CreateLineItems,
DeleteLayer,
DeleteLineItems,
DeleteLinePoints,
GetLinesService,
UpdateLineItems,
} from "../../../../shared/services/builder/lineService.ts";
export const NewLineController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { line, type, layer, projectId } = req.body;
if (!organization || !userId || !line || !type || !layer || !projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const data = {
line,
type,
layer,
projectId,
organization,
userId,
};
const result = await CreateLineItems(data);
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Success":
res.status(201).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
console.log("error: ", error);
res.status(500).json({
message: "Unknown error",
});
}
};
export const UpdateLineController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { uuid, position, projectId } = req.body;
if (!organization || !userId || !uuid || !position || projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await UpdateLineItems({
organization,
projectId,
uuid,
position,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Success":
res.status(201).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const DeleteLineController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId, line } = req.body;
if (!organization || !userId || !projectId || !line) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await DeleteLineItems({
organization,
projectId,
line,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "line not found":
res.status(404).json({
message: "data not found",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const DeleteLayerController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId, layer } = req.body;
if (!organization || !userId || !projectId || !layer) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await DeleteLayer({
organization,
projectId,
layer,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "layer not found":
res.status(404).json({
message: "data not found",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const DeleteLinePointsController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId, uuid } = req.body;
if (!organization || !userId || !projectId || !uuid) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await DeleteLinePoints({
organization,
projectId,
uuid,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Line not found":
res.status(404).json({
message: "data not found",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const GetLinesController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId } = req.params;
if (!organization || !userId || !projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await GetLinesService({
organization,
projectId,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};

327
src/api-server/V1/v1Controllers/builderController/v1assetController.ts
View File

@@ -0,0 +1,327 @@
import { Response } from "express";
import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
import {
deleteAssetModel,
getFloorItems,
replaceEventDatas,
setAssetModel,
updateAssetPositionRotation,
} from "../../../../shared/services/builder/assetService.ts";
export const CreateAssetController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const {
modelUuid,
modelName,
position,
rotation,
eventData,
modelfileID,
isLocked,
isVisible,
projectId,
} = req.body;
if (
!organization ||
!userId ||
!isLocked ||
!isVisible ||
!position ||
!rotation ||
!modelfileID ||
!modelName ||
!projectId ||
!modelUuid
) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const data = {
organization,
userId,
modelUuid,
modelName,
position,
rotation,
eventData,
modelfileID,
isLocked,
isVisible,
projectId,
};
const result = await setAssetModel(data);
switch (result.status) {
case "User not found":
res.status(200).json({
message: "User not found",
});
break;
case "Project not found":
res.status(200).json({
message: "Project not found",
});
break;
case "Updated successfully":
res.status(200).json(result.data);
break;
case "Success":
res.status(200).json({
message: "Model stored successfully",
});
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
console.log("error: ", error);
res.status(500).json({
message: "Unknown error",
});
}
};
export const DeleteAssetController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { modelUuid, modelName, projectId } = req.body;
if (!organization || !userId || !modelUuid || !projectId || !modelName) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await deleteAssetModel({
organization,
modelName,
modelUuid,
projectId,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "model not found":
res.status(404).json({
message: "Model not found",
});
break;
case "Failed to archive asset":
res.status(200).json({
message: "Failed to archive asset",
});
break;
case "Success":
res.status(200).json({
message: "Asset Deleted successfully",
});
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const GetAssetController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId } = req.params;
if (!organization || !userId || !projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await getFloorItems({
organization,
projectId,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "floorItems not found":
res.status(404).json({
message: "floorItems not found",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const ReplaceEventDataController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { modelUuid, eventData, projectId } = req.body;
if (!organization || !userId || !projectId || !modelUuid || !eventData) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await replaceEventDatas({
modelUuid,
organization,
eventData,
projectId,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "Model not for this UUID":
res.status(404).json({
message: "Model not for this UUID",
});
break;
case "Success":
res.status(200).json({ message: "Data updated successfully" });
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const AssetUpdatePosRotController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const {
modelUuid,
modelName,
position,
rotation,
isLocked,
isVisible,
projectId,
} = req.body;
if (
!organization ||
!userId ||
!isLocked ||
!isVisible ||
!position ||
!rotation ||
!modelName ||
!projectId ||
!modelUuid
) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await updateAssetPositionRotation({
organization,
userId,
modelUuid,
modelName,
position,
rotation,
isLocked,
isVisible,
projectId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "Asset not found":
res.status(404).json({
message: "Asset not found",
});
break;
case "Success":
res.status(200).json({ message: "Asset updated successfully" });
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};

43
src/api-server/V1/v1Controllers/builderController/v1cameraController.ts
View File

@@ -1,8 +1,9 @@
import { Request, Response } from "express";
import { Response } from "express";
import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
import {
GetCamers,
onlineActiveDatas,
SetCamera,
} from "../../../../shared/services/builder/cameraService.ts";
@@ -75,6 +76,7 @@ export const CameraList = async (
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId } = req.params;
if (!organization || !userId) {
res.status(400).json({
message: "All fields are required",
@@ -84,6 +86,7 @@ export const CameraList = async (
const result = await GetCamers({
organization,
userId,
projectId,
});
switch (result.status) {
@@ -110,3 +113,41 @@ export const CameraList = async (
});
}
};
export const ActiveOnlineController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
if (!organization || !userId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await onlineActiveDatas({
organization,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};

46
src/api-server/V1/v1Controllers/builderController/v1wallController.ts
View File

@@ -1,8 +1,7 @@
import { Request, Response } from "express";
import { Response } from "express";
import { WallItems } from "../../../../shared/services/builder/wallService.ts";
import { error } from "console";
import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
export const WallSetup = async (
req: AuthenticatedRequest,
res: Response
@@ -18,7 +17,6 @@ export const WallSetup = async (
csgscale,
quaternion,
scale,
// versionId
projectId,
} = req.body;
if (
@@ -29,10 +27,10 @@ export const WallSetup = async (
!projectId ||
!csgscale ||
!csgposition ||
// !versionId ||
!quaternion ||
!scale ||
!organization
!organization ||
!userId
) {
res.status(400).json({
message: "All fields are required!",
@@ -42,7 +40,6 @@ export const WallSetup = async (
const result = await WallItems.setWallItems({
projectId,
modelUuid,
// versionId,
modelName,
position,
type,
@@ -51,13 +48,17 @@ export const WallSetup = async (
quaternion,
scale,
organization,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({ message: "User not found" });
break;
case "Updated successfully":
res.status(200).json(result.data);
break;
case "wall Item created successfully":
res.status(200).json(result.data);
res.status(201).json(result.data);
break;
default:
res.status(500).json(error);
@@ -75,9 +76,9 @@ export const WallGet = async (
res: Response
): Promise<void> => {
try {
const { organization, role, userId } = req.user || {};
const { organization, userId } = req.user || {};
const { projectId } = req.params;
if (!organization || !role || !userId || !projectId) {
if (!organization || !userId || !projectId) {
res.status(400).json({
message: "All fields are required",
});
@@ -85,21 +86,21 @@ export const WallGet = async (
}
const result = await WallItems.getWallItems({
organization,
role,
userId,
projectId,
});
switch (result.status) {
case "User not found":
res.status(404).json({ message: "User not found" });
break;
case "wallitems not found":
res.status(404).json({
message: "wallitems not found",
});
break;
case "Success":
res.status(200).json({
WallItems: result.data,
});
res.status(200).json(result.data);
break;
default:
res.status(500).json({
@@ -118,16 +119,9 @@ export const WallDelete = async (
res: Response
): Promise<void> => {
try {
const { organization, role, userId } = req.user || {};
const { organization, userId } = req.user || {};
const { projectId, modelName, modelUuid } = req.body;
if (
!organization ||
!role ||
!userId ||
!projectId ||
!modelName ||
!modelUuid
) {
if (!organization || !userId || !projectId || !modelName || !modelUuid) {
res.status(400).json({
message: "All fields are required",
});
@@ -135,7 +129,6 @@ export const WallDelete = async (
}
const result = await WallItems.deleteWallItems({
organization,
role,
userId,
projectId,
modelName,
@@ -143,15 +136,16 @@ export const WallDelete = async (
});
switch (result.status) {
case "User not found":
res.status(404).json({ message: "User not found" });
break;
case "model not found":
res.status(404).json({
message: "model not found",
});
break;
case "Success":
res.status(200).json({
message: "WallItem deleted",
});
res.status(200).json(result.data);
break;
default:
res.status(500).json({

259
src/api-server/V1/v1Controllers/builderController/v1zoneController.ts
View File

@@ -1,61 +1,51 @@
import { Request, Response } from "express";
import { Response } from "express";
import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
import {
GetCamers,
SetCamera,
} from "../../../../shared/services/builder/cameraService.ts";
DelZone,
GetZones,
SetZone,
SingleZonePanelData,
VizZoneDatas,
ZoneData,
} from "../../../../shared/services/builder/zoneService.ts";
export const SetNewCamera = async (
export const CreateZoneController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, role, userId } = req.user || {};
const { position, target, rotation, projectId, versionId } = req.body;
if (
!organization ||
!role ||
!userId ||
!position ||
!target ||
!rotation ||
!projectId ||
!versionId
) {
const { organization, userId } = req.user || {};
const { zoneData, projectId } = req.body;
if (!organization || !userId || !zoneData || !projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const data = {
position,
target,
rotation,
zoneData,
projectId,
versionId,
organization,
role,
userId,
};
const result = await SetCamera(data);
const result = await SetZone(data);
switch (result.status) {
case "Project not found":
res.status(404).json({
message: "Project not found",
TrashDatas: [],
case "User not found":
res.status(200).json({
message: "User not found",
});
break;
case "Update Success":
case "zone updated":
res.status(200).json({
TrashDatas: result.data,
message: "zone updated",
ZoneData: result.data,
});
break;
case "Success":
res.status(200).json({
TrashDatas: result.data,
message: "zone created",
ZoneData: result.data,
});
break;
default:
@@ -71,29 +61,35 @@ export const SetNewCamera = async (
});
}
};
export const CameraList = async (
export const DeleteZoneController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, role, userId } = req.user || {};
if (!organization || !role || !userId) {
const { organization, userId } = req.user || {};
const { zoneId, projectId } = req.body;
if (!organization || !userId || !zoneId || !projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await GetCamers({
const result = await DelZone({
organization,
role,
zoneId,
projectId,
userId,
});
switch (result.status) {
case "Project not found":
case "User not found":
res.status(404).json({
message: "Project not found",
TrashDatas: [],
message: "User not found",
});
break;
case "Invalid zone ID":
res.status(404).json({
message: "Zone not found for the UUID",
});
break;
case "Success":
@@ -113,3 +109,186 @@ export const CameraList = async (
});
}
};
export const GetZoneController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId } = req.params;
if (!organization || !userId || !projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await GetZones({
organization,
projectId,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Invalid zone":
res.status(404).json({
message: "Zone not found for the UUID",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const VizZoneController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId } = req.params;
if (!organization || !userId || !projectId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await VizZoneDatas({
organization,
projectId,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Zone not found for the UUID":
res.status(404).json({
message: "Zone not found for the UUID",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const ZoneDataController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId, zoneId } = req.params;
if (!organization || !userId || !projectId || !zoneId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await ZoneData({
organization,
projectId,
userId,
zoneId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Zone not found":
res.status(404).json({
message: "Zone not found",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};
export const SingleZonePanelController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, userId } = req.user || {};
const { projectId, zoneId } = req.params;
if (!organization || !userId || !projectId || !zoneId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await SingleZonePanelData({
organization,
projectId,
userId,
zoneId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Zone not found for the UUID":
res.status(404).json({
message: "Zone not found for the UUID",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
}
};

66
src/api-server/V1/v1Controllers/trashController/v1trashController.ts
View File

@@ -20,6 +20,11 @@ export const GetTrashList = async (
const result = await TrashDatas({ organization, role, userId });
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Trash is Empty":
res.status(200).json({
message: "Trash is Empty",
@@ -69,6 +74,11 @@ export const RestoreTrash = async (
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
@@ -97,3 +107,59 @@ export const RestoreTrash = async (
});
}
};
export const DeleteTrash = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { organization, role, userId } = req.user || {};
const { projectId } = req.query as {
projectId: string;
};
if (!organization || !projectId || !role || !userId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await RestoreTrashData({
organization,
projectId,
role,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "Project Trash Delete unsuccessfull":
res.status(200).json({
message: "Project Trash Delete unsuccessfull",
});
break;
case "Trash Project Restored successfully":
res.status(200).json({
message: "Trash Project Restored successfully",
});
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
console.log("error: ", error);
res.status(500).json({
message: "Unknown error",
});
}
};

130
src/api-server/V1/v1Controllers/vizualizationController/v1widgetController.ts
View File

@@ -2,6 +2,8 @@ import { Response } from "express";
import { AuthenticatedRequest } from "../../../../shared/utils/token.ts";
import {
AddWidget,
GetWidget,
UpdateWidget,
WidgetDelete,
} from "../../../../shared/services/visualization/widgetService.ts";
@@ -128,3 +130,131 @@ export const WidgetDeleteController = async (
return;
}
};
export const WidgetUpdateController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { userId, organization } = req.user || {};
const { values, projectId, zoneId, widgetID } = req.body;
if (
!userId ||
!organization ||
!widgetID ||
!values ||
!projectId ||
!zoneId
) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await UpdateWidget({
organization,
values,
zoneId,
widgetID,
projectId,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "Zone not found for the zoneId":
res.status(404).json({
message: "Zone not found for the zoneId",
});
break;
case "Data not found":
res.status(409).json({
message: "Data not found",
});
break;
case "Success":
res.status(200).json({
message: "Widget updated successfully",
});
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
return;
}
};
export const GetWidgetController = async (
req: AuthenticatedRequest,
res: Response
): Promise<void> => {
try {
const { userId, organization } = req.user || {};
const { projectId, zoneId, widgetID } = req.query as {
projectId: string;
zoneId: string;
widgetID: string;
};
if (!userId || !organization || !widgetID || !projectId || !zoneId) {
res.status(400).json({
message: "All fields are required",
});
return;
}
const result = await GetWidget({
organization,
zoneId,
widgetID,
projectId,
userId,
});
switch (result.status) {
case "User not found":
res.status(404).json({
message: "User not found",
});
break;
case "Project not found":
res.status(404).json({
message: "Project not found",
});
break;
case "Zone not found for the zoneId":
res.status(404).json({
message: "Zone not found for the zoneId",
});
break;
case "Widget not found for the widgetID":
res.status(409).json({
message: "Widget not found for the widgetID",
});
break;
case "Success":
res.status(200).json(result.data);
break;
default:
res.status(500).json({
message: "Internal server error",
});
break;
}
} catch (error) {
res.status(500).json({
message: "Unknown error",
});
return;
}
};

56
src/api-server/V1/v1Routes/BuilderRoutes/v1-ZoneRoutes.ts
View File

@@ -0,0 +1,56 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
CreateZoneController,
DeleteZoneController,
GetZoneController,
SingleZonePanelController,
VizZoneController,
ZoneDataController,
} from "../../v1Controllers/builderController/v1zoneController.ts";
const v1Zone = express.Router();
//Zone-Page
v1Zone.post(
"/zones",
tokenValidator,
// authorizedRoles("Admin", "User"),
CreateZoneController
);
v1Zone.patch(
"/zones/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
DeleteZoneController
);
//viz
v1Zone.get(
"/zones/visualization/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
VizZoneController
);
//getzones
v1Zone.get(
"/zones/:projectId/:zoneId",
tokenValidator,
// authorizedRoles("Admin", "User"),
ZoneDataController
);
// viz
v1Zone.get(
"/zones/panel/:projectId/:zoneId",
tokenValidator,
// authorizedRoles("Admin", "User"),
SingleZonePanelController
);
v1Zone.get(
"/zones/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
GetZoneController
);
export default v1Zone;

37
src/api-server/V1/v1Routes/BuilderRoutes/v1-assetRoutes.ts
View File

@@ -0,0 +1,37 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
AssetUpdatePosRotController,
CreateAssetController,
GetAssetController,
ReplaceEventDataController,
} from "../../v1Controllers/builderController/v1assetController.ts";
const v1Asset = express.Router();
//Asset-Page
v1Asset.post(
"/setAsset",
tokenValidator,
// authorizedRoles("Admin", "User"),
CreateAssetController
);
v1Asset.patch(
"/updateFloorAssetPositions",
tokenValidator,
// authorizedRoles("Admin", "User"),
AssetUpdatePosRotController
);
v1Asset.get(
"/floorAssets/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
GetAssetController
);
v1Asset.patch(
"/updateEventData",
tokenValidator,
// authorizedRoles("Admin", "User"),
ReplaceEventDataController
);
export default v1Asset;

31
src/api-server/V1/v1Routes/BuilderRoutes/v1-cameraRoutes.ts
View File

@@ -0,0 +1,31 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
ActiveOnlineController,
CameraList,
SetNewCamera,
} from "../../v1Controllers/builderController/v1cameraController.ts";
const v1Camera = express.Router();
//Camera-Page
v1Camera.post(
"/setCamera",
tokenValidator,
// authorizedRoles("Admin", "User"),
SetNewCamera
);
v1Camera.get(
"/activeCameras",
tokenValidator,
// authorizedRoles("Admin", "User"),
ActiveOnlineController
);
v1Camera.get(
"/cameras/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
CameraList
);
export default v1Camera;

51
src/api-server/V1/v1Routes/BuilderRoutes/v1-linesRoutes.ts
View File

@@ -0,0 +1,51 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
DeleteLayerController,
DeleteLineController,
DeleteLinePointsController,
GetLinesController,
NewLineController,
UpdateLineController,
} from "../../v1Controllers/builderController/v1LineController.ts";
const v1Line = express.Router();
//Line-Page
v1Line.post(
"/lines",
tokenValidator,
// authorizedRoles("Admin", "User"),
NewLineController
);
v1Line.post(
"/points",
tokenValidator,
// authorizedRoles("Admin", "User"),
UpdateLineController
);
v1Line.patch(
"/layers/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
DeleteLayerController
);
v1Line.patch(
"/lines/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
DeleteLineController
);
v1Line.patch(
"/points/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
DeleteLinePointsController
);
v1Line.get(
"/lines/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
GetLinesController
);
export default v1Line;

30
src/api-server/V1/v1Routes/BuilderRoutes/v1-wallRoutes.ts
View File

@@ -0,0 +1,30 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
WallDelete,
WallGet,
WallSetup,
} from "../../v1Controllers/builderController/v1wallController.ts";
const v1Wall = express.Router();
//Wall-Page
v1Wall.post(
"/walls",
tokenValidator,
// authorizedRoles("Admin", "User"),
WallSetup
);
v1Wall.patch(
"/walls/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
WallDelete
);
v1Wall.get(
"/walls/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
WallGet
);
export default v1Wall;

8
src/api-server/V1/v1Routes/v1-trashRoutes.ts
View File

@@ -2,6 +2,7 @@ import express from "express";
import { tokenValidator } from "../../../shared/utils/token.ts";
import authorizedRoles from "../../../shared/middleware/rbacMiddleware.ts";
import {
DeleteTrash,
GetTrashList,
RestoreTrash,
} from "../../V1/v1Controllers/trashController/v1trashController.ts";
@@ -21,4 +22,11 @@ v1TrashRoutes.patch(
// authorizedRoles("Admin", "User"),
RestoreTrash
);
v1TrashRoutes.patch(
"/Trash/Delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
DeleteTrash
);
export default v1TrashRoutes;

44
src/api-server/V1/v1Routes/vizRoutes.ts/v1-FloatWidgetRoutes.ts Normal file
View File

@@ -0,0 +1,44 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
DeleteFloatController,
DuplicateFloatController,
FloatAddController,
GetFloatController,
SingleFloatController,
} from "../../v1Controllers/vizualizationController/v1floatWidgetController.ts";
const v1FloatWidget = express.Router();
//floatWidget-Page
v1FloatWidget.post(
"/floatWidget/save",
tokenValidator,
// authorizedRoles("Admin", "User"),
FloatAddController
);
v1FloatWidget.patch(
"/floatWidget/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
DeleteFloatController
);
v1FloatWidget.get(
"/floatWidgets/:zoneId/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
GetFloatController
);
v1FloatWidget.get(
"/floatWidget/:floatWidgetId",
tokenValidator,
// authorizedRoles("Admin", "User"),
SingleFloatController
);
v1FloatWidget.post(
"/floatWidget/duplicate",
tokenValidator,
// authorizedRoles("Admin", "User"),
DuplicateFloatController
);
export default v1FloatWidget;

37
src/api-server/V1/v1Routes/vizRoutes.ts/v1-TemplateRoutes.ts Normal file
View File

@@ -0,0 +1,37 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
AddTemplateController,
AddTemToZoneController,
GetTemplateController,
TemplateDeleteController,
} from "../../v1Controllers/vizualizationController/v1templateController.ts";
const v1Template = express.Router();
//template-Page
v1Template.post(
"/template/save",
tokenValidator,
// authorizedRoles("Admin", "User"),
AddTemplateController
);
v1Template.post(
"/template/toZone",
tokenValidator,
// authorizedRoles("Admin", "User"),
AddTemToZoneController
);
v1Template.get(
"/template/data/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
GetTemplateController
);
v1Template.patch(
"/template/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
TemplateDeleteController
);
export default v1Template;

31
src/api-server/V1/v1Routes/vizRoutes.ts/v1-panelRoutes.ts Normal file
View File

@@ -0,0 +1,31 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
AddPanelController,
ClearPanelController,
DeletePanelController,
} from "../../v1Controllers/vizualizationController/v1panelController.ts";
const v1PanelRoutes = express.Router();
//panel-Page
v1PanelRoutes.post(
"/panel/save",
tokenValidator,
// authorizedRoles("Admin", "User"),
AddPanelController
);
v1PanelRoutes.patch(
"/panel/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
DeletePanelController
);
v1PanelRoutes.patch(
"/panel/clear",
tokenValidator,
// authorizedRoles("Admin", "User"),
ClearPanelController
);
export default v1PanelRoutes;

38
src/api-server/V1/v1Routes/vizRoutes.ts/v1-widget3dRoutes.ts Normal file
View File

@@ -0,0 +1,38 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
Add3dWidgetController,
Delete3DwidgetController,
Get3DWidgetController,
Update3DwidgetController,
} from "../../v1Controllers/vizualizationController/widget3Dcontroller.ts";
const v1Widget3d = express.Router();
//widget3d-Page
v1Widget3d.post(
"/widget3d/save",
tokenValidator,
// authorizedRoles("Admin", "User"),
Add3dWidgetController
);
v1Widget3d.patch(
"/widget3d/update",
tokenValidator,
// authorizedRoles("Admin", "User"),
Update3DwidgetController
);
v1Widget3d.get(
"/widget3d/data/:zoneId/:projectId",
tokenValidator,
// authorizedRoles("Admin", "User"),
Get3DWidgetController
);
v1Widget3d.patch(
"/widget3d/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
Delete3DwidgetController
);
export default v1Widget3d;

37
src/api-server/V1/v1Routes/vizRoutes.ts/v1-widgetRoutes.ts Normal file
View File

@@ -0,0 +1,37 @@
import express from "express";
import { tokenValidator } from "../../../../shared/utils/token.ts";
import {
AddWidgetController,
GetWidgetController,
WidgetDeleteController,
WidgetUpdateController,
} from "../../v1Controllers/vizualizationController/v1widgetController.ts";
const v1Widget = express.Router();
//widget-Page
v1Widget.post(
"/widget/save",
tokenValidator,
// authorizedRoles("Admin", "User"),
AddWidgetController
);
v1Widget.patch(
"/widget/:widgetID",
tokenValidator,
// authorizedRoles("Admin", "User"),
WidgetUpdateController
);
v1Widget.get(
"/widget/data",
tokenValidator,
// authorizedRoles("Admin", "User"),
GetWidgetController
);
v1Widget.patch(
"/widget/delete",
tokenValidator,
// authorizedRoles("Admin", "User"),
WidgetDeleteController
);
export default v1Widget;

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

@@ -25,6 +25,16 @@ import Authrouter from "./V1/v1Routes/authRoutes.ts";
import v1TrashRoutes from "./V1/v1Routes/v1-trashRoutes.ts";
import v1homeRoutes from "./V1/v1Routes/v1-homeRoutes.ts";
import v1projectRouter from "./V1/v1Routes/v1-projectRoutes.ts";
import v1Asset from "./V1/v1Routes/BuilderRoutes/v1-assetRoutes.ts";
import v1Camera from "./V1/v1Routes/BuilderRoutes/v1-cameraRoutes.ts";
import v1Line from "./V1/v1Routes/BuilderRoutes/v1-linesRoutes.ts";
import v1Wall from "./V1/v1Routes/BuilderRoutes/v1-wallRoutes.ts";
import v1Zone from "./V1/v1Routes/BuilderRoutes/v1-ZoneRoutes.ts";
import v1FloatWidget from "./V1/v1Routes/vizRoutes.ts/v1-FloatWidgetRoutes.ts";
import v1PanelRoutes from "./V1/v1Routes/vizRoutes.ts/v1-panelRoutes.ts";
import v1Template from "./V1/v1Routes/vizRoutes.ts/v1-TemplateRoutes.ts";
import v1Widget from "./V1/v1Routes/vizRoutes.ts/v1-widgetRoutes.ts";
import v1Widget3d from "./V1/v1Routes/vizRoutes.ts/v1-widget3dRoutes.ts";
// import productFlowRoutes from "./Routes/productFlowRouts.ts";
redis;
const app = express();
@@ -94,9 +104,19 @@ app.use("/api/v1", trashRouter);
app.use("/api/v1", homePageRouter);
//New versions--based on the token and role based
app.use("/api/v2", Authrouter);
app.use("/api/v2", v1projectRouter);
app.use("/api/v2", v1TrashRoutes);
app.use("/api/v2", v1homeRoutes);
app.use("/api/V1", Authrouter);
app.use("/api/V1", v1projectRouter);
app.use("/api/V1", v1TrashRoutes);
app.use("/api/V1", v1homeRoutes);
app.use("/api/V1", v1Asset);
app.use("/api/V1", v1Camera);
app.use("/api/V1", v1Line);
app.use("/api/V1", v1Wall);
app.use("/api/V1", v1Zone);
app.use("/api/V1", v1FloatWidget);
app.use("/api/V1", v1PanelRoutes);
app.use("/api/V1", v1Template);
app.use("/api/V1", v1Widget);
app.use("/api/V1", v1Widget3d);
export default app;