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

package/src/hooks/useTransactions.ts

@@ -1,85 +1,221 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import type { 
+  TransactionRequestDTO, 
+  TransactionRequestResponseDTO, 
+  TransactionDTO
+} from '@explorins/pers-shared';
+import type { TransactionPaginationParams } from '@explorins/pers-sdk/transaction';
 
+interface TransactionFilters {
+  type?: string;
+}
+
+/**
+ * React hook for transaction operations in the PERS SDK
+ * 
+ * Provides comprehensive transaction management including creation, retrieval, history,
+ * and administrative operations. Supports pagination and CSV export functionality.
+ * 
+ * @returns Transaction hook with methods for transaction management
+ * 
+ * @example
+ * ```typescript
+ * function TransactionsComponent() {
+ *   const { 
+ *     createTransaction, 
+ *     getUserTransactionHistory 
+ *   } = useTransactions();
+ *   
+ *   const handleCreateTransaction = async (request) => {
+ *     try {
+ *       const result = await createTransaction(request);
+ *       console.log('Transaction created:', result);
+ *       // Handle signature URL if returned
+ *     } catch (error) {
+ *       console.error('Transaction failed:', error);
+ *     }
+ *   };
+ * 
+ *   return (
+ *     <div>
+ *       <button onClick={() => handleCreateTransaction(transactionRequest)}>
+ *         Create Transaction
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export const useTransactions = () => {
-  const { transactions, isInitialized, isAuthenticated } = usePersSDK();
+  const { sdk, isInitialized, isAuthenticated } = usePersSDK();
 
   if (!isAuthenticated && isInitialized) {
     console.warn('SDK not authenticated. Some transaction operations may fail.');
   }
 
-  const createTransaction = useCallback(async (request: any) => {
-    if (!isInitialized) {
+  /**
+   * Creates a new transaction in the system
+   * 
+   * Automatically handles signature URLs by opening them in the device's browser.
+   * The transaction may require user approval through external wallet applications.
+   * 
+   * @param request - Transaction request data including amount, recipient, etc.
+   * @returns Promise resolving to transaction response with potential actionable items
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { createTransaction } = useTransactions();
+   * const request = {
+   *   amount: '100',
+   *   recipient: '0x123...',
+   *   tokenId: 'token-123'
+   * };
+   * const result = await createTransaction(request);
+   * console.log('Transaction created:', result);
+   * ```
+   */
+  const createTransaction = useCallback(async (request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!transactions?.createTransaction) {
-      throw new Error('createTransaction method not available');
-    }
     
     try {
-      console.log('🔄 Creating transaction with request:', request);
-      const result = await transactions.createTransaction(request);
+      console.log('Creating transaction with request:', request);
+      const result = await sdk.transactions.createTransaction(request);
       
-      // React Native specific: Handle signature URLs
+      // Cross-platform: Handle signature URLs
       if (result?.actionable?.actionUrl) {
         try {
           const { Linking } = require('react-native');
-          console.log('🔗 Opening signature URL:', result.actionable.actionUrl);
+          console.log('Opening signature URL:', result.actionable.actionUrl);
           await Linking.openURL(result.actionable.actionUrl);
         } catch (linkingError) {
-          console.error('❌ Failed to open signature URL:', linkingError);
+          console.error('Failed to open signature URL:', linkingError);
         }
       }
       
-      console.log('✅ Transaction created successfully:', result);
+      console.log('Transaction created successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to create transaction:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  /**
+   * Retrieves a specific transaction by its ID
+   * 
+   * @param transactionId - Unique identifier of the transaction
+   * @returns Promise resolving to transaction data or null if not found
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getTransactionById } = useTransactions();
+   * const transaction = await getTransactionById('txn-123');
+   * console.log('Transaction details:', transaction);
+   * ```
+   */
+  const getTransactionById = useCallback(async (transactionId: string): Promise<TransactionDTO | null> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.transactions.getTransactionById(transactionId);
+      console.log('Transaction fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to create transaction:', error);
+      console.error('Failed to fetch transaction:', error);
       throw error;
     }
-  }, [transactions]);
+  }, [sdk, isInitialized]);
 
-  const getTransactionById = useCallback(async (transactionId: string) => {
-    if (!isInitialized) {
+  /**
+   * Retrieves transaction history for the authenticated user, filtered by type
+   * 
+   * @param type - Transaction type filter (defaults to 'all')
+   * @returns Promise resolving to array of user's transactions
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getUserTransactionHistory } = useTransactions();
+   * const transactions = await getUserTransactionHistory('credit');
+   * console.log('Credit transactions:', transactions);
+   * ```
+   */
+  const getUserTransactionHistory = useCallback(async (type: string = 'all'): Promise<TransactionDTO[]> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!transactions?.getTransactionById) {
-      throw new Error('getTransactionById method not available');
+    
+    try {
+      const result = await sdk.transactions.getUserTransactionHistory(type);
+      console.log('Transaction history fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch transaction history:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getTenantTransactions = useCallback(async (): Promise<TransactionDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await transactions.getTransactionById(transactionId);
-      console.log('✅ Transaction fetched successfully:', result);
+      const result = await sdk.transactions.getTenantTransactions();
+      console.log('Tenant transactions fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch transaction:', error);
+      console.error('Failed to fetch tenant transactions:', error);
       throw error;
     }
-  }, [transactions]);
+  }, [sdk, isInitialized]);
 
-  const getTransactionHistory = useCallback(async (filters?: any) => {
-    if (!isInitialized) {
+  const getPaginatedTransactions = useCallback(async (params: TransactionPaginationParams): Promise<any> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!transactions?.getTransactionHistory) {
-      console.warn('getTransactionHistory method not available');
-      return [];
+    
+    try {
+      const result = await sdk.transactions.getPaginatedTransactions(params);
+      console.log('Paginated transactions fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch paginated transactions:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const exportTransactionsCSV = useCallback(async (): Promise<Blob> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await transactions.getTransactionHistory(filters);
-      console.log('✅ Transaction history fetched successfully:', result);
+      const result = await sdk.transactions.exportTransactionsCSV();
+      console.log('Transactions CSV exported successfully');
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch transaction history:', error);
+      console.error('Failed to export transactions CSV:', error);
       throw error;
     }
-  }, [transactions]);
+  }, [sdk, isInitialized]);
 
   return {
     createTransaction,
     getTransactionById,
-    getTransactionHistory,
-    isAvailable: isInitialized && !!transactions,
+    getUserTransactionHistory,
+    getTenantTransactions,
+    getPaginatedTransactions,
+    exportTransactionsCSV,
+    isAvailable: isInitialized && !!sdk?.transactions,
   };
-};
+};
+
+export type TransactionHook = ReturnType<typeof useTransactions>;

package/src/hooks/useUserStatus.ts

@@ -0,0 +1,65 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+import type { UserStatusTypeDTO } from '@explorins/pers-shared';
+
+export const useUserStatus = () => {
+  const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+
+  const getUserStatusTypes = useCallback(async (): Promise<UserStatusTypeDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.userStatus.getUserStatusTypes();
+      console.log('User status types fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch user status types:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getEarnedUserStatus = useCallback(async (): Promise<UserStatusTypeDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    if (!isAuthenticated) {
+      throw new Error('SDK not authenticated. getEarnedUserStatus requires authentication.');
+    }
+    
+    try {
+      const result = await sdk.userStatus.getEarnedUserStatus();
+      console.log('Earned user status fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch earned user status:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized, isAuthenticated]);
+
+  // Admin methods
+  const createUserStatusType = useCallback(async (userStatusType: UserStatusTypeDTO): Promise<UserStatusTypeDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.userStatus.createUserStatusType(userStatusType);
+      console.log('User status type created successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to create user status type:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  return {
+    getUserStatusTypes,
+    getEarnedUserStatus,
+    createUserStatusType,
+    isAvailable: isInitialized && !!sdk?.userStatus,
+  };
+};
+
+export type UserStatusHook = ReturnType<typeof useUserStatus>;

package/src/hooks/useUsers.ts

@@ -0,0 +1,133 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+import type { UserDTO, UserCreateRequestDTO } from '@explorins/pers-shared';
+import type { UserPublicProfileDTO } from '@explorins/pers-sdk/user';
+
+export const useUsers = () => {
+  const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+
+  const getCurrentUser = useCallback(async (): Promise<UserDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    if (!isAuthenticated) {
+      throw new Error('SDK not authenticated. getCurrentUser requires authentication.');
+    }
+    
+    try {
+      const result = await sdk.users.getCurrentUser();
+      console.log('Current user fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch current user:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized, isAuthenticated]);
+
+  const updateCurrentUser = useCallback(async (userData: UserCreateRequestDTO): Promise<UserDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    if (!isAuthenticated) {
+      throw new Error('SDK not authenticated. updateCurrentUser requires authentication.');
+    }
+    
+    try {
+      const result = await sdk.users.updateCurrentUser(userData);
+      console.log('Current user updated successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to update current user:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized, isAuthenticated]);
+
+  const getUserById = useCallback(async (userId: string): Promise<UserDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.users.getUserById(userId);
+      console.log('User fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch user:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getAllUsersPublic = useCallback(async (filter?: { key: string; value: string }): Promise<UserPublicProfileDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.users.getAllUsersPublic(filter);
+      console.log('Public users fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch public users:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  // Admin methods
+  const getAllUsers = useCallback(async (): Promise<UserDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.users.getAllUsers();
+      console.log('All users fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch all users:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const updateUser = useCallback(async (userId: string, userData: UserCreateRequestDTO): Promise<UserDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.users.updateUser(userId, userData);
+      console.log('User updated successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to update user:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const toggleUserStatus = useCallback(async (user: UserDTO): Promise<UserDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.users.toggleUserStatus(user);
+      console.log('User status toggled successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to toggle user status:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  return {
+    getCurrentUser,
+    updateCurrentUser,
+    getUserById,
+    getAllUsersPublic,
+    getAllUsers,
+    updateUser,
+    toggleUserStatus,
+    isAvailable: isInitialized && !!sdk?.users,
+  };
+};
+
+export type UserHook = ReturnType<typeof useUsers>;