@fadyshawky/react-native-magic 2.0.4 → 2.0.6

package/template/src/common/localization/translations/profileLocalization.ts

@@ -1,6 +1,6 @@
 export const profileLocalization = {
   en: {
-    studentProfile: 'Student Profile',
+    studentProfile: 'User Profile',
     allDetails: 'All Details',
     settings: 'Settings',
     darkMode: 'Dark Mode',
@@ -11,10 +11,10 @@ export const profileLocalization = {
     logout: 'Logout',
     changeLanguage: 'Change Language',
     changeLanguageConfirmation:
-      'Are you sure you want to change the language? The app will restart to apply changes.',
+      'Are you sure you want to change the language? The app will restart.',
   },
   ar: {
-    studentProfile: 'الملف الشخصي للطالب',
+    studentProfile: 'الملف الشخصي',
     allDetails: 'جميع التفاصيل',
     settings: 'الإعدادات',
     darkMode: 'الوضع الداكن',
@@ -25,6 +25,6 @@ export const profileLocalization = {
     logout: 'تسجيل الخروج',
     changeLanguage: 'تغيير اللغة',
     changeLanguageConfirmation:
-      'هل أنت متأكد أنك تريد تغيير اللغة؟ سيتم إعادة تشغيل التطبيق لتطبيق التغييرات.',
+      'هل تريد تغيير اللغة؟ سيتم إعادة تشغيل التطبيق.',
   },
 };

package/template/src/common/utils/FeesCaalculation.tsx

@@ -0,0 +1,37 @@
+import {
+  Service,
+  TierEntity,
+  Percent1,
+} from '../../core/store/Services/servicesState';
+
+export function initFees(service: Service, amount: string) {
+  let fee = 0;
+  if (service?.Fees) {
+    for (const f of service.Fees) {
+      if (f.AcctType && f.AcctType !== 'SDA') continue;
+      fee = fee + calculateFees(Number(amount), f.Tier as TierEntity[]);
+    }
+  }
+  return fee;
+}
+
+export function calculateFees(amount: number, tiers: TierEntity[]) {
+  if (!tiers || !amount || amount < 0) return 0;
+
+  const tier = tiers.find(t => amount >= t.LowerAmt && amount <= t.UpperAmt);
+
+  if (!tier) return 0;
+
+  const fixed = tier.FixedAmt?.Amt || 0;
+  const percent = tier.Percent?.Value ? tier.Percent.Value / 100 : 0;
+  const minPercentFee = (tier.Percent as Percent1)?.MinAmt || 0;
+  const maxPercentFee = tier.Percent?.MaxAmt || 0;
+  const calculatedPercentFee = Number((percent * amount).toFixed(2));
+
+  const percentFee = Math.min(
+    Math.max(calculatedPercentFee, minPercentFee),
+    maxPercentFee,
+  );
+
+  return fixed + percentFee;
+}

package/template/src/common/utils/index.tsx

@@ -0,0 +1,11 @@
+// Fee calculation utilities
+export {initFees, calculateFees} from './FeesCaalculation';
+
+// State management utility
+export {newState} from './newState';
+
+// Size calculation utility
+export {createPerfectSize} from './createPerfectSize';
+
+// Print data utility
+export {makePrintData} from './printData';

package/template/src/common/utils/printData.tsx

@@ -0,0 +1,161 @@
+import moment from 'moment';
+import {Service} from '../../core/store/Services/servicesState';
+import {ServiceProvider} from '../../core/store/Providers/providersState';
+
+const localization = {
+  serialNumber: 'الرقم التسلسلي',
+  serviceName: 'اسم الخدمة',
+  providerName: 'اسم المقدم',
+  customerNumber: 'رقم العميل',
+  value: 'القيمة',
+  serviceCost: 'تكلفة الخدمة',
+  operationNumber: 'رقم العملية',
+  referenceNumber: 'الرقم المرجعي',
+  time: 'الوقت',
+  total: 'الإجمالي',
+  expiryDate: 'تاريخ الانتهاء',
+  dueDate: 'الموعد المستحق',
+  issueDate: 'تاريخ الإصدار',
+  quantity: 'الكمية',
+  vatValue: 'القسيمة',
+};
+
+export const makePrintData = ({
+  service,
+  BillingAcct,
+  provider,
+  billInfo,
+  amuont,
+  fees,
+  quantity,
+  vatValue,
+}: {
+  service: Service;
+  BillingAcct: string;
+  provider: ServiceProvider;
+  billInfo: any;
+  amuont: string;
+  fees: number;
+  quantity: string;
+  vatValue: string;
+}) => {
+  let newData = [];
+  newData.push({
+    value: 'logo',
+    type: 'image',
+  });
+
+  newData.push({
+    value: service?.Name,
+    type: 'header2',
+  });
+  if (billInfo?.BillLabel) {
+    newData.push({
+      value: billInfo?.BillLabel,
+      type: 'header2',
+    });
+  }
+  newData.push({
+    value: provider?.BillerName,
+    type: 'header2',
+  });
+
+  if (BillingAcct) {
+    newData.push({
+      value: BillingAcct,
+      type: 'body',
+      label: localization['customerNumber'],
+    });
+  }
+  // response?.PmtInfo?.ExtraBillingAcctKeys?.ExtraBillingAcctKey?.forEach(
+  // 	(item: any) => {
+  // 		newData.push({
+  // 			value: item.Value,
+  // 			type: 'extra_description'
+  // 		});
+  // 	}
+  // );
+
+  if (!!vatValue) {
+    newData.push({
+      value: `${vatValue}`,
+      label: localization['vatValue'],
+      type: 'body',
+    });
+  }
+  if (quantity) {
+    newData.push({
+      value: `${quantity}`,
+      label: localization['quantity'],
+      type: 'body',
+    });
+  }
+  newData.push({
+    value: `${amuont} EGP`,
+    label: localization['value'],
+    type: 'body',
+  });
+
+  if (fees?.toString() !== '0') {
+    newData.push({
+      value: `${fees?.toString()} EGP`,
+      label: localization['serviceCost'],
+      type: 'body',
+    });
+  }
+  newData.push({
+    value: moment().format('YYYY-MM-DD HH:mm'),
+    label: localization['time'],
+    type: 'body',
+  });
+
+  newData.push({
+    value: quantity
+      ? `${(Number(quantity) * (Number(amuont) + Number(fees)))?.toFixed(
+          2,
+        )} EGP`
+      : `${(Number(amuont) + Number(fees))?.toString()} EGP`,
+    label: localization['total'],
+    type: 'body_title',
+  });
+
+  if (billInfo?.DueDt) {
+    newData.push({
+      value: billInfo?.DueDt,
+      type: 'body',
+      label: localization['dueDate'],
+    });
+  }
+
+  if (billInfo?.IssueDt) {
+    newData.push({
+      value: billInfo?.IssueDt,
+      type: 'body',
+      label: localization['issueDate'],
+    });
+  }
+
+  if (billInfo?.ExtraBillInfo) {
+    newData.push({
+      value: billInfo?.ExtraBillInfo,
+      type: 'description',
+      label: '',
+    });
+  }
+
+  if (!!service?.meta?.note) {
+    newData.push({
+      value: service?.meta?.note,
+      type: 'description',
+    });
+  }
+
+  if (!!service?.meta?.explain) {
+    newData.push({
+      value: service?.meta?.explain,
+      type: 'description',
+    });
+  }
+
+  return newData;
+};

package/template/src/common/validations/errorValidations.ts

@@ -1,8 +1,9 @@
+import {localization} from '../localization/localization';
 import {unwrapResult} from '@reduxjs/toolkit';
 import {Alert} from 'react-native';
+import {IErrorResult, ErrorRepresentationType} from '../../../types';
 import Snackbar from 'react-native-snackbar';
-import {ErrorRepresentationType, IErrorResult} from '../../../types';
-import {localization} from '../localization/localization';
+import {NewColors} from '../../core/theme/colors';
 export function handlePromiseResult(
   promiseAction: Promise<any>,
   successMessage?: string,

package/template/src/core/api/serverHeaders.ts

@@ -1,6 +1,10 @@
 import axios, {AxiosDefaults} from 'axios';
+import DeviceInfo from 'react-native-device-info';
+import {fetch} from 'react-native-ssl-pinning';
 
 export const defaultHeaders: HeadersInit_ = {
+  'app-version': DeviceInfo.getVersion(),
+  'serial-number': DeviceInfo.getSerialNumberSync(),
   Connection: 'keep-alive',
   'Content-Type': 'application/json',
 };
@@ -10,7 +14,7 @@ declare type MethodData = {
   config?: any;
 };
 
-const baseURL = '';
+const baseURL = 'https://sofapi.neo-dg.app/api/v1/mobile/';
 
 const instance = axios.create({
   baseURL: baseURL,
@@ -19,6 +23,63 @@ const instance = axios.create({
   },
 });
 
+export async function configureSecureRequest() {
+  // Only apply SSL pinning in production
+  if (baseURL.includes('neopayplus')) {
+    try {
+      instance.defaults.adapter = (config: any) => {
+        const url = `${config.baseURL}${config.url}`;
+        const fetchOptions: any = {
+          method: config.method?.toUpperCase() || 'GET',
+          timeoutInterval: 0,
+          headers: {
+            ...config.headers,
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+          },
+          // Don't double stringify the data
+          body: config.data ? config.data : undefined,
+          sslPinning: {
+            certs: ['STAR.neopayplus.com'],
+            allowInvalidCertificates: false,
+            validatesDomainName: true,
+          },
+        };
+
+        if (fetchOptions.method === 'GET' || fetchOptions.method === 'HEAD') {
+          delete fetchOptions.body;
+        }
+
+        return fetch(url, fetchOptions)
+          .then(async response => {
+            const data = await response.json();
+            return {
+              data,
+              status: response.status,
+              statusText: response.statusText,
+              headers: response.headers,
+              config,
+              request: {},
+            };
+          })
+          .catch(error => {
+            console.error('error: ', error);
+            if (error === 'timeout') {
+              throw new Error(error);
+            } else if (JSON.parse(error?.bodyString)?.error) {
+              throw new Error(JSON.parse(error?.bodyString)?.error);
+            } else if (JSON.parse(error?.bodyString)?.message) {
+              throw new Error(JSON.parse(error?.bodyString)?.message);
+            }
+          });
+      };
+    } catch (error) {
+      console.info('error: ', error);
+      throw error;
+    }
+  }
+}
+
 // Export HTTP methods using the configured instance
 export const post = ({url, data, config}: MethodData) =>
   instance.post(url, data, config);

package/template/src/core/store/Categories/categoryActions.ts

@@ -0,0 +1,33 @@
+import {createAsyncThunk} from '@reduxjs/toolkit';
+import {handleFetchJsonResponse} from '../../api/responseHandlers';
+import {post} from '../../api/serverHeaders';
+import {RootState} from '../rootReducer';
+import {extractServerError} from '../../api/errorHandler';
+
+export const getCategories = createAsyncThunk(
+  'categories/list',
+  async (
+    {data: {limit}}: {data: {limit?: number}},
+    {rejectWithValue, getState, dispatch}: any,
+  ) => {
+    try {
+      const token = (getState() as RootState).user.accessToken;
+
+      const response = await post({
+        url: 'serviceMangement/Category/get_categories',
+        data: {limit},
+        config: {
+          headers: {
+            Authorization: `${token}`,
+          },
+        },
+      });
+
+      return handleFetchJsonResponse(response);
+    } catch (e: any) {
+      // Extract the server error from the Axios error
+      const serverError = extractServerError(e);
+      return rejectWithValue(serverError);
+    }
+  },
+);

package/template/src/core/store/Categories/categorySlice.ts

@@ -0,0 +1,75 @@
+import {createSlice} from '@reduxjs/toolkit';
+import {newState} from '../../../common/utils/newState';
+import {handleErrorResponse} from '../../api/responseHandlers';
+import {getCategories} from './categoryActions';
+import {
+  CategoriesInitialState,
+  CategoriesState,
+  Category,
+  CategoryPayload,
+} from './categoryState';
+import {LoadState} from '../../../../types';
+
+function getCategoriesHandler(
+  state: CategoriesState,
+  payload: {payload: CategoryPayload},
+) {
+  return newState(state, {
+    categories: payload.payload.categories,
+    settings: payload.payload.settings,
+    loadState: LoadState.allIsLoaded,
+  });
+}
+function getCategoriesLoadingHandler(state: CategoriesState) {
+  return newState(state, {
+    loadState: LoadState.loadingMore,
+  });
+}
+
+function getCategoriesErrorHandler(
+  state: CategoriesState,
+  payload: {payload: {message: string}},
+) {
+  handleErrorResponse(payload.payload.message || 'Categories fetch failed');
+  return newState(state, {
+    loadState: LoadState.error,
+  });
+}
+
+function categoriesLogoutHandler(state: CategoriesState) {
+  return newState(state, CategoriesInitialState);
+}
+
+function selectedCategoryHandler(
+  state: CategoriesState,
+  payload: {payload: Category},
+) {
+  return newState(state, {
+    selectedCategory: payload.payload,
+  });
+}
+
+function clearSelectedCategoryHandler(state: CategoriesState) {
+  return newState(state, {
+    selectedCategory: CategoriesInitialState.selectedCategory,
+  });
+}
+
+export const {reducer: CategoriesReducer, actions} = createSlice({
+  name: 'categories',
+  initialState: CategoriesInitialState,
+  reducers: {
+    setCategoriesLogout: categoriesLogoutHandler,
+    setSelectedCategory: selectedCategoryHandler,
+    clearSelectedCategory: clearSelectedCategoryHandler,
+  },
+  extraReducers: builder => {
+    builder
+      .addCase(getCategories.fulfilled, getCategoriesHandler)
+      .addCase(getCategories.rejected, getCategoriesErrorHandler)
+      .addCase(getCategories.pending, getCategoriesLoadingHandler);
+  },
+});
+
+export const {setCategoriesLogout, setSelectedCategory, clearSelectedCategory} =
+  actions;

package/template/src/core/store/Categories/categoryState.ts

@@ -0,0 +1,41 @@
+import {LoadState} from '../../../../types';
+
+export type PosSettings = {
+  id: number;
+  name: string;
+  function_name: string;
+  is_active: boolean;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export interface CategoriesState {
+  categories: Category[];
+  loadState: LoadState;
+  settings: PosSettings[];
+  selectedCategory: Category | null;
+}
+
+export interface Category {
+  createdAt?: string | null;
+  externalId?: null;
+  id: number;
+  img_url: string;
+  name: string;
+  name_en?: string | null;
+  parent_id: number;
+  priority: number;
+  updatedAt: string;
+}
+
+export interface CategoryPayload {
+  categories: Category[];
+  settings: PosSettings[];
+}
+
+export const CategoriesInitialState: CategoriesState = {
+  categories: [],
+  loadState: LoadState.idle,
+  settings: [],
+  selectedCategory: null,
+};

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),
+      });
+    }
+  },
+);