add ConvertComputation use case and update plan creation logic

Author: rajman01

src/adapters/controllers/PlanController.ts

@@ -23,6 +23,7 @@ import {
     EditLongitudinalProfileParameters,
     EditLongitudinalProfileParametersRequest,
 } from '@use-cases/plan/EditLongitudinalProfileParameters';
+import { ConvertComputation, ConvertComputationRequest } from '@use-cases/plan/ConvertComputation';
 
 export class PlanController {
     constructor(
@@ -41,6 +42,7 @@ export class PlanController {
         private readonly editTopoBoundaryUseCase: EditTopoBoundary,
         private readonly editTopoSettingUseCase: EditTopoSetting,
         private readonly editLongitudinalProfileParametersUseCase: EditLongitudinalProfileParameters,
+        private readonly convertComputationUseCase: ConvertComputation,
     ) {}
 
     async createPlan(
@@ -319,13 +321,18 @@ export class PlanController {
         req: HttpRequest<undefined, { project_id: string }, undefined, Record<string, string>, AuthenticateResponse>,
     ): Promise<HttpResponse<Plan[] | Error>> {
         try {
-            const repoOptions: RepoOptions = parseQuery(req.query!, ['type'], ['created_at', 'updated_at']);
+            const repoOptions: RepoOptions = parseQuery(
+                req.query!,
+                ['type', 'bool-computation_only'],
+                ['created_at', 'updated_at'],
+            );
             repoOptions.filter = repoOptions.filter ?? {};
             repoOptions.filter['user'] = req.user!.id;
             repoOptions.projection = {
                 id: 1,
                 name: 1,
                 type: 1,
+                computation_only: 1,
                 created_at: 1,
                 updated_at: 1,
             };
@@ -474,4 +481,27 @@ export class PlanController {
             return handleError(e);
         }
     }
+
+    async convertComputation(
+        req: HttpRequest<ConvertComputationRequest, { plan_id: string }, undefined, undefined, AuthenticateResponse>,
+    ): Promise<HttpResponse<void | Error>> {
+        try {
+            const error = PlanValidator.validateConvertComputation(req.body);
+            if (error) {
+                return badRequest(error);
+            }
+
+            await this.convertComputationUseCase.execute({
+                ...req.body!,
+                plan_id: req.params!.plan_id,
+                options: {
+                    filter: { user: req.user!.id },
+                },
+            });
+
+            return noContent();
+        } catch (e) {
+            return handleError(e);
+        }
+    }
 }

src/adapters/validators/PlanValidator.ts

@@ -6,7 +6,9 @@ export class PlanValidator {
         const rules = {
             project: 'required|string',
             name: 'required|string',
-            type: `required|in:${Object.values(PlanType)}`,
+            computation_only: `required|boolean`,
+            // type: `required_if:computation_only,false|in:${Object.values(PlanType)}`,
+            type: [{ required_if: ['computation_only', false] }],
         };
 
         try {
@@ -277,4 +279,18 @@ export class PlanValidator {
 
         return null;
     }
+
+    static validateConvertComputation(data: any): Error | null {
+        const rules = {
+            type: `required|in:${Object.values(PlanType)}`,
+        };
+
+        try {
+            validator.validate(data, rules);
+        } catch (e) {
+            return new Error((e as Error).message);
+        }
+
+        return null;
+    }
 }

src/domain/entities/Plan.ts

@@ -121,6 +121,7 @@ export interface PlanProps {
     footer_size: number;
     longitudinal_profile_parameters?: LongitudinalProfileParameters;
     dxf_version?: string; // e.g., R12, R2000
+    computation_only: boolean;
 }
 
 export class Plan {
@@ -172,6 +173,7 @@ export class Plan {
     public readonly footer_size: number;
     public readonly longitudinal_profile_parameters?: LongitudinalProfileParameters;
     public readonly dxf_version?: string; // e.g., R12, R2000
+    public readonly computation_only: boolean;
 
     constructor(props: PlanProps) {
         this.id = props.id;
@@ -209,5 +211,6 @@ export class Plan {
         this.footer_size = props.footer_size; // Default to 0.5 if not provided
         this.longitudinal_profile_parameters = props.longitudinal_profile_parameters;
         this.dxf_version = props.dxf_version; // Default to R12 if not provided
+        this.computation_only = props.computation_only;
     }
 }

src/infrastructure/mongodb/models/Plan.ts

@@ -185,7 +185,7 @@ const PlanSchema: Schema<PlanDocument> = new Schema<PlanDocument>(
         type: {
             type: String,
             enum: Object.values(PlanType),
-            default: PlanType.CADASTRAL,
+            // default: PlanType.CADASTRAL,
         },
         font: {
             type: String,
@@ -297,6 +297,10 @@ const PlanSchema: Schema<PlanDocument> = new Schema<PlanDocument>(
             type: String,
             default: 'R2000',
         },
+        computation_only: {
+            type: Boolean,
+            default: false,
+        },
         deleted: {
             type: Boolean,
             select: false,

src/main/config/container.ts

@@ -54,6 +54,7 @@ import { EditTopoBoundary } from '@use-cases/plan/EditTopoBoundary';
 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';
 
 export class Container {
     private instances = new Map<string, any>();
@@ -294,6 +295,12 @@ export function setupContainer(): Container {
             container.resolve<PlanRepositoryInterface>('PlanRepo'),
         );
     });
+    container.register('ConvertComputationUseCase', () => {
+        return new ConvertComputation(
+            container.resolve<Logger>('Logger'),
+            container.resolve<PlanRepositoryInterface>('PlanRepo'),
+        );
+    });
 
     // Register Controllers
     container.register('AuthController', () => {
@@ -356,6 +363,7 @@ export function setupContainer(): Container {
             container.resolve('EditTopoBoundaryUseCase'),
             container.resolve('EditTopoSettingUseCase'),
             container.resolve('EditLongitudinalProfileParametersUseCase'),
+            container.resolve('ConvertComputationUseCase'),
         );
     });
 

src/main/routes/plan-routes.ts

@@ -42,5 +42,10 @@ export default (logger: Logger, authController: AuthController, planController:
     );
     router.get('/generate/:plan_id', expressRouteAdapter(planController.generatePlan.bind(planController)));
 
+    router.put(
+        '/computation/convert/:plan_id',
+        expressRouteAdapter(planController.convertComputation.bind(planController)),
+    );
+
     return router;
 };

src/use-cases/plan/ConvertComputation.ts

@@ -0,0 +1,71 @@
+import { Logger, RepoOptions } from '@domain/types/Common';
+import { LongitudinalProfileParameters, PlanType, TopographicSetting } from '@domain/entities/Plan';
+import { PlanRepositoryInterface } from '@domain/interfaces/repositories/PlanRepositoryInterface';
+import NotFoundError from '@domain/errors/NotFoundError';
+import BadRequestError from '@domain/errors/BadRequestError';
+
+export interface ConvertComputationRequest {
+    plan_id: string;
+    type: PlanType;
+    options?: RepoOptions;
+}
+
+export class ConvertComputation {
+    constructor(
+        private readonly logger: Logger,
+        private readonly planRepo: PlanRepositoryInterface,
+    ) {}
+
+    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);
+        if (!plan) {
+            throw new NotFoundError('Plan not found');
+        }
+
+        let topographicSetting: TopographicSetting | undefined = undefined;
+        let longitudinalProfileParameters: LongitudinalProfileParameters | undefined = undefined;
+
+        if (data.type === PlanType.TOPOGRAPHIC) {
+            topographicSetting = {
+                show_spot_heights: true,
+                point_label_scale: 0.2,
+                show_contours: true,
+                contour_interval: 0.1,
+                major_contour: 0.5,
+                minimum_distance: 0.1,
+                show_contours_labels: true,
+                contour_label_scale: 0.5,
+                show_boundary: true,
+                boundary_label_scale: 0.2,
+                tin: false,
+                grid: true,
+                show_mesh: false,
+            };
+        }
+
+        if (data.type === PlanType.ROUTE) {
+            longitudinalProfileParameters = {
+                horizontal_scale: 1.0,
+                vertical_scale: 10,
+                profile_origin: [0.0, 0.0],
+                station_interval: 10,
+                elevation_interval: 1.0,
+                starting_chainage: 0.0,
+            };
+        }
+
+        if (!plan.computation_only) {
+            throw new BadRequestError('Only Computations can be converted to a plan');
+        }
+
+        await this.planRepo.editPlan(plan.id, {
+            computation_only: false,
+            type: data.type,
+            longitudinal_profile_parameters: longitudinalProfileParameters,
+            topographic_setting: topographicSetting,
+        });
+    }
+}

src/use-cases/plan/CreatePlan.ts

@@ -5,7 +5,7 @@ import { PlanRepositoryInterface } from '@domain/interfaces/repositories/PlanRep
 import NotFoundError from '@domain/errors/NotFoundError';
 
 export interface CreatePlanRequest {
-    plan: Pick<PlanProps, 'name' | 'type' | 'project'>;
+    plan: Pick<PlanProps, 'name' | 'type' | 'project' | 'computation_only'>;
     options?: RepoOptions;
 }
 
@@ -17,7 +17,7 @@ export class CreatePlan {
     ) {}
 
     async execute(data: CreatePlanRequest): Promise<Plan> {
-        this.logger.debug('Create Project execute');
+        this.logger.debug('Create Plan execute');
 
         // get project
         const project = await this.projectRepo.getProjectById(data.plan.project as string, data.options);
@@ -46,6 +46,7 @@ export class CreatePlan {
             title: 'Untitled Plan',
             footers: [],
             footer_size: 0.5,
+            computation_only: data.plan.computation_only,
         };
 
         if (planData.type === PlanType.TOPOGRAPHIC) {