Feat/marxan 1471 allow cloning published projects

api/apps/api/src/modules/clone/export/domain/export/export.ts

@@ -132,4 +132,8 @@ export class Export extends AggregateRoot {
   #allPiecesReady = () => this.pieces.every((piece) => piece.isReady());
 
   isCloning = () => Boolean(this.importResourceId);
+
+  isForProject() {
+    return this.resourceKind === ResourceKind.Project;
+  }
 }

api/apps/api/src/modules/clone/import/domain/import/import.id.ts

@@ -7,4 +7,8 @@ export class ImportId {
   static create(): ImportId {
     return new ImportId(v4());
   }
+
+  toString() {
+    return this.value;
+  }
 }

api/apps/api/src/modules/projects/dto/export.project.dto.ts

@@ -50,3 +50,17 @@ export class RequestProjectCloneResponseDto {
   })
   projectId!: string;
 }
+
+export class RequestPublishedProjectCloneResponseDto {
+  @ApiProperty({
+    description: 'ID of the import',
+    example: '6fbec34e-04a7-4131-be14-c245f2435a6c',
+  })
+  importId!: string;
+
+  @ApiProperty({
+    description: 'ID of the new project',
+    example: '6fbec34e-04a7-4131-be14-c245f2435a6c',
+  })
+  projectId!: string;
+}

api/apps/api/src/modules/projects/projects.controller.ts

@@ -97,21 +97,16 @@ import {
 } from '@marxan-api/decorators/acl.decorator';
 import { locationNotFound } from '@marxan-api/modules/clone/export/application/get-archive.query';
 import {
-  RequestProjectExportResponseDto,
-  RequestProjectExportBodyDto,
   GetLatestExportResponseDto,
   RequestProjectCloneResponseDto,
+  RequestProjectExportBodyDto,
+  RequestProjectExportResponseDto,
 } from './dto/export.project.dto';
 import { ScenarioLockResultPlural } from '@marxan-api/modules/access-control/scenarios-acl/locks/dto/scenario.lock.dto';
 import { RequestProjectImportResponseDto } from './dto/import.project.response.dto';
-import {
-  unknownError as fileRepositoryUnknownError,
-  fileNotFound,
-} from '@marxan/cloning-files-repository';
 import { ProxyService } from '@marxan-api/modules/proxy/proxy.service';
 import { TilesOpenApi } from '@marxan/tiles';
 import { mapAclDomainToHttpError } from '@marxan-api/utils/acl.utils';
-import { scenarioResource } from '@marxan-api/modules/scenarios/scenario.api.entity';
 import { invalidExportZipFile } from '../clone/infra/import/generate-export-from-zip-file.command';
 
 @UseGuards(JwtAuthGuard)

api/apps/api/src/modules/projects/projects.module.ts

@@ -94,6 +94,6 @@ import { TypeormExportRepository } from '../clone/export/adapters/typeorm-export
     ProjectsController,
   ],
   // @ToDo Remove TypeOrmModule after project publish will stop use the ProjectRepository
-  exports: [ProjectsCrudService, TypeOrmModule],
+  exports: [ProjectsCrudService, TypeOrmModule, ProjectsService],
 })
 export class ProjectsModule {}

api/apps/api/src/modules/projects/projects.service.ts

@@ -55,7 +55,6 @@ import {
   GenerateExportFromZipFile,
   GenerateExportFromZipFileError,
 } from '../clone/infra/import/generate-export-from-zip-file.command';
