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

package/src-app/redux/authSaga.ts

@@ -0,0 +1,605 @@
+import { call, put, select, takeLatest, all, delay } from "redux-saga/effects";
+import { SagaIterator } from "redux-saga";
+import {
+  addToCartApi,
+  checkoutApi,
+  createAddressApi,
+  dashboardInfoApi,
+  deleteAddressApi,
+  deleteCartApi,
+  deliverHereApi,
+  generateEVouchersApi,
+  generateOtpApi,
+  getAddressListApi,
+  getMyExistingCartApi,
+  myOrdersApi,
+  myOrdersGenerateOtpApi,
+  myOrdersValidateOtpApi,
+  myProductListApi,
+  myProfileApi,
+  pointsLogApi,
+  productCategoriesByTypeApi,
+  productDetailsByIdApi,
+  productTypesApi,
+  redemptionHistoryApi,
+  sdkAuthApi,
+  updateAddressApi,
+  updateCartApi,
+  uploadProfileImageApi,
+  validateEVouchersApi,
+  verifyMobileOtpApi,
+  viewMyCartApi,
+} from "../services";
+import {
+  addToCartFailure,
+  addToCartRequest,
+  addToCartSuccess,
+  addToExistingCartRequest,
+  checkoutFailure,
+  checkoutRequest,
+  checkoutSuccess,
+  createAddressFailure,
+  createAddressRequest,
+  createAddressSuccess,
+  dashboardInfoFailure,
+  dashboardInfoRequest,
+  dashboardInfoSuccess,
+  deleteAddressFailure,
+  deleteAddressRequest,
+  deleteAddressSuccess,
+  deleteCartFailure,
+  deleteCartRequest,
+  deleteCartSuccess,
+  deliverHereFailure,
+  deliverHereRequest,
+  deliverHereSuccess,
+  generateEVouchersFailure,
+  generateEVouchersRequest,
+  generateEVouchersSuccess,
+  generateOtpFailure,
+  generateOtpRequest,
+  generateOtpSuccess,
+  getAddressListFailure,
+  getAddressListRequest,
+  getAddressListSuccess,
+  myOrdersFailure,
+  myOrdersGenerateOtpFailure,
+  myOrdersGenerateOtpRequest,
+  myOrdersGenerateOtpSuccess,
+  myOrdersRequest,
+  myOrdersSuccess,
+  myOrdersValidateOtpFailure,
+  myOrdersValidateOtpRequest,
+  myOrdersValidateOtpSuccess,
+  myProductsListFailure,
+  myProductsListRequest,
+  myProductsListSuccess,
+  myProfileFailure,
+  myProfileRequest,
+  myProfileSuccess,
+  pointsLogFailure,
+  pointsLogRequest,
+  pointsLogSuccess,
+  productCategoriesByTypeFailure,
+  productCategoriesByTypeRequest,
+  productCategoriesByTypeSuccess,
+  productDetailsByIdFailure,
+  productDetailsByIdRequest,
+  productDetailsByIdSuccess,
+  productTypesFailure,
+  productTypesRequest,
+  productTypesSuccess,
+  redemptionHistoryFailure,
+  redemptionHistoryRequest,
+  redemptionHistorySuccess,
+  sdkAuthFailure,
+  sdkAuthRequest,
+  sdkAuthSuccess,
+  updateAddressFailure,
+  updateAddressRequest,
+  updateAddressSuccess,
+  updateCartFailure,
+  updateCartRequest,
+  updateCartSuccess,
+  uploadProfileImageFailure,
+  uploadProfileImageRequest,
+  uploadProfileImageSuccess,
+  validateEVouchersFailure,
+  validateEVouchersRequest,
+  validateEVouchersSuccess,
+  verifyMobileOtpFailure,
+  verifyMobileOtpRequest,
+  verifyMobileOtpSuccess,
+  viewMyCartFailure,
+  viewMyCartRequest,
+  viewMyCartSuccess,
+} from "./authSlice";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { RootState } from "./store";
+
+function* handleGenerateOtp(
+  action: ReturnType<typeof generateOtpRequest>
+): SagaIterator {
+  try {
+    const response = yield call(generateOtpApi, action.payload);
+    if (response.data?.status === false) {
+      yield put(generateOtpFailure(response.data?.message || 'OTP generation failed'));
+    } else {
+      yield put(generateOtpSuccess(response.data));
+    }
+  } catch (error: any) {
+    yield put(generateOtpFailure(error?.response?.data?.message || error?.message || 'Network error'));
+  }
+}
+
+function* handleVerifyMobileOtp(
+  action: ReturnType<typeof verifyMobileOtpRequest>
+): SagaIterator {
+  try {
+    const response = yield call(verifyMobileOtpApi, action.payload);
+    const token = response?.data?.session?.token;
+
+    if (token) {
+      yield call(AsyncStorage.setItem, "accessToken", token);
+      yield call(AsyncStorage.getItem, "accessToken");
+    }
+
+    yield put(verifyMobileOtpSuccess(response.data));
+    yield put(myOrdersRequest({}));
+  } catch (error: any) {
+    yield put(verifyMobileOtpFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleMyOrders(): SagaIterator {
+  try {
+    const response = yield call(myOrdersApi);
+    yield put(myOrdersSuccess(response.data));
+  } catch (error: any) {
+    yield put(myOrdersFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleMyProductList(
+  action: ReturnType<typeof myProductsListRequest>
+): SagaIterator {
+  const name = action.payload?.name;
+  const product_types = action.payload?.product_types;
+  const category_ids = action.payload?.category_ids;
+  try {
+    const response = yield call(
+      myProductListApi,
+      name,
+      product_types,
+      category_ids
+    );
+    yield put(myProductsListSuccess(response.data));
+  } catch (error: any) {
+    yield put(myProductsListFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleMyProfile(): SagaIterator {
+  try {
+    const response = yield call(myProfileApi);
+    yield put(myProfileSuccess(response.data));
+  } catch (error: any) {
+    yield put(myProfileFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleUploadProfileImage(
+  action: ReturnType<typeof uploadProfileImageRequest>
+): SagaIterator {
+  try {
+    const response = yield call(uploadProfileImageApi, action.payload);
+    yield put(uploadProfileImageSuccess(response.data));
+    yield put(myProfileRequest({}));
+  } catch (error: any) {
+    yield put(uploadProfileImageFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleProductDetailsById(
+  action: ReturnType<typeof productDetailsByIdRequest>
+): SagaIterator {
+  try {
+    const response = yield call(productDetailsByIdApi, action.payload.id);
+    yield put(productDetailsByIdSuccess(response.data));
+  } catch (error: any) {
+    yield put(productDetailsByIdFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleMyOrdersGenerateOtp(): SagaIterator {
+  try {
+    const response = yield call(myOrdersGenerateOtpApi);
+    yield put(myOrdersGenerateOtpSuccess(response.data));
+  } catch (error: any) {
+    yield put(myOrdersGenerateOtpFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleMyOrdersValidateOtp(
+  action: ReturnType<typeof myOrdersValidateOtpRequest>
+): SagaIterator {
+  try {
+    const { otp } = action.payload || {};
+    const response = yield call(myOrdersValidateOtpApi, { otp });
+    yield put(myOrdersValidateOtpSuccess(response));
+  } catch (error: any) {
+    const apiMsg =
+      error?.response?.data?.message ||
+      error?.response?.data?.errors?.[0] ||
+      error?.message ||
+      'Something went wrong'; 
+    yield put(
+      myOrdersValidateOtpFailure(
+        apiMsg
+      )
+    );
+  }
+}
+
+function* handleRedemptionHistory(
+  action: ReturnType<typeof redemptionHistoryRequest>
+): SagaIterator {
+  try {
+    const id = action.payload?.id;
+
+    if (!id) {
+      yield put(
+        redemptionHistoryFailure("ID is required for redemption history")
+      );
+      return;
+    }
+
+    const response = yield call(redemptionHistoryApi, id);
+    yield put(redemptionHistorySuccess(response.data));
+  } catch (error: any) {
+    yield put(
+      redemptionHistoryFailure(
+        error?.response?.data?.message ?? "Something went wrong"
+      )
+    );
+  }
+}
+
+function* handleProductTypes(): SagaIterator {
+  try {
+    const response = yield call(productTypesApi);
+    yield put(productTypesSuccess(response.data));
+  } catch (error: any) {
+    yield put(productTypesFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleProductCategoriesByType(
+  action: ReturnType<typeof productCategoriesByTypeRequest>
+): SagaIterator {
+  const product_type = action.payload?.product_type;
+
+  try {
+    const response = yield call(productCategoriesByTypeApi, product_type);
+    yield put(productCategoriesByTypeSuccess(response.data));
+  } catch (error: any) {
+    yield put(productCategoriesByTypeFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleViewMyCartById(
+  action: ReturnType<typeof viewMyCartRequest>
+): SagaIterator {
+  const id = action.payload.id;
+
+  if (!id) {
+    yield put(viewMyCartFailure("Cart ID is required"));
+    return;
+  }
+
+  try {
+    const response = yield call(viewMyCartApi, id);
+
+    yield put(
+      viewMyCartSuccess({
+        data: response.data,
+        successMessage: response.data.message || "Cart updated successfully",
+      })
+    );
+  } catch (error: any) {
+    yield put(viewMyCartFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleDashboardInfo(): SagaIterator {
+  try {
+    const response = yield call(dashboardInfoApi);
+
+    yield put(dashboardInfoSuccess(response.data));
+  } catch (error: any) {
+    const msg =
+      error?.response?.data?.message ||
+      error?.message ||
+      "Unable to load dashboard info";
+    yield put(dashboardInfoFailure(msg));
+  }
+}
+
+function* handleGetAddressList(): SagaIterator {
+  try {
+    const response = yield call(getAddressListApi);
+    yield put(getAddressListSuccess(response.data));
+  } catch (error: any) {
+    yield put(getAddressListFailure(error.message));
+  }
+}
+
+function* handleCreateAddress(
+  action: ReturnType<typeof createAddressRequest>
+): SagaIterator {
+  try {
+    const response = yield call(createAddressApi, action.payload);
+    yield put(createAddressSuccess(response.data));
+    yield put(getAddressListRequest({}));
+  } catch (error: any) {
+    yield put(createAddressFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleUpdateAddress(
+  action: ReturnType<typeof updateAddressRequest>
+): SagaIterator {
+  try {
+    const response = yield call(
+      updateAddressApi,
+      action.payload,
+      action.payload.id
+    );
+    yield put(updateAddressSuccess(response.data));
+    yield put(getAddressListRequest({}));
+  } catch (error: any) {
+    yield put(updateAddressFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleDeleteAddress(
+  action: ReturnType<typeof deleteAddressRequest>
+): SagaIterator {
+  try {
+    const response = yield call(deleteAddressApi, action.payload.id);
+    yield put(deleteAddressSuccess(response.data));
+    yield put(getAddressListRequest({}));
+  } catch (error: any) {
+    yield put(deleteAddressFailure(error.message));
+  }
+}
+
+function* handleUpdateCart(
+  action: ReturnType<typeof updateCartRequest>
+): SagaIterator {
+  try {
+    const { id, item } = action.payload;
+    const response = yield call(updateCartApi, id, item);
+    yield put(updateCartSuccess(response.data));
+    yield put(viewMyCartRequest({ id }));
+  } catch (error: any) {
+    yield put(updateCartFailure(error?.response?.data?.errors));
+  }
+}
+
+function* handleDeleteCart(
+  action: ReturnType<typeof deleteCartRequest>
+): SagaIterator {
+  try {
+    const { id, item } = action.payload;
+    const response = yield call(deleteCartApi, id, item);
+    yield put(deleteCartSuccess(response.data));
+    yield put(viewMyCartRequest({ id }));
+  } catch (error: any) {
+    yield put(deleteCartFailure(error.message));
+  }
+}
+
+function* handleAddToCart(
+  action: ReturnType<typeof addToCartRequest>
+): SagaIterator {
+  try {
+    let cartId = yield select((state: RootState) => state.auth.cartId);
+
+    let response;
+
+    if (!cartId || cartId === "null" || cartId === "") {
+      response = yield call(addToCartApi, action.payload);
+
+      yield put(addToCartSuccess(response.data));
+
+      const newCartId =
+        response.data?.response?.id ||
+        response.data?.id ||
+        response.data?.order?.id;
+
+      if (newCartId) {
+        cartId = newCartId;
+      }
+    } else {
+      const addToExistingPayload = {
+        product_variation_id:
+          action.payload.order.items[0].product_variation_id,
+        quantity: action.payload.order.items[0].quantity,
+        shipping_address: action.payload.order.items[0].shipping_address,
+      };
+
+      response = yield call(getMyExistingCartApi, cartId, addToExistingPayload);
+      yield put(addToCartSuccess(response.data));
+    }
+
+    if (cartId && cartId !== "" && cartId !== "null") {
+      yield put(
+        viewMyCartRequest({
+          id: cartId,
+          successMessage: response.data.message,
+        })
+      );
+    }
+  } catch (error: any) {
+    console.log("failure of cart...",error?.response);
+    
+    yield put(addToCartFailure(error?.response?.data));
+  }
+}
+
+function* handlePointsLog(): SagaIterator {
+  try {
+    const response = yield call(pointsLogApi);
+    yield put(pointsLogSuccess(response.data));
+  } catch (error: any) {
+    yield put(pointsLogFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleGenerateEVouchers(): SagaIterator {
+  try {
+    const response = yield call(generateEVouchersApi);
+    yield put(generateEVouchersSuccess(response.data));
+  } catch (error: any) {
+    yield put(generateEVouchersFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleValidateEVouchers(
+  action: ReturnType<typeof validateEVouchersRequest>
+): SagaIterator {
+  try {
+    const otp = action.payload?.otp;
+    const response = yield call(validateEVouchersApi, otp);
+    yield put(validateEVouchersSuccess(response.data));
+  } catch (error: any) {
+    yield put(validateEVouchersFailure(error?.response?.data?.message));
+  }
+}
+
+function* handleCheckout(
+  action: ReturnType<typeof checkoutRequest>
+): SagaIterator {
+  try {
+    const { orderId } = action.payload;
+
+    if (!orderId) {
+      yield put(checkoutFailure("Order ID is required for checkout"));
+      return;
+    }
+
+    const response = yield call(checkoutApi, orderId, action.payload);
+
+    yield put(checkoutSuccess(response.data));
+  } catch (error: any) {
+    let errorMessage = "Checkout failed. Please try again.";
+
+    if (error?.response) {
+      if (error.response.data?.message) {
+        errorMessage = error.response.data.message;
+      } else if (error.response.status === 500) {
+        errorMessage = "Server error. Please try again later.";
+      } else if (error.response.status === 400) {
+        errorMessage = "Invalid request. Please check your order details.";
+      }
+    } else if (error?.message) {
+      errorMessage = error.message;
+    }
+
+    yield put(checkoutFailure(errorMessage));
+  }
+}
+
+function* handleDeliverHere(
+  action: ReturnType<typeof deliverHereRequest>
+): SagaIterator {
+  try {
+    const { order_id } = action.payload;
+
+    if (!order_id) {
+      yield put(deliverHereFailure("Order ID is required for deliver here"));
+      return;
+    }
+
+    const response = yield call(deliverHereApi, order_id, action.payload);
+
+    const serializableData = {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText
+    };
+    
+    yield put(deliverHereSuccess(serializableData));
+  } catch (error: any) {
+    let errorMessage = "Deliver here failed. Please try again.";
+
+    if (error?.response) {
+      if (error.response.data?.message) {
+        errorMessage = error.response.data.message;
+      } else if (error.response.status === 500) {
+        errorMessage = "Server error. Please try again later.";
+      } else if (error.response.status === 400) {
+        errorMessage = "Invalid request. Please check your order details.";
+      }
+    } else if (error?.message) {
+      errorMessage = error.message;
+    }
+
+    yield put(deliverHereFailure(errorMessage));
+  }
+}
+
+function* handleSdkAuth(): SagaIterator {
+  try {
+    const response = yield call(sdkAuthApi);
+
+    if (response.data?.status === true && response.data?.session?.token) {
+      const token = response.data.session.token;
+      yield call(AsyncStorage.setItem, "accessToken", token);
+      yield put(sdkAuthSuccess(response.data));
+    } else {
+      const errorMsg = response.data?.message || "SDK authentication failed";
+      yield put(sdkAuthFailure(errorMsg));
+    }
+  } catch (error: any) {
+    yield put(
+      sdkAuthFailure(
+        error?.response?.data?.message || error?.message || "SDK authentication failed"
+      )
+    );
+  }
+}
+
+export function* authSaga(): SagaIterator {
+  yield takeLatest(sdkAuthRequest.type, handleSdkAuth);
+  yield takeLatest(generateOtpRequest.type, handleGenerateOtp);
+  yield takeLatest(verifyMobileOtpRequest.type, handleVerifyMobileOtp);
+  yield takeLatest(myOrdersRequest.type, handleMyOrders);
+  yield takeLatest(myProductsListRequest.type, handleMyProductList);
+  yield takeLatest(myProfileRequest.type, handleMyProfile);
+  yield takeLatest(uploadProfileImageRequest.type, handleUploadProfileImage);
+  yield takeLatest(productDetailsByIdRequest.type, handleProductDetailsById);
+  yield takeLatest(myOrdersGenerateOtpRequest.type, handleMyOrdersGenerateOtp);
+  yield takeLatest(myOrdersValidateOtpRequest.type, handleMyOrdersValidateOtp);
+  yield takeLatest(redemptionHistoryRequest.type, handleRedemptionHistory);
+  yield takeLatest(productTypesRequest.type, handleProductTypes);
+  yield takeLatest(
+    productCategoriesByTypeRequest.type,
+    handleProductCategoriesByType
+  );
+  yield takeLatest(viewMyCartRequest.type, handleViewMyCartById);
+  yield takeLatest(dashboardInfoRequest.type, handleDashboardInfo);
+  yield takeLatest(getAddressListRequest.type, handleGetAddressList);
+  yield takeLatest(createAddressRequest.type, handleCreateAddress);
+  yield takeLatest(updateAddressRequest.type, handleUpdateAddress);
+  yield takeLatest(deleteAddressRequest.type, handleDeleteAddress);
+  yield takeLatest(updateCartRequest.type, handleUpdateCart);
+  yield takeLatest(deleteCartRequest.type, handleDeleteCart);
+  yield takeLatest(addToCartRequest.type, handleAddToCart);
+  yield takeLatest(pointsLogRequest.type, handlePointsLog);
+  yield takeLatest(generateEVouchersRequest.type, handleGenerateEVouchers);
+  yield takeLatest(validateEVouchersRequest.type, handleValidateEVouchers);
+  yield takeLatest(checkoutRequest.type, handleCheckout);
+  yield takeLatest(deliverHereRequest.type, handleDeliverHere);
+}