@umituz/react-native-design-system 2.3.12 → 2.3.14

package/src/molecules/calendar/infrastructure/services/CalendarEvents.ts

@@ -0,0 +1,196 @@
+/**
+ * Calendar Events Service
+ *
+ * Handles CRUD operations for calendar events.
+ *
+ * SOLID: Single Responsibility - Only event operations
+ * DRY: Centralized event management
+ * KISS: Simple event interface
+ */
+
+import * as Calendar from 'expo-calendar';
+import { Platform } from 'react-native';
+import { DateUtilities } from '../utils/DateUtilities';
+import { CalendarPermissions } from './CalendarPermissions';
+import type { CalendarEvent, SystemCalendar } from '../../domain/entities/CalendarEvent.entity';
+
+export class CalendarEvents {
+  /**
+   * Create event in system calendar
+   */
+  static async createEvent(
+    event: CalendarEvent,
+    calendar: SystemCalendar
+  ): Promise<{ success: boolean; eventId?: string; error?: string }> {
+    try {
+      if (Platform.OS === 'web') {
+        return { success: false, error: 'Calendar sync not supported on web' };
+      }
+
+      const permission = await CalendarPermissions.requestPermissions();
+      if (!permission.granted) {
+        return { success: false, error: 'Calendar permission not granted' };
+      }
+
+      const eventData = this.buildEventData(event);
+      const systemEventId = await Calendar.createEventAsync(calendar.id, eventData);
+
+      return {
+        success: true,
+        eventId: systemEventId
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to create event'
+      };
+    }
+  }
+
+  /**
+   * Update event in system calendar
+   */
+  static async updateEvent(
+    event: CalendarEvent
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      if (Platform.OS === 'web' || !event.systemCalendar?.eventId) {
+        return { success: false, error: 'No system calendar data' };
+      }
+
+      const permission = await CalendarPermissions.requestPermissions();
+      if (!permission.granted) {
+        return { success: false, error: 'Calendar permission not granted' };
+      }
+
+      const eventData = this.buildEventData(event);
+      await Calendar.updateEventAsync(event.systemCalendar.eventId, eventData);
+
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to update event'
+      };
+    }
+  }
+
+  /**
+   * Delete event from system calendar
+   */
+  static async deleteEvent(
+    eventId: string
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      if (Platform.OS === 'web') {
+        return { success: false, error: 'Calendar sync not supported on web' };
+      }
+
+      const permission = await CalendarPermissions.requestPermissions();
+      if (!permission.granted) {
+        return { success: false, error: 'Calendar permission not granted' };
+      }
+
+      await Calendar.deleteEventAsync(eventId);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to delete event'
+      };
+    }
+  }
+
+  /**
+   * Get events from system calendar
+   */
+  static async getSystemEvents(
+    calendarId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<CalendarEvent[]> {
+    try {
+      if (Platform.OS === 'web') {
+        return [];
+      }
+
+      const permission = await CalendarPermissions.hasPermissions();
+      if (!permission) {
+        return [];
+      }
+
+      const systemEvents = await Calendar.getEventsAsync(
+        [calendarId],
+        startDate,
+        endDate
+      );
+
+      return systemEvents.map((event: Calendar.Event) => this.mapSystemEventToCalendarEvent(event));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Build event data for system calendar
+   */
+  private static buildEventData(event: CalendarEvent) {
+    const [year, month, day] = event.date.split('-').map(Number);
+    let startDate = new Date(year, month - 1, day);
+    let endDate = new Date(startDate);
+
+    // Set time if provided
+    if (event.time) {
+      const [hours, minutes] = event.time.split(':').map(Number);
+      startDate.setHours(hours, minutes, 0, 0);
+      endDate.setHours(hours, minutes, 0, 0);
+    }
+
+    // Set duration
+    if (event.duration) {
+      endDate.setMinutes(endDate.getMinutes() + event.duration);
+    } else {
+      endDate.setHours(endDate.getHours() + 1); // Default 1 hour
+    }
+
+    // Create reminders
+    const alarms = event.reminders?.map(minutesBefore => ({
+      relativeOffset: -minutesBefore
+    }));
+
+    return {
+      title: event.title,
+      startDate,
+      endDate,
+      notes: event.description,
+      location: event.location,
+      alarms,
+      timeZone: DateUtilities.getCurrentTimezone()
+    };
+  }
+
+  /**
+   * Map system calendar event to domain event
+   */
+  private static mapSystemEventToCalendarEvent(systemEvent: any): CalendarEvent {
+    return {
+      id: systemEvent.id,
+      title: systemEvent.title || '',
+      description: systemEvent.notes || '',
+      date: DateUtilities.formatDateToString(systemEvent.startDate),
+      time: DateUtilities.formatTimeToString(systemEvent.startDate),
+      duration: systemEvent.endDate && systemEvent.startDate
+        ? (systemEvent.endDate.getTime() - systemEvent.startDate.getTime()) / (1000 * 60)
+        : undefined,
+      location: systemEvent.location || '',
+      reminders: systemEvent.alarms?.map((alarm: any) => -alarm.relativeOffset) || [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      systemCalendar: {
+        calendarId: systemEvent.calendarId,
+        eventId: systemEvent.id,
+        lastSyncedAt: new Date()
+      }
+    };
+  }
+}

package/src/molecules/calendar/infrastructure/services/CalendarGeneration.ts

@@ -0,0 +1,172 @@
+/**
+ * Calendar Generation Service
+ *
+ * Generates calendar grids and layouts.
+ *
+ * SOLID: Single Responsibility - Only calendar generation
+ * DRY: Reusable calendar generation logic
+ * KISS: Simple calendar grid creation
+ */
+
+import { DateUtilities } from '../utils/DateUtilities';
+import type { CalendarDay } from '../../domain/entities/CalendarDay.entity';
+import type { CalendarEvent } from '../../domain/entities/CalendarEvent.entity';
+
+export class CalendarGeneration {
+  /**
+   * Generate calendar days for a specific month
+   * Returns 42 days (6 weeks) including days from prev/next months
+   */
+  static generateMonthDays(
+    year: number,
+    month: number,
+    events: CalendarEvent[] = []
+  ): CalendarDay[] {
+    const firstDay = new Date(year, month, 1);
+    const startDate = new Date(firstDay);
+
+    // Start from Sunday of the week containing the 1st
+    startDate.setDate(startDate.getDate() - firstDay.getDay());
+
+    const days: CalendarDay[] = [];
+    const today = new Date();
+
+    // Generate 42 days (6 weeks)
+    for (let i = 0; i < 42; i++) {
+      const currentDate = DateUtilities.addDays(startDate, i);
+      const dayEvents = this.getEventsForDate(currentDate, events);
+
+      days.push({
+        date: currentDate,
+        isCurrentMonth: currentDate.getMonth() === month,
+        isToday: DateUtilities.isSameDay(currentDate, today),
+        isSelected: false,
+        events: dayEvents
+      });
+    }
+
+    return days;
+  }
+
+  /**
+   * Generate calendar days for a specific week
+   */
+  static generateWeekDays(
+    startDate: Date,
+    events: CalendarEvent[] = []
+  ): CalendarDay[] {
+    const days: CalendarDay[] = [];
+    const today = new Date();
+
+    for (let i = 0; i < 7; i++) {
+      const currentDate = DateUtilities.addDays(startDate, i);
+      const dayEvents = this.getEventsForDate(currentDate, events);
+
+      days.push({
+        date: currentDate,
+        isCurrentMonth: true, // All days in week view are "current"
+        isToday: DateUtilities.isSameDay(currentDate, today),
+        isSelected: false,
+        events: dayEvents
+      });
+    }
+
+    return days;
+  }
+
+  /**
+   * Get events for a specific date
+   */
+  static getEventsForDate(date: Date, allEvents: CalendarEvent[]): CalendarEvent[] {
+    const dateStr = DateUtilities.formatDateToString(date);
+    return allEvents.filter(event => event.date === dateStr);
+  }
+
+  /**
+   * Get events in date range
+   */
+  static getEventsInRange(
+    startDate: Date,
+    endDate: Date,
+    events: CalendarEvent[]
+  ): CalendarEvent[] {
+    const startStr = DateUtilities.formatDateToString(startDate);
+    const endStr = DateUtilities.formatDateToString(endDate);
+
+    return events.filter(event => event.date >= startStr && event.date <= endStr);
+  }
+
+  /**
+   * Navigate to previous month
+   */
+  static getPreviousMonth(currentDate: Date): Date {
+    const newDate = new Date(currentDate);
+    newDate.setMonth(newDate.getMonth() - 1);
+    return newDate;
+  }
+
+  /**
+   * Navigate to next month
+   */
+  static getNextMonth(currentDate: Date): Date {
+    const newDate = new Date(currentDate);
+    newDate.setMonth(newDate.getMonth() + 1);
+    return newDate;
+  }
+
+  /**
+   * Navigate to previous week
+   */
+  static getPreviousWeek(currentDate: Date): Date {
+    return DateUtilities.addDays(currentDate, -7);
+  }
+
+  /**
+   * Navigate to next week
+   */
+  static getNextWeek(currentDate: Date): Date {
+    return DateUtilities.addDays(currentDate, 7);
+  }
+
+  /**
+   * Check if date is today
+   */
+  static isToday(date: Date): boolean {
+    return DateUtilities.isToday(date);
+  }
+
+  /**
+   * Check if two dates are the same day
+   */
+  static isSameDay(date1: Date, date2: Date): boolean {
+    return DateUtilities.isSameDay(date1, date2);
+  }
+
+  /**
+   * Format date for display
+   */
+  static formatDate(date: Date): string {
+    return DateUtilities.formatDateToString(date);
+  }
+
+  /**
+   * Get month name
+   */
+  static getMonthName(date: Date): string {
+    return date.toLocaleDateString('en-US', { month: 'long' });
+  }
+
+  /**
+   * Get weekday name
+   */
+  static getWeekdayName(date: Date): string {
+    return date.toLocaleDateString('en-US', { weekday: 'long' });
+  }
+
+  /**
+   * Get short weekday name
+   */
+  static getShortWeekdayName(date: Date): string {
+    return date.toLocaleDateString('en-US', { weekday: 'short' });
+  }
+}

package/src/molecules/calendar/infrastructure/services/CalendarPermissions.ts

@@ -0,0 +1,92 @@
+/**
+ * Calendar Permissions Service
+ *
+ * Handles calendar permission requests and status checks.
+ *
+ * SOLID: Single Responsibility - Only permission operations
+ * DRY: Centralized permission logic
+ * KISS: Simple permission interface
+ */
+
+import * as Calendar from 'expo-calendar';
+import { Platform } from 'react-native';
+import type { CalendarPermissionResult } from '../../domain/entities/CalendarEvent.entity';
+
+export class CalendarPermissions {
+  /**
+   * Request calendar permissions
+   *
+   * @returns Promise with permission result
+   */
+  static async requestPermissions(): Promise<CalendarPermissionResult> {
+    try {
+      if (Platform.OS === 'web') {
+        return {
+          granted: false,
+          canAskAgain: false,
+          status: 'denied'
+        };
+      }
+
+      const { status, canAskAgain } = await Calendar.requestCalendarPermissionsAsync();
+
+      return {
+        granted: status === 'granted',
+        canAskAgain,
+        status
+      };
+    } catch {
+      return {
+        granted: false,
+        canAskAgain: false,
+        status: 'error'
+      };
+    }
+  }
+
+  /**
+   * Check if calendar permissions are granted
+   *
+   * @returns Promise with permission status
+   */
+  static async hasPermissions(): Promise<boolean> {
+    try {
+      if (Platform.OS === 'web') {
+        return false;
+      }
+
+      const { status } = await Calendar.getCalendarPermissionsAsync();
+      return status === 'granted';
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get current permission status
+   *
+   * @returns Promise with current status
+   */
+  static async getPermissionStatus(): Promise<CalendarPermissionResult['status']> {
+    try {
+      if (Platform.OS === 'web') {
+        return 'denied';
+      }
+
+      const { status } = await Calendar.getCalendarPermissionsAsync();
+      return status;
+    } catch {
+      return 'error';
+    }
+  }
+}
+
+
+
+
+
+
+
+
+
+

package/src/molecules/calendar/infrastructure/services/CalendarService.ts

@@ -0,0 +1,161 @@
+/**
+ * Calendar Service
+ *
+ * Facade for calendar operations using composition.
+ * Delegates to specialized services for specific operations.
+ *
+ * SOLID: Facade pattern - Single entry point, delegates to specialists
+ * DRY: Avoids code duplication by composing smaller services
+ * KISS: Simple interface, complex operations delegated
+ */
+
+import type { CalendarDay, CalendarWeek } from '../../domain/entities/CalendarDay.entity';
+import type { CalendarEvent, SystemCalendar } from '../../domain/entities/CalendarEvent.entity';
+import { CalendarGeneration } from './CalendarGeneration';
+import { CalendarPermissions } from './CalendarPermissions';
+// CalendarEvents is not used in this facade
+// import { CalendarEvents } from './CalendarEvents';
+import { CalendarSync } from './CalendarSync';
+import { DateUtilities } from '../utils/DateUtilities';
+
+/**
+ * Calendar Service Implementation
+ *
+ * Facade that delegates to specialized services.
+ * Follows SOLID principles with composition over inheritance.
+ */
+export class CalendarService {
+  /**
+   * Generate calendar days for a specific month
+   */
+  static getMonthDays(
+    year: number,
+    month: number,
+    events: CalendarEvent[] = []
+  ): CalendarDay[] {
+    return CalendarGeneration.generateMonthDays(year, month, events);
+  }
+
+  /**
+   * Generate calendar week
+   */
+  static getWeek(date: Date, events: CalendarEvent[] = []): CalendarWeek {
+    const startDate = DateUtilities.getStartOfWeek(date);
+    const endDate = DateUtilities.getEndOfWeek(date);
+    const days = CalendarGeneration.generateWeekDays(startDate, events);
+
+    return {
+      startDate,
+      endDate,
+      days
+    };
+  }
+
+  /**
+   * Navigate to previous month
+   */
+  static getPreviousMonth(currentDate: Date): Date {
+    return CalendarGeneration.getPreviousMonth(currentDate);
+  }
+
+  /**
+   * Navigate to next month
+   */
+  static getNextMonth(currentDate: Date): Date {
+    return CalendarGeneration.getNextMonth(currentDate);
+  }
+
+  /**
+   * Navigate to previous week
+   */
+  static getPreviousWeek(currentDate: Date): Date {
+    return CalendarGeneration.getPreviousWeek(currentDate);
+  }
+
+  /**
+   * Navigate to next week
+   */
+  static getNextWeek(currentDate: Date): Date {
+    return CalendarGeneration.getNextWeek(currentDate);
+  }
+
+  /**
+   * Request calendar permissions
+   */
+  static async requestPermissions() {
+    return CalendarPermissions.requestPermissions();
+  }
+
+  /**
+   * Check if permissions are granted
+   */
+  static async hasPermissions(): Promise<boolean> {
+    return CalendarPermissions.hasPermissions();
+  }
+
+  /**
+   * Sync event to system calendar
+   */
+  static async syncToSystemCalendar(event: CalendarEvent) {
+    return CalendarSync.syncToSystemCalendar(event);
+  }
+
+  /**
+   * Update system calendar event
+   */
+  static async updateSystemCalendarEvent(event: CalendarEvent) {
+    return CalendarSync.updateSystemCalendarEvent(event);
+  }
+
+  /**
+   * Remove event from system calendar
+   */
+  static async removeFromSystemCalendar(eventId: string) {
+    return CalendarSync.removeFromSystemCalendar(eventId);
+  }
+
+  /**
+   * Get system calendars
+   */
+  static async getSystemCalendars(): Promise<SystemCalendar[]> {
+    return CalendarSync.getSystemCalendars();
+  }
+
+  /**
+   * Get events for a specific date
+   */
+  static getEventsForDate(date: Date, events: CalendarEvent[]): CalendarEvent[] {
+    return CalendarGeneration.getEventsForDate(date, events);
+  }
+
+  /**
+   * Get events in date range
+   */
+  static getEventsInRange(
+    startDate: Date,
+    endDate: Date,
+    events: CalendarEvent[]
+  ): CalendarEvent[] {
+    return CalendarGeneration.getEventsInRange(startDate, endDate, events);
+  }
+
+  /**
+   * Get weekday names
+   */
+  static getWeekdayNames(): string[] {
+    const weekdays: string[] = [];
+    for (let i = 0; i < 7; i++) {
+      const date = new Date();
+      date.setDate(date.getDate() - date.getDay() + i);
+      weekdays.push(date.toLocaleDateString('en-US', { weekday: 'short' }));
+    }
+    return weekdays;
+  }
+
+  /**
+   * Check if two dates are the same day
+   */
+  static isSameDay(date1: Date, date2: Date): boolean {
+    return DateUtilities.isSameDay(date1, date2);
+  }
+}