@propel-nsl/propel-react-native-sdk 1.0.0

package/src-app/redux/rootSaga.ts

@@ -0,0 +1,6 @@
+import { all } from 'redux-saga/effects';
+import { authSaga } from './authSaga';
+
+export default function* rootSaga() {
+  yield all([authSaga()]);
+}

package/src-app/redux/store.ts

@@ -0,0 +1,25 @@
+import { configureStore } from '@reduxjs/toolkit';
+import authReducer from './authSlice';
+import rootSaga from './rootSaga';
+
+const createSagaMiddleware = require('redux-saga').default;
+const sagaMiddleware = createSagaMiddleware();
+
+export const store = configureStore({
+  reducer: {
+    auth: authReducer,
+  },
+  middleware: getDefaultMiddleware =>
+    getDefaultMiddleware({
+      thunk: false,
+      serializableCheck: {
+        ignoredActions: ['auth/uploadProfileImageRequest'],
+        ignoredActionPaths: ['payload'],
+      },
+    }).concat(sagaMiddleware),
+});
+
+sagaMiddleware.run(rootSaga);
+
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;

package/src-app/services/api.ts

@@ -0,0 +1,14 @@
+import ENV from '../config/env';
+import axios from 'axios';
+
+const api = axios.create({
+  baseURL: ENV.apiUrl,
+  timeout: 10000,
+});
+
+export const api1 =  axios.create({
+  baseURL: ENV.apiUrl1,
+  timeout: 10000,
+});
+
+export default api;

package/src-app/services/endpoints.ts

@@ -0,0 +1,33 @@
+const ENDPOINTS = {
+  SDK_AUTH_INIT: 'api/v1/propel/sdk/auth/init',
+  GENERATE_OTP: 'api/v1/auth/client/generate_otp',
+  VERIFY_MOBILE_OTP: 'api/v1/auth/client',
+  MY_ORDERS: 'api/v1/orders',
+  PRODUCTS_LIST: 'api/v1/propel/product_catalogues',
+  MY_PROFILE: 'api/v1/propel/client/profile_info',
+  UPLOAD_PROFILE_IMAGE: 'api/v1/propel/client/update_profile',
+  PRODUCT_DETAILS_BY_ID: 'api/v1/products',
+  MY_ORDERS_GENERATE_OTP: 'api/v1/orders/generate_order_otp',
+  MY_ORDERS_VALIDATE_OTP: 'api/v1/orders/validate_order_confirmation_otp',
+  REDEMPTION_HISTORY: 'api/v1/propel/user_transactions/redemption_history',
+  PRODUCT_TYPES: 'api/v1/products/product_types',
+  PRODUCT_CATEGORIES_BY_TYPE: 'propel/product_catalogues/categories',
+  VIEW_MY_CART: 'api/v1/orders',
+  DASHBOARD_INFO: 'api/v1/propel/dashboard/info',
+  GET_ADDRESS_LIST: 'api/v1/orders/addresses',
+  CREATE_ADDRESS: 'api/v1/orders/addresses',
+  UPDATE_ADDRESS: 'api/v1/orders/addresses',
+  DELETE_ADDRESS: 'api/v1/orders/addresses',
+  UPDATE_CART: (orderId: string | number) => `api/v1/orders/${orderId}/items`,
+  DELETE_CART: (orderId: string | number) => `api/v1/orders/${orderId}/items`,
+  ADD_TO_CART: 'api/v1/orders',
+  ADD_TO_EXISTING_CART: (orderId: string | number) =>
+    `api/v1/propel/orders/${orderId}/items`,
+  POINTS_LOG: 'api/v1/propel/user_transactions/details',
+  GENERATE_E_VOUCERS: 'api/v1/orders/evouchers/generate_evoucher_otp',
+  E_VOUCERS_VALIDATE_OTP: 'api/v1/orders/evouchers',
+  CHECKOUT: (orderId: string | number) => `api/v1/orders/${orderId}/complete`,
+  DELIVERHERE: (orderId: string | number) => `api/v1/orders/${orderId}`,
+};
+
+export default ENDPOINTS;

package/src-app/services/index.ts

