@acorex/modules 21.0.0-next.70 → 21.0.0-next.72

package/fesm2022/acorex-modules-calendar-management.mjs

@@ -1,13 +1,14 @@
 import { AXP_MODULE_MANIFEST_PROVIDER, provideLazyProvider, AXP_DATASOURCE_DEFINITION_PROVIDER, AXPSystemActionType } from '@acorex/platform/core';
-import { AXP_ENTITY_DEFINITION_LOADER, entityMasterCrudActions, entityMasterRecordActions, entityDetailsCrudActions, entityMasterDeleteAction, entityDetailsSimpleCondition, AXPEntityService } from '@acorex/platform/layout/entity';
-import { AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, createAllQueryView, AXPEntityCommandScope, AXPSearchCommandProvider, createEntityCommandOptions } from '@acorex/platform/common';
+import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER, entityMasterCrudActions, entityMasterRecordActions, entityDetailsCrudActions, entityMasterDeleteAction, entityDetailsSimpleCondition } from '@acorex/platform/layout/entity';
+import { AXPSettingsService, AXPRegionalSetting, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, createAllQueryView, AXPEntityCommandScope, AXPSearchCommandProvider, createEntityCommandOptions } from '@acorex/platform/common';
 import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
 import { CommonModule } from '@angular/common';
 import * as i0 from '@angular/core';
-import { NgModule, inject, Injector, Injectable } from '@angular/core';
+import { inject, Injectable, NgModule, Injector } from '@angular/core';
+import { AX_DATETIME_HOLIDAYS_LOADER, AXCalendarService } from '@acorex/core/date-time';
+import { resolveMultiLanguageString, AXTranslationService } from '@acorex/core/translation';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
 import { AXPCommonMenuKeys } from '@acorex/modules/common';
