@capillarytech/creatives-library 8.0.130 → 8.0.131

package/v2Containers/MobilePushNew/reducer.js

@@ -0,0 +1,160 @@
+/*
+ *
+ * Create & Edit reducer
+ *
+ */
+
+import { fromJS } from "immutable";
+import * as types from "./constants";
+
+const initialState = fromJS({
+  createTemplateInProgress: false,
+  response: {},
+  editTemplateInProgress: false,
+  editResponse: {},
+  getTemplateDetailsInProgress: false,
+  templateDetails: {},
+  createTemplateErrorMessage: "",
+});
+
+export function mobilePushReducer(state = initialState, action) {
+  // Handle null or undefined action
+  if (!action || typeof action !== 'object') {
+    return state;
+  }
+
+  switch (action.type) {
+    case types.DEFAULT_ACTION:
+      return state;
+    case types.CREATE_TEMPLATE_REQUEST:
+      return state
+        .set("createTemplateInProgress", true)
+        .set("createTemplateError", false)
+        .set("createTemplateErrorMessage", fromJS(""));
+    case types.CREATE_TEMPLATE_SUCCESS:
+      return state
+        .set("createTemplateInProgress", false)
+        .set("response", action.data)
+        .set(
+          "createTemplateError",
+          action.statusCode !== undefined && action.statusCode > 300
+        );
+    case types.CREATE_TEMPLATE_FAILURE:
+      return state
+        .set("createTemplateInProgress", false)
+        .set("createTemplateError", true)
+        .set("createTemplateErrorMessage", fromJS(action.error));
+    case types.CLEAR_CREATE_RESPONSE_REQUEST:
+      return state.set("response", {});
+    case types.UPLOAD_ASSET_REQUEST:
+      return state.set("uploadAssetSuccess", false).set("assetUploading", true);
+    case types.UPLOAD_ASSET_SUCCESS:
+      return state
+        .set(
+          "uploadAssetSuccess",
+          action.statusCode !== undefined
+            && action.statusCode !== ""
+            && action.statusCode < 300
+        )
+        .set("assetUploading", false)
+        .set(action.index !== undefined ? `uploadedAssetData${action.index}` : "uploadedAssetData", action.data);
+    case types.UPLOAD_ASSET_FAILURE:
+      return state
+        .set("uploadAssetSuccess", false)
+        .set("assetUploading", false);
+    case types.CLEAR_ASSET:
+      return action.index !== undefined 
+        ? state.delete(`uploadedAssetData${action.index}`)
+        : state.delete("uploadedAssetData");
+    case types.GET_IOS_CTAS:
+      return state.set("getIosCtasSucccess", false).set("iosCtasLoading", true);
+    case types.GET_IOS_CTAS_SUCCESS:
+      return state
+        .set(
+          "getIosCtasSucccess",
+          action.statusCode !== undefined
+            && action.statusCode !== ""
+            && action.statusCode < 300
+        )
+        .set("iosCtasLoading", false)
+        .set("iosCtasData", action.data);
+    case types.GET_IOS_CTAS_FAILURE:
+      return state
+        .set("getIosCtasSucccess", false)
+        .set("iosCtasLoading", false);
+    case types.RESET_STORE:
+      return state
+        .delete("uploadedAssetData")
+        .delete("uploadedAssetData0")
+        .delete("uploadedAssetData1")
+        .delete("iosCtasData");
+    case types.EDIT_TEMPLATE_REQUEST:
+      return state
+        .set("editTemplateInProgress", true)
+        .set("editTemplateError", false)
+        .set("editTemplateErrorMessage", fromJS(""));
+    case types.EDIT_TEMPLATE_SUCCESS:
+      return state
+        .set("editTemplateInProgress", false)
+        .set("editResponse", action.data)
+        .set(
+          "editTemplateError",
+          action.statusCode !== undefined && action.statusCode > 300
+        )
+        .set("editTemplateErrorMessage", fromJS(action.errorMsg));
+    case types.EDIT_TEMPLATE_FAILURE:
+      return state
+        .set("editTemplateInProgress", false)
+        .set("editTemplateError", true)
+        .set("editTemplateErrorMessage", fromJS(action.errorMsg));
+    case types.GET_TEMPLATE_DETAILS_REQUEST:
+      return state.set("getTemplateDetailsInProgress", true);
+    case types.GET_TEMPLATE_DETAILS_SUCCESS:
+    case types.SET_SELECTED_TEMPLATE:
+      return state
+        .set("getTemplateDetailsInProgress", false)
+        .set("templateDetails", action.data);
+    case types.GET_TEMPLATE_DETAILS_FAILURE:
+      return state.set("getTemplateDetailsInProgress", false);
+    case types.CLEAR_EDIT_RESPONSE_REQUEST:
+      return state.set("editResponse", {});
+    case types.CLEAR_DATA:
+      return state
+        .delete("uploadedAssetData")
+        .delete("uploadedAssetData0")
+        .delete("uploadedAssetData1")
+        .delete("metaEntities")
+        .delete("templateDetails")
+        .delete("iosCtasData");
+    case types.GET_WECRM_ACCOUNTS_REQUEST:
+      return state
+        .set("fetchingWeCrmAccounts", true)
+        .set("weCrmAccountFetchingError", false);
+    case types.GET_WECRM_ACCOUNTS_SUCCESS:
+      return state
+        .set("fetchingWeCrmAccounts", false)
+        .set("weCrmAccounts", fromJS(action.data));
+    case types.GET_WECRM_ACCOUNTS_FAILURE:
+      return state
+        .set("fetchingWeCrmAccounts", false)
+        .set("weCrmAccountFetchingError", true);
+    case types.SET_WECHAT_ACCOUNT:
+      return state
+        .set("selectedWeChatAccount", fromJS(action.weChatAccount))
+        .delete("mobilepushTemplates");
+    case types.GET_MOBILEPUSH_TEMPLATES_LIST_REQUEST:
+      return state.set("fetchingDefaultTemplates", true);
+    case types.GET_MOBILEPUSH_TEMPLATES_LIST_SUCCESS:
+      return state
+        .set("fetchingDefaultTemplates", false)
+        .set("mobilepushTemplates", fromJS(action.data));
+    case types.GET_MOBILEPUSH_TEMPLATES_LIST_FAILURE:
+      return state
+        .set("fetchingDefaultTemplates", false)
+        .set("errorFetchingDefaultTempalte", true);
+    default:
+      return state;
+  }
+}
+
+export default mobilePushReducer;

