updated

app/src/modules/builder/geomentries/lines/deleteLine.ts

@@ -2,91 +2,91 @@ import { Socket } from "socket.io-client";
 // import { deleteLineApi } from "../../../../services/factoryBuilder/lines/deleteLineApi";
 import * as Types from "../../../../types/world/worldTypes";
 
-import { toast } from 'react-toastify';
+import { toast } from "react-toastify";
+import { getUserData } from "../../../../functions/getUserData";
 
 function deleteLine(
-    hoveredDeletableLine: Types.RefMesh,
-    onlyFloorlines: Types.RefOnlyFloorLines,
-    lines: Types.RefLines,
-    floorPlanGroupLine: Types.RefGroup,
-    floorPlanGroupPoint: Types.RefGroup,
-    setDeletedLines: any,
-    socket: Socket<any>,
-    projectId?: string
+  hoveredDeletableLine: Types.RefMesh,
+  onlyFloorlines: Types.RefOnlyFloorLines,
+  lines: Types.RefLines,
+  floorPlanGroupLine: Types.RefGroup,
+  floorPlanGroupPoint: Types.RefGroup,
+  setDeletedLines: any,
+  socket: Socket<any>,
+  projectId?: string,
+  versionId?: string,
 ): void {
+  const { userId, organization, email } = getUserData();
+  //////////  Deleting a line and the points if they are not connected to any other line  //////////
 
-    //////////  Deleting a line and the points if they are not connected to any other line  //////////
+  if (!hoveredDeletableLine.current) {
+    return;
+  }
 
-    if (!hoveredDeletableLine.current) {
-        return;
-    }
+  const linePoints = hoveredDeletableLine.current.userData.linePoints;
+  const connectedpoints = [linePoints[0][1], linePoints[1][1]];
 
-    const linePoints = hoveredDeletableLine.current.userData.linePoints;
-    const connectedpoints = [linePoints[0][1], linePoints[1][1]];
+  //REST
 
-    const email = localStorage.getItem('email')
-    const organization = (email!.split("@")[1]).split(".")[0];
-    const userId = localStorage.getItem("userId");
+  // deleteLineApi(
+  //     organization,
+  //     [
+  //         { "uuid": linePoints[0][1] },
+  //         { "uuid": linePoints[1][1] }
+  //     ]
+  // )
 
-    //REST
+  //SOCKET
 
-    // deleteLineApi(
-    //     organization,
-    //     [
-    //         { "uuid": linePoints[0][1] },
-    //         { "uuid": linePoints[1][1] }
-    //     ]
-    // )
+  const data = {
+    organization,
+    line: [{ uuid: linePoints[0][1] }, { uuid: linePoints[1][1] }],
+    socketId: socket.id,
+    versionId,
+    projectId,
+    userId,
+  };
 
-    //SOCKET
+  socket.emit("v1:Line:delete", data);
 
-    const data = {
-        organization: organization,
-        line: [
-            { "uuid": linePoints[0][1] },
-            { "uuid": linePoints[1][1] }
-        ],
-        socketId: socket.id,
-        projectId,
-        userId
-    }
+  onlyFloorlines.current = onlyFloorlines.current
+    .map((floorline) =>
+      floorline.filter(
+        (line) =>
+          line[0][1] !== connectedpoints[0] && line[1][1] !== connectedpoints[1]
+      )
+    )
+    .filter((floorline) => floorline.length > 0);
 
-    socket.emit('v1:Line:delete', data);
+  lines.current = lines.current.filter((item) => item !== linePoints);
+  (<any>hoveredDeletableLine.current.material).dispose();
+  (<any>hoveredDeletableLine.current.geometry).dispose();
+  floorPlanGroupLine.current.remove(hoveredDeletableLine.current);
+  setDeletedLines([linePoints]);
 
-
-    onlyFloorlines.current = onlyFloorlines.current.map(floorline =>
-        floorline.filter(line => line[0][1] !== connectedpoints[0] && line[1][1] !== connectedpoints[1])
-    ).filter(floorline => floorline.length > 0);
-
-    lines.current = lines.current.filter(item => item !== linePoints);
-    (<any>hoveredDeletableLine.current.material).dispose();
-    (<any>hoveredDeletableLine.current.geometry).dispose();
-    floorPlanGroupLine.current.remove(hoveredDeletableLine.current);
-    setDeletedLines([linePoints]);
-
-    connectedpoints.forEach((pointUUID) => {
-        let isConnected = false;
-        floorPlanGroupLine.current.children.forEach((line) => {
-            const linePoints = line.userData.linePoints;
-            const uuid1 = linePoints[0][1];
-            const uuid2 = linePoints[1][1];
-            if (uuid1 === pointUUID || uuid2 === pointUUID) {
-                isConnected = true;
-            }
-        });
-
-        if (!isConnected) {
-            floorPlanGroupPoint.current.children.forEach((point: any) => {
-                if (point.uuid === pointUUID) {
-                    (<any>point.material).dispose();
-                    (<any>point.geometry).dispose();
-                    floorPlanGroupPoint.current.remove(point);
-                }
-            });
-        }
+  connectedpoints.forEach((pointUUID) => {
+    let isConnected = false;
+    floorPlanGroupLine.current.children.forEach((line) => {
+      const linePoints = line.userData.linePoints;
+      const uuid1 = linePoints[0][1];
+      const uuid2 = linePoints[1][1];
+      if (uuid1 === pointUUID || uuid2 === pointUUID) {
+        isConnected = true;
+      }
     });
 
-    echo.success("Line Removed!");
+    if (!isConnected) {
+      floorPlanGroupPoint.current.children.forEach((point: any) => {
+        if (point.uuid === pointUUID) {
+          (<any>point.material).dispose();
+          (<any>point.geometry).dispose();
+          floorPlanGroupPoint.current.remove(point);
+        }
+      });
+    }
+  });
+
+  echo.success("Line Removed!");
 }
 
 export default deleteLine;

app/src/modules/builder/geomentries/lines/distanceText/distanceText.tsx

@@ -15,6 +15,8 @@ import * as Types from "../../../../../types/world/worldTypes";
 import getRoomsFromLines from "../getRoomsFromLines";
 import * as turf from '@turf/turf';
 import { useParams } from "react-router-dom";
+import { getUserData } from "../../../../../functions/getUserData";
+import { useVersionContext } from "../../../version/versionContext";
 
 const DistanceText = () => {
   const [lines, setLines] = useState<
@@ -31,7 +33,10 @@ const DistanceText = () => {
   const { deletedLines, setDeletedLines } = useDeletedLines();
   const [linesState, setLinesState] = useState<Types.Lines>([]);
   const { roomsState, setRoomsState } = useRoomsState();
+  const { selectedVersionStore } = useVersionContext();
+  const { selectedVersion } = selectedVersionStore();
   const { projectId } = useParams();
+  const { organization, email } = getUserData();
 
   useEffect(() => {
 
@@ -93,11 +98,9 @@ const DistanceText = () => {
 
 
   useEffect(() => {
-    const email = localStorage.getItem("email");
     if (!email) return;
-    const organization = email.split("@")[1].split(".")[0];
 
-    getLines(organization,projectId).then((data) => {
+    getLines(organization, projectId, selectedVersion?.versionId || '').then((data) => {
       data = objectLinesToArray(data);
       setLinesState(data);
 
@@ -127,7 +130,7 @@ const DistanceText = () => {
         });
       setLines(lines);
     });
-  }, [activeLayer]);
+  }, [activeLayer, selectedVersion?.versionId]);
 
   useEffect(() => {
     if (newLines.length > 0) {

app/src/modules/builder/geomentries/lines/drawWall.ts

@@ -1,146 +1,129 @@
-import * as THREE from 'three';
-import * as CONSTANTS from '../../../../types/world/worldConstants';
+import * as THREE from "three";
+import * as CONSTANTS from "../../../../types/world/worldConstants";
 
-import addPointToScene from '../points/addPointToScene';
-import addLineToScene from './addLineToScene';
-import splitLine from './splitLine';
-import removeReferenceLine from './removeReferenceLine';
-import getClosestIntersection from './getClosestIntersection';
+import addPointToScene from "../points/addPointToScene";
+import addLineToScene from "./addLineToScene";
+import splitLine from "./splitLine";
+import removeReferenceLine from "./removeReferenceLine";
+import getClosestIntersection from "./getClosestIntersection";
 
 import * as Types from "../../../../types/world/worldTypes";
-import arrayLineToObject from './lineConvertions/arrayLineToObject';
+import arrayLineToObject from "./lineConvertions/arrayLineToObject";
 // import { setLine } from '../../../../services/factoryBuilder/lines/setLineApi';
-import { Socket } from 'socket.io-client';
+import { Socket } from "socket.io-client";
+import { getUserData } from "../../../../functions/getUserData";
 
 async function drawWall(
-    raycaster: THREE.Raycaster,
-    plane: Types.RefMesh,
-    floorPlanGroupPoint: Types.RefGroup,
-    snappedPoint: Types.RefVector3,
-    isSnapped: Types.RefBoolean,
-    isSnappedUUID: Types.RefString,
-    line: Types.RefLine,
-    ispreSnapped: Types.RefBoolean,
-    anglesnappedPoint: Types.RefVector3,
-    isAngleSnapped: Types.RefBoolean,
-    lines: Types.RefLines,
-    floorPlanGroupLine: Types.RefGroup,
-    floorPlanGroup: Types.RefGroup,
-    ReferenceLineMesh: Types.RefMesh,
-    LineCreated: Types.RefBoolean,
-    currentLayerPoint: Types.RefMeshArray,
-    dragPointControls: Types.RefDragControl,
-    setNewLines: any,
-    setDeletedLines: any,
-    activeLayer: Types.Number,
-    socket: Socket<any>,
-    projectId?: string
+  raycaster: THREE.Raycaster,
+  plane: Types.RefMesh,
+  floorPlanGroupPoint: Types.RefGroup,
+  snappedPoint: Types.RefVector3,
+  isSnapped: Types.RefBoolean,
+  isSnappedUUID: Types.RefString,
+  line: Types.RefLine,
+  ispreSnapped: Types.RefBoolean,
+  anglesnappedPoint: Types.RefVector3,
+  isAngleSnapped: Types.RefBoolean,
+  lines: Types.RefLines,
+  floorPlanGroupLine: Types.RefGroup,
+  floorPlanGroup: Types.RefGroup,
+  ReferenceLineMesh: Types.RefMesh,
+  LineCreated: Types.RefBoolean,
+  currentLayerPoint: Types.RefMeshArray,
+  dragPointControls: Types.RefDragControl,
+  setNewLines: any,
+  setDeletedLines: any,
+  activeLayer: Types.Number,
+  socket: Socket<any>,
+  projectId?: string,
+  versionId?: string,
 ): Promise<void> {
+  const { userId, organization, email } = getUserData();
+  //////////  Creating lines Based on the positions clicked  //////////
 
-    //////////  Creating lines Based on the positions clicked  //////////
+  //////////  Allows the user lines that represents walls and roof, floor if forms a polygon  //////////
 
-    //////////  Allows the user lines that represents walls and roof, floor if forms a polygon  //////////
+  if (!plane.current) return;
+  let intersects = raycaster.intersectObject(plane.current, true);
 
+  let intersectsLines = raycaster.intersectObjects(
+    floorPlanGroupLine.current.children,
+    true
+  );
+  let intersectsPoint = raycaster.intersectObjects(
+    floorPlanGroupPoint.current.children,
+    true
+  );
 
-    if (!plane.current) return
-    let intersects = raycaster.intersectObject(plane.current, true);
+  const VisibleintersectsPoint = intersectsPoint.find(
+    (intersect) => intersect.object.visible
+  );
+  const visibleIntersect = intersectsLines.find(
+    (intersect) =>
+      intersect.object.visible &&
+      intersect.object.name !== CONSTANTS.lineConfig.referenceName &&
+      intersect.object.userData.linePoints[0][3] ===
+      CONSTANTS.lineConfig.wallName
+  );
 
-    let intersectsLines = raycaster.intersectObjects(floorPlanGroupLine.current.children, true);
-    let intersectsPoint = raycaster.intersectObjects(floorPlanGroupPoint.current.children, true);
+  if (
+    (intersectsPoint.length === 0 || VisibleintersectsPoint === undefined) &&
+    intersectsLines.length > 0 &&
+    !isSnapped.current &&
+    !ispreSnapped.current
+  ) {
+    //////////  Clicked on a preexisting Line  //////////
 
-    const VisibleintersectsPoint = intersectsPoint.find(intersect => intersect.object.visible);
-    const visibleIntersect = intersectsLines.find(intersect => intersect.object.visible && intersect.object.name !== CONSTANTS.lineConfig.referenceName && intersect.object.userData.linePoints[0][3] === CONSTANTS.lineConfig.wallName);
+    if (visibleIntersect && intersects) {
+      let IntersectsPoint = new THREE.Vector3(
+        intersects[0].point.x,
+        0.01,
+        intersects[0].point.z
+      );
 
-    if ((intersectsPoint.length === 0 || VisibleintersectsPoint === undefined) && intersectsLines.length > 0 && !isSnapped.current && !ispreSnapped.current) {
+      if (isAngleSnapped.current && anglesnappedPoint.current) {
+        IntersectsPoint = anglesnappedPoint.current;
+      }
+      if (visibleIntersect.object instanceof THREE.Mesh) {
+        const ThroughPoint =
+          visibleIntersect.object.geometry.parameters.path.getPoints(
+            CONSTANTS.lineConfig.lineIntersectionPoints
+          );
+        let intersectionPoint = getClosestIntersection(
+          ThroughPoint,
+          IntersectsPoint
+        );
 
-        //////////  Clicked on a preexisting Line  //////////
+        if (intersectionPoint) {
+          const newLines = splitLine(
+            visibleIntersect,
+            intersectionPoint,
+            currentLayerPoint,
+            floorPlanGroupPoint,
+            dragPointControls,
+            isSnappedUUID,
+            lines,
+            setDeletedLines,
+            floorPlanGroupLine,
+            socket,
+            CONSTANTS.pointConfig.wallOuterColor,
+            CONSTANTS.lineConfig.wallColor,
+            CONSTANTS.lineConfig.wallName,
+            projectId,
+            versionId
+          );
+          setNewLines([newLines[0], newLines[1]]);
 
-        if (visibleIntersect && intersects) {
-            let IntersectsPoint = new THREE.Vector3(intersects[0].point.x, 0.01, intersects[0].point.z);
+          (line.current as Types.Line).push([
+            new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z),
+            isSnappedUUID.current!,
+            activeLayer,
+            CONSTANTS.lineConfig.wallName,
+          ]);
 
-            if (isAngleSnapped.current && anglesnappedPoint.current) {
-                IntersectsPoint = anglesnappedPoint.current;
-            }
-            if (visibleIntersect.object instanceof THREE.Mesh) {
-                const ThroughPoint = (visibleIntersect.object.geometry.parameters.path).getPoints(CONSTANTS.lineConfig.lineIntersectionPoints);
-                let intersectionPoint = getClosestIntersection(ThroughPoint, IntersectsPoint);
-
-                if (intersectionPoint) {
-
-                    const newLines = splitLine(visibleIntersect, intersectionPoint, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, lines, setDeletedLines, floorPlanGroupLine, socket, CONSTANTS.pointConfig.wallOuterColor, CONSTANTS.lineConfig.wallColor, CONSTANTS.lineConfig.wallName,projectId);
-                    setNewLines([newLines[0], newLines[1]]);
-
-                    (line.current as Types.Line).push([new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z), isSnappedUUID.current!, activeLayer, CONSTANTS.lineConfig.wallName,]);
-
-                    if (line.current.length >= 2 && line.current[0] && line.current[1]) {
-                        const data = arrayLineToObject(line.current as Types.Line);
-
-                        const email = localStorage.getItem('email')
-                        const organization = (email!.split("@")[1]).split(".")[0];
-                        const userId = localStorage.getItem("userId");
-
-                        //REST
-
-                        // setLine(organization, data.layer!, data.line!, data.type!);
-
-                        //SOCKET
-
-                        const input = {
-                            organization: organization,
-                            layer: data.layer,
-                            line: data.line,
-                            type: data.type,
-                            socketId: socket.id,
-                            projectId,
-                            userId
-                        }
-
-                        socket.emit('v1:Line:create', input);
-
-                        setNewLines([newLines[0], newLines[1], line.current]);
-                        lines.current.push(line.current as Types.Line);
-                        addLineToScene(line.current[0][0], line.current[1][0], CONSTANTS.lineConfig.wallColor, line.current, floorPlanGroupLine);
-                        let lastPoint = line.current[line.current.length - 1];
-                        line.current = [lastPoint];
-                    }
-                    return;
-                }
-            }
-        }
-    }
-
-    if (intersects && intersects.length > 0) {
-
-        //////////  Clicked on a emply place or a point  //////////
-
-        let intersectionPoint = intersects[0].point;
-
-        if (isAngleSnapped.current && line.current.length > 0 && anglesnappedPoint.current) {
-            intersectionPoint = anglesnappedPoint.current;
-        }
-        if (isSnapped.current && line.current.length > 0 && snappedPoint.current) {
-            intersectionPoint = snappedPoint.current;
-        }
-        if (ispreSnapped.current && snappedPoint.current) {
-            intersectionPoint = snappedPoint.current;
-        }
-
-        if (!isSnapped.current && !ispreSnapped.current) {
-            addPointToScene(intersectionPoint, CONSTANTS.pointConfig.wallOuterColor, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, CONSTANTS.lineConfig.wallName);
-        } else {
-            ispreSnapped.current = false;
-            isSnapped.current = false;
-        }
-
-        (line.current as Types.Line).push([new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z), isSnappedUUID.current!, activeLayer, CONSTANTS.lineConfig.wallName,]);
-
-        if (line.current.length >= 2 && line.current[0] && line.current[1]) {
+          if (line.current.length >= 2 && line.current[0] && line.current[1]) {
             const data = arrayLineToObject(line.current as Types.Line);
 
-            const email = localStorage.getItem('email')
-            const organization = (email!.split("@")[1]).split(".")[0];
-            const userId = localStorage.getItem("userId");
-
             //REST
 
             // setLine(organization, data.layer!, data.line!, data.type!);
@@ -148,27 +131,115 @@ async function drawWall(
             //SOCKET
 
             const input = {
-                organization: organization,
-                layer: data.layer,
-                line: data.line,
-                type: data.type,
-                socketId: socket.id,
-                projectId,
-                userId
-            }
+              organization,
+              layer: data.layer,
+              line: data.line,
+              type: data.type,
+              socketId: socket.id,
+              versionId,
+              projectId,
+              userId,
+            };
 
-            socket.emit('v1:Line:create', input);
+            socket.emit("v1:Line:create", input);
 
-            setNewLines([line.current])
+            setNewLines([newLines[0], newLines[1], line.current]);
             lines.current.push(line.current as Types.Line);
-            addLineToScene(line.current[0][0], line.current[1][0], CONSTANTS.lineConfig.wallColor, line.current, floorPlanGroupLine);
+            addLineToScene(
+              line.current[0][0],
+              line.current[1][0],
+              CONSTANTS.lineConfig.wallColor,
+              line.current,
+              floorPlanGroupLine
+            );
             let lastPoint = line.current[line.current.length - 1];
             line.current = [lastPoint];
+          }
+          return;
         }
-        if (isSnapped.current) {
-            removeReferenceLine(floorPlanGroup, ReferenceLineMesh, LineCreated, line);
-        }
+      }
     }
+  }
+
+  if (intersects && intersects.length > 0) {
+    //////////  Clicked on a emply place or a point  //////////
+
+    let intersectionPoint = intersects[0].point;
+
+    if (
+      isAngleSnapped.current &&
+      line.current.length > 0 &&
+      anglesnappedPoint.current
+    ) {
+      intersectionPoint = anglesnappedPoint.current;
+    }
+    if (isSnapped.current && line.current.length > 0 && snappedPoint.current) {
+      intersectionPoint = snappedPoint.current;
+    }
+    if (ispreSnapped.current && snappedPoint.current) {
+      intersectionPoint = snappedPoint.current;
+    }
+
+    if (!isSnapped.current && !ispreSnapped.current) {
+      addPointToScene(
+        intersectionPoint,
+        CONSTANTS.pointConfig.wallOuterColor,
+        currentLayerPoint,
+        floorPlanGroupPoint,
+        dragPointControls,
+        isSnappedUUID,
+        CONSTANTS.lineConfig.wallName
+      );
+    } else {
+      ispreSnapped.current = false;
+      isSnapped.current = false;
+    }
+
+    (line.current as Types.Line).push([
+      new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z),
+      isSnappedUUID.current!,
+      activeLayer,
+      CONSTANTS.lineConfig.wallName,
+    ]);
+
+    if (line.current.length >= 2 && line.current[0] && line.current[1]) {
+      const data = arrayLineToObject(line.current as Types.Line);
+
+      //REST
+
+      // setLine(organization, data.layer!, data.line!, data.type!);
+
+      //SOCKET
+
+      const input = {
+        organization,
+        layer: data.layer,
+        line: data.line,
+        type: data.type,
+        socketId: socket.id,
+        versionId,
+        projectId,
+        userId,
+      };
+
+      socket.emit("v1:Line:create", input);
+
+      setNewLines([line.current]);
+      lines.current.push(line.current as Types.Line);
+      addLineToScene(
+        line.current[0][0],
+        line.current[1][0],
+        CONSTANTS.lineConfig.wallColor,
+        line.current,
+        floorPlanGroupLine
+      );
+      let lastPoint = line.current[line.current.length - 1];
+      line.current = [lastPoint];
+    }
+    if (isSnapped.current) {
+      removeReferenceLine(floorPlanGroup, ReferenceLineMesh, LineCreated, line);
+    }
+  }
 }
 
 export default drawWall;

app/src/modules/builder/geomentries/lines/getClosestIntersection.ts

@@ -5,11 +5,11 @@ import * as Types from "../../../../types/world/worldTypes";
 function getClosestIntersection(
     intersects: Types.Vector3Array,
     point: Types.Vector3
-): Types.Vector3 | null {
+): Types.Vector3 {
 
     //////////  A function that finds which point is closest from the intersects points that is given, Used in finding which point in a line is closest when clicked on a line during drawing  ////////// 
 
-    let closestNewPoint: THREE.Vector3 | null = null;
+    let closestNewPoint: THREE.Vector3 = point;
     let minDistance = Infinity;
 
     for (const intersect of intersects) {

app/src/modules/builder/geomentries/lines/splitLine.ts

@@ -1,132 +1,151 @@
-import * as THREE from 'three';
+import * as THREE from "three";
 
-import addLineToScene from './addLineToScene';
-import addPointToScene from '../points/addPointToScene';
+import addLineToScene from "./addLineToScene";
+import addPointToScene from "../points/addPointToScene";
 
 import * as Types from "../../../../types/world/worldTypes";
-import arrayLineToObject from '../lines/lineConvertions/arrayLineToObject';
-import { Socket } from 'socket.io-client';
+import arrayLineToObject from "../lines/lineConvertions/arrayLineToObject";
+import { Socket } from "socket.io-client";
+import { getUserData } from "../../../../functions/getUserData";
 // import { deleteLineApi } from '../../../../services/factoryBuilder/lines/deleteLineApi';
 // import { setLine } from '../../../../services/factoryBuilder/lines/setLineApi';
 
 function splitLine(
-    visibleIntersect: Types.IntersectionEvent,
-    intersectionPoint: Types.Vector3,
-    currentLayerPoint: Types.RefMeshArray,
-    floorPlanGroupPoint: Types.RefGroup,
-    dragPointControls: Types.RefDragControl,
-    isSnappedUUID: Types.RefString,
-    lines: Types.RefLines,
-    setDeletedLines: any,
-    floorPlanGroupLine: { current: THREE.Group },
-    socket: Socket<any>,
-    pointColor: Types.String,
-    lineColor: Types.String,
-    lineType: Types.String,
-    projectId?: string
+  visibleIntersect: Types.IntersectionEvent,
+  intersectionPoint: Types.Vector3,
+  currentLayerPoint: Types.RefMeshArray,
+  floorPlanGroupPoint: Types.RefGroup,
+  dragPointControls: Types.RefDragControl,
+  isSnappedUUID: Types.RefString,
+  lines: Types.RefLines,
+  setDeletedLines: any,
+  floorPlanGroupLine: { current: THREE.Group },
+  socket: Socket<any>,
+  pointColor: Types.String,
+  lineColor: Types.String,
+  lineType: Types.String,
+  projectId?: string,
+  versionId?: string,
 ): [Types.Line, Types.Line] {
+  //////////  Removing the clicked line and splitting it with the clicked position adding a new point and two new lines  //////////
 
-    //////////  Removing the clicked line and splitting it with the clicked position adding a new point and two new lines  //////////
+  const { userId, organization, email } = getUserData();
+  (visibleIntersect.object as any).material.dispose();
+  (visibleIntersect.object as any).geometry.dispose();
+  floorPlanGroupLine.current.remove(visibleIntersect.object);
+  setDeletedLines([visibleIntersect.object.userData.linePoints]);
 
+  //REST
 
-    ((visibleIntersect.object as any).material).dispose();
-    ((visibleIntersect.object as any).geometry).dispose();
-    floorPlanGroupLine.current.remove(visibleIntersect.object);
-    setDeletedLines([visibleIntersect.object.userData.linePoints]);
+  // deleteLineApi(
+  //     organization,
+  //     [
+  //         { "uuid": visibleIntersect.object.userData.linePoints[0][1] },
+  //         { "uuid": visibleIntersect.object.userData.linePoints[1][1] }
+  //     ]
+  // )
 
-    const email = localStorage.getItem('email')
-    const organization = (email!.split("@")[1]).split(".")[0];
-    const userId = localStorage.getItem("userId");
+  //SOCKET
 
-    //REST
+  const data = {
+    organization,
+    line: [
+      { uuid: visibleIntersect.object.userData.linePoints[0][1] },
+      { uuid: visibleIntersect.object.userData.linePoints[1][1] },
+    ],
+    socketId: socket.id,
+    versionId,
+    projectId,
+    userId,
+  };
 
-    // deleteLineApi(
-    //     organization,
-    //     [
-    //         { "uuid": visibleIntersect.object.userData.linePoints[0][1] },
-    //         { "uuid": visibleIntersect.object.userData.linePoints[1][1] }
-    //     ]
-    // )
+  socket.emit("v1:Line:delete", data);
 
-    //SOCKET
+  const point = addPointToScene(
+    intersectionPoint,
+    pointColor,
+    currentLayerPoint,
+    floorPlanGroupPoint,
+    dragPointControls,
+    isSnappedUUID,
+    lineType
+  );
 
+  const oldLinePoints = visibleIntersect.object.userData.linePoints;
+  lines.current = lines.current.filter((item) => item !== oldLinePoints);
 
-    const data = {
-        organization: organization,
-        line: [
-            { "uuid": visibleIntersect.object.userData.linePoints[0][1] },
-            { "uuid": visibleIntersect.object.userData.linePoints[1][1] }
-        ],
-        socketId: socket.id,
-        projectId,
-        userId
-    }
+  const clickedPoint: Types.Point = [
+    new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z),
+    point.uuid,
+    oldLinePoints[0][2],
+    lineType,
+  ];
 
-    socket.emit('v1:Line:delete', data);
+  const start = oldLinePoints[0];
+  const end = oldLinePoints[1];
 
-    const point = addPointToScene(intersectionPoint, pointColor, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, lineType);
+  const newLine1: Types.Line = [start, clickedPoint];
+  const newLine2: Types.Line = [clickedPoint, end];
 
-    const oldLinePoints = visibleIntersect.object.userData.linePoints;
-    lines.current = lines.current.filter(item => item !== oldLinePoints);
+  const line1 = arrayLineToObject(newLine1);
+  const line2 = arrayLineToObject(newLine2);
 
-    const clickedPoint: Types.Point = [
-        new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z),
-        point.uuid,
-        oldLinePoints[0][2],
-        lineType
-    ];
+  //REST
 
-    const start = oldLinePoints[0];
-    const end = oldLinePoints[1];
+  // setLine(organization, line1.layer!, line1.line!, line1.type!);
 
-    const newLine1: Types.Line = [start, clickedPoint];
-    const newLine2: Types.Line = [clickedPoint, end];
+  //SOCKET
 
-    const line1 = arrayLineToObject(newLine1);
-    const line2 = arrayLineToObject(newLine2);
+  const input1 = {
+    organization,
+    layer: line1.layer,
+    line: line1.line,
+    type: line1.type,
+    socketId: socket.id,
+    versionId,
+    projectId,
+    userId,
+  };
 
-    //REST
+  socket.emit("v1:Line:create", input1);
 
-    // setLine(organization, line1.layer!, line1.line!, line1.type!);
+  //REST
 
-    //SOCKET
+  // setLine(organization, line2.layer!, line2.line!, line2.type!);
 
-    const input1 = {
-        organization: organization,
-        layer: line1.layer,
-        line: line1.line,
-        type: line1.type,
-        socketId: socket.id,
-        projectId,
-        userId
-    }
+  //SOCKET
 
-    socket.emit('v1:Line:create', input1);
+  const input2 = {
+    organization,
+    layer: line2.layer,
+    line: line2.line,
+    type: line2.type,
+    socketId: socket.id,
+    versionId,
+    projectId,
+    userId,
+  };
 
-    //REST
+  socket.emit("v1:Line:create", input2);
 
-    // setLine(organization, line2.layer!, line2.line!, line2.type!);
+  lines.current.push(newLine1, newLine2);
 
-    //SOCKET
+  addLineToScene(
+    newLine1[0][0],
+    newLine1[1][0],
+    lineColor,
+    newLine1,
+    floorPlanGroupLine
+  );
+  addLineToScene(
+    newLine2[0][0],
+    newLine2[1][0],
+    lineColor,
+    newLine2,
+    floorPlanGroupLine
+  );
 
-    const input2 = {
-        organization: organization,
-        layer: line2.layer,
-        line: line2.line,
-        type: line2.type,
-        socketId: socket.id,
-        projectId,
-        userId
-    }
-
-    socket.emit('v1:Line:create', input2);
-
-    lines.current.push(newLine1, newLine2);
-
-    addLineToScene(newLine1[0][0], newLine1[1][0], lineColor, newLine1, floorPlanGroupLine);
-    addLineToScene(newLine2[0][0], newLine2[1][0], lineColor, newLine2, floorPlanGroupLine);
-
-    return [newLine1, newLine2];
+  return [newLine1, newLine2];
 }
 
 export default splitLine;