@capillarytech/creatives-library 8.0.241 → 8.0.242-alpha.0

package/v2Containers/WebPush/reducer.js

@@ -0,0 +1,104 @@
+/*
+ *
+ * WebPush reducer
+ *
+ */
+
+import { fromJS } from "immutable";
+import * as types from "./constants";
+
+const initialState = fromJS({
+  createTemplateInProgress: false,
+  response: {},
+  createTemplateErrorMessage: "",
+  editTemplateInProgress: false,
+  editResponse: {},
+  editTemplateErrorMessage: "",
+  uploadedAssetData: {},
+  uploadAssetSuccess: false,
+  assetUploading: false,
+});
+
+export function webPushReducer(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.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
+        );
+    case types.EDIT_TEMPLATE_FAILURE:
+      return state
+        .set("editTemplateInProgress", false)
+        .set("editTemplateError", true)
+        .set("editTemplateErrorMessage", fromJS(action.error || action.errorMsg || ""));
+    case types.CLEAR_EDIT_RESPONSE_REQUEST:
+      return state.set("editResponse", {});
+    case types.UPLOAD_WEBPUSH_ASSET_REQUEST:
+      return state.set("uploadAssetSuccess", false).set("assetUploading", true);
+    case types.UPLOAD_WEBPUSH_ASSET_SUCCESS:
+      return state
+        .set(
+          "uploadAssetSuccess",
+          action.statusCode !== undefined &&
+            action.statusCode !== "" &&
+            action.statusCode < 300,
+        )
+        .set("assetUploading", false)
+        .set(
+          action.templateType !== undefined
+            ? `uploadedAssetData${action.templateType}`
+            : "uploadedAssetData",
+          action.data,
+        );
+    case types.UPLOAD_WEBPUSH_ASSET_FAILURE:
+      return state
+        .set("uploadAssetSuccess", false)
+        .set("assetUploading", false);
+    case types.CLEAR_WEBPUSH_ASSET:
+      return state.delete(
+        action.templateType !== undefined
+          ? `uploadedAssetData${action.templateType}`
+          : "uploadedAssetData",
+      );
+    default:
+      return state;
+  }
+}
+
+export default webPushReducer;
+

package/v2Containers/WebPush/sagas.js

@@ -0,0 +1,119 @@
+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, meta }) {
+  let errorMsg;
+  try {
+    const result = yield call(Api.createWebPushTemplate, template);
+    if (result.status && result.status.code >= 400) {
+      errorMsg = result.message;
+      throw errorMsg;
+    }
+    if (result.message) {
+      errorMsg = result.message;
+    }
+    // Merge meta into response if provided
+    const responseWithMeta = meta ? { ...result.response, meta } : result.response;
+    if (callback) {
+      yield call(callback, responseWithMeta);
+    }
+    yield put({
+      type: types.CREATE_TEMPLATE_SUCCESS,
+      data: responseWithMeta,
+      statusCode: result.status ? result.status.code : '',
+      errorMsg,
+    });
+  } catch (error) {
+    yield put({ type: types.CREATE_TEMPLATE_FAILURE, error, errorMsg });
+  }
+}
+
+export function* clearCreateResponse() {
+  yield put({ type: types.CLEAR_CREATE_RESPONSE_SUCCESS });
+}
+
+export function* editTemplate({ template, callback }) {
+  let errorMsg;
+  try {
+    const result = yield call(Api.createWebPushTemplate, template);
+    if (result.status && result.status.code >= 400) {
+      errorMsg = result.message;
+      throw errorMsg;
+    }
+    if (result.message) {
+      errorMsg = result.message;
+    }
+    if (callback) {
+      callback(result.response, errorMsg);
+    }
+    yield put({
+      type: types.EDIT_TEMPLATE_SUCCESS,
+      data: result.response,
+      statusCode: result.status ? result.status.code : '',
+      errorMsg,
+    });
+  } catch (error) {
+    yield put({ type: types.EDIT_TEMPLATE_FAILURE, error, errorMsg });
+    if (callback) {
+      callback(null, errorMsg);
+    }
+  }
+}
+
+export function* clearEditResponse() {
+  yield put({ type: types.CLEAR_EDIT_RESPONSE_SUCCESS });
+}
+
+export function* uploadWebPushAsset({ file, assetType, fileParams, templateType }) {
+  try {
+    const result = yield call(Api.uploadFile, {
+      file,
+      assetType,
+      fileParams,
+    });
+    yield put({
+      type: types.UPLOAD_WEBPUSH_ASSET_SUCCESS,
+      data: result?.response?.asset,
+      statusCode: result?.status?.code || '',
+      templateType,
+    });
+  } catch (error) {
+    yield put({ type: types.UPLOAD_WEBPUSH_ASSET_FAILURE, error });
+  }
+}
+
+export function* watchCreateTemplate() {
+  yield takeLatest(types.CREATE_TEMPLATE_REQUEST, createTemplate);
+}
+
+export function* watchClearCreateResponse() {
+  yield takeLatest(types.CLEAR_CREATE_RESPONSE_REQUEST, clearCreateResponse);
+}
+
+export function* watchEditTemplate() {
+  yield takeLatest(types.EDIT_TEMPLATE_REQUEST, editTemplate);
+}
+
+export function* watchClearEditResponse() {
+  yield takeLatest(types.CLEAR_EDIT_RESPONSE_REQUEST, clearEditResponse);
+}
+
+export function* watchUploadWebPushAsset() {
+  yield takeLatest(
+    types.UPLOAD_WEBPUSH_ASSET_REQUEST,
+    uploadWebPushAsset,
+  );
+}
+
+export default function* webPushSagas() {
+  yield all([
+    watchCreateTemplate(),
+    watchClearCreateResponse(),
+    watchEditTemplate(),
+    watchClearEditResponse(),
+    watchUploadWebPushAsset(),
+  ]);
+}

