@fadyshawky/react-native-magic 2.0.3 → 2.0.5

package/template/src/core/store/Providers/providersActions.ts

@@ -0,0 +1,102 @@
+import {createAsyncThunk} from '@reduxjs/toolkit';
+import {handleFetchJsonResponse} from '../../api/responseHandlers';
+import {get, post} from '../../api/serverHeaders';
+import {RootState} from '../rootReducer';
+import {extractServerError} from '../../api/errorHandler';
+import {ensureString} from '../../utils/stringUtils';
+
+export const getProviders = createAsyncThunk(
+  'providers/getProviders',
+  async (
+    {
+      data: {limit, category_id},
+    }: {data: {limit?: number; category_id?: number}},
+    {rejectWithValue, getState, dispatch}: any,
+  ) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'serviceProvider_category',
+        data: {limit, category_id},
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const getProviderById = createAsyncThunk(
+  'providers/getProviderById',
+  async (
+    {data: {BillerId}}: {data: {BillerId?: number}},
+    {rejectWithValue, getState, dispatch}: any,
+  ) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await get({
+        url: `serviceMangement/get-single-provider/${BillerId}`,
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const getHomeProviders = createAsyncThunk(
+  'providers/getHomeProviders',
+  async (
+    {
+      data: {limit, category_id},
+    }: {data: {limit?: number; category_id?: number}},
+    {rejectWithValue, getState, dispatch}: any,
+  ) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'serviceProvider_category',
+        data: {limit, category_id},
+        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/Providers/providersSlice.ts

@@ -0,0 +1,136 @@
+import {createSlice} from '@reduxjs/toolkit';
+import {newState} from '../../../common/utils/newState';
+import {handleErrorResponse} from '../../api/responseHandlers';
+import {
+  getHomeProviders,
+  getProviderById,
+  getProviders,
+} from './providersActions';
+import {
+  ProviderPayload,
+  ProvidersInitialState,
+  ProvidersState,
+  ServiceProvider,
+} from './providersState';
+import {navigationRef} from '../../../navigation/RootNavigation';
+
+function providersHandler(
+  state: ProvidersState,
+  payload: {payload: ProviderPayload},
+) {
+  return newState(state, {
+    providers: payload.payload.Service_providers,
+    loading: false,
+  });
+}
+
+function providersLoadingHandler(state: ProvidersState) {
+  return newState(state, {
+    loading: true,
+  });
+}
+
+function providersErrorHandler(
+  state: ProvidersState,
+  payload: {payload: {message: string}},
+) {
+  handleErrorResponse(
+    payload.payload.message || 'get service providers failed',
+  );
+  return newState(state, {
+    loading: false,
+  });
+}
+
+function homeProvidersHandler(
+  state: ProvidersState,
+  payload: {payload: ProviderPayload},
+) {
+  return newState(state, {
+    homeProviders: payload.payload.Service_providers,
+    loading: false,
+  });
+}
+
+function homeProvidersLoadingHandler(state: ProvidersState) {
+  return newState(state, {
+    loading: true,
+  });
+}
+
+function homeProvidersErrorHandler(
+  state: ProvidersState,
+  payload: {payload: {message: string}},
+) {
+  handleErrorResponse(
+    payload.payload.message || 'get service providers failed',
+  );
+  return newState(state, {
+    loading: false,
+  });
+}
+
+function providerLogoutHandler(state: ProvidersState) {
+  return newState(state, ProvidersInitialState);
+}
+
+function selectedProviderHandler(
+  state: ProvidersState,
+  payload: {payload: ServiceProvider},
+) {
+  return newState(state, {
+    selectedProvider: payload.payload,
+  });
+}
+
+function ProviderHandler(
+  state: ProvidersState,
+  payload: {payload: {data: ServiceProvider}},
+) {
+  return newState(state, {
+    selectedProvider: payload.payload.data,
+    loading: false,
+  });
+}
+
+function resetProvidersHandler(state: ProvidersState) {
+  return newState(state, {
+    providers: [],
+  });
+}
+
+function clearSelectedProviderHandler(state: ProvidersState) {
+  return newState(state, {
+    selectedProvider: ProvidersInitialState.selectedProvider,
+  });
+}
+
+export const {reducer: ProvidersReducer, actions} = createSlice({
+  name: 'providers',
+  initialState: ProvidersInitialState,
+  reducers: {
+    setProvidersLogout: providerLogoutHandler,
+    setSelectedProvider: selectedProviderHandler,
+    resetProviders: resetProvidersHandler,
+    clearSelectedProvider: clearSelectedProviderHandler,
+  },
+  extraReducers: builder => {
+    builder
+      .addCase(getProviders.fulfilled, providersHandler)
+      .addCase(getProviders.rejected, providersErrorHandler)
+      .addCase(getProviders.pending, providersLoadingHandler)
+      .addCase(getHomeProviders.fulfilled, homeProvidersHandler)
+      .addCase(getHomeProviders.rejected, homeProvidersErrorHandler)
+      .addCase(getHomeProviders.pending, homeProvidersLoadingHandler)
+      .addCase(getProviderById.fulfilled, ProviderHandler)
+      .addCase(getProviderById.rejected, providersErrorHandler)
+      .addCase(getProviderById.pending, providersLoadingHandler);
+  },
+});
+
+export const {
+  setProvidersLogout,
+  setSelectedProvider,
+  resetProviders,
+  clearSelectedProvider,
+} = actions;

package/template/src/core/store/Providers/providersState.ts

@@ -0,0 +1,37 @@
+import {LoadState} from '../../../../types';
+
+export interface ProvidersState {
+  providers: ServiceProvider[];
+  homeProviders: ServiceProvider[];
+  selectedProvider: ServiceProvider;
+  loading: boolean;
+}
+
+export interface ServiceProvider {
+  provider: string;
+  BillerId: string;
+  id?: string;
+  BillerName: string;
+  priority: number;
+  meta?: null;
+  img_url?: string | null;
+  categories?: CategoriesEntity[] | null;
+}
+export interface CategoriesEntity {
+  id: number;
+  fawry_biller_id: string;
+  category_id: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ProviderPayload {
+  Service_providers: ServiceProvider[];
+}
+
+export const ProvidersInitialState: ProvidersState = {
+  providers: [],
+  selectedProvider: {} as ServiceProvider,
+  loading: false,
+  homeProviders: [],
+};

package/template/src/core/store/Services/servicesActions.ts

@@ -0,0 +1,191 @@
+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 getServices = createAsyncThunk(
+  'services/list',
+  async (
+    {
+      data,
+    }: {
+      data: {
+        service_provider_id?: string;
+        fawry_provider_id?: string;
+        category_id?: string;
+      };
+    },
+    {rejectWithValue, getState, dispatch}: any,
+  ) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'listServices',
+        data,
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const getService = createAsyncThunk(
+  'services/single',
+  async (
+    {data}: {data: {fawry_service_id?: string; bee_service_id?: string}},
+    {rejectWithValue, getState, dispatch}: any,
+  ) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'serviceMangement/getService',
+        data,
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const getServiceById = createAsyncThunk(
+  'services/single/by/id',
+  async (
+    {data}: {data: {BillTypeCode?: string}},
+    {rejectWithValue, getState, dispatch}: any,
+  ) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'serviceMangement/getService',
+        data,
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const enquireService = createAsyncThunk(
+  'services/enquireService',
+  async ({data}: any, {rejectWithValue, getState, dispatch}: any) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'serviceMangement/fawry/bill-inquiry',
+        data,
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const payService = createAsyncThunk(
+  'services/payService',
+  async ({data}: any, {rejectWithValue, getState, dispatch}: any) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'serviceMangement/fawry/payment',
+        data,
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      const serverError = extractServerError(e);
+
+      return rejectWithValue({
+        ...serverError,
+        message: ensureString(serverError.message),
+      });
+    }
+  },
+);
+
+export const reverseService = createAsyncThunk(
+  'services/reverseService',
+  async ({data}: any, {rejectWithValue, getState, dispatch}: any) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: '/serviceMangement/fawry/reversePayment',
+        data,
+        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/Services/servicesSlice.ts

@@ -0,0 +1,205 @@
+import {createSlice} from '@reduxjs/toolkit';
+import {newState} from '../../../common/utils/newState';
+import {handleErrorResponse} from '../../api/responseHandlers';
+import {
+  enquireService,
+  getService,
+  getServiceById,
+  getServices,
+  payService,
+  reverseService,
+} from './servicesActions';
+import {
+  InquiredBill,
+  Service,
+  ServicePayload,
+  ServicesInitialState,
+  ServicesState,
+} from './servicesState';
+
+function getServicesHandler(
+  state: ServicesState,
+  payload: {payload: ServicePayload},
+) {
+  return newState(state, {
+    services: payload.payload.services,
+  });
+}
+function getServicesLoadingHandler(state: ServicesState) {
+  return newState(state, {});
+}
+
+function getServicesErrorHandler(
+  state: ServicesState,
+  payload: {payload: {message: string | unknown}},
+) {
+  handleErrorResponse((payload.payload.message as string) || 'Login failed');
+  return newState(state, {});
+}
+
+function resetServicesHandler(state: ServicesState) {
+  return newState(state, {
+    services: ServicesInitialState.services,
+  });
+}
+
+function serviceLogoutHandler(state: ServicesState) {
+  return newState(state, ServicesInitialState);
+}
+
+function getServiceHandler(
+  state: ServicesState,
+  payload: {payload: ServicePayload},
+) {
+  return newState(state, {
+    service: payload.payload.service,
+  });
+}
+
+function clearServiceHandler(state: ServicesState) {
+  return newState(state, {
+    service: ServicesInitialState.service,
+  });
+}
+
+function clearInquiryHandler(state: ServicesState) {
+  return newState(state, {
+    inquiredBill: ServicesInitialState.inquiredBill,
+  });
+}
+
+function clearPaymentHandler(state: ServicesState) {
+  return newState(state, {
+    paymentResponse: ServicesInitialState.paymentResponse,
+  });
+}
+
+function getServiceErrorHandler(
+  state: ServicesState,
+  payload: {payload: {message: string}},
+) {
+  handleErrorResponse(payload.payload.message);
+  return newState(state, {
+    loading: false,
+  });
+}
+
+function getServiceLoadingHandler(state: ServicesState) {
+  return newState(state, {
+    loading: true,
+  });
+}
+
+function enquireServiceHandler(
+  state: ServicesState,
+  payload: {payload: ServicePayload},
+) {
+  return newState(state, {
+    inquiredBill: payload.payload.data.Response.PresSvcRs
+      .BillInqRs as InquiredBill,
+    loading: false,
+  });
+}
+
+function enquireServiceLoadingHandler(state: ServicesState) {
+  return newState(state, {
+    loading: true,
+  });
+}
+
+function enquireServiceErrorHandler(
+  state: ServicesState,
+  payload: {payload: {message: string}},
+) {
+  handleErrorResponse(payload.payload.message || 'enquire service failed');
+  return newState(state, {
+    loading: false,
+  });
+}
+
+function payServiceHandler(
+  state: ServicesState,
+  payload: {payload: ServicePayload},
+) {
+  return newState(state, {
+    paymentResponse: payload.payload.data,
+    loading: false,
+  });
+}
+
+function reverseServiceHandler(
+  state: ServicesState,
+  payload: {payload: ServicePayload},
+) {
+  return newState(state, {
+    paymentResponse: payload.payload.data,
+    loading: false,
+  });
+}
+
+function payServiceLoadingHandler(state: ServicesState) {
+  return newState(state, {
+    loading: true,
+  });
+}
+
+function payServiceErrorHandler(
+  state: ServicesState,
+  payload: {payload: {message: string}},
+) {
+  handleErrorResponse(payload.payload.message || 'pay service failed');
+  return newState(state, {
+    loading: false,
+  });
+}
+
+function selectedServiceHandler(
+  state: ServicesState,
+  payload: {payload: Service},
+) {
+  return newState(state, {
+    selectedService: payload.payload,
+  });
+}
+export const {reducer: ServicesReducer, actions} = createSlice({
+  name: 'services',
+  initialState: ServicesInitialState,
+  reducers: {
+    setServiceLogout: serviceLogoutHandler,
+    setSelectedService: selectedServiceHandler,
+    clearService: clearServiceHandler,
+    clearInquiry: clearInquiryHandler,
+    clearPayment: clearPaymentHandler,
+    resetServices: resetServicesHandler,
+  },
+  extraReducers: builder => {
+    builder
+      .addCase(getServices.fulfilled, getServicesHandler)
+      .addCase(getServices.rejected, getServicesErrorHandler)
+      .addCase(getServices.pending, getServicesLoadingHandler)
+      .addCase(getService.fulfilled, getServiceHandler)
+      .addCase(getService.rejected, getServiceErrorHandler)
+      .addCase(getService.pending, getServiceLoadingHandler)
+      .addCase(getServiceById.fulfilled, getServiceHandler)
+      .addCase(getServiceById.rejected, getServiceErrorHandler)
+      .addCase(getServiceById.pending, getServiceLoadingHandler)
+      .addCase(enquireService.fulfilled, enquireServiceHandler)
+      .addCase(enquireService.rejected, enquireServiceErrorHandler)
+      .addCase(enquireService.pending, enquireServiceLoadingHandler)
+      .addCase(payService.fulfilled, payServiceHandler)
+      .addCase(payService.rejected, payServiceErrorHandler)
+      .addCase(payService.pending, payServiceLoadingHandler)
+      .addCase(reverseService.fulfilled, reverseServiceHandler)
+      .addCase(reverseService.rejected, payServiceErrorHandler)
+      .addCase(reverseService.pending, payServiceLoadingHandler);
+  },
+});
+
+export const {
+  setServiceLogout,
+  setSelectedService,
+  clearService,
+  clearInquiry,
+  clearPayment,
+  resetServices,
+} = actions;