577 lines
22 KiB
TypeScript
577 lines
22 KiB
TypeScript
import { useParams } from "react-router-dom";
|
|
import { getUserData } from "../../../../../functions/getUserData";
|
|
import { useSceneContext } from "../../../sceneContext";
|
|
import { useSocketStore } from "../../../../../store/socket/useSocketStore";
|
|
import useWallResponseHandler from "../../../../collaboration/responseHandler/useWallResponseHandler";
|
|
import useAisleResponseHandler from "../../../../collaboration/responseHandler/useAisleResponseHandler";
|
|
import useFloorResponseHandler from "../../../../collaboration/responseHandler/useFloorResponseHandler";
|
|
import useZoneResponseHandler from "../../../../collaboration/responseHandler/useZoneResponseHandler";
|
|
|
|
import { upsertWallApi } from "../../../../../services/factoryBuilder/wall/upsertWallApi";
|
|
import { deleteWallApi } from "../../../../../services/factoryBuilder/wall/deleteWallApi";
|
|
|
|
import { upsertZoneApi } from "../../../../../services/factoryBuilder/zone/upsertZoneApi";
|
|
import { deleteZoneApi } from "../../../../../services/factoryBuilder/zone/deleteZoneApi";
|
|
|
|
import { upsertFloorApi } from "../../../../../services/factoryBuilder/floor/upsertFloorApi";
|
|
import { deleteFloorApi } from "../../../../../services/factoryBuilder/floor/deleteFloorApi";
|
|
|
|
import { upsertAisleApi } from "../../../../../services/factoryBuilder/aisle/upsertAisleApi";
|
|
import { deleteAisleApi } from "../../../../../services/factoryBuilder/aisle/deleteAisleApi";
|
|
|
|
function use2DRedoHandler() {
|
|
const { undoRedo2DStore, versionStore } = useSceneContext();
|
|
const { redo2D, peekRedo2D } = undoRedo2DStore();
|
|
const { addWallToScene, removeWallFromScene, updateWallInScene } = useWallResponseHandler();
|
|
const { addAisleToScene, removeAisleFromScene, updateAisleInScene } = useAisleResponseHandler();
|
|
const { addFloorToScene, removeFloorFromScene, updateFloorInScene } = useFloorResponseHandler();
|
|
const { addZoneToScene, removeZoneFromScene, updateZoneInScene } = useZoneResponseHandler();
|
|
const { selectedVersion } = versionStore();
|
|
const { userId, organization } = getUserData();
|
|
const { projectId } = useParams();
|
|
const { builderSocket } = useSocketStore();
|
|
|
|
const handleRedo = () => {
|
|
const redoData = peekRedo2D();
|
|
if (!redoData) return;
|
|
|
|
if (redoData.type === "Draw") {
|
|
const { actions } = redoData;
|
|
|
|
actions.forEach((action) => {
|
|
const { actionType } = action;
|
|
|
|
if ("point" in action) {
|
|
const point = action.point;
|
|
|
|
if (actionType === "Line-Create") {
|
|
handleCreate(point);
|
|
} else if (actionType === "Line-Update") {
|
|
handleUpdate(point);
|
|
} else if (actionType === "Line-Delete") {
|
|
handleRemove(point);
|
|
}
|
|
} else if ("points" in action) {
|
|
const points = action.points;
|
|
|
|
if (actionType === "Lines-Create") {
|
|
points.forEach(handleCreate);
|
|
} else if (actionType === "Lines-Update") {
|
|
points.forEach(handleUpdate);
|
|
} else if (actionType === "Lines-Delete") {
|
|
points.forEach(handleRemove);
|
|
}
|
|
}
|
|
});
|
|
} else if (redoData.type === "UI") {
|
|
// Handle UI actions if needed
|
|
}
|
|
|
|
redo2D();
|
|
};
|
|
|
|
const handleCreate = (point: UndoRedo2DDataTypeSchema) => {
|
|
switch (point.type) {
|
|
case "Wall":
|
|
createWallFromBackend(point.lineData);
|
|
break;
|
|
case "Floor":
|
|
createFloorFromBackend(point.lineData);
|
|
break;
|
|
case "Zone":
|
|
createZoneFromBackend(point.lineData);
|
|
break;
|
|
case "Aisle":
|
|
createAisleFromBackend(point.lineData);
|
|
break;
|
|
}
|
|
};
|
|
|
|
const handleRemove = (point: UndoRedo2DDataTypeSchema) => {
|
|
switch (point.type) {
|
|
case "Wall":
|
|
removeWallFromBackend(point.lineData.wallUuid);
|
|
break;
|
|
case "Floor":
|
|
removeFloorFromBackend(point.lineData.floorUuid);
|
|
break;
|
|
case "Zone":
|
|
removeZoneFromBackend(point.lineData.zoneUuid);
|
|
break;
|
|
case "Aisle":
|
|
removeAisleFromBackend(point.lineData.aisleUuid);
|
|
break;
|
|
}
|
|
};
|
|
|
|
const handleUpdate = (point: UndoRedo2DDataTypeSchema) => {
|
|
if (!point.newData) return;
|
|
switch (point.type) {
|
|
case "Wall":
|
|
updateWallFromBackend(point.newData.wallUuid, point.newData);
|
|
break;
|
|
case "Floor":
|
|
updateFloorFromBackend(point.newData.floorUuid, point.newData);
|
|
break;
|
|
case "Zone":
|
|
updateZoneFromBackend(point.newData.zoneUuid, point.newData);
|
|
break;
|
|
case "Aisle":
|
|
updateAisleFromBackend(point.newData.aisleUuid, point.newData);
|
|
break;
|
|
}
|
|
};
|
|
|
|
const createWallFromBackend = (wallData: Wall) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
upsertWallApi(projectId, selectedVersion?.versionId || "", wallData)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error adding wall`);
|
|
return;
|
|
}
|
|
if (data.message === "Wall Created Successfully") {
|
|
addWallToScene(wallData, () => {
|
|
echo.info(`Added wall: ${wallData.wallUuid}`);
|
|
});
|
|
} else {
|
|
echo.error(`Error adding wall: ${wallData.wallUuid}`);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error adding wall: ${wallData.wallUuid}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
wallData: wallData,
|
|
projectId: projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId: userId,
|
|
organization: organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-Wall:add", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const removeWallFromBackend = (wallUuid: string) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
deleteWallApi(projectId, selectedVersion?.versionId || "", wallUuid)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error removing wall`);
|
|
return;
|
|
}
|
|
if (data.message === "Wall Deleted Successfully") {
|
|
removeWallFromScene(wallUuid, () => {
|
|
echo.info(`Removed wall: ${wallUuid}`);
|
|
});
|
|
} else {
|
|
echo.error(`Error removing wall: ${wallUuid}`);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error removing wall: ${wallUuid}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
wallUuid: wallUuid,
|
|
projectId: projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId: userId,
|
|
organization: organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-Wall:delete", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const updateWallFromBackend = (wallUuid: string, updatedData: Wall) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
upsertWallApi(projectId, selectedVersion?.versionId || "", updatedData)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error updating wall`);
|
|
return;
|
|
}
|
|
if (data.message === "Wall Updated Successfully") {
|
|
updateWallInScene(updatedData, () => {
|
|
echo.info(`Updated wall: ${wallUuid}`);
|
|
});
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error updating wall: ${wallUuid}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
wallData: updatedData,
|
|
projectId: projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId: userId,
|
|
organization: organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-Wall:add", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const createFloorFromBackend = (floorData: Floor) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
upsertFloorApi(projectId, selectedVersion?.versionId || "", floorData)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error adding floor: ${floorData.floorName}`);
|
|
return;
|
|
}
|
|
if (data.message === "Floor Created Successfully") {
|
|
addFloorToScene(floorData, () => {
|
|
echo.info(`Added floor: ${floorData.floorName}`);
|
|
});
|
|
} else {
|
|
echo.error(`Error adding floor: ${floorData.floorName}`);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error adding floor: ${floorData.floorName}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
floorData: floorData,
|
|
projectId: projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId: userId,
|
|
organization: organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-Floor:add", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const removeFloorFromBackend = (floorUuid: string) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
deleteFloorApi(projectId, selectedVersion?.versionId || "", floorUuid)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error removing floor: ${floorUuid}`);
|
|
return;
|
|
}
|
|
if (data.message === "Floor Deleted Successfully") {
|
|
removeFloorFromScene(floorUuid, () => {
|
|
echo.info(`Removed floor: ${floorUuid}`);
|
|
});
|
|
} else {
|
|
echo.error(`Error removing floor: ${floorUuid}`);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error removing floor: ${floorUuid}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
floorUuid: floorUuid,
|
|
projectId: projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId: userId,
|
|
organization: organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-Floor:delete", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const updateFloorFromBackend = (floorUuid: string, updatedData: Floor) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
upsertFloorApi(projectId, selectedVersion?.versionId || "", updatedData)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error updating floor: ${updatedData.floorName}`);
|
|
return;
|
|
}
|
|
if (data.message === "Floor Updated Successfully") {
|
|
updateFloorInScene(updatedData, () => {
|
|
echo.info(`Updated floor: ${updatedData.floorName}`);
|
|
});
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error updating floor: ${updatedData.floorName}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
floorData: updatedData,
|
|
projectId: projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId: userId,
|
|
organization: organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-Floor:add", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const createZoneFromBackend = (zoneData: Zone) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
upsertZoneApi(projectId, selectedVersion?.versionId || "", zoneData)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error adding zone: ${zoneData.zoneName}`);
|
|
return;
|
|
}
|
|
if (data.message === "Zone Created Successfully") {
|
|
addZoneToScene(zoneData, () => {
|
|
echo.info(`Added zone: ${zoneData.zoneName}`);
|
|
});
|
|
} else {
|
|
echo.error(`Error adding zone: ${zoneData.zoneName}`);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error adding zone: ${zoneData.zoneName}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
zoneData: zoneData,
|
|
projectId: projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId: userId,
|
|
organization: organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:zone:add", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const removeZoneFromBackend = (zoneUuid: string) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
deleteZoneApi(projectId, selectedVersion?.versionId || "", zoneUuid)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error removing zone: ${zoneUuid}`);
|
|
return;
|
|
}
|
|
if (data.message === "Zone Deleted Successfully") {
|
|
removeZoneFromScene(zoneUuid, () => {
|
|
echo.info(`Removed zone: ${zoneUuid}`);
|
|
});
|
|
} else {
|
|
echo.error(`Error removing zone: ${zoneUuid}`);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error removing zone: ${zoneUuid}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
zoneUuid,
|
|
projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId,
|
|
organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:zone:delete", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const updateZoneFromBackend = (zoneUuid: string, updatedData: Zone) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
upsertZoneApi(projectId, selectedVersion?.versionId || "", updatedData)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error updating zone: ${updatedData.zoneName}`);
|
|
return;
|
|
}
|
|
if (data.message === "Zone Updated Successfully") {
|
|
updateZoneInScene(updatedData, () => {
|
|
echo.info(`Updated zone: ${updatedData.zoneName}`);
|
|
});
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error updating zone: ${updatedData.zoneName}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
zoneData: updatedData,
|
|
projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId,
|
|
organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:zone:add", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const createAisleFromBackend = (aisleData: Aisle) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
upsertAisleApi(aisleData.aisleUuid, aisleData.points, aisleData.type, projectId, selectedVersion?.versionId || "")
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error adding aisle`);
|
|
return;
|
|
}
|
|
if (data.message === "Aisle Created Successfully") {
|
|
addAisleToScene(aisleData, () => {
|
|
echo.info(`Added aisle: ${aisleData.aisleUuid}`);
|
|
});
|
|
} else {
|
|
echo.error(`Error adding aisle: ${aisleData.aisleUuid}`);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error adding aisle: ${aisleData.aisleUuid}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
...aisleData,
|
|
projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId,
|
|
organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-aisle:add", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const removeAisleFromBackend = (aisleUuid: string) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
deleteAisleApi(projectId, selectedVersion?.versionId || "", aisleUuid)
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error removing aisle`);
|
|
return;
|
|
}
|
|
if (data.message === "Aisle Deleted Successfully") {
|
|
removeAisleFromScene(aisleUuid, () => {
|
|
echo.info(`Removed aisle: ${aisleUuid}`);
|
|
});
|
|
} else {
|
|
echo.error(`Error removing aisle: ${aisleUuid}`);
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error removing aisle: ${aisleUuid}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
aisleUuid,
|
|
projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId,
|
|
organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-aisle:delete", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
const updateAisleFromBackend = (aisleUuid: string, updatedData: Aisle) => {
|
|
if (projectId) {
|
|
if (!builderSocket?.connected) {
|
|
// API
|
|
|
|
upsertAisleApi(aisleUuid, updatedData.points, updatedData.type, projectId, selectedVersion?.versionId || "")
|
|
.then((data) => {
|
|
if (!data.message || !data.data) {
|
|
echo.error(`Error updating aisle`);
|
|
return;
|
|
}
|
|
if (data.message === "Aisle Updated Successfully") {
|
|
updateAisleInScene(updatedData, () => {
|
|
echo.info(`Updated aisle: ${aisleUuid}`);
|
|
});
|
|
}
|
|
})
|
|
.catch(() => {
|
|
echo.error(`Error updating aisle: ${aisleUuid}`);
|
|
});
|
|
} else {
|
|
// SOCKET
|
|
|
|
const data = {
|
|
...updatedData,
|
|
projectId,
|
|
versionId: selectedVersion?.versionId || "",
|
|
userId,
|
|
organization,
|
|
};
|
|
|
|
builderSocket.emit("v1:model-aisle:add", data);
|
|
}
|
|
}
|
|
};
|
|
|
|
return { handleRedo };
|
|
}
|
|
|
|
export default use2DRedoHandler;
|