import computation done

rajman01 · rajman01 · commit 28ad26b6edad · 2026-01-05T11:44:15.000+01:00
diff --git a/src/adapters/controllers/PlanController.ts b/src/adapters/controllers/PlanController.ts
@@ -24,6 +24,7 @@ import {
     EditLongitudinalProfileParametersRequest,
 } from '@use-cases/plan/EditLongitudinalProfileParameters';
 import { ConvertComputation, ConvertComputationRequest } from '@use-cases/plan/ConvertComputation';
+import { ImportComputation, ImportComputationRequest } from '@use-cases/plan/ImportComputation';
 
 export class PlanController {
     constructor(
@@ -43,6 +44,7 @@ export class PlanController {
         private readonly editTopoSettingUseCase: EditTopoSetting,
         private readonly editLongitudinalProfileParametersUseCase: EditLongitudinalProfileParameters,
         private readonly convertComputationUseCase: ConvertComputation,
+        private readonly importComputationUseCase: ImportComputation,
     ) {}
 
     async createPlan(
@@ -504,4 +506,27 @@ export class PlanController {
             return handleError(e);
         }
     }
+
+    async importComputation(
+        req: HttpRequest<ImportComputationRequest, { plan_id: string }, undefined, undefined, AuthenticateResponse>,
+    ): Promise<HttpResponse<void | Error>> {
+        try {
+            const error = PlanValidator.validateImportComputation(req.body);
+            if (error) {
+                return badRequest(error);
+            }
+
+            await this.importComputationUseCase.execute({
+                ...req.body!,
+                plan_id: req.params!.plan_id,
+                options: {
+                    filter: { user: req.user!.id },
+                },
+            });
+
+            return noContent();
+        } catch (e) {
+            return handleError(e);
+        }
+    }
 }
diff --git a/src/adapters/validators/PlanValidator.ts b/src/adapters/validators/PlanValidator.ts
@@ -293,4 +293,19 @@ export class PlanValidator {
 
         return null;
     }
+
+    static validateImportComputation(data: any): Error | null {
+        const rules = {
+            computation_id: 'required|string',
+            replace: 'required|boolean',
+        };
+
+        try {
+            validator.validate(data, rules);
+        } catch (e) {
+            return new Error((e as Error).message);
+        }
+
+        return null;
+    }
 }
diff --git a/src/main/config/container.ts b/src/main/config/container.ts
@@ -55,6 +55,7 @@ import { EditTopoSetting } from '@use-cases/plan/EditTopoSetting';
 import { GoogleAuth } from '@use-cases/auth/GoogleAuth';
 import { EditLongitudinalProfileParameters } from '@use-cases/plan/EditLongitudinalProfileParameters';
 import { ConvertComputation } from '@use-cases/plan/ConvertComputation';
+import { ImportComputation } from '@use-cases/plan/ImportComputation';
 
 export class Container {
     private instances = new Map<string, any>();
@@ -299,6 +300,24 @@ export function setupContainer(): Container {
         return new ConvertComputation(
             container.resolve<Logger>('Logger'),
             container.resolve<PlanRepositoryInterface>('PlanRepo'),
+            container.resolve('ForwardComputationUseCase'),
+            container.resolve('TraverseComputationUseCase'),
+            container.resolve('EditCoordinateUseCase'),
+            container.resolve('EditTopoBoundaryUseCase'),
+            container.resolve('DifferentialLevelingUseCase'),
+            container.resolve('EditElevationUseCase'),
+        );
+    });
+    container.register('ImportComputationUseCase', () => {
+        return new ImportComputation(
+            container.resolve<Logger>('Logger'),
+            container.resolve<PlanRepositoryInterface>('PlanRepo'),
+            container.resolve('ForwardComputationUseCase'),
+            container.resolve('TraverseComputationUseCase'),
+            container.resolve('EditCoordinateUseCase'),
+            container.resolve('EditTopoBoundaryUseCase'),
+            container.resolve('DifferentialLevelingUseCase'),
+            container.resolve('EditElevationUseCase'),
         );
     });
 
@@ -364,6 +383,7 @@ export function setupContainer(): Container {
             container.resolve('EditTopoSettingUseCase'),
             container.resolve('EditLongitudinalProfileParametersUseCase'),
             container.resolve('ConvertComputationUseCase'),
+            container.resolve('ImportComputationUseCase'),
         );
     });
 
diff --git a/src/main/routes/plan-routes.ts b/src/main/routes/plan-routes.ts
@@ -40,12 +40,15 @@ export default (logger: Logger, authController: AuthController, planController:
         '/differential-leveling-data/edit/:plan_id',
         expressRouteAdapter(planController.editDifferentialLeveling.bind(planController)),
     );
+
     router.get('/generate/:plan_id', expressRouteAdapter(planController.generatePlan.bind(planController)));
 
     router.put(
         '/computation/convert/:plan_id',
         expressRouteAdapter(planController.convertComputation.bind(planController)),
     );
 
+    router.put('/import/:plan_id', expressRouteAdapter(planController.importComputation.bind(planController)));
+
     return router;
 };
diff --git a/src/use-cases/auth/SendLoginOTP.ts b/src/use-cases/auth/SendLoginOTP.ts
@@ -49,7 +49,6 @@ export class SendLoginOTP {
 
         // generate OTP
         const otp = await this.createOTP.execute({ identifier: user.id, type: `login_otp`, exp: 10 });
-        console.log(otp);
         await this.sendOTP(user.email, 10, otp);
     }
 
