@carbonbox/domain 0.54.0 → 0.55.0

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/constants/ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT = void 0;
+/**
+ * Most evidences (supporting documents) one activity data submission holds: 20 (AUD-D21).
+ *
+ * A submission is one activity for one period (the invoices of a year fit); the cap keeps the
+ * record bounded. More documents go in a single PDF or workbook.
+ */
+exports.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT = 20;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/constants/ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES = void 0;
+/**
+ * Largest evidence (supporting document) an activity data submission accepts: 25 MiB (AUD-D21).
+ *
+ * Enough for a scanned multi-page invoice, a phone photo or a yearly consumption workbook, and
+ * small enough to upload from the browser in one request. The backend uses it as the size
+ * condition of the upload URL and the web checks it before uploading.
+ */
+exports.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES = 25 * 1024 * 1024;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/entity/ActivityDataSubmission.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ActivityDataSubmission_dynamicFormCode, _ActivityDataSubmission_carbonClient, _ActivityDataSubmission_footprintType, _ActivityDataSubmission_country, _ActivityDataSubmission_footprintConfiguration, _ActivityDataSubmission_segmentConfiguration, _ActivityDataSubmission_facility, _ActivityDataSubmission_filledByStakeholder, _ActivityDataSubmission_fieldResponses, _ActivityDataSubmission_periodStart, _ActivityDataSubmission_periodEnd, _ActivityDataSubmission_overallUncertaintyPercentage, _ActivityDataSubmission_uncertaintySource, _ActivityDataSubmission_dataQualityNotes, _ActivityDataSubmission_reportingStandard, _ActivityDataSubmission_emissionScope, _ActivityDataSubmission_subScope, _ActivityDataSubmission_status, _ActivityDataSubmission_submittedAt, _ActivityDataSubmission_approvedAt, _ActivityDataSubmission_rejectedAt, _ActivityDataSubmission_rejectionReason;
+var _ActivityDataSubmission_instances, _a, _ActivityDataSubmission_dynamicFormCode, _ActivityDataSubmission_carbonClient, _ActivityDataSubmission_footprintType, _ActivityDataSubmission_country, _ActivityDataSubmission_footprintConfiguration, _ActivityDataSubmission_segmentConfiguration, _ActivityDataSubmission_facility, _ActivityDataSubmission_filledByStakeholder, _ActivityDataSubmission_fieldResponses, _ActivityDataSubmission_periodStart, _ActivityDataSubmission_periodEnd, _ActivityDataSubmission_overallUncertaintyPercentage, _ActivityDataSubmission_uncertaintySource, _ActivityDataSubmission_dataQualityNotes, _ActivityDataSubmission_reportingStandard, _ActivityDataSubmission_emissionScope, _ActivityDataSubmission_subScope, _ActivityDataSubmission_status, _ActivityDataSubmission_submittedAt, _ActivityDataSubmission_approvedAt, _ActivityDataSubmission_rejectedAt, _ActivityDataSubmission_rejectionReason, _ActivityDataSubmission_statusHistory, _ActivityDataSubmission_evidences, _ActivityDataSubmission_withStatusChange, _ActivityDataSubmission_toProps, _ActivityDataSubmission_guardAgainstInvalidTransitionTo, _ActivityDataSubmission_guardAgainstStatusOutside, _ActivityDataSubmission_guardAgainstStatusDifferentFromLastChange;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActivityDataSubmission = void 0;
 const AggregateRoot_1 = require("../../../../shared/domain/entities/AggregateRoot");
@@ -40,12 +40,38 @@ const ActivityDataSubmissionStatus_1 = require("../value-objects/ActivityDataSub
 const ActivityDataSubmissionSubmittedAt_1 = require("../value-objects/ActivityDataSubmissionSubmittedAt");
 const ActivityDataSubmissionSubScope_1 = require("../value-objects/ActivityDataSubmissionSubScope");
 const ActivityDataSubmissionUncertaintySource_1 = require("../value-objects/ActivityDataSubmissionUncertaintySource");
+const ActivityDataSubmissionStatusHistory_1 = require("../value-objects/ActivityDataSubmissionStatusHistory");
+const ActivityDataSubmissionStatusChangedAt_1 = require("../value-objects/ActivityDataSubmissionStatusChangedAt");
+const ActivityDataSubmissionEvidences_1 = require("../value-objects/ActivityDataSubmissionEvidences");
+const ActivityDataSubmissionEvidenceId_1 = require("../value-objects/ActivityDataSubmissionEvidenceId");
+const SubmissionStatus_1 = require("../enums/SubmissionStatus");
+const ActivityDataSubmissionInvalidStatusTransitionError_1 = require("../exceptions/ActivityDataSubmissionInvalidStatusTransitionError");
+const ActivityDataSubmissionEvidenceLimitReachedError_1 = require("../exceptions/ActivityDataSubmissionEvidenceLimitReachedError");
+const ActivityDataSubmissionEvidenceNotFoundError_1 = require("../exceptions/ActivityDataSubmissionEvidenceNotFoundError");
+const ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT_1 = require("../constants/ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT");
+/**
+ * ActivityDataSubmission aggregate: the activity data of one form for one period.
+ *
+ * Lifecycle (AUD-D22): DRAFT → SUBMITTED → APPROVED | REJECTED; REJECTED → SUBMITTED (resubmitted
+ * after correcting it); APPROVED | REJECTED → ARCHIVED. `submit`, `approve`, `reject` and `archive`
+ * receive who acts and the current moment (`DD/MM/YYYY HH:mm:ss`; the domain does not read the
+ * clock), append the change to `statusHistory` and return a new instance. `submittedAt`,
+ * `approvedAt`, `rejectedAt` and `rejectionReason` keep the last moment of each change, as before.
+ *
+ * Evidences (AUD-D21): `addEvidence` while the submission is not ARCHIVED (a carbon client can
+ * attach a document after approval to answer a verifier) and `removeEvidence` only while it is
+ * DRAFT or REJECTED, so a document that backed a submitted figure cannot disappear.
+ *
+ * Invariant: the current status is the status of the last history entry (DRAFT with an empty
+ * history).
+ */
 class ActivityDataSubmission extends AggregateRoot_1.AggregateRoot {
     constructor(props, skipDomainValidation) {
         const id = skipDomainValidation
             ? ActivityDataSubmissionId_1.ActivityDataSubmissionId.fromPrimitives(props.id).toPrimitives()
             : ActivityDataSubmissionId_1.ActivityDataSubmissionId.create(props.id).toPrimitives();
         super({ id }, skipDomainValidation);
+        _ActivityDataSubmission_instances.add(this);
         _ActivityDataSubmission_dynamicFormCode.set(this, void 0);
         _ActivityDataSubmission_carbonClient.set(this, void 0);
         _ActivityDataSubmission_footprintType.set(this, void 0);
@@ -68,6 +94,8 @@ class ActivityDataSubmission extends AggregateRoot_1.AggregateRoot {
         _ActivityDataSubmission_approvedAt.set(this, void 0);
         _ActivityDataSubmission_rejectedAt.set(this, void 0);
         _ActivityDataSubmission_rejectionReason.set(this, void 0);
+        _ActivityDataSubmission_statusHistory.set(this, void 0);
+        _ActivityDataSubmission_evidences.set(this, void 0);
         if (skipDomainValidation === false) {
             __classPrivateFieldSet(this, _ActivityDataSubmission_dynamicFormCode, ActivityDataSubmissionDynamicFormCode_1.ActivityDataSubmissionDynamicFormCode.create(props.dynamicFormCode), "f");
             __classPrivateFieldSet(this, _ActivityDataSubmission_carbonClient, ActivityDataSubmissionCarbonClient_1.ActivityDataSubmissionCarbonClient.create(props.carbonClient), "f");
@@ -91,8 +119,11 @@ class ActivityDataSubmission extends AggregateRoot_1.AggregateRoot {
             __classPrivateFieldSet(this, _ActivityDataSubmission_approvedAt, ActivityDataSubmissionApprovedAt_1.ActivityDataSubmissionApprovedAt.create(props.approvedAt), "f");
             __classPrivateFieldSet(this, _ActivityDataSubmission_rejectedAt, ActivityDataSubmissionRejectedAt_1.ActivityDataSubmissionRejectedAt.create(props.rejectedAt), "f");
             __classPrivateFieldSet(this, _ActivityDataSubmission_rejectionReason, ActivityDataSubmissionRejectionReason_1.ActivityDataSubmissionRejectionReason.create(props.rejectionReason), "f");
-            ActivityDataSubmission.guardAgainstInvalidPeriodRange(props.periodStart, props.periodEnd);
-            ActivityDataSubmission.guardAgainstFacilityOnNonCorporateFootprint(props.facility, props.footprintType);
+            __classPrivateFieldSet(this, _ActivityDataSubmission_statusHistory, ActivityDataSubmissionStatusHistory_1.ActivityDataSubmissionStatusHistory.create(props.statusHistory), "f");
+            __classPrivateFieldSet(this, _ActivityDataSubmission_evidences, ActivityDataSubmissionEvidences_1.ActivityDataSubmissionEvidences.create(props.evidences), "f");
+            _a.guardAgainstInvalidPeriodRange(props.periodStart, props.periodEnd);
+            _a.guardAgainstFacilityOnNonCorporateFootprint(props.facility, props.footprintType);
+            __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_guardAgainstStatusDifferentFromLastChange).call(this);
         }
         else {
             __classPrivateFieldSet(this, _ActivityDataSubmission_dynamicFormCode, ActivityDataSubmissionDynamicFormCode_1.ActivityDataSubmissionDynamicFormCode.fromPrimitives(props.dynamicFormCode), "f");
@@ -117,6 +148,8 @@ class ActivityDataSubmission extends AggregateRoot_1.AggregateRoot {
             __classPrivateFieldSet(this, _ActivityDataSubmission_approvedAt, ActivityDataSubmissionApprovedAt_1.ActivityDataSubmissionApprovedAt.fromPrimitives(props.approvedAt), "f");
             __classPrivateFieldSet(this, _ActivityDataSubmission_rejectedAt, ActivityDataSubmissionRejectedAt_1.ActivityDataSubmissionRejectedAt.fromPrimitives(props.rejectedAt), "f");
             __classPrivateFieldSet(this, _ActivityDataSubmission_rejectionReason, ActivityDataSubmissionRejectionReason_1.ActivityDataSubmissionRejectionReason.fromPrimitives(props.rejectionReason), "f");
+            __classPrivateFieldSet(this, _ActivityDataSubmission_statusHistory, ActivityDataSubmissionStatusHistory_1.ActivityDataSubmissionStatusHistory.fromPrimitives(props.statusHistory), "f");
+            __classPrivateFieldSet(this, _ActivityDataSubmission_evidences, ActivityDataSubmissionEvidences_1.ActivityDataSubmissionEvidences.fromPrimitives(props.evidences), "f");
         }
     }
     /**
@@ -146,7 +179,7 @@ class ActivityDataSubmission extends AggregateRoot_1.AggregateRoot {
         }
     }
     static create(props) {
-        return new ActivityDataSubmission(props, false);
+        return new _a(props, false);
     }
     static fromPrimitives(primitives) {
         const props = {
@@ -173,8 +206,10 @@ class ActivityDataSubmission extends AggregateRoot_1.AggregateRoot {
             approvedAt: primitives.approvedAt,
             rejectedAt: primitives.rejectedAt,
             rejectionReason: primitives.rejectionReason,
+            statusHistory: primitives.statusHistory,
+            evidences: primitives.evidences,
         };
-        return new ActivityDataSubmission(props, true);
+        return new _a(props, true);
     }
     get toPrimitives() {
         return {
@@ -201,6 +236,8 @@ class ActivityDataSubmission extends AggregateRoot_1.AggregateRoot {
             approvedAt: __classPrivateFieldGet(this, _ActivityDataSubmission_approvedAt, "f").toPrimitives(),
             rejectedAt: __classPrivateFieldGet(this, _ActivityDataSubmission_rejectedAt, "f").toPrimitives(),
             rejectionReason: __classPrivateFieldGet(this, _ActivityDataSubmission_rejectionReason, "f").toPrimitives(),
+            statusHistory: __classPrivateFieldGet(this, _ActivityDataSubmission_statusHistory, "f").toPrimitives(),
+            evidences: __classPrivateFieldGet(this, _ActivityDataSubmission_evidences, "f").toPrimitives(),
         };
     }
     get dynamicFormCode() {
@@ -269,6 +306,164 @@ class ActivityDataSubmission extends AggregateRoot_1.AggregateRoot {
     get rejectionReason() {
         return __classPrivateFieldGet(this, _ActivityDataSubmission_rejectionReason, "f");
     }
+    get statusHistory() {
+        return __classPrivateFieldGet(this, _ActivityDataSubmission_statusHistory, "f");
+    }
+    get evidences() {
+        return __classPrivateFieldGet(this, _ActivityDataSubmission_evidences, "f");
+    }
+    /**
+     * Returns the submission sent for review at `now` (from DRAFT, or from REJECTED after correcting
+     * it). Otherwise ActivityDataSubmissionInvalidStatusTransitionError.
+     */
+    submit(now, submittedByStakeholder) {
+        const changedAt = ActivityDataSubmissionStatusChangedAt_1.ActivityDataSubmissionStatusChangedAt.create(now).toPrimitives();
+        __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_guardAgainstInvalidTransitionTo).call(this, SubmissionStatus_1.SubmissionStatus.SUBMITTED, 'submit');
+        return __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_withStatusChange).call(this, SubmissionStatus_1.SubmissionStatus.SUBMITTED, changedAt, submittedByStakeholder, null, {
+            submittedAt: changedAt,
+        });
+    }
+    /**
+     * Returns the submission approved at `now` (only from SUBMITTED). Otherwise
+     * ActivityDataSubmissionInvalidStatusTransitionError.
+     */
+    approve(now, approvedByStakeholder) {
+        const changedAt = ActivityDataSubmissionStatusChangedAt_1.ActivityDataSubmissionStatusChangedAt.create(now).toPrimitives();
+        __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_guardAgainstInvalidTransitionTo).call(this, SubmissionStatus_1.SubmissionStatus.APPROVED, 'approve');
+        return __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_withStatusChange).call(this, SubmissionStatus_1.SubmissionStatus.APPROVED, changedAt, approvedByStakeholder, null, {
+            approvedAt: changedAt,
+        });
+    }
+    /**
+     * Returns the submission rejected at `now` with the reason shown to whoever filled it (only from
+     * SUBMITTED). The reason is required (InvalidPropertyValueError when empty) and clears the
+     * previous approval moment.
+     */
+    reject(now, rejectedByStakeholder, reason) {
+        const changedAt = ActivityDataSubmissionStatusChangedAt_1.ActivityDataSubmissionStatusChangedAt.create(now).toPrimitives();
+        __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_guardAgainstInvalidTransitionTo).call(this, SubmissionStatus_1.SubmissionStatus.REJECTED, 'reject');
+        if (typeof reason !== 'string' || reason.trim() === '') {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create('reason', 'a reason when rejecting an activity data submission', String(reason));
+        }
+        return __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_withStatusChange).call(this, SubmissionStatus_1.SubmissionStatus.REJECTED, changedAt, rejectedByStakeholder, reason, {
+            rejectedAt: changedAt,
+            rejectionReason: reason.trim(),
+            approvedAt: null,
+        });
+    }
+    /**
+     * Returns the submission archived at `now` (from APPROVED or REJECTED), with an optional reason.
+     * Otherwise ActivityDataSubmissionInvalidStatusTransitionError.
+     */
+    archive(now, archivedByStakeholder, reason) {
+        const changedAt = ActivityDataSubmissionStatusChangedAt_1.ActivityDataSubmissionStatusChangedAt.create(now).toPrimitives();
+        __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_guardAgainstInvalidTransitionTo).call(this, SubmissionStatus_1.SubmissionStatus.ARCHIVED, 'archive');
+        return __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_withStatusChange).call(this, SubmissionStatus_1.SubmissionStatus.ARCHIVED, changedAt, archivedByStakeholder, reason, {});
+    }
+    /**
+     * Returns the submission with one more evidence at the end. Allowed while the submission is not
+     * ARCHIVED (ActivityDataSubmissionInvalidStatusTransitionError); at most
+     * ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT evidences (ActivityDataSubmissionEvidenceLimitReachedError).
+     * The evidence is validated: content type (ActivityDataSubmissionEvidenceContentTypeNotAllowedError),
+     * size (ActivityDataSubmissionEvidenceTooLargeError), uploader role, unique id and storage key.
+     */
+    addEvidence(evidence) {
+        __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_guardAgainstStatusOutside).call(this, _a.EVIDENCE_ADDABLE_STATUSES, 'add an evidence to');
+        if (__classPrivateFieldGet(this, _ActivityDataSubmission_evidences, "f").isFull()) {
+            throw ActivityDataSubmissionEvidenceLimitReachedError_1.ActivityDataSubmissionEvidenceLimitReachedError.create(this.id.toPrimitives(), ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT_1.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT);
+        }
+        return _a.create({
+            ...__classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_toProps).call(this),
+            evidences: [...__classPrivateFieldGet(this, _ActivityDataSubmission_evidences, "f").toPrimitives(), evidence],
+        });
+    }
+    /**
+     * Returns the submission without the evidence of the given id. Allowed only while the submission
+     * is DRAFT or REJECTED (ActivityDataSubmissionInvalidStatusTransitionError); an unknown id raises
+     * ActivityDataSubmissionEvidenceNotFoundError. Deleting the stored file is up to the caller.
+     */
+    removeEvidence(evidenceId) {
+        const id = ActivityDataSubmissionEvidenceId_1.ActivityDataSubmissionEvidenceId.create(evidenceId).toPrimitives();
+        __classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_guardAgainstStatusOutside).call(this, _a.EVIDENCE_REMOVABLE_STATUSES, 'remove an evidence from');
+        if (__classPrivateFieldGet(this, _ActivityDataSubmission_evidences, "f").includes(id) === false) {
+            throw ActivityDataSubmissionEvidenceNotFoundError_1.ActivityDataSubmissionEvidenceNotFoundError.create(this.id.toPrimitives(), id);
+        }
+        return _a.create({
+            ...__classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_toProps).call(this),
+            evidences: __classPrivateFieldGet(this, _ActivityDataSubmission_evidences, "f").toPrimitives().filter((evidence) => evidence.id !== id),
+        });
+    }
+    /**
+     * The evidence with the given id, or null when the submission does not have it.
+     */
+    findEvidence(evidenceId) {
+        return __classPrivateFieldGet(this, _ActivityDataSubmission_evidences, "f").findById(evidenceId);
+    }
 }
 exports.ActivityDataSubmission = ActivityDataSubmission;
-_ActivityDataSubmission_dynamicFormCode = new WeakMap(), _ActivityDataSubmission_carbonClient = new WeakMap(), _ActivityDataSubmission_footprintType = new WeakMap(), _ActivityDataSubmission_country = new WeakMap(), _ActivityDataSubmission_footprintConfiguration = new WeakMap(), _ActivityDataSubmission_segmentConfiguration = new WeakMap(), _ActivityDataSubmission_facility = new WeakMap(), _ActivityDataSubmission_filledByStakeholder = new WeakMap(), _ActivityDataSubmission_fieldResponses = new WeakMap(), _ActivityDataSubmission_periodStart = new WeakMap(), _ActivityDataSubmission_periodEnd = new WeakMap(), _ActivityDataSubmission_overallUncertaintyPercentage = new WeakMap(), _ActivityDataSubmission_uncertaintySource = new WeakMap(), _ActivityDataSubmission_dataQualityNotes = new WeakMap(), _ActivityDataSubmission_reportingStandard = new WeakMap(), _ActivityDataSubmission_emissionScope = new WeakMap(), _ActivityDataSubmission_subScope = new WeakMap(), _ActivityDataSubmission_status = new WeakMap(), _ActivityDataSubmission_submittedAt = new WeakMap(), _ActivityDataSubmission_approvedAt = new WeakMap(), _ActivityDataSubmission_rejectedAt = new WeakMap(), _ActivityDataSubmission_rejectionReason = new WeakMap();
+_a = ActivityDataSubmission, _ActivityDataSubmission_dynamicFormCode = new WeakMap(), _ActivityDataSubmission_carbonClient = new WeakMap(), _ActivityDataSubmission_footprintType = new WeakMap(), _ActivityDataSubmission_country = new WeakMap(), _ActivityDataSubmission_footprintConfiguration = new WeakMap(), _ActivityDataSubmission_segmentConfiguration = new WeakMap(), _ActivityDataSubmission_facility = new WeakMap(), _ActivityDataSubmission_filledByStakeholder = new WeakMap(), _ActivityDataSubmission_fieldResponses = new WeakMap(), _ActivityDataSubmission_periodStart = new WeakMap(), _ActivityDataSubmission_periodEnd = new WeakMap(), _ActivityDataSubmission_overallUncertaintyPercentage = new WeakMap(), _ActivityDataSubmission_uncertaintySource = new WeakMap(), _ActivityDataSubmission_dataQualityNotes = new WeakMap(), _ActivityDataSubmission_reportingStandard = new WeakMap(), _ActivityDataSubmission_emissionScope = new WeakMap(), _ActivityDataSubmission_subScope = new WeakMap(), _ActivityDataSubmission_status = new WeakMap(), _ActivityDataSubmission_submittedAt = new WeakMap(), _ActivityDataSubmission_approvedAt = new WeakMap(), _ActivityDataSubmission_rejectedAt = new WeakMap(), _ActivityDataSubmission_rejectionReason = new WeakMap(), _ActivityDataSubmission_statusHistory = new WeakMap(), _ActivityDataSubmission_evidences = new WeakMap(), _ActivityDataSubmission_instances = new WeakSet(), _ActivityDataSubmission_withStatusChange = function _ActivityDataSubmission_withStatusChange(status, changedAt, changedByStakeholder, reason, changes) {
+    const statusHistory = __classPrivateFieldGet(this, _ActivityDataSubmission_statusHistory, "f").append({
+        status,
+        changedByStakeholder,
+        changedAt,
+        reason,
+    });
+    return _a.create({
+        ...__classPrivateFieldGet(this, _ActivityDataSubmission_instances, "m", _ActivityDataSubmission_toProps).call(this),
+        ...changes,
+        status,
+        statusHistory: statusHistory.toPrimitives(),
+    });
+}, _ActivityDataSubmission_toProps = function _ActivityDataSubmission_toProps() {
+    const primitives = this.toPrimitives;
+    return {
+        id: primitives.id,
+        dynamicFormCode: primitives.dynamicFormCode,
+        carbonClient: primitives.carbonClient,
+        footprintType: primitives.footprintType,
+        country: primitives.country,
+        footprintConfiguration: primitives.footprintConfiguration,
+        segmentConfiguration: primitives.segmentConfiguration,
+        facility: primitives.facility,
+        filledByStakeholder: primitives.filledByStakeholder,
+        fieldResponses: primitives.fieldResponses,
+        periodStart: primitives.periodStart,
+        periodEnd: primitives.periodEnd,
+        overallUncertaintyPercentage: primitives.overallUncertaintyPercentage,
+        uncertaintySource: primitives.uncertaintySource,
+        dataQualityNotes: primitives.dataQualityNotes,
+        reportingStandard: primitives.reportingStandard,
+        emissionScope: primitives.emissionScope,
+        subScope: primitives.subScope,
+        status: primitives.status,
+        submittedAt: primitives.submittedAt,
+        approvedAt: primitives.approvedAt,
+        rejectedAt: primitives.rejectedAt,
+        rejectionReason: primitives.rejectionReason,
+        statusHistory: primitives.statusHistory,
+        evidences: primitives.evidences,
+    };
+}, _ActivityDataSubmission_guardAgainstInvalidTransitionTo = function _ActivityDataSubmission_guardAgainstInvalidTransitionTo(targetStatus, action) {
+    if (__classPrivateFieldGet(this, _ActivityDataSubmission_status, "f").canTransitionTo(targetStatus) === false) {
+        throw ActivityDataSubmissionInvalidStatusTransitionError_1.ActivityDataSubmissionInvalidStatusTransitionError.create(__classPrivateFieldGet(this, _ActivityDataSubmission_status, "f").toEnum(), action);
+    }
+}, _ActivityDataSubmission_guardAgainstStatusOutside = function _ActivityDataSubmission_guardAgainstStatusOutside(allowedStatuses, action) {
+    if (allowedStatuses.includes(__classPrivateFieldGet(this, _ActivityDataSubmission_status, "f").toEnum()) === false) {
+        throw ActivityDataSubmissionInvalidStatusTransitionError_1.ActivityDataSubmissionInvalidStatusTransitionError.create(__classPrivateFieldGet(this, _ActivityDataSubmission_status, "f").toEnum(), action);
+    }
+}, _ActivityDataSubmission_guardAgainstStatusDifferentFromLastChange = function _ActivityDataSubmission_guardAgainstStatusDifferentFromLastChange() {
+    const expectedStatus = __classPrivateFieldGet(this, _ActivityDataSubmission_statusHistory, "f").currentStatus();
+    if (expectedStatus !== __classPrivateFieldGet(this, _ActivityDataSubmission_status, "f").toEnum()) {
+        throw InvalidPropertyValueError_1.InvalidPropertyValueError.create('status', `the status of the last history entry (${expectedStatus})`, __classPrivateFieldGet(this, _ActivityDataSubmission_status, "f").toEnum());
+    }
+};
+ActivityDataSubmission.EVIDENCE_ADDABLE_STATUSES = [
+    SubmissionStatus_1.SubmissionStatus.DRAFT,
+    SubmissionStatus_1.SubmissionStatus.SUBMITTED,
+    SubmissionStatus_1.SubmissionStatus.APPROVED,
+    SubmissionStatus_1.SubmissionStatus.REJECTED,
+];
+ActivityDataSubmission.EVIDENCE_REMOVABLE_STATUSES = [
+    SubmissionStatus_1.SubmissionStatus.DRAFT,
+    SubmissionStatus_1.SubmissionStatus.REJECTED,
+];

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/enums/SubmissionEvidenceContentType.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmissionEvidenceContentType = void 0;
+/**
+ * Content types an evidence (supporting document) of an activity data submission can have
+ * (AUD-D21): PDF, images, Excel workbooks (xlsx) and CSV. Values are the canonical MIME types.
+ *
+ * Browsers do not always report the canonical type (a CSV can arrive as
+ * `application/vnd.ms-excel` on Windows): the client derives it from the file extension before
+ * requesting the upload, and the domain rejects anything else.
+ */
+var SubmissionEvidenceContentType;
+(function (SubmissionEvidenceContentType) {
+    SubmissionEvidenceContentType["PDF"] = "application/pdf";
+    SubmissionEvidenceContentType["JPEG"] = "image/jpeg";
+    SubmissionEvidenceContentType["PNG"] = "image/png";
+    SubmissionEvidenceContentType["WEBP"] = "image/webp";
+    SubmissionEvidenceContentType["HEIC"] = "image/heic";
+    SubmissionEvidenceContentType["XLSX"] = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    SubmissionEvidenceContentType["CSV"] = "text/csv";
+})(SubmissionEvidenceContentType || (exports.SubmissionEvidenceContentType = SubmissionEvidenceContentType = {}));

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/ActivityDataSubmissionEvidenceContentTypeNotAllowedError.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceContentTypeNotAllowedError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+const SubmissionEvidenceContentType_1 = require("../enums/SubmissionEvidenceContentType");
+/**
+ * The evidence of an activity data submission has a content type that is not accepted (AUD-D21).
+ * Accepted: PDF, images (JPEG, PNG, WEBP, HEIC), Excel workbooks (xlsx) and CSV.
+ */
+class ActivityDataSubmissionEvidenceContentTypeNotAllowedError extends CodedRootError_1.CodedRootError {
+    constructor(receivedContentType) {
+        const allowedContentTypes = Object.values(SubmissionEvidenceContentType_1.SubmissionEvidenceContentType);
+        const technicalMessage = `Evidence content type '${receivedContentType}' is not allowed. Allowed: ${allowedContentTypes.join(', ')}.`;
+        const context = {
+            receivedContentType,
+            allowedContentTypes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Upload the document as PDF, image (JPEG, PNG, WEBP or HEIC), Excel workbook (xlsx) or CSV',
+            'Export legacy spreadsheets (xls) or text documents as xlsx or PDF before uploading',
+        ];
+        super(ErrorCode_1.ErrorCode.ACTIVITY_DATA_SUBMISSION_EVIDENCE_CONTENT_TYPE_NOT_ALLOWED, technicalMessage, context, suggestions);
+        this.name = 'ActivityDataSubmissionEvidenceContentTypeNotAllowedError';
+    }
+    static create(receivedContentType) {
+        return new ActivityDataSubmissionEvidenceContentTypeNotAllowedError(receivedContentType);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ActivityDataSubmissionEvidenceContentTypeNotAllowedError = ActivityDataSubmissionEvidenceContentTypeNotAllowedError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/ActivityDataSubmissionEvidenceLimitReachedError.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceLimitReachedError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * The activity data submission already holds the most evidences it accepts (AUD-D21).
+ */
+class ActivityDataSubmissionEvidenceLimitReachedError extends CodedRootError_1.CodedRootError {
+    constructor(activityDataSubmissionId, maxCount) {
+        const technicalMessage = `Activity data submission '${activityDataSubmissionId}' cannot hold more than ${maxCount} evidences.`;
+        const context = {
+            activityDataSubmissionId,
+            maxCount,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Merge several documents into a single PDF or workbook',
+            'Remove an evidence that is no longer needed (only while the submission is DRAFT or REJECTED)',
+        ];
+        super(ErrorCode_1.ErrorCode.ACTIVITY_DATA_SUBMISSION_EVIDENCE_LIMIT_REACHED, technicalMessage, context, suggestions);
+        this.name = 'ActivityDataSubmissionEvidenceLimitReachedError';
+    }
+    static create(activityDataSubmissionId, maxCount) {
+        return new ActivityDataSubmissionEvidenceLimitReachedError(activityDataSubmissionId, maxCount);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ActivityDataSubmissionEvidenceLimitReachedError = ActivityDataSubmissionEvidenceLimitReachedError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/ActivityDataSubmissionEvidenceNotFoundError.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceNotFoundError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * The activity data submission has no evidence with the given id (AUD-D21).
+ */
+class ActivityDataSubmissionEvidenceNotFoundError extends CodedRootError_1.CodedRootError {
+    constructor(activityDataSubmissionId, evidenceId) {
+        const technicalMessage = `Activity data submission '${activityDataSubmissionId}' has no evidence '${evidenceId}'.`;
+        const context = {
+            activityDataSubmissionId,
+            evidenceId,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Reload the activity data submission to see its current evidences',
+            'The evidence may have been removed already',
+        ];
+        super(ErrorCode_1.ErrorCode.ACTIVITY_DATA_SUBMISSION_EVIDENCE_NOT_FOUND, technicalMessage, context, suggestions);
+        this.name = 'ActivityDataSubmissionEvidenceNotFoundError';
+    }
+    static create(activityDataSubmissionId, evidenceId) {
+        return new ActivityDataSubmissionEvidenceNotFoundError(activityDataSubmissionId, evidenceId);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ActivityDataSubmissionEvidenceNotFoundError = ActivityDataSubmissionEvidenceNotFoundError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/ActivityDataSubmissionEvidenceTooLargeError.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceTooLargeError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * The evidence of an activity data submission is larger than the accepted size (AUD-D21).
+ */
+class ActivityDataSubmissionEvidenceTooLargeError extends CodedRootError_1.CodedRootError {
+    constructor(receivedSizeInBytes, maxSizeInBytes) {
+        const technicalMessage = `Evidence of ${receivedSizeInBytes} bytes exceeds the maximum of ${maxSizeInBytes} bytes.`;
+        const context = {
+            receivedSizeInBytes,
+            maxSizeInBytes,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            `Upload files up to ${Math.floor(maxSizeInBytes / (1024 * 1024))} MB`,
+            'Compress the PDF or lower the resolution of the scan before uploading',
+            'Split a large workbook into one file per period',
+        ];
+        super(ErrorCode_1.ErrorCode.ACTIVITY_DATA_SUBMISSION_EVIDENCE_TOO_LARGE, technicalMessage, context, suggestions);
+        this.name = 'ActivityDataSubmissionEvidenceTooLargeError';
+    }
+    static create(receivedSizeInBytes, maxSizeInBytes) {
+        return new ActivityDataSubmissionEvidenceTooLargeError(receivedSizeInBytes, maxSizeInBytes);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ActivityDataSubmissionEvidenceTooLargeError = ActivityDataSubmissionEvidenceTooLargeError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/exceptions/ActivityDataSubmissionInvalidStatusTransitionError.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionInvalidStatusTransitionError = void 0;
+const CodedRootError_1 = require("../../../../shared/domain/exceptions/CodedRootError");
+const ErrorCode_1 = require("../../../../shared/domain/enums/ErrorCode");
+/**
+ * The action is not allowed in the current status of the activity data submission (AUD-D22): for
+ * example approving a DRAFT, submitting an APPROVED one, or removing an evidence once the data was
+ * submitted.
+ */
+class ActivityDataSubmissionInvalidStatusTransitionError extends CodedRootError_1.CodedRootError {
+    constructor(currentStatus, action) {
+        const technicalMessage = `Cannot ${action} an activity data submission in status ${currentStatus}.`;
+        const context = {
+            currentStatus,
+            action,
+            timestamp: new Date().toISOString(),
+        };
+        const suggestions = [
+            'Reload the activity data submission to see its current status',
+            'DRAFT and REJECTED submissions are submitted; SUBMITTED ones are approved or rejected',
+            'APPROVED and REJECTED submissions are archived; ARCHIVED ones cannot change anymore',
+            'Evidences are removed only while the submission is DRAFT or REJECTED',
+        ];
+        super(ErrorCode_1.ErrorCode.ACTIVITY_DATA_SUBMISSION_INVALID_STATUS_TRANSITION, technicalMessage, context, suggestions);
+        this.name = 'ActivityDataSubmissionInvalidStatusTransitionError';
+    }
+    static create(currentStatus, action) {
+        return new ActivityDataSubmissionInvalidStatusTransitionError(currentStatus, action);
+    }
+    logError() {
+        return `${this.name}: ${this.technicalMessage}`;
+    }
+}
+exports.ActivityDataSubmissionInvalidStatusTransitionError = ActivityDataSubmissionInvalidStatusTransitionError;

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/types/ActivityDataSubmissionEvidence.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/types/ActivityDataSubmissionEvidencePrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/types/ActivityDataSubmissionStatusChange.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/types/ActivityDataSubmissionStatusChangePrimitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/value-objects/ActivityDataSubmissionEvidenceContentType.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceContentType = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const SubmissionEvidenceContentType_1 = require("../enums/SubmissionEvidenceContentType");
+const ActivityDataSubmissionEvidenceContentTypeNotAllowedError_1 = require("../exceptions/ActivityDataSubmissionEvidenceContentTypeNotAllowedError");
+/**
+ * Content type of an evidence file (AUD-D21): one of `SubmissionEvidenceContentType` (PDF, images,
+ * xlsx, csv). Anything else is rejected with ActivityDataSubmissionEvidenceContentTypeNotAllowedError.
+ */
+class ActivityDataSubmissionEvidenceContentType extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ActivityDataSubmissionEvidenceContentType.PROPERTY_NAME);
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, ActivityDataSubmissionEvidenceContentType.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, ActivityDataSubmissionEvidenceContentType.PROPERTY_NAME);
+        if (ActivityDataSubmissionEvidenceContentType.isAllowed(value) === false) {
+            throw ActivityDataSubmissionEvidenceContentTypeNotAllowedError_1.ActivityDataSubmissionEvidenceContentTypeNotAllowedError.create(value);
+        }
+        return new ActivityDataSubmissionEvidenceContentType(value, false);
+    }
+    static fromPrimitives(primitive) {
+        return new ActivityDataSubmissionEvidenceContentType(primitive, true);
+    }
+    /**
+     * Whether a content type is accepted for an evidence (lets the backend check it before issuing an
+     * upload URL).
+     */
+    static isAllowed(value) {
+        return Object.values(SubmissionEvidenceContentType_1.SubmissionEvidenceContentType).includes(value);
+    }
+    isImage() {
+        return this.value.startsWith('image/');
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    toEnum() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionEvidenceContentType = ActivityDataSubmissionEvidenceContentType;
+ActivityDataSubmissionEvidenceContentType.PROPERTY_NAME = 'contentType';

package/build/carbonbox/activity-data-collection/activity-data-submissions/domain/value-objects/ActivityDataSubmissionEvidenceFileName.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceFileName = void 0;
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+const String_1 = require("../../../../shared/domain/value-objects/String");
+/**
+ * Name of the evidence file as the user uploaded it (AUD-D21), shown in the list and used for the
+ * download. A name, not a path: up to 255 characters, without `/` or `\`.
+ */
+class ActivityDataSubmissionEvidenceFileName extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ActivityDataSubmissionEvidenceFileName.PROPERTY_NAME);
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, ActivityDataSubmissionEvidenceFileName.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, ActivityDataSubmissionEvidenceFileName.PROPERTY_NAME);
+        const trimmed = value.trim();
+        if (trimmed.length > ActivityDataSubmissionEvidenceFileName.MAX_LENGTH) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(ActivityDataSubmissionEvidenceFileName.PROPERTY_NAME, `up to ${ActivityDataSubmissionEvidenceFileName.MAX_LENGTH} characters`, `${trimmed.length} characters`);
+        }
+        if (ActivityDataSubmissionEvidenceFileName.PATH_SEPARATOR_REGEX.test(trimmed)) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(ActivityDataSubmissionEvidenceFileName.PROPERTY_NAME, 'a file name without path separators', trimmed);
+        }
+        return new ActivityDataSubmissionEvidenceFileName(trimmed, false);
+    }
+    static fromPrimitives(primitive) {
+        return new ActivityDataSubmissionEvidenceFileName(primitive, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionEvidenceFileName = ActivityDataSubmissionEvidenceFileName;
+ActivityDataSubmissionEvidenceFileName.PROPERTY_NAME = 'fileName';
+ActivityDataSubmissionEvidenceFileName.MAX_LENGTH = 255;
+ActivityDataSubmissionEvidenceFileName.PATH_SEPARATOR_REGEX = /[/\\]/;