@cbm-common/cbm-types 0.0.274 → 0.0.276

package/lib/domain/models/user-calendar.domain.model.d.ts

@@ -0,0 +1,38 @@
+export declare namespace UserCalendarModel {
+    interface ListResponse {
+        success: boolean;
+        data: ListResponse.Data[];
+    }
+    namespace ListResponse {
+        interface Data {
+            _id: string;
+            user_id: string;
+            day_code: number;
+            day_name: string;
+            begin_time: string;
+            end_time: string;
+            all_day: boolean;
+            enabled: boolean;
+            created_at: number;
+            created_user: string;
+        }
+    }
+    interface Save {
+        user_id: string;
+        day_code: string;
+        day_name: string;
+        begin_time: string;
+        end_time: string;
+        all_day: boolean;
+        enabled: boolean;
+    }
+    interface Update {
+        user_id: string;
+        day_code: number;
+        day_name: string;
+        begin_time: string;
+        end_time: string;
+        all_day: boolean;
+        enabled: boolean;
+    }
+}

package/lib/domain/repositories/user-calendar.domain.repository.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from "rxjs";
+import { UserCalendarModel } from "../models/user-calendar.domain.model";
+import { IUserCalendarInfrastructureRepository } from "../../infrastructure/repositories/user-calendar.infrastructure.repository";
+import { IGeneral } from "../models/general.domain.model";
+export declare class UserCalendarDomainRepository implements IUserCalendarInfrastructureRepository {
+    private readonly userCalendarService;
+    constructor(userCalendarService: IUserCalendarInfrastructureRepository);
+    list(userId: string): Observable<UserCalendarModel.ListResponse>;
+    save(request: UserCalendarModel.Save): Observable<IGeneral.Confirm>;
+    update(id: string, request: UserCalendarModel.Update): Observable<IGeneral.Confirm>;
+}

package/lib/domain/services/refresch-schedules.domain.service.d.ts

@@ -0,0 +1,132 @@
+import { OnDestroy } from "@angular/core";
+import { Subject } from "rxjs";
+import { Router } from "@angular/router";
+import { UserCalendarModel } from "../models/user-calendar.domain.model";
+import { UserCalendarDomainRepository } from "../repositories/user-calendar.domain.repository";
+import { CbmAuthReactiveService } from "./auth-reactive.domain.service";
+import { CbmNotificationService } from "./notification/notification.service";
+export interface AccessControlResult {
+    hasAccess: boolean;
+    message: string;
+    scheduleInfo?: UserCalendarModel.ListResponse.Data;
+}
+export declare class RefreshSchedulesDomainService implements OnDestroy {
+    private userModel;
+    private router;
+    private authService;
+    private notificationService;
+    private readonly STORAGE_KEY;
+    private readonly LAST_CHECK_KEY;
+    private readonly CHECK_INTERVAL_MS;
+    private accessCheckSubscription;
+    private isMonitoring;
+    closeInterval$: Subject<void>;
+    private notifiedEndTime;
+    onAccessDenied: () => void;
+    onAccessGranted: (() => void) | null;
+    onAccessStatusChange: ((result: AccessControlResult) => void) | null;
+    constructor(userModel: UserCalendarDomainRepository, router: Router, authService: CbmAuthReactiveService, notificationService: CbmNotificationService);
+    ngOnDestroy(): void;
+    initUsershecudles(): void;
+    /**
+     * Inicia la verificación periódica del acceso del usuario
+     * @param intervalMs Intervalo en milisegundos (por defecto 60000 = 1 minuto)
+     */
+    startPeriodicAccessCheck(intervalMs?: number): void;
+    /**
+     * Detiene la verificación periódica del acceso
+     */
+    stopPeriodicAccessCheck(): void;
+    /**
+     * Realiza la verificación de acceso y ejecuta las acciones correspondientes
+     */
+    private performAccessCheck;
+    /**
+     * Obtiene el estado actual del monitoreo
+     */
+    isAccessMonitoring(): boolean;
+    /**
+     * Cambia el intervalo de verificación
+     * Nota: Se aplica en la próxima ronda de verificación
+     */
+    setCheckInterval(intervalMs: number): void;
+    /**
+     * Verifica si el usuario tiene acceso en la hora actual
+     * Compara la hora actual con los horarios permitidos del día
+     * @param schedules Lista de horarios configurados
+     * @returns Resultado indicando si tiene acceso o debe ser sacado del sistema
+     */
+    checkAccessByCurrentTime(schedules: UserCalendarModel.ListResponse.Data[]): AccessControlResult;
+    /**
+     * Verifica y aplica control de acceso iterando sobre múltiples horarios
+     * Útil para verificar si un usuario debe ser expulsado del sistema
+     * @param schedules Lista de horarios a verificar
+     * @param userCurrentTime Hora actual del usuario (opcional, usa hora del servidor si no se proporciona)
+     * @returns Array de resultados de acceso por cada horario verificado
+     */
+    validateSchedulesAndApplyControl(schedules: UserCalendarModel.ListResponse.Data[], userCurrentTime?: Date): AccessControlResult[];
+    /**
+     * Verifica si existe acceso activo en la hora actual
+     * Retorna true si el usuario tiene acceso ahora mismo
+     */
+    hasActiveAccess(schedules: UserCalendarModel.ListResponse.Data[]): boolean;
+    /**
+     * Obtiene el próximo horario de expulsión del sistema
+     * Útil para programar la expulsión automática
+     */
+    getNextLogoutTime(schedules: UserCalendarModel.ListResponse.Data[]): Date | null;
+    private checkAndNotifyExpiry;
+    /**
+     * Guarda los horarios en localStorage
+     * @param schedules Lista de horarios a guardar
+     */
+    saveSchedulesToStorage(schedules: UserCalendarModel.ListResponse.Data[]): void;
+    /**
+     * Obtiene los horarios desde localStorage
+     * @returns Array de horarios o array vacío si no existen
+     */
+    getSchedulesFromStorage(): UserCalendarModel.ListResponse.Data[];
+    /**
+     * Verifica si existen horarios guardados en localStorage
+     */
+    hasSchedulesInStorage(): boolean;
+    /**
+     * Elimina los horarios de localStorage
+     */
+    clearSchedulesFromStorage(): void;
+    /**
+     * Actualiza un horario específico en localStorage
+     * @param dayName Nombre del día a actualizar
+     * @param updatedSchedule Nuevo horario
+     */
+    updateScheduleInStorage(dayName: string, updatedSchedule: UserCalendarModel.ListResponse.Data): void;
+    /**
+     * Verifica acceso usando los horarios guardados en localStorage
+     * @returns Resultado del control de acceso
+     */
+    checkAccessFromStorage(): AccessControlResult;
+    /**
+     * Registra la última vez que se verificó el acceso en localStorage
+     */
+    recordLastAccessCheck(): void;
+    /**
+     * Obtiene la última vez que se verificó el acceso
+     */
+    getLastAccessCheck(): Date | null;
+    /**
+     * Convierte un número de día (0-6) a nombre del día en español
+     */
+    private getDayName;
+    /**
+     * Formatea la hora actual en formato HH:mm
+     */
+    private formatTime;
+    /**
+     * Verifica si una hora está dentro de un rango de tiempo
+     */
+    private isTimeWithinRange;
+    /**
+     * Genera un mensaje descriptivo sobre el acceso
+     */
+    private generateAccessMessage;
+}