diff --git a/src/use-cases/plan/ConvertComputation.ts b/src/use-cases/plan/ConvertComputation.ts
@@ -3,6 +3,12 @@ import { LongitudinalProfileParameters, PlanType, TopographicSetting } from '@do
 import { PlanRepositoryInterface } from '@domain/interfaces/repositories/PlanRepositoryInterface';
 import NotFoundError from '@domain/errors/NotFoundError';
 import BadRequestError from '@domain/errors/BadRequestError';
+import { ForwardComputation } from '@use-cases/traversing/ForwardComputation';
+import { EditCoordinates } from '@use-cases/plan/EditCoordinates';
+import { EditTopoBoundary } from '@use-cases/plan/EditTopoBoundary';
+import { TraverseComputation } from '@use-cases/traversing/TraverseComputation';
+import { DifferentialLeveling } from '@use-cases/leveling/DifferentialLeveling';
+import { EditElevation } from '@use-cases/plan/EditElevation';
 
 export interface ConvertComputationRequest {
     plan_id: string;
@@ -14,13 +20,19 @@ export class ConvertComputation {
     constructor(
         private readonly logger: Logger,
         private readonly planRepo: PlanRepositoryInterface,
+        private readonly forwardComputationUseCase: ForwardComputation,
+        private readonly traverseComputationUseCase: TraverseComputation,
+        private readonly editCoordinatesUseCase: EditCoordinates,
+        private readonly editTopoBoundaryUseCase: EditTopoBoundary,
+        private readonly differentialLevelingUseCase: DifferentialLeveling,
+        private readonly editElevationUseCase: EditElevation,
     ) {}
 
     async execute(data: ConvertComputationRequest): Promise<void> {
         this.logger.debug('Convert Computation execute');
 
         // get plan
-        const plan = await this.planRepo.getPlanById(data.plan_id, data.options);
+        let plan = await this.planRepo.getPlanById(data.plan_id, data.options);
         if (!plan) {
             throw new NotFoundError('Plan not found');
         }
@@ -61,11 +73,95 @@ export class ConvertComputation {
             throw new BadRequestError('Only Computations can be converted to a plan');
         }
 
-        await this.planRepo.editPlan(plan.id, {
+        plan = await this.planRepo.editPlan(plan.id, {
             computation_only: false,
             type: data.type,
             longitudinal_profile_parameters: longitudinalProfileParameters,
             topographic_setting: topographicSetting,
         });
+
+        if (!plan) {
+            throw new NotFoundError('Plan not found');
+        }
+
+        // add coordinates
+        if (plan.forward_computation_data) {
+            const forwardComputationResult = this.forwardComputationUseCase.execute(plan.forward_computation_data);
+
+            const coordinates = [forwardComputationResult.start];
+            for (let i = 0; i < forwardComputationResult.computed_legs.length; i++) {
+                coordinates.push(forwardComputationResult.computed_legs[i].to);
+                coordinates.push(forwardComputationResult.computed_legs[i].from);
+            }
+
+            // depending on the type of plan
+            if (plan.type === PlanType.CADASTRAL || plan.type === PlanType.LAYOUT) {
+                // update coordinates
+                await this.editCoordinatesUseCase.execute({
+                    plan_id: plan.id,
+                    coordinates: coordinates,
+                });
+            }
+
+            if (plan.type === PlanType.TOPOGRAPHIC) {
+                // update topo boundaries
+                await this.editTopoBoundaryUseCase.execute({
+                    plan_id: plan.id,
+                    boundary: {
+                        coordinates: coordinates,
+                    },
+                });
+            }
+        }
+
+        if (plan.traverse_computation_data) {
+            const traverseComputationResult = this.traverseComputationUseCase.execute(plan.traverse_computation_data);
+
+            const coordinates = [];
+            for (let i = 0; i < traverseComputationResult.traverse_legs.length; i++) {
+                coordinates.push(traverseComputationResult.traverse_legs[i].to);
+                coordinates.push(traverseComputationResult.traverse_legs[i].from);
+            }
+
+            // depending on the type of plan
+            if (plan.type === PlanType.CADASTRAL || plan.type === PlanType.LAYOUT) {
+                // update coordinates
+                await this.editCoordinatesUseCase.execute({
+                    plan_id: plan.id,
+                    coordinates: coordinates,
+                });
+            }
+
+            if (plan.type === PlanType.TOPOGRAPHIC) {
+                // update topo boundaries
+                await this.editTopoBoundaryUseCase.execute({
+                    plan_id: plan.id,
+                    boundary: {
+                        coordinates: coordinates,
+                    },
+                });
+            }
+        }
+
+        if (plan.differential_leveling_data) {
+            const differentialLevelResult = this.differentialLevelingUseCase.execute(plan.differential_leveling_data);
+
+            const elevations = [];
+            for (let i = 0; i < differentialLevelResult.stations.length; i++) {
+                elevations.push({
+                    id: differentialLevelResult.stations[i].stn as string,
+                    chainage: differentialLevelResult.stations[i].chainage as string,
+                    elevation: differentialLevelResult.stations[i].reduced_level as number,
+                });
+            }
+
+            if (plan.type === PlanType.ROUTE) {
+                // update elevations
+                await this.editElevationUseCase.execute({
+                    plan_id: plan.id,
+                    elevations: elevations,
+                });
+            }
+        }
     }
 }
diff --git a/src/use-cases/plan/ImportComputation.ts b/src/use-cases/plan/ImportComputation.ts

Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,6 @@ export class SendLoginOTP {`
`49`	`49`
`50`	`50`	`// generate OTP`
`51`	`51`	const otp = await this.createOTP.execute({ identifier: user.id, type: `login_otp`, exp: 10 });
`52`		`- console.log(otp);`
`53`	`52`	`await this.sendOTP(user.email, 10, otp);`
`54`	`53`	`}`
`55`	`54`