-import { AXTranslationService } from '@acorex/core/translation';
 
 const config = {
     i18n: 'calendar-management',
@@ -27,16 +28,16 @@ const RootConfig = {
             titlePlural: `@${config.i18n}:calendars.entities.calendar.plural`,
             icon: 'fa-light fa-calendar',
         },
-        calendarEvent: {
-            name: 'CalendarEvent',
-            title: `@${config.i18n}:calendar-events.entities.calendar-event.title`,
-            titlePlural: `@${config.i18n}:calendar-events.entities.calendar-event.plural`,
+        calendarOccasion: {
+            name: 'CalendarOccasion',
+            title: `@${config.i18n}:calendar-occasions.entities.calendar-occasion.title`,
+            titlePlural: `@${config.i18n}:calendar-occasions.entities.calendar-occasion.plural`,
             icon: 'fa-light fa-calendar-day',
         },
-        calendarEventType: {
-            name: 'CalendarEventType',
-            title: `@${config.i18n}:calendar-event-types.entities.calendar-event-type.title`,
-            titlePlural: `@${config.i18n}:calendar-event-types.entities.calendar-event-type.plural`,
+        calendarOccasionType: {
+            name: 'CalendarOccasionType',
+            title: `@${config.i18n}:calendar-occasion-types.entities.calendar-occasion-type.title`,
+            titlePlural: `@${config.i18n}:calendar-occasion-types.entities.calendar-occasion-type.plural`,
             icon: 'fa-light fa-tag',
         },
     },
@@ -60,7 +61,345 @@ const CalendarManagementManifest = {
 };
 //#endregion
 
+/** Normalizes regional calendar-event setting values to calendar ids. */
+function normalizeRegionalCalendarEventIds(value) {
+    if (value == null) {
+        return [];
+    }
+    const values = Array.isArray(value) ? value : [value];
+    return [
+        ...new Set(values
+            .map((item) => {
+            if (typeof item === 'string' || typeof item === 'number') {
+                return String(item);
+            }
+            if (item && typeof item === 'object' && 'id' in item) {
+                return String(item.id);
+            }
+            return '';
+        })
+            .filter(Boolean)),
+    ];
+}
+
+const STYLE_ELEMENT_ID = 'axm-calendar-occasion-holiday-styles';
+const registeredColorClasses = new Set();
+function hexToRgb(hex) {
+    const value = hex.replace('#', '').trim();
+    if (!/^[0-9a-fA-F]{6}$/.test(value)) {
+        return null;
+    }
+    return {
+        r: Number.parseInt(value.slice(0, 2), 16),
+        g: Number.parseInt(value.slice(2, 4), 16),
+        b: Number.parseInt(value.slice(4, 6), 16),
+    };
+}
+function resolveOccasionColorClass(color) {
+    const normalized = color.toLowerCase();
+    const token = normalized.replace('#', '');
+    const className = `axm-calendar-occasion-${token}`;
+    if (registeredColorClasses.has(className)) {
+        return className;
+    }
+    registeredColorClasses.add(className);
+    registerOccasionColorStyles(normalized, className);
+    return className;
+}
+function registerOccasionColorStyles(color, className) {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    let styleElement = document.getElementById(STYLE_ELEMENT_ID);
+    if (!styleElement) {
+        styleElement = document.createElement('style');
+        styleElement.id = STYLE_ELEMENT_ID;
+        document.head.appendChild(styleElement);
+    }
+    const rgb = hexToRgb(color);
+    const backgroundColor = rgb ? `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.14)` : 'transparent';
+    styleElement.appendChild(document.createTextNode(`
+      ax-scheduler .ax-scheduler-month-day-cell.${className},
+      ax-calendar .ax-calendar-day.${className} {
+        background-color: ${backgroundColor};
+      }
+
+      ax-scheduler .ax-scheduler-month-day-cell.${className} .ax-scheduler-month-day-number,
+      ax-scheduler .ax-scheduler-month-header-date-day.${className},
+      ax-scheduler .ax-scheduler-week-header-date-day.${className},
+      ax-scheduler .ax-scheduler-year-header-date-day.${className},
+      ax-scheduler .ax-scheduler-agenda-view-container.${className} .ax-scheduler-agenda-header-date-day,
+      ax-calendar .ax-calendar-day.${className} .ax-calendar-day-number {
+        color: ${color};
+        font-weight: 700;
+      }
+    `));
+}
+function mapCalendarOccasionToHolidayDate(occasion) {
+    if (occasion.isPublicHoliday) {
+        return {
+            date: occasion.date,
+            title: occasion.title,
+            description: occasion.description,
+            cssClass: 'ax-state-holiday',
+            icon: occasion.type.icon,
+            isHoliday: true,
+        };
+    }
+    const color = occasion.type.color || '#6b7280';
+    return {
+        date: occasion.date,
+        title: occasion.title,
+        description: occasion.description,
+        cssClass: resolveOccasionColorClass(color),
+        color,
+        icon: occasion.type.icon,
+        isHoliday: false,
+    };
+}
+
+function startOfDay(date) {
+    const normalized = new Date(date);
+    normalized.setHours(0, 0, 0, 0);
+    return normalized;
+}
+function parseRecurrenceRule(rule) {
+    return Object.fromEntries(rule
+        .split(';')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => {
+        const [key, value] = part.split('=');
+        return [key, value ?? ''];
+    }));
+}
+/**
+ * Expands occasion occurrences using the canonical ISO (Gregorian) anchor date.
+ * Calendar display system does not change which absolute days are matched.
+ */
+function expandCalendarOccasionOccurrences(occasion, range) {
+    const rangeStart = startOfDay(range.from);
+    const rangeEnd = startOfDay(range.end);
+    const anchor = startOfDay(new Date(occasion.date));
+    if (!occasion.isRecurring) {
+        return anchor >= rangeStart && anchor <= rangeEnd ? [anchor] : [];
+    }
+    const params = occasion.recurrenceRule?.trim()
+        ? parseRecurrenceRule(occasion.recurrenceRule)
+        : { FREQ: 'YEARLY' };
+    if (params['FREQ'] && params['FREQ'] !== 'YEARLY') {
+        return anchor >= rangeStart && anchor <= rangeEnd ? [anchor] : [];
+    }
+    const month = anchor.getMonth();
+    const day = anchor.getDate();
+    const dates = [];
+    const startYear = range.from.getFullYear() - 1;
+    const endYear = range.end.getFullYear() + 1;
+    for (let year = startYear; year <= endYear; year++) {
+        const occurrence = new Date(year, month, day);
+        occurrence.setHours(0, 0, 0, 0);
+        if (occurrence >= rangeStart && occurrence <= rangeEnd) {
+            dates.push(occurrence);
+        }
+    }
+    return dates;
+}
+
+function resolveCalendarLocalizedText(value, locale) {
+    if (value == null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    return resolveMultiLanguageString(value, locale).trim();
+}
+
+class AXMCalendarManagementService {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.translationService = inject(AXTranslationService);
+        //#region ----   Data Accessors   ----
+        this.calendarOccasionDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.calendarOccasion.name)
+            .data();
+        this.calendarDataAccessor = this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.calendar.name)
+            .data();
+    }
+    //#endregion
+    //#region ----   Methods   ----
+    async getCalendars() {
+        const calendars = await this.calendarDataAccessor.query({
+            skip: 0,
+            take: 9999,
+            filter: {
+                logic: 'and',
+                filters: [
+                    { field: 'isArchived', operator: { type: 'equal', negative: true }, value: true },
+                ],
+            },
+        });
+        const locale = this.translationService.getActiveLang();
+        return calendars.items.map((calendar) => ({
+            id: calendar.id,
+            title: resolveCalendarLocalizedText(calendar.title, locale),
+        }));
+    }
+    async getOccasions(range, calendarIds) {
+        if (!calendarIds || calendarIds.length === 0) {
+            return [];
+        }
+        const calendars = await this.calendarDataAccessor.query({
+            skip: 0,
+            take: 9999,
+            filter: {
+                logic: 'and',
+                filters: [
+                    { field: 'id', operator: { type: 'in' }, value: calendarIds },
+                    { field: 'isArchived', operator: { type: 'equal', negative: true }, value: true },
+                ],
+            },
+        });
+        if (calendars.items.length === 0) {
+            return [];
+        }
+        const filters = [
+            { field: 'calendarId', operator: { type: 'in' }, value: calendarIds },
+            {
+                logic: 'or',
+                filters: [
+                    { field: 'isRecurring', operator: { type: 'equal' }, value: true },
+                    {
+                        logic: 'and',
+                        filters: [
+                            { field: 'date', operator: { type: 'gte' }, value: range.from },
+                            { field: 'date', operator: { type: 'lte' }, value: range.end },
+                        ],
+                    },
+                ],
+            },
+        ];
+        const occasions = await this.calendarOccasionDataAccessor.query({
+            skip: 0,
+            take: 9999,
+            filter: {
+                logic: 'and',
+                filters,
+            },
+        });
+        const locale = this.translationService.getActiveLang();
+        const expandedOccasions = [];
+        for (const occasion of occasions.items) {
+            const occurrenceDates = expandCalendarOccasionOccurrences(occasion, range);
+            for (const date of occurrenceDates) {
+                expandedOccasions.push({
+                    date,
+                    title: resolveCalendarLocalizedText(occasion.title, locale),
+                    description: resolveCalendarLocalizedText(occasion.description, locale) || undefined,
+                    isPublicHoliday: occasion.isPublicHoliday ?? occasion.type?.isPublicHoliday ?? false,
+                    type: {
+                        color: occasion.type?.color ?? '#6b7280',
+                        icon: occasion.type?.icon,
+                    },
+                });
+            }
+        }
+        return expandedOccasions.sort((left, right) => left.date.getTime() - right.date.getTime());
+    }
+    async getHolidayDates(range, calendarIds) {
+        const occasions = await this.getOccasions(range, calendarIds);
+        return occasions.map((occasion) => mapCalendarOccasionToHolidayDate(occasion));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+function resolveHolidayRange(options) {
+    if (options?.range) {
+        return {
+            from: options.range.start,
+            end: options.range.end,
+        };
+    }
+    const now = new Date();
+    return {
+        from: new Date(now.getFullYear() - 2, 0, 1),
+        end: new Date(now.getFullYear() + 2, 11, 31),
+    };
+}
+class AXMCalendarManagementHolidaysLoader {
+    constructor() {
+        this.calendarManagementService = inject(AXMCalendarManagementService);
+        this.settingsService = inject(AXPSettingsService);
+    }
+    async getHolidays(options) {
+        const range = resolveHolidayRange(options);
+        const calendarIds = await this.resolveCalendarIds();
+        if (calendarIds.length === 0) {
+            return [];
+        }
+        const occasions = await this.calendarManagementService.getOccasions(range, calendarIds);
+        return occasions.map((occasion) => mapCalendarOccasionToHolidayDate(occasion));
+    }
+    async resolveCalendarIds() {
+        const configured = normalizeRegionalCalendarEventIds(await this.settingsService.get(AXPRegionalSetting.CalendarEvents));
+        if (configured.length > 0) {
+            return configured;
+        }
+        const calendars = await this.calendarManagementService.getCalendars();
+        return calendars.map((calendar) => calendar.id);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementHolidaysLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementHolidaysLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementHolidaysLoader, decorators: [{
+            type: Injectable
+        }] });
+const AXM_CALENDAR_MANAGEMENT_HOLIDAYS_LOADER_PROVIDER = {
+    provide: AX_DATETIME_HOLIDAYS_LOADER,
+    useClass: AXMCalendarManagementHolidaysLoader,
+};
+
+const HOLIDAY_RELOAD_SETTING_KEYS = [
+    AXPRegionalSetting.CalendarEvents,
+    AXPRegionalSetting.Language,
+    AXPRegionalSetting.LocaleProfile,
+];
+class AXMCalendarManagementHolidaysSyncService {
+    constructor() {
+        this.calendarService = inject(AXCalendarService);
+        this.settingsService = inject(AXPSettingsService);
+        this.settingsService.onLoaded.subscribe(() => {
+            void this.reloadHolidays();
+        });
+        this.settingsService.onChanged.subscribe((change) => {
+            if (change.keys.some((key) => HOLIDAY_RELOAD_SETTING_KEYS.includes(key))) {
+                void this.reloadHolidays();
+            }
+        });
+    }
+    reloadHolidays() {
+        return this.calendarService.loadHolidays();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementHolidaysSyncService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementHolidaysSyncService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementHolidaysSyncService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
 class AXMCalendarManagementModule {
+    constructor() {
+        inject(AXMCalendarManagementHolidaysSyncService);
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementModule, imports: [CommonModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementModule, providers: [
@@ -76,7 +415,8 @@ class AXMCalendarManagementModule {
             provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then(m => m.AXMCalendarManagementEntityProvider)),
             provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return searchCommand_provider; }).then(m => m.AXMCalendarManagementSearchCommandProvider)),
             // Lazy datasource provider: AXPDataSourceDefinitionProviderService resolves Promise providers (await Promise.resolve(raw)) before calling .items()
-            provideLazyProvider(AXP_DATASOURCE_DEFINITION_PROVIDER, () => import('./acorex-modules-calendar-management-datasource.provider-C_iazC89.mjs').then(m => m.AXMCalendarManagementDataSourceProvider)),
+            provideLazyProvider(AXP_DATASOURCE_DEFINITION_PROVIDER, () => import('./acorex-modules-calendar-management-datasource.provider-CnxTy81J.mjs').then(m => m.AXMCalendarManagementDataSourceProvider)),
+            AXM_CALENDAR_MANAGEMENT_HOLIDAYS_LOADER_PROVIDER,
         ], imports: [CommonModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementModule, decorators: [{
@@ -98,21 +438,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                         provideLazyProvider(AXP_ENTITY_DEFINITION_LOADER, () => Promise.resolve().then(function () { return entity_provider; }).then(m => m.AXMCalendarManagementEntityProvider)),
                         provideLazyProvider(AXP_SEARCH_PROVIDER, () => Promise.resolve().then(function () { return searchCommand_provider; }).then(m => m.AXMCalendarManagementSearchCommandProvider)),
                         // Lazy datasource provider: AXPDataSourceDefinitionProviderService resolves Promise providers (await Promise.resolve(raw)) before calling .items()
-                        provideLazyProvider(AXP_DATASOURCE_DEFINITION_PROVIDER, () => import('./acorex-modules-calendar-management-datasource.provider-C_iazC89.mjs').then(m => m.AXMCalendarManagementDataSourceProvider)),
+                        provideLazyProvider(AXP_DATASOURCE_DEFINITION_PROVIDER, () => import('./acorex-modules-calendar-management-datasource.provider-CnxTy81J.mjs').then(m => m.AXMCalendarManagementDataSourceProvider)),
+                        AXM_CALENDAR_MANAGEMENT_HOLIDAYS_LOADER_PROVIDER,
                     ],
                 }]
-        }] });
+        }], ctorParameters: () => [] });
 
