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

179
src/shared/services/builder/EnvironmentService.ts
View File

@@ -1,86 +1,119 @@
import environmentModel from "../../V1Models/Environment/environments-Model.ts";
import { existingProjectById, existingUser } from "../helpers/v1projecthelperFns.ts";
import {
existingProjectById,
existingUser,
} from "../helpers/v1projecthelperFns.ts";
interface EnvironmentInput {
roofVisibility: boolean;
wallVisibility: boolean;
shadowVisibility: boolean;
renderDistance: number;
limitDistance: boolean;
organization: string;
projectId: string;
userId: string;
roofVisibility: boolean;
wallVisibility: boolean;
shadowVisibility: boolean;
renderDistance: number;
limitDistance: boolean;
organization: string;
projectId: string;
userId: string;
}
interface GetEnvironmentInput {
organization: string;
projectId: string;
userId: string;
}
export const setEnvironment = async (
data: EnvironmentInput
data: EnvironmentInput
): Promise<{ status: string; data?: Object }> => {
try {
const { roofVisibility, wallVisibility, shadowVisibility, organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const findvalue = await environmentModel(organization).findOne({ userId: userId })
if (findvalue) {
const updatevalue = await environmentModel(organization).findOneAndUpdate(
{ userId: userId, projectId: projectId }, { roofVisibility: roofVisibility, wallVisibility: wallVisibility, shadowVisibility: shadowVisibility }, { new: true });
// return { success: true, message: 'evironments updated', data: updatevalue,organization:organization }
return { status: 'evironments updated', data: updatevalue }
} else {
const newValue = await environmentModel(organization).create({ userId, projectId, roofVisibility, wallVisibility, shadowVisibility });
// return { success: true, message: 'evironments created', data: newValue,organization:organization }
return { status: 'Success', data: newValue }
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
try {
const {
roofVisibility,
wallVisibility,
renderDistance,
limitDistance,
shadowVisibility,
organization,
projectId,
userId,
} = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const findvalue = await environmentModel(organization).findOne({
userId: userId,
isArchive: false,
});
if (findvalue) {
const updatevalue = await environmentModel(organization).findOneAndUpdate(
{ userId: userId, projectId: projectId, isArchive: false },
{
roofVisibility: roofVisibility,
wallVisibility: wallVisibility,
shadowVisibility: shadowVisibility,
renderDistance: renderDistance,
limitDistance: limitDistance,
},
{ new: true }
);
return { status: "environments updated", data: updatevalue };
} else {
const newValue = await environmentModel(organization).create({
userId,
projectId,
roofVisibility,
wallVisibility,
shadowVisibility,
});
return { status: "Success", data: newValue };
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};
export const getEnvironment = async (
data: EnvironmentInput
data: GetEnvironmentInput
): Promise<{ status: string; data?: Object }> => {
try {
const { organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
try {
const { organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const findValue = await environmentModel(organization).findOne({
userId: userId, projectId: projectId
});
if (!findValue) {
// res.status(200).json("user not found");
return { status: 'evironments user not found' }
} else {
// res.status(201).json(findValue);
return { status: 'Success', data: findValue }
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
const findValue = await environmentModel(organization).findOne({
userId: userId,
projectId: projectId,
isArchive: false,
});
if (!findValue) {
return { status: "Environment Not found for the User" };
} else {
return { status: "Success", data: findValue };
}
};
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};

948
src/shared/services/builder/assetService.ts
View File

@@ -1,473 +1,539 @@
import { Mixed } from "mongoose";
import assetModel from "../../V1Models/Builder/assetModel.ts";
import EventsDataModel from "../../V1Models/Simulation/eventsDataModel.ts";
import { existingProjectById, existingUser } from "../helpers/v1projecthelperFns.ts";
import {
existingProjectById,
existingUser,
} from "../helpers/v1projecthelperFns.ts";
interface setAssetInput {
modelUuid: string;
modelName: string;
position: []; // user ID
rotation: object;
eventData: Mixed;
modelfileID: string;
isLocked: boolean;
isVisible: boolean;
organization: string;
projectId: string;
userId: string;
modelUuid: string;
modelName: string;
position: []; // user ID
rotation: object;
eventData: Mixed;
modelfileID: string;
isLocked: boolean;
isVisible: boolean;
organization: string;
projectId: string;
userId: string;
}
interface AssetUpdate {
modelUuid: string;
modelName: string;
position: []; // user ID
rotation: object;
isLocked: boolean;
isVisible: boolean;
organization: string;
projectId: string;
userId: string;
}
interface DelAssetInput {
modelUuid: string;
modelName: string;
organization: string;
projectId: string;
userId: string;
}
interface GetAssetInput {
organization: string;
projectId: string;
userId: string;
}
interface ReplaceEventInput {
organization: string;
projectId: string;
userId: string;
eventData: Mixed;
modelUuid: string;
}
export const setAssetModel = async (
data: setAssetInput
data: setAssetInput
): Promise<{ status: string; data?: Object }> => {
try {
const { modelUuid,
modelName,
position,
rotation,
eventData,
modelfileID,
isLocked,
isVisible,
organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const findvalue = await assetModel(organization).findOne({
modelUuid: modelUuid,
projectId: projectId,
userId: userId,
isArchive: false,
});
if (findvalue) {
const updatevalue = await assetModel(organization).findOneAndUpdate(
{ modelUuid: modelUuid, projectId: projectId, userId: userId, isArchive: false },
{
modelName: modelName,
position: position,
rotation: rotation,
isVisible: isVisible,
isLocked: isLocked,
eventData: eventData,
},
{ new: true }
);
// return {
// success: true,
// message: "Model updated successfully",
// data: updatevalue,
// organization: organization,
// };
return {
status: "Updated successfully",
data: updatevalue,
};
try {
const {
modelUuid,
modelName,
position,
rotation,
eventData,
modelfileID,
isLocked,
isVisible,
organization,
projectId,
userId,
} = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const findvalue = await assetModel(organization).findOne({
modelUuid: modelUuid,
projectId: projectId,
userId: userId,
isArchive: false,
});
if (findvalue) {
const updatevalue = await assetModel(organization).findOneAndUpdate(
{
modelUuid: modelUuid,
projectId: projectId,
userId: userId,
isArchive: false,
},
{
modelName: modelName,
position: position,
rotation: rotation,
isVisible: isVisible,
isLocked: isLocked,
eventData: eventData,
},
{ new: true }
);
// return {
// success: true,
// message: "Model updated successfully",
// data: updatevalue,
// organization: organization,
// };
return {
status: "Updated successfully",
data: updatevalue,
};
} else {
let assetData: any = {
projectId,
userId,
modelUuid,
modelName,
position,
modelfileID,
rotation,
isLocked,
isVisible,
};
// if (eventData) {
// if (eventData?.type === "Conveyor") {
// assetData.eventData = {
// type: eventData.type,
// // point:undefined,
// points: eventData.points,
// };
// } else {
// assetData.eventData = {
// type: eventData.type,
// point: eventData.point,
// // points: undefined
// };
// }
// }
if (eventData) {
const typedEventData = eventData as unknown as {
type: string;
point?: any;
points?: any[];
};
if (typedEventData.type === "Conveyor") {
assetData.eventData = {
type: typedEventData.type,
points: typedEventData.points,
};
} else {
let assetData: any = {
projectId,
userId,
modelUuid,
modelName,
position,
modelfileID,
rotation,
isLocked,
isVisible,
};
// if (eventData) {
// if (eventData?.type === "Conveyor") {
// assetData.eventData = {
// type: eventData.type,
// // point:undefined,
// points: eventData.points,
// };
// } else {
// assetData.eventData = {
// type: eventData.type,
// point: eventData.point,
// // points: undefined
// };
// }
// }
if (eventData) {
const typedEventData = eventData as unknown as { type: string; point?: any; points?: any[] };
if (typedEventData.type === "Conveyor") {
assetData.eventData = {
type: typedEventData.type,
points: typedEventData.points,
};
} else {
assetData.eventData = {
type: typedEventData.type,
point: typedEventData.point,
};
}
}
if (eventData) {
const typedEventData = eventData as unknown as { type: string; point?: any; points?: any[] };
if (typedEventData.type === "Conveyor") {
assetData.eventData = {
type: typedEventData.type,
points: typedEventData.points,
};
} else {
assetData.eventData = {
type: typedEventData.type,
point: typedEventData.point,
};
}
}
const assetDoc = await assetModel(organization).create(assetData);
await assetDoc.save();
let assetDatas;
const typedEventData = eventData as unknown as { type: string };
if (typedEventData && typedEventData.type === "Conveyor") {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
modelUuid: assetDoc.modelUuid,
modelName: assetDoc.modelName,
modelfileID: assetDoc.modelfileID,
position: assetDoc.position,
rotation: assetDoc.rotation,
isLocked: assetDoc.isLocked,
isVisible: assetDoc.isVisible,
eventData: eventData,
};
} else if (eventData && assetDoc.type === "Vehicle") {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
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,
},
};
} else if (eventData && assetDoc.type === "ArmBot") {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
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,
},
};
} else if (eventData && assetDoc.type === "StaticMachine") {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
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,
},
};
} else {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
modelUuid: assetDoc.modelUuid,
modelName: assetDoc.modelName,
modelfileID: assetDoc.modelfileID,
position: assetDoc.position,
rotation: assetDoc.rotation,
isLocked: assetDoc.isLocked,
isVisible: assetDoc.isVisible,
};
}
// return {
// success: true,
// message: "Model created successfully",
// data: assetDatas,
// organization: organization,
// };
return {
status: "Success",
data: assetDatas,
};
assetData.eventData = {
type: typedEventData.type,
point: typedEventData.point,
};
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
}
if (eventData) {
const typedEventData = eventData as unknown as {
type: string;
point?: any;
points?: any[];
};
if (typedEventData.type === "Conveyor") {
assetData.eventData = {
type: typedEventData.type,
points: typedEventData.points,
};
} else {
return {
status: "An unexpected error occurred",
};
assetData.eventData = {
type: typedEventData.type,
point: typedEventData.point,
};
}
}
const assetDoc = await assetModel(organization).create(assetData);
await assetDoc.save();
let assetDatas;
const typedEventData = eventData as unknown as { type: string };
if (typedEventData && typedEventData.type === "Conveyor") {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
modelUuid: assetDoc.modelUuid,
modelName: assetDoc.modelName,
modelfileID: assetDoc.modelfileID,
position: assetDoc.position,
rotation: assetDoc.rotation,
isLocked: assetDoc.isLocked,
isVisible: assetDoc.isVisible,
eventData: eventData,
};
} else if (eventData && assetDoc.type === "Vehicle") {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
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,
},
};
} else if (eventData && assetDoc.type === "ArmBot") {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
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,
},
};
} else if (eventData && assetDoc.type === "StaticMachine") {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
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,
},
};
} else {
assetDatas = {
projectId: assetDoc.projectId,
userId: assetDoc.userId,
modelUuid: assetDoc.modelUuid,
modelName: assetDoc.modelName,
modelfileID: assetDoc.modelfileID,
position: assetDoc.position,
rotation: assetDoc.rotation,
isLocked: assetDoc.isLocked,
isVisible: assetDoc.isVisible,
};
}
// return {
// success: true,
// message: "Model created successfully",
// data: assetDatas,
// organization: organization,
// };
return {
status: "Success",
data: assetDatas,
};
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};
export const deleteAssetModel = async (
data: setAssetInput
data: DelAssetInput
): Promise<{ status: string; data?: Object }> => {
try {
const { modelUuid, modelName, organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const asset = await assetModel(organization).findOne({
modelUuid,
modelName,
projectId,
isArchive: false,
});
if (!asset) {
return {
status: "model not found",
};
}
const archivedAsset = await assetModel(organization).findOneAndUpdate(
{ modelUuid, modelName, projectId },
{ $set: { isArchive: true } },
{ new: true }
);
if (!archivedAsset) {
// return {
// success: false,
// status: "Failed to archive asset",
// organization: organization,
// };
}
const updatedEvents = await EventsDataModel(organization).updateMany(
{ modelUuid, productId: projectId },
{ $set: { isArchive: true } }
);
// return {
// success: true,
// message: "Model deleted successfully",
// data: archivedAsset,
// organization: organization,
// };
return {
status: "Model deleted successfully",
data: archivedAsset,
};
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
try {
const { modelUuid, modelName, organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const asset = await assetModel(organization).findOne({
modelUuid,
modelName,
projectId,
isArchive: false,
});
if (!asset) {
return {
status: "model not found",
};
}
const archivedAsset = await assetModel(organization).findOneAndUpdate(
{ modelUuid, modelName, projectId },
{ $set: { isArchive: true } },
{ new: true }
);
if (!archivedAsset) {
// return {
// success: false,
// status: "Failed to archive asset",
// organization: organization,
// };
return {
status: "Failed to archive asset",
};
}
const updatedEvents = await EventsDataModel(organization).updateMany(
{ modelUuid, productId: projectId },
{ $set: { isArchive: true } }
);
// return {
// success: true,
// message: "Model deleted successfully",
// data: archivedAsset,
// organization: organization,
// };
return {
status: "Success",
data: archivedAsset,
};
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};
export const replaceEventDatas = async (
data: setAssetInput
data: ReplaceEventInput
): Promise<{ status: string; data?: Object }> => {
try {
const { modelUuid, organization, eventData, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const existingModel = await assetModel(organization).findOne({
modelUuid: modelUuid, projectId: projectId,
isArchive: false,
});
if (!existingModel) {
return { status: "Model not for this UUID" }
// return {
// success: false,
// message: "Model not for this UUID",
// organization: organization,
// };
}
else {
const typedEventData = eventData as unknown as {
speed: number; points?: any[];
type?: string;
};
let speed;
try {
const { modelUuid, organization, eventData, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const existingModel = await assetModel(organization).findOne({
modelUuid: modelUuid,
projectId: projectId,
isArchive: false,
});
if (!existingModel) {
return { status: "Model not for this UUID" };
// return {
// success: false,
// message: "Model not for this UUID",
// organization: organization,
// };
} else {
const typedEventData = eventData as unknown as {
speed: number;
points?: any[];
type?: string;
};
let speed;
if (existingModel.type === "Conveyor") {
speed = typedEventData?.speed;
}
;
const updatedModel = await assetModel(organization).findOneAndUpdate(
{ modelUuid, projectId, isArchive: false },
{
points: typedEventData?.points,
// speed: speed,
type: typedEventData?.type || existingModel?.type,
},
{ new: true }
);
if (existingModel.type === "Conveyor") {
speed = typedEventData?.speed;
}
const updatedModel = await assetModel(organization).findOneAndUpdate(
{ modelUuid, projectId, isArchive: false },
{
points: typedEventData?.points,
// speed: speed,
type: typedEventData?.type || existingModel?.type,
},
{ new: true }
);
// if (updatedModel)
// // return {
// // success: true,
// // message: "Data updated successfully",
// // data: updatedModel,
// // organization: organization,
// // };
// return {
// status: "Success",
// data: updatedModel,
// };
return {
status: "Success",
data: updatedModel,
};
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
// if (updatedModel)
// // return {
// // success: true,
// // message: "Data updated successfully",
// // data: updatedModel,
// // organization: organization,
// // };
// return {
// status: "Success",
// data: updatedModel,
// };
return {
status: "Success",
data: updatedModel,
};
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};
export const updateAssetPositionRotation = async (
data: setAssetInput
data: AssetUpdate
): Promise<{ status: string; data?: Object }> => {
try {
const { modelUuid, modelName, position, rotation, isLocked, isVisible, organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const existingAsset = await assetModel(organization).findOne({
modelUuid: modelUuid, projectId: projectId,
isArchive: false,
});
if (!existingAsset) {
return { status: "Asset not found" }
// return res.send("Asset not found");
}
const updateAsset = await assetModel(organization).updateMany(
{ modelUuid: modelUuid, projectId: projectId, modelName: modelName, isArchive: false },
{
position: position,
rotation: rotation,
isVisible: isVisible,
isLocked: isLocked,
}
);
// if (updateAsset)
return {
status: "Success",
data: updateAsset,
};
// return res.status(200).json({ message: "Asset updated successfully" });
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
try {
const {
modelUuid,
modelName,
position,
rotation,
isLocked,
isVisible,
organization,
projectId,
userId,
} = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const existingAsset = await assetModel(organization).findOne({
modelUuid: modelUuid,
projectId: projectId,
isArchive: false,
});
if (!existingAsset) {
return { status: "Asset not found" };
// return res.send("Asset not found");
}
const updateAsset = await assetModel(organization).updateMany(
{
modelUuid: modelUuid,
projectId: projectId,
modelName: modelName,
isArchive: false,
},
{
position: position,
rotation: rotation,
isVisible: isVisible,
isLocked: isLocked,
}
);
// if (updateAsset)
return {
status: "Success",
data: updateAsset,
};
// return res.status(200).json({ message: "Asset updated successfully" });
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};
export const getFloorItems = async (
data: setAssetInput
data: GetAssetInput
): Promise<{ status: string; data?: Object }> => {
try {
const { organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const findValues = await assetModel(organization)
.find({ isArchive: false })
.select("-_id -isArchive");
try {
const { organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const findValues = await assetModel(organization)
.find({ isArchive: false })
.select("-_id -isArchive");
if (!findValues || findValues.length === 0) {
return { status: "floorItems not found" }
// return res.status(200).json({ message: "floorItems not found" });
}
const response = findValues.map((item) => {
const responseItem: any = {
projectId: item.productId,
modelUuid: item.modelUuid,
modelName: item.modelName,
position: item.position,
rotation: item.rotation,
modelfileID: item.modelfileID,
isLocked: item.isLocked,
isVisible: item.isVisible,
eventData: item.eventData,
};
return responseItem;
});
// return res.status(200).json(response);
return {
status: "Success",
data: response,
};
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
if (!findValues || findValues.length === 0) {
return { status: "floorItems not found" };
// return res.status(200).json({ message: "floorItems not found" });
}
};
const response = findValues.map((item) => {
const responseItem: any = {
projectId: item.productId,
modelUuid: item.modelUuid,
modelName: item.modelName,
position: item.position,
rotation: item.rotation,
modelfileID: item.modelfileID,
isLocked: item.isLocked,
isVisible: item.isVisible,
eventData: item.eventData,
};
return responseItem;
});
// return res.status(200).json(response);
return {
status: "Success",
data: response,
};
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};

17
src/shared/services/builder/cameraService.ts
View File

@@ -14,6 +14,11 @@ interface IcameraData {
versionId: string;
}
interface IgetCameras {
organization: string;
projectId: string;
userId: string;
}
interface IOnline {
organization: string;
userId: string;
}
@@ -40,6 +45,7 @@ export const SetCamera = async (
if (!LivingProject) return { status: "Project not found" };
const existingCamera = await cameraModel(organization).findOne({
userId: userId,
isArchive: false,
});
if (existingCamera) {
const updateCamera = await cameraModel(organization).findOneAndUpdate(
@@ -86,12 +92,14 @@ export const SetCamera = async (
export const GetCamers = async (
data: IgetCameras
): Promise<{ status: string; data?: Object }> => {
const { userId, organization } = data;
const { userId, organization, projectId } = data;
try {
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const findCamera = await cameraModel(organization).findOne({
userId: userId,
projectId: projectId,
isArchive: false,
});
if (!findCamera) {
return { status: "Camera not found" };
@@ -111,7 +119,7 @@ export const GetCamers = async (
}
};
export const onlineActiveDatas = async (
data: IgetCameras
data: IOnline
): Promise<{ status: string; data?: Object }> => {
const { organization, userId } = data;
try {
@@ -119,11 +127,12 @@ export const onlineActiveDatas = async (
if (!UserExists) return { status: "User not found" };
const findactiveUsers = await UsersDataModel(organization).find({
activeStatus: "online",
isArchive: false,
});
const cameraDataPromises = findactiveUsers.map(async (activeUser: any) => {
const cameraData = await cameraModel(organization)
.findOne({ userId: activeUser._id })
.findOne({ userId: activeUser._id, isArchive: false })
.select("position target rotation -_id");
if (cameraData) {
@@ -143,7 +152,7 @@ export const onlineActiveDatas = async (
});
const cameraDatas = (await Promise.all(cameraDataPromises)).filter(
(singledata: any) => singledata !== null
(singledata: unknown) => singledata !== null
);
return { status: "Success", data: cameraDatas };

81
src/shared/services/builder/lineService.ts
View File

@@ -8,7 +8,11 @@ interface ILineItems {
projectId: string;
userId: string;
}
interface ILineGet {
organization: string;
projectId: string;
userId: string;
}
interface ILineUpdate {
organization: string;
uuid: number;
@@ -67,19 +71,14 @@ export const UpdateLineItems = async (
const { organization, projectId, uuid, position, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
await lineModel(organization).updateMany(
const updateResult = await lineModel(organization).updateMany(
{ "line.uuid": uuid, projectId: projectId },
{ $set: { "line.$.position": position } }
);
// return {
// success: true,
// status: "line updated",
// data: { uuid: uuid, position: position },
// organization: organization,
// };
return {
status: "Success",
data: { uuid: uuid, position: position },
data: updateResult,
};
} catch (error: unknown) {
if (error instanceof Error) {
@@ -103,9 +102,9 @@ export const DeleteLineItems = async (
const inputUuids = line.map((item: any) => item.uuid);
const findValue = await lineModel(organization).findOneAndDelete(
{ projectId: projectId },
{ projectId: projectId, isArchive: false },
{
"line.uuid": { $all: inputUuids }, // Ensure all UUIDs are present in the `line` key
"line.uuid": { $all: inputUuids },
}
);
@@ -113,22 +112,11 @@ export const DeleteLineItems = async (
return {
status: "line not found",
};
// return {
// success: false,
// message: "line not found",
// organization: organization,
// };
} else {
return {
status: "Success",
data: findValue,
};
// return {
// success: true,
// message: "line deleted",
// data: findValue,
// organization: organization,
// };
}
} catch (error: unknown) {
if (error instanceof Error) {
@@ -152,11 +140,11 @@ export const DeleteLayer = async (
const findValue = await lineModel(organization).find({
layer: layer,
projectId: projectId,
isArchive: false,
});
if (!findValue) {
return { status: "layer not found" };
// return { success: false, message: "layer not found" };
} else {
await lineModel(organization).deleteMany(
{ projectId: projectId },
@@ -171,12 +159,6 @@ export const DeleteLayer = async (
status: "Success",
data: updateResult,
};
// return {
// success: true,
// message: "layer deleted",
// data: layer,
// organization: organization,
// };
}
} catch (error: unknown) {
if (error instanceof Error) {
@@ -191,6 +173,34 @@ export const DeleteLayer = async (
}
};
export const GetLinesService = async (
data: ILineGet
): Promise<{ status: string; data?: object }> => {
try {
const { organization, projectId, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const findValue = await lineModel(organization).find({
projectId: projectId,
isArchive: false,
});
if (!findValue) {
return { status: "user not found" };
} else {
return { status: "Success", data: findValue };
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};
export const DeleteLinePoints = async (
data: ILinePointsDelete
): Promise<{ status: string; data?: object }> => {
@@ -199,7 +209,7 @@ export const DeleteLinePoints = async (
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const findValue = await lineModel(organization).deleteMany(
{ projectId: projectId },
{ projectId: projectId, isArchive: false },
{
"line.uuid": uuid,
}
@@ -207,19 +217,8 @@ export const DeleteLinePoints = async (
if (!findValue) {
return { status: "Line not found" };
// return {
// success: false,
// message: "line not found",
// organization: organization,
// };
} else {
return { status: "Success" };
// return {
// success: true,
// message: "point deleted",
// data: uuid,
// organization: organization,
// };
}
} catch (error: unknown) {
if (error instanceof Error) {

9
src/shared/services/builder/wallService.ts
View File

@@ -49,11 +49,12 @@ export class WallItems {
if (!UserExists) return { status: "User not found" };
const findvalue = await wallItemModel(organization).findOne({
modelUuid: modelUuid,
isArchive: false,
});
if (findvalue) {
const updatevalue = await wallItemModel(organization).findOneAndUpdate(
{ modelUuid: modelUuid, projectId: projectId },
{ modelUuid: modelUuid, projectId: projectId, isArchive: false },
{
modelName,
position,
@@ -63,13 +64,12 @@ export class WallItems {
quaternion,
scale,
},
{ new: true } // Return the updated document
{ new: true }
);
return {
status: "Updated successfully",
data: updatevalue,
};
// res.status(201).json(updatevalue);
} else {
const newValue = await wallItemModel(organization).create({
modelUuid,
@@ -86,7 +86,6 @@ export class WallItems {
status: "wall Item created successfully",
data: newValue,
};
// res.status(201).json(newValue);
}
} catch (error: unknown) {
if (error instanceof Error) {
@@ -107,6 +106,7 @@ export class WallItems {
if (!UserExists) return { status: "User not found" };
const findValue = await wallItemModel(organization).find({
projectId: projectId,
isArchive: false,
});
if (!findValue) {
return {
@@ -139,6 +139,7 @@ export class WallItems {
modelUuid: modelUuid,
modelName: modelName,
projectId: projectId,
isArchive: false,
});
if (!findValue) {
return {

52
src/shared/services/builder/zoneService.ts
View File

@@ -24,12 +24,18 @@ interface IZone {
zoneId: string;
userId: string;
}
interface IVizZone {
organization: string;
projectId: string;
userId: string;
}
interface IResult {
status: string;
data?: object;
}
interface IGetZones {
organization: string;
projectId: string;
userId: string;
}
@@ -51,7 +57,7 @@ export const SetZone = async (data: ISetZone): Promise<IResult> => {
if (findZoneId) {
const updateZone = await zoneModel(organization)
.findOneAndUpdate(
{ zoneId: zoneId, projectId: projectId },
{ zoneId: zoneId, projectId: projectId, isArchive: false },
{
points: points,
viewPortposition: viewPortposition,
@@ -60,7 +66,6 @@ export const SetZone = async (data: ISetZone): Promise<IResult> => {
{ new: true }
)
.select("-_id -__v");
// return { success: true, message: 'zone updated', data: updateZone, organization: organization }
return { status: "zone updated", data: updateZone };
} else {
const zoneCreate = await zoneModel(organization).create({
@@ -76,7 +81,6 @@ export const SetZone = async (data: ISetZone): Promise<IResult> => {
const createdZone = await zoneModel(organization)
.findById(zoneCreate._id)
.select("-_id -__v");
// return { success: true, status: 'zone created', data: createdZone, organization: organization }
return { status: "Success", data: createdZone };
}
} catch (error: unknown) {
@@ -97,6 +101,7 @@ export const DelZone = async (data: IZone): Promise<IResult> => {
const findZoneId = await zoneModel(organization).findOne({
zoneId: zoneId,
projectId: projectId,
isArchive: false,
});
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
@@ -110,7 +115,10 @@ export const DelZone = async (data: IZone): Promise<IResult> => {
})
.select("-_id -__v");
if (deleteZone) {
const panels = await panelModel(organization).find({ zoneId });
const panels = await panelModel(organization).find({
zoneId,
isArchive: false,
});
const allWidgetIds = panels.reduce((ids: string[], panel: any) => {
return ids.concat(panel.widgets || []);
@@ -122,32 +130,26 @@ export const DelZone = async (data: IZone): Promise<IResult> => {
);
await panelModel(organization).updateMany(
{ zoneId },
{ zoneId, isArchive: false },
{ $set: { isArchive: true } }
);
await Promise.all([
widget3dModel(organization).updateMany(
{ zoneId },
{ zoneId, isArchive: false },
{ $set: { isArchive: true } }
),
templateModel(organization).updateMany(
{ zoneId },
{ zoneId, isArchive: false },
{ $set: { isArchive: true } }
),
floatWidgetModel(organization).updateMany(
{ zoneId },
{ zoneId, isArchive: false },
{ $set: { isArchive: true } }
),
]);
}
// return {
// success: true,
// message: "zone deleted",
// data: deleteZone,
// organization: organization,
// };
return {
status: "Success",
data: deleteZone,
@@ -156,11 +158,6 @@ export const DelZone = async (data: IZone): Promise<IResult> => {
return {
status: "Invalid zone ID",
};
// return {
// success: true,
// message: "Invalid zone ID",
// organization: organization,
// };
}
} catch (error: unknown) {
if (error instanceof Error) {
@@ -176,21 +173,19 @@ export const DelZone = async (data: IZone): Promise<IResult> => {
};
export const GetZones = async (data: IGetZones): Promise<IResult> => {
try {
const { organization, userId } = data;
const { organization, userId, projectId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const findZoneId = await zoneModel(organization)
.find()
.find({ projectId: projectId, isArchive: false })
.select(
"zoneId zoneName layer points viewPortCenter viewPortposition -_id"
);
if (!findZoneId) {
return { status: "Invalid zone" };
// res.status(500).json({ message: "Invalid zone" });
}
return { status: "Success", data: findZoneId };
// res.status(200).json({ data: findZoneId, organization: organization });
} catch (error: unknown) {
if (error instanceof Error) {
return {
@@ -211,6 +206,7 @@ export const ZoneData = async (data: IZone): Promise<IResult> => {
const findZone = await zoneModel(organization).findOne({
zoneId: zoneId,
projectId: projectId,
isArchive: false,
});
if (findZone)
return {
@@ -220,7 +216,6 @@ export const ZoneData = async (data: IZone): Promise<IResult> => {
else {
return { status: "Zone not found" };
}
// if (findZone) return res.status(200).json(findZone);
} catch (error: unknown) {
if (error instanceof Error) {
return {
@@ -249,7 +244,6 @@ export const SingleZonePanelData = async (data: IZone): Promise<IResult> => {
);
if (!existingZone) {
return { status: "Zone not found for the UUID" };
// return res.send({ message: "Zone not found for the UUID" });
} else {
const panelData = await panelModel(organization).find({
zoneId: zoneId,
@@ -289,7 +283,6 @@ export const SingleZonePanelData = async (data: IZone): Promise<IResult> => {
};
return { status: "Success", data: objectData };
// return res.status(200).json(objectData);
}
} catch (error: unknown) {
if (error instanceof Error) {
@@ -303,9 +296,9 @@ export const SingleZonePanelData = async (data: IZone): Promise<IResult> => {
}
}
};
export const VizZoneDatas = async (data: IZone): Promise<IResult> => {
export const VizZoneDatas = async (data: IVizZone): Promise<IResult> => {
try {
const { organization, userId, projectId, zoneId } = data;
const { organization, userId, projectId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const existingZones = await zoneModel(organization)
@@ -318,7 +311,6 @@ export const VizZoneDatas = async (data: IZone): Promise<IResult> => {
);
if (!existingZones) {
return { status: "Zone not found for the UUID" };
// return res.send({ message: "Zone not found for the UUID" });
} else {
const response = await Promise.all(
existingZones.map(async (zone) => {
@@ -327,7 +319,6 @@ export const VizZoneDatas = async (data: IZone): Promise<IResult> => {
isArchive: false,
});
// Fetch widgets for each panel
const widgets = await Promise.all(
panelData.map(async (panel) => {
const widgetDataArray = await widgetModel(organization).find({
@@ -360,7 +351,6 @@ export const VizZoneDatas = async (data: IZone): Promise<IResult> => {
);
return { status: "Success", data: response };
// return res.status(200).json(response);
}
} catch (error: unknown) {
if (error instanceof Error) {

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

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

34
src/shared/services/trash/trashService.ts
View File

@@ -1,15 +1,19 @@
import projectModel from "../../model/project/project-model.ts";
import { existingUser } from "../helpers/v1projecthelperFns.ts";
interface IOrg {
organization: string;
userId: string;
}
interface IRestore {
projectId: string;
organization: string;
userId: string;
}
export const TrashDatas = async (data: IOrg) => {
try {
const { organization } = data;
const { organization, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const TrashLists = await projectModel(organization).find({
isArchive: true,
isDeleted: false,
@@ -47,7 +51,9 @@ export const TrashDatas = async (data: IOrg) => {
};
export const RestoreTrashData = async (data: IRestore) => {
try {
const { projectId, organization } = data;
const { projectId, organization, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const findProject = await projectModel(organization).findOne({
_id: projectId,
isArchive: true,
@@ -64,3 +70,25 @@ export const RestoreTrashData = async (data: IRestore) => {
return { status: error };
}
};
export const TrashDelete = async (data: IRestore) => {
try {
const { projectId, organization, userId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const findProject = await projectModel(organization).findOne({
_id: projectId,
isArchive: true,
});
if (!findProject) return { status: "Project not found" };
const DeleteTrashData = await projectModel(organization).findOneAndUpdate(
{ _id: projectId, isArchive: true },
{ isDelete: true },
{ new: true }
);
if (!DeleteTrashData)
return { status: "Project Trash Delete unsuccessfull" };
return { status: "Trash Project Restored successfully" };
} catch (error) {
return { status: error };
}
};

63
src/shared/services/visualization/floatWidgetService.ts
View File

@@ -81,11 +81,6 @@ export const AddFloat = async (data: IAddFloatData): Promise<IResult> => {
projectId: projectId,
});
if (!existingZone) return { status: "Zone not found for the zoneId" };
// return {
// success: false,
// message: "Zone not found for the zoneId",
// organization: organization,
// };
const existingFloatWidget = await floatWidgetModel(organization).findOne({
floatWidgetID: widget.id,
@@ -122,12 +117,6 @@ export const AddFloat = async (data: IAddFloatData): Promise<IResult> => {
zoneName: existingZone.zoneName,
};
return { status: "Widget updated successfully", data: floatUpdateDatas };
// return {
// success: true,
// message: "Widget updated successfully",
// data: floatUpdateDatas,
// organization: organization,
// };
} else {
const newFloadWidget = await floatWidgetModel(organization).create({
className: widget.className,
@@ -153,12 +142,6 @@ export const AddFloat = async (data: IAddFloatData): Promise<IResult> => {
zoneName: existingZone.zoneName,
};
return { status: "Success", data: floatDatas };
// return {
// success: true,
// message: "FloatWidget created successfully",
// data: floatDatas,
// organization: organization,
// };
}
return { status: "Failed to create FloatWidget" };
}
@@ -186,22 +169,12 @@ export const DelFloat = async (data: IDelFloat): Promise<IResult> => {
projectId: projectId,
});
if (!existingZone) return { status: "Zone not found for the zoneId" };
// return {
// success: false,
// message: "Zone not found for the zoneId",
// organization: organization,
// };
const findfloatWidget = await floatWidgetModel(organization).findOne({
floatWidgetID: floatWidgetID,
isArchive: false,
});
if (!findfloatWidget) return { status: "FloatWidget not found for the Id" };
// return {
// success: false,
// message: "Zone not found for the zoneId",
// organization: organization,
// };
const widgetData = await floatWidgetModel(organization).findByIdAndUpdate(
{ _id: findfloatWidget._id, isArchive: false },
{ isArchive: true },
@@ -215,12 +188,6 @@ export const DelFloat = async (data: IDelFloat): Promise<IResult> => {
zoneName: existingZone.zoneName,
};
return { status: "Success", data: floatDeleteData };
// return {
// success: true,
// message: "FloatingWidget deleted successfully",
// data: floatDeleteData,
// organization: organization,
// };
}
return { status: "FloatWidget not deleted" };
} catch (error: unknown) {
@@ -248,13 +215,7 @@ export const DuplicateFloat = async (
isArchive: false,
projectId: projectId,
});
if (!existingZone)
// return {
// success: false,
// message: "Zone not found for the zoneId",
// organization: organization,
// };
return { status: "Zone not found for the zoneId" };
if (!existingZone) return { status: "Zone not found for the zoneId" };
const existingFloatWidget = await floatWidgetModel(organization).findOne({
floatWidgetID: widget.id,
@@ -285,12 +246,6 @@ export const DuplicateFloat = async (
}
);
if (!updateFloatWidget) {
// return {
// success: false,
// message: "FloatWidget update unsuccessfull",
// // data: updateWidget,
// organization: organization,
// };
return { status: "FloatWidget update unsuccessfull" };
}
const floatUpdateDatas = {
@@ -303,12 +258,6 @@ export const DuplicateFloat = async (
status: "Widget updated successfully",
data: floatUpdateDatas,
};
// return {
// success: true,
// message: "Widget updated successfully",
// data: floatUpdateDatas,
// organization: organization,
// };
}
const newFloadWidget = await floatWidgetModel(organization).create({
className: widget.className,
@@ -341,12 +290,6 @@ export const DuplicateFloat = async (
status: "Success",
data: floatDatas,
};
// return {
// success: true,
// message: "duplicate FloatWidget created successfully",
// data: floatDatas,
// organization: organization,
// };
}
return {
status: "Failed to duplicate FloatWidget",
@@ -383,7 +326,6 @@ export const GetFloatWidget = async (data: IGetZoneFloat): Promise<IResult> => {
.select("-_id -zoneId -createdAt -updatedAt -__v");
if (!widgetData || widgetData.length === 0) {
return { status: "All Datas" };
// return res.send([]);
}
const formattedWidgets = widgetData.map((widget) => ({
@@ -400,7 +342,6 @@ export const GetFloatWidget = async (data: IGetZoneFloat): Promise<IResult> => {
value: widget.value,
}));
return { status: "Success", data: formattedWidgets };
// return res.status(200).json(formattedWidgets);
} catch (error: unknown) {
if (error instanceof Error) {
return {
@@ -428,7 +369,6 @@ export const SingleFloatWidget = async (
.select("-_id -zoneId -createdAt -updatedAt -__v");
if (!widgetData || widgetData.length === 0) {
return { status: "Widget not found" };
// return res.status(204).json({ message: "Widget not found" });
}
const Datastructure = {
measurements: widgetData?.Data?.measurements || {},
@@ -436,7 +376,6 @@ export const SingleFloatWidget = async (
};
const header = widgetData?.header;
return { status: "Success", data: { Datastructure, header } };
// return res.status(200).json({ Data: Datastructure, header });
} catch (error: unknown) {
if (error instanceof Error) {
return {

63
src/shared/services/visualization/panelService.ts
View File

@@ -69,11 +69,6 @@ export const AddPanel = async (data: IAddPanel): Promise<IResult> => {
if (createdPanels.length === 0) {
return { status: "No new panels were created. All panels already exist" };
// return {
// success: false,
// message: "No new panels were created. All panels already exist",
// organization: organization,
// };
}
const zoneAndPanelData = await getZoneAndPanelData(
@@ -85,12 +80,6 @@ export const AddPanel = async (data: IAddPanel): Promise<IResult> => {
return zoneAndPanelData;
}
return { status: "Success", data: zoneAndPanelData };
// return {
// success: true,
// message: "Panels created successfully",
// data: zoneAndPanelData,
// organization: organization,
// };
} catch (error: unknown) {
if (error instanceof Error) {
return {
@@ -120,11 +109,7 @@ export const DelPanel = async (data: IPanel): Promise<IResult> => {
isArchive: false,
});
if (!existingPanel) return { status: "Panel Already Deleted" };
// return {
// success: false,
// message: "Panel Already Deleted",
// organization: organization,
// };
await panelModel(organization).updateOne(
{ _id: existingPanel._id, isArchive: false },
{ $set: { isArchive: true } }
@@ -154,12 +139,6 @@ export const DelPanel = async (data: IPanel): Promise<IResult> => {
return zoneAndPanelData;
}
return { status: "Success", data: zoneAndPanelData };
// return {
// success: true,
// message: "Panel deleted successfully",
// data: zoneAndPanelData,
// organization: organization,
// };
} catch (error: unknown) {
if (error instanceof Error) {
return {
@@ -189,22 +168,13 @@ export const ClearPanel = async (data: IPanel): Promise<IResult> => {
isArchive: false,
});
if (!existingPanel) return { status: "Requested Panel not found" };
// return {
// success: false,
// message: "Requested Panel not found",
// organization: organization,
// };
const existingWidgets = await widgetModel(organization).find({
panelID: existingPanel._id,
isArchive: false,
});
if (existingWidgets.length === 0) return { status: "No widgets to clear" };
// return {
// success: false,
// message: "No widgets to clear",
// organization: organization,
// };
const clearWidgetsofPanel = await widgetModel(organization).updateMany(
{ panelID: existingPanel._id, isArchive: false },
{ isArchive: true }
@@ -218,11 +188,6 @@ export const ClearPanel = async (data: IPanel): Promise<IResult> => {
);
if (!clearWidgetsofPanel && !removeWidgetsInPanel)
return { status: "Failed to clear widgets in panel" };
// return {
// success: false,
// message: "Failed to clear widgets in panel",
// organization: organization,
// };
const zoneAndPanelData = await getZoneAndPanelData(
organization,
@@ -232,12 +197,7 @@ export const ClearPanel = async (data: IPanel): Promise<IResult> => {
if (!zoneAndPanelData) {
return zoneAndPanelData;
}
// return {
// success: true,
// data: zoneAndPanelData,
// message: "PanelWidgets cleared successfully",
// organization: organization,
// };
return {
status: "Success",
data: zoneAndPanelData,
@@ -286,12 +246,6 @@ export const LockedPanel = async (data: ILockedPanel): Promise<IResult> => {
status: "Success",
data: zoneAndPanelData,
};
// return {
// success: true,
// message: "locked panel updated successfully",
// data: zoneAndPanelData,
// organization: organization,
// };
}
return { status: "locked panel not updated" };
}
@@ -324,11 +278,6 @@ const getZoneAndPanelData = async (
);
if (!existingZone) {
return { status: "Zone not found" };
// return {
// success: false,
// message: "Zone not found",
// organization: organization,
// };
} else {
const panelData = await panelModel(organization).find({
zoneId: zoneId,
@@ -371,11 +320,5 @@ const getZoneAndPanelData = async (
}
} catch (error: unknown) {
return { status: "Panel not found" };
// return {
// success: false,
// message: "Panel not found",
// error,
// organization: organization,
// };
}
};

37
src/shared/services/visualization/templateService.ts
View File

@@ -51,7 +51,6 @@ export const AddTemplate = async (data: IAddTemplate): Promise<IResult> => {
projectId: projectId,
});
if (existingTemplate) return { status: "TemplateID alreay exists" };
// return res.json({ message: "TemplateID alreay exists" });
const newTemplate = await templateModel(organization).create({
templateID: template.id,
templateName: template.name,
@@ -62,7 +61,6 @@ export const AddTemplate = async (data: IAddTemplate): Promise<IResult> => {
Widgets3D: template.Widgets3D,
});
if (newTemplate) {
// return res.status(200).json({ message: "Template saved successfully" });
const allTemplateDatas = await templateModel(organization)
.find({ isArchive: false })
.select("-_id -__v -isArchive -createdAt -updatedAt");
@@ -77,12 +75,6 @@ export const AddTemplate = async (data: IAddTemplate): Promise<IResult> => {
snapshot: data.snapshot,
}));
return { status: "Success", data: formattedTemplates };
// return {
// success: true,
// message: "Template saved successfully",
// data: formattedTemplates,
// organization: organization,
// };
}
return { status: "Template not saved" };
} catch (error: unknown) {
@@ -113,11 +105,6 @@ export const AddTemplateToZone = async (
return {
status: "Zone not found ",
};
// return {
// success: false,
// message: "Zone not found ",
// organization: organization,
// };
const existingTemplate = await templateModel(organization).findOne({
templateID: templateID,
@@ -128,16 +115,10 @@ export const AddTemplateToZone = async (
return {
status: "TemplateID not found",
};
// return {
// success: false,
// message: "TemplateID not found",
// organization: organization,
// };
if (existingZone.panelOrder.length > 0) {
existingZone.panelOrder = existingTemplate.panelOrder;
await existingZone.save();
// Clear existing data before adding new data
const archivePanelDatas = await panelModel(organization).find({
zoneId,
isArchive: false,
@@ -164,13 +145,13 @@ export const AddTemplateToZone = async (
isArchive: false,
});
const existingPanelNames = existingPanels.map(
(panel: any) => panel.panelName
(panel) => panel.panelName as string
);
const missingPanels = existingTemplate.panelOrder.filter(
(panelName: string) => !existingPanelNames.includes(panelName)
);
const createdPanels = await Promise.all(
await Promise.all(
missingPanels.map((panelName: any) =>
panelModel(organization).create({
zoneId,
@@ -240,12 +221,6 @@ export const AddTemplateToZone = async (
};
return { status: "Success", data: templateZoneDatas };
// return {
// success: true,
// message: "Template placed in Zone",
// data: templateZoneDatas,
// organization: organization,
// };
} catch (error: unknown) {
if (error instanceof Error) {
return {
@@ -279,12 +254,6 @@ export const TemplateDelete = async (data: ITemplate): Promise<IResult> => {
status: "Success",
data: TemplateDeleteData,
};
// return {
// success: true,
// message: "Template deleted successfully",
// data: TemplateDeleteData,
// organization: organization,
// };
}
return { status: "Template not Deleted" };
}
@@ -310,7 +279,6 @@ export const GetAllTemplates = async (data: IGetTemplate): Promise<IResult> => {
.find({ projectId: projectId, isArchive: false })
.select("-_id -__v -isArchive -createdAt -updatedAt");
if (!templateDatas) return { status: "All Datas" };
// return res.status(200).send([]);
const formattedTemplates = templateDatas.map((data) => ({
id: data.templateID,
@@ -322,7 +290,6 @@ export const GetAllTemplates = async (data: IGetTemplate): Promise<IResult> => {
snapshot: data.snapshot,
}));
return { status: "Success", data: formattedTemplates };
// return res.status(200).json(formattedTemplates);
} catch (error: unknown) {
if (error instanceof Error) {
return {

59
src/shared/services/visualization/widget3dService.ts
View File

@@ -53,11 +53,7 @@ export const Add3DWidget = async (data: IWidget3DAdd): Promise<IResult> => {
projectId: projectId,
});
if (!existingZone) return { status: "Zone not found for the zoneId" };
// return {
// success: false,
// message: "Zone not found for the zoneId",
// organization: organization,
// };
const existing3Dwidget = await widget3dModel(organization).findOne({
widgetID: widget.id,
isArchive: false,
@@ -76,17 +72,7 @@ export const Add3DWidget = async (data: IWidget3DAdd): Promise<IResult> => {
return {
status: "3dwidget update successfully",
};
// return {
// success: true,
// message: "widget update successfully",
// organization: organization,
// };
} else return { status: "3dWidget not updated" };
// return {
// success: false,
// message: "Widget not updated",
// organization: organization,
// };
} else {
const newWidget3d = await widget3dModel(organization).create({
type: widget.type,
@@ -115,12 +101,6 @@ export const Add3DWidget = async (data: IWidget3DAdd): Promise<IResult> => {
};
}
return { status: "Widget 3d not created" };
// return {
// success: true,
// message: "Widget created successfully",
// data: widgemodel3D_Datas,
// organization: organization,
// };
}
} catch (error: unknown) {
if (error instanceof Error) {
@@ -149,11 +129,7 @@ export const Update3Dwidget = async (data: IWidgetUpdate): Promise<IResult> => {
return {
status: "Zone not found",
};
// return {
// success: false,
// message: "Zone not found",
// organization: organization,
// };
const existing3Dwidget = await widget3dModel(organization).findOne({
widgetID: id,
zoneId: zoneId,
@@ -183,21 +159,10 @@ export const Update3Dwidget = async (data: IWidgetUpdate): Promise<IResult> => {
status: "Success",
data: updateDatas,
};
// return {
// success: true,
// message: "widget update successfully",
// data: updateDatas,
// organization: organization,
// };
}
return { status: "Widget not updated" };
} else {
return { status: "widget not found" };
// return {
// success: false,
// message: "widget not found",
// organization: organization,
// };
}
} catch (error: unknown) {
if (error instanceof Error) {
@@ -227,11 +192,7 @@ export const Delete3Dwidget = async (
return {
status: "Zone not found",
};
// return {
// success: false,
// message: "Zone not found",
// organization: organization,
// };
const existing3Dwidget = await widget3dModel(organization).findOne({
widgetID: id,
isArchive: false,
@@ -239,11 +200,6 @@ export const Delete3Dwidget = async (
});
if (!existing3Dwidget) {
return { status: "3D widget not found for the ID" };
// return {
// success: false,
// message: "3D widget not found for the ID",
// organization: organization,
// };
}
const updateWidget = await widget3dModel(organization).findOneAndUpdate(
{
@@ -263,12 +219,6 @@ export const Delete3Dwidget = async (
status: "Success",
data: delete_Datas,
};
// return {
// success: true,
// data: delete_Datas,
// message: "3DWidget delete successfull",
// organization: organization,
// };
}
return { status: "3DWidget delete unsuccessfull" };
} catch (error: unknown) {
@@ -297,14 +247,12 @@ export const Get3Dwidget = async (data: I3dWidgetGet): Promise<IResult> => {
return {
status: "Zone not found",
};
// return res.send("Zone not found");
const widgetData = await widget3dModel(organization).find({
zoneId: zoneId,
isArchive: false,
});
if (!widgetData || widgetData.length === 0) {
return { status: "All 3Dwidgets" };
// return res.json([]);
}
const zonebasedWidget = widgetData.map((widget) => ({
@@ -318,7 +266,6 @@ export const Get3Dwidget = async (data: I3dWidgetGet): Promise<IResult> => {
rotation: widget?.rotation,
}));
return { status: "Success", data: zonebasedWidget };
// return res.status(200).json(zonebasedWidget);
} catch (error: unknown) {
if (error instanceof Error) {
return {

197
src/shared/services/visualization/widgetService.ts
View File

@@ -1,7 +1,10 @@
import widgetModel from "../../V1Models/Vizualization/widgemodel.ts";
import zoneModel from "../../V1Models/Builder/zoneModel.ts";
import panelModel from "../../V1Models/Vizualization/panelmodel.ts";
import { existingUser } from "../helpers/v1projecthelperFns.ts";
import {
existingProjectById,
existingUser,
} from "../helpers/v1projecthelperFns.ts";
interface IResult {
status: string;
data?: object;
@@ -29,11 +32,44 @@ interface IWidgetDelete {
projectId: string;
widgetID: string;
}
interface IWidgetUpdate {
organization: string;
userId: string;
zoneId: string;
projectId: string;
widgetID: string;
values: {
widgetName: string;
widgetSide: string;
type: string;
Data: {
measurement: {};
duration: string;
};
color: string;
fontFamily: string;
fontStyle: string;
fontWeight: string;
};
}
interface IGetWidget {
organization: string;
userId: string;
zoneId: string;
projectId: string;
widgetID: string;
}
export const AddWidget = async (data: IWidgetCreate): Promise<IResult> => {
try {
const { organization, widget, userId, zoneId, projectId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const existingZone = await zoneModel(organization).findOne({
zoneId: zoneId,
isArchive: false,
@@ -47,18 +83,12 @@ export const AddWidget = async (data: IWidgetCreate): Promise<IResult> => {
isArchive: false,
});
if (!existingPanel) return { status: "panelName not found" };
// return {
// success: false,
// message: "panelName not found",
// organization: organization,
// };
if (existingPanel.panelName === widget.panel) {
const existingWidget = await widgetModel(organization).findOne({
panelID: existingPanel._id,
widgetID: widget.id,
isArchive: false,
// widgetOrder: widget.widgetOrder,
});
if (existingWidget) {
const updateWidget = await widgetModel(organization).findOneAndUpdate(
@@ -78,29 +108,16 @@ export const AddWidget = async (data: IWidgetCreate): Promise<IResult> => {
isArchive: false,
},
},
{ upsert: true, new: true } // Upsert: create if not exists, new: return updated document
{ upsert: true, new: true }
);
if (!updateWidget) {
return { status: "Widget update unsuccessfull" };
// return {
// success: false,
// message: "Widget update unsuccessfull",
// // data: updateWidget,
// organization: organization,
// };
}
return { status: "Widget update successfully", data: updateWidget };
// return {
// success: true,
// message: "Widget updated successfully",
// data: updateWidget,
// organization: organization,
// };
}
const newWidget = await widgetModel(organization).create({
widgetID: widget.id,
elementType: widget.type,
// widgetOrder: widgetOrder,
widgetName: widget.title,
panelID: existingPanel._id,
widgetside: widget.panel,
@@ -128,22 +145,11 @@ export const AddWidget = async (data: IWidgetCreate): Promise<IResult> => {
status: "Success",
data: finaldata,
};
// return {
// success: true,
// message: "Widget created successfully",
// data: finaldata,
// organization: organization,
// };
}
}
return {
status: "Type mismatch",
};
// return {
// success: false,
// message: "Type mismatch",
// organization: organization,
// };
} catch (error: unknown) {
if (error instanceof Error) {
return {
@@ -161,6 +167,12 @@ export const WidgetDelete = async (data: IWidgetDelete): Promise<IResult> => {
const { organization, widgetID, userId, zoneId, projectId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const existingZone = await zoneModel(organization).findOne({
zoneId: zoneId,
isArchive: false,
@@ -174,11 +186,7 @@ export const WidgetDelete = async (data: IWidgetDelete): Promise<IResult> => {
isArchive: false,
});
if (!findWidget) return { status: "Widget not found" };
// return {
// success: false,
// message: "Widget not found",
// organization: organization,
// };
const widgetData = await widgetModel(organization).updateOne(
{ _id: findWidget._id, isArchive: false, zoneId: zoneId },
{ $set: { isArchive: true } }
@@ -223,12 +231,6 @@ export const WidgetDelete = async (data: IWidgetDelete): Promise<IResult> => {
zoneName: existingZone.zoneName,
};
return { status: "Success", data: widgetData1 };
// return {
// success: true,
// message: "Widget deleted successfully",
// data: widgetData1,
// organization: organization,
// };
}
return { status: "Widget not found" };
} catch (error: unknown) {
@@ -243,3 +245,112 @@ export const WidgetDelete = async (data: IWidgetDelete): Promise<IResult> => {
}
}
};
export const UpdateWidget = async (data: IWidgetUpdate): Promise<IResult> => {
try {
const { organization, widgetID, userId, projectId, zoneId, values } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const existingZone = await zoneModel(organization).findOne({
zoneId: zoneId,
isArchive: false,
projectId: projectId,
});
if (!existingZone) return { status: "Zone not found for the zoneId" };
const findWidget = await widgetModel(organization).findOne({
widgetID: widgetID,
zoneId: zoneId,
isArchive: false,
});
if (!findWidget) return { status: "Data not found" };
const updateData = {
widgetName: values.widgetName,
widgetSide: values.widgetSide,
elementType: values.type,
Data: {
measurement: values.Data.measurement,
duration: values.Data.duration,
},
elementColor: values.color,
fontFamily: values.fontFamily,
fontStyle: values.fontStyle,
fontWeight: values.fontWeight,
isArchive: false,
};
await widgetModel(organization).findOneAndUpdate(
{ widgetID: widgetID, isArchive: false },
updateData,
{
new: true,
upsert: true,
setDefaultsOnInsert: true,
}
);
return {
status: "Success",
};
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};
export const GetWidget = async (data: IGetWidget): Promise<IResult> => {
try {
const { organization, widgetID, userId, projectId, zoneId } = data;
const UserExists = await existingUser(userId, organization);
if (!UserExists) return { status: "User not found" };
const LivingProject = await existingProjectById(
projectId,
organization,
userId
);
if (!LivingProject) return { status: "Project not found" };
const existingZone = await zoneModel(organization).findOne({
zoneId: zoneId,
isArchive: false,
projectId: projectId,
});
if (!existingZone) return { status: "Zone not found for the zoneId" };
const existingWidget = await widgetModel(organization)
.findOne({
widgetID: widgetID,
zoneId: zoneId,
isArchive: false,
})
.select("Data widgetName -_id");
if (!existingWidget) return { status: "Widget not found for the widgetID" };
const Datastructure = {
measurements: existingWidget.Data.measurements || {},
duration: existingWidget.Data.duration || "1h",
};
const widgetName = existingWidget.widgetName || "Widget";
const Data = { Datastructure, widgetName };
return { status: "Success", data: Data };
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};