package/v2Containers/MobilePushNew/sagas.js

@@ -0,0 +1,193 @@
+import {
+  call, put, takeLatest, all,
+} from "redux-saga/effects";
+import * as Api from "../../services/api";
+import * as types from "./constants";
+
+export function* createTemplate({template, callback}) {
+  let errorMsg;
+  try {
+    const result = yield call(Api.createMobilePushTemplateV2, template);
+    if (result.message) {
+      errorMsg = result.message;
+      if (result.status && result.status.code >= 400) {
+        throw errorMsg;
+      }
+    }
+    if (callback) {
+      yield call(callback, result.response);
+    }
+    yield put({
+      type: types.CREATE_TEMPLATE_SUCCESS,
+      data: result.response,
+      statusCode: result.status ? result.status.code : "",
+      errorMsg,
+    });
+  } catch (error) {
+    yield put({ type: types.CREATE_TEMPLATE_FAILURE, error, errorMsg });
+  }
+}
+export function* uploadAsset(action) {
+  try {
+    const {
+      file, assetType, fileParams, index, mobilePushParams = {},
+    } = action;
+    const uploadParams = {
+      file,
+      assetType,
+      fileParams,
+      ...mobilePushParams,
+    };
+    const result = yield call(Api.uploadFile, uploadParams);
+
+    yield put({
+      type: types.UPLOAD_ASSET_SUCCESS,
+      data: result.response.asset,
+      statusCode: result.status ? result.status.code : "",
+      index,
+    });
+  } catch (error) {
+    yield put({ type: types.UPLOAD_ASSET_FAILURE, error });
+  }
+}
+
+export function* watchCreateTemplate() {
+  yield takeLatest(types.CREATE_TEMPLATE_REQUEST, createTemplate);
+}
+export function* watchUploadAsset() {
+  yield takeLatest(types.UPLOAD_ASSET_REQUEST, uploadAsset);
+}
+export function* watchGetIosCtas() {
+  yield takeLatest(types.GET_IOS_CTAS, getIosCtas);
+}
+
+export function* editTemplate({ template, callback }) {
+  let errorMsg;
+  try {
+    // Use the same API endpoint as create - backend determines create vs edit based on _id presence
+    const result = yield call(Api.createMobilePushTemplateV2, template);
+    // Check for error status codes (400+)
+    if (result.status.code >= 400) {
+      errorMsg = result.message || `HTTP Error ${result.status.code}`;
+      throw errorMsg;
+    }
+
+    // For edit operations, we need to structure the response similar to create
+    // The Templates container expects a templateId field
+    const editResponseData = {
+      ...result.response,
+      templateId: result?.response?.templateId?._id || result?.response?._id || template._id,
+    };
+
+    yield put({
+      type: types.EDIT_TEMPLATE_SUCCESS,
+      data: editResponseData,
+      statusCode: result.status ? result.status.code : "",
+      errorMsg,
+    });
+
+    // Call callback with proper response structure
+    if (callback) {
+      yield call(callback, editResponseData);
+    }
+  } catch (error) {
+    yield put({ type: types.EDIT_TEMPLATE_FAILURE, error, errorMsg });
+  }
+}
+
+export function* getTemplateDetails(id) {
+  try {
+    const result = yield call(Api.getTemplateDetails, id);
+    yield put({
+      type: types.GET_TEMPLATE_DETAILS_SUCCESS,
+      data: result.response,
+    });
+  } catch (error) {
+    yield put({ type: types.GET_TEMPLATE_DETAILS_FAILURE, error });
+  }
+}
+
+export function* getIosCtas(licenseCode) {
+  try {
+    const result = yield call(Api.getIosCtas, licenseCode);
+    yield put({
+      type: types.GET_IOS_CTAS_SUCCESS,
+      data: result.response.metaEntities.data,
+      statusCode: result.status ? result.status.code : "",
+    });
+  } catch (error) {
+    yield put({ type: types.GET_IOS_CTAS_FAILURE, error });
+  }
+}
+
+export function* getMobilepushTemplatesList(params) {
+  try {
+    const result = yield call(Api.getAllTemplates, {
+      channel: params.channel,
+      queryParams: params.queryParams,
+    });
+    yield put({
+      type: types.GET_MOBILEPUSH_TEMPLATES_LIST_SUCCESS,
+      data: result.response.templates,
+      templateData: result.response.mapped,
+    });
+  } catch (error) {
+    yield put({ type: types.GET_MOBILEPUSH_TEMPLATES_LIST_FAILURE, error });
+  }
+}
+
+export function* fetchWeCrmAccounts(action) {
+  try {
+    const result = yield call(Api.fetchWeCrmAccounts, action.source);
+    yield put({
+      type: types.GET_WECRM_ACCOUNTS_SUCCESS,
+      data: result.response,
+    });
+  } catch (error) {
+    yield put({
+      type: types.GET_WECRM_ACCOUNTS_FAILURE,
+      data: error,
+    });
+  }
+}
+
+export function* watchFetchWeCrmAccounts() {
+  yield takeLatest(types.GET_WECRM_ACCOUNTS_REQUEST, fetchWeCrmAccounts);
+}
+
+export function* watchEditTemplate() {
+  yield takeLatest(types.EDIT_TEMPLATE_REQUEST, editTemplate);
+}
+
+export function* watchGetTemplateDetails() {
+  yield takeLatest(types.GET_TEMPLATE_DETAILS_REQUEST, getTemplateDetails);
+}
+
+export function* watchMobilepushTemplatesList() {
+  yield takeLatest(
+    types.GET_MOBILEPUSH_TEMPLATES_LIST_REQUEST,
+    getMobilepushTemplatesList
+  );
+}
+
+export default [
+  watchEditTemplate,
+  watchCreateTemplate,
+  watchGetTemplateDetails,
+  watchFetchWeCrmAccounts,
+  watchMobilepushTemplatesList,
+  watchUploadAsset,
+  watchGetIosCtas,
+];
+
+export function* v2MobilePushSagas() {
+  yield all([
+    watchCreateTemplate(),
+    watchEditTemplate(),
+    watchGetTemplateDetails(),
+    watchFetchWeCrmAccounts(),
+    watchMobilepushTemplatesList(),
+    watchUploadAsset(),
+    watchGetIosCtas(),
+  ]);
+}