-import { unknownError } from '@marxan/cloning-files-repository';
 import {
   ImportProject,
   ImportProjectCommandResult,
@@ -77,6 +76,14 @@ export const notFound = Symbol(`project not found`);
 export const exportNotFound = Symbol(`project export not found`);
 export const apiEventDataNotFound = Symbol(`missing data in api event`);
 
+// Check where to centralize this symbols
+export const exportResourceKindIsNotProject = Symbol(
+  `export is not for a project`,
+);
+export const exportIsNotStandalone = Symbol(`export is not standalone`);
+export const projectIsNotPublished = Symbol(`project is not published`);
+export const projectNotFoundForExport = Symbol(`project not found`);
+
 @Injectable()
 export class ProjectsService {
   constructor(
@@ -328,6 +335,14 @@ export class ProjectsService {
     return right(void 0);
   }
 
+  async find(projectId: string): Promise<Project | undefined> {
+    try {
+      return this.projectsCrud.getById(projectId);
+    } catch {
+      return undefined;
+    }
+  }
+
   async updateBlmValues(
     projectId: string,
     userId: string,
@@ -381,6 +396,23 @@ export class ProjectsService {
     return right(res);
   }
 
+  async clone(
+    exportId: ExportId,
+    userId: UserId,
+  ): Promise<Either<any, ImportProjectCommandResult>> {
+    const exportInstance = await this.exportRepository.find(exportId);
+    if (!exportInstance) return left(exportNotFound);
+    if (!exportInstance.isForProject())
+      return left(exportResourceKindIsNotProject);
+    if (exportInstance.importResourceId) return left(exportIsNotStandalone);
+
+    const project = await this.find(exportInstance.resourceId.value);
+    if (!project) return left(projectNotFoundForExport);
+    if (!project.isPublic) return left(projectIsNotPublished);
+
+    return this.commandBus.execute(new ImportProject(exportId, userId));
+  }
+
   async remove(
     projectId: string,
     userId: string,

api/apps/api/src/modules/published-project/controllers/publish-project.controller.ts

@@ -19,11 +19,11 @@ import {
 import {
   accessDenied,
   alreadyPublished,
-  sameUnderModerationStatus,
   internalError,
   notFound,
-  PublishedProjectService,
   notPublished,
+  PublishedProjectService,
+  sameUnderModerationStatus,
   underModerationError,
 } from '../published-project.service';
 import { JwtAuthGuard } from '@marxan-api/guards/jwt-auth.guard';
@@ -55,6 +55,11 @@ import {
 } from 'nestjs-base-service';
 import { PublishedProjectSerializer } from '../published-project.serializer';
 import { PublishProjectDto } from '../dto/publish-project.dto';
+import { RequestPublishedProjectCloneResponseDto } from '@marxan-api/modules/projects/dto/export.project.dto';
+import { ProjectsService } from '@marxan-api/modules/projects/projects.service';
+import { ExportId } from '@marxan-api/modules/clone';
+import { UserId } from '@marxan/domain-ids';
+import { mapAclDomainToHttpError } from '@marxan-api/utils/acl.utils';
 
 @IsMissingAclImplementation()
 @UseGuards(JwtAuthGuard)
@@ -65,6 +70,7 @@ export class PublishProjectController {
   constructor(
     private readonly publishedProjectService: PublishedProjectService,
     private readonly serializer: PublishedProjectSerializer,
+    private readonly projectsService: ProjectsService,
   ) {}
 
   @Post(':id/publish')
@@ -278,4 +284,34 @@ export class PublishProjectController {
 
     return await this.serializer.serialize(result.right);
   }
+
+  @ApiNotFoundResponse()
+  @ApiOperation({
+    description:
+      'Clones a public project and makes the user the owner of the new project.',
+  })
+  @ApiOkResponse({ type: RequestPublishedProjectCloneResponseDto })
+  @Post('published-projects/:exportId/clone')
+  async clone(
+    @Req() req: RequestWithAuthenticatedUser,
+    @Param('exportId') exportId: string,
+  ): Promise<RequestPublishedProjectCloneResponseDto> {
+    const cloneResult = await this.projectsService.clone(
+      new ExportId(exportId),
+      new UserId(req.user.id),
+    );
+
+    if (isLeft(cloneResult)) {
+      throw mapAclDomainToHttpError(cloneResult.left, {
+        userId: req.user.id,
+        resourceType: projectResource.name.plural,
+        exportId,
+      });
+    }
+
+    return {
+      importId: cloneResult.right.importId,
+      projectId: cloneResult.right.projectId,
+    };
+  }
 }

api/apps/api/src/utils/acl.utils.ts

@@ -58,14 +58,22 @@ import {
   unknownPngWebshotError,
 } from '@marxan/webshot';
 import { notFound as notFoundSpec } from '@marxan-api/modules/scenario-specification/application/last-updated-specification.query';
-import { projectIsMissingInfoForRegularPus } from '@marxan-api/modules/projects/projects.service';
+import {
+  exportIsNotStandalone,
+  exportNotFound,
+  exportResourceKindIsNotProject,
+  projectIsMissingInfoForRegularPus,
+  projectIsNotPublished,
+  projectNotFoundForExport,
+} from '@marxan-api/modules/projects/projects.service';
 
 interface ErrorHandlerOptions {
   projectId?: string;
   range?: [number, number];
   resourceType?: string;
   scenarioId?: string;
   userId?: string;
+  exportId?: string;
 }
 
 export const mapAclDomainToHttpError = (
@@ -105,7 +113,12 @@ export const mapAclDomainToHttpError = (
     | typeof bestSolutionNotFound
     | typeof unknownPdfWebshotError
     | typeof unknownPngWebshotError
-    | typeof unknownError,
+    | typeof unknownError
+    | typeof exportNotFound
+    | typeof exportResourceKindIsNotProject
+    | typeof exportIsNotStandalone
+    | typeof projectNotFoundForExport
+    | typeof projectIsNotPublished,
   options?: ErrorHandlerOptions,
 ) => {
   switch (errorToCheck) {
@@ -213,6 +226,27 @@ export const mapAclDomainToHttpError = (
       return new NotFoundException(
         `Could not find spec for scenario with ID: ${options?.scenarioId}.`,
       );
+
+    case exportNotFound:
+      return new NotFoundException(
+        `Could not find export with ID: ${options?.exportId}`,
+      );
+    case exportResourceKindIsNotProject:
+      return new BadRequestException(
+        `Export with ID ${options?.exportId} is not a project export`,
+      );
+    case exportIsNotStandalone:
+      return new BadRequestException(
+        `Export with ID ${options?.exportId} is not a standalone export`,
+      );
+    case projectNotFoundForExport:
+      return new NotFoundException(
+        `Project not found for export with ID ${options?.exportId}`,
+      );
+    case projectIsNotPublished:
+      return new ForbiddenException(
+        `Trying to clone project export with ID ${options?.exportId} which is not a published project`,
+      );
     default:
       const _exhaustiveCheck: never = errorToCheck;
       return _exhaustiveCheck;

api/apps/api/test/project/import-project.e2e-spec.ts

@@ -185,7 +185,7 @@ export const getFixtures = async () => {
           }, 6000);
         },
       );
-      expect(res!.data?.importId).toEqual(importId.value);
+      expect(res.data?.importId).toEqual(importId.value);
     },
   };
 };