@onairos/react-native 3.1.16 → 3.1.18

package/src/utils/eventUtils.ts

@@ -1,303 +1,303 @@
-/**
- * Event utility functions for event management
- */
-
-/**
- * Generate a random alphanumeric event code
- * @param length - Length of the code (default: 6)
- * @returns Random event code
- */
-export const generateEventCode = (length: number = 6): string => {
-  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-  let result = '';
-  
-  for (let i = 0; i < length; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  
-  return result;
-};
-
-/**
- * Generate a smart event code based on the event title
- * @param title - Event title
- * @returns Smart event code
- */
-export const generateSmartEventCode = (title: string): string => {
-  if (!title.trim()) {
-    return generateEventCode();
-  }
-
-  // Clean the title and split into words
-  const words = title
-    .trim()
-    .toUpperCase()
-    .replace(/[^A-Z0-9\s]/g, '') // Remove special characters
-    .split(/\s+/)
-    .filter(word => word.length > 0);
-
-  if (words.length === 0) {
-    return generateEventCode();
-  }
-
-  let code = '';
-  
-  // Strategy 1: Take first 2 letters of each word (up to 3 words)
-  if (words.length >= 2) {
-    const significantWords = words.slice(0, 3);
-    code = significantWords
-      .map(word => word.substring(0, 2))
-      .join('');
-  } else {
-    // Strategy 2: Single word - take first 4 letters
-    code = words[0].substring(0, 4);
-  }
-
-  // Add current year's last 2 digits
-  const currentYear = new Date().getFullYear().toString().slice(-2);
-  code += currentYear;
-
-  // Ensure minimum length of 4 and maximum of 8
-  if (code.length < 4) {
-    code += generateEventCode(4 - code.length);
-  } else if (code.length > 8) {
-    code = code.substring(0, 8);
-  }
-
-  return code;
-};
-
-/**
- * Validate event code format
- * @param code - Event code to validate
- * @returns Object with validation result and error message
- */
-export const validateEventCode = (code: string): { isValid: boolean; error?: string } => {
-  if (!code || !code.trim()) {
-    return { isValid: false, error: 'Event code is required' };
-  }
-
-  const trimmedCode = code.trim().toUpperCase();
-
-  if (trimmedCode.length < 3) {
-    return { isValid: false, error: 'Event code must be at least 3 characters' };
-  }
-
-  if (trimmedCode.length > 10) {
-    return { isValid: false, error: 'Event code must be 10 characters or less' };
-  }
-
-  if (!/^[A-Z0-9]+$/.test(trimmedCode)) {
-    return { isValid: false, error: 'Event code must contain only letters and numbers' };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Format event date for display
- * @param dateString - Date string in YYYY-MM-DD format
- * @returns Formatted date string
- */
-export const formatEventDate = (dateString: string): string => {
-  try {
-    const date = new Date(dateString);
-    return date.toLocaleDateString('en-US', {
-      weekday: 'long',
-      year: 'numeric',
-      month: 'long',
-      day: 'numeric',
-    });
-  } catch (error) {
-    return dateString;
-  }
-};
-
-/**
- * Check if an event is happening today
- * @param eventDate - Event date string
- * @returns True if event is today
- */
-export const isEventToday = (eventDate: string): boolean => {
-  try {
-    const today = new Date();
-    const event = new Date(eventDate);
-    
-    return (
-      today.getFullYear() === event.getFullYear() &&
-      today.getMonth() === event.getMonth() &&
-      today.getDate() === event.getDate()
-    );
-  } catch (error) {
-    return false;
-  }
-};
-
-/**
- * Check if an event is in the past
- * @param eventDate - Event date string
- * @returns True if event is in the past
- */
-export const isEventPast = (eventDate: string): boolean => {
-  try {
-    const today = new Date();
-    const event = new Date(eventDate);
-    
-    // Set time to start of day for accurate comparison
-    today.setHours(0, 0, 0, 0);
-    event.setHours(0, 0, 0, 0);
-    
-    return event < today;
-  } catch (error) {
-    return false;
-  }
-};
-
-/**
- * Get event status based on date and active status
- * @param eventDate - Event date string
- * @param isActive - Whether event is active
- * @returns Event status string
- */
-export const getEventStatus = (eventDate: string, isActive: boolean): string => {
-  if (!isActive) {
-    return 'Inactive';
-  }
-  
-  if (isEventPast(eventDate)) {
-    return 'Past';
-  }
-  
-  if (isEventToday(eventDate)) {
-    return 'Today';
-  }
-  
-  return 'Upcoming';
-};
-
-/**
- * Calculate days until event
- * @param eventDate - Event date string
- * @returns Number of days until event (negative if past)
- */
-export const getDaysUntilEvent = (eventDate: string): number => {
-  try {
-    const today = new Date();
-    const event = new Date(eventDate);
-    
-    // Set time to start of day for accurate comparison
-    today.setHours(0, 0, 0, 0);
-    event.setHours(0, 0, 0, 0);
-    
-    const diffTime = event.getTime() - today.getTime();
-    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
-    
-    return diffDays;
-  } catch (error) {
-    return 0;
-  }
-};
-
-/**
- * Sort events by date (upcoming first, then past events)
- * @param events - Array of events
- * @returns Sorted array of events
- */
-export const sortEventsByDate = <T extends { eventDate: string; isActive: boolean }>(events: T[]): T[] => {
-  return events.sort((a, b) => {
-    // Active events first
-    if (a.isActive && !b.isActive) return -1;
-    if (!a.isActive && b.isActive) return 1;
-    
-    // Then sort by date
-    const dateA = new Date(a.eventDate);
-    const dateB = new Date(b.eventDate);
-    
-    // Upcoming events first (ascending), then past events (descending)
-    const today = new Date();
-    const aIsPast = dateA < today;
-    const bIsPast = dateB < today;
-    
-    if (aIsPast && !bIsPast) return 1;
-    if (!aIsPast && bIsPast) return -1;
-    
-    if (aIsPast && bIsPast) {
-      return dateB.getTime() - dateA.getTime(); // Past events: most recent first
-    } else {
-      return dateA.getTime() - dateB.getTime(); // Upcoming events: soonest first
-    }
-  });
-};
-
-/**
- * Filter events by search query
- * @param events - Array of events
- * @param query - Search query
- * @returns Filtered array of events
- */
-export const filterEventsBySearch = <T extends { 
-  title: string; 
-  description: string; 
-  code: string; 
-  location?: string; 
-  organizer?: string;
-  tags?: string[];
-}>(events: T[], query: string): T[] => {
-  if (!query.trim()) {
-    return events;
-  }
-  
-  const searchTerm = query.toLowerCase().trim();
-  
-  return events.filter(event => 
-    event.title.toLowerCase().includes(searchTerm) ||
-    event.description.toLowerCase().includes(searchTerm) ||
-    event.code.toLowerCase().includes(searchTerm) ||
-    event.location?.toLowerCase().includes(searchTerm) ||
-    event.organizer?.toLowerCase().includes(searchTerm) ||
-    event.tags?.some(tag => tag.toLowerCase().includes(searchTerm))
-  );
-};
-
-/**
- * Get unique tags from events
- * @param events - Array of events
- * @returns Array of unique tags
- */
-export const getUniqueEventTags = <T extends { tags?: string[] }>(events: T[]): string[] => {
-  const allTags = events.flatMap(event => event.tags || []);
-  return Array.from(new Set(allTags)).sort();
-};
-
-/**
- * Calculate event statistics
- * @param events - Array of events
- * @returns Event statistics object
- */
-export const calculateEventStats = <T extends { 
-  isActive: boolean; 
-  attendeeCount: number; 
-  maxAttendees: number;
-  eventDate: string;
-}>(events: T[]) => {
-  const total = events.length;
-  const active = events.filter(e => e.isActive).length;
-  const inactive = total - active;
-  const totalAttendees = events.reduce((sum, e) => sum + e.attendeeCount, 0);
-  const totalCapacity = events.reduce((sum, e) => sum + e.maxAttendees, 0);
-  const upcoming = events.filter(e => e.isActive && !isEventPast(e.eventDate)).length;
-  const past = events.filter(e => isEventPast(e.eventDate)).length;
-  const today = events.filter(e => e.isActive && isEventToday(e.eventDate)).length;
-  
-  return {
-    total,
-    active,
-    inactive,
-    upcoming,
-    past,
-    today,
-    totalAttendees,
-    totalCapacity,
-    averageAttendance: totalCapacity > 0 ? Math.round((totalAttendees / totalCapacity) * 100) : 0,
-  };
+/**
+ * Event utility functions for event management
+ */
+
+/**
+ * Generate a random alphanumeric event code
+ * @param length - Length of the code (default: 6)
+ * @returns Random event code
+ */
+export const generateEventCode = (length: number = 6): string => {
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  let result = '';
+  
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  
+  return result;
+};
+
+/**
+ * Generate a smart event code based on the event title
+ * @param title - Event title
+ * @returns Smart event code
+ */
+export const generateSmartEventCode = (title: string): string => {
+  if (!title.trim()) {
+    return generateEventCode();
+  }
+
+  // Clean the title and split into words
+  const words = title
+    .trim()
+    .toUpperCase()
+    .replace(/[^A-Z0-9\s]/g, '') // Remove special characters
+    .split(/\s+/)
+    .filter(word => word.length > 0);
+
+  if (words.length === 0) {
+    return generateEventCode();
+  }
+
+  let code = '';
+  
+  // Strategy 1: Take first 2 letters of each word (up to 3 words)
+  if (words.length >= 2) {
+    const significantWords = words.slice(0, 3);
+    code = significantWords
+      .map(word => word.substring(0, 2))
+      .join('');
+  } else {
+    // Strategy 2: Single word - take first 4 letters
+    code = words[0].substring(0, 4);
+  }
+
+  // Add current year's last 2 digits
+  const currentYear = new Date().getFullYear().toString().slice(-2);
+  code += currentYear;
+
+  // Ensure minimum length of 4 and maximum of 8
+  if (code.length < 4) {
+    code += generateEventCode(4 - code.length);
+  } else if (code.length > 8) {
+    code = code.substring(0, 8);
+  }
+
+  return code;
+};
+
+/**
+ * Validate event code format
+ * @param code - Event code to validate
+ * @returns Object with validation result and error message
+ */
+export const validateEventCode = (code: string): { isValid: boolean; error?: string } => {
+  if (!code || !code.trim()) {
+    return { isValid: false, error: 'Event code is required' };
+  }
+
+  const trimmedCode = code.trim().toUpperCase();
+
+  if (trimmedCode.length < 3) {
+    return { isValid: false, error: 'Event code must be at least 3 characters' };
+  }
+
+  if (trimmedCode.length > 10) {
+    return { isValid: false, error: 'Event code must be 10 characters or less' };
+  }
+
+  if (!/^[A-Z0-9]+$/.test(trimmedCode)) {
+    return { isValid: false, error: 'Event code must contain only letters and numbers' };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Format event date for display
+ * @param dateString - Date string in YYYY-MM-DD format
+ * @returns Formatted date string
+ */
+export const formatEventDate = (dateString: string): string => {
+  try {
+    const date = new Date(dateString);
+    return date.toLocaleDateString('en-US', {
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+    });
+  } catch (error) {
+    return dateString;
+  }
+};
+
+/**
+ * Check if an event is happening today
+ * @param eventDate - Event date string
+ * @returns True if event is today
+ */
+export const isEventToday = (eventDate: string): boolean => {
+  try {
+    const today = new Date();
+    const event = new Date(eventDate);
+    
+    return (
+      today.getFullYear() === event.getFullYear() &&
+      today.getMonth() === event.getMonth() &&
+      today.getDate() === event.getDate()
+    );
+  } catch (error) {
+    return false;
+  }
+};
+
+/**
+ * Check if an event is in the past
+ * @param eventDate - Event date string
+ * @returns True if event is in the past
+ */
+export const isEventPast = (eventDate: string): boolean => {
+  try {
+    const today = new Date();
+    const event = new Date(eventDate);
+    
+    // Set time to start of day for accurate comparison
+    today.setHours(0, 0, 0, 0);
+    event.setHours(0, 0, 0, 0);
+    
+    return event < today;
+  } catch (error) {
+    return false;
+  }
+};
+
+/**
+ * Get event status based on date and active status
+ * @param eventDate - Event date string
+ * @param isActive - Whether event is active
+ * @returns Event status string
+ */
+export const getEventStatus = (eventDate: string, isActive: boolean): string => {
+  if (!isActive) {
+    return 'Inactive';
+  }
+  
+  if (isEventPast(eventDate)) {
+    return 'Past';
+  }
+  
+  if (isEventToday(eventDate)) {
+    return 'Today';
+  }
+  
+  return 'Upcoming';
+};
+
+/**
+ * Calculate days until event
+ * @param eventDate - Event date string
+ * @returns Number of days until event (negative if past)
+ */
+export const getDaysUntilEvent = (eventDate: string): number => {
+  try {
+    const today = new Date();
+    const event = new Date(eventDate);
+    
+    // Set time to start of day for accurate comparison
+    today.setHours(0, 0, 0, 0);
+    event.setHours(0, 0, 0, 0);
+    
+    const diffTime = event.getTime() - today.getTime();
+    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+    
+    return diffDays;
+  } catch (error) {
+    return 0;
+  }
+};
+
+/**
+ * Sort events by date (upcoming first, then past events)
+ * @param events - Array of events
+ * @returns Sorted array of events
+ */
+export const sortEventsByDate = <T extends { eventDate: string; isActive: boolean }>(events: T[]): T[] => {
+  return events.sort((a, b) => {
+    // Active events first
+    if (a.isActive && !b.isActive) return -1;
+    if (!a.isActive && b.isActive) return 1;
+    
+    // Then sort by date
+    const dateA = new Date(a.eventDate);
+    const dateB = new Date(b.eventDate);
+    
+    // Upcoming events first (ascending), then past events (descending)
+    const today = new Date();
+    const aIsPast = dateA < today;
+    const bIsPast = dateB < today;
+    
+    if (aIsPast && !bIsPast) return 1;
+    if (!aIsPast && bIsPast) return -1;
+    
+    if (aIsPast && bIsPast) {
+      return dateB.getTime() - dateA.getTime(); // Past events: most recent first
+    } else {
+      return dateA.getTime() - dateB.getTime(); // Upcoming events: soonest first
+    }
+  });
+};
+
+/**
+ * Filter events by search query
+ * @param events - Array of events
+ * @param query - Search query
+ * @returns Filtered array of events
+ */
+export const filterEventsBySearch = <T extends { 
+  title: string; 
+  description: string; 
+  code: string; 
+  location?: string; 
+  organizer?: string;
+  tags?: string[];
+}>(events: T[], query: string): T[] => {
+  if (!query.trim()) {
+    return events;
+  }
+  
+  const searchTerm = query.toLowerCase().trim();
+  
+  return events.filter(event => 
+    event.title.toLowerCase().includes(searchTerm) ||
+    event.description.toLowerCase().includes(searchTerm) ||
+    event.code.toLowerCase().includes(searchTerm) ||
+    event.location?.toLowerCase().includes(searchTerm) ||
+    event.organizer?.toLowerCase().includes(searchTerm) ||
+    event.tags?.some(tag => tag.toLowerCase().includes(searchTerm))
+  );
+};
+
+/**
+ * Get unique tags from events
+ * @param events - Array of events
+ * @returns Array of unique tags
+ */
+export const getUniqueEventTags = <T extends { tags?: string[] }>(events: T[]): string[] => {
+  const allTags = events.flatMap(event => event.tags || []);
+  return Array.from(new Set(allTags)).sort();
+};
+
+/**
+ * Calculate event statistics
+ * @param events - Array of events
+ * @returns Event statistics object
+ */
+export const calculateEventStats = <T extends { 
+  isActive: boolean; 
+  attendeeCount: number; 
+  maxAttendees: number;
+  eventDate: string;
+}>(events: T[]) => {
+  const total = events.length;
+  const active = events.filter(e => e.isActive).length;
+  const inactive = total - active;
+  const totalAttendees = events.reduce((sum, e) => sum + e.attendeeCount, 0);
+  const totalCapacity = events.reduce((sum, e) => sum + e.maxAttendees, 0);
+  const upcoming = events.filter(e => e.isActive && !isEventPast(e.eventDate)).length;
+  const past = events.filter(e => isEventPast(e.eventDate)).length;
+  const today = events.filter(e => e.isActive && isEventToday(e.eventDate)).length;
+  
+  return {
+    total,
+    active,
+    inactive,
+    upcoming,
+    past,
+    today,
+    totalAttendees,
+    totalCapacity,
+    averageAttendance: totalCapacity > 0 ? Math.round((totalAttendees / totalCapacity) * 100) : 0,
+  };
 };