@umituz/react-native-design-system 2.3.13 → 2.3.15

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);
+  }
+}

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

@@ -0,0 +1,205 @@
+/**
+ * Calendar Sync Service
+ *
+ * Handles synchronization with system calendar.
+ *
+ * SOLID: Single Responsibility - Only sync operations
+ * DRY: Centralized sync logic
+ * KISS: Simple sync interface
+ */
+
+import * as Calendar from 'expo-calendar';
+import { Platform } from 'react-native';
+import { CalendarPermissions } from './CalendarPermissions';
+import type { CalendarEvent, SystemCalendar } from '../../domain/entities/CalendarEvent.entity';
+
+export class CalendarSync {
+  /**
+   * Sync event to system calendar
+   */
+  static async syncToSystemCalendar(
+    event: CalendarEvent
+  ): Promise<{
+    success: boolean;
+    eventId?: string;
+    calendarId?: 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 primaryCal = await this.getPrimaryCalendar();
+      if (!primaryCal) {
+        return { success: false, error: 'No writable calendar found' };
+      }
+
+      const eventData = this.buildSystemEventData(event);
+      const systemEventId = await Calendar.createEventAsync(primaryCal.id, eventData);
+
+      return {
+        success: true,
+        eventId: systemEventId,
+        calendarId: primaryCal.id
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to sync to calendar'
+      };
+    }
+  }
+
+  /**
+   * Update system calendar event
+   */
+  static async updateSystemCalendarEvent(
+    event: CalendarEvent
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      if (Platform.OS === 'web' || !event.systemCalendar) {
+        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.buildSystemEventData(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'
+      };
+    }
+  }
+
+  /**
+   * Remove event from system calendar
+   */
+  static async removeFromSystemCalendar(
+    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 remove from calendar'
+      };
+    }
+  }
+
+  /**
+   * Get primary writable calendar
+   */
+  static async getPrimaryCalendar(): Promise<SystemCalendar | null> {
+    try {
+      if (Platform.OS === 'web') {
+        return null;
+      }
+
+      const calendars = await Calendar.getCalendarsAsync();
+      const writableCalendars = calendars.filter((cal: Calendar.Calendar) =>
+        cal.allowsModifications &&
+        (cal.source.type === 'local' || cal.source.type === 'caldav')
+      );
+
+      // Prefer default calendar, fallback to first writable
+      const primaryCal = writableCalendars.find((cal: Calendar.Calendar) => cal.isPrimary) || writableCalendars[0];
+      if (!primaryCal) return null;
+
+      return {
+        id: primaryCal.id,
+        title: primaryCal.title,
+        color: primaryCal.color,
+        allowsModifications: primaryCal.allowsModifications,
+        source: primaryCal.source.name,
+        isPrimary: primaryCal.isPrimary || false
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get all system calendars
+   */
+  static async getSystemCalendars(): Promise<SystemCalendar[]> {
+    try {
+      if (Platform.OS === 'web') {
+        return [];
+      }
+
+      const calendars = await Calendar.getCalendarsAsync();
+      return calendars.map((cal: Calendar.Calendar) => ({
+        id: cal.id,
+        title: cal.title,
+        color: cal.color,
+        allowsModifications: cal.allowsModifications,
+        source: cal.source.name,
+        isPrimary: cal.isPrimary || false
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Build system calendar event data
+   */
+  private static buildSystemEventData(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: Intl.DateTimeFormat().resolvedOptions().timeZone
+    };
+  }
+}

package/src/molecules/calendar/infrastructure/storage/CalendarStore.ts

@@ -0,0 +1,307 @@
+/**
+ * Calendar Store (Zustand)
+ *
+ * Global state management for calendar functionality.
+ * Manages calendar view state, selected date, and events.
+ *
+ * Design Philosophy:
+ * - Zustand for lightweight state
+ * - AsyncStorage for persistence
+ * - Generic event handling
+ * - Timezone-aware via CalendarService
+ */
+
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../../domain/entities/CalendarEvent.entity';
+import { CalendarService } from '../services/CalendarService';
+
+/**
+ * Calendar view mode
+ */
+export type CalendarViewMode = 'month' | 'week' | 'day' | 'list';
+
+/**
+ * Calendar state interface
+ */
+interface CalendarState {
+  // State
+  events: CalendarEvent[];
+  selectedDate: Date;
+  currentMonth: Date;
+  viewMode: CalendarViewMode;
+  isLoading: boolean;
+  error: string | null;
+
+  // Actions
+  actions: {
+    // Event CRUD
+    loadEvents: () => Promise<void>;
+    addEvent: (request: CreateCalendarEventRequest) => Promise<void>;
+    updateEvent: (request: UpdateCalendarEventRequest) => Promise<void>;
+    deleteEvent: (id: string) => Promise<void>;
+    completeEvent: (id: string) => Promise<void>;
+    uncompleteEvent: (id: string) => Promise<void>;
+
+    // Navigation
+    setSelectedDate: (date: Date) => void;
+    goToToday: () => void;
+    navigateMonth: (direction: 'prev' | 'next') => void;
+    navigateWeek: (direction: 'prev' | 'next') => void;
+    setCurrentMonth: (date: Date) => void;
+
+    // View mode
+    setViewMode: (mode: CalendarViewMode) => void;
+
+    // Utilities
+    getEventsForDate: (date: Date) => CalendarEvent[];
+    getEventsForMonth: (year: number, month: number) => CalendarEvent[];
+    clearError: () => void;
+    clearAllEvents: () => Promise<void>;
+  };
+}
+
+/**
+ * Storage key for calendar events
+ */
+const STORAGE_KEY = 'calendar_events';
+
+/**
+ * Generate unique ID for events
+ */
+const generateId = (): string => {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+};
+
+/**
+ * Calendar Store
+ */
+export const useCalendarStore = create<CalendarState>()(
+  persist(
+    (set, get) => ({
+      // Initial State
+      events: [],
+      selectedDate: new Date(),
+      currentMonth: new Date(),
+      viewMode: 'month',
+      isLoading: false,
+      error: null,
+
+      // Actions
+      actions: {
+        /**
+         * Load events from storage
+         */
+        loadEvents: async () => {
+          set({ isLoading: true, error: null });
+          try {
+            const stored = await AsyncStorage.getItem(STORAGE_KEY);
+            if (stored) {
+              const events = JSON.parse(stored);
+              // Restore Date objects
+              events.forEach((event: CalendarEvent) => {
+                event.createdAt = new Date(event.createdAt);
+                event.updatedAt = new Date(event.updatedAt);
+              });
+              set({ events, isLoading: false });
+            } else {
+              set({ isLoading: false });
+            }
+          } catch (error) {
+            set({
+              error: error instanceof Error ? error.message : 'Failed to load events',
+              isLoading: false
+            });
+          }
+        },
+
+        /**
+         * Add a new event
+         */
+        addEvent: async (request: CreateCalendarEventRequest) => {
+          set({ isLoading: true, error: null });
+          try {
+            const newEvent: CalendarEvent = {
+              id: generateId(),
+              ...request,
+              isCompleted: false,
+              createdAt: new Date(),
+              updatedAt: new Date(),
+            };
+
+            const events = [...get().events, newEvent];
+            await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(events));
+            set({ events, isLoading: false });
+          } catch (error) {
+            set({
+              error: error instanceof Error ? error.message : 'Failed to add event',
+              isLoading: false
+            });
+          }
+        },
+
+        /**
+         * Update an existing event
+         */
+        updateEvent: async (request: UpdateCalendarEventRequest) => {
+          set({ isLoading: true, error: null });
+          try {
+            const events = get().events.map(event => {
+              if (event.id === request.id) {
+                return {
+                  ...event,
+                  ...request,
+                  updatedAt: new Date(),
+                };
+              }
+              return event;
+            });
+
+            await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(events));
+            set({ events, isLoading: false });
+          } catch (error) {
+            set({
+              error: error instanceof Error ? error.message : 'Failed to update event',
+              isLoading: false
+            });
+          }
+        },
+
+        /**
+         * Delete an event
+         */
+        deleteEvent: async (id: string) => {
+          set({ isLoading: true, error: null });
+          try {
+            const events = get().events.filter(event => event.id !== id);
+            await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(events));
+            set({ events, isLoading: false });
+          } catch (error) {
+            set({
+              error: error instanceof Error ? error.message : 'Failed to delete event',
+              isLoading: false
+            });
+          }
+        },
+
+        /**
+         * Mark event as completed
+         */
+        completeEvent: async (id: string) => {
+          await get().actions.updateEvent({ id, isCompleted: true });
+        },
+
+        /**
+         * Mark event as incomplete
+         */
+        uncompleteEvent: async (id: string) => {
+          await get().actions.updateEvent({ id, isCompleted: false });
+        },
+
+        /**
+         * Set selected date
+         */
+        setSelectedDate: (date: Date) => {
+          set({ selectedDate: date });
+        },
+
+        /**
+         * Go to today's date
+         */
+        goToToday: () => {
+          const today = new Date();
+          set({
+            selectedDate: today,
+            currentMonth: today,
+          });
+        },
+
+        /**
+         * Navigate to previous/next month
+         */
+        navigateMonth: (direction: 'prev' | 'next') => {
+          const currentMonth = get().currentMonth;
+          const newMonth = direction === 'prev'
+            ? CalendarService.getPreviousMonth(currentMonth)
+            : CalendarService.getNextMonth(currentMonth);
+
+          set({ currentMonth: newMonth });
+        },
+
+        /**
+         * Navigate to previous/next week
+         */
+        navigateWeek: (direction: 'prev' | 'next') => {
+          const selectedDate = get().selectedDate;
+          const newDate = direction === 'prev'
+            ? CalendarService.getPreviousWeek(selectedDate)
+            : CalendarService.getNextWeek(selectedDate);
+
+          set({ selectedDate: newDate });
+        },
+
+        /**
+         * Set current month directly
+         */
+        setCurrentMonth: (date: Date) => {
+          set({ currentMonth: date });
+        },
+
+        /**
+         * Set view mode
+         */
+        setViewMode: (mode: CalendarViewMode) => {
+          set({ viewMode: mode });
+        },
+
+        /**
+         * Get events for a specific date
+         */
+        getEventsForDate: (date: Date) => {
+          const events = get().events;
+          return CalendarService.getEventsForDate(date, events);
+        },
+
+        /**
+         * Get events for a specific month
+         */
+        getEventsForMonth: (year: number, month: number) => {
+          const events = get().events;
+          const firstDay = new Date(year, month, 1);
+          const lastDay = new Date(year, month + 1, 0);
+          return CalendarService.getEventsInRange(firstDay, lastDay, events);
+        },
+
+        /**
+         * Clear error state
+         */
+        clearError: () => {
+          set({ error: null });
+        },
+
+        /**
+         * Clear all events (for testing/reset)
+         */
+        clearAllEvents: async () => {
+          set({ isLoading: true, error: null });
+          try {
+            await AsyncStorage.removeItem(STORAGE_KEY);
+            set({ events: [], isLoading: false });
+          } catch (error) {
+            set({
+              error: error instanceof Error ? error.message : 'Failed to clear events',
+              isLoading: false
+            });
+          }
+        },
+      },
+    }),
+    {
+      name: 'calendar-storage',
+      storage: createJSONStorage(() => AsyncStorage),
+      // Only persist events, not UI state
+      partialize: (state) => ({ events: state.events }),
+    }
+  )
+);