@carbonbox/domain 0.54.0 → 0.55.0

package/build/carbonbox/emission-calculation-results/emission-calculations/domain/value-objects/EmissionCalculationCalculationVariableValues.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmissionCalculationCalculationVariableValues = void 0;
+const InvalidPropertyTypeError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyTypeError");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
+const Numeric_1 = require("../../../../shared/domain/value-objects/Numeric");
+const ValueObject_1 = require("../../../../shared/domain/value-objects/ValueObject");
+const CalculationVariableCode_1 = require("../../../../emission-calculation-formulas/calculation-variables/domain/value-objects/CalculationVariableCode");
+const CalculationVariableId_1 = require("../../../../emission-calculation-formulas/calculation-variables/domain/value-objects/CalculationVariableId");
+const CalculationVariableName_1 = require("../../../../emission-calculation-formulas/calculation-variables/domain/value-objects/CalculationVariableName");
+const CalculationVariableResolutionStrategy_1 = require("../../../../emission-calculation-formulas/calculation-variables/domain/value-objects/CalculationVariableResolutionStrategy");
+const CalculationVariableSymbol_1 = require("../../../../emission-calculation-formulas/calculation-variables/domain/value-objects/CalculationVariableSymbol");
+/**
+ * Values the formula variables took in an emission calculation (AUD-D20), in the order of the
+ * formula. With the formula snapshot (`emissionCalculationFormula.expression`) and the EF/GWP of
+ * each GHG emission result, a verifier reproduces the number without reading the current catalog.
+ *
+ * Invariants: each entry is a valid variable reference with a known resolution strategy and a
+ * finite value; a variable (id) and a symbol appear once. Empty only for a formula without
+ * variables.
+ */
+class EmissionCalculationCalculationVariableValues extends ValueObject_1.ValueObject {
+    constructor(value, skipDomainValidation) {
+        super(EmissionCalculationCalculationVariableValues.toPrimitivesArray(value), skipDomainValidation, EmissionCalculationCalculationVariableValues.PROPERTY_NAME, 'AppliedCalculationVariableValuePrimitives[]', { allowNull: false, allowUndefined: false });
+    }
+    static create(value) {
+        EmissionCalculationCalculationVariableValues.guardAgainstInvalidValues(value);
+        return new EmissionCalculationCalculationVariableValues(value, false);
+    }
+    static fromPrimitives(primitives) {
+        return new EmissionCalculationCalculationVariableValues(primitives, true);
+    }
+    static guardAgainstInvalidValues(value) {
+        const propertyName = EmissionCalculationCalculationVariableValues.PROPERTY_NAME;
+        if (Array.isArray(value) === false) {
+            throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(propertyName, 'array of AppliedCalculationVariableValue', typeof value);
+        }
+        value.forEach((entry, index) => {
+            if (entry === null || typeof entry !== 'object' || entry.calculationVariable === null || typeof entry.calculationVariable !== 'object') {
+                throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(`${propertyName}[${index}]`, 'AppliedCalculationVariableValue object', typeof entry);
+            }
+            CalculationVariableId_1.CalculationVariableId.create(entry.calculationVariable.id);
+            CalculationVariableCode_1.CalculationVariableCode.create(entry.calculationVariable.code);
+            CalculationVariableSymbol_1.CalculationVariableSymbol.create(entry.calculationVariable.symbol);
+            CalculationVariableName_1.CalculationVariableName.create(entry.calculationVariable.name);
+            CalculationVariableResolutionStrategy_1.CalculationVariableResolutionStrategy.create(entry.resolutionStrategy);
+            Numeric_1.Numeric.guardAgainstInvalidNumber(entry.value, `${propertyName}[${index}].value`);
+        });
+        EmissionCalculationCalculationVariableValues.guardAgainstDuplicates(value.map((entry) => entry.calculationVariable.id), `${propertyName}.calculationVariable.id`);
+        EmissionCalculationCalculationVariableValues.guardAgainstDuplicates(value.map((entry) => entry.calculationVariable.symbol), `${propertyName}.calculationVariable.symbol`);
+    }
+    static guardAgainstDuplicates(keys, propertyName) {
+        const duplicated = keys.filter((key, index) => keys.indexOf(key) !== index);
+        if (duplicated.length > 0) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(propertyName, 'each variable once', `repeated: ${Array.from(new Set(duplicated)).join(', ')}`);
+        }
+    }
+    static toPrimitivesArray(value) {
+        if (Array.isArray(value) === false) {
+            return value;
+        }
+        return value.map((entry) => ({
+            calculationVariable: {
+                id: entry.calculationVariable.id,
+                code: entry.calculationVariable.code,
+                symbol: entry.calculationVariable.symbol,
+                name: entry.calculationVariable.name,
+            },
+            resolutionStrategy: entry.resolutionStrategy,
+            value: entry.value,
+        }));
+    }
+    /**
+     * The value the variable with the given symbol took, or null when the formula has no such variable.
+     */
+    findValueBySymbol(symbol) {
+        const entry = this.value.find((candidate) => candidate.calculationVariable.symbol === symbol);
+        return entry === undefined ? null : entry.value;
+    }
+    toPrimitives() {
+        return EmissionCalculationCalculationVariableValues.toPrimitivesArray(this.value);
+    }
+}
+exports.EmissionCalculationCalculationVariableValues = EmissionCalculationCalculationVariableValues;
+EmissionCalculationCalculationVariableValues.PROPERTY_NAME = 'calculationVariableValues';

package/build/carbonbox/emission-calculation-results/ghg-emission-results/domain/types/AppliedEmissionFactor.js

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

package/build/carbonbox/emission-calculation-results/ghg-emission-results/domain/types/AppliedEmissionFactorPrimitives.js

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

package/build/carbonbox/emission-calculation-results/ghg-emission-results/domain/types/AppliedGlobalWarmingPotential.js

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

package/build/carbonbox/emission-calculation-results/ghg-emission-results/domain/types/AppliedGlobalWarmingPotentialPrimitives.js

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

package/build/carbonbox/emission-calculation-results/ghg-emission-results/domain/value-objects/GHGEmissionResultEmissionFactor.js

@@ -1,31 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GHGEmissionResultEmissionFactor = void 0;
+const CountryCode_1 = require("../../../../shared/domain/enums/CountryCode");
+const InvalidPropertyTypeError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyTypeError");
+const InvalidPropertyValueError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyValueError");
 const Numeric_1 = require("../../../../shared/domain/value-objects/Numeric");
-class GHGEmissionResultEmissionFactor extends Numeric_1.Numeric {
+const ObjectValueObject_1 = require("../../../../shared/domain/value-objects/ObjectValueObject");
+const EmissionFactorCode_1 = require("../../../../emission-calculation-formulas/emission-factors/domain/value-objects/EmissionFactorCode");
+const EmissionFactorId_1 = require("../../../../emission-calculation-formulas/emission-factors/domain/value-objects/EmissionFactorId");
+/**
+ * Emission factor applied to one greenhouse gas of a calculation (AUD-D20): the factor of the catalog
+ * (id and code), the country of the value applied and the value. A verifier recomputes
+ * `activity × factorValue × GWP` and follows the id to the factor without depending on the current
+ * catalog, which is edited in place.
+ *
+ * `factorValue` can be negative (removals) or zero (the factor declares no value for the gas) and has
+ * no cap on decimals (CAL-006). `country` is the country of the value the calculation took: the
+ * country of the activity, or the country of the fallback value when the factor is not split by
+ * country.
+ */
+class GHGEmissionResultEmissionFactor extends ObjectValueObject_1.ObjectValueObject {
     constructor(value, skipDomainValidation) {
-        super(value, skipDomainValidation, GHGEmissionResultEmissionFactor.PROPERTY_NAME, {
-            allowNegative: true,
-            allowZero: true,
-            allowDecimals: true,
-            // CAL-006: sin cap de decimales (idiom EmissionAggregationTotalCO2Equivalent)
-            // — el factor de emisión usado (p.ej. 0.01923076923…) puede traer muchos
-            // decimales; se persiste como Float.
-            maxDecimalPlaces: Number.POSITIVE_INFINITY,
-            minValue: Number.NEGATIVE_INFINITY,
-            maxValue: Number.POSITIVE_INFINITY,
-        });
+        super({
+            id: value.id,
+            code: value.code,
+            country: value.country,
+            factorValue: value.factorValue,
+        }, skipDomainValidation, GHGEmissionResultEmissionFactor.PROPERTY_NAME, 'AppliedEmissionFactorPrimitives', { allowNull: false, allowUndefined: false });
     }
     static create(value) {
-        Numeric_1.Numeric.guardAgainstInvalidType(value, GHGEmissionResultEmissionFactor.PROPERTY_NAME);
+        GHGEmissionResultEmissionFactor.guardAgainstInvalidAppliedEmissionFactor(value);
         return new GHGEmissionResultEmissionFactor(value, false);
     }
-    static fromPrimitives(primitive) {
-        const value = primitive;
+    static fromPrimitives(primitives) {
+        const value = {
+            id: primitives.id,
+            code: primitives.code,
+            country: primitives.country,
+            factorValue: primitives.factorValue,
+        };
         return new GHGEmissionResultEmissionFactor(value, true);
     }
+    static guardAgainstInvalidAppliedEmissionFactor(value) {
+        if (value === null || value === undefined || typeof value !== 'object') {
+            throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(GHGEmissionResultEmissionFactor.PROPERTY_NAME, 'AppliedEmissionFactor object', typeof value);
+        }
+        EmissionFactorId_1.EmissionFactorId.create(value.id);
+        EmissionFactorCode_1.EmissionFactorCode.create(value.code);
+        if (Object.values(CountryCode_1.CountryCode).includes(value.country) === false) {
+            throw InvalidPropertyValueError_1.InvalidPropertyValueError.create(`${GHGEmissionResultEmissionFactor.PROPERTY_NAME}.country`, 'a value of CountryCode', String(value.country));
+        }
+        Numeric_1.Numeric.guardAgainstInvalidNumber(value.factorValue, `${GHGEmissionResultEmissionFactor.PROPERTY_NAME}.factorValue`);
+    }
+    get id() {
+        return this.value.id;
+    }
+    get code() {
+        return this.value.code;
+    }
+    get country() {
+        return this.value.country;
+    }
+    get factorValue() {
+        return this.value.factorValue;
+    }
+    isFactor(emissionFactorId) {
+        return this.value.id === emissionFactorId;
+    }
     toPrimitives() {
-        return this.value;
+        return {
+            id: this.value.id,
+            code: this.value.code,
+            country: this.value.country,
+            factorValue: this.value.factorValue,
+        };
     }
 }
 exports.GHGEmissionResultEmissionFactor = GHGEmissionResultEmissionFactor;

package/build/carbonbox/emission-calculation-results/ghg-emission-results/domain/value-objects/GHGEmissionResultGlobalWarmingPotential.js

@@ -1,31 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GHGEmissionResultGlobalWarmingPotential = void 0;
+const InvalidPropertyTypeError_1 = require("../../../../shared/domain/exceptions/InvalidPropertyTypeError");
 const Numeric_1 = require("../../../../shared/domain/value-objects/Numeric");
-class GHGEmissionResultGlobalWarmingPotential extends Numeric_1.Numeric {
+const ObjectValueObject_1 = require("../../../../shared/domain/value-objects/ObjectValueObject");
+const GlobalWarmingPotentialId_1 = require("../../../../emission-calculation-formulas/global-warming-potentials/domain/value-objects/GlobalWarmingPotentialId");
+const GlobalWarmingPotentialProtocolVersion_1 = require("../../../../emission-calculation-formulas/global-warming-potentials/domain/value-objects/GlobalWarmingPotentialProtocolVersion");
+const GlobalWarmingPotentialTimeHorizonYears_1 = require("../../../../emission-calculation-formulas/global-warming-potentials/domain/value-objects/GlobalWarmingPotentialTimeHorizonYears");
+/**
+ * Global warming potential applied to one greenhouse gas of a calculation (AUD-D20): the GWP table of
+ * the catalog (id), its protocol version (AR5, AR6...) and time horizon, and the potential applied.
+ * Frozen at calculation time, so the result does not depend on the current catalog.
+ *
+ * `potentialValue` is positive and has no cap on decimals (CAL-006).
+ */
+class GHGEmissionResultGlobalWarmingPotential extends ObjectValueObject_1.ObjectValueObject {
     constructor(value, skipDomainValidation) {
-        super(value, skipDomainValidation, GHGEmissionResultGlobalWarmingPotential.PROPERTY_NAME, {
-            allowNegative: false,
-            allowZero: false,
-            allowDecimals: true,
-            // CAL-006: sin cap de decimales (idiom EmissionAggregationTotalCO2Equivalent)
-            // — el GWP usado se persiste como Float; un GWP fraccionario no debe
-            // reventar la persistencia.
-            maxDecimalPlaces: Number.POSITIVE_INFINITY,
-            minValue: Number.MIN_VALUE, // o 0.0000000001 aprox si no quieres usar MIN_VALUE
-            maxValue: Number.POSITIVE_INFINITY,
-        });
+        super({
+            id: value.id,
+            protocolVersion: value.protocolVersion,
+            timeHorizonYears: value.timeHorizonYears,
+            potentialValue: value.potentialValue,
+        }, skipDomainValidation, GHGEmissionResultGlobalWarmingPotential.PROPERTY_NAME, 'AppliedGlobalWarmingPotentialPrimitives', { allowNull: false, allowUndefined: false });
     }
     static create(value) {
-        Numeric_1.Numeric.guardAgainstInvalidType(value, GHGEmissionResultGlobalWarmingPotential.PROPERTY_NAME);
+        GHGEmissionResultGlobalWarmingPotential.guardAgainstInvalidAppliedGlobalWarmingPotential(value);
         return new GHGEmissionResultGlobalWarmingPotential(value, false);
     }
-    static fromPrimitives(primitive) {
-        const value = primitive;
+    static fromPrimitives(primitives) {
+        const value = {
+            id: primitives.id,
+            protocolVersion: primitives.protocolVersion,
+            timeHorizonYears: primitives.timeHorizonYears,
+            potentialValue: primitives.potentialValue,
+        };
         return new GHGEmissionResultGlobalWarmingPotential(value, true);
     }
+    static guardAgainstInvalidAppliedGlobalWarmingPotential(value) {
+        if (value === null || value === undefined || typeof value !== 'object') {
+            throw InvalidPropertyTypeError_1.InvalidPropertyTypeError.create(GHGEmissionResultGlobalWarmingPotential.PROPERTY_NAME, 'AppliedGlobalWarmingPotential object', typeof value);
+        }
+        GlobalWarmingPotentialId_1.GlobalWarmingPotentialId.create(value.id);
+        GlobalWarmingPotentialProtocolVersion_1.GlobalWarmingPotentialProtocolVersion.create(value.protocolVersion);
+        GlobalWarmingPotentialTimeHorizonYears_1.GlobalWarmingPotentialTimeHorizonYears.create(value.timeHorizonYears);
+        Numeric_1.Numeric.guardAgainstNonPositiveValue(value.potentialValue, `${GHGEmissionResultGlobalWarmingPotential.PROPERTY_NAME}.potentialValue`);
+    }
+    get id() {
+        return this.value.id;
+    }
+    get protocolVersion() {
+        return this.value.protocolVersion;
+    }
+    get timeHorizonYears() {
+        return this.value.timeHorizonYears;
+    }
+    get potentialValue() {
+        return this.value.potentialValue;
+    }
+    isGlobalWarmingPotential(globalWarmingPotentialId) {
+        return this.value.id === globalWarmingPotentialId;
+    }
     toPrimitives() {
-        return this.value;
+        return {
+            id: this.value.id,
+            protocolVersion: this.value.protocolVersion,
+            timeHorizonYears: this.value.timeHorizonYears,
+            potentialValue: this.value.potentialValue,
+        };
     }
 }
 exports.GHGEmissionResultGlobalWarmingPotential = GHGEmissionResultGlobalWarmingPotential;

package/build/carbonbox/shared/domain/enums/ErrorCode.js

@@ -131,6 +131,12 @@ var ErrorCode;
     ErrorCode["UNKNOWN_CONDITIONAL_ACTION_CATEGORY"] = "CBX-ADC-022";
     // Activity Data Submission facility attribution (CBX-ADC-023)
     ErrorCode["INVALID_SUBMISSION_FACILITY"] = "CBX-ADC-023";
+    // Activity Data Submission status history and evidences (CBX-ADC-024 to CBX-ADC-028) — AUD-D21/AUD-D22
+    ErrorCode["ACTIVITY_DATA_SUBMISSION_INVALID_STATUS_TRANSITION"] = "CBX-ADC-024";
+    ErrorCode["ACTIVITY_DATA_SUBMISSION_EVIDENCE_CONTENT_TYPE_NOT_ALLOWED"] = "CBX-ADC-025";
+    ErrorCode["ACTIVITY_DATA_SUBMISSION_EVIDENCE_TOO_LARGE"] = "CBX-ADC-026";
+    ErrorCode["ACTIVITY_DATA_SUBMISSION_EVIDENCE_LIMIT_REACHED"] = "CBX-ADC-027";
+    ErrorCode["ACTIVITY_DATA_SUBMISSION_EVIDENCE_NOT_FOUND"] = "CBX-ADC-028";
     // Emission Calculation Errors (CBX-EMC-XXX)
     ErrorCode["CALCULATION_FAILED"] = "CBX-EMC-001";
     ErrorCode["MISSING_EMISSION_FACTOR"] = "CBX-EMC-002";

package/build/carbonbox/shared/domain/enums/SemanticUuidPrefix.js

@@ -23,6 +23,7 @@ var SemanticUuidPrefix;
     SemanticUuidPrefix["STC"] = "STC";
     // Activity Data Collection
     SemanticUuidPrefix["ADC_SUBMISSIONS"] = "ADC-SUB";
+    SemanticUuidPrefix["ADC_SUBMISSION_EVIDENCES"] = "ADC-SUB-EVD";
     SemanticUuidPrefix["ADC_FIELDS"] = "ADC-FLD";
     SemanticUuidPrefix["ADC_LOGIC"] = "ADC-LOG";
     SemanticUuidPrefix["ADC_LABELS"] = "ADC-LBL";

package/build/carbonbox/stakeholders/shared/domain/constants/CARBON_AUDITOR_PERMISSION_CEILING.js

@@ -49,7 +49,9 @@ exports.CARBON_AUDITOR_PERMISSION_CEILING = [
     Permission_1.Permission.ACTIVITY_DATA_COLLECTION_VIEW_ACTIVITY_DATA_SUBMISSION,
     Permission_1.Permission.ACTIVITY_DATA_COLLECTION_VIEW_ACTIVITY_DATA_SUBMISSION_LIST,
     Permission_1.Permission.ACTIVITY_DATA_COLLECTION_VIEW_COLLECTION_FIELD,
+    Permission_1.Permission.ACTIVITY_DATA_COLLECTION_VIEW_COLLECTION_FIELD_LIST,
     Permission_1.Permission.ACTIVITY_DATA_COLLECTION_VIEW_DYNAMIC_FORM,
+    Permission_1.Permission.ACTIVITY_DATA_COLLECTION_VIEW_DYNAMIC_FORM_LIST,
     // === Emission Calculation Process (read) ===
     Permission_1.Permission.EMISSION_CALCULATION_PROCESS_VIEW_CALCULATION_PROCESS,
     Permission_1.Permission.EMISSION_CALCULATION_PROCESS_VIEW_CALCULATION_PROCESS_LIST,