@explorins/pers-sdk-react-native 1.3.2 → 1.5.1

package/src/hooks/useCampaigns.ts

@@ -1,96 +1,174 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import type { 
+  CampaignClaimRequestDTO, 
+  CampaignDTO, 
+  CampaignClaimDTO, 
+  CampaignTriggerDTO,
+  CampaignCreateRequestDTO,
+  TokenUnitCreateRequestDTO,
+  CampaignBusinessEngagementCreateRequestDTO 
+} from '@explorins/pers-shared';
 
 export const useCampaigns = () => {
-  const { campaigns, isInitialized, isAuthenticated } = usePersSDK();
+  const { sdk, isInitialized, isAuthenticated } = usePersSDK();
 
-  const getActiveCampaigns = useCallback(async () => {
-    if (!isInitialized) {
+  const getActiveCampaigns = useCallback(async (): Promise<CampaignDTO[]> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!campaigns?.getActiveCampaigns) {
-      console.warn('getActiveCampaigns method not available');
-      return [];
-    }
     
     try {
-      const result = await campaigns.getActiveCampaigns();
-      console.log('✅ Active campaigns fetched successfully:', result);
+      const result = await sdk.campaigns.getActiveCampaigns();
+      console.log('Active campaigns fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch active campaigns:', error);
+      console.error('Failed to fetch active campaigns:', error);
       throw error;
     }
-  }, [campaigns]);
+  }, [sdk, isInitialized]);
 
-  const getCampaignById = useCallback(async (campaignId: string) => {
-    if (!isInitialized) {
+  const getCampaignById = useCallback(async (campaignId: string): Promise<CampaignDTO | null> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!campaigns?.getCampaignById) {
-      throw new Error('getCampaignById method not available');
-    }
     
     try {
-      const result = await campaigns.getCampaignById(campaignId);
-      console.log('✅ Campaign fetched successfully:', result);
+      const result = await sdk.campaigns.getCampaignById(campaignId);
+      console.log('Campaign fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch campaign:', error);
+      console.error('Failed to fetch campaign:', error);
       throw error;
     }
-  }, [campaigns]);
+  }, [sdk, isInitialized]);
 
-  const claimCampaign = useCallback(async (request: any) => {
-    if (!isInitialized) {
+  const claimCampaign = useCallback(async (request: CampaignClaimRequestDTO): Promise<CampaignClaimDTO | null> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     if (!isAuthenticated) {
       throw new Error('SDK not authenticated. claimCampaign requires authentication.');
     }
-    if (!campaigns?.claimCampaign) {
-      throw new Error('claimCampaign method not available');
-    }
     
     try {
-      console.log('🔄 Claiming campaign with request:', request);
-      const result = await campaigns.claimCampaign(request);
-      console.log('✅ Campaign claimed successfully:', result);
+      console.log('Claiming campaign with request:', request);
+      const result = await sdk.campaigns.claimCampaign(request);
+      console.log('Campaign claimed successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to claim campaign:', error);
+      console.error('Failed to claim campaign:', error);
       throw error;
     }
-  }, [isInitialized, isAuthenticated, campaigns]);
+  }, [sdk, isInitialized, isAuthenticated]);
 
-  const getClaimsForLoggedUser = useCallback(async () => {
-    if (!isInitialized) {
+  const getUserClaims = useCallback(async (): Promise<CampaignClaimDTO[]> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     if (!isAuthenticated) {
-      console.warn('SDK not authenticated. getClaimsForLoggedUser requires authentication.');
+      console.warn('SDK not authenticated. getUserClaims requires authentication.');
       return [];
     }
-    if (!campaigns?.getClaimsForLoggedUser) {
-      console.warn('getClaimsForLoggedUser method not available');
-      return [];
+    
+    try {
+      const result = await sdk.campaigns.getUserClaims();
+      console.log('User claims fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch user claims:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized, isAuthenticated]);
+
+  const getCampaignTriggers = useCallback(async (): Promise<CampaignTriggerDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.campaigns.getCampaignTriggers();
+      console.log('Campaign triggers fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch campaign triggers:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  // Admin methods
+  const getAllCampaigns = useCallback(async (active?: boolean): Promise<CampaignDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.campaigns.getAllCampaigns(active);
+      console.log('All campaigns fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch all campaigns:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getCampaignClaims = useCallback(async (): Promise<CampaignClaimDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await campaigns.getClaimsForLoggedUser();
-      console.log('✅ User claims fetched successfully:', result);
+      const result = await sdk.campaigns.getCampaignClaims();
+      console.log('Campaign claims fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch user claims:', error);
+      console.error('Failed to fetch campaign claims:', error);
       throw error;
     }
-  }, [isInitialized, isAuthenticated, campaigns]);
+  }, [sdk, isInitialized]);
+
+  const getCampaignClaimsByUserId = useCallback(async (userId: string): Promise<CampaignClaimDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.campaigns.getCampaignClaimsByUserId(userId);
+      console.log('Campaign claims by user ID fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch campaign claims by user ID:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getCampaignClaimsByBusinessId = useCallback(async (businessId: string): Promise<CampaignClaimDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.campaigns.getCampaignClaimsByBusinessId(businessId);
+      console.log('Campaign claims by business ID fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch campaign claims by business ID:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
 
   return {
     getActiveCampaigns,
     getCampaignById,
     claimCampaign,
-    getClaimsForLoggedUser,
-    isAvailable: isInitialized && !!campaigns,
+    getUserClaims,
+    getCampaignTriggers,
+    getAllCampaigns,
+    getCampaignClaims,
+    getCampaignClaimsByUserId,
+    getCampaignClaimsByBusinessId,
+    isAvailable: isInitialized && !!sdk?.campaigns,
   };
-};
+};
+
+export type CampaignHook = ReturnType<typeof useCampaigns>;

package/src/hooks/useDonations.ts

@@ -0,0 +1,68 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+import type { DonationTypeDTO } from '@explorins/pers-shared';
+
+/**
+ * React hook for donation operations in the PERS SDK
+ * 
+ * Provides methods for managing donations and donation types within the platform.
+ * Supports retrieving available donation categories and types.
+ * 
+ * @returns Donation hook with methods for donation management
+ * 
+ * @example
+ * ```typescript
+ * function DonationsComponent() {
+ *   const { getDonationTypes } = useDonations();
+ *   
+ *   const loadDonationTypes = async () => {
+ *     try {
+ *       const types = await getDonationTypes();
+ *       console.log('Available donation types:', types);
+ *     } catch (error) {
+ *       console.error('Failed to load donation types:', error);
+ *     }
+ *   };
+ * 
+ *   return <button onClick={loadDonationTypes}>Load Donation Types</button>;
+ * }
+ * ```
+ */
+export const useDonations = () => {
+  const { sdk, isInitialized } = usePersSDK();
+
+  /**
+   * Retrieves all available donation types in the system
+   * 
+   * @returns Promise resolving to array of donation types
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getDonationTypes } = useDonations();
+   * const types = await getDonationTypes();
+   * console.log('Donation types:', types.map(t => t.name));
+   * ```
+   */
+  const getDonationTypes = useCallback(async (): Promise<DonationTypeDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.donations.getDonationTypes();
+      console.log('Donation types fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch donation types:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  return {
+    getDonationTypes,
+    isAvailable: isInitialized && !!sdk?.donations,
+  };
+};
+
+export type DonationHook = ReturnType<typeof useDonations>;

package/src/hooks/useFiles.ts

@@ -0,0 +1,160 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+import type { 
+  SignedUrlRequest,
+  FileUploadEntityType
+} from '@explorins/pers-sdk';
+
+/**
+ * React hook for file operations in the PERS SDK
+ * 
+ * Provides methods for generating signed URLs for file uploads and downloads,
+ * media optimization, and secure file access. Supports various entity types
+ * and customizable expiration times.
+ * 
+ * @returns File hook with methods for file management
+ * 
+ * @example
+ * ```typescript
+ * function FileUploadComponent() {
+ *   const { getSignedPutUrl, getSignedGetUrl, optimizeMedia } = useFiles();
+ *   
+ *   const uploadFile = async (entityId: string, file: File) => {
+ *     try {
+ *       const uploadUrl = await getSignedPutUrl(
+ *         entityId, 
+ *         'profile', 
+ *         'jpg'
+ *       );
+ *       
+ *       // Upload file to the signed URL
+ *       await fetch(uploadUrl, {
+ *         method: 'PUT',
+ *         body: file
+ *       });
+ *       
+ *       // Get download URL
+ *       const downloadUrl = await getSignedGetUrl(entityId, 'profile');
+ *       console.log('File uploaded, download URL:', downloadUrl);
+ *     } catch (error) {
+ *       console.error('File upload failed:', error);
+ *     }
+ *   };
+ * 
+ *   return <input type="file" onChange={(e) => uploadFile('user-123', e.target.files[0])} />;
+ * }
+ * ```
+ */
+export const useFiles = () => {
+  const { sdk, isInitialized } = usePersSDK();
+
+  /**
+   * Generates a signed URL for uploading files to cloud storage
+   * 
+   * @param entityId - Unique identifier of the entity the file belongs to
+   * @param entityType - Type of entity ('profile', 'business', 'campaign', etc.)
+   * @param fileExtension - File extension without the dot (e.g., 'jpg', 'png')
+   * @returns Promise resolving to signed upload URL
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getSignedPutUrl } = useFiles();
+   * const uploadUrl = await getSignedPutUrl('user-123', 'profile', 'jpg');
+   * // Use uploadUrl with PUT request to upload file
+   * ```
+   */
+  const getSignedPutUrl = useCallback(async (
+    entityId: string, 
+    entityType: FileUploadEntityType, 
+    fileExtension: string
+  ): Promise<string> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.files.getSignedPutUrl(entityId, entityType, fileExtension);
+      console.log('Signed put URL generated successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to generate signed put URL:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  /**
+   * Generates a signed URL for downloading files from cloud storage
+   * 
+   * @param entityId - Unique identifier of the entity the file belongs to
+   * @param entityType - Type of entity ('profile', 'business', 'campaign', etc.)
+   * @param expireSeconds - Optional expiration time in seconds (default varies by implementation)
+   * @returns Promise resolving to signed download URL
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getSignedGetUrl } = useFiles();
+   * const downloadUrl = await getSignedGetUrl('user-123', 'profile', 3600); // 1 hour expiry
+   * // Use downloadUrl to display or download the file
+   * ```
+   */
+  const getSignedGetUrl = useCallback(async (
+    entityId: string, 
+    entityType: FileUploadEntityType,
+    expireSeconds?: number
+  ): Promise<string> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.files.getSignedGetUrl(entityId, entityType, expireSeconds);
+      console.log('Signed get URL generated successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to generate signed get URL:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getSignedUrl = useCallback(async (request: SignedUrlRequest): Promise<string> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.files.getSignedUrl(request);
+      console.log('Signed URL generated successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to generate signed URL:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const optimizeMedia = useCallback(async (url: string, width?: number, height?: number): Promise<string> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.files.optimizeMedia(url, width, height);
+      console.log('Media optimized successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to optimize media:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  return {
+    getSignedPutUrl,
+    getSignedGetUrl,
+    getSignedUrl,
+    optimizeMedia,
+    isAvailable: isInitialized && !!sdk?.files,
+  };
+};
+
+export type FileHook = ReturnType<typeof useFiles>;

package/src/hooks/usePurchases.ts

@@ -0,0 +1,69 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+import type { PurchaseTokenDTO, PurchaseDTO } from '@explorins/pers-shared';
+
+export const usePurchases = () => {
+  const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+
+  const createPaymentIntent = useCallback(async (
+    amount: number, 
+    currency: string, 
+    receiptEmail: string, 
+    description: string
+  ) => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.purchases.createPaymentIntent(amount, currency, receiptEmail, description);
+      console.log('Payment intent created successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to create payment intent:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getActivePurchaseTokens = useCallback(async (): Promise<PurchaseTokenDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.purchases.getActivePurchaseTokens();
+      console.log('Active purchase tokens fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch active purchase tokens:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getAllUserPurchases = useCallback(async (): Promise<PurchaseDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    if (!isAuthenticated) {
+      throw new Error('SDK not authenticated. getAllUserPurchases requires authentication.');
+    }
+    
+    try {
+      const result = await sdk.purchases.getAllUserPurchases();
+      console.log('User purchases fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch user purchases:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized, isAuthenticated]);
+
+  return {
+    createPaymentIntent,
+    getActivePurchaseTokens,
+    getAllUserPurchases,
+    isAvailable: isInitialized && !!sdk?.purchases,
+  };
+};
+
+export type PurchaseHook = ReturnType<typeof usePurchases>;