MARXAN-1274-publicMap-screenshot

api/apps/api/src/migrations/api/1650619314086-AddLocationPngDataPublicProject.ts

@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddLocationsPngDataPublicProject1650619314086
+  implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE published_projects
+        ADD COLUMN location varchar,
+        ADD COLUMN png_data text;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+        ALTER TABLE published_projects
+            DROP COLUMN location,
+            DROP COLUMN png_data;
+    `);
+  }
+}

api/apps/api/src/modules/published-project/dto/create-published-project.dto.ts

@@ -17,7 +17,9 @@ export interface CreatePublishedProjectDto {
   id: string;
   name?: string;
   description?: string;
+  location?: string;
   creators?: Creator[];
   resources?: Resource[];
   company?: Company;
+  pngData?: string;
 }

api/apps/api/src/modules/published-project/dto/publish-project.dto.ts

@@ -1,5 +1,7 @@
+import { WebshotConfig } from '@marxan/webshot';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsOptional, IsString } from 'class-validator';
+import { Type } from 'class-transformer';
+import { IsOptional, IsString, ValidateNested } from 'class-validator';
 import { Company, Creator, Resource } from './create-published-project.dto';
 
 export class PublishProjectDto {
@@ -13,6 +15,10 @@ export class PublishProjectDto {
   @ApiPropertyOptional()
   description?: string;
 
+  @IsOptional()
+  @ApiPropertyOptional()
+  location?: string;
+
   @IsOptional()
   @ApiPropertyOptional()
   creators?: Creator[];
@@ -27,5 +33,10 @@ export class PublishProjectDto {
 
   @IsOptional()
   @ApiPropertyOptional()
-  scenarioId?: string;
+  featuredScenarioId?: string;
+
+  @ApiProperty()
+  @ValidateNested({ each: true })
+  @Type(() => WebshotConfig)
+  config?: WebshotConfig;
 }

api/apps/api/src/modules/published-project/entities/published-project.api.entity.ts

@@ -17,6 +17,9 @@ export class PublishedProject {
   @Column('character varying')
   description?: string;
 
+  @Column('character varying')
+  location?: string;
+
   @Column('boolean', { name: 'under_moderation', default: false })
   underModeration?: boolean;
 
@@ -29,6 +32,9 @@ export class PublishedProject {
   @Column('jsonb')
   creators?: Creator[];
 
+  @Column('character varying', { name: 'png_data' })
+  pngData?: string;
+
   @OneToOne(() => Project)
   @JoinColumn({ name: 'id' })
   originalProject?: Project;

api/apps/api/src/modules/published-project/published-project-crud.service.ts

@@ -41,11 +41,13 @@ export class PublishedProjectCrudService extends AppBaseService<
       attributes: [
         'name',
         'description',
+        'location',
         'creators',
         'company',
         'resources',
         'underModeration',
         'originalProject',
+        'pngData',
       ],
       keyForAttribute: 'camelCase',
       originalProject: {

api/apps/api/src/modules/published-project/published-project.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { PublishedProjectService } from './published-project.service';
 import { ProjectsModule } from '@marxan-api/modules/projects/projects.module';
 import { PublishedProjectCrudService } from '@marxan-api/modules/published-project/published-project-crud.service';
@@ -9,13 +9,15 @@ import { PublishProjectController } from '@marxan-api/modules/published-project/
 import { PublishedProjectSerializer } from '@marxan-api/modules/published-project/published-project.serializer';
 import { AccessControlModule } from '@marxan-api/modules/access-control';
 import { UsersModule } from '@marxan-api/modules/users/users.module';
+import { WebshotModule } from '@marxan/webshot';
 
 @Module({
   imports: [
     AccessControlModule,
     ProjectsModule,
     TypeOrmModule.forFeature([PublishedProject]),
     UsersModule,
+    forwardRef(() => WebshotModule),
   ],
   controllers: [PublishProjectController, PublishedProjectReadController],
   providers: [

api/apps/api/src/modules/published-project/published-project.service.ts

@@ -10,6 +10,10 @@ import { PublishedProject } from '@marxan-api/modules/published-project/entities
 import { ProjectAccessControl } from '@marxan-api/modules/access-control';
 import { UsersService } from '@marxan-api/modules/users/users.service';
 import { PublishProjectDto } from './dto/publish-project.dto';
+import { WebshotService } from '@marxan/webshot';
+import { AppConfig } from '@marxan-api/utils/config.utils';
+import { assertDefined } from '@marxan/utils';
+import { isLeft, isRight } from 'fp-ts/lib/Either';
 
 export const notFound = Symbol(`project not found`);
 export const accessDenied = Symbol(`not allowed`);
@@ -33,6 +37,7 @@ export class PublishedProjectService {
     @InjectRepository(PublishedProject)
     private publicProjectsRepo: Repository<PublishedProject>,
     private crudService: PublishedProjectCrudService,
+    private webshotService: WebshotService,
     private readonly acl: ProjectAccessControl,
     private readonly usersService: UsersService,
   ) {}
@@ -59,13 +64,47 @@ export class PublishedProjectService {
       return left(alreadyPublished);
     }
 
-    // @debt scenarioId will be used in the png_map_data generation.
-    const { scenarioId, ...projectWithoutScenario } = projectToPublish;
+    // @debt If we end up moving the scenario map thumbnail generation
+    // to the end of the Marxan run process, this part here regarding
+    // the webshot should be removed and/or adapted to it. It looks
+    // like it does not belong here at all anyways, but right now there
+    // is not a better place to deal with this.
+
+    const webshotUrl = AppConfig.get('webshot.url') as string;
+
+    const {
+      featuredScenarioId,
+      config,
+      ...projectWithoutScenario
+    } = projectToPublish;
+
+    assertDefined(featuredScenarioId);
+    assertDefined(config);
+
+    const pngData = await this.webshotService.getPublishedProjectsImage(
+      featuredScenarioId,
+      id,
+      {
+        ...config,
+        screenshotOptions: {
+          clip: { x: 0, y: 0, width: 500, height: 500 },
+        },
+      },
+      webshotUrl,
+    );
+
+    if (isLeft(pngData)) {
+      console.info(
+        `Map screenshot for public project ${id} could not be generated`,
+      );
+    }
 
     await this.crudService.create({
       id,
       ...projectWithoutScenario,
+      pngData: isRight(pngData) ? pngData.right : '',
     });
+
     return right(true);
   }
 

api/apps/api/test/fixtures/test-data.sql

@@ -41,15 +41,6 @@ VALUES
 ('Example scenario 1 Project 2 Org 2', (select id from projects where name = 'Example Project 2 Org 2'), 'marxan', 30, 100, 1, (SELECT id FROM users WHERE email = '[email protected]') ),
 ('Example scenario 2 Project 2 Org 2', (select id from projects where name = 'Example Project 2 Org 2'), 'marxan', 50, 100, 1, (SELECT id FROM users WHERE email = '[email protected]') );
 
-INSERT INTO users_scenarios
-(user_id, scenario_id, role_id)
-VALUES
-((SELECT id FROM users WHERE lower(email) = '[email protected]'), (SELECT id FROM scenarios WHERE name = 'Example scenario 1 Project 2 Org 2'), 'scenario_owner'),
-((SELECT id FROM users WHERE lower(email) = '[email protected]'), (SELECT id FROM scenarios WHERE name = 'Example scenario 1 Project 2 Org 2'), 'scenario_contributor'),
-((SELECT id FROM users WHERE lower(email) = '[email protected]'), (SELECT id FROM scenarios WHERE name = 'Example scenario 1 Project 2 Org 2'), 'scenario_viewer'),
-((SELECT id FROM users WHERE lower(email) = '[email protected]'), (SELECT id FROM scenarios WHERE name = 'Example scenario 2 Project 2 Org 2'), 'scenario_owner'),
-((SELECT id FROM users WHERE lower(email) = '[email protected]'), (SELECT id FROM scenarios WHERE name = 'Example scenario 2 Project 2 Org 2'), 'scenario_contributor'),
-((SELECT id FROM users WHERE lower(email) = '[email protected]'), (SELECT id FROM scenarios WHERE name = 'Example scenario 2 Project 2 Org 2'), 'scenario_viewer');
 
 INSERT INTO platform_admins
 (user_id)

api/apps/api/test/project/projects.fixtures.ts

@@ -23,6 +23,8 @@ import { GivenProjectExists } from '../steps/given-project';
 import { GivenUserIsLoggedIn } from '../steps/given-user-is-logged-in';
 import { bootstrapApplication } from '../utils/api-application';
 import { EventBusTestUtils } from '../utils/event-bus.test.utils';
+import { ScenariosTestUtils } from '../utils/scenarios.test.utils';
+import { ScenarioType } from '@marxan-api/modules/scenarios/scenario.api.entity';
 
 export const getFixtures = async () => {
   const app = await bootstrapApplication([CqrsModule], [EventBusTestUtils]);
@@ -83,6 +85,19 @@ export const getFixtures = async () => {
       cleanups.push(cleanup);
       return projectId;
     },
+    GivenScenarioWasCreated: async (projectId: string) => {
+      const result = await ScenariosTestUtils.createScenario(
+        app,
+        randomUserToken,
+        {
+          name: `Test scenario`,
+          type: ScenarioType.marxan,
+          projectId,
+        },
+      );
+
+      return result.data.id;
+    },
     GivenPublicProjectWasCreated: async () => {
       const { projectId, cleanup } = await GivenProjectExists(
         app,
@@ -179,6 +194,8 @@ export const getFixtures = async () => {
             company: null,
             resources: null,
             creators: null,
+            location: null,
+            pngData: null,
           },
           id: publicProjectId,
           type: 'published_projects',
@@ -207,6 +224,8 @@ export const getFixtures = async () => {
               },
             ],
             resources: [{ title: expect.any(String), url: expect.any(String) }],
+            location: expect.any(String),
+            pngData: expect.any(String),
           },
           id: publicProjectId,
           type: 'published_projects',
@@ -224,6 +243,7 @@ export const getFixtures = async () => {
             name: expect.any(String),
             underModeration: true,
             description: expect.any(String),
+            location: expect.any(String),
             company: {
               name: expect.any(String),
               logoDataUrl: expect.any(String),
@@ -235,6 +255,7 @@ export const getFixtures = async () => {
               },
             ],
             resources: [{ title: expect.any(String), url: expect.any(String) }],
+            pngData: expect.any(String),
           },
           id: publicProjectId,
           type: 'published_projects',
@@ -253,15 +274,18 @@ export const getFixtures = async () => {
       await request(app.getHttpServer())
         .get(`/api/v1/projects/${projectId}`)
         .set('Authorization', `Bearer ${notIncludedUserToken}`),
-    WhenPublishingAProject: async (projectId: string) =>
+    WhenPublishingAProject: async (projectId: string, scenarioId: string) =>
       await request(app.getHttpServer())
         .post(`/api/v1/projects/${projectId}/publish`)
         .send({
           name: 'example project',
           description: 'fake description',
+          location: 'fake location',
           company: { name: 'logo', logoDataUrl: blmImageMock },
           creators: [{ displayName: 'fake name', avatarDataUrl: blmImageMock }],
           resources: [{ title: 'fake url', url: 'http://www.example.com' }],
+          config: { baseUrl: 'example/png', cookie: 'randomCookie' },
+          featuredScenarioId: scenarioId,
         })
         .set('Authorization', `Bearer ${randomUserToken}`),
     WhenUnpublishingAProjectAsProjectOwner: async (projectId: string) =>

api/apps/api/test/project/public-projects.e2e-spec.ts

@@ -25,15 +25,17 @@ test(`getting public projects`, async () => {
 
 test(`publishing a project`, async () => {
   const projectId = await fixtures.GivenPrivateProjectWasCreated();
-  let response = await fixtures.WhenPublishingAProject(projectId);
+  const scenarioId = await fixtures.GivenScenarioWasCreated(projectId);
+  let response = await fixtures.WhenPublishingAProject(projectId, scenarioId);
   fixtures.ThenCreatedIsReturned(response);
   response = await fixtures.WhenGettingPublicProjects();
   fixtures.ThenPublicProjectIsAvailable(projectId, response);
 });
 
 test(`when placing a public project under moderation as a platform admin`, async () => {
   const projectId = await fixtures.GivenPrivateProjectWasCreated();
-  let response = await fixtures.WhenPublishingAProject(projectId);
+  const scenarioId = await fixtures.GivenScenarioWasCreated(projectId);
+  let response = await fixtures.WhenPublishingAProject(projectId, scenarioId);
   fixtures.ThenCreatedIsReturned(response);
   response = await fixtures.WhenPlacingAPublicProjectUnderModerationAsAdmin(
     projectId,
@@ -61,7 +63,8 @@ test(`when placing a public project under moderation as a platform admin`, async
 
 test(`when clearing under moderation status from a public project as a platform admin`, async () => {
   const projectId = await fixtures.GivenPrivateProjectWasCreated();
-  let response = await fixtures.WhenPublishingAProject(projectId);
+  const scenarioId = await fixtures.GivenScenarioWasCreated(projectId);
+  let response = await fixtures.WhenPublishingAProject(projectId, scenarioId);
   fixtures.ThenCreatedIsReturned(response);
   response = await fixtures.WhenPlacingAPublicProjectUnderModerationAsAdmin(
     projectId,
@@ -82,7 +85,8 @@ test(`when clearing under moderation status from a public project as a platform
 
 test(`when placing a public project under moderation as not a platform admin`, async () => {
   const projectId = await fixtures.GivenPrivateProjectWasCreated();
-  let response = await fixtures.WhenPublishingAProject(projectId);
+  const scenarioId = await fixtures.GivenScenarioWasCreated(projectId);
+  let response = await fixtures.WhenPublishingAProject(projectId, scenarioId);
   fixtures.ThenCreatedIsReturned(response);
   response = await fixtures.WhenPlacingAPublicProjectUnderModerationNotAsAdmin(
     projectId,
@@ -96,7 +100,8 @@ test(`when placing a public project under moderation as not a platform admin`, a
 
 test(`when clearing under moderation status from a public project not as platform admin`, async () => {
   const projectId = await fixtures.GivenPrivateProjectWasCreated();
-  let response = await fixtures.WhenPublishingAProject(projectId);
+  const scenarioId = await fixtures.GivenScenarioWasCreated(projectId);
+  let response = await fixtures.WhenPublishingAProject(projectId, scenarioId);
   fixtures.ThenCreatedIsReturned(response);
   response = await fixtures.WhenPlacingAPublicProjectUnderModerationAsAdmin(
     projectId,
@@ -119,7 +124,8 @@ test(`when clearing under moderation status from a public project not as platfor
 
 test(`when unpublishing a public project as a project owner`, async () => {
   const projectId = await fixtures.GivenPrivateProjectWasCreated();
-  let response = await fixtures.WhenPublishingAProject(projectId);
+  const scenarioId = await fixtures.GivenScenarioWasCreated(projectId);
+  let response = await fixtures.WhenPublishingAProject(projectId, scenarioId);
   fixtures.ThenCreatedIsReturned(response);
 
   response = await fixtures.WhenUnpublishingAProjectAsProjectOwner(projectId);
@@ -130,7 +136,8 @@ test(`when unpublishing a public project as a project owner`, async () => {
 
 test(`when unpublishing a public project that is under moderation as a project owner`, async () => {
   const projectId = await fixtures.GivenPrivateProjectWasCreated();
-  let response = await fixtures.WhenPublishingAProject(projectId);
+  const scenarioId = await fixtures.GivenScenarioWasCreated(projectId);
+  let response = await fixtures.WhenPublishingAProject(projectId, scenarioId);
   fixtures.ThenCreatedIsReturned(response);
   response = await fixtures.WhenPlacingAPublicProjectUnderModerationAsAdmin(
     projectId,
@@ -145,7 +152,8 @@ test(`when unpublishing a public project that is under moderation as a project o
 
 test(`when unpublishing a public project that is under moderation as a platform admin`, async () => {
   const projectId = await fixtures.GivenPrivateProjectWasCreated();
-  let response = await fixtures.WhenPublishingAProject(projectId);
+  const scenarioId = await fixtures.GivenScenarioWasCreated(projectId);
+  let response = await fixtures.WhenPublishingAProject(projectId, scenarioId);
   fixtures.ThenCreatedIsReturned(response);
   response = await fixtures.WhenPlacingAPublicProjectUnderModerationAsAdmin(
     projectId,

api/libs/webshot/src/webshot.service.ts

@@ -67,4 +67,31 @@ export class WebshotService {
       return left(unknownPngWebshotError);
     }
   }
+
+  async getPublishedProjectsImage(
+    scenarioId: string,
+    projectId: string,
+    config: WebshotPngConfig,
+    webshotUrl: string,
+  ): Promise<Either<typeof unknownPngWebshotError, string>> {
+    try {
+      const pngBuffer = await this.httpService
+        .post(
+          `${webshotUrl}/projects/${projectId}/scenarios/${scenarioId}/published-projects/frequency`,
+          config,
+          { responseType: 'arraybuffer' },
+        )
+        .toPromise()
+        .then((response) => response.data)
+        .catch((error) => {
+          throw new Error(error);
+        });
+
+      const pngBase64String = Buffer.from(pngBuffer).toString('base64');
+
+      return right(pngBase64String);
+    } catch (error) {
+      return left(unknownPngWebshotError);
+    }
+  }
 }