package/v2Containers/MobilePushNew/selectors.js

@@ -0,0 +1,55 @@
+import { createSelector } from 'reselect';
+import { fromJS } from 'immutable';
+
+// New selectors for MobilePushNew
+const selectMobilePushNewDomain = () => (state) => state.get('mobilePushNew') || fromJS({});
+
+const makeSelectMobilePushNew = () => createSelector(
+  selectMobilePushNewDomain(),
+  (substate) => substate.toJS()
+);
+
+const makeSelectUploadedAssetData = () => createSelector(
+  selectMobilePushNewDomain(),
+  (substate) => substate.get('uploadedAssetData') || {}
+);
+
+const makeSelectUploadedAssetData0 = () => createSelector(
+  selectMobilePushNewDomain(),
+  (substate) => substate.get('uploadedAssetData0') || {}
+);
+
+const makeSelectUploadedAssetData1 = () => createSelector(
+  selectMobilePushNewDomain(),
+  (substate) => substate.get('uploadedAssetData1') || {}
+);
+
+const makeSelectUploadAssetSuccess = () => createSelector(
+  selectMobilePushNewDomain(),
+  (substate) => substate.get('uploadAssetSuccess') || false
+);
+
+const makeSelectCreateError = () => createSelector(
+  selectMobilePushNewDomain(), (dimensionState) => dimensionState.get('createTemplateErrorMessage') || ""
+);
+
+const makeSelectAssetUploading = () => createSelector(
+  selectMobilePushNewDomain(),
+  (substate) => substate.get('assetUploading') || false
+);
+
+const makeSelectGetTemplateDetailsInProgress = () => createSelector(
+  selectMobilePushNewDomain(),
+  (substate) => substate.get('getTemplateDetailsInProgress') || false
+);
+
+export {
+  makeSelectMobilePushNew,
+  makeSelectUploadedAssetData,
+  makeSelectUploadedAssetData0,
+  makeSelectUploadedAssetData1,
+  makeSelectUploadAssetSuccess,
+  makeSelectCreateError,
+  makeSelectAssetUploading,
+  makeSelectGetTemplateDetailsInProgress,
+};