@carbonbox/domain 0.2.3 → 0.2.4

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

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogStatus = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const ServiceCatalogStatus_1 = require("../enums/ServiceCatalogStatus");
+const InvalidServiceCatalogStatusError_1 = require("../exceptions/InvalidServiceCatalogStatusError");
+class ServiceCatalogStatus extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogStatus.PROPERTY_NAME);
+        if (skipDomainValidation === false) {
+            this.validateServiceCatalogStatus(value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, ServiceCatalogStatus.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, ServiceCatalogStatus.PROPERTY_NAME);
+        return new ServiceCatalogStatus(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogStatus(value, true);
+    }
+    /**
+     * Valida que el valor sea un estado de servicio válido.
+     */
+    validateServiceCatalogStatus(value) {
+        if (!ServiceCatalogStatus.VALID_SERVICE_STATUSES.includes(value)) {
+            throw InvalidServiceCatalogStatusError_1.InvalidServiceCatalogStatusError.create(value, ServiceCatalogStatus.VALID_SERVICE_STATUSES);
+        }
+    }
+    /**
+     * Verifica si el servicio está activo.
+     */
+    isActive() {
+        return this.value === ServiceCatalogStatus_1.ServiceCatalogStatus.ACTIVE;
+    }
+    /**
+     * Verifica si el servicio está inactivo.
+     */
+    isInactive() {
+        return this.value === ServiceCatalogStatus_1.ServiceCatalogStatus.INACTIVE;
+    }
+    /**
+     * Verifica si el servicio está descontinuado.
+     */
+    isDiscontinued() {
+        return this.value === ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED;
+    }
+    /**
+     * Verifica si el servicio está disponible para uso (activo).
+     */
+    isAvailable() {
+        return this.isActive();
+    }
+    /**
+     * Verifica si el servicio no está disponible (inactivo o descontinuado).
+     */
+    isUnavailable() {
+        return this.isInactive() || this.isDiscontinued();
+    }
+    /**
+     * Verifica si es un estado temporal (inactivo).
+     */
+    isTemporaryStatus() {
+        return this.isInactive();
+    }
+    /**
+     * Verifica si es un estado permanente (activo o descontinuado).
+     */
+    isPermanentStatus() {
+        return this.isActive() || this.isDiscontinued();
+    }
+    /**
+     * Verifica si el servicio puede ser reactivado.
+     */
+    canBeReactivated() {
+        // Los servicios inactivos pueden ser reactivados, los descontinuados no
+        return this.isInactive();
+    }
+    /**
+     * Verifica si el servicio puede ser contratado.
+     */
+    canBeContracted() {
+        return this.isActive();
+    }
+    /**
+     * Verifica si requiere migración (descontinuado).
+     */
+    requiresMigration() {
+        return this.isDiscontinued();
+    }
+    /**
+     * Obtiene los estados de servicio válidos.
+     */
+    static getValidServiceCatalogStatuses() {
+        return Object.freeze([...ServiceCatalogStatus.VALID_SERVICE_STATUSES]);
+    }
+    /**
+     * Verifica si un valor es un estado de servicio válido.
+     */
+    static isValidServiceCatalogStatus(value) {
+        return ServiceCatalogStatus.VALID_SERVICE_STATUSES.includes(value);
+    }
+    /**
+     * Obtiene la descripción del estado del servicio.
+     */
+    getDescription() {
+        const descriptions = {
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.ACTIVE]: 'Servicio activo y disponible para contratación',
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.INACTIVE]: 'Servicio temporalmente inactivo, no disponible para nuevas contrataciones',
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED]: 'Servicio descontinuado permanentemente, requiere migración',
+        };
+        return descriptions[this.value] || this.value;
+    }
+    /**
+     * Obtiene el impacto del estado en el negocio.
+     */
+    getBusinessImpact() {
+        const impacts = {
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.ACTIVE]: 'Generación de ingresos activa',
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.INACTIVE]: 'Pérdida temporal de ingresos',
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED]: 'Fin del ciclo de vida del producto',
+        };
+        return impacts[this.value] || 'Impacto desconocido';
+    }
+    /**
+     * Obtiene las acciones recomendadas según el estado.
+     */
+    getRecommendedActions() {
+        const actions = {
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.ACTIVE]: [
+                'Monitorear rendimiento del servicio',
+                'Mantener calidad del servicio',
+                'Promocionar activamente',
+            ],
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.INACTIVE]: [
+                'Evaluar razones de inactividad',
+                'Planificar reactivación si es viable',
+                'Comunicar estado a clientes existentes',
+            ],
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED]: [
+                'Planificar migración de clientes existentes',
+                'Comunicar timeline de descontinuación',
+                'Ofrecer alternativas equivalentes',
+            ],
+        };
+        return actions[this.value] || [];
+    }
+    /**
+     * Obtiene el nivel de prioridad de atención.
+     */
+    getPriorityLevel() {
+        const priorities = {
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.ACTIVE]: 'high',
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.INACTIVE]: 'medium',
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED]: 'low',
+        };
+        return priorities[this.value] || 'medium';
+    }
+    /**
+     * Verifica si el estado permite actualizaciones del servicio.
+     */
+    allowsServiceUpdates() {
+        // Solo servicios activos e inactivos permiten actualizaciones
+        return this.isActive() || this.isInactive();
+    }
+    /**
+     * Obtiene las características del estado del servicio.
+     */
+    getCharacteristics() {
+        return {
+            isAvailable: this.isAvailable(),
+            isTemporary: this.isTemporaryStatus(),
+            canBeReactivated: this.canBeReactivated(),
+            canBeContracted: this.canBeContracted(),
+            requiresMigration: this.requiresMigration(),
+            allowsUpdates: this.allowsServiceUpdates(),
+            priorityLevel: this.getPriorityLevel(),
+            businessImpact: this.getBusinessImpact(),
+            recommendedActions: this.getRecommendedActions(),
+        };
+    }
+    /**
+     * Obtiene los estados de transición válidos desde el estado actual.
+     */
+    getValidTransitions() {
+        const transitions = {
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.ACTIVE]: [ServiceCatalogStatus_1.ServiceCatalogStatus.INACTIVE, ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED],
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.INACTIVE]: [ServiceCatalogStatus_1.ServiceCatalogStatus.ACTIVE, ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED],
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED]: [], // No hay transiciones desde descontinuado
+        };
+        return transitions[this.value] || [];
+    }
+    /**
+     * Verifica si puede transicionar a un estado específico.
+     */
+    canTransitionTo(targetStatus) {
+        return this.getValidTransitions().includes(targetStatus);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    toEnum() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        const statusNames = {
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.ACTIVE]: 'Activo',
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.INACTIVE]: 'Inactivo',
+            [ServiceCatalogStatus_1.ServiceCatalogStatus.DISCONTINUED]: 'Descontinuado',
+        };
+        return statusNames[this.value] || this.value;
+    }
+}
+exports.ServiceCatalogStatus = ServiceCatalogStatus;
+ServiceCatalogStatus.PROPERTY_NAME = 'status';
+// Estados de servicio válidos
+ServiceCatalogStatus.VALID_SERVICE_STATUSES = Object.values(ServiceCatalogStatus_1.ServiceCatalogStatus);

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

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceCatalogType = void 0;
+const String_1 = require("../../../../shared/domain/value-objects/String");
+const ServiceCatalogType_1 = require("../enums/ServiceCatalogType");
+const InvalidServiceCatalogTypeError_1 = require("../exceptions/InvalidServiceCatalogTypeError");
+class ServiceCatalogType extends String_1.String {
+    constructor(value, skipDomainValidation) {
+        super(value, skipDomainValidation, ServiceCatalogType.PROPERTY_NAME);
+        if (skipDomainValidation === false) {
+            this.validateServiceCatalogType(value);
+        }
+    }
+    static create(value) {
+        String_1.String.guardAgainstEmptyValue(value, ServiceCatalogType.PROPERTY_NAME);
+        String_1.String.guardAgainstInvalidType(value, ServiceCatalogType.PROPERTY_NAME);
+        return new ServiceCatalogType(value, false);
+    }
+    static fromPrimitives(primitive) {
+        const value = primitive;
+        return new ServiceCatalogType(value, true);
+    }
+    /**
+     * Valida que el valor sea un tipo de servicio válido.
+     */
+    validateServiceCatalogType(value) {
+        if (!ServiceCatalogType.VALID_SERVICE_TYPES.includes(value)) {
+            throw InvalidServiceCatalogTypeError_1.InvalidServiceCatalogTypeError.create(value, ServiceCatalogType.VALID_SERVICE_TYPES);
+        }
+    }
+    /**
+     * Verifica si es un servicio base.
+     */
+    isBaseService() {
+        return this.value === ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE;
+    }
+    /**
+     * Verifica si es un servicio adicional.
+     */
+    isAdditionalService() {
+        return this.value === ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE;
+    }
+    /**
+     * Verifica si es una característica de plataforma.
+     */
+    isPlatformFeature() {
+        return this.value === ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE;
+    }
+    /**
+     * Verifica si es un servicio dependiente.
+     */
+    isDependentService() {
+        return this.value === ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE;
+    }
+    /**
+     * Verifica si es un servicio principal (base o adicional).
+     */
+    isPrincipalService() {
+        return this.isBaseService() || this.isAdditionalService();
+    }
+    /**
+     * Verifica si es un servicio que requiere dependencias.
+     */
+    requiresDependencies() {
+        return this.isDependentService();
+    }
+    /**
+     * Verifica si es un servicio que genera ingresos directos.
+     */
+    generatesDirectRevenue() {
+        // Los servicios base, adicionales y dependientes generan ingresos directos
+        return this.isBaseService() || this.isAdditionalService() || this.isDependentService();
+    }
+    /**
+     * Verifica si es un servicio que mejora la propuesta de valor.
+     */
+    enhancesValueProposition() {
+        // Las características de plataforma mejoran la propuesta de valor
+        return this.isPlatformFeature();
+    }
+    /**
+     * Verifica si puede ser contratado independientemente.
+     */
+    canBeContractedIndependently() {
+        // Solo servicios base y adicionales pueden ser contratados independientemente
+        return this.isBaseService() || this.isAdditionalService();
+    }
+    /**
+     * Verifica si puede ser incluido en paquetes.
+     */
+    canBeIncludedInPackages() {
+        // Todos los tipos pueden ser incluidos en paquetes
+        return true;
+    }
+    /**
+     * Verifica si requiere configuración especial.
+     */
+    requiresSpecialConfiguration() {
+        // Características de plataforma y servicios dependientes requieren configuración especial
+        return this.isPlatformFeature() || this.isDependentService();
+    }
+    /**
+     * Obtiene los tipos de servicio válidos.
+     */
+    static getValidServiceCatalogTypes() {
+        return Object.freeze([...ServiceCatalogType.VALID_SERVICE_TYPES]);
+    }
+    /**
+     * Verifica si un valor es un tipo de servicio válido.
+     */
+    static isValidServiceCatalogType(value) {
+        return ServiceCatalogType.VALID_SERVICE_TYPES.includes(value);
+    }
+    /**
+     * Obtiene la descripción del tipo de servicio.
+     */
+    getDescription() {
+        const descriptions = {
+            [ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE]: 'Servicio principal que constituye la oferta base',
+            [ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE]: 'Servicio adicional opcional que complementa la oferta',
+            [ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE]: 'Característica de plataforma que mejora la experiencia del usuario',
+            [ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE]: 'Servicio que requiere un servicio principal para funcionar',
+        };
+        return descriptions[this.value] || this.value;
+    }
+    /**
+     * Obtiene el modelo de negocio del tipo de servicio.
+     */
+    getBusinessModel() {
+        const models = {
+            [ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE]: 'Ingreso principal recurrente',
+            [ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE]: 'Ingreso adicional opcional',
+            [ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE]: 'Valor agregado incluido',
+            [ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE]: 'Ingreso complementario condicionado',
+        };
+        return models[this.value] || 'Modelo no definido';
+    }
+    /**
+     * Obtiene la estrategia de precio del tipo de servicio.
+     */
+    getPricingStrategy() {
+        const strategies = {
+            [ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE]: 'Precio base competitivo',
+            [ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE]: 'Precio premium por valor agregado',
+            [ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE]: 'Incluido en precio base',
+            [ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE]: 'Precio condicionado al servicio principal',
+        };
+        return strategies[this.value] || 'Estrategia no definida';
+    }
+    /**
+     * Obtiene el nivel de prioridad comercial.
+     */
+    getCommercialPriority() {
+        const priorities = {
+            [ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE]: 'high',
+            [ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE]: 'medium',
+            [ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE]: 'low',
+            [ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE]: 'medium',
+        };
+        return priorities[this.value] || 'medium';
+    }
+    /**
+     * Obtiene las características del tipo de servicio.
+     */
+    getCharacteristics() {
+        return {
+            isPrincipal: this.isPrincipalService(),
+            requiresDependencies: this.requiresDependencies(),
+            generatesDirectRevenue: this.generatesDirectRevenue(),
+            enhancesValueProposition: this.enhancesValueProposition(),
+            canBeContractedIndependently: this.canBeContractedIndependently(),
+            canBeIncludedInPackages: this.canBeIncludedInPackages(),
+            requiresSpecialConfiguration: this.requiresSpecialConfiguration(),
+            commercialPriority: this.getCommercialPriority(),
+            businessModel: this.getBusinessModel(),
+            pricingStrategy: this.getPricingStrategy(),
+        };
+    }
+    /**
+     * Obtiene los tipos de servicio compatibles para bundling.
+     */
+    getCompatibleTypesForBundling() {
+        const compatibility = {
+            [ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE]: [
+                ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE,
+                ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE,
+                ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE,
+            ],
+            [ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE]: [
+                ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE,
+                ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE,
+                ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE,
+            ],
+            [ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE]: [
+                ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE,
+                ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE,
+                ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE,
+            ],
+            [ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE]: [
+                ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE,
+                ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE,
+                ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE,
+            ],
+        };
+        return compatibility[this.value] || [];
+    }
+    /**
+     * Verifica si puede ser bundled con otro tipo de servicio.
+     */
+    canBeBundledWith(otherType) {
+        return this.getCompatibleTypesForBundling().includes(otherType);
+    }
+    toPrimitives() {
+        return this.value;
+    }
+    toEnum() {
+        return this.value;
+    }
+    /**
+     * Representación como string descriptiva.
+     */
+    toString() {
+        const typeNames = {
+            [ServiceCatalogType_1.ServiceCatalogType.BASE_SERVICE]: 'Servicio Base',
+            [ServiceCatalogType_1.ServiceCatalogType.ADDITIONAL_SERVICE]: 'Servicio Adicional',
+            [ServiceCatalogType_1.ServiceCatalogType.PLATFORM_FEATURE]: 'Característica de Plataforma',
+            [ServiceCatalogType_1.ServiceCatalogType.DEPENDENT_SERVICE]: 'Servicio Dependiente',
+        };
+        return typeNames[this.value] || this.value;
+    }
+}
+exports.ServiceCatalogType = ServiceCatalogType;
+ServiceCatalogType.PROPERTY_NAME = 'type';
+// Tipos de servicio válidos
+ServiceCatalogType.VALID_SERVICE_TYPES = Object.values(ServiceCatalogType_1.ServiceCatalogType);

package/build/carbonbox/purchase-management-system/service-pricing/domain/value-objects/ServicePricingService.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServicePricingService = void 0;
-const ServiceReference_1 = require("../../../../shared/domain/value-objects/ServiceReference");
-class ServicePricingService extends ServiceReference_1.ServiceReference {
+const ServiceCatalogReference_1 = require("../../../../shared/domain/value-objects/ServiceCatalogReference");
+class ServicePricingService extends ServiceCatalogReference_1.ServiceCatalogReference {
     constructor(value, skipDomainValidation) {
         super(value, skipDomainValidation, ServicePricingService.PROPERTY_NAME);
     }

package/build/carbonbox/shared/domain/types/ServiceCatalogReference.js

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

package/build/carbonbox/shared/domain/types/ServiceCatalogReferencePrimitives.js

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