package/v2Containers/WebPush/selectors.js

@@ -0,0 +1,65 @@
+import { createSelector } from 'reselect';
+import { fromJS } from 'immutable';
+
+// Selectors for WebPush
+const selectWebPushDomain = () => (state) => state.get('webPush') || fromJS({});
+
+const makeSelectWebPush = () => createSelector(
+  selectWebPushDomain(),
+  (substate) => substate.toJS()
+);
+
+const makeSelectCreateError = () => createSelector(
+  selectWebPushDomain(),
+  (dimensionState) => dimensionState.get('createTemplateErrorMessage') || ""
+);
+
+const makeSelectCreateTemplateInProgress = () => createSelector(
+  selectWebPushDomain(),
+  (substate) => substate.get('createTemplateInProgress') || false
+);
+
+const makeSelectEditTemplateInProgress = () => createSelector(
+  selectWebPushDomain(),
+  (substate) => substate.get('editTemplateInProgress') || false
+);
+
+const makeSelectEditError = () => createSelector(
+  selectWebPushDomain(),
+  (dimensionState) => dimensionState.get('editTemplateErrorMessage') || ""
+);
+
+const makeSelectUploadedAssetData = (templateType) => createSelector(
+  selectWebPushDomain(),
+  (substate) => {
+    // Compute the key based on templateType (matches reducer logic)
+    const key = templateType !== undefined
+      ? `uploadedAssetData${templateType}`
+      : 'uploadedAssetData';
+    
+    const uploadedAssetData = substate.get(key);
+    
+    if (!uploadedAssetData) {
+      return {};
+    }
+    
+    // Safe: handle both Immutable and plain JS values
+    // If it's Immutable, convert to JS; if already plain JS, return as-is
+    if (uploadedAssetData && typeof uploadedAssetData.toJS === 'function') {
+      return uploadedAssetData.toJS();
+    }
+    
+    // Already plain JS object (from reducer storing action.data directly)
+    return uploadedAssetData;
+  }
+);
+
+export {
+  makeSelectWebPush,
+  makeSelectCreateError,
+  makeSelectCreateTemplateInProgress,
+  makeSelectEditTemplateInProgress,
+  makeSelectEditError,
+  makeSelectUploadedAssetData,
+};
+