Expose saving a field in a contact or a paper for inline menu

apps/browser/src/_locales/en/messages.json

@@ -1120,6 +1120,12 @@
   "sharedWithKonnector": {
     "message": "Shared with Cozy Connector"
   },
+  "administrativeFolder": {
+    "message": "Administrative"
+  },
+  "papersFolder": {
+    "message": "My papers"
+  },
   "movedItemToFolder": {
     "message": "Element moved"
   },

apps/browser/src/_locales/fr/messages.json

@@ -1120,6 +1120,12 @@
   "sharedWithKonnector": {
     "message": "Partagé avec un Connecteur Cozy"
   },
+  "administrativeFolder": {
+    "message": "Administratif"
+  },
+  "papersFolder": {
+    "message": "Mes papiers"
+  },
   "movedItemToFolder": {
     "message": "Élément déplacé"
   },

apps/browser/src/autofill/background/overlay.background.ts

@@ -1018,7 +1018,13 @@ export class OverlayBackground implements OverlayBackgroundInterface {
       const client = await this.cozyClientService.getClientInstance();
       const cipher = this.inlineMenuCiphers.get(inlineMenuCipherId);
 
-      await createOrUpdateCozyDoctype({ client, cipher, fieldQualifier, newAutofillValue });
+      await createOrUpdateCozyDoctype({
+        client,
+        cipher,
+        fieldQualifier,
+        newAutofillValue,
+        i18nService: this.i18nService,
+      });
     }
   }
 

libs/cozy/createOrUpdateCozyDoctype.ts

@@ -1,13 +1,21 @@
-import CozyClient, { Q } from "cozy-client";
+import CozyClient, { Q, models } from "cozy-client";
 import { IOCozyContact } from "cozy-client/types/types";
 import * as _ from "lodash";
 
+import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view";
 
 import { AutofillFieldQualifierType } from "../../apps/browser/src/autofill/enums/autofill-field.enums";
 
+import { getOrCreateAppFolderWithReference } from "./helpers/folder";
+import { createPDFWithText } from "./helpers/pdf";
 import { COZY_ATTRIBUTES_MAPPING, CozyAttributesModel } from "./mapping";
 
+const {
+  document: { Qualification, locales },
+  file: { uploadFileWithConflictStrategy },
+} = models;
+
 interface AutofillValue {
   value: string;
   type?: string;
@@ -19,13 +27,15 @@ interface CreateOrUpdateCozyDoctypeType {
   cipher: CipherView;
   fieldQualifier: AutofillFieldQualifierType;
   newAutofillValue: AutofillValue;
+  i18nService: I18nService;
 }
 
 export const createOrUpdateCozyDoctype = async ({
   client,
   cipher,
   fieldQualifier,
   newAutofillValue,
+  i18nService,
 }: CreateOrUpdateCozyDoctypeType) => {
   const cozyAttributeModel = COZY_ATTRIBUTES_MAPPING[fieldQualifier];
 
@@ -46,6 +56,16 @@ export const createOrUpdateCozyDoctype = async ({
     });
 
     await client.save(updatedContact);
+  } else if (cozyAttributeModel.doctype === "io.cozy.files") {
+    // only create for the moment
+    const createdPaper = await createOrUpdateCozyPaper({
+      client,
+      cozyAttributeModel,
+      newAutofillValue,
+      i18nService,
+    });
+
+    await client.save(createdPaper);
   }
 };
 
@@ -92,3 +112,62 @@ export const createOrUpdateCozyContact = async ({
 
   return contact;
 };
+
+interface CreateOrUpdateCozyPaperType {
+  client: CozyClient;
+  cozyAttributeModel: CozyAttributesModel;
+  newAutofillValue: AutofillValue;
+  i18nService: I18nService;
+}
+
+export const createOrUpdateCozyPaper = async ({
+  client,
+  cozyAttributeModel,
+  newAutofillValue,
+  i18nService,
+}: CreateOrUpdateCozyPaperType): Promise<any> => {
+  const [, qualificationLabelValue] = Object.entries(cozyAttributeModel.selector)[0];
+
+  const qualification = Qualification.getByLabel(qualificationLabelValue as string);
+
+  // Create the PDF
+  const pdfText = `${qualificationLabelValue} ${newAutofillValue.value}`;
+  const pdfBytes = await createPDFWithText(pdfText);
+
+  // Build the io.cozy.files document
+  const dir = await getOrCreateAppFolderWithReference(client, i18nService);
+
+  const t = locales.getBoundT(i18nService.translationLocale || "en");
+
+  const paperOptions = {
+    name: t(`Scan.items.${qualification.label}`) + ".pdf",
+    contentType: "application/pdf",
+    metadata: {
+      qualification,
+      paperProps: {
+        isBlank: true,
+      },
+    },
+    dirId: dir._id,
+    conflictStrategy: "rename",
+  };
+
+  _.set(paperOptions, cozyAttributeModel.path, newAutofillValue.value);
+
+  const { data: fileCreated } = await uploadFileWithConflictStrategy(
+    client,
+    pdfBytes,
+    paperOptions,
+  );
+
+  // Add contact
+  // const fileCollection = client.collection('io.cozy.files')
+  // const references = [{
+  //   _id: contact._id,
+  //   _type: 'io.cozy.contacts'
+  // }]
+
+  // await fileCollection.addReferencedBy(fileCreated, references)
+
+  return fileCreated;
+};

libs/cozy/helpers/folder.ts

@@ -0,0 +1,36 @@
+import CozyClient, { models } from "cozy-client";
+
+import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
+
+const { MAGIC_FOLDERS, ensureMagicFolder, getReferencedFolder } = models.folder;
+
+export const APPS_DOCTYPE = "io.cozy.apps";
+const APP_DIR_REF = `${APPS_DOCTYPE}/mypapers`;
+
+export const getOrCreateAppFolderWithReference = async (
+  client: CozyClient,
+  i18nService: I18nService,
+) => {
+  const existingFolders = await getReferencedFolder(client, {
+    _id: APP_DIR_REF,
+    _type: APPS_DOCTYPE,
+  });
+
+  if (existingFolders) {
+    return existingFolders;
+  } else {
+    const { path: administrativeFolderPath } = await ensureMagicFolder(
+      client,
+      MAGIC_FOLDERS.ADMINISTRATIVE,
+      `/${i18nService.t("administrativeFolder")}`,
+    );
+
+    const appFolder = await ensureMagicFolder(
+      client,
+      MAGIC_FOLDERS.PAPERS,
+      `${administrativeFolderPath}/${i18nService.t("papersFolder")}`,
+    );
+
+    return appFolder;
+  }
+};

libs/cozy/helpers/pdf.ts

@@ -0,0 +1,24 @@
+import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
+
+export const createPDFWithText = async (text: string): Promise<Uint8Array> => {
+  const pdfDoc = await PDFDocument.create();
+
+  const timesRomanFont = await pdfDoc.embedFont(StandardFonts.TimesRoman);
+
+  const page = pdfDoc.addPage();
+
+  const { height } = page.getSize();
+
+  const fontSize = 30;
+  page.drawText(text, {
+    x: 50,
+    y: height - 4 * fontSize,
+    size: fontSize,
+    font: timesRomanFont,
+    color: rgb(0, 0.53, 0.71),
+  });
+
+  const pdfBytes = await pdfDoc.save();
+
+  return pdfBytes;
+};