@overmap-ai/core 1.0.63-form-submission-fix.0 → 1.0.63-form-submission-fix.2

package/dist/overmap-core.js

@@ -5503,36 +5503,66 @@ const separateImageFromFields = async (fields) => {
   }
   return { fields: newFields, images };
 };
-class FormService extends BaseApiService {
-  constructor() {
-    super(...arguments);
-    // Attach images to revision, after uploading them to S3
-    __publicField(this, "getAttachImagePromises", (images, offlineRevisionId) => {
-      return Object.entries(images).map(async ([key, image]) => {
-        const sha1 = await hashFile(image);
-        await this.client.files.addCache(image, sha1);
-        const [fileProps] = await this.client.files.uploadFileToS3(sha1);
-        const revisionAttachmentPayload = offline({
-          ...fileProps,
-          revision: offlineRevisionId,
-          field_identifier: key
-        });
-        const attach = await this.enqueueRequest({
-          description: "Attach image to form revision field",
-          method: HttpMethod.POST,
-          url: `/forms/revisions/${offlineRevisionId}/attachments/`,
-          payload: revisionAttachmentPayload,
-          blockers: [revisionAttachmentPayload.revision],
-          blocks: [revisionAttachmentPayload.offline_id]
-        });
-        const offlinePayload = {
-          ...revisionAttachmentPayload,
-          file: URL.createObjectURL(image)
+class FormService extends BaseUploadService {
+  async bulkAddRevisionAttachments(revisionId, files) {
+    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const createdBy = this.client.store.getState().userReducer.currentUser.id;
+    const filePayloads = {};
+    const offlineFormRevisionAttachments = [];
+    const attachmentPayloads = [];
+    for (const [fieldIdentifier, file] of Object.entries(files)) {
+      const sha1 = await hashFile(file);
+      if (!(sha1 in filePayloads)) {
+        filePayloads[sha1] = {
+          sha1,
+          file_type: file.type,
+          extension: file.name.split(".").pop(),
+          size: file.size
         };
-        this.dispatch(addFormRevisionAttachment(offlinePayload));
-        return attach;
+        await this.client.files.addCache(file, sha1);
+      }
+      const offlineFormRevisionAttachment = offline({
+        file: URL.createObjectURL(file),
+        file_type: file.type,
+        file_name: file.name,
+        file_sha1: sha1,
+        created_by: createdBy,
+        revision: revisionId,
+        submitted_at: submittedAt,
+        field_identifier: fieldIdentifier
       });
+      offlineFormRevisionAttachments.push(offlineFormRevisionAttachment);
+      const attachmentPayload = {
+        offline_id: offlineFormRevisionAttachment.offline_id,
+        name: file.name,
+        sha1
+      };
+      attachmentPayloads.push(attachmentPayload);
+    }
+    this.dispatch(addFormRevisionAttachments(offlineFormRevisionAttachments));
+    const promise = this.enqueueRequest({
+      description: "Attach files to form revision",
+      method: HttpMethod.POST,
+      url: `/forms/revisions/${revisionId}/attachments/bulk/`,
+      payload: {
+        submitted_at: submittedAt,
+        attachments: attachmentPayloads,
+        files: Object.values(filePayloads)
+      },
+      blockers: [revisionId],
+      blocks: offlineFormRevisionAttachments.map((attachment) => attachment.offline_id)
+    });
+    promise.then((result) => {
+      this.processPresignedUrls(result.presigned_urls);
+      this.dispatch(updateFormRevisionAttachments(result.attachments));
+    }).catch(() => {
+      this.dispatch(
+        deleteFormRevisionAttachments(
+          offlineFormRevisionAttachments.map((attachment) => attachment.offline_id)
+        )
+      );
     });
+    return [offlineFormRevisionAttachments, promise.then(({ attachments }) => attachments)];
   }
   async add(ownerId, form, initialRevision, urlPrefix) {
     const { fields, images } = await separateImageFromFields(initialRevision.fields);
@@ -5565,14 +5595,16 @@ class FormService extends BaseApiService {
       blockers: [ownerId],
       blocks: [form.offline_id, offlineFormRevision.offline_id]
     });
-    const attachImagesPromises = this.getAttachImagePromises(images, offlineFormRevision.offline_id);
+    const [offlineFormRevisionAttachments, attachmentsPromise] = await this.bulkAddRevisionAttachments(
+      offlineFormRevision.offline_id,
+      images
+    );
     void formPromise.catch((e) => {
       this.dispatch(deleteForm(form.offline_id));
       this.dispatch(deleteFormRevision(offlineFormRevision.offline_id));
       throw e;
     });
-    const settledPromise = Promise.all([formPromise, ...attachImagesPromises]).then(() => formPromise);
-    return [form, offlineFormRevision, formPromise, settledPromise];
+    return [form, offlineFormRevision, offlineFormRevisionAttachments, formPromise, attachmentsPromise];
   }
   addForOrganization(organizationId, initialRevision) {
     const state = this.client.store.getState();
@@ -5654,14 +5686,16 @@ class FormService extends BaseApiService {
       blockers: [formId],
       blocks: [offlineRevision.offline_id]
     });
-    const attachImagesPromises = this.getAttachImagePromises(images, offlineRevision.offline_id);
+    const [offlineFormRevisionAttachments, attachmentsPromise] = await this.bulkAddRevisionAttachments(
+      fullRevision.offline_id,
+      images
+    );
     void promise.then((result) => {
       this.dispatch(setFormRevision(result));
     }).catch(() => {
       this.dispatch(deleteFormRevision(fullRevision.offline_id));
     });
-    const settledPromise = Promise.all([promise, ...attachImagesPromises]).then(() => promise);
-    return [fullRevision, settledPromise];
+    return [fullRevision, offlineFormRevisionAttachments, promise, attachmentsPromise];
   }
   async favorite(formId) {
     const { store } = this.client;
@@ -5824,46 +5858,70 @@ const separateFilesFromValues = (values) => {
   return { values: newValues, files };
 };
 class FormSubmissionService extends BaseUploadService {
-  constructor() {
-    super(...arguments);
-    // Attach files to submission, after uploading them to S3
-    __publicField(this, "getAttachFilesPromises", (files, submission) => {
-      return Object.entries(files).map(async ([key, fileArray]) => {
-        const attachResults = [];
-        for (const file of fileArray) {
-          const sha1 = await hashFile(file);
-          await this.client.files.addCache(file, sha1);
-          const [fileProps] = await this.client.files.uploadFileToS3(sha1);
-          const submissionAttachmentPayload = offline({
-            ...fileProps,
-            submission: submission.offline_id,
-            field_identifier: key
-          });
-          const attach = await this.enqueueRequest({
-            description: "Attach file to form submission",
-            method: HttpMethod.POST,
-            url: `/forms/submission/${submission.offline_id}/attachments/`,
-            payload: submissionAttachmentPayload,
-            blockers: [
-              submission.asset,
-              submission.asset_stage,
-              submission.issue,
-              submission.form_revision
-            ].filter((x) => x !== void 0),
-            blocks: [submissionAttachmentPayload.offline_id]
-          });
-          const offlinePayload = {
-            ...submissionAttachmentPayload,
-            file: URL.createObjectURL(file)
+  async bulkAddSubmissionAttachments(submissionId, files) {
+    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const createdBy = this.client.store.getState().userReducer.currentUser.id;
+    const filePayloads = {};
+    const offlineFormSubmissionAttachments = [];
+    const attachmentPayloads = [];
+    for (const [fieldIdentifier, filesArray] of Object.entries(files)) {
+      for (const file of filesArray) {
+        const sha1 = await hashFile(file);
+        if (!(sha1 in filePayloads)) {
+          filePayloads[sha1] = {
+            sha1,
+            file_type: file.type,
+            extension: file.name.split(".").pop(),
+            size: file.size
           };
-          this.dispatch(addFormSubmissionAttachment(offlinePayload));
-          attachResults.push(attach);
+          await this.client.files.addCache(file, sha1);
         }
-        return attachResults;
-      });
+        const offlineFormSubmissionAttachment = offline({
+          file: URL.createObjectURL(file),
+          file_type: file.type,
+          file_name: file.name,
+          file_sha1: sha1,
+          created_by: createdBy,
+          submission: submissionId,
+          submitted_at: submittedAt,
+          field_identifier: fieldIdentifier
+        });
+        offlineFormSubmissionAttachments.push(offlineFormSubmissionAttachment);
+        const attachmentPayload = {
+          offline_id: offlineFormSubmissionAttachment.offline_id,
+          name: file.name,
+          sha1
+        };
+        attachmentPayloads.push(attachmentPayload);
+      }
+    }
+    this.dispatch(addFormSubmissionAttachments(offlineFormSubmissionAttachments));
+    const promise = this.enqueueRequest({
+      description: "Attach files to form submission",
+      method: HttpMethod.POST,
+      url: `/forms/submissions/${submissionId}/attachments/bulk/`,
+      payload: {
+        submitted_at: submittedAt,
+        attachments: attachmentPayloads,
+        files: Object.values(filePayloads)
+      },
+      blockers: [submissionId],
+      blocks: offlineFormSubmissionAttachments.map((attachment) => attachment.offline_id)
+    });
+    promise.then((result) => {
+      this.processPresignedUrls(result.presigned_urls);
+      this.dispatch(updateFormSubmissionAttachments(result.attachments));
+    }).catch(() => {
+      this.dispatch(
+        deleteFormSubmissionAttachments(
+          offlineFormSubmissionAttachments.map((attachment) => attachment.offline_id)
+        )
+      );
     });
+    return [offlineFormSubmissionAttachments, promise.then(({ attachments }) => attachments)];
   }
-  add(payload) {
+  // Outer promise is for hashing and caching files for submission attachments
+  async add(payload) {
     const { store } = this.client;
     const state = store.getState();
     const activeProjectId = state.projectReducer.activeProjectId;
@@ -5887,9 +5945,12 @@ class FormSubmissionService extends BaseUploadService {
       ),
       blocks: [offlineSubmission.offline_id]
     });
-    const attachFilesPromises = this.getAttachFilesPromises(files, offlineSubmission);
     this.dispatch(addFormSubmission(offlineSubmission));
-    void promise.then((result) => {
+    const [offlineFormSubmissionAttachments, attachmentsPromise] = await this.bulkAddSubmissionAttachments(
+      offlineSubmission.offline_id,
+      files
+    );
+    promise.then((result) => {
       this.dispatch(addActiveProjectFormSubmissionsCount(1));
       this.dispatch(setFormSubmission(result));
       return result;
@@ -5897,8 +5958,7 @@ class FormSubmissionService extends BaseUploadService {
       this.dispatch(deleteFormSubmission(offlineSubmission.offline_id));
       this.dispatch(addActiveProjectFormSubmissionsCount(-1));
     });
-    const settledPromise = Promise.all([promise, ...attachFilesPromises]).then(() => promise);
-    return [offlineSubmission, settledPromise];
+    return [offlineSubmission, offlineFormSubmissionAttachments, promise, attachmentsPromise];
   }
   // Note currently the bulkAdd method is specific to form submissions for assets
   // TODO: adapt the support bulk adding to any model type
@@ -5999,36 +6059,6 @@ class FormSubmissionService extends BaseUploadService {
     });
     return batchPromises;
   }
-  update(submission) {
-    const { store } = this.client;
-    const { values, files } = separateFilesFromValues(submission.values);
-    const attachFilesPromises = this.getAttachFilesPromises(files, submission);
-    const offlineSubmission = {
-      ...submission,
-      values
-    };
-    const submissionToBeUpdated = selectFormSubmission(submission.offline_id)(store.getState());
-    if (!submissionToBeUpdated) {
-      throw new Error(`Expected submission with offline_id ${submission.offline_id} to exist`);
-    }
-    this.dispatch(updateFormSubmission(offlineSubmission));
-    const promise = this.enqueueRequest({
-      description: "Patch form submission",
-      method: HttpMethod.PATCH,
-      url: `/forms/submissions/${submission.offline_id}/`,
-      payload: offlineSubmission,
-      blockers: [offlineSubmission.issue, offlineSubmission.asset, offlineSubmission.asset_stage].filter(
-        (x) => x !== void 0
-      ),
-      blocks: [offlineSubmission.offline_id]
-    });
-    promise.then((createdSubmission) => {
-      this.dispatch(setFormSubmission(createdSubmission));
-    }).catch(() => {
-      this.dispatch(setFormSubmission(submissionToBeUpdated));
-    });
-    return [offlineSubmission, Promise.all([promise, ...attachFilesPromises]).then(() => promise)];
-  }
   async delete(submissionId) {
     const { store } = this.client;
     const state = store.getState();