@fadyshawky/react-native-magic 2.0.4 → 2.0.5

package/template/src/core/store/user/userActions.ts

@@ -1,74 +1,212 @@
 import {createAsyncThunk} from '@reduxjs/toolkit';
 import {handleFetchJsonResponse} from '../../api/responseHandlers';
 import {post} from '../../api/serverHeaders';
+import {RootState} from '../rootReducer';
+import {extractServerError} from '../../api/errorHandler';
+import {ensureString} from '../../utils/stringUtils';
 
 export const userLogin = createAsyncThunk(
   'user/login',
   async (
-    {email, password}: {email: string; password: string},
+    {phone, password}: {phone: string; password: string},
     {rejectWithValue, getState, dispatch}: any,
   ) => {
     try {
-      const data: {email: string; password: string} = {
-        email,
-        password,
+      const data: {
+        mobile_number: string;
+        mpin: string;
+        scheme_id: number;
+      } = {
+        mobile_number: phone,
+        mpin: password,
+        scheme_id: 1,
       };
-
       const response = await post({
-        url: '/login',
+        url: 'wallet_users/login',
         data,
       });
 
       return handleFetchJsonResponse(response);
     } catch (e: any) {
-      return rejectWithValue(e?.response);
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
     }
   },
 );
 
-export const userRegister = createAsyncThunk(
-  'user/register',
+export const verifyOTP = createAsyncThunk(
+  'user/verifyOTP',
   async (
     {
-      fullName,
-      email,
-      password,
+      verification_code,
+      mobile_number,
+      device_token,
+      scheme_id,
     }: {
-      fullName: string;
-      email: string;
-      password: string;
+      verification_code: string;
+      mobile_number: string;
+      device_token?: string;
+      scheme_id: number;
     },
-    {rejectWithValue},
+    {rejectWithValue, getState, dispatch}: any,
   ) => {
     try {
+      const data: {
+        mobile_number: string;
+        verification_code: string;
+        device_token?: string;
+        scheme_id: number;
+      } = {
+        mobile_number,
+        verification_code,
+        device_token: undefined,
+        scheme_id: 1,
+      };
+
+      const token = (getState() as RootState).user.tempToken;
+
+      const response = await post({
+        url: 'wallet_users/verifylogin',
+        data,
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const getBalance = createAsyncThunk(
+  'user/getBalance',
+  async (_, {rejectWithValue, getState, dispatch}: any) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
       const response = await post({
-        url: '/register',
-        data: {
-          fullName,
-          email,
-          password,
+        url: 'wallet_users/getbalance',
+        data: {},
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
         },
       });
 
       return handleFetchJsonResponse(response);
     } catch (e: any) {
-      return rejectWithValue(e?.response);
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
     }
   },
 );
 
 export const resetPassword = createAsyncThunk(
   'user/resetPassword',
-  async ({email}: {email: string}, {rejectWithValue}) => {
+  async (
+    {
+      mpin,
+      new_mpin,
+      confirm_mpin,
+    }: {mpin: string; new_mpin: string; confirm_mpin: string},
+    {rejectWithValue, getState},
+  ) => {
     try {
+      const token = (getState() as RootState).user.accessToken;
+
       const response = await post({
-        url: '/reset-password',
-        data: {email},
+        url: 'wallet_users/force-update-mpin',
+        data: {mpin, new_mpin, confirm_mpin},
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
       });
 
       return handleFetchJsonResponse(response);
     } catch (e: any) {
-      return rejectWithValue(e?.response);
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const fetchHistory = createAsyncThunk(
+  'user/fetchHistory',
+  async (
+    {data}: {data: {page: number; limit: number}},
+    {rejectWithValue, getState},
+  ) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+      const response = await post({
+        url: 'wallet_users/history',
+        data: {page: data.page, limit: data.limit},
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const fetchHistoryDetails = createAsyncThunk(
+  'user/fetchHistoryDetails',
+  async ({trxRef}: {trxRef: string}, {rejectWithValue, getState}) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'wallet_users/history/details',
+        data: {trxRef},
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
     }
   },
 );

package/template/src/core/store/user/userSlice.ts

@@ -2,13 +2,20 @@ import {createSlice} from '@reduxjs/toolkit';
 import {LoadState} from '../../../../types';
 import {newState} from '../../../common/utils/newState';
 import {handleErrorResponse} from '../../api/responseHandlers';
-import {resetPassword, userLogin, userRegister} from './userActions';
+import {
+  resetPassword,
+  userLogin,
+  getBalance,
+  verifyOTP,
+  fetchHistoryDetails,
+  fetchHistory,
+} from './userActions';
 import {UserInitialState, UserPayload, UserState} from './userState';
+import {cloneDeep, uniqBy} from 'lodash';
 
 function loginHandler(state: UserState, payload: {payload: UserPayload}) {
   return newState(state, {
-    user: payload.payload.user,
-    accessToken: payload.payload.token,
+    tempToken: payload.payload.token,
     loginLoading: LoadState['allIsLoaded'],
   });
 }
@@ -20,12 +27,49 @@ function loginLoadingHandler(state: UserState) {
 
 function loginErrorHandler(
   state: UserState,
-  payload: {payload: string | unknown},
+  payload: {payload: {message: string}},
+) {
+  console.error('payload: ', JSON.stringify(payload));
+  handleErrorResponse((payload.payload.message as string) || 'Login failed');
+  return newState(state, {
+    loginLoading: LoadState['error'],
+  });
+}
+
+function verifyOTPHandler(state: UserState, payload: {payload: UserPayload}) {
+  return newState(state, {
+    user: {
+      type: payload.payload.type,
+      mobile_number: payload.payload.mobile_number,
+      full_name: payload.payload.fullname,
+      merchantStore: payload.payload.merchantStore,
+      status: payload.payload.status,
+    },
+    accessToken: payload.payload.token,
+    loginLoading: LoadState['allIsLoaded'],
+    current_balance: payload?.payload?.current_balance?.find(
+      i => i.name === 'Deposit',
+    )?.value,
+    daily_commission: payload?.payload?.current_balance?.find(
+      i => i.name === 'Daily Commission',
+    )?.value,
+  });
+}
+function verifyOTPLoadingHandler(state: UserState) {
+  return newState(state, {
+    loginLoading: LoadState['pullToRefresh'],
+  });
+}
+
+function verifyOTPErrorHandler(
+  state: UserState,
+  payload: {payload: {message: string}},
 ) {
-  handleErrorResponse((payload.payload as string) || 'Login failed');
+  handleErrorResponse(
+    (payload.payload.message as string) || 'Verify OTP failed',
+  );
   return newState(state, {
     loginLoading: LoadState['error'],
-    accessToken: 'kl;hadjlcnaidojp8989y4hrkn4w3r89',
   });
 }
 
@@ -38,8 +82,10 @@ function resetPasswordHandler(
   payload: {payload: UserPayload},
 ) {
   return newState(state, {
-    user: payload.payload.user,
-    accessToken: payload.payload.token,
+    user: {
+      ...state.user,
+      status: payload.payload.status,
+    },
     loginLoading: LoadState['allIsLoaded'],
   });
 }
@@ -50,25 +96,28 @@ function resetPasswordLoadingHandler(state: UserState) {
   });
 }
 
-function registerHandler(state: UserState, payload: {payload: UserPayload}) {
+function getBalanceHandler(state: UserState, payload: {payload: UserPayload}) {
   return newState(state, {
-    user: payload.payload.user,
-    accessToken: payload.payload.token,
+    current_balance: payload?.payload?.balance?.find(i => i.name === 'Deposit')
+      ?.value,
+    daily_commission: payload?.payload?.balance?.find(
+      i => i.name === 'Daily Commission',
+    )?.value,
     loginLoading: LoadState['allIsLoaded'],
   });
 }
 
-function registerLoadingHandler(state: UserState) {
+function getBalanceLoadingHandler(state: UserState) {
   return newState(state, {
     loginLoading: LoadState['pullToRefresh'],
   });
 }
 
-function registerErrorHandler(
+function getBalanceErrorHandler(
   state: UserState,
-  payload: {payload: string | unknown},
+  payload: {payload: {message: string}},
 ) {
-  handleErrorResponse((payload.payload as string) || 'Register failed');
+  handleErrorResponse((payload.payload.message as string) || 'Register failed');
   return newState(state, {
     loginLoading: LoadState['error'],
   });
@@ -85,14 +134,115 @@ function updateHandler(state: UserState, payload: any) {
 
 function resetPasswordErrorHandler(
   state: UserState,
-  payload: {payload: string | unknown},
+  payload: {payload: {message: string}},
 ) {
-  handleErrorResponse((payload.payload as string) || 'Password reset failed');
+  handleErrorResponse(
+    (payload.payload.message as string) || 'Password reset failed',
+  );
   return newState(state, {
     loginLoading: LoadState['error'],
   });
 }
 
+function setFavoriteCategoriesHandler(
+  state: UserState,
+  payload: {payload: number},
+) {
+  if (!state.favoriteCategories) {
+    state.favoriteCategories = [];
+  }
+  state.favoriteCategories.push(payload.payload);
+}
+
+function setFavoriteProvidersHandler(
+  state: UserState,
+  payload: {payload: number},
+) {
+  if (!state.favoriteProviders) {
+    state.favoriteProviders = [];
+  }
+  state.favoriteProviders.push(payload.payload);
+}
+
+function removeFavoriteCategoriesHandler(
+  state: UserState,
+  payload: {payload: number},
+) {
+  if (state.favoriteCategories) {
+    state.favoriteCategories = state.favoriteCategories.filter(
+      id => id !== payload.payload,
+    );
+  }
+}
+
+function removeFavoriteProvidersHandler(
+  state: UserState,
+  payload: {payload: number},
+) {
+  if (state.favoriteProviders) {
+    state.favoriteProviders = state.favoriteProviders.filter(
+      id => id !== payload.payload,
+    );
+  }
+}
+
+function fetchHistoryHandler(
+  state: UserState,
+  payload: {payload: UserPayload},
+) {
+  let tmp = cloneDeep(state.history);
+  tmp = [...tmp, ...payload.payload.requests];
+  tmp = uniqBy(tmp, 'transaction_reference_num');
+  return newState(state, {
+    history: tmp,
+  });
+}
+
+function fetchHistoryLoadingHandler(state: UserState) {
+  return newState(state, {
+    loginLoading: LoadState['pullToRefresh'],
+  });
+}
+
+function fetchHistoryErrorHandler(
+  state: UserState,
+  payload: {payload: {message: string}},
+) {
+  handleErrorResponse(
+    (payload.payload.message as string) || 'Fetch history failed',
+  );
+}
+
+function fetchHistoryDetailsHandler(
+  state: UserState,
+  payload: {payload: UserPayload},
+) {
+  return newState(state, {
+    historyDetails: payload.payload.data,
+  });
+}
+
+function fetchHistoryDetailsLoadingHandler(state: UserState) {
+  return newState(state, {
+    loginLoading: LoadState['pullToRefresh'],
+  });
+}
+
+function fetchHistoryDetailsErrorHandler(
+  state: UserState,
+  payload: {payload: {message: string}},
+) {
+  handleErrorResponse(
+    (payload.payload.message as string) || 'Fetch history details failed',
+  );
+}
+
+function clearHistoryHandler(state: UserState) {
+  return newState(state, {
+    history: UserInitialState.history,
+  });
+}
+
 export const {reducer: UserReducer, actions} = createSlice({
   name: 'user',
   initialState: UserInitialState,
@@ -102,6 +252,11 @@ export const {reducer: UserReducer, actions} = createSlice({
     setLoginError: loginLoadingHandler,
     setLogout: logoutHandler,
     setUpdate: updateHandler,
+    setFavoriteCategories: setFavoriteCategoriesHandler,
+    setFavoriteProviders: setFavoriteProvidersHandler,
+    removeFavoriteCategories: removeFavoriteCategoriesHandler,
+    removeFavoriteProviders: removeFavoriteProvidersHandler,
+    clearHistory: clearHistoryHandler,
   },
   extraReducers: builder => {
     builder
@@ -111,10 +266,27 @@ export const {reducer: UserReducer, actions} = createSlice({
       .addCase(resetPassword.fulfilled, resetPasswordHandler)
       .addCase(resetPassword.rejected, resetPasswordErrorHandler)
       .addCase(resetPassword.pending, resetPasswordLoadingHandler)
-      .addCase(userRegister.fulfilled, registerHandler)
-      .addCase(userRegister.rejected, registerErrorHandler)
-      .addCase(userRegister.pending, registerLoadingHandler);
+      .addCase(getBalance.fulfilled, getBalanceHandler)
+      .addCase(getBalance.rejected, getBalanceErrorHandler)
+      .addCase(getBalance.pending, getBalanceLoadingHandler)
+      .addCase(verifyOTP.fulfilled, verifyOTPHandler)
+      .addCase(verifyOTP.rejected, verifyOTPErrorHandler)
+      .addCase(verifyOTP.pending, verifyOTPLoadingHandler)
+      .addCase(fetchHistory.fulfilled, fetchHistoryHandler)
+      .addCase(fetchHistory.rejected, fetchHistoryErrorHandler)
+      .addCase(fetchHistory.pending, fetchHistoryLoadingHandler)
+      .addCase(fetchHistoryDetails.fulfilled, fetchHistoryDetailsHandler)
+      .addCase(fetchHistoryDetails.rejected, fetchHistoryDetailsErrorHandler)
+      .addCase(fetchHistoryDetails.pending, fetchHistoryDetailsLoadingHandler);
   },
 });
 
-export const {setLogout, setUpdate} = actions;
+export const {
+  setLogout,
+  setUpdate,
+  setFavoriteCategories,
+  setFavoriteProviders,
+  removeFavoriteCategories,
+  removeFavoriteProviders,
+  clearHistory,
+} = actions;