-async function calendarEventTypeFactory(injector) {
+async function calendarOccasionTypeFactory(injector) {
     const i18n = RootConfig.config.i18n;
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.calendarEventType.name,
-        title: RootConfig.entities.calendarEventType.title,
-        icon: RootConfig.entities.calendarEventType.icon,
+        name: RootConfig.entities.calendarOccasionType.name,
+        title: RootConfig.entities.calendarOccasionType.title,
+        icon: RootConfig.entities.calendarOccasionType.icon,
         formats: {
-            individual: RootConfig.entities.calendarEventType.title,
-            plural: RootConfig.entities.calendarEventType.titlePlural,
+            individual: RootConfig.entities.calendarOccasionType.title,
+            plural: RootConfig.entities.calendarOccasionType.titlePlural,
             searchResult: {
                 title: '{{ title }}',
                 description: '{{ description }}',
@@ -124,7 +465,6 @@ async function calendarEventTypeFactory(injector) {
             { name: 'compare' },
             { name: 'color' },
             { name: 'icon' },
-            { name: 'default' },
             { name: 'archive' },
         ],
         //#region ----   Property Groups   ----
@@ -137,15 +477,10 @@ async function calendarEventTypeFactory(injector) {
                 id: 'appearance',
                 title: '@general:terms.interface.appearance',
             },
-            {
-                id: 'settings',
-                title: '@general:terms.interface.settings',
-            },
         ],
         //#endregion
         //#region ----   Properties   ----
         properties: [
-            // Basic Information
             {
                 name: 'title',
                 title: '@general:terms.common.title',
@@ -162,7 +497,8 @@ async function calendarEventTypeFactory(injector) {
                     interface: {
                         type: AXPWidgetsCatalog.text,
                         options: {
-                            placeholder: 'Enter event type title',
+                            multiLanguage: true,
+                            placeholder: 'Enter occasion type title',
                         },
                     },
                 },
@@ -187,30 +523,28 @@ async function calendarEventTypeFactory(injector) {
                         type: AXPWidgetsCatalog.largeText,
                         options: {
                             rows: 3,
-                            placeholder: 'Enter event type description',
+                            multiLanguage: true,
+                            placeholder: 'Enter occasion type description',
                         },
                     },
                 },
             },
             {
-                name: 'order',
-                title: '@general:terms.classification.order',
-                groupId: 'settings',
+                name: 'isPublicHoliday',
+                title: '@calendar-management:calendar-occasion-types.entities.calendar-occasion-type.fields.is-public-holiday.title',
+                groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
                     filter: {
                         advance: { enabled: true },
-                        inline: { enabled: false },
+                        inline: { enabled: true },
                     },
                 },
                 schema: {
-                    dataType: 'number',
+                    dataType: 'boolean',
+                    defaultValue: false,
                     interface: {
-                        type: AXPWidgetsCatalog.number,
-                        options: {
-                            minValue: 0,
-                            maxValue: 9999,
-                        },
+                        type: AXPWidgetsCatalog.toggle,
                     },
                 },
             },
@@ -219,6 +553,7 @@ async function calendarEventTypeFactory(injector) {
         //#region ----   Table Columns   ----
         columns: [
             { name: 'title' },
+            { name: 'isPublicHoliday' },
         ],
         //#endregion
         //#region ----   Interface Layouts   ----
@@ -228,30 +563,22 @@ async function calendarEventTypeFactory(injector) {
                     sections: [
                         { id: 'basic-info' },
                         { id: 'appearance' },
-                        { id: 'settings' },
                     ],
                     properties: [
-                        // Basic Info
-                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-                        // Appearance
-                        // Settings
-                        { name: 'order', layout: { positions: { lg: { colSpan: 4, order: 8 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'isPublicHoliday', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
                     ],
                 },
                 update: {
                     sections: [
                         { id: 'basic-info' },
                         { id: 'appearance' },
-                        { id: 'settings' },
                     ],
                     properties: [
-                        // Basic Info
-                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-                        // Appearance
-                        // Settings
-                        { name: 'order', layout: { positions: { lg: { colSpan: 4, order: 8 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'isPublicHoliday', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
                     ],
                 },
                 single: {
@@ -259,15 +586,11 @@ async function calendarEventTypeFactory(injector) {
                     sections: [
                         { id: 'basic-info' },
                         { id: 'appearance' },
-                        { id: 'settings' },
                     ],
                     properties: [
-                        // Basic Info
-                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-                        // Appearance
-                        // Settings
-                        { name: 'order', layout: { positions: { lg: { colSpan: 4, order: 8 } } } },
+                        { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'isPublicHoliday', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
                     ],
                     actions: [
                         ...entityMasterRecordActions()
@@ -279,7 +602,7 @@ async function calendarEventTypeFactory(injector) {
                     ],
                     views: [
                         createAllQueryView({
-                            sorts: [{ name: 'order', dir: 'asc' }]
+                            sorts: [{ name: 'title', dir: 'asc' }]
                         }),
                     ],
                 },
@@ -290,24 +613,24 @@ async function calendarEventTypeFactory(injector) {
     return entityDef;
 }
 
-var calendarEventType_entity = /*#__PURE__*/Object.freeze({
+var calendarOccasionType_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    calendarEventTypeFactory: calendarEventTypeFactory
+    calendarOccasionTypeFactory: calendarOccasionTypeFactory
 });
 
-async function calendarEventFactory(injector) {
+async function calendarOccasionFactory(injector) {
     const i18n = RootConfig.config.i18n;
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.calendarEvent.name,
-        title: RootConfig.entities.calendarEvent.title,
-        icon: RootConfig.entities.calendarEvent.icon,
+        name: RootConfig.entities.calendarOccasion.name,
+        title: RootConfig.entities.calendarOccasion.title,
+        icon: RootConfig.entities.calendarOccasion.icon,
         formats: {
-            individual: RootConfig.entities.calendarEvent.title,
-            plural: RootConfig.entities.calendarEvent.titlePlural,
+            individual: RootConfig.entities.calendarOccasion.title,
+            plural: RootConfig.entities.calendarOccasion.titlePlural,
             searchResult: {
-                title: '{{ title }} - {{ date }}',
-                description: '{{ calendar.title }} - {{ type }}',
+                title: '{{ context.eval("title") + " - " + context.eval("date") }}',
+                description: '{{ context.eval("calendar.title") + " - " + context.eval("type") }}',
             },
         },
         //#region ----   Property Groups   ----
@@ -332,10 +655,9 @@ async function calendarEventFactory(injector) {
         //#endregion
         //#region ----   Properties   ----
         properties: [
-            // Basic Information
             {
                 name: 'calendarId',
-                title: '@calendar-management:calendar-events.entities.calendar-event.fields.calendar.title',
+                title: '@calendar-management:calendar-occasions.entities.calendar-occasion.fields.calendar.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -377,7 +699,8 @@ async function calendarEventFactory(injector) {
                     interface: {
                         type: AXPWidgetsCatalog.text,
                         options: {
-                            placeholder: 'Enter event title',
+                            multiLanguage: true,
+                            placeholder: 'Enter occasion title',
                         },
                     },
                 },
@@ -402,14 +725,15 @@ async function calendarEventFactory(injector) {
                         type: AXPWidgetsCatalog.largeText,
                         options: {
                             rows: 3,
-                            placeholder: 'Enter event description',
+                            multiLanguage: true,
+                            placeholder: 'Enter occasion description',
                         },
                     },
                 },
             },
             {
                 name: 'typeId',
-                title: '@calendar-management:calendar-events.entities.calendar-event.fields.type.title',
+                title: '@calendar-management:calendar-occasions.entities.calendar-occasion.fields.type.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -424,12 +748,13 @@ async function calendarEventFactory(injector) {
                         type: AXPWidgetsCatalog.lookup,
                         options: {
                             look: 'select',
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.calendarEventType.name}`,
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.calendarOccasionType.name}`,
                             expose: [
                                 { source: 'id', target: 'type.id' },
                                 { source: 'title', target: 'type.title' },
                                 { source: 'color', target: 'type.color' },
                                 { source: 'icon', target: 'type.icon' },
+                                { source: 'isPublicHoliday', target: 'type.isPublicHoliday' },
                             ],
                         },
                     },
@@ -438,7 +763,6 @@ async function calendarEventFactory(injector) {
                     { rule: 'required' },
                 ],
             },
-            // Date & Time
             {
                 name: 'date',
                 title: '@general:terms.datetime.date',
@@ -463,10 +787,9 @@ async function calendarEventFactory(injector) {
                     { rule: 'required' },
                 ],
             },
-            // Recurrence
             {
                 name: 'isRecurring',
-                title: '@calendar-management:calendar-events.entities.calendar-event.fields.is-recurring.title',
+                title: '@calendar-management:calendar-occasions.entities.calendar-occasion.fields.is-recurring.title',
                 groupId: 'date',
                 options: {
                     sort: { enabled: true },
@@ -485,7 +808,7 @@ async function calendarEventFactory(injector) {
             },
             {
                 name: 'recurrenceRule',
-                title: '@calendar-management:calendar-events.entities.calendar-event.fields.recurrence-rule.title',
+                title: '@calendar-management:calendar-occasions.entities.calendar-occasion.fields.recurrence-rule.title',
                 groupId: 'date',
                 options: {
                     sort: { enabled: false },
@@ -496,16 +819,35 @@ async function calendarEventFactory(injector) {
                 },
                 schema: {
                     dataType: 'string',
+                    visible: '{{ !!context.eval("isRecurring") }}',
                     interface: {
                         type: AXPWidgetsCatalog.largeText,
                         options: {
                             rows: 3,
-                            placeholder: 'FREQ=YEARLY;BYMONTH=3;BYMONTHDAY=21',
-                            visibility: '{{ context.eval("isRecurring") ?? false }}'
+                            placeholder: 'FREQ=YEARLY',
                         },
                     },
                 },
             },
+            {
+                name: 'isPublicHoliday',
+                title: '@calendar-management:calendar-occasions.entities.calendar-occasion.fields.is-public-holiday.title',
+                groupId: 'settings',
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
+                },
+                schema: {
+                    dataType: 'boolean',
+                    defaultValue: '{{ context.eval("type.isPublicHoliday") || false }}',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                },
+            },
             {
                 name: 'order',
                 title: '@general:terms.classification.order',
@@ -533,9 +875,11 @@ async function calendarEventFactory(injector) {
         //#region ----   Table Columns   ----
         columns: [
             { name: 'title' },
-            { name: 'typeId', options: { dataPath: 'type.title' } },
+            { name: 'description' },
+            { name: 'typeId' },
             { name: 'date' },
             { name: 'isRecurring' },
+            { name: 'isPublicHoliday' },
         ],
         //#endregion
         //#region ----   Interface Layouts   ----
@@ -548,15 +892,13 @@ async function calendarEventFactory(injector) {
                         { id: 'settings' },
                     ],
                     properties: [
-                        // Basic Info
                         { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
                         { name: 'typeId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-                        // Date 
                         { name: 'date', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
                         { name: 'isRecurring', layout: { positions: { lg: { colSpan: 6, order: 9 } } } },
                         { name: 'recurrenceRule', layout: { positions: { lg: { colSpan: 12, order: 10 } } } },
-                        // Settings
+                        { name: 'isPublicHoliday', layout: { positions: { lg: { colSpan: 6, order: 11 } } } },
                         { name: 'order', layout: { positions: { lg: { colSpan: 6, order: 13 } } } },
                     ],
                 },
@@ -567,15 +909,13 @@ async function calendarEventFactory(injector) {
                         { id: 'settings' },
                     ],
                     properties: [
-                        // Basic Info
                         { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
                         { name: 'typeId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-                        // Date 
                         { name: 'date', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
                         { name: 'isRecurring', layout: { positions: { lg: { colSpan: 6, order: 9 } } } },
                         { name: 'recurrenceRule', layout: { positions: { lg: { colSpan: 12, order: 10 } } } },
-                        // Settings
+                        { name: 'isPublicHoliday', layout: { positions: { lg: { colSpan: 6, order: 11 } } } },
                         { name: 'order', layout: { positions: { lg: { colSpan: 6, order: 13 } } } },
                     ],
                 },
@@ -587,15 +927,13 @@ async function calendarEventFactory(injector) {
                         { id: 'settings' },
                     ],
                     properties: [
-                        // Basic Info
                         { name: 'title', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
                         { name: 'typeId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
                         { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-                        // Date 
                         { name: 'date', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
                         { name: 'isRecurring', layout: { positions: { lg: { colSpan: 6, order: 9 } } } },
                         { name: 'recurrenceRule', layout: { positions: { lg: { colSpan: 12, order: 10 } } } },
-                        // Settings
+                        { name: 'isPublicHoliday', layout: { positions: { lg: { colSpan: 6, order: 11 } } } },
                         { name: 'order', layout: { positions: { lg: { colSpan: 6, order: 13 } } } },
                     ],
                     actions: [
@@ -632,9 +970,9 @@ async function calendarEventFactory(injector) {
     return entityDef;
 }
 
-var calendarEvent_entity = /*#__PURE__*/Object.freeze({
+var calendarOccasion_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    calendarEventFactory: calendarEventFactory
+    calendarOccasionFactory: calendarOccasionFactory
 });
 
 async function calendarFactory(injector) {
@@ -649,22 +987,23 @@ async function calendarFactory(injector) {
             plural: RootConfig.entities.calendar.titlePlural,
             searchResult: {
                 title: '{{ title }}',
-                description: '{{ calendarType.title }}',
+                description: '{{ description }}',
             },
         },
         plugins: [
             { name: 'archive' },
-            { name: 'color' },
-            { name: 'icon' },
+            { name: 'history' },
         ],
         //#region ----   Related Entities   ----
         relatedEntities: [
             {
-                entity: `${RootConfig.module.name}.${RootConfig.entities.calendarEvent.name}`,
-                title: RootConfig.entities.calendarEvent.titlePlural,
-                columns: ['date', 'typeId', 'title', 'isRecurring'],
+                entity: `${RootConfig.module.name}.${RootConfig.entities.calendarOccasion.name}`,
+                title: RootConfig.entities.calendarOccasion.titlePlural,
                 conditions: [entityDetailsSimpleCondition('calendarId')],
                 actions: [...entityDetailsCrudActions('calendarId')],
+                layout: {
+                    type: 'page-list',
+                }
             },
         ],
         //#endregion
@@ -678,19 +1017,10 @@ async function calendarFactory(injector) {
             //   id: 'inheritance',
             //   title: '@calendar-management:calendars.entities.calendar.groups.inheritance',
             // },
-            {
-                id: 'week-config',
-                title: '@calendar-management:calendars.entities.calendar.groups.week-configuration',
-            },
-            // {
-            //   id: 'working-hours',
-            //   title: '@calendar-management:calendars.entities.calendar.groups.working-hours',
-            // },
         ],
         //#endregion
         //#region ----   Properties   ----
         properties: [
-            // Basic Information
             {
                 name: 'title',
                 title: '@general:terms.common.title',
@@ -707,6 +1037,7 @@ async function calendarFactory(injector) {
                     interface: {
                         type: AXPWidgetsCatalog.text,
                         options: {
+                            multiLanguage: true,
                             placeholder: 'Enter calendar title',
                         },
                     },
@@ -732,41 +1063,12 @@ async function calendarFactory(injector) {
                         type: AXPWidgetsCatalog.largeText,
                         options: {
                             rows: 3,
+                            multiLanguage: true,
                             placeholder: 'Enter calendar description',
                         },
                     },
                 },
             },
-            {
-                name: 'calendarTypeId',
-                title: '@calendar-management:calendars.entities.calendar.fields.calendar-type.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
-                },
-                schema: {
-                    dataType: 'object',
-                    interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: {
-                            valueField: 'value',
-                            textField: 'text',
-                            multiple: false,
-                            dataSource: [
-                                { value: 'gregorian', text: 'Gregorian' },
-                                { value: 'solar-hijri', text: 'Solar Hijri' },
-                            ],
-                        },
-                    },
-                },
-                validations: [
-                    { rule: 'required' },
-                ],
-            },
             // Inheritance
             {
                 name: 'parentId',
@@ -794,94 +1096,11 @@ async function calendarFactory(injector) {
                     },
                 },
             },
-            // Week Configuration
-            {
-                name: 'weekends',
-                title: '@calendar-management:calendars.entities.calendar.fields.weekend-pattern.title',
-                groupId: 'week-config',
-                options: {
-                    sort: { enabled: false },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: false },
-                    },
-                },
-                schema: {
-                    dataType: 'object',
-                    interface: {
-                        type: AXPWidgetsCatalog.selectionList,
-                        options: {
-                            dataSource: 'week-days',
-                            valueField: 'id',
-                            textField: 'title',
-                            multiple: true,
-                        },
-                    },
-                },
-                validations: [
-                    { rule: 'required' },
-                ],
-            },
-            {
-                name: 'firstDayOfWeek',
-                title: '@calendar-management:calendars.entities.calendar.fields.first-day-of-week.title',
-                groupId: 'week-config',
-                options: {
-                    sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
-                },
-                schema: {
-                    dataType: 'object',
-                    interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: {
-                            dataSource: 'week-days',
-                            valueField: 'id',
-                            textField: 'title',
-                            multiple: false,
-                        },
-                    },
-                },
-                validations: [
-                    { rule: 'required' },
-                ],
-            },
-            // // Working Hours
-            // {
-            //     name: 'workingHours',
-            //     title: '@calendar-management:calendars.entities.calendar.fields.working-hours-config.title',
-            //     groupId: 'working-hours',
-            //     options: {
-            //         sort: { enabled: false },
-            //         filter: {
-            //             advance: { enabled: false },
-            //             inline: { enabled: false },
-            //         },
-            //     },
-            //     schema: {
-            //         dataType: 'string',
-            //         interface: {
-            //             type: AXPWidgetsCatalog.flexLayout,
-            //             options: {
-            //                 rows: 5,
-            //                 placeholder: 'JSON configuration for working hours',
-            //             },
-            //             children:[
-            //                 {
-            //                 }
-            //             ]
-            //         },
-            //     },
-            // },
         ],
         //#endregion
         //#region ----   Table Columns   ----
         columns: [
             { name: 'title' },
-            { name: 'calendarTypeId' },
         ],
         //#region ----   Interface Layouts   ----
         interfaces: {
@@ -890,73 +1109,36 @@ async function calendarFactory(injector) {
                     sections: [
                         { id: 'basic-info' },
                         { id: 'inheritance' },
-                        { id: 'week-config' },
                     ],
                     properties: [
-                        // Basic Info — title and type 6+6
                         {
                             name: 'title',
                             layout: {
                                 positions: {
-                                    md: { colSpan: 6, order: 2 },
-                                    lg: { colSpan: 6, order: 2 },
-                                },
-                            },
-                        },
-                        {
-                            name: 'calendarTypeId',
-                            layout: {
-                                positions: {
-                                    md: { colSpan: 6, order: 3 },
-                                    lg: { colSpan: 6, order: 3 },
+                                    lg: { colSpan: 12, order: 1 },
                                 },
                             },
                         },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-                        // Inheritance
-                        { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 5 } } } },
-                        // Week Config
-                        { name: 'weekends', layout: { positions: { lg: { colSpan: 12, order: 8 } } } },
-                        { name: 'firstDayOfWeek', layout: { positions: { lg: { colSpan: 12, order: 9 } } } },
-                        // Working Hours
-                        //{ name: 'workingHours', layout: { positions: { lg: { colSpan: 12, order: 9 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
                     ],
                 },
                 update: {
                     sections: [
                         { id: 'basic-info' },
                         { id: 'inheritance' },
-                        { id: 'week-config' },
-                        { id: 'working-hours' },
                     ],
                     properties: [
-                        // Basic Info — title and type 6+6
                         {
                             name: 'title',
                             layout: {
                                 positions: {
-                                    md: { colSpan: 6, order: 2 },
-                                    lg: { colSpan: 6, order: 2 },
-                                },
-                            },
-                        },
-                        {
-                            name: 'calendarTypeId',
-                            layout: {
-                                positions: {
-                                    md: { colSpan: 6, order: 3 },
-                                    lg: { colSpan: 6, order: 3 },
+                                    lg: { colSpan: 12, order: 1 },
                                 },
                             },
                         },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-                        // Inheritance
-                        { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 5 } } } },
-                        // Week Config
-                        { name: 'weekends', layout: { positions: { lg: { colSpan: 12, order: 8 } } } },
-                        { name: 'firstDayOfWeek', layout: { positions: { lg: { colSpan: 12, order: 9 } } } },
-                        // Working Hours
-                        //{ name: 'workingHours', layout: { positions: { lg: { colSpan: 12, order: 9 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
                     ],
                 },
                 single: {
@@ -964,38 +1146,18 @@ async function calendarFactory(injector) {
                     sections: [
                         { id: 'basic-info' },
                         { id: 'inheritance' },
-                        { id: 'week-config' },
-                        { id: 'working-hours' },
                     ],
                     properties: [
-                        // Basic Info — title and type 6+6
                         {
                             name: 'title',
                             layout: {
                                 positions: {
-                                    md: { colSpan: 6, order: 2 },
-                                    lg: { colSpan: 6, order: 2 },
+                                    lg: { colSpan: 12, order: 1 },
                                 },
                             },
                         },
-                        {
-                            name: 'calendarTypeId',
-                            layout: {
-                                positions: {
-                                    md: { colSpan: 6, order: 3 },
-                                    lg: { colSpan: 6, order: 3 },
-                                },
-                            },
-                            dataPath: 'calendarType.title',
-                        },
-                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-                        // Inheritance
-                        { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 5 } } } },
-                        // Week Config
-                        { name: 'weekends', layout: { positions: { lg: { colSpan: 12, order: 8 } } } },
-                        { name: 'firstDayOfWeek', layout: { positions: { lg: { colSpan: 12, order: 9 } } } },
-                        // Working Hours
-                        //{ name: 'workingHours', layout: { positions: { lg: { colSpan: 12, order: 9 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                        { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
                     ],
                     actions: [
                         entityMasterDeleteAction()
@@ -1013,7 +1175,7 @@ async function calendarFactory(injector) {
                 },
             },
         },
-        //#endregion    
+        //#endregion
     };
     return entityDef;
 }
@@ -1039,10 +1201,10 @@ class AXMCalendarManagementEntityProvider {
             switch (entityName) {
                 case RootConfig.entities.calendar.name:
                     return (await Promise.resolve().then(function () { return calendar_entity; })).calendarFactory(this.injector);
-                case RootConfig.entities.calendarEvent.name:
-                    return (await Promise.resolve().then(function () { return calendarEvent_entity; })).calendarEventFactory(this.injector);
-                case RootConfig.entities.calendarEventType.name:
-                    return (await Promise.resolve().then(function () { return calendarEventType_entity; })).calendarEventTypeFactory(this.injector);
+                case RootConfig.entities.calendarOccasion.name:
+                    return (await Promise.resolve().then(function () { return calendarOccasion_entity; })).calendarOccasionFactory(this.injector);
+                case RootConfig.entities.calendarOccasionType.name:
+                    return (await Promise.resolve().then(function () { return calendarOccasionType_entity; })).calendarOccasionTypeFactory(this.injector);
             }
         }
         return null;
@@ -1061,7 +1223,7 @@ var entity_provider = /*#__PURE__*/Object.freeze({
 const AXPCalendarManagementMenuKeys = {
     Root: 'CalendarManagement:Menu',
     Calendars: 'CalendarManagement:Menu:Calendars',
-    CalendarEventTypes: 'CalendarManagement:Menu:CalendarEventTypes',
+    CalendarOccasionTypes: 'CalendarManagement:Menu:CalendarOccasionTypes',
 };
 
 //#region ----   Imports   ----
@@ -1073,7 +1235,6 @@ class AXMCalendarManagementMenuProvider {
     }
     async provide(context) {
         const module = RootConfig.module;
-        // Add Calendars and Calendar Event Types under Configuration/Date and Time
         context.find(AXPCommonMenuKeys.DateAndTime).addItems([
             {
                 name: AXPCalendarManagementMenuKeys.Calendars,
@@ -1086,10 +1247,10 @@ class AXMCalendarManagementMenuProvider {
                 },
             },
             {
-                name: AXPCalendarManagementMenuKeys.CalendarEventTypes,
-                text: '@calendar-management:calendar-event-types.entities.calendar-event-type.plural',
-                path: this.entityService.createPath(module.name, RootConfig.entities.calendarEventType.name),
-                icon: RootConfig.entities.calendarEventType.icon,
+                name: AXPCalendarManagementMenuKeys.CalendarOccasionTypes,
+                text: '@calendar-management:calendar-occasion-types.entities.calendar-occasion-type.plural',
+                path: this.entityService.createPath(module.name, RootConfig.entities.calendarOccasionType.name),
+                icon: RootConfig.entities.calendarOccasionType.icon,
                 priority: 3,
                 policy: {
                     features: [module.name],
@@ -1120,12 +1281,12 @@ const AXMPermissionsKeys = {
             Delete: `${moduleKey}:Calendar:${AXPSystemActionType.Delete}`,
             Admin: `${moduleKey}:Calendar:Admin`,
         },
-        CalendarEventType: {
-            Management: `${moduleKey}:CalendarEventType:${AXPSystemActionType.Manage}`,
-            View: `${moduleKey}:CalendarEventType:${AXPSystemActionType.View}`,
-            Create: `${moduleKey}:CalendarEventType:${AXPSystemActionType.Create}`,
-            Update: `${moduleKey}:CalendarEventType:${AXPSystemActionType.Update}`,
-            Delete: `${moduleKey}:CalendarEventType:${AXPSystemActionType.Delete}`,
+        CalendarOccasionType: {
+            Management: `${moduleKey}:CalendarOccasionType:${AXPSystemActionType.Manage}`,
+            View: `${moduleKey}:CalendarOccasionType:${AXPSystemActionType.View}`,
+            Create: `${moduleKey}:CalendarOccasionType:${AXPSystemActionType.Create}`,
+            Update: `${moduleKey}:CalendarOccasionType:${AXPSystemActionType.Update}`,
+            Delete: `${moduleKey}:CalendarOccasionType:${AXPSystemActionType.Delete}`,
         },
     },
 };
@@ -1139,23 +1300,20 @@ class AXMCalendarManagementPermissionDefinitionProvider {
         const keys = AXMPermissionsKeys.CalendarManagement;
         const moduleTitle = await this.translateService.translateAsync('@calendar-management:module.title');
         const calendarTrans = async (action) => await this.translateService.translateAsync(`@calendar-management:calendars.permissions.calendar.actions.${action}.title`);
-        const eventTypeTrans = async (action) => await this.translateService.translateAsync(`@calendar-management:calendar-event-types.permissions.calendar-event-type.actions.${action}.title`);
+        const occasionTypeTrans = async (action) => await this.translateService.translateAsync(`@calendar-management:calendar-occasion-types.permissions.calendar-occasion-type.actions.${action}.title`);
         context.addGroup(RootConfig.module.name, moduleTitle)
-            // Calendar Management
             .addPermission(keys.Calendar.Management, await calendarTrans('manage'))
             .addChild(keys.Calendar.View, await calendarTrans('view'))
             .addChild(keys.Calendar.Create, await calendarTrans('create'))
             .addChild(keys.Calendar.Update, await calendarTrans('update'))
             .addChild(keys.Calendar.Delete, await calendarTrans('delete'))
             .endPermission()
-            // Calendar Event Type Management
-            .addPermission(keys.CalendarEventType.Management, await eventTypeTrans('manage'))
-            .addChild(keys.CalendarEventType.View, await eventTypeTrans('view'))
-            .addChild(keys.CalendarEventType.Create, await eventTypeTrans('create'))
-            .addChild(keys.CalendarEventType.Update, await eventTypeTrans('update'))
-            .addChild(keys.CalendarEventType.Delete, await eventTypeTrans('delete'))
+            .addPermission(keys.CalendarOccasionType.Management, await occasionTypeTrans('manage'))
+            .addChild(keys.CalendarOccasionType.View, await occasionTypeTrans('view'))
+            .addChild(keys.CalendarOccasionType.Create, await occasionTypeTrans('create'))
+            .addChild(keys.CalendarOccasionType.Update, await occasionTypeTrans('update'))
+            .addChild(keys.CalendarOccasionType.Delete, await occasionTypeTrans('delete'))
             .endPermission()
-            // Administrative Permissions
             .addPermission(keys.Calendar.Admin, await calendarTrans('admin'))
             .endPermission()
             .endGroup();
@@ -1187,17 +1345,17 @@ class AXMCalendarManagementSearchCommandProvider extends AXPSearchCommandProvide
                 },
             },
             {
-                id: 'create-calendar-event-type',
+                id: 'create-calendar-occasion-type',
                 group: 'command',
-                title: RootConfig.entities.calendarEventType.title,
-                icon: RootConfig.entities.calendarEventType.icon,
-                description: RootConfig.entities.calendarEventType.titlePlural,
+                title: RootConfig.entities.calendarOccasionType.title,
+                icon: RootConfig.entities.calendarOccasionType.icon,
+                description: RootConfig.entities.calendarOccasionType.titlePlural,
                 command: {
                     name: 'Entity:Create',
-                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.calendarEventType.name}`, {
-                        name: RootConfig.entities.calendarEventType.name,
+                    options: createEntityCommandOptions(`${RootConfig.module.name}.${RootConfig.entities.calendarOccasionType.name}`, {
+                        name: RootConfig.entities.calendarOccasionType.name,
                         module: RootConfig.module.name,
-                        title: RootConfig.entities.calendarEventType.title,
+                        title: RootConfig.entities.calendarOccasionType.title,
                     }),
                 },
             },
@@ -1210,80 +1368,11 @@ var searchCommand_provider = /*#__PURE__*/Object.freeze({
     AXMCalendarManagementSearchCommandProvider: AXMCalendarManagementSearchCommandProvider
 });
 
-class AXMCalendarManagementService {
-    constructor() {
-        this.entityService = inject(AXPEntityService);
-        //#region ----   Data Accessors   ----
-        this.calendarEventDataAccessor = this.entityService
-            .withEntity(RootConfig.module.name, RootConfig.entities.calendarEvent.name)
-            .data();
-        this.calendarDataAccessor = this.entityService
-            .withEntity(RootConfig.module.name, RootConfig.entities.calendar.name)
-            .data();
-    }
-    //#endregion
-    //#region ----   Methods   ----
-    async getCalendars() {
-        const calendars = await this.calendarDataAccessor.query({
-            skip: 0,
-            take: 9999,
-            filter: {
-                logic: 'and',
-                filters: [
-                    { field: 'isArchived', operator: { type: 'equal', negative: true }, value: true },
-                ],
-            },
-        });
-        return calendars.items.map((eventType) => ({
-            id: eventType.id,
-            title: eventType.title,
-        }));
-    }
-    async getEvents(range, calendarIds) {
-        //TODO: check calendars state to be active
-        const filters = [
-            { field: 'date', operator: { type: 'lte' }, value: range.end },
-            { field: 'date', operator: { type: 'gte' }, value: range.from },
-        ];
-        // If no calendar IDs provided or empty array, return no events (user must explicitly select calendars)
-        if (!calendarIds || calendarIds.length === 0) {
-            return [];
-        }
-        filters.push({ field: 'calendarId', operator: { type: 'in' }, value: calendarIds });
-        const events = await this.calendarEventDataAccessor.query({
-            skip: 0,
-            take: 9999,
-            filter: {
-                logic: 'and',
-                filters,
-            },
-        });
-        return events.items.map((event) => ({
-            date: event.date,
-            title: event.title,
-            description: event.description,
-            type: {
-                color: event.type?.color,
-                icon: event.type?.icon,
-                isHoliday: event.type?.isHoliday,
-            },
-        }));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMCalendarManagementService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
 // Main Module
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMCalendarManagementEntityProvider, AXMCalendarManagementMenuProvider, AXMCalendarManagementModule, AXMCalendarManagementPermissionDefinitionProvider, AXMCalendarManagementSearchCommandProvider, AXMCalendarManagementService, AXMPermissionsKeys, RootConfig, calendarEventFactory, calendarEventTypeFactory, calendarFactory };
+export { AXMCalendarManagementEntityProvider, AXMCalendarManagementHolidaysLoader, AXMCalendarManagementHolidaysSyncService, AXMCalendarManagementMenuProvider, AXMCalendarManagementModule, AXMCalendarManagementPermissionDefinitionProvider, AXMCalendarManagementSearchCommandProvider, AXMCalendarManagementService, AXMPermissionsKeys, RootConfig, calendarFactory, calendarOccasionFactory, calendarOccasionTypeFactory, mapCalendarOccasionToHolidayDate, normalizeRegionalCalendarEventIds };
 //# sourceMappingURL=acorex-modules-calendar-management.mjs.map