@carbonbox/domain 0.54.0 → 0.56.0

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceId = void 0;
+const AggregateId_1 = require("../../../../shared/domain/value-objects/AggregateId");
+const SemanticUuidPrefix_1 = require("../../../../shared/domain/enums/SemanticUuidPrefix");
+const InvalidAggregatePrefixError_1 = require("../../../../shared/domain/exceptions/InvalidAggregatePrefixError");
+/**
+ * Id of an evidence (supporting document) of an activity data submission (`ADC-SUB-EVD_<id>`,
+ * AUD-D21). The caller generates it, like every aggregate id.
+ */
+class ActivityDataSubmissionEvidenceId extends AggregateId_1.AggregateId {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ActivityDataSubmissionEvidenceId.PROPERTY_NAME);
+    }
+    static create(value) {
+        AggregateId_1.AggregateId.guardAgainstEmptyValue(value, ActivityDataSubmissionEvidenceId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidType(value, ActivityDataSubmissionEvidenceId.PROPERTY_NAME);
+        AggregateId_1.AggregateId.guardAgainstInvalidId(value, ActivityDataSubmissionEvidenceId.PROPERTY_NAME);
+        ActivityDataSubmissionEvidenceId.guardAgainstInvalidPrefix(value);
+        return new ActivityDataSubmissionEvidenceId(value, false);
+    }
+    static guardAgainstInvalidPrefix(value) {
+        const prefix = new ActivityDataSubmissionEvidenceId(value, true).extractPrefix();
+        if (ActivityDataSubmissionEvidenceId.VALID_PREFIXES.includes(prefix) === false) {
+            throw InvalidAggregatePrefixError_1.InvalidAggregatePrefixError.create(value, 'ActivityDataSubmissionEvidence', prefix, ActivityDataSubmissionEvidenceId.VALID_PREFIXES, ActivityDataSubmissionEvidenceId.PROPERTY_NAME);
+        }
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ActivityDataSubmissionEvidenceId(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionEvidenceId = ActivityDataSubmissionEvidenceId;
+ActivityDataSubmissionEvidenceId.PROPERTY_NAME = 'evidenceId';
+ActivityDataSubmissionEvidenceId.VALID_PREFIXES = [
+    SemanticUuidPrefix_1.SemanticUuidPrefix.ADC_SUBMISSION_EVIDENCES,
+];

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceSizeInBytes = void 0;
+const PositiveInteger_1 = require("../../../../shared/domain/value-objects/PositiveInteger");
+const ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES_1 = require("../constants/ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES");
+const ActivityDataSubmissionEvidenceTooLargeError_1 = require("../exceptions/ActivityDataSubmissionEvidenceTooLargeError");
+/**
+ * Size of an evidence file in bytes (AUD-D21): an integer from 1 to
+ * ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES (25 MiB). Larger files are rejected with
+ * ActivityDataSubmissionEvidenceTooLargeError.
+ */
+class ActivityDataSubmissionEvidenceSizeInBytes extends PositiveInteger_1.PositiveInteger {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ActivityDataSubmissionEvidenceSizeInBytes.PROPERTY_NAME);
+    }
+    static create(value) {
+        PositiveInteger_1.PositiveInteger.guardAgainstInvalidType(value, ActivityDataSubmissionEvidenceSizeInBytes.PROPERTY_NAME);
+        PositiveInteger_1.PositiveInteger.guardAgainstNegativeValue(value, ActivityDataSubmissionEvidenceSizeInBytes.PROPERTY_NAME);
+        PositiveInteger_1.PositiveInteger.guardAgainstZeroValue(value, ActivityDataSubmissionEvidenceSizeInBytes.PROPERTY_NAME);
+        if (value > ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES_1.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES) {
+            throw ActivityDataSubmissionEvidenceTooLargeError_1.ActivityDataSubmissionEvidenceTooLargeError.create(value, ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES_1.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_SIZE_IN_BYTES);
+        }
+        return new ActivityDataSubmissionEvidenceSizeInBytes(value, false);
+    }
+    static fromPrimitives(primitive) {
+        return new ActivityDataSubmissionEvidenceSizeInBytes(primitive, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionEvidenceSizeInBytes = ActivityDataSubmissionEvidenceSizeInBytes;
+ActivityDataSubmissionEvidenceSizeInBytes.PROPERTY_NAME = 'sizeInBytes';

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceStorageObjectKey = void 0;
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+const String_1 = require("../../../../shared/domain/value-objects/String");
+/**
+ * Key of the evidence file in the object storage (AUD-D21). The backend builds it when it issues
+ * the upload URL; the domain only requires a non-empty key of up to 1024 characters.
+ */
+class ActivityDataSubmissionEvidenceStorageObjectKey extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ActivityDataSubmissionEvidenceStorageObjectKey.PROPERTY_NAME);
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, ActivityDataSubmissionEvidenceStorageObjectKey.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, ActivityDataSubmissionEvidenceStorageObjectKey.PROPERTY_NAME);
+        if (value.length > ActivityDataSubmissionEvidenceStorageObjectKey.MAX_LENGTH) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(ActivityDataSubmissionEvidenceStorageObjectKey.PROPERTY_NAME, `up to ${ActivityDataSubmissionEvidenceStorageObjectKey.MAX_LENGTH} characters`, `${value.length} characters`);
+        }
+        return new ActivityDataSubmissionEvidenceStorageObjectKey(value, false);
+    }
+    static fromPrimitives(primitive) {
+        return new ActivityDataSubmissionEvidenceStorageObjectKey(primitive, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionEvidenceStorageObjectKey = ActivityDataSubmissionEvidenceStorageObjectKey;
+ActivityDataSubmissionEvidenceStorageObjectKey.PROPERTY_NAME = 'storageObjectKey';
+ActivityDataSubmissionEvidenceStorageObjectKey.MAX_LENGTH = 1024;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceUploadedAt = void 0;
+const DateTimeString_1 = require("../../../../shared/domain/value-objects/DateTimeString");
+/**
+ * Moment an evidence was uploaded (`DD/MM/YYYY HH:mm:ss`, AUD-D21). The caller passes it.
+ */
+class ActivityDataSubmissionEvidenceUploadedAt extends DateTimeString_1.DateTimeString {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ActivityDataSubmissionEvidenceUploadedAt.PROPERTY_NAME);
+    }
+    static create(value) {
+        DateTimeString_1.DateTimeString.guardAgainstEmptyValue(value, ActivityDataSubmissionEvidenceUploadedAt.PROPERTY_NAME);
+        DateTimeString_1.DateTimeString.guardAgainstInvalidType(value, ActivityDataSubmissionEvidenceUploadedAt.PROPERTY_NAME);
+        DateTimeString_1.DateTimeString.guardAgainstInvalidDateTimeFormat(value);
+        return new ActivityDataSubmissionEvidenceUploadedAt(value, false);
+    }
+    static fromPrimitives(primitive) {
+        return new ActivityDataSubmissionEvidenceUploadedAt(primitive, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionEvidenceUploadedAt = ActivityDataSubmissionEvidenceUploadedAt;
+ActivityDataSubmissionEvidenceUploadedAt.PROPERTY_NAME = 'uploadedAt';

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

@@ -0,0 +1,54 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _ActivityDataSubmissionEvidenceUploadedByStakeholder_instances, _a, _ActivityDataSubmissionEvidenceUploadedByStakeholder_guardAgainstInvalidRole;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidenceUploadedByStakeholder = void 0;
+const StakeholderReference_1 = require("../../../../shared/domain/value-objects/StakeholderReference");
+const StakeholderRole_1 = require("../../../../shared/domain/enums/StakeholderRole");
+const InvalidActivityDataSubmissionStakeholderRoleError_1 = require("../exceptions/InvalidActivityDataSubmissionStakeholderRoleError");
+/**
+ * Stakeholder who uploaded an evidence of an activity data submission (AUD-D21): the carbon client
+ * side (client, coordinator, manager) or the host. A carbon auditor only reads, so its role is
+ * rejected (InvalidActivityDataSubmissionStakeholderRoleError).
+ */
+class ActivityDataSubmissionEvidenceUploadedByStakeholder extends StakeholderReference_1.StakeholderReference {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, _a.PROPERTY_NAME);
+        _ActivityDataSubmissionEvidenceUploadedByStakeholder_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _ActivityDataSubmissionEvidenceUploadedByStakeholder_instances, "m", _ActivityDataSubmissionEvidenceUploadedByStakeholder_guardAgainstInvalidRole).call(this, value.roleType);
+        }
+    }
+    static create(value) {
+        return new _a(value, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = {
+            id: primitives.id,
+            displayName: primitives.displayName,
+            roleType: primitives.roleType,
+            taxIdentification: primitives.taxIdentification,
+        };
+        return new _a(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionEvidenceUploadedByStakeholder = ActivityDataSubmissionEvidenceUploadedByStakeholder;
+_a = ActivityDataSubmissionEvidenceUploadedByStakeholder, _ActivityDataSubmissionEvidenceUploadedByStakeholder_instances = new WeakSet(), _ActivityDataSubmissionEvidenceUploadedByStakeholder_guardAgainstInvalidRole = function _ActivityDataSubmissionEvidenceUploadedByStakeholder_guardAgainstInvalidRole(roleType) {
+    if (_a.VALID_ROLES.includes(roleType) === false) {
+        throw InvalidActivityDataSubmissionStakeholderRoleError_1.InvalidActivityDataSubmissionStakeholderRoleError.create(roleType, _a.VALID_ROLES);
+    }
+};
+ActivityDataSubmissionEvidenceUploadedByStakeholder.PROPERTY_NAME = 'uploadedByStakeholder';
+ActivityDataSubmissionEvidenceUploadedByStakeholder.VALID_ROLES = [
+    StakeholderRole_1.StakeholderRole.CARBON_CLIENT,
+    StakeholderRole_1.StakeholderRole.CARBON_HOST,
+    StakeholderRole_1.StakeholderRole.CARBON_MANAGER,
+    StakeholderRole_1.StakeholderRole.CARBON_COORDINATOR,
+];

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

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionEvidences = void 0;
+const InvalidPropertyTypeError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyTypeError");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT_1 = require("../constants/ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT");
+const ActivityDataSubmissionEvidenceId_1 = require("./ActivityDataSubmissionEvidenceId");
+const ActivityDataSubmissionEvidenceStorageObjectKey_1 = require("./ActivityDataSubmissionEvidenceStorageObjectKey");
+const ActivityDataSubmissionEvidenceFileName_1 = require("./ActivityDataSubmissionEvidenceFileName");
+const ActivityDataSubmissionEvidenceContentType_1 = require("./ActivityDataSubmissionEvidenceContentType");
+const ActivityDataSubmissionEvidenceSizeInBytes_1 = require("./ActivityDataSubmissionEvidenceSizeInBytes");
+const ActivityDataSubmissionEvidenceUploadedByStakeholder_1 = require("./ActivityDataSubmissionEvidenceUploadedByStakeholder");
+const ActivityDataSubmissionEvidenceUploadedAt_1 = require("./ActivityDataSubmissionEvidenceUploadedAt");
+/**
+ * Evidences (supporting documents) of an activity data submission, in upload order (AUD-D21).
+ * Each one is validated with its own value objects: id, storage key, file name, content type (PDF,
+ * images, xlsx, csv), size (up to 25 MiB) and who uploaded it and when.
+ *
+ * Invariants: at most ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT entries (the aggregate raises
+ * ActivityDataSubmissionEvidenceLimitReachedError when adding one more); ids and storage keys
+ * appear once.
+ */
+class ActivityDataSubmissionEvidences extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(ActivityDataSubmissionEvidences.toPrimitivesArray(value), skipDomainValidation, ActivityDataSubmissionEvidences.PROPERTY_NAME, 'ActivityDataSubmissionEvidencePrimitives[]', { allowNull: false, allowUndefined: false });
+    }
+    static create(value) {
+        ActivityDataSubmissionEvidences.guardAgainstInvalidEvidences(value);
+        const normalized = value.map((evidence) => ({
+            ...evidence,
+            fileName: ActivityDataSubmissionEvidenceFileName_1.ActivityDataSubmissionEvidenceFileName.create(evidence.fileName).toPrimitives(),
+        }));
+        return new ActivityDataSubmissionEvidences(normalized, false);
+    }
+    static fromPrimitives(primitives) {
+        return new ActivityDataSubmissionEvidences(primitives, true);
+    }
+    static guardAgainstInvalidEvidences(value) {
+        const propertyName = ActivityDataSubmissionEvidences.PROPERTY_NAME;
+        if (Array.isArray(value) === false) {
+            throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(propertyName, 'array of ActivityDataSubmissionEvidence', typeof value);
+        }
+        if (value.length > ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT_1.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, `at most ${ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT_1.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT} evidences`, `${value.length} evidences`);
+        }
+        value.forEach((evidence, index) => {
+            if (evidence === null || typeof evidence !== 'object') {
+                throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}[${index}]`, 'ActivityDataSubmissionEvidence object', typeof evidence);
+            }
+            ActivityDataSubmissionEvidenceId_1.ActivityDataSubmissionEvidenceId.create(evidence.id);
+            ActivityDataSubmissionEvidenceStorageObjectKey_1.ActivityDataSubmissionEvidenceStorageObjectKey.create(evidence.storageObjectKey);
+            ActivityDataSubmissionEvidenceFileName_1.ActivityDataSubmissionEvidenceFileName.create(evidence.fileName);
+            ActivityDataSubmissionEvidenceContentType_1.ActivityDataSubmissionEvidenceContentType.create(evidence.contentType);
+            ActivityDataSubmissionEvidenceSizeInBytes_1.ActivityDataSubmissionEvidenceSizeInBytes.create(evidence.sizeInBytes);
+            ActivityDataSubmissionEvidenceUploadedByStakeholder_1.ActivityDataSubmissionEvidenceUploadedByStakeholder.create(evidence.uploadedByStakeholder);
+            ActivityDataSubmissionEvidenceUploadedAt_1.ActivityDataSubmissionEvidenceUploadedAt.create(evidence.uploadedAt);
+        });
+        ActivityDataSubmissionEvidences.guardAgainstDuplicates(value.map((evidence) => evidence.id), `${propertyName}.id`);
+        ActivityDataSubmissionEvidences.guardAgainstDuplicates(value.map((evidence) => evidence.storageObjectKey), `${propertyName}.storageObjectKey`);
+    }
+    static guardAgainstDuplicates(keys, propertyName) {
+        const duplicated = keys.filter((key, index) => keys.indexOf(key) !== index);
+        if (duplicated.length > 0) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'unique values', `repeated: ${Array.from(new Set(duplicated)).join(', ')}`);
+        }
+    }
+    static toPrimitivesArray(value) {
+        if (Array.isArray(value) === false) {
+            return value;
+        }
+        return value.map((evidence) => ({
+            id: evidence.id,
+            storageObjectKey: evidence.storageObjectKey,
+            fileName: evidence.fileName,
+            contentType: evidence.contentType,
+            sizeInBytes: evidence.sizeInBytes,
+            uploadedByStakeholder: {
+                id: evidence.uploadedByStakeholder.id,
+                displayName: evidence.uploadedByStakeholder.displayName,
+                roleType: evidence.uploadedByStakeholder.roleType,
+                taxIdentification: evidence.uploadedByStakeholder.taxIdentification,
+            },
+            uploadedAt: evidence.uploadedAt,
+        }));
+    }
+    count() {
+        return this.value.length;
+    }
+    isFull() {
+        return this.value.length >= ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT_1.ACTIVITY_DATA_SUBMISSION_EVIDENCE_MAX_COUNT;
+    }
+    includes(evidenceId) {
+        return this.value.some((evidence) => evidence.id === evidenceId);
+    }
+    /**
+     * The evidence with the given id, or null when the submission does not have it.
+     */
+    findById(evidenceId) {
+        const evidence = this.value.find((candidate) => candidate.id === evidenceId);
+        return evidence === undefined ? null : ActivityDataSubmissionEvidences.toPrimitivesArray([evidence])[0];
+    }
+    toPrimitives() {
+        return ActivityDataSubmissionEvidences.toPrimitivesArray(this.value);
+    }
+}
+exports.ActivityDataSubmissionEvidences = ActivityDataSubmissionEvidences;
+ActivityDataSubmissionEvidences.PROPERTY_NAME = 'evidences';

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionStatusChangedAt = void 0;
+const DateTimeString_1 = require("../../../../shared/domain/value-objects/DateTimeString");
+/**
+ * Moment of a status change of an activity data submission (`DD/MM/YYYY HH:mm:ss`, AUD-D22). The
+ * domain does not read the clock: the caller passes the current moment to each transition.
+ */
+class ActivityDataSubmissionStatusChangedAt extends DateTimeString_1.DateTimeString {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ActivityDataSubmissionStatusChangedAt.PROPERTY_NAME);
+    }
+    static create(value) {
+        DateTimeString_1.DateTimeString.guardAgainstEmptyValue(value, ActivityDataSubmissionStatusChangedAt.PROPERTY_NAME);
+        DateTimeString_1.DateTimeString.guardAgainstInvalidType(value, ActivityDataSubmissionStatusChangedAt.PROPERTY_NAME);
+        DateTimeString_1.DateTimeString.guardAgainstInvalidDateTimeFormat(value);
+        return new ActivityDataSubmissionStatusChangedAt(value, false);
+    }
+    static fromPrimitives(primitive) {
+        return new ActivityDataSubmissionStatusChangedAt(primitive, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionStatusChangedAt = ActivityDataSubmissionStatusChangedAt;
+ActivityDataSubmissionStatusChangedAt.PROPERTY_NAME = 'changedAt';

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

@@ -0,0 +1,54 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _ActivityDataSubmissionStatusChangedByStakeholder_instances, _a, _ActivityDataSubmissionStatusChangedByStakeholder_guardAgainstInvalidRole;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionStatusChangedByStakeholder = void 0;
+const StakeholderReference_1 = require("../../../../shared/domain/value-objects/StakeholderReference");
+const StakeholderRole_1 = require("../../../../shared/domain/enums/StakeholderRole");
+const InvalidActivityDataSubmissionStakeholderRoleError_1 = require("../exceptions/InvalidActivityDataSubmissionStakeholderRoleError");
+/**
+ * Stakeholder who changed the status of an activity data submission (AUD-D22): the carbon client
+ * side (client, coordinator, manager) or the host. A carbon auditor only reads, so its role is
+ * rejected (InvalidActivityDataSubmissionStakeholderRoleError).
+ */
+class ActivityDataSubmissionStatusChangedByStakeholder extends StakeholderReference_1.StakeholderReference {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, _a.PROPERTY_NAME);
+        _ActivityDataSubmissionStatusChangedByStakeholder_instances.add(this);
+        if (skipDomainValidation === false) {
+            __classPrivateFieldGet(this, _ActivityDataSubmissionStatusChangedByStakeholder_instances, "m", _ActivityDataSubmissionStatusChangedByStakeholder_guardAgainstInvalidRole).call(this, value.roleType);
+        }
+    }
+    static create(value) {
+        return new _a(value, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = {
+            id: primitives.id,
+            displayName: primitives.displayName,
+            roleType: primitives.roleType,
+            taxIdentification: primitives.taxIdentification,
+        };
+        return new _a(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ActivityDataSubmissionStatusChangedByStakeholder = ActivityDataSubmissionStatusChangedByStakeholder;
+_a = ActivityDataSubmissionStatusChangedByStakeholder, _ActivityDataSubmissionStatusChangedByStakeholder_instances = new WeakSet(), _ActivityDataSubmissionStatusChangedByStakeholder_guardAgainstInvalidRole = function _ActivityDataSubmissionStatusChangedByStakeholder_guardAgainstInvalidRole(roleType) {
+    if (_a.VALID_ROLES.includes(roleType) === false) {
+        throw InvalidActivityDataSubmissionStakeholderRoleError_1.InvalidActivityDataSubmissionStakeholderRoleError.create(roleType, _a.VALID_ROLES);
+    }
+};
+ActivityDataSubmissionStatusChangedByStakeholder.PROPERTY_NAME = 'changedByStakeholder';
+ActivityDataSubmissionStatusChangedByStakeholder.VALID_ROLES = [
+    StakeholderRole_1.StakeholderRole.CARBON_CLIENT,
+    StakeholderRole_1.StakeholderRole.CARBON_HOST,
+    StakeholderRole_1.StakeholderRole.CARBON_MANAGER,
+    StakeholderRole_1.StakeholderRole.CARBON_COORDINATOR,
+];

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityDataSubmissionStatusHistory = void 0;
+const InvalidPropertyTypeError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyTypeError");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const SubmissionStatus_1 = require("../enums/SubmissionStatus");
+const ActivityDataSubmissionStatus_1 = require("./ActivityDataSubmissionStatus");
+const ActivityDataSubmissionStatusChangedAt_1 = require("./ActivityDataSubmissionStatusChangedAt");
+const ActivityDataSubmissionStatusChangedByStakeholder_1 = require("./ActivityDataSubmissionStatusChangedByStakeholder");
+/**
+ * Status history of an activity data submission, oldest first (AUD-D22): one entry per submit,
+ * approval, rejection and archive, with who and when. Empty while the submission was never
+ * submitted (a DRAFT); the creation is not a change.
+ *
+ * Invariants: the sequence starts at DRAFT and every entry is a valid transition of
+ * `ActivityDataSubmissionStatus` (DRAFT → SUBMITTED → APPROVED | REJECTED, REJECTED → SUBMITTED,
+ * APPROVED | REJECTED → ARCHIVED); every moment is a valid datetime; a rejection carries its reason
+ * and reasons are up to 1000 characters.
+ */
+class ActivityDataSubmissionStatusHistory extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(ActivityDataSubmissionStatusHistory.toPrimitivesArray(value), skipDomainValidation, ActivityDataSubmissionStatusHistory.PROPERTY_NAME, 'ActivityDataSubmissionStatusChangePrimitives[]', { allowNull: false, allowUndefined: false });
+    }
+    static create(value) {
+        ActivityDataSubmissionStatusHistory.guardAgainstInvalidHistory(value);
+        return new ActivityDataSubmissionStatusHistory(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new ActivityDataSubmissionStatusHistory(primitives, true);
+    }
+    static guardAgainstInvalidHistory(value) {
+        const propertyName = ActivityDataSubmissionStatusHistory.PROPERTY_NAME;
+        if (Array.isArray(value) === false) {
+            throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(propertyName, 'array of ActivityDataSubmissionStatusChange', typeof value);
+        }
+        value.reduce((previousStatus, change, index) => {
+            if (change === null || typeof change !== 'object') {
+                throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}[${index}]`, 'ActivityDataSubmissionStatusChange object', typeof change);
+            }
+            const previous = ActivityDataSubmissionStatus_1.ActivityDataSubmissionStatus.fromPrimitives(previousStatus);
+            const status = ActivityDataSubmissionStatus_1.ActivityDataSubmissionStatus.create(change.status).toEnum();
+            if (previous.canTransitionTo(status) === false) {
+                throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(`${propertyName}[${index}].status`, `a status reachable from ${previousStatus} (${previous.getValidTransitions().join(', ') || 'none'})`, status);
+            }
+            ActivityDataSubmissionStatusChangedAt_1.ActivityDataSubmissionStatusChangedAt.create(change.changedAt);
+            ActivityDataSubmissionStatusChangedByStakeholder_1.ActivityDataSubmissionStatusChangedByStakeholder.create(change.changedByStakeholder);
+            ActivityDataSubmissionStatusHistory.guardAgainstInvalidReason(change.status, change.reason, index);
+            return status;
+        }, SubmissionStatus_1.SubmissionStatus.DRAFT);
+    }
+    static guardAgainstInvalidReason(status, reason, index) {
+        const propertyName = `${ActivityDataSubmissionStatusHistory.PROPERTY_NAME}[${index}].reason`;
+        if (reason === null) {
+            if (status === SubmissionStatus_1.SubmissionStatus.REJECTED) {
+                throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'the reason of the rejection', 'null');
+            }
+            return;
+        }
+        if (typeof reason !== 'string' || reason.trim() === '') {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'a non-empty text or null', String(reason));
+        }
+        if (reason.trim().length > ActivityDataSubmissionStatusHistory.REASON_MAX_LENGTH) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, `up to ${ActivityDataSubmissionStatusHistory.REASON_MAX_LENGTH} characters`, `${reason.trim().length} characters`);
+        }
+    }
+    static toPrimitivesArray(value) {
+        if (Array.isArray(value) === false) {
+            return value;
+        }
+        return value.map((change) => ({
+            status: change.status,
+            changedByStakeholder: {
+                id: change.changedByStakeholder.id,
+                displayName: change.changedByStakeholder.displayName,
+                roleType: change.changedByStakeholder.roleType,
+                taxIdentification: change.changedByStakeholder.taxIdentification,
+            },
+            changedAt: change.changedAt,
+            reason: change.reason,
+        }));
+    }
+    /**
+     * Returns the history with one more entry at the end (the history never changes in place).
+     */
+    append(change) {
+        return ActivityDataSubmissionStatusHistory.create([
+            ...this.toPrimitives(),
+            { ...change, reason: change.reason === null ? null : change.reason.trim() },
+        ]);
+    }
+    /**
+     * The status of the last entry, or DRAFT when the submission was never submitted.
+     */
+    currentStatus() {
+        return this.value.length === 0 ? SubmissionStatus_1.SubmissionStatus.DRAFT : this.value[this.value.length - 1].status;
+    }
+    /**
+     * The last change to the given status (who approved it last, for example), or null.
+     */
+    findLastChangeTo(status) {
+        const changes = this.value.filter((change) => change.status === status);
+        return changes.length === 0 ? null : ActivityDataSubmissionStatusHistory.toPrimitivesArray([changes[changes.length - 1]])[0];
+    }
+    isEmpty() {
+        return this.value.length === 0;
+    }
+    toPrimitives() {
+        return ActivityDataSubmissionStatusHistory.toPrimitivesArray(this.value);
+    }
+}
+exports.ActivityDataSubmissionStatusHistory = ActivityDataSubmissionStatusHistory;
+ActivityDataSubmissionStatusHistory.PROPERTY_NAME = 'statusHistory';
+ActivityDataSubmissionStatusHistory.REASON_MAX_LENGTH = 1000;

package/build/carbonbox/carbon-footprint-audits/audit-findings/domain/enums/AuditFindingSubjectType.js

@@ -32,6 +32,14 @@ var AuditFindingSubjectType;
      * An emission factor used by the calculations
      */
     AuditFindingSubjectType["EMISSION_FACTOR"] = "EMISSION_FACTOR";
+    /**
+     * A calculation variable of a formula used by the calculations (its value or how it is resolved)
+     */
+    AuditFindingSubjectType["CALCULATION_VARIABLE"] = "CALCULATION_VARIABLE";
+    /**
+     * A global warming potential table used by the calculations (protocol version, horizon or value)
+     */
+    AuditFindingSubjectType["GLOBAL_WARMING_POTENTIAL"] = "GLOBAL_WARMING_POTENTIAL";
     /**
      * An emission calculation formula used by the calculations
      */

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/entity/EmissionCalculation.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 _EmissionCalculation_activityDataSubmission, _EmissionCalculation_emissionCalculationFormula, _EmissionCalculation_emissionSource, _EmissionCalculation_carbonClient, _EmissionCalculation_footprintConfiguration, _EmissionCalculation_calculatedAt, _EmissionCalculation_calculatedByStakeholder, _EmissionCalculation_activityDataUncertainty, _EmissionCalculation_emissionFactorUncertainty, _EmissionCalculation_combinedUncertainty, _EmissionCalculation_status, _EmissionCalculation_errorMessage, _EmissionCalculation_calculationNotes, _EmissionCalculation_dimensions;
+var _EmissionCalculation_activityDataSubmission, _EmissionCalculation_emissionCalculationFormula, _EmissionCalculation_calculationVariableValues, _EmissionCalculation_emissionSource, _EmissionCalculation_carbonClient, _EmissionCalculation_footprintConfiguration, _EmissionCalculation_calculatedAt, _EmissionCalculation_calculatedByStakeholder, _EmissionCalculation_activityDataUncertainty, _EmissionCalculation_emissionFactorUncertainty, _EmissionCalculation_combinedUncertainty, _EmissionCalculation_status, _EmissionCalculation_errorMessage, _EmissionCalculation_calculationNotes, _EmissionCalculation_dimensions;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmissionCalculation = void 0;
 const AggregateRoot_1 = require("../../../../shared/domain/entities/AggregateRoot");
@@ -19,6 +19,7 @@ const EmissionCalculationActivityDataUncertainty_1 = require("../value-objects/E
 const EmissionCalculationCalculatedAt_1 = require("../value-objects/EmissionCalculationCalculatedAt");
 const EmissionCalculationCalculatedByStakeholder_1 = require("../value-objects/EmissionCalculationCalculatedByStakeholder");
 const EmissionCalculationCalculationNotes_1 = require("../value-objects/EmissionCalculationCalculationNotes");
+const EmissionCalculationCalculationVariableValues_1 = require("../value-objects/EmissionCalculationCalculationVariableValues");
 const EmissionCalculationCarbonClient_1 = require("../value-objects/EmissionCalculationCarbonClient");
 const EmissionCalculationCombinedUncertainty_1 = require("../value-objects/EmissionCalculationCombinedUncertainty");
 const EmissionCalculationDimensions_1 = require("../value-objects/EmissionCalculationDimensions");
@@ -37,6 +38,7 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
         super({ id }, skipDomainValidation);
         _EmissionCalculation_activityDataSubmission.set(this, void 0);
         _EmissionCalculation_emissionCalculationFormula.set(this, void 0);
+        _EmissionCalculation_calculationVariableValues.set(this, void 0);
         _EmissionCalculation_emissionSource.set(this, void 0);
         _EmissionCalculation_carbonClient.set(this, void 0);
         _EmissionCalculation_footprintConfiguration.set(this, void 0);
@@ -53,6 +55,7 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
             // Initialize with domain validation
             __classPrivateFieldSet(this, _EmissionCalculation_activityDataSubmission, EmissionCalculationActivityDataSubmission_1.EmissionCalculationActivityDataSubmission.create(props.activityDataSubmission), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_emissionCalculationFormula, EmissionCalculationEmissionCalculationFormula_1.EmissionCalculationEmissionCalculationFormula.create(props.emissionCalculationFormula), "f");
+            __classPrivateFieldSet(this, _EmissionCalculation_calculationVariableValues, EmissionCalculationCalculationVariableValues_1.EmissionCalculationCalculationVariableValues.create(props.calculationVariableValues), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_emissionSource, EmissionCalculationEmissionSource_1.EmissionCalculationEmissionSource.create(props.emissionSource), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_carbonClient, EmissionCalculationCarbonClient_1.EmissionCalculationCarbonClient.create(props.carbonClient), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_footprintConfiguration, EmissionCalculationFootprintConfiguration_1.EmissionCalculationFootprintConfiguration.create(props.footprintConfiguration), "f");
@@ -72,6 +75,7 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
             // Initialize from primitives (no domain validation)
             __classPrivateFieldSet(this, _EmissionCalculation_activityDataSubmission, EmissionCalculationActivityDataSubmission_1.EmissionCalculationActivityDataSubmission.fromPrimitives(props.activityDataSubmission), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_emissionCalculationFormula, EmissionCalculationEmissionCalculationFormula_1.EmissionCalculationEmissionCalculationFormula.fromPrimitives(props.emissionCalculationFormula), "f");
+            __classPrivateFieldSet(this, _EmissionCalculation_calculationVariableValues, EmissionCalculationCalculationVariableValues_1.EmissionCalculationCalculationVariableValues.fromPrimitives(props.calculationVariableValues), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_emissionSource, EmissionCalculationEmissionSource_1.EmissionCalculationEmissionSource.fromPrimitives(props.emissionSource), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_carbonClient, EmissionCalculationCarbonClient_1.EmissionCalculationCarbonClient.fromPrimitives(props.carbonClient), "f");
             __classPrivateFieldSet(this, _EmissionCalculation_footprintConfiguration, EmissionCalculationFootprintConfiguration_1.EmissionCalculationFootprintConfiguration.fromPrimitives(props.footprintConfiguration), "f");
@@ -96,6 +100,7 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
             id: primitives.id,
             activityDataSubmission: primitives.activityDataSubmission,
             emissionCalculationFormula: primitives.emissionCalculationFormula,
+            calculationVariableValues: primitives.calculationVariableValues,
             emissionSource: primitives.emissionSource,
             carbonClient: primitives.carbonClient,
             footprintConfiguration: primitives.footprintConfiguration,
@@ -116,6 +121,7 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
             id: this.id.toPrimitives(),
             activityDataSubmission: __classPrivateFieldGet(this, _EmissionCalculation_activityDataSubmission, "f").toPrimitives(),
             emissionCalculationFormula: __classPrivateFieldGet(this, _EmissionCalculation_emissionCalculationFormula, "f").toPrimitives(),
+            calculationVariableValues: __classPrivateFieldGet(this, _EmissionCalculation_calculationVariableValues, "f").toPrimitives(),
             emissionSource: __classPrivateFieldGet(this, _EmissionCalculation_emissionSource, "f").toEnum(),
             carbonClient: __classPrivateFieldGet(this, _EmissionCalculation_carbonClient, "f").toPrimitives(),
             footprintConfiguration: __classPrivateFieldGet(this, _EmissionCalculation_footprintConfiguration, "f").toPrimitives(),
@@ -136,6 +142,9 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
     get emissionCalculationFormula() {
         return __classPrivateFieldGet(this, _EmissionCalculation_emissionCalculationFormula, "f");
     }
+    get calculationVariableValues() {
+        return __classPrivateFieldGet(this, _EmissionCalculation_calculationVariableValues, "f");
+    }
     get emissionSource() {
         return __classPrivateFieldGet(this, _EmissionCalculation_emissionSource, "f");
     }
@@ -174,4 +183,4 @@ class EmissionCalculation extends AggregateRoot_1.AggregateRoot {
     }
 }
 exports.EmissionCalculation = EmissionCalculation;
-_EmissionCalculation_activityDataSubmission = new WeakMap(), _EmissionCalculation_emissionCalculationFormula = new WeakMap(), _EmissionCalculation_emissionSource = new WeakMap(), _EmissionCalculation_carbonClient = new WeakMap(), _EmissionCalculation_footprintConfiguration = new WeakMap(), _EmissionCalculation_calculatedAt = new WeakMap(), _EmissionCalculation_calculatedByStakeholder = new WeakMap(), _EmissionCalculation_activityDataUncertainty = new WeakMap(), _EmissionCalculation_emissionFactorUncertainty = new WeakMap(), _EmissionCalculation_combinedUncertainty = new WeakMap(), _EmissionCalculation_status = new WeakMap(), _EmissionCalculation_errorMessage = new WeakMap(), _EmissionCalculation_calculationNotes = new WeakMap(), _EmissionCalculation_dimensions = new WeakMap();
+_EmissionCalculation_activityDataSubmission = new WeakMap(), _EmissionCalculation_emissionCalculationFormula = new WeakMap(), _EmissionCalculation_calculationVariableValues = new WeakMap(), _EmissionCalculation_emissionSource = new WeakMap(), _EmissionCalculation_carbonClient = new WeakMap(), _EmissionCalculation_footprintConfiguration = new WeakMap(), _EmissionCalculation_calculatedAt = new WeakMap(), _EmissionCalculation_calculatedByStakeholder = new WeakMap(), _EmissionCalculation_activityDataUncertainty = new WeakMap(), _EmissionCalculation_emissionFactorUncertainty = new WeakMap(), _EmissionCalculation_combinedUncertainty = new WeakMap(), _EmissionCalculation_status = new WeakMap(), _EmissionCalculation_errorMessage = new WeakMap(), _EmissionCalculation_calculationNotes = new WeakMap(), _EmissionCalculation_dimensions = new WeakMap();

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/types/AppliedCalculationVariableValue.js

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

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/types/AppliedCalculationVariableValuePrimitives.js

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