package/lib/infrastructure/repositories/user-calendar.infrastructure.repository.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { UserCalendarModel } from "../../domain/models/user-calendar.domain.model";
+import { IGeneral } from "../../domain/models/general.domain.model";
+export interface IUserCalendarInfrastructureRepository {
+    list(userId: string): Observable<UserCalendarModel.ListResponse>;
+    save(request: UserCalendarModel.Save): Observable<IGeneral.Confirm>;
+    update(id: string, request: UserCalendarModel.Update): Observable<IGeneral.Confirm>;
+}

package/lib/infrastructure/services/user-calendar.infrastructure.service.d.ts

@@ -0,0 +1,13 @@
+import { IUserCalendarInfrastructureRepository } from "../repositories/user-calendar.infrastructure.repository";
+import { Observable } from "rxjs";
+import { HttpClient } from "@angular/common/http";
+import { UserCalendarModel } from "../../domain/models/user-calendar.domain.model";
+import { IGeneral } from "../../domain/models/general.domain.model";
+export declare class UserCalendarInfrastrcutureService implements IUserCalendarInfrastructureRepository {
+    private readonly http;
+    constructor(http: HttpClient);
+    private readonly userCalendarUrl;
+    list(userId: string): Observable<UserCalendarModel.ListResponse>;
+    save(request: UserCalendarModel.Save): Observable<IGeneral.Confirm>;
+    update(id: string, request: UserCalendarModel.Update): Observable<IGeneral.Confirm>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cbm-common/cbm-types",
-  "version": "0.0.274",
+  "version": "0.0.276",
   "main": "index.js",
   "types": "public-api.d.ts",
   "exports": {

package/lib/components/detail-by-section/detail-by-section.d.ts

@@ -1,75 +0,0 @@
-import { CdkDragDrop } from '@angular/cdk/drag-drop';
-import { DestroyRef } from '@angular/core';
-import { FormControl } from '@angular/forms';
-import { CbmDetailBySectionModel } from './detail-by-section.model';
-type TDetailCategory = 'all' | 'item' | 'service' | 'subcontracted';
-declare class DetailSectionControl {
-    readonly id: `${string}-${string}-${string}-${string}-${string}`;
-    readonly defaultTitle: string;
-    constructor(title: string);
-    title: import("@angular/core").WritableSignal<string>;
-    items: import("@angular/core").WritableSignal<CbmDetailBySectionModel.SectionDetail[]>;
-    isDetailHidden: import("@angular/core").WritableSignal<boolean>;
-    itemsCount: import("@angular/core").Signal<number>;
-    subtotal: import("@angular/core").Signal<number>;
-    hasItems: import("@angular/core").Signal<boolean>;
-    summaryMessage: import("@angular/core").Signal<string>;
-    addItems(details: Array<CbmDetailBySectionModel.SectionDetail>): void;
-    replaceItems(details: Array<CbmDetailBySectionModel.SectionDetail>): void;
-    removeItem(detailKey: string): boolean;
-    resetTitleIfEmpty(value: string): void;
-    toggleDetailVisibility(): void;
-}
-export declare class CbmDetailBySectionComponent {
-    private readonly destroyRef;
-    EType: typeof CbmDetailBySectionModel.Type;
-    constructor(destroyRef: DestroyRef);
-    labels: import("@angular/core").WritableSignal<{
-        labelDetail: string;
-        labelSection: string;
-    }>;
-    sectionsChange: import("@angular/core").OutputEmitterRef<CbmDetailBySectionModel.SectionSnapshot[]>;
-    searchItemsControl: FormControl<string>;
-    detailCategory: import("@angular/core").WritableSignal<{
-        all: boolean;
-        item: boolean;
-        service: boolean;
-        subcontracted: boolean;
-    }>;
-    selectedCategory: import("@angular/core").WritableSignal<TDetailCategory>;
-    detail: import("@angular/core").WritableSignal<CbmDetailBySectionModel.SectionDetail[]>;
-    sectionsDetail: import("@angular/core").WritableSignal<DetailSectionControl[]>;
-    editingSectionIndex: import("@angular/core").WritableSignal<number | null>;
-    nextSectionNumber: import("@angular/core").WritableSignal<number>;
-    visibleDetail: import("@angular/core").Signal<CbmDetailBySectionModel.SectionDetail[]>;
-    detailSectionAssignments: import("@angular/core").Signal<Map<string, string[]>>;
-    dropListIds: import("@angular/core").Signal<string[]>;
-    allSectionsConsolidated: import("@angular/core").Signal<boolean>;
-    setLabels(labels: Partial<ReturnType<typeof this.labels>>): void;
-    setDetail(input: Array<CbmDetailBySectionModel.InputDetail>): void;
-    reset(): void;
-    searchTerm(term: string): void;
-    createSection(): void;
-    distributeSections(): void;
-    startEditSectionTitle(index: number): void;
-    saveSectionTitle(index: number, value: string): void;
-    removeSection(index: number): void;
-    removeItemFromSection(sectionId: string, detailKey: string, event?: Event): void;
-    addItemsByTypeToSection(sectionIndex: number, type: CbmDetailBySectionModel.Type): void;
-    toggleSectionDetailVisibility(sectionIndex: number): void;
-    toggleAllSectionsDetailVisibility(): void;
-    isDetailAssigned(detailKey: string): boolean;
-    getDetailAssignedSections(detailKey: string): string[];
-    onDropToSection(event: CdkDragDrop<Array<CbmDetailBySectionModel.SectionDetail>>, targetSectionIndex: number): void;
-    getSectionDropListId(id: string): string;
-    getSectionsSnapshot(): Array<CbmDetailBySectionModel.SectionSnapshot>;
-    getDetailAmount(detail: Pick<CbmDetailBySectionModel.SectionDetail, 'amount'>): number;
-    getDetailTotal(detail: Pick<CbmDetailBySectionModel.SectionDetail, 'total' | 'total_price'>): number;
-    private getDistributionSectionDefinitions;
-    private getSourceDetails;
-    private getAvailableDetailsByType;
-    private getSourceDetailsByType;
-    private loadCategory;
-    private getDetailKey;
-}
-export {};

package/lib/components/detail-by-section/detail-by-section.model.d.ts

@@ -1,30 +0,0 @@
-export declare namespace CbmDetailBySectionModel {
-    enum Type {
-        ITEM = "item",
-        SERVICE = "service",
-        SUBCONTRACTED = "subcontracted"
-    }
-    interface InputDetail {
-        _id?: string;
-        item_id: string;
-        item_code: string;
-        item_name: string;
-        amount: number;
-        total: number;
-        type: Type;
-        visible: boolean;
-        item_barcode?: string;
-        total_price?: number;
-        unit_measure_name?: string;
-    }
-    interface SectionDetail extends InputDetail {
-        key: string;
-    }
-    interface SectionSnapshot {
-        id: string;
-        title: string;
-        isDetailHidden: boolean;
-        subtotal: number;
-        items: Array<SectionDetail>;
-    }
-}