@@ -0,0 +1,574 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import {
+  AddToCartPayload,
+  CheckoutPayload,
+  CreateAddressPayload,
+  DeliverHerePayload,
+  generateOtpPayload,
+  UpdateAddressPayload,
+  UploadProfileImagePayload,
+  VerifyMobileOtpPayload,
+} from "../types/authTypes";
+import api, { api1 } from "./api";
+import ENDPOINTS from "./endpoints";
+import DeviceInfo from "react-native-device-info";
+import { getSDKCredentials } from "./sdkCredentials";
+
+let cachedDeviceId: string | null = null;
+
+const getDeviceId = async (): Promise<string> => {
+  if (cachedDeviceId) {
+    return cachedDeviceId;
+  }
+  try {
+    const id = await DeviceInfo.getUniqueId();
+    cachedDeviceId = String(id);
+    return cachedDeviceId;
+  } catch (error) {
+    console.log("Error getting device ID:", error);
+    return "fallback-device-id";
+  }
+};
+
+
+
+const createAuthHeader = async (token: string): Promise<string> => {
+  const deviceId = await getDeviceId();
+  return `Token token=${token};client_key=mobile_app;device_id=device123;client_id=7b170ef2-c0a0-4968-a832-d308d54a8419;user_type=end_user;language_code=en;`;
+};
+
+
+
+
+const getAuthHeader = async (): Promise<{ Authorization: string }> => {
+  const token = await AsyncStorage.getItem("accessToken");
+  if (!token || token === "null") {
+    throw new Error("No valid access token");
+  }
+  return {
+    Authorization: await createAuthHeader(token),
+  };
+};
+
+
+export const generateOtpApi = (payload: generateOtpPayload) => {
+  return api1.post(ENDPOINTS.GENERATE_OTP, payload);
+};
+
+export const verifyMobileOtpApi = (payload: VerifyMobileOtpPayload) => {
+  return api1.post(ENDPOINTS.VERIFY_MOBILE_OTP, payload);
+};
+
+export const sdkAuthApi = async () => {
+  const payload = {
+    device_id: "device123",
+    client_name: "AndroidApp",
+    client_version: "1.0.0",
+    environment: "PRODUCTION",
+    user: {
+      user_id: "uuid",
+      name: "abc12345",
+      mobile: "9030992316",
+      email: "abc12345@yopmail.com",
+    },
+  };
+ 
+  const headers = {
+    "X-Auth-Token": "8540f0e5-029c-4a80-bbc8-7da952e1b1d3:7630a8c22d0c9dbcbf1b86b03bd58bf2",
+    "X-Auth-Id": "NUZIVEEDUS",
+    "Content-Type": "application/json",
+  };
+ 
+  return api1.post(ENDPOINTS.SDK_AUTH_INIT, payload, { headers });
+};
+export const myOrdersApi = async () => {
+  try {
+    const headers = await getAuthHeader();
+    const response = await api.get(ENDPOINTS.MY_ORDERS, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const myProductListApi = async (
+  name?: string,
+  product_types?: string,
+  category_ids?: string
+) => {
+  try {
+    const headers = await getAuthHeader();
+    const params: any = {
+      include: "variations,variation_types",
+      per: "12",
+      payment_method: "zaggle_card",
+    };
+
+    if (name) {
+      params.by_name = name;
+    }
+
+    if (product_types) {
+      params.product_types = product_types;
+    }
+
+    if (category_ids) {
+      params.category_ids = category_ids;
+    }
+
+    const response = await api.get(ENDPOINTS.PRODUCTS_LIST, {
+      headers,
+      params,
+    });
+
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const myProfileApi = async () => {
+  try {
+    const headers = await getAuthHeader();
+    const response = await api1.get(ENDPOINTS.MY_PROFILE, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+// export const uploadProfileImageApi = async (
+//   payload: UploadProfileImagePayload
+// ) => {
+//   try {
+//     const headers = await getAuthHeader();
+//     const response = await api.put(ENDPOINTS.UPLOAD_PROFILE_IMAGE, payload, {
+//       headers,
+//     });
+//     return response;
+//   } catch (error: any) {
+//     throw error;
+//   }
+// };
+
+export const uploadProfileImageApi = async (
+  payload: UploadProfileImagePayload
+) => {
+  try {
+    const token = await AsyncStorage.getItem("accessToken");
+    if (!token || token === "null") {
+      throw new Error("No valid access token found");
+    }
+
+    // Include all required headers like other API calls
+    const authHeader = await createAuthHeader(token);
+
+    console.log("Uploading profile image with headers:", {
+      Authorization: authHeader.substring(0, 50) + "...",
+      "Content-Type": "multipart/form-data",
+    });
+
+    const response = await api.put(ENDPOINTS.UPLOAD_PROFILE_IMAGE, payload, {
+      headers: {
+        Authorization: authHeader,
+        "Content-Type": "multipart/form-data",
+      },
+      timeout: 30000, // 30 second timeout for file uploads
+    });
+
+    console.log("Upload successful:", response.status);
+    return response;
+  } catch (error: any) {
+    console.error("Upload profile image API error:", {
+      status: error?.response?.status,
+      message: error?.response?.data?.message || error.message,
+      data: error?.response?.data,
+    });
+
+    // Provide more specific error messages
+    if (error?.response?.status === 401) {
+      throw new Error("Authentication failed. Please login again.");
+    } else if (error?.response?.status === 413) {
+      throw new Error("File size too large. Please select a smaller image.");
+    } else if (error?.response?.status === 415) {
+      throw new Error("Unsupported file type. Please select a valid image.");
+    } else if (error?.code === "NETWORK_ERROR") {
+      throw new Error("Network error. Please check your connection.");
+    }
+
+    throw error;
+  }
+};
+
+export const productDetailsByIdApi = async (productId: string) => {
+  try {
+    const headers = await getAuthHeader();
+
+    const response = await api.get(
+      `${ENDPOINTS.PRODUCT_DETAILS_BY_ID}/${productId}`,
+      {
+        headers,
+      }
+    );
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const myOrdersGenerateOtpApi = async (params?: {
+  order_id?: string;
+  otp_type?: 'orders_confirm_otp';
+}) => {
+  try {
+    const headers = await getAuthHeader();
+
+    const config: any = { headers };
+    if (params && (params.order_id || params.otp_type)) {
+      config.params = params;
+    }
+
+    const response = await api1.get(ENDPOINTS.MY_ORDERS_GENERATE_OTP, config);
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const myOrdersValidateOtpApi = async (
+  arg: { otp: string; order_id?: string; otp_type?: 'orders_confirm_otp' } | string
+) => {
+  try {
+    console.log("🌐 API: myOrdersValidateOtpApi called with arg:", arg);
+    const headers = await getAuthHeader();
+    const params = typeof arg === 'string' ? { otp: arg } : arg;
+    const listRes = await api1.get(ENDPOINTS.MY_ORDERS, {
+            headers,
+      params: { otp: params.otp },
+    });
+    const raw = listRes?.data;
+    const orders =
+      raw?.orders ?? raw?.data ?? (Array.isArray(raw) ? raw : raw?.items ?? raw);
+
+    const result = { ...listRes, data: { orders } };
+    console.log("🌐 API: myOrdersValidateOtpApi returning:", result);
+    return result;
+  } catch (error: any) {
+    console.log("🌐 API: myOrdersValidateOtpApi ERROR DETAILS:");
+    console.log("  - Error message:", error?.message);
+    console.log("  - Status code:", error?.response?.status);
+    console.log("  - Status text:", error?.response?.statusText);
+    console.log("  - Response data:", JSON.stringify(error?.response?.data, null, 2));
+    console.log("  - Response headers:", JSON.stringify(error?.response?.headers, null, 2));
+    console.log("  - Full error object:", error);
+    
+    const errMsg = error?.response?.data?.message || error.message || 'Unknown error';
+  
+    throw error;
+  }
+};
+
+export const redemptionHistoryApi = async (id: string) => {
+  try {
+    const headers = await getAuthHeader();
+
+    const params = {
+      id: id,
+      client_id: "7b170ef2-c0a0-4968-a832-d308d54a8419",
+    };
+    console.log("params", params);
+    console.log("headers", headers);
+    const response = await api1.get(`${ENDPOINTS.REDEMPTION_HISTORY}`, {
+      headers,
+      params,
+    });
+
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const productTypesApi = async () => {
+  try {
+    const headers = await getAuthHeader();
+
+    const response = await api.get(`${ENDPOINTS.PRODUCT_TYPES}`, {
+      headers,
+    });
+
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const productCategoriesByTypeApi = async (product_type?: string) => {
+  try {
+    const headers = await getAuthHeader();
+
+    const params: any = {
+      "product_type[]": product_type,
+      include: "variations,variation_types",
+      payment_method: "zaggle_card",
+    };
+
+    const response = await api.get(
+      `/api/v1/propel/product_catalogues/categories`,
+      {
+        headers,
+        params,
+      }
+    );
+
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const viewMyCartApi = async (productId: string) => {
+  try {
+    const headers = await getAuthHeader();
+    console.log("url", `${ENDPOINTS.VIEW_MY_CART}/${productId}`);
+
+    const response = await api.get(`${ENDPOINTS.VIEW_MY_CART}/${productId}`, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const dashboardInfoApi = async () => {
+  try {
+    const headers = await getAuthHeader();
+      console.log("dashboard api",headers);
+    const response = await api1.get(`${ENDPOINTS.DASHBOARD_INFO}`, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const getAddressListApi = async () => {
+  try {
+    const headers = await getAuthHeader();
+    const params = {
+      address_type: "billing_address",
+    };
+
+    const response = await api.get(`${ENDPOINTS.GET_ADDRESS_LIST}`, {
+      headers,
+      params,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const createAddressApi = async (payload: CreateAddressPayload) => {
+  try {
+    const headers = await getAuthHeader();
+
+    const response = await api.post(`${ENDPOINTS.CREATE_ADDRESS}`, payload, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const updateAddressApi = async (
+  payload: UpdateAddressPayload,
+  id: string
+) => {
+  try {
+    const headers = await getAuthHeader();
+
+    const response = await api.put(
+      `${ENDPOINTS.UPDATE_ADDRESS}/${id}`,
+      payload,
+      {
+        headers,
+      }
+    );
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const deleteAddressApi = async (id: string) => {
+  try {
+    const headers = await getAuthHeader();
+
+    const response = await api.delete(`${ENDPOINTS.DELETE_ADDRESS}/${id}`, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const updateCartApi = async (orderId: string, payload: any) => {
+  try {
+    const headers = await getAuthHeader();
+    const response = await api.put(
+      `${ENDPOINTS.UPDATE_CART(orderId)}`,
+      payload,
+      {
+        headers,
+      }
+    );
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const deleteCartApi = async (orderId: string, payload: any) => {
+  try {
+    const headers = await getAuthHeader();
+    const params = {
+      product_variation_id: payload.product_variation_id,
+    };
+    const response = await api1.delete(`${ENDPOINTS.DELETE_CART(orderId)}`, {
+      headers,
+      params,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const addToCartApi = async (payload: AddToCartPayload) => {
+  try {
+    const headers = await getAuthHeader();
+    console.log("Headers object:", headers);
+    console.log("api url",api1.defaults.baseURL);
+    console.log("endpoints",ENDPOINTS.ADD_TO_CART);
+    console.log("payload",payload);
+    
+    const response = await api1.post(`${ENDPOINTS.ADD_TO_CART}`, payload, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const getMyExistingCartApi = async (orderId: string, payload: any) => {
+  try {
+    const headers = await getAuthHeader();
+     console.log("Headers object:", headers);
+    console.log("api url",api1.defaults.baseURL);
+    console.log("endpoints",ENDPOINTS.ADD_TO_EXISTING_CART(orderId));
+    console.log("payload",payload);
+    
+
+    const response = await api1.post(
+      `${ENDPOINTS.ADD_TO_EXISTING_CART(orderId)}`,
+      payload,
+      {
+        headers,
+      }
+    );
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const pointsLogApi = async () => {
+  try {
+    const headers = await getAuthHeader();
+    const params = {
+      tab_type: "ezsc",
+    };
+    const response = await api.get(`${ENDPOINTS.POINTS_LOG}`, {
+      headers,
+      params,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const generateEVouchersApi = async () => {
+  try {
+    const headers = await getAuthHeader();
+
+    const response = await api.get(`${ENDPOINTS.GENERATE_E_VOUCERS}`, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const validateEVouchersApi = async (otp: string) => {
+  try {
+    const headers = await getAuthHeader();
+    console.log("headers",headers);
+    
+
+    const params = {
+      otp: otp,
+    };
+
+    const response = await api.get(`${ENDPOINTS.E_VOUCERS_VALIDATE_OTP}`, {
+      headers,
+      params,
+    });
+     console.log("vouchers response",response);
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const checkoutApi = async (
+  orderId: string,
+  payload: CheckoutPayload
+) => {
+  try {
+    const headers = await getAuthHeader();
+    console.log("headers", `${ENDPOINTS.CHECKOUT(orderId)}`);
+    console.log(" checkout payload", payload);
+
+    const response = await api.put(`${ENDPOINTS.CHECKOUT(orderId)}`, payload, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+
+export const deliverHereApi = async (orderId: string, payload: DeliverHerePayload) => {
+  try {
+    const headers = await getAuthHeader();
+    const response = await api.put(`${ENDPOINTS.DELIVERHERE(orderId)}`, payload, {
+      headers,
+    });
+    return response;
+  } catch (error: any) {
+    throw error;
+  }
+};
+

package/src-app/services/sdkCredentials.ts

@@ -0,0 +1,44 @@
+/**
+ * SDK Credentials Store
+ * 
+ * Stores authentication credentials passed from the host app via the native bridge.
+ * These credentials are used by sdkAuthApi to authenticate with the backend.
+ */
+
+export interface SDKCredentials {
+  authToken: string;
+  authId: string;
+  userId?: string;
+  userName?: string;
+  userMobile?: string;
+  userEmail?: string;
+  deviceId?: string;
+  clientName?: string;
+  clientVersion?: string;
+  environment?: string;
+}
+
+let _credentials: SDKCredentials | null = null;
+
+/**
+ * Set SDK credentials from host app params.
+ * Must be called before sdkAuthApi is invoked.
+ */
+export const setSDKCredentials = (credentials: SDKCredentials): void => {
+  _credentials = credentials;
+};
+
+/**
+ * Get the current SDK credentials.
+ * Returns null if credentials have not been set.
+ */
+export const getSDKCredentials = (): SDKCredentials | null => {
+  return _credentials;
+};
+
+/**
+ * Clear stored SDK credentials (called on SDK exit).
+ */
+export const clearSDKCredentials = (): void => {
+  _credentials = null;
+};