main

Author: rajman01

src/adapters/controllers/PlanController.ts

@@ -19,6 +19,10 @@ import { EditElevation, EditElevationRequest } from '@use-cases/plan/EditElevati
 import { EditDifferentialLeveling, EditDifferentialLevelingRequest } from '@use-cases/plan/EditDifferentialLeveling';
 import { EditTopoBoundary, EditTopoBoundaryRequest } from '@use-cases/plan/EditTopoBoundary';
 import { EditTopoSetting, EditTopoSettingRequest } from '@use-cases/plan/EditTopoSetting';
+import {
+    EditLongitudinalProfileParameters,
+    EditLongitudinalProfileParametersRequest,
+} from '@use-cases/plan/EditLongitudinalProfileParameters';
 
 export class PlanController {
     constructor(
@@ -36,6 +40,7 @@ export class PlanController {
         private readonly editDifferentialLevelingUseCase: EditDifferentialLeveling,
         private readonly editTopoBoundaryUseCase: EditTopoBoundary,
         private readonly editTopoSettingUseCase: EditTopoSetting,
+        private readonly editLongitudinalProfileParametersUseCase: EditLongitudinalProfileParameters,
     ) {}
 
     async createPlan(
@@ -297,6 +302,7 @@ export class PlanController {
                         page_orientation: 1,
                         footers: 1,
                         footer_size: 1,
+                        dxf_version: 1,
                         created_at: 1,
                         updated_at: 1,
                     },
@@ -434,4 +440,38 @@ export class PlanController {
             return handleError(e);
         }
     }
+
+    async editLongitudinalProfileParameters(
+        req: HttpRequest<
+            EditLongitudinalProfileParametersRequest['params'],
+            { plan_id: string },
+            undefined,
+            undefined,
+            AuthenticateResponse
+        >,
+    ): Promise<HttpResponse<Plan | Error>> {
+        try {
+            const error = PlanValidator.validateEditLongitudinalProfileParameters(req.body);
+            if (error) {
+                return badRequest(error);
+            }
+
+            const plan = await this.editLongitudinalProfileParametersUseCase.execute({
+                plan_id: req.params!.plan_id,
+                params: req.body!,
+                options: {
+                    filter: { user: req.user!.id },
+                    projection: {
+                        longitudinal_profile_parameters: 1,
+                        created_at: 1,
+                        updated_at: 1,
+                    },
+                },
+            });
+
+            return success(plan);
+        } catch (e) {
+            return handleError(e);
+        }
+    }
 }

src/adapters/validators/PlanValidator.ts

@@ -103,6 +103,26 @@ export class PlanValidator {
         return null;
     }
 
+    static validateEditLongitudinalProfileParameters(data: any): Error | null {
+        const rules = {
+            horizontal_scale: 'numeric',
+            vertical_scale: 'numeric',
+            profile_origin: 'array',
+            'profile_origin.*': 'numeric',
+            station_interval: 'numeric',
+            elevation_interval: 'numeric',
+            starting_chainage: 'numeric',
+        };
+
+        try {
+            validator.validate(data, rules);
+        } catch (e) {
+            return new Error((e as Error).message);
+        }
+
+        return null;
+    }
+
     static validateEditParcels(data: any): Error | null {
         const rules = {
             parcels: 'required|array',
@@ -246,6 +266,7 @@ export class PlanValidator {
             footers: 'array',
             'footers.*': 'string',
             footer_size: 'numeric',
+            dxf_version: 'string',
         };
 
         try {

src/domain/entities/Plan.ts

@@ -63,6 +63,15 @@ export interface TopographicBoundary {
     legs?: TraverseLegProps[];
 }
 
+export interface LongitudinalProfileParameters {
+    horizontal_scale?: number;
+    vertical_scale?: number;
+    profile_origin?: number[];
+    station_interval?: number;
+    elevation_interval?: number;
+    starting_chainage?: number;
+}
+
 export interface PlanProps {
     id: string;
     created_at: Date;
@@ -110,6 +119,8 @@ export interface PlanProps {
     page_orientation?: PageOrientation;
     footers: string[];
     footer_size: number;
+    longitudinal_profile_parameters?: LongitudinalProfileParameters;
+    dxf_version?: string; // e.g., R12, R2000
 }
 
 export class Plan {
@@ -159,6 +170,8 @@ export class Plan {
     public readonly page_orientation?: PageOrientation;
     public readonly footers: string[];
     public readonly footer_size: number;
+    public readonly longitudinal_profile_parameters?: LongitudinalProfileParameters;
+    public readonly dxf_version?: string; // e.g., R12, R2000
 
     constructor(props: PlanProps) {
         this.id = props.id;
@@ -194,5 +207,7 @@ export class Plan {
         this.differential_leveling_data = props.differential_leveling_data;
         this.footers = props.footers;
         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
     }
 }

src/infrastructure/mongodb/models/Plan.ts

@@ -152,6 +152,20 @@ export const topographicSettingSchema = new Schema(
     },
 );
 
+export const longitudinalProfileParametersSchema = new Schema(
+    {
+        horizontal_scale: Number,
+        vertical_scale: Number,
+        profile_origin: [Number],
+        station_interval: Number,
+        elevation_interval: Number,
+        starting_chainage: Number,
+    },
+    {
+        _id: false,
+    },
+);
+
 const PlanSchema: Schema<PlanDocument> = new Schema<PlanDocument>(
     {
         user: {
@@ -276,6 +290,13 @@ const PlanSchema: Schema<PlanDocument> = new Schema<PlanDocument>(
             type: Number,
             default: 0.5,
         },
+        longitudinal_profile_parameters: {
+            type: longitudinalProfileParametersSchema,
+        },
+        dxf_version: {
+            type: String,
+            default: 'R2010',
+        },
         deleted: {
             type: Boolean,
             select: false,

src/main/config/container.ts

@@ -53,6 +53,7 @@ import { EditDifferentialLeveling } from '@use-cases/plan/EditDifferentialLeveli
 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';
 
 export class Container {
     private instances = new Map<string, any>();
@@ -287,6 +288,12 @@ export function setupContainer(): Container {
     container.register('DifferentialLevelingUseCase', () => {
         return new DifferentialLeveling(container.resolve<Logger>('Logger'));
     });
+    container.register('EditLongitudinalProfileParametersUseCase', () => {
+        return new EditLongitudinalProfileParameters(
+            container.resolve<Logger>('Logger'),
+            container.resolve<PlanRepositoryInterface>('PlanRepo'),
+        );
+    });
 
     // Register Controllers
     container.register('AuthController', () => {
@@ -348,6 +355,7 @@ export function setupContainer(): Container {
             container.resolve('EditDifferentialLevelingUseCase'),
             container.resolve('EditTopoBoundaryUseCase'),
             container.resolve('EditTopoSettingUseCase'),
+            container.resolve('EditLongitudinalProfileParametersUseCase'),
         );
     });
 

src/main/routes/plan-routes.ts

@@ -23,6 +23,10 @@ export default (logger: Logger, authController: AuthController, planController:
         expressRouteAdapter(planController.editTopoBoundary.bind(planController)),
     );
     router.put('/topo/setting/edit/:plan_id', expressRouteAdapter(planController.editTopoSetting.bind(planController)));
+    router.put(
+        '/route/longitudinal/params/edit/:plan_id',
+        expressRouteAdapter(planController.editLongitudinalProfileParameters.bind(planController)),
+    );
     router.delete('/delete/:plan_id', expressRouteAdapter(planController.deletePlan.bind(planController)));
     router.put(
         '/traverse-data/edit/:plan_id',

src/use-cases/auth/SendLoginOTP.ts

@@ -49,6 +49,7 @@ 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);
     }
 

src/use-cases/plan/CreatePlan.ts

@@ -66,6 +66,17 @@ export class CreatePlan {
             };
         }
 
+        if (planData.type === PlanType.ROUTE) {
+            planData.longitudinal_profile_parameters = {
+                horizontal_scale: 1.0,
+                vertical_scale: 10,
+                profile_origin: [0.0, 0.0],
+                station_interval: 10,
+                elevation_interval: 1.0,
+                starting_chainage: 0.0,
+            };
+        }
+
         // create plan
         return await this.planRepo.createPlan(planData);
     }

src/use-cases/plan/EditLongitudinalProfileParameters.ts

@@ -0,0 +1,43 @@
+import { LongitudinalProfileParameters, Plan, PlanType, TopographicSetting } from '@domain/entities/Plan';
+import { Logger, RepoOptions } from '@domain/types/Common';
+import { PlanRepositoryInterface } from '@domain/interfaces/repositories/PlanRepositoryInterface';
+import NotFoundError from '@domain/errors/NotFoundError';
+import BadRequestError from '@domain/errors/BadRequestError';
+
+export interface EditLongitudinalProfileParametersRequest {
+    plan_id: string;
+    params: LongitudinalProfileParameters;
+    options?: RepoOptions;
+}
+
+export class EditLongitudinalProfileParameters {
+    constructor(
+        private readonly logger: Logger,
+        private readonly planRepo: PlanRepositoryInterface,
+    ) {}
+
+    async execute(data: EditLongitudinalProfileParametersRequest): Promise<Plan> {
+        this.logger.info('EditLongitudinalProfileParameters', data);
+
+        const filter = data.options?.filter || {};
+        let plan = await this.planRepo.getPlanById(data.plan_id, { projection: { type: 1 }, filter });
+        if (!plan) {
+            throw new NotFoundError('Plan not found');
+        }
+
+        if (plan.type !== PlanType.ROUTE) {
+            throw new BadRequestError('Plan is not a route plan');
+        }
+
+        plan = await this.planRepo.editPlan(
+            data.plan_id,
+            { longitudinal_profile_parameters: data.params },
+            data.options,
+        );
+        if (!plan) {
+            throw new NotFoundError('Plan not found');
+        }
+
+        return plan;
+    }
+}