@capillarytech/creatives-library 7.18.0-beta.0 → 8.0.0

package/v2Containers/InApp/tests/reducer.test.js

@@ -0,0 +1,177 @@
+import { fromJS } from "immutable";
+import inAppReducer from "../reducer";
+import * as actions from "../actions";
+import * as types from "../constants";
+// import { editData } from "./mockData";
+
+
+describe("zalo reducer", () => {
+  let state;
+  const action = {};
+  beforeEach(() => {
+    state = fromJS({
+      uploadedAssetData: {},
+      createTemplateInProgress: false,
+      editTemplateInProgress: false,
+    });
+  });
+
+  describe("Reducer : INAPP_TEMPLATE_CREATE_REQUEST", () => {
+    it("should handle INAPP_TEMPLATE_CREATE_REQUEST action", () => {
+      state = state
+        .set("createTemplateInProgress", true)
+        .set("createTemplateError", false)
+        .set("createTemplateErrorMessage", "");
+      const expectedResult = state;
+      expect(inAppReducer(state, actions.createInAppTemplate({}))).toEqual(
+        expectedResult
+      );
+    });
+    it("should handle INAPP_TEMPLATE_CREATE_SUCCESS action", () => {
+      action.type = types.INAPP_TEMPLATE_CREATE_SUCCESS;
+      action.data = 'data';
+      state = state
+        .set("createTemplateInProgress", false)
+        .set("createTemplateError", false)
+        .set("createTemplateErrorMessage", undefined)
+        .set('response', 'data');
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+    it("should handle INAPP_TEMPLATE_CREATE_FAILURE action", () => {
+      action.type = types.INAPP_TEMPLATE_CREATE_FAILURE;
+      action.errorMsg = 'error';
+      state = state
+        .set("createTemplateInProgress", false)
+        .set('createTemplateError', true)
+        .set('createTemplateErrorMessage', fromJS(action.errorMsg));
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+  });
+  describe("Reducer : INAPP_EDIT_TEMPLATE_REQUEST", () => {
+    it("should handle INAPP_EDIT_TEMPLATE_REQUEST action", () => {
+      state = state
+        .set("editTemplateInProgress", true)
+        .set("editTemplateError", false)
+        .set("editTemplateErrorMessage", "");
+      const expectedResult = state;
+      expect(inAppReducer(state, actions.editTemplate({}))).toEqual(
+        expectedResult
+      );
+    });
+    it("should handle INAPP_EDIT_TEMPLATE_SUCCESS action", () => {
+      action.type = types.INAPP_EDIT_TEMPLATE_SUCCESS;
+      action.data = 'data';
+      action.statusCode = 200;
+      state = state
+        .set("editTemplateInProgress", false)
+        .set("editTemplateError", false)
+        .set("editTemplateErrorMessage", 'error')
+        .set('editResponse', 'data');
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+    it("should handle INAPP_EDIT_TEMPLATE_FAILURE action", () => {
+      action.type = types.INAPP_EDIT_TEMPLATE_FAILURE;
+      action.errorMsg = 'error';
+      state = state
+        .set("editTemplateInProgress", false)
+        .set('editTemplateError', true)
+        .set('editTemplateErrorMessage', fromJS(action.errorMsg));
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+
+    it("should handle default action", () => {
+      action.type = "deafult_action";
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+  });
+  describe("Reducer : GET_TEMPLATE_DETAILS_REQUEST", () => {
+    it("should handle GET_TEMPLATE_DETAILS_REQUEST action", () => {
+      state = state
+        .set("getTemplateDetailsInProgress", true);
+      const expectedResult = state;
+      expect(inAppReducer(state, actions.getTemplateDetails({}))).toEqual(
+        expectedResult
+      );
+    });
+    it("should handle INAPP_EDIT_TEMPLATE_SUCCESS action", () => {
+      action.type = types.GET_INAPP_TEMPLATE_DETAILS_SUCCESS;
+      action.data = 'data';
+      action.statusCode = 200;
+      state = state
+        .set("getTemplateDetailsInProgress", false)
+        .set('templateDetails', 'data');
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+    it("should handle GET_TEMPLATE_DETAILS_FAILURE action", () => {
+      action.type = types.GET_INAPP_TEMPLATE_DETAILS_FAILURE;
+      action.errorMsg = 'error';
+      state = state
+        .set("getTemplateDetailsInProgress", false);
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+    it("should handle CLEAR_CREATE_RESPONSE_REQUEST action", () => {
+      action.type = types.CLEAR_CREATE_RESPONSE_REQUEST;
+      state = state
+        .set("response", {});
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+    it("should handle RESET_EDIT_TEMPLATE action", () => {
+      action.type = types.RESET_EDIT_TEMPLATE;
+      state = state
+        .set("templateDetails", {});
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+  });
+  describe("Reducer : UPLOAD_INAPP_ASSET_REQUEST", () => {
+    it("should handle UPLOAD_INAPP_ASSET_REQUEST action", () => {
+      state = state
+        .set("uploadAssetSuccess", false)
+        .set("assetUploading", true);
+      const expectedResult = state;
+      expect(inAppReducer(state, actions.uploadInAppAsset({}))).toEqual(
+        expectedResult
+      );
+    });
+    it("should handle UPLOAD_INAPP_ASSET_SUCCESS action", () => {
+      action.type = types.UPLOAD_INAPP_ASSET_SUCCESS;
+      action.data = 'data';
+      action.statusCode = 200;
+      state = state
+        .set("getTemplateDetailsInProgress", false)
+        .set('assetUploading', false)
+        .set('uploadAssetSuccess', true)
+        .set('uploadedAssetData', 'data');
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+    it("should handle UPLOAD_INAPP_ASSET_FAILURE action", () => {
+      action.type = types.UPLOAD_INAPP_ASSET_FAILURE;
+      action.errorMsg = 'error';
+      state = state
+        .set("assetUploading", false)
+        .set('uploadAssetSuccess', false);
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+    it("should handle CLEAR_INAPP_ASSET action", () => {
+      action.type = types.CLEAR_INAPP_ASSET;
+      action.errorMsg = 'error';
+      action.data = 'data';
+      state = state
+        .set("assetUploading", false)
+        .delete('uploadedAssetData', {})
+        .set('uploadAssetSuccess', false);
+      const expectedResult = state;
+      expect(inAppReducer(state, action)).toEqual(expectedResult);
+    });
+  });
+});

package/v2Containers/InApp/tests/sagas.test.js

@@ -0,0 +1,391 @@
+import { call, cancel, put, takeLatest } from 'redux-saga/effects';
+import { createMockTask } from 'redux-saga/utils';
+import * as sagas from '../sagas';
+import * as Api from '../../../services/api';
+import * as types from '../constants';
+import { INAPP } from '../../CreativesContainer/constants';
+
+describe('test for uploadInAppAsset function', () => {
+  it('should dispatch UPLOAD_INAPP_ASSET_SUCCESS action with asset data, status code, and template type', () => {
+    // Mock the necessary dependencies
+    const params = {
+      file: new File([""], "filename"),
+      assetType: 'image',
+      fileParams: {
+        name: 'image.jpg',
+        size: 1024,
+      },
+      mode: 'create',
+      wechatParams: {
+        source: 'wechat',
+        appId: '123456',
+        appSecret: 'abcdef',
+      },
+      whatsappParams: {
+        source: 'whatsapp',
+        wabaId: '987654',
+        accessToken: 'xyz123',
+        hostName: 'whatsapp.com',
+      },
+    };
+
+    // Mock the API.uploadFile function
+    const uploadFileMock = jest.spyOn(Api, 'uploadFile').mockImplementation(() => Promise.resolve({
+      response: {
+        asset: { id: 1, name: 'image.jpg' },
+      },
+      status: {
+        code: 200,
+      },
+    }));
+
+    const result = { response: { asset: { id: 1, name: 'image.jpg' } }, status: { code: 200 } };
+
+    // Invoke the function
+    const generator = sagas.uploadInAppAsset(params);
+    generator.next();
+    const actual = generator.next(result).value;
+
+    // Assert the dispatched action
+    expect(actual).toEqual(
+      put({
+        type: types.UPLOAD_INAPP_ASSET_SUCCESS,
+        data: { id: 1, name: 'image.jpg' },
+        statusCode: 200,
+        templateType: params.templateType,
+      })
+    );
+
+    // Restore the mocks
+    uploadFileMock.mockRestore();
+  });
+
+  it('should dispatch UPLOAD_INAPP_ASSET_FAILURE action with error', () => {
+    // Mock the necessary dependencies
+    const params = {
+      file: new File([""], "filename"),
+      assetType: 'image',
+      fileParams: {
+        name: 'image.jpg',
+        size: 1024,
+      },
+      mode: 'create',
+      wechatParams: {
+        source: 'wechat',
+        appId: '123456',
+        appSecret: 'abcdef',
+      },
+      whatsappParams: {
+        source: 'whatsapp',
+        wabaId: '987654',
+        accessToken: 'xyz123',
+        hostName: 'whatsapp.com',
+      },
+    };
+
+    // Mock the API.uploadFile function
+    const uploadFileMock = jest.spyOn(Api, 'uploadFile').mockImplementation(() => Promise.reject(new Error('Upload failed')));
+    // Invoke the function
+    const generator = sagas.uploadInAppAsset(params);
+    generator.next();
+
+    // Assert the dispatched action
+    expect(generator.throw(new Error('Upload failed')).value).toEqual(
+      put({ type: types.UPLOAD_INAPP_ASSET_FAILURE, error: new Error('Upload failed') })
+    );
+
+    // Restore the mocks
+    uploadFileMock.mockRestore();
+  });
+  it('should call uploadInAppAsset when UPLOAD_INAPP_ASSET_REQUEST action is dispatched', () => {
+    const watcher = sagas.watchUploadInAppAsset();
+    const uploadInAppAssetGenerator = watcher.next().value;
+    expect(uploadInAppAssetGenerator).toEqual(takeLatest(types.UPLOAD_INAPP_ASSET_REQUEST, sagas.uploadInAppAsset));
+  });
+  it('should cancel the watcher watchUploadInAppAsset', () => {
+    const gen = sagas.watchUploadInAppAsset();
+    const mockTask = createMockTask();
+
+    // Advance the generator to the takeLatest effect
+    expect(gen.next().value).toEqual(
+      takeLatest(types.UPLOAD_INAPP_ASSET_REQUEST, sagas.uploadInAppAsset),
+    );
+
+    // Pass the mock task to the takeLatest effect
+    expect(gen.next(mockTask).done).toBe(false);
+
+    // Call the cancel function on the mock task to simulate cancellation
+    expect(mockTask.isRunning()).toBe(true); // the task is running
+    expect(gen.next().value).toEqual(cancel(mockTask));
+  });
+});
+
+describe('test for inAppTemplateCreate function', () => {
+  it('should handle TEMPLATE_CREATE_SUCCESS', () => {
+    const payload = {}; // Add your payload for testing
+    const mockResult = {
+      status: {
+        code: 200,
+      },
+      response: { /* mock response */ },
+    };
+
+    const iterator = sagas.inAppTemplateCreate({ payload, callback: jest.fn() });
+
+    // Test the yield call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload })
+    expect(iterator.next().value).toEqual(call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload }));
+
+    // Test the result
+    expect(iterator.next(mockResult).value).toEqual(
+      put({
+        type: types.INAPP_TEMPLATE_CREATE_SUCCESS,
+        data: mockResult.response,
+        statusCode: mockResult.status.code,
+        errorMsg: undefined, // No error message expected
+      })
+    );
+
+    // Ensure the saga completes
+    expect(iterator.next().done).toBe(true);
+  });
+
+  it('should handle error case', () => {
+    const payload = {}; // Add your payload for testing
+    const mockResult = {
+      status: {
+        code: 400,
+      },
+      // message: 'error',
+      response: { /* mock response */ },
+    };
+
+    const iterator = sagas.inAppTemplateCreate({ payload, callback: jest.fn() });
+
+    // Test the yield call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload })
+    expect(iterator.next().value).toEqual(call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload }));
+
+    // Test the result
+    expect(iterator.next(mockResult).value).toEqual(
+      put({
+        type: types.INAPP_TEMPLATE_CREATE_FAILURE,
+        error: 400,
+        errorMsg: 400, // No error message expected
+      })
+    );
+
+    // Ensure the saga completes
+    expect(iterator.next().done).toBe(true);
+  });
+
+  it('should handle INAPP_TEMPLATE_CREATE_FAILURE', () => {
+    const payload = {}; // Add your payload for testing
+    const error = new Error('Test error');
+    const iterator = sagas.inAppTemplateCreate({ payload });
+
+    // Test the yield call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload })
+    expect(iterator.next().value).toEqual(call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload }));
+
+    // Test the error handling path
+    expect(iterator.throw(error).value).toEqual(
+      put({
+        type: types.INAPP_TEMPLATE_CREATE_FAILURE,
+        error,
+        errorMsg: undefined, // No error message expected
+      })
+    );
+
+    // Ensure the saga completes
+    expect(iterator.next().done).toBe(true);
+  });
+  it('should call inAppTemplateCreate when INAPP_TEMPLATE_CREATE_REQUEST action is dispatched', () => {
+    const watcher = sagas.watchCreateTemplate();
+    const gen = watcher.next().value;
+    expect(gen).toEqual(takeLatest(types.INAPP_TEMPLATE_CREATE_REQUEST, sagas.inAppTemplateCreate));
+  });
+  it('should cancel the watcher watchCreateTemplate', () => {
+    const gen = sagas.watchCreateTemplate();
+    const mockTask = createMockTask();
+
+    // Advance the generator to the takeLatest effect
+    expect(gen.next().value).toEqual(
+      takeLatest(types.INAPP_TEMPLATE_CREATE_REQUEST, sagas.inAppTemplateCreate),
+    );
+
+    // Pass the mock task to the takeLatest effect
+    expect(gen.next(mockTask).done).toBe(false);
+
+    // Call the cancel function on the mock task to simulate cancellation
+    expect(mockTask.isRunning()).toBe(true); // the task is running
+    expect(gen.next().value).toEqual(cancel(mockTask));
+  });
+});
+
+describe('test for editTemplate function', () => {
+  it('should handle INAPP_EDIT_TEMPLATE_SUCCESS', () => {
+    const payload = {}; // Add your payload for testing
+    const mockResult = {
+      status: {
+        code: 200,
+      },
+      response: { /* mock response */ },
+    };
+
+    const iterator = sagas.editTemplate({ payload, callback: jest.fn() });
+
+    // Test the yield call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload })
+    expect(iterator.next().value).toEqual(call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload }));
+
+    // Test the result
+    expect(iterator.next(mockResult).value).toEqual(
+      put({
+        type: types.INAPP_EDIT_TEMPLATE_SUCCESS,
+        data: mockResult.response,
+        statusCode: mockResult.status.code,
+        errorMsg: undefined, // No error message expected
+      })
+    );
+
+    // Ensure the saga completes
+    expect(iterator.next().done).toBe(true);
+  });
+
+  it('should handle error case', () => {
+    const payload = {}; // Add your payload for testing
+    const mockResult = {
+      status: {
+        code: 400,
+      },
+      // message: 'error',
+      response: { /* mock response */ },
+    };
+
+    const iterator = sagas.editTemplate({ payload, callback: jest.fn() });
+
+    // Test the yield call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload })
+    expect(iterator.next().value).toEqual(call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload }));
+
+    // Test the result
+    expect(iterator.next(mockResult).value).toEqual(
+      put({
+        type: types.INAPP_EDIT_TEMPLATE_FAILURE,
+        error: 400,
+        errorMsg: 400, // No error message expected
+      })
+    );
+
+    // Ensure the saga completes
+    expect(iterator.next().done).toBe(true);
+  });
+
+  it('should handle EDIT_TEMPLATE_FAILURE', () => {
+    const payload = {}; // Add your payload for testing
+    const error = new Error('Test error');
+    const iterator = sagas.editTemplate({ payload });
+
+    // Test the yield call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload })
+    expect(iterator.next().value).toEqual(call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload }));
+
+    // Test the error handling path
+    expect(iterator.throw(error).value).toEqual(
+      put({
+        type: types.INAPP_EDIT_TEMPLATE_FAILURE,
+        error,
+        errorMsg: undefined, // No error message expected
+      })
+    );
+
+    // Ensure the saga completes
+    expect(iterator.next().done).toBe(true);
+  });
+  it('should call editTemplate when INAPP_EDIT_TEMPLATE_REQUEST action is dispatched', () => {
+    const watcher = sagas.watchEditTemplate();
+    const gen = watcher.next().value;
+    expect(gen).toEqual(takeLatest(types.INAPP_EDIT_TEMPLATE_REQUEST, sagas.editTemplate));
+  });
+  it('should cancel the watcher watchCreateTemplate', () => {
+    const gen = sagas.watchEditTemplate();
+    const mockTask = createMockTask();
+
+    // Advance the generator to the takeLatest effect
+    expect(gen.next().value).toEqual(
+      takeLatest(types.INAPP_EDIT_TEMPLATE_REQUEST, sagas.editTemplate),
+    );
+
+    // Pass the mock task to the takeLatest effect
+    expect(gen.next(mockTask).done).toBe(false);
+
+    // Call the cancel function on the mock task to simulate cancellation
+    expect(mockTask.isRunning()).toBe(true); // the task is running
+    expect(gen.next().value).toEqual(cancel(mockTask));
+  });
+});
+
+describe('test for getTemplateDetails', () => {
+  it('should handle GET_INAPP_TEMPLATE_DETAILS_SUCCESS', () => {
+    const payload = {}; // Add your payload for testing
+    const mockResult = {
+      status: {
+        code: 200,
+      },
+      response: { /* mock response */ },
+    };
+
+    const iterator = sagas.getTemplateDetails({ payload, callback: jest.fn() });
+
+    // Test the yield call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload })
+    expect(iterator.next().value).toEqual(call(Api.getTemplateDetails, { channel: 'INAPP', id: undefined }));
+
+    // Test the result
+    expect(iterator.next(mockResult).value).toEqual(
+      put({
+        type: types.GET_INAPP_TEMPLATE_DETAILS_SUCCESS,
+        data: mockResult.response,
+      })
+    );
+
+    // Ensure the saga completes
+    expect(iterator.next().done).toBe(true);
+  });
+
+  it('should handle GET_INAPP_TEMPLATE_DETAILS_FAILURE', () => {
+    const payload = {}; // Add your payload for testing
+    const error = new Error('Test error');
+    const iterator = sagas.getTemplateDetails({ channel: INAPP, template: payload });
+
+    // Test the yield call(Api.createChannelWiseTemplate, { channel: INAPP, template: payload })
+    expect(iterator.next().value).toEqual(call(Api.getTemplateDetails, { channel: 'INAPP', id: undefined }));
+
+    // Test the error handling path
+    expect(iterator.throw(error).value).toEqual(
+      put({
+        type: types.GET_INAPP_TEMPLATE_DETAILS_FAILURE,
+        error,
+        errorMsg: undefined, // No error message expected
+      })
+    );
+
+    // Ensure the saga completes
+    expect(iterator.next().done).toBe(true);
+  });
+  it('should call getTemplateDetails when GET_INAPP_TEMPLATE_DETAILS_REQUEST action is dispatched', () => {
+    const watcher = sagas.watchGetTemplateDetails();
+    const gen = watcher.next().value;
+    expect(gen).toEqual(takeLatest(types.GET_INAPP_TEMPLATE_DETAILS_REQUEST, sagas.getTemplateDetails));
+  });
+  it('should cancel the watcher watchGetTemplateDetails', () => {
+    const gen = sagas.watchGetTemplateDetails();
+    const mockTask = createMockTask();
+
+    // Advance the generator to the takeLatest effect
+    expect(gen.next().value).toEqual(
+      takeLatest(types.GET_INAPP_TEMPLATE_DETAILS_REQUEST, sagas.getTemplateDetails),
+    );
+
+    // Pass the mock task to the takeLatest effect
+    expect(gen.next(mockTask).done).toBe(false);
+
+    // Call the cancel function on the mock task to simulate cancellation
+    expect(mockTask.isRunning()).toBe(true); // the task is running
+    expect(gen.next().value).toEqual(cancel(mockTask));
+  });
+});

package/v2Containers/InApp/utils.js

@@ -0,0 +1,12 @@
+export const getCtaObject = (ctaData) =>
+  ctaData?.map((cta, index) => {
+    const { type = "", actionText = "", actionLink = "" } = cta;
+    const obj = {
+      index,
+      text: actionText,
+      url: actionLink,
+      urlType: type,
+      isSaved: true,
+    };
+    return obj;
+  });

package/v2Containers/LanguageProvider/index.js

@@ -17,11 +17,14 @@ import { connect } from 'react-redux';
 import { createStructuredSelector } from 'reselect';
 import { IntlProvider } from 'react-intl';
 import moment from 'moment';
-import { bindActionCreators } from 'redux';
+import { bindActionCreators, compose } from 'redux';
 import * as actions from './actions';
 import { makeSelectLocale } from './selectors';
 import { makeSelectUser } from '../Cap/selectors';
-
+import { LanguageProviderRootSaga } from './sagas';
+import injectSaga from '../../utils/injectSaga';
+import injectReducer from '../../utils/injectReducer';
+import reducer from './reducer';
 
 export class LanguageProvider extends React.PureComponent { // eslint-disable-line react/prefer-stateless-function
   componentDidUpdate(prevProps) {
@@ -53,7 +56,7 @@ export class LanguageProvider extends React.PureComponent { // eslint-disable-li
     this.props.actions.getLocizMessage(locale);
   }
   render() {
-    const { locale, messages} = this.props.language;
+    const { locale, messages, languageLocale} = this.props.language;
     const mappedLocale = {
       'en': enUS,
       'zh-cn': zhCN,
@@ -65,7 +68,7 @@ export class LanguageProvider extends React.PureComponent { // eslint-disable-li
     const file = mappedLocale[jLocale];
     return (
       <ConfigProvider locale={file}>
-        <IntlProvider locale={locale} key={locale} messages={messages}>
+        <IntlProvider locale={languageLocale} key={locale} messages={messages}>
           {React.Children.only(this.props.children)}
         </IntlProvider>
       </ConfigProvider>
@@ -92,4 +95,13 @@ function mapDispatchToProps(dispatch) {
   };
 }
 
-export default connect(mapStateToProps, mapDispatchToProps)(LanguageProvider);
+const withSaga = injectSaga({ key: 'language', saga: LanguageProviderRootSaga });
+const withReducer = injectReducer({ key: 'language', reducer });
+
+const withConnect = connect(mapStateToProps, mapDispatchToProps);
+
+export default compose(
+  withSaga,
+  withReducer,
+  withConnect,
+)(LanguageProvider);

package/v2Containers/LanguageProvider/reducer.js

@@ -10,6 +10,7 @@ import * as types from './constants';
 
 const initialState = fromJS({
   locale: types.DEFAULT_LOCALE,
+  languageLocale: types.DEFAULT_LOCALE,
   messages: {},
   localeLoading: false,
 });
@@ -18,11 +19,11 @@ function languageProviderReducer(state = initialState, action) {
   switch (action.type) {
     case types.GET_LOCIZ_MESSAGE_REQUEST:
       return state
-        .set('localeLoading', true)
-        .set('locale', action.locale);
+        .set('localeLoading', true);
     case types.GET_LOCIZ_MESSAGE_SUCCESS:
       return state
         .set('localeLoading', false)
+        .set('languageLocale', action.locale)
         .set('messages', fromJS(action.data));
     case types.GET_LOCIZ_MESSAGE_FAILURE:
       return state.set('localeLoading', false);

package/v2Containers/LanguageProvider/sagas.js

@@ -1,17 +1,16 @@
 import { takeLatest, take, all, cancel, call, put } from 'redux-saga/effects';
-import { LOCATION_CHANGE } from 'react-router-redux';
 import * as Api from '../../services/api';
 import * as types from './constants';
 
 function* getLocizMessage(action) {
   try {
     const result = yield call(Api.getLocizMessage, action.locale);
-    yield [
-      put({
-        type: types.GET_LOCIZ_MESSAGE_SUCCESS,
-        data: result,
-      }),
-    ];
+    yield put({
+      type: types.GET_LOCIZ_MESSAGE_SUCCESS,
+      data: result,
+      locale: action.locale,
+    });
+
   } catch (error) {
     yield [
       put({
@@ -22,7 +21,7 @@ function* getLocizMessage(action) {
   }
 }
 export function* watchGetLocizMessage() {
-  const watcher = yield takeLatest(
+  yield takeLatest(
     types.GET_LOCIZ_MESSAGE_REQUEST,
     getLocizMessage,
   );

package/v2Containers/LanguageProvider/selectors.js

@@ -14,7 +14,8 @@ const makeSelectLocale = () => createSelector(
   (languageState) => languageState.toJS()
 );
 
+
 export {
   selectLanguage,
-  makeSelectLocale,
+  makeSelectLocale
 };