create-gufran-expo-app 2.0.0 → 2.0.2

package/template/src/utils/imagePicker.ts

@@ -0,0 +1,321 @@
+import * as ImagePicker from 'expo-image-picker';
+import { launchCamera as RNLaunchCamera, ImagePickerResponse, MediaType, CameraOptions, PhotoQuality } from 'react-native-image-picker';
+import { Alert, Linking, Platform } from 'react-native';
+import { requestPermission } from './permissions';
+
+export interface ImagePickerResult {
+  uri: string;
+  width: number;
+  height: number;
+  type?: string;
+  fileName?: string;
+  fileSize?: number;
+}
+
+export interface ImagePickerOptions {
+  allowsEditing?: boolean;
+  aspect?: [number, number];
+  quality?: number;
+  base64?: boolean;
+  exif?: boolean;
+}
+
+/**
+ * Request camera permission
+ */
+export const requestCameraPermission = async (): Promise<boolean> => {
+  const result = await requestPermission('camera');
+  return result.granted;
+};
+
+/**
+ * Request camera roll permission
+ */
+export const requestCameraRollPermission = async (): Promise<boolean> => {
+  const result = await requestPermission('cameraRoll');
+  return result.granted;
+};
+
+/**
+ * Convert quality number to PhotoQuality type
+ */
+const convertQualityToPhotoQuality = (quality: number): PhotoQuality => {
+  // PhotoQuality accepts: 0 | 0.1 | 0.2 | 0.3 | 0.4 | 0.5 | 0.6 | 0.7 | 0.8 | 0.9 | 1
+  const allowedValues: PhotoQuality[] = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1];
+  // Clamp quality between 0 and 1
+  const clampedQuality = Math.max(0, Math.min(1, quality));
+  // Round to nearest allowed value
+  const rounded = Math.round(clampedQuality * 10) / 10;
+  // Find closest allowed value
+  return allowedValues.reduce((prev, curr) => 
+    Math.abs(curr - rounded) < Math.abs(prev - rounded) ? curr : prev
+  );
+};
+
+/**
+ * Launch camera to take a photo
+ */
+export const launchCamera = async (options: ImagePickerOptions = {}): Promise<ImagePickerResult | null> => {
+  try {
+    // Check camera permission
+    const hasPermission = await requestCameraPermission();
+    if (!hasPermission) {
+      Alert.alert(
+        'Permission Required',
+        'Camera permission is required to take photos. Please enable it in settings.',
+        [
+          { text: 'Cancel', style: 'cancel' },
+          { text: 'Settings', onPress: () => {
+            // You can add logic to open app settings here
+            Linking.openSettings();
+          }},
+        ]
+      );
+      return null;
+    }
+
+    // Prepare react-native-image-picker options
+    const cameraOptions: CameraOptions = {
+      mediaType: 'photo' as MediaType,
+      quality: convertQualityToPhotoQuality(options.quality ?? 0.8),
+      includeBase64: options.base64 ?? false,
+      saveToPhotos: false, // Set to false to avoid requesting photo library permission on iOS
+
+    };
+
+    // Handle aspect ratio if allowsEditing is true
+    if (options.allowsEditing ?? true) {
+      const [aspectX, aspectY] = options.aspect ?? [1, 1];
+      // react-native-image-picker doesn't support aspect ratio directly
+      // but we can use maxWidth and maxHeight for basic constraints
+      // For square images (1:1), we can set equal max dimensions
+      if (aspectX === aspectY) {
+        cameraOptions.maxWidth = 1080;
+        cameraOptions.maxHeight = 1080;
+      }
+    }
+
+    // Use Promise wrapper for react-native-image-picker
+    const result: ImagePickerResponse = await new Promise((resolve, reject) => {
+      RNLaunchCamera(cameraOptions, (response) => {
+        resolve(response);
+      });
+    });
+
+    // Check if user cancelled
+    if (result.didCancel) {
+      return null;
+    }
+
+    // Check for errors
+    if (result.errorCode) {
+      console.error('Camera error:', result.errorMessage);
+      Alert.alert('Error', result.errorMessage || 'Failed to open camera. Please try again.');
+      return null;
+    }
+
+    // Extract image data
+    if (result.assets && result.assets.length > 0) {
+      const asset = result.assets[0];
+      return {
+        uri: asset.uri || '',
+        width: asset.width || 0,
+        height: asset.height || 0,
+        type: asset.type || 'image/jpeg',
+        fileName: `image_${Date.now()}.jpg`,
+        fileSize: asset.fileSize || 0,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('Error launching camera:', error);
+    Alert.alert('Error', 'Failed to open camera. Please try again.');
+    return null;
+  }
+};
+
+/**
+ * Launch image library to select a photo
+ */
+export const launchImageLibrary = async (options: ImagePickerOptions = {}): Promise<ImagePickerResult | null> => {
+  try {
+    // Request gallery permission for iOS only
+    if (Platform.OS === 'ios') {
+      const hasPermission = await requestCameraRollPermission();
+      if (!hasPermission) {
+        Alert.alert(
+          'Permission Required',
+          'Photo library permission is required to select images. Please enable it in settings.',
+          [
+            { text: 'Cancel', style: 'cancel' },
+            { text: 'Settings', onPress: () => {
+              Linking.openSettings();
+            }},
+          ]
+        );
+        return null;
+      }
+    }
+
+    const result = await ImagePicker.launchImageLibraryAsync({
+      mediaTypes: ["images"],
+      quality: options.quality ?? 0.8,
+      aspect: options.aspect ?? [1, 1],
+      base64: options.base64 ?? false,
+      exif: options.exif ?? false,
+    });
+
+    console.log("result11===>>>>", JSON.stringify(result));
+
+    if (!result.canceled && result.assets && result.assets.length > 0) {
+      const asset = result.assets[0];
+      return {
+        uri: asset.uri,
+        width: asset.width,
+        height: asset.height,
+        type: asset.type,
+        fileName: `image_${Date.now()}.jpg`,
+        fileSize: asset.fileSize,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('Error launching image library:', error);
+    Alert.alert('Error', 'Failed to open photo library. Please try again.');
+    return null;
+  }
+};
+
+/**
+ * Show action sheet with camera and gallery options
+ */
+export const showImagePickerOptions = (
+  onCameraPress: () => void,
+  onGalleryPress: () => void,
+  onCancelPress?: () => void
+): void => {
+  const options = [
+    { text: 'Camera', onPress: onCameraPress },
+    { text: 'Gallery', onPress: onGalleryPress },
+    { text: 'Cancel', onPress: onCancelPress, style: 'cancel' as const },
+  ];
+
+  Alert.alert(
+    'Select Image',
+    'Choose how you want to add an image',
+    options,
+    { cancelable: true }
+  );
+};
+
+/**
+ * Complete image picker flow with action sheet
+ */
+export const pickImage = async (options: ImagePickerOptions & { source?: 'camera' | 'gallery' } = {}): Promise<ImagePickerResult | null> => {
+  if (options.source === 'camera') {
+    console.log("options--->", options);
+    return await launchCamera(options);
+  } else if (options.source === 'gallery') {
+    return await launchImageLibrary(options);
+  }
+
+  return new Promise((resolve) => {
+    showImagePickerOptions(
+      async () => {
+        const result = await launchCamera(options);
+        resolve(result);
+      },
+      async () => {
+        const result = await launchImageLibrary(options);
+        resolve(result);
+      },
+      () => {
+        resolve(null);
+      }
+    );
+  });
+};
+
+/**
+ * Get image picker permissions status
+ */
+export const getImagePickerPermissions = async () => {
+  const cameraStatus = await ImagePicker.getCameraPermissionsAsync();
+  const mediaLibraryStatus = await ImagePicker.getMediaLibraryPermissionsAsync();
+
+  return {
+    camera: {
+      granted: cameraStatus.granted,
+      canAskAgain: cameraStatus.canAskAgain,
+    },
+    mediaLibrary: {
+      granted: mediaLibraryStatus.granted,
+      canAskAgain: mediaLibraryStatus.canAskAgain,
+    },
+  };
+};
+
+/**
+ * Request all image picker permissions
+ */
+export const requestImagePickerPermissions = async () => {
+  const cameraStatus = await ImagePicker.requestCameraPermissionsAsync();
+  const mediaLibraryStatus = await ImagePicker.requestMediaLibraryPermissionsAsync();
+
+  return {
+    camera: {
+      granted: cameraStatus.granted,
+      canAskAgain: cameraStatus.canAskAgain,
+    },
+    mediaLibrary: {
+      granted: mediaLibraryStatus.granted,
+      canAskAgain: mediaLibraryStatus.canAskAgain,
+    },
+  };
+};
+
+/**
+ * Utility to format file size
+ */
+export const formatFileSize = (bytes: number): string => {
+  if (bytes === 0) return '0 Bytes';
+  
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+};
+
+/**
+ * Utility to validate image file
+ */
+export const validateImageFile = (result: ImagePickerResult): { isValid: boolean; error?: string } => {
+  const maxSize = 10 * 1024 * 1024; // 10MB
+  const minSize = 1024; // 1KB
+  
+  if (result.fileSize && result.fileSize > maxSize) {
+    return {
+      isValid: false,
+      error: `Image size is too large. Maximum allowed size is ${formatFileSize(maxSize)}.`,
+    };
+  }
+  
+  if (result.fileSize && result.fileSize < minSize) {
+    return {
+      isValid: false,
+      error: 'Image size is too small. Please select a valid image.',
+    };
+  }
+  
+  if (!result.uri) {
+    return {
+      isValid: false,
+      error: 'Invalid image. Please try again.',
+    };
+  }
+  
+  return { isValid: true };
+};

package/template/src/utils/index.ts

@@ -0,0 +1,111 @@
+// Validation utilities - Re-export from validation class for backward compatibility
+export * from './validation';
+
+// String utilities
+export const capitalize = (str: string): string => {
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+export const truncateText = (text: string, maxLength: number): string => {
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength).trim() + '...';
+};
+
+export const generateId = (): string => {
+  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+};
+
+// Date utilities
+export const formatDate = (date: Date): string => {
+  return new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  }).format(date);
+};
+
+export const formatDateTime = (date: Date): string => {
+  return new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  }).format(date);
+};
+
+export const formatReminderDateTime = (dateString: string): string => {
+  try {
+    const date = new Date(dateString);
+    
+    // Format: "30 May 2025, 3:00 PM"
+    const day = date.getDate();
+    const month = date.toLocaleString('en-US', { month: 'short' });
+    const year = date.getFullYear();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    
+    // Convert to 12-hour format
+    const period = hours >= 12 ? 'PM' : 'AM';
+    const displayHours = hours % 12 || 12;
+    const displayMinutes = minutes.toString().padStart(2, '0');
+    
+    return `${day} ${month} ${year}, ${displayHours}:${displayMinutes} ${period}`;
+  } catch (error) {
+    console.error('Error formatting reminder date:', error);
+    return dateString;
+  }
+};
+
+export const isToday = (date: Date): boolean => {
+  const today = new Date();
+  return date.toDateString() === today.toDateString();
+};
+
+// Platform utilities
+export const isIOS = (): boolean => {
+  return require('react-native').Platform.OS === 'ios';
+};
+
+export const isAndroid = (): boolean => {
+  return require('react-native').Platform.OS === 'android';
+};
+
+// API utilities
+export const createQueryString = (params: Record<string, any>): string => {
+  const searchParams = new URLSearchParams();
+  
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== null && value !== undefined && value !== '') {
+      searchParams.append(key, String(value));
+    }
+  });
+  
+  return searchParams.toString();
+};
+
+export const delay = (ms: number): Promise<void> => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+// Re-export storage utilities
+export * from './storage';
+
+// Re-export permission utilities
+export * from './permissions';
+
+// Re-export permission hooks
+export * from './usePermissions';
+
+// Re-export image picker utilities
+export * from './imagePicker';
+
+// Re-export UploadDebugUtil
+export * from './UploadDebugUtil';
+
+// Re-export AzureUploaderService
+export * from './AzureUploaderService';
+
+// Re-export ClubSearchManager
+export * from './ClubSearchManager';
+

package/template/src/utils/permissions.ts

@@ -0,0 +1,277 @@
+import { Platform } from 'react-native';
+import {
+  PERMISSIONS,
+  RESULTS,
+  Permission,
+  PermissionStatus,
+  request,
+  check,
+  requestMultiple,
+  checkMultiple,
+} from 'react-native-permissions';
+
+export type PermissionType = 
+  | 'camera'
+  | 'cameraRoll';
+
+export interface PermissionResult {
+  status: 'granted' | 'denied' | 'undetermined' | 'blocked';
+  canAskAgain: boolean;
+  expires?: 'never' | number;
+}
+
+export interface PermissionRequestResult {
+  granted: boolean;
+  status: 'granted' | 'denied' | 'undetermined' | 'blocked';
+  canAskAgain: boolean;
+  expires?: 'never' | number;
+}
+
+// Map permission types to react-native-permissions constants
+const getPermissionConstant = (permission: PermissionType): Permission => {
+  const permissionMap: Record<PermissionType, Permission> = {
+    camera: Platform.OS === 'ios' ? PERMISSIONS.IOS.CAMERA : PERMISSIONS.ANDROID.CAMERA,
+    cameraRoll: Platform.OS === 'ios' ? PERMISSIONS.IOS.PHOTO_LIBRARY : PERMISSIONS.ANDROID.READ_EXTERNAL_STORAGE,
+  };
+  
+  return permissionMap[permission];
+};
+
+// Convert react-native-permissions status to our format
+const convertPermissionStatus = (status: PermissionStatus): PermissionResult => {
+  const statusMap: Record<PermissionStatus, PermissionResult['status']> = {
+    [RESULTS.GRANTED]: 'granted',
+    [RESULTS.DENIED]: 'denied',
+    [RESULTS.BLOCKED]: 'blocked',
+    [RESULTS.UNAVAILABLE]: 'denied',
+    [RESULTS.LIMITED]: 'granted',
+  };
+
+  return {
+    status: statusMap[status] || 'denied',
+    canAskAgain: status === RESULTS.DENIED,
+    expires: 'never',
+  };
+};
+
+/**
+ * Request a single permission
+ */
+export const requestPermission = async (permission: PermissionType): Promise<PermissionRequestResult> => {
+  try {
+    const permissionConstant = getPermissionConstant(permission);
+    const status = await request(permissionConstant);
+    const result = convertPermissionStatus(status);
+    
+    return {
+      granted: result.status === 'granted',
+      status: result.status,
+      canAskAgain: result.canAskAgain,
+      expires: result.expires,
+    };
+  } catch (error) {
+    console.error(`Error requesting permission ${permission}:`, error);
+    return {
+      granted: false,
+      status: 'denied',
+      canAskAgain: false,
+    };
+  }
+};
+
+/**
+ * Request multiple permissions at once
+ */
+export const requestMultiplePermissions = async (permissions: PermissionType[]): Promise<Record<PermissionType, PermissionRequestResult>> => {
+  try {
+    const permissionConstants = permissions.map(getPermissionConstant);
+    const results = await requestMultiple(permissionConstants);
+    const permissionResults: Record<PermissionType, PermissionRequestResult> = {} as any;
+    
+    permissions.forEach((permission, index) => {
+      const status = results[permissionConstants[index]];
+      const result = convertPermissionStatus(status);
+      
+      permissionResults[permission] = {
+        granted: result.status === 'granted',
+        status: result.status,
+        canAskAgain: result.canAskAgain,
+        expires: result.expires,
+      };
+    });
+    
+    return permissionResults;
+  } catch (error) {
+    console.error('Error requesting multiple permissions:', error);
+    const failedResults: Record<PermissionType, PermissionRequestResult> = {} as any;
+    
+    permissions.forEach(permission => {
+      failedResults[permission] = {
+        granted: false,
+        status: 'denied',
+        canAskAgain: false,
+      };
+    });
+    
+    return failedResults;
+  }
+};
+
+/**
+ * Get the current status of a permission without requesting it
+ */
+export const getPermissionStatus = async (permission: PermissionType): Promise<PermissionResult> => {
+  try {
+    const permissionConstant = getPermissionConstant(permission);
+    const status = await check(permissionConstant);
+    return convertPermissionStatus(status);
+  } catch (error) {
+    console.error(`Error getting permission status for ${permission}:`, error);
+    return {
+      status: 'denied',
+      canAskAgain: false,
+    };
+  }
+};
+
+/**
+ * Get the current status of multiple permissions
+ */
+export const getMultiplePermissionStatuses = async (permissions: PermissionType[]): Promise<Record<PermissionType, PermissionResult>> => {
+  try {
+    const permissionConstants = permissions.map(getPermissionConstant);
+    const results = await checkMultiple(permissionConstants);
+    const permissionResults: Record<PermissionType, PermissionResult> = {} as any;
+    
+    permissions.forEach((permission, index) => {
+      const status = results[permissionConstants[index]];
+      permissionResults[permission] = convertPermissionStatus(status);
+    });
+    
+    return permissionResults;
+  } catch (error) {
+    console.error('Error getting multiple permission statuses:', error);
+    const failedResults: Record<PermissionType, PermissionResult> = {} as any;
+    
+    permissions.forEach(permission => {
+      failedResults[permission] = {
+        status: 'denied',
+        canAskAgain: false,
+      };
+    });
+    
+    return failedResults;
+  }
+};
+
+/**
+ * Check if a permission is granted
+ */
+export const isPermissionGranted = async (permission: PermissionType): Promise<boolean> => {
+  const status = await getPermissionStatus(permission);
+  return status.status === 'granted';
+};
+
+/**
+ * Check if multiple permissions are granted
+ */
+export const arePermissionsGranted = async (permissions: PermissionType[]): Promise<Record<PermissionType, boolean>> => {
+  const statuses = await getMultiplePermissionStatuses(permissions);
+  const results: Record<PermissionType, boolean> = {} as any;
+  
+  permissions.forEach(permission => {
+    results[permission] = statuses[permission].status === 'granted';
+  });
+  
+  return results;
+};
+
+/**
+ * Request permission with user-friendly error handling
+ */
+export const requestPermissionWithFallback = async (
+  permission: PermissionType,
+  onDenied?: () => void,
+  onError?: (error: Error) => void
+): Promise<boolean> => {
+  try {
+    const result = await requestPermission(permission);
+    
+    if (!result.granted) {
+      if (result.canAskAgain) {
+        // Permission was denied but can ask again
+        console.log(`Permission ${permission} was denied but can ask again`);
+      } else {
+        // Permission was denied and cannot ask again
+        console.log(`Permission ${permission} was denied and cannot ask again`);
+        onDenied?.();
+      }
+    }
+    
+    return result.granted;
+  } catch (error) {
+    console.error(`Error requesting permission ${permission}:`, error);
+    onError?.(error as Error);
+    return false;
+  }
+};
+
+/**
+ * Common permission combinations
+ */
+export const PermissionGroups = {
+  camera: ['camera', 'cameraRoll'] as PermissionType[],
+  media: ['camera', 'cameraRoll', 'audioRecording'] as PermissionType[],
+} as const;
+
+/**
+ * Request a group of related permissions
+ */
+export const requestPermissionGroup = async (group: keyof typeof PermissionGroups): Promise<Record<PermissionType, PermissionRequestResult>> => {
+  const permissions = PermissionGroups[group];
+  return requestMultiplePermissions(permissions);
+};
+
+/**
+ * Check if all permissions in a group are granted
+ */
+export const isPermissionGroupGranted = async (group: keyof typeof PermissionGroups): Promise<boolean> => {
+  const permissions = PermissionGroups[group];
+  const results = await arePermissionsGranted(permissions);
+  return Object.values(results).every(granted => granted);
+};
+
+/**
+ * Platform-specific permission helpers
+ */
+export const PlatformPermissions = {
+  /**
+   * Check if the platform supports the permission
+   */
+  isSupported: (permission: PermissionType): boolean => {
+    if (Platform.OS === 'ios') {
+      // iOS supports all permissions
+      return true;
+    } else if (Platform.OS === 'android') {
+      // Android-specific permission checks
+      const androidSupportedPermissions: PermissionType[] = [
+        'camera',
+        'cameraRoll',
+      ];
+      return androidSupportedPermissions.includes(permission);
+    }
+    return false;
+  },
+
+  /**
+   * Get platform-specific permission name
+   */
+  getPlatformPermissionName: (permission: PermissionType): string => {
+    const permissionNames: Record<PermissionType, string> = {
+      camera: Platform.OS === 'ios' ? 'Camera' : 'Camera',
+      cameraRoll: Platform.OS === 'ios' ? 'Photo Library' : 'Storage'
+    };
+    
+    return permissionNames[permission] || permission;
+  },
+};