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

package/dist/overmap-core.umd.cjs

@@ -5491,36 +5491,65 @@ var __publicField = (obj, key, value) => {
     }
     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
+        },
+        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);
@@ -5553,14 +5582,16 @@ var __publicField = (obj, key, value) => {
         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();
@@ -5642,14 +5673,16 @@ var __publicField = (obj, key, value) => {
         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;
@@ -5812,46 +5845,69 @@ var __publicField = (obj, key, value) => {
     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
+        },
+        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;
@@ -5875,9 +5931,12 @@ var __publicField = (obj, key, value) => {
         ),
         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;
@@ -5885,8 +5944,7 @@ var __publicField = (obj, key, value) => {
         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
@@ -5987,36 +6045,6 @@ var __publicField = (obj, key, value) => {
       });
       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();