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

asset and environment service addet

Browse Source
This commit is contained in:
sabarinathan
2025-05-29 09:24:16 +05:30
parent 7fb2a6bd2d
commit bea6044b25
2 changed files with 559 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -0,0 +1,86 @@
import environmentModel from "../../V1Models/Environment/environments-Model.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;
}
export const setEnvironment = async (
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",
};
}
}
};
export const getEnvironment = async (
data: EnvironmentInput
): 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 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",
};
}
}
};

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

@@ -0,0 +1,473 @@
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";
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;
}
export const setAssetModel = async (
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,
};
} 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,
};
}
} catch (error: unknown) {
if (error instanceof Error) {
return {
status: error.message,
};
} else {
return {
status: "An unexpected error occurred",
};
}
}
};
export const deleteAssetModel = async (
data: setAssetInput
): 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",
};
}
}
};
export const replaceEventDatas = async (
data: setAssetInput
): 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;
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",
};
}
}
};
export const updateAssetPositionRotation = async (
data: setAssetInput
): 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",
};
}
}
};
export const getFloorItems = async (
data: setAssetInput
): 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");
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",
};
}
}
};