feat: aseta aloituskuulutukseen tiedostot julkaisuaikana kansalaisten…

… saataville

backend/integrationtest/api/__snapshots__/api.test.ts.snap

@@ -26,7 +26,15 @@ Object {
       },
       "kuulutusPaiva": "2022-01-02",
       "siirtyySuunnitteluVaiheeseen": "2022-01-01",
-      "suunnitteluSopimus": undefined,
+      "suunnitteluSopimus": Object {
+        "__typename": "SuunnitteluSopimus",
+        "email": "Joku.Jossain@vayla.fi",
+        "etunimi": "Joku",
+        "kunta": "Nokia",
+        "logo": "/tiedostot/suunnitelma/1.2.246.578.5.1.2978288874.2711575506/suunnittelusopimus/logo.png",
+        "puhelinnumero": "123",
+        "sukunimi": "Jossain",
+      },
       "velho": Object {
         "__typename": "Velho",
         "kunnat": Array [

backend/integrationtest/api/api.test.ts

@@ -164,14 +164,11 @@ describe("Api", () => {
     // Test that fields can be removed as well
     await api.tallennaProjekti({
       oid,
-      suunnitteluSopimus: null,
+      muistiinpano: null,
     });
 
     const updatedProjekti2 = await loadProjektiFromDatabase(oid);
-    expect(updatedProjekti2.muistiinpano).to.be.equal(newNote);
-    expect(updatedProjekti2.aloitusKuulutus).eql(aloitusKuulutus);
-    expect(updatedProjekti2.suunnitteluSopimus).to.be.undefined;
-    expect(updatedProjekti2.kielitiedot).eql(kielitiedot);
+    expect(updatedProjekti2.muistiinpano).to.be.undefined;
 
     userFixture.loginAsProjektiKayttaja(projektiPaallikko);
     await api.siirraTila({

backend/src/config.ts

@@ -27,6 +27,7 @@ const config = {
 
   uploadBucketName: process.env.UPLOAD_BUCKET_NAME,
   yllapitoBucketName: process.env.YLLAPITO_BUCKET_NAME,
+  publicBucketName: process.env.PUBLIC_BUCKET_NAME,
   internalBucketName: process.env.INTERNAL_BUCKET_NAME,
   archiveBucketName: process.env.ARCHIVE_BUCKET_NAME,
 

backend/src/files/fileService.ts

@@ -13,6 +13,7 @@ import {
 } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 import { ArchivedProjektiKey } from "../database/projektiDatabase";
+import { Dayjs } from "dayjs";
 
 export type UploadFileProperties = {
   fileNameWithPath: string;
@@ -26,6 +27,8 @@ export type CreateFileProperties = {
   contents: Buffer;
   contentType?: string;
   inline?: boolean;
+  publicationTimestamp?: Dayjs;
+  copyToPublic?: boolean;
 };
 
 export type PersistFileProperties = { targetFilePathInProjekti: string; uploadedFileSource: string; oid: string };
@@ -55,7 +58,7 @@ export class FileService {
 
     const fileNameFromUpload = FileService.getFileNameFromPath(filePath);
     const targetPath = `/${param.targetFilePathInProjekti}/${fileNameFromUpload}`;
-    const targetBucketPath = FileService.getProjektiDirectory(param.oid) + targetPath;
+    const targetBucketPath = FileService.getYllapitoProjektiDirectory(param.oid) + targetPath;
     try {
       await getS3Client().send(
         new CopyObjectCommand({
@@ -80,26 +83,54 @@ export class FileService {
    */
   async createFileToProjekti(param: CreateFileProperties): Promise<string> {
     const pathWithinProjekti = `/${param.filePathInProjekti}/${param.fileName}`;
-    const targetPath = FileService.getProjektiDirectory(param.oid) + pathWithinProjekti;
     try {
-      const commandOutput = await getS3Client().send(
-        new PutObjectCommand({
-          Body: param.contents,
-          Bucket: config.yllapitoBucketName,
-          Key: targetPath,
-          ContentType: param.contentType,
-          ContentDisposition: param.inline && "inline; filename=" + param.fileName,
-        })
+      const metadata: { [key: string]: string } = {};
+      if (param.publicationTimestamp) {
+        metadata["publication-timestamp"] = param.publicationTimestamp.toISOString();
+      }
+      await FileService.putFile(
+        config.yllapitoBucketName,
+        param,
+        FileService.getYllapitoProjektiDirectory(param.oid) + pathWithinProjekti,
+        metadata
       );
-      log.info(`Created file ${targetPath}`, commandOutput.$metadata);
+
+      if (param.copyToPublic) {
+        await FileService.putFile(
+          config.publicBucketName,
+          param,
+          FileService.getPublicProjektiDirectory(param.oid) + pathWithinProjekti,
+          metadata
+        );
+      }
+
       return pathWithinProjekti;
     } catch (e) {
       log.error(e);
       throw new Error("Error creating file to yllapito");
     }
   }
 
-  private static getProjektiDirectory(oid: string) {
+  private static async putFile(
+    bucket: string,
+    param: CreateFileProperties,
+    targetPath: string,
+    metadata: { [p: string]: string }
+  ) {
+    const commandOutput = await getS3Client().send(
+      new PutObjectCommand({
+        Body: param.contents,
+        Bucket: bucket,
+        Key: targetPath,
+        ContentType: param.contentType,
+        ContentDisposition: param.inline && "inline; filename=" + param.fileName,
+        Metadata: metadata,
+      })
+    );
+    log.info(`Created file ${bucket}/${targetPath}`, commandOutput.$metadata);
+  }
+
+  private static getYllapitoProjektiDirectory(oid: string) {
     return `yllapito/tiedostot/projekti/${oid}`;
   }
 
@@ -130,7 +161,7 @@ export class FileService {
   }
 
   async archiveProjekti({ oid, timestamp }: ArchivedProjektiKey): Promise<void> {
-    const sourcePrefix = FileService.getProjektiDirectory(oid);
+    const sourcePrefix = FileService.getYllapitoProjektiDirectory(oid);
     const targetPrefix = sourcePrefix + "/" + timestamp;
     const sourceBucket = config.yllapitoBucketName;
     const targetBucket = config.archiveBucketName;
@@ -145,6 +176,7 @@ export class FileService {
           Bucket: targetBucket,
           Key: targetKey,
           CopySource: `${sourceBucket}/${sourceKey}`,
+          MetadataDirective: "REPLACE",
         })
       );
 
@@ -183,12 +215,35 @@ export class FileService {
   }
 
   getYllapitoPathForProjektiFile(oid: string, path: string): string | undefined {
-    return path ? `/${FileService.getProjektiDirectory(oid)}${path}` : undefined;
+    return path ? `/${FileService.getYllapitoProjektiDirectory(oid)}${path}` : undefined;
   }
 
   getPublicPathForProjektiFile(oid: string, path: string): string | undefined {
     return path ? `/${FileService.getPublicProjektiDirectory(oid)}${path}` : undefined;
   }
+
+  /**
+   * Copy file from yllapito to public bucket
+   */
+  async publishProjektiFile(oid: string, filePathInProjekti: string, publishDate?: Dayjs): Promise<void> {
+    const sourceBucket = config.yllapitoBucketName;
+    const targetBucket = config.publicBucketName;
+
+    const s3Client = getS3Client();
+    const metadata: { [key: string]: string } = {};
+    if (publishDate) {
+      metadata["publication-timestamp"] = publishDate.toISOString();
+    }
+    const copyObjectParams = {
+      Bucket: targetBucket,
+      Key: `${FileService.getPublicProjektiDirectory(oid)}${filePathInProjekti}`,
+      CopySource: `${sourceBucket}/${FileService.getYllapitoProjektiDirectory(oid)}${filePathInProjekti}`,
+      MetadataDirective: "REPLACE",
+      Metadata: metadata,
+    };
+    const copyObjectCommandOutput = await s3Client.send(new CopyObjectCommand(copyObjectParams));
+    log.info("Publish file", { copyObjectParams, copyObjectCommandOutput });
+  }
 }
 
 export const fileService = new FileService();

backend/src/handler/aloitusKuulutusHandler.ts

@@ -15,6 +15,7 @@ import { fileService } from "../files/fileService";
 import { sendEmail } from "../email/email";
 import { createHyvaksyttavanaEmail } from "../email/emailTemplates";
 import { log } from "../logger";
+import { parseDate } from "../util/dateUtil";
 
 async function sendForApproval(projekti: DBProjekti, aloitusKuulutus: AloitusKuulutus) {
   const muokkaaja = requirePermissionMuokkaa(projekti);
@@ -67,6 +68,8 @@ async function createAloituskuulutusPDF(
     contents: Buffer.from(pdf.sisalto, "base64"),
     inline: true,
     contentType: "application/pdf",
+    publicationTimestamp: parseDate(julkaisuWaitingForApproval.kuulutusPaiva),
+    copyToPublic: true,
   });
 }
 
@@ -109,6 +112,14 @@ async function approve(projekti: DBProjekti, aloitusKuulutus: AloitusKuulutus) {
       kielitiedot.toissijainenKieli,
       julkaisuWaitingForApproval
     );
+
+    if (projekti.suunnitteluSopimus?.logo) {
+      await fileService.publishProjektiFile(
+        projekti.oid,
+        projekti.suunnitteluSopimus?.logo,
+        parseDate(julkaisuWaitingForApproval.kuulutusPaiva)
+      );
+    }
   }
 
   await projektiDatabase.updateAloitusKuulutusJulkaisu(projekti, julkaisuWaitingForApproval);