@carbonbox/domain 0.2.3 → 0.2.4

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogIsAvailableForProduct.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogIsAvailableForProduct = void 0;
+const Boolean_1 = require("../../../../shared/domain/value-objects/Boolean");
+class ServiceCatalogIsAvailableForProduct extends Boolean_1.Boolean {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogIsAvailableForProduct.PROPERTY_NAME);
+    }
+    static create(value) {
+        Boolean_1.Boolean.guardAgainstInvalidType(value, ServiceCatalogIsAvailableForProduct.PROPERTY_NAME);
+        return new ServiceCatalogIsAvailableForProduct(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogIsAvailableForProduct(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogIsAvailableForProduct = ServiceCatalogIsAvailableForProduct;
+ServiceCatalogIsAvailableForProduct.PROPERTY_NAME = 'isAvailableForProduct';

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogIsRequiredService.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogIsRequiredService = void 0;
+const Boolean_1 = require("../../../../shared/domain/value-objects/Boolean");
+class ServiceCatalogIsRequiredService extends Boolean_1.Boolean {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogIsRequiredService.PROPERTY_NAME);
+    }
+    static create(value) {
+        Boolean_1.Boolean.guardAgainstInvalidType(value, ServiceCatalogIsRequiredService.PROPERTY_NAME);
+        return new ServiceCatalogIsRequiredService(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogIsRequiredService(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogIsRequiredService = ServiceCatalogIsRequiredService;
+ServiceCatalogIsRequiredService.PROPERTY_NAME = 'isRequiredService';

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogMaxUsers.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogMaxUsers = void 0;
+const NullableNumeric_1 = require("../../../../shared/domain/value-objects/NullableNumeric");
+class ServiceCatalogMaxUsers extends NullableNumeric_1.NullableNumeric {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogMaxUsers.PROPERTY_NAME, ServiceCatalogMaxUsers.MAX_USERS_OPTIONS);
+    }
+    static create(value) {
+        return new ServiceCatalogMaxUsers(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogMaxUsers(value, true);
+    }
+    /**
+     * Verifica si no permite usuarios adicionales.
+     */
+    allowsNoAdditionalUsers() {
+        if (!this.hasValue())
+            return null;
+        return this.value === 0;
+    }
+    /**
+     * Verifica si es un límite bajo de usuarios (1-10).
+     */
+    isLowUserLimit() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 0 && this.value <= 10;
+    }
+    /**
+     * Verifica si es un límite medio de usuarios (11-50).
+     */
+    isMediumUserLimit() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 10 && this.value <= 50;
+    }
+    /**
+     * Verifica si es un límite alto de usuarios (51-200).
+     */
+    isHighUserLimit() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 50 && this.value <= 200;
+    }
+    /**
+     * Verifica si es un límite enterprise de usuarios (>200).
+     */
+    isEnterpriseUserLimit() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 200;
+    }
+    /**
+     * Verifica si permite usuarios adicionales.
+     */
+    allowsAdditionalUsers() {
+        if (!this.hasValue())
+            return null;
+        return this.value > 0;
+    }
+    /**
+     * Verifica si es un servicio de usuario único.
+     */
+    isSingleUser() {
+        if (!this.hasValue())
+            return null;
+        return this.value === 1;
+    }
+    /**
+     * Verifica si requiere licenciamiento especial (límites altos).
+     */
+    requiresSpecialLicensing() {
+        if (!this.hasValue())
+            return null;
+        return this.isEnterpriseUserLimit();
+    }
+    /**
+     * Obtiene la categoría de usuarios.
+     */
+    getUserCategory() {
+        if (!this.hasValue())
+            return null;
+        if (this.allowsNoAdditionalUsers())
+            return 'none';
+        if (this.isSingleUser())
+            return 'single';
+        if (this.isLowUserLimit())
+            return 'small';
+        if (this.isMediumUserLimit())
+            return 'medium';
+        if (this.isHighUserLimit())
+            return 'large';
+        if (this.isEnterpriseUserLimit())
+            return 'enterprise';
+        return null;
+    }
+    /**
+     * Obtiene el tipo de plan según el número de usuarios.
+     */
+    getPlanType() {
+        if (!this.hasValue())
+            return null;
+        if (this.value <= 10)
+            return 'basic';
+        if (this.value <= 50)
+            return 'standard';
+        if (this.value <= 200)
+            return 'professional';
+        return 'enterprise';
+    }
+    /**
+     * Calcula el costo adicional por usuario (basado en escalas).
+     */
+    calculateUserCost(costPerUser) {
+        if (!this.hasValue())
+            return null;
+        if (costPerUser < 0)
+            return null;
+        return this.value * costPerUser;
+    }
+    /**
+     * Calcula descuentos por volumen según el número de usuarios.
+     */
+    getVolumeDiscountRate() {
+        if (!this.hasValue())
+            return null;
+        // Escalas de descuento por volumen
+        if (this.value <= 10)
+            return 0; // Sin descuento
+        if (this.value <= 50)
+            return 0.05; // 5% descuento
+        if (this.value <= 200)
+            return 0.10; // 10% descuento
+        return 0.15; // 15% descuento para enterprise
+    }
+    /**
+     * Verifica si excede un límite específico.
+     */
+    exceedsLimit(limit) {
+        if (!this.hasValue())
+            return null;
+        return this.value > limit;
+    }
+    /**
+     * Verifica si está dentro de un rango de usuarios.
+     */
+    isWithinRange(minUsers, maxUsers) {
+        if (!this.hasValue())
+            return null;
+        return this.value >= minUsers && this.value <= maxUsers;
+    }
+    /**
+     * Obtiene la descripción del límite de usuarios.
+     */
+    getDescription() {
+        if (!this.hasValue())
+            return null;
+        const category = this.getUserCategory();
+        const descriptions = {
+            none: 'Sin usuarios adicionales permitidos',
+            single: 'Un usuario adicional',
+            small: 'Grupo pequeño (2-10 usuarios)',
+            medium: 'Grupo medio (11-50 usuarios)',
+            large: 'Grupo grande (51-200 usuarios)',
+            enterprise: 'Nivel empresarial (más de 200 usuarios)',
+        };
+        return descriptions[category] || `${this.value} usuarios máximo`;
+    }
+    /**
+     * Obtiene recomendaciones de uso.
+     */
+    getUsageRecommendations() {
+        if (!this.hasValue())
+            return null;
+        const category = this.getUserCategory();
+        const recommendations = {
+            none: ['Servicio individual', 'Sin colaboración multi-usuario'],
+            single: ['Ideal para asistentes', 'Soporte básico adicional'],
+            small: ['Equipos pequeños', 'Startups', 'Departamentos específicos'],
+            medium: ['Empresas medianas', 'Múltiples departamentos', 'Proyectos colaborativos'],
+            large: ['Grandes organizaciones', 'División corporativa', 'Múltiples ubicaciones'],
+            enterprise: ['Corporaciones', 'Multinacionales', 'Implementación masiva'],
+        };
+        return recommendations[category] || [];
+    }
+    /**
+     * Verifica si requiere infraestructura especial.
+     */
+    requiresSpecialInfrastructure() {
+        if (!this.hasValue())
+            return null;
+        // Más de 100 usuarios requiere infraestructura especial
+        return this.value > 100;
+    }
+    /**
+     * Obtiene las características del límite de usuarios.
+     */
+    getCharacteristics() {
+        if (!this.hasValue())
+            return null;
+        return {
+            allowsAdditionalUsers: this.allowsAdditionalUsers(),
+            userCategory: this.getUserCategory(),
+            planType: this.getPlanType(),
+            requiresSpecialLicensing: this.requiresSpecialLicensing(),
+            requiresSpecialInfrastructure: this.requiresSpecialInfrastructure(),
+            volumeDiscountRate: this.getVolumeDiscountRate(),
+            description: this.getDescription(),
+            usageRecommendations: this.getUsageRecommendations(),
+        };
+    }
+    /**
+     * Compara con otro límite de usuarios.
+     */
+    compareWith(other) {
+        if (!this.hasValue() || !other.hasValue())
+            return null;
+        return this.value - other.value;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        if (!this.hasValue())
+            return 'No user limit defined';
+        if (this.value === 0)
+            return 'No additional users allowed';
+        return `Maximum ${this.value} additional users`;
+    }
+}
+exports.ServiceCatalogMaxUsers = ServiceCatalogMaxUsers;
+ServiceCatalogMaxUsers.PROPERTY_NAME = 'maxUsers';
+ServiceCatalogMaxUsers.MAX_USERS_OPTIONS = {
+    allowNegative: false, // El número de usuarios no puede ser negativo
+    allowZero: true, // Permitir 0 usuarios adicionales (servicio sin extensión de usuarios)
+    allowDecimals: false, // Los usuarios deben ser números enteros
+    maxDecimalPlaces: 0, // Sin decimales para conteo de usuarios
+    minValue: 0, // Valor mínimo es cero
+    maxValue: 10000, // Valor máximo razonable para usuarios adicionales
+};

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogName.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogName = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+class ServiceCatalogName extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogName.PROPERTY_NAME);
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, ServiceCatalogName.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, ServiceCatalogName.PROPERTY_NAME);
+        return new ServiceCatalogName(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogName(value, true);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogName = ServiceCatalogName;
+ServiceCatalogName.PROPERTY_NAME = 'name';

package/build/carbonbox/purchase-management-system/service-catalog/domain/value-objects/ServiceCatalogReportTypes.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogReportTypes = void 0;
+const StringList_1 = require("../../../../shared/domain/value-objects/StringList");
+const ReportType_1 = require("../enums/ReportType");
+const InvalidReportTypeError_1 = require("../exceptions/InvalidReportTypeError");
+class ServiceCatalogReportTypes extends StringList_1.StringList {
+    constructor(reportTypes, skipDomainValidation) {
+        super(reportTypes, skipDomainValidation, ServiceCatalogReportTypes.PROPERTY_NAME, { allowEmpty: true });
+        if (skipDomainValidation === false) {
+            this.validateReportTypes(reportTypes);
+        }
+    }
+    static create(reportTypes) {
+        StringList_1.StringList.guardAgainstInvalidStringList(reportTypes, ServiceCatalogReportTypes.PROPERTY_NAME);
+        return new ServiceCatalogReportTypes(reportTypes, false);
+    }
+    static fromPrimitives(primitives) {
+        const value = primitives.map((primitive) => primitive);
+        return new ServiceCatalogReportTypes(value, true);
+    }
+    /**
+     * Valida que todos los tipos de reporte sean válidos.
+     */
+    validateReportTypes(reportTypes) {
+        for (const reportType of reportTypes) {
+            if (!ServiceCatalogReportTypes.VALID_REPORT_TYPES.includes(reportType)) {
+                throw InvalidReportTypeError_1.InvalidReportTypeError.create(reportType, ServiceCatalogReportTypes.VALID_REPORT_TYPES);
+            }
+        }
+    }
+    /**
+     * Verifica si incluye reportes auditables.
+     */
+    includesAuditableReports() {
+        return this.value.includes(ReportType_1.ReportType.AUDITABLE);
+    }
+    /**
+     * Verifica si incluye reportes técnicos.
+     */
+    includesTechnicalReports() {
+        return this.value.includes(ReportType_1.ReportType.TECHNICAL);
+    }
+    /**
+     * Verifica si incluye reportes ejecutivos.
+     */
+    includesExecutiveReports() {
+        return this.value.includes(ReportType_1.ReportType.EXECUTIVE);
+    }
+    /**
+     * Verifica si incluye múltiples tipos de reporte.
+     */
+    hasMultipleReportTypes() {
+        return this.value.length > 1;
+    }
+    /**
+     * Verifica si incluye todos los tipos de reporte.
+     */
+    includesAllReportTypes() {
+        return this.value.length === ServiceCatalogReportTypes.VALID_REPORT_TYPES.length
+            && ServiceCatalogReportTypes.VALID_REPORT_TYPES.every((type) => this.value.includes(type));
+    }
+    /**
+     * Verifica si solo incluye reportes de cumplimiento (auditables).
+     */
+    isComplianceOnly() {
+        return this.value.length === 1 && this.includesAuditableReports();
+    }
+    /**
+     * Verifica si solo incluye reportes técnicos.
+     */
+    isTechnicalOnly() {
+        return this.value.length === 1 && this.includesTechnicalReports();
+    }
+    /**
+     * Verifica si solo incluye reportes ejecutivos.
+     */
+    isExecutiveOnly() {
+        return this.value.length === 1 && this.includesExecutiveReports();
+    }
+    /**
+     * Verifica si incluye reportes para audiencias técnicas.
+     */
+    includesTechnicalAudience() {
+        return this.includesTechnicalReports() || this.includesAuditableReports();
+    }
+    /**
+     * Verifica si incluye reportes para audiencias ejecutivas.
+     */
+    includesExecutiveAudience() {
+        return this.includesExecutiveReports();
+    }
+    /**
+     * Obtiene los tipos de reporte válidos.
+     */
+    static getValidReportTypes() {
+        return Object.freeze([...ServiceCatalogReportTypes.VALID_REPORT_TYPES]);
+    }
+    /**
+     * Verifica si un valor es un tipo de reporte válido.
+     */
+    static isValidReportType(reportType) {
+        return ServiceCatalogReportTypes.VALID_REPORT_TYPES.includes(reportType);
+    }
+    /**
+     * Agrega un nuevo tipo de reporte si no está ya presente.
+     */
+    addReportType(reportType) {
+        if (this.value.includes(reportType)) {
+            return this;
+        }
+        const newReportTypes = [...this.value, reportType];
+        return new ServiceCatalogReportTypes(newReportTypes, false);
+    }
+    /**
+     * Remueve un tipo de reporte específico.
+     */
+    removeReportType(reportType) {
+        const newReportTypes = this.value.filter((type) => type !== reportType);
+        return new ServiceCatalogReportTypes(newReportTypes, false);
+    }
+    /**
+     * Obtiene los tipos de reporte faltantes.
+     */
+    getMissingReportTypes() {
+        return ServiceCatalogReportTypes.VALID_REPORT_TYPES.filter((type) => !this.value.includes(type));
+    }
+    /**
+     * Obtiene el nivel de cobertura de reportes.
+     */
+    getCoverageLevel() {
+        if (this.value.length === 0)
+            return 'none';
+        if (this.value.length === 1)
+            return 'basic';
+        if (this.value.length === 2)
+            return 'standard';
+        return 'comprehensive';
+    }
+    /**
+     * Obtiene las audiencias objetivo de los reportes.
+     */
+    getTargetAudiences() {
+        const audiences = [];
+        if (this.includesAuditableReports()) {
+            audiences.push('Auditores externos', 'Organismos regulatorios');
+        }
+        if (this.includesTechnicalReports()) {
+            audiences.push('Equipos técnicos', 'Especialistas en sostenibilidad');
+        }
+        if (this.includesExecutiveReports()) {
+            audiences.push('Alta dirección', 'Stakeholders externos');
+        }
+        return audiences;
+    }
+    /**
+     * Obtiene las características de los tipos de reporte.
+     */
+    getReportCharacteristics() {
+        const characteristics = {};
+        if (this.includesAuditableReports()) {
+            characteristics[ReportType_1.ReportType.AUDITABLE] = {
+                purpose: 'Cumplimiento y verificación',
+                audience: 'Auditores y reguladores',
+                detail: 'Alto nivel de detalle y trazabilidad',
+                format: 'Formal y estructurado',
+            };
+        }
+        if (this.includesTechnicalReports()) {
+            characteristics[ReportType_1.ReportType.TECHNICAL] = {
+                purpose: 'Análisis técnico detallado',
+                audience: 'Equipos técnicos y especialistas',
+                detail: 'Datos técnicos y metodológicos',
+                format: 'Detallado con anexos técnicos',
+            };
+        }
+        if (this.includesExecutiveReports()) {
+            characteristics[ReportType_1.ReportType.EXECUTIVE] = {
+                purpose: 'Resumen ejecutivo y toma de decisiones',
+                audience: 'Alta dirección y stakeholders',
+                detail: 'Resumen con insights clave',
+                format: 'Visual y fácil de entender',
+            };
+        }
+        return characteristics;
+    }
+    /**
+     * Verifica si requiere recursos especializados.
+     */
+    requiresSpecializedResources() {
+        // Múltiples tipos de reporte requieren recursos especializados
+        return this.hasMultipleReportTypes() || this.includesAuditableReports();
+    }
+    /**
+     * Obtiene una descripción de los tipos de reporte incluidos.
+     */
+    getDescription() {
+        if (this.value.length === 0) {
+            return 'Sin tipos de reporte definidos';
+        }
+        const typeDescriptions = {
+            [ReportType_1.ReportType.AUDITABLE]: 'Reportes Auditables',
+            [ReportType_1.ReportType.TECHNICAL]: 'Reportes Técnicos',
+            [ReportType_1.ReportType.EXECUTIVE]: 'Reportes Ejecutivos',
+        };
+        const descriptions = this.value.map((type) => typeDescriptions[type]);
+        return descriptions.join(', ');
+    }
+    /**
+     * Convierte los tipos de reporte a enum para uso tipado.
+     */
+    toEnumArray() {
+        return this.value;
+    }
+    /**
+     * Obtiene el número de tipos de reporte únicos.
+     */
+    getReportTypeCount() {
+        return this.value.length;
+    }
+    /**
+     * Verifica si está vacío (sin tipos de reporte).
+     */
+    isEmpty() {
+        return this.value.length === 0;
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        if (this.isEmpty()) {
+            return 'No report types';
+        }
+        return this.getDescription();
+    }
+    toEnums() {
+        return this.value;
+    }
+}
+exports.ServiceCatalogReportTypes = ServiceCatalogReportTypes;
+ServiceCatalogReportTypes.PROPERTY_NAME = 'reportTypes';
+// Tipos de reporte válidos
+ServiceCatalogReportTypes.VALID_REPORT_TYPES = Object.values(ReportType_1.ReportType);