progress

server/src/features/projects/create_new_project_scenario.ts

@@ -0,0 +1,33 @@
+import { App } from "../../core/controllers/app";
+import { Result } from "../../core/helper/result";
+import { CreateDataBaseModelUseCase } from "../../core/usecases/create_database_model_usecase";
+import { CreateFolderUseCase } from "../../core/usecases/crete_folder_usecase";
+import { ProjectDBModel, ProjectValidationModel } from "./projects_model";
+import { v4 as uuidv4 } from "uuid";
+
+export class CreateNewProjectScenario {
+  call = async (model: ProjectValidationModel): Promise<Result<Error, any>> => {
+    try {
+      const folderName = uuidv4() + "/";
+      const createFolderUseCase = await new CreateFolderUseCase().call(
+        App.staticFilesStoreDir() + folderName
+      );
+      if (createFolderUseCase.isFailure()) {
+        return createFolderUseCase.forward();
+      }
+
+      model.rootDir = folderName;
+      const createDataBaseModelUseCase = await new CreateDataBaseModelUseCase(
+        ProjectDBModel
+      ).call(model);
+
+      if (createDataBaseModelUseCase.isFailure()) {
+        return createDataBaseModelUseCase.forward();
+      }
+
+      return Result.ok({ status: "ok" });
+    } catch (error) {
+      return Result.error(error as Error);
+    }
+  };
+}

server/src/features/projects/projects_model.ts

@@ -1,8 +1,9 @@
 import { Schema, model } from "mongoose";
 import { PipelineModel, schemaPipeline } from "../pipelines/pipeline_model";
-import { IsMongoId, IsString } from "class-validator";
+import { IsArray, IsOptional, IsString } from "class-validator";
 
 export interface IProjectModel {
+  _id: string;
   pipelines: [PipelineModel];
   rootDir: string;
   description: string;
@@ -27,13 +28,11 @@ const schema = "Projects";
 
 export const ProjectDBModel = model<IProjectModel>(schema, ProjectSchema);
 
-export class ProjectModel implements IProjectModel {
-  @IsMongoId()
-  public pipelines: [PipelineModel];
-
-  @IsString()
-  public rootDir: string;
-
+export class ProjectValidationModel {
+  @IsArray()
+  public pipelines: [string];
   @IsString()
   public description: string;
+  @IsOptional()
+  public rootDir: string;
 }

server/src/features/projects/projects_presentation.ts

@@ -1,16 +1,17 @@
-// import { TriggerDBModel, TriggerModel } from "./trigger_model";
 import { CrudController } from "../../core/controllers/crud_controller";
-import { ProjectDBModel, ProjectModel } from "./projects_model";
+import { CreateNewProjectScenario } from "./create_new_project_scenario";
+import { ProjectDBModel, ProjectValidationModel } from "./projects_model";
 
 export class ProjectsPresentation extends CrudController<
-  ProjectModel,
+  ProjectValidationModel,
   typeof ProjectDBModel
 > {
   constructor() {
     super({
       url: "project",
-      validationModel: ProjectModel,
+      validationModel: ProjectValidationModel,
       databaseModel: ProjectDBModel,
     });
+    super.post(new CreateNewProjectScenario().call);
   }
 }

server/src/features/realtime/realtime_presentation.ts

@@ -1,29 +1,24 @@
+import { IsString } from "class-validator";
 import { CoreHttpController } from "../../core/controllers/http_controller";
-import { Result } from "../../core/helper/result";
-import { IPipelineMeta } from "../../core/model/pipiline_meta";
-import {
-  PipelineRealTimeService,
-} from "../../core/services/pipeline_real_time_service";
+import { PipelineRealTimeService } from "../../core/services/pipeline_real_time_service";
+import { RunInstancePipelineUseCase } from "./usecases/run_instance_pipeline_usecase";
+import { PipelineStatusUseCase } from "./usecases/pipeline_status_usecase";
 
 export const pipelineRealTimeService = new PipelineRealTimeService();
 
-class PipelineStatusUseCase {
-  async call(): Promise<Result<Error, IPipelineMeta>> {
-    try {
-      return Result.ok(pipelineRealTimeService.status);
-    } catch (error) {
-      return Result.error(error as Error);
-    }
-  }
+export class RealTimeValidationModel {
+  @IsString()
+  public id: string;
 }
 
-export class RealTimePresentation extends CoreHttpController<void> {
+export class RealTimePresentation extends CoreHttpController<RealTimeValidationModel> {
   constructor() {
     super({
-      validationModel: null,
+      validationModel: RealTimeValidationModel,
       url: "realtime",
       databaseModel: null,
     });
+    super.post(new RunInstancePipelineUseCase().call);
     super.get(new PipelineStatusUseCase().call);
   }
 }

server/src/features/realtime/usecases/pipeline_status_usecase.ts

@@ -0,0 +1,13 @@
+import { Result } from "../../../core/helper/result";
+import { IPipelineMeta } from "../../../core/model/pipeline_meta";
+import { pipelineRealTimeService } from "../realtime_presentation";
+
+export class PipelineStatusUseCase {
+  async call(): Promise<Result<Error, IPipelineMeta>> {
+    try {
+      return Result.ok(pipelineRealTimeService.status);
+    } catch (error) {
+      return Result.error(error as Error);
+    }
+  }
+}

server/src/features/realtime/usecases/run_instance_pipeline_usecase.ts

@@ -0,0 +1,30 @@
+import { Result } from "../../../core/helper/result";
+import { ReadByIdDataBaseModelUseCase } from "../../../core/usecases/read_by_id_database_model_usecase";
+import { IProjectModel, ProjectDBModel } from "../../projects/projects_model";
+import {
+  RealTimeValidationModel,
+  pipelineRealTimeService,
+} from "../realtime_presentation";
+
+export class RunInstancePipelineUseCase {
+  async call(model: RealTimeValidationModel): Promise<Result<Error, any>> {
+    const id = model.id;
+    const readByIdDataBaseModelUseCase =
+      await new ReadByIdDataBaseModelUseCase<IProjectModel>(
+        ProjectDBModel
+      ).call(id);
+    if (readByIdDataBaseModelUseCase.isFailure()) {
+      return readByIdDataBaseModelUseCase.forward();
+    }
+
+    const projectModel = readByIdDataBaseModelUseCase.value;
+
+    pipelineRealTimeService.runPipeline(
+      projectModel.pipelines,
+      projectModel.rootDir,
+      projectModel._id
+    );
+    
+    return Result.ok({ status: "ok" });
+  }
+}