@capillarytech/creatives-library 2.0.70 → 2.0.72

package/v2Containers/Cap/constants.js

@@ -0,0 +1,24 @@
+export const DEFAULT_LOCALE = 'en';
+export const SWITCH_ORG_REQUEST = 'cap/SWITCH_ORG_REQUEST';
+export const SWITCH_ORG_SUCCESS = 'cap/SWITCH_ORG_SUCCESS';
+export const SWITCH_ORG_FAILURE = 'cap/SWITCH_ORG_FAILURE';
+export const LOGIN_REQUEST = 'cap/LOGIN_REQUEST';
+export const LOGIN_SUCCESS = 'cap/LOGIN_SUCCESS';
+export const LOGIN_FAILURE = 'cap/LOGIN_FAILURE';
+
+export const LOGOUT_REQUEST = 'cap/LOGOUT_REQUEST';
+export const LOGOUT_SUCCESS = 'cap/LOGOUT_SUCCESS';
+export const LOGOUT_FAILURE = 'cap/LOGOUT_FAILURE';
+export const ADD_MESSAGE = 'cap/ADD_MESSAGE';
+export const REMOVE_MESSAGE = 'cap/REMOVE_MESSAGE';
+export const GET_USER_DATA_REQUEST = 'cap/GET_USER_DATA_REQUEST';
+export const GET_USER_DATA_SUCCESS = 'cap/GET_USER_DATA_SUCCESS';
+export const GET_USER_DATA_FAILURE = 'cap/GET_USER_DATA_FAILURE';
+
+export const GET_SCHEMA_FOR_ENTITY_FAILURE = 'cap/GET_SCHEMA_FOR_ENTITY_FAILURE';
+export const GET_SCHEMA_FOR_ENTITY_REQUEST = 'cap/GET_SCHEMA_FOR_ENTITY_REQUEST';
+export const GET_SCHEMA_FOR_ENTITY_SUCCESS = 'cap/GET_SCHEMA_FOR_ENTITY_SUCCESS';
+export const CLEAR_META_ENTITIES = 'cap/CLEAR_META_ENTITIES';
+export const HIDE_TAGS = 'cap/HIDE_TAGS';
+
+export const SET_INJECTED_TAGS = 'cap/SET_INJECTED_TAGS';

package/v2Containers/Cap/index.js

@@ -0,0 +1,349 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import Helmet from 'react-helmet';
+import { connect } from 'react-redux';
+// import { Link } from 'react-router';
+// import { Icon } from 'semantic-ui-react';
+import { bindActionCreators } from 'redux';
+import styled from 'styled-components';
+import { createStructuredSelector } from 'reselect';
+import _ from 'lodash';
+import moment from 'moment';
+import 'moment/locale/zh-cn';
+import { injectIntl, intlShape } from 'react-intl';
+import {CapNotification} from '@capillarytech/cap-ui-library';
+import TopBar from '../../components/TopBar';
+// import 'moment/locale/en-us';
+import Sidebar from '../../components/Sidebar';
+import { makeSelectAuthenticated, makeSelectUser } from './selectors';
+import * as actions from './actions';
+import * as locationActions from '../LanguageProvider/actions';
+import * as appActions from '../App/actions';
+import config from '../../config/app';
+import messages from './messsages';
+const gtm = window.dataLayer || [];
+
+const CapWrapper = styled.div`
+  margin: 0 auto;
+  display: flex;
+  min-height: 100%;
+  padding: 0;
+  flex-direction: column;
+`;
+
+export class Cap extends React.Component { // eslint-disable-line react/prefer-stateless-function
+
+  constructor(props) {
+    super(props);
+    this.state = {
+      menuData: [],
+      switchedOrg: false,
+    };
+    this.changeOrg = this.changeOrg.bind(this);
+    this.logout = this.logout.bind(this);
+    this.handleRemoveMessage = this.handleRemoveMessage.bind(this);
+    this.getMappedLocale = this.getMappedLocale.bind(this);
+  }
+
+  componentWillMount() {
+    this.props.actions.getUserData();
+    if (this.props.Global.user) {
+      const userGtmData = this.getUserGtmData(this.props);
+      gtm.push(userGtmData);
+    }
+    if (this.props.Global.orgID !== undefined) {
+      gtm.push({orgId: this.props.Global.orgID});
+    }
+    if (this.props.Global.isLoggedIn) {
+      if (this.props.Global.user && Object.keys(this.props.Global.user).length) {
+        // gtm.push({userId: this.props.Global.user.id});
+        this.props.appActions.getSidebar();
+      }
+    }
+  }
+
+  componentDidMount() {
+    const user = localStorage.getItem('user');
+    let locale = 'en';
+    if (user) {
+      locale = JSON.parse(user).lang;
+    }
+    locale = this.getMappedLocale(locale);
+    //locale = 'zh';
+    console.log('Setting final locale as', locale);
+    moment.locale(locale);
+    this.props.locationActions.changeLocale(locale);
+  }
+
+  componentWillReceiveProps(nextProps) {
+    const user = this.props.Global.user;
+    const nextPropsUser = nextProps.Global.user;
+    if (!nextProps.Global.settingProxyOrg && nextProps.Global.changeProxyOrgSuccess &&
+      !_.isEqual(nextProps.Global.changeProxyOrgSuccess, this.props.Global.changeProxyOrgSuccess) && !this.state.switchedOrg) {
+      this.navigateToDashboard();
+    }
+
+    const callBack = nextProps.routeParams.callbackUrl ? decodeURIComponent(nextProps.routeParams.callbackUrl) : "";
+    if (nextProps.Global.error) {
+      const locationValue = `${window.location.origin}${callBack}?flash=${nextProps.Global.error}`;
+      window.location.replace(locationValue);
+      window.location.reload();
+    }
+
+    if (nextPropsUser && user && nextProps.Global.isLoggedIn && nextProps.Global.isLoggedIn !== this.props.Global.isLoggedIn) {
+      this.props.appActions.getSidebar();
+    }
+
+    if (nextProps.Global.user && this.props.Global.user && (nextProps.Global.user.refID !== this.props.Global.user.refID)) {
+      const userGtmData = this.getUserGtmData(nextProps);
+      gtm.push(userGtmData);
+    }
+
+    if (nextProps.Global.isLoggedIn && nextProps.Global.isLoggedIn !== this.props.Global.isLoggedIn) {
+      if (nextProps.Global.orgID !== undefined && !_.isEqual(nextProps.Global.orgID, this.props.Global.orgID)) {
+        const userGtmData = this.getUserGtmData(nextProps);
+        gtm.push(userGtmData);
+      }
+    }
+  }
+
+  componentWillUnmount() {
+    this.setState({ switchedOrg: false });
+  }
+
+  // getSideBarData(reportData) {
+  //   const tmpMenuData = [];
+  //   const categoryId = reportData.categories ? Object.keys(reportData.categories) : [];
+  //   _.forEach(categoryId, (id) => {
+  //     const groupReport = {
+  //       group: reportData.categories[id].name,
+  //       items: [],
+  //     };
+  //     _.forEach(reportData.reportList, (report, reportId) => {
+  //       if (report.category === id) {
+  //         groupReport.items.push({
+  //           link: `/report/${reportId}`,
+  //           text: report.name,
+  //         });
+  //       }
+  //     });
+  //     tmpMenuData.push(groupReport);
+  //   });
+  //   const menuLibrary = {
+  //     group: 'Library',
+  //     items: [
+  //       {
+  //         link: '/library/charts',
+  //         text: 'Charts',
+  //       },
+  //       {
+  //         link: '/library/dimension',
+  //         text: 'Dimensions',
+  //       },
+  //     ],
+  //   };
+  //   tmpMenuData.push(menuLibrary);
+  //   this.setState({ menuData: tmpMenuData });
+  // }
+
+  getUserGtmData = (props) => {
+    const { user: userData } = props.Global;
+    const userName = userData.attributes.USERNAME;
+    const userEmail = userData.attributes.EMAIL;
+    const orgObj = find(userData.proxyOrgList, {orgID: props.Global.orgID});
+    const gtmData = {
+      orgId: props.Global.orgID,
+      orgName: orgObj && orgObj.orgName,
+      userId: userData.refID,
+      userName: userName && userName.value,
+      userEmail: userEmail && userEmail.value,
+      isCapUser: userData.isCapUser,
+    };
+    return gtmData;
+  }
+
+  getMappedLocale(locale) {
+    const map = {
+      'en': 'en',
+      'zh-cn': 'zh',
+    };
+    return map[locale];
+  }
+  handleRemoveMessage(messageIndex) {
+    this.props.actions.removeMessageFromQueue(messageIndex);
+  }
+
+  navigateToDashboard() {
+    const dashboardUrl = process.env.NODE_ENV === 'production' ? config.production.dashboard_url : config.development.dashboard_url;
+    this.props.router.push({ pathname: dashboardUrl, state: {} });
+    this.props.router.go(dashboardUrl);
+  }
+
+  logout() {
+    this.props.actions.logout();
+  }
+  changeOrg(orgId) {
+    this.props.actions.changeOrg(orgId);
+    //this.navigateToDashboard();
+  }
+
+  render() {
+    const userData = this.props.Global;
+    const type = this.props.location.query.type;
+    // const changeOrg = this.props.actions.changeOrg;
+    // const logout = this.props.actions.logout;
+    console.log('props', this.props);
+    const proxyOrgList = [];
+    let defaultOrgName = '';
+    let defaultOrgId = '';
+    let userName = '';
+    const navigateToDashboard = this.navigateToDashboard;
+    if (userData && userData.user && userData.user !== '') {
+      console.log('Org name ', userData.user.orgName, userData.user.orgID);
+      defaultOrgName = userData.user.orgName;
+      defaultOrgId = userData.user.orgID;
+      proxyOrgList.push({ text: defaultOrgName, value: defaultOrgId });
+      const orgList = userData.user.proxyOrgList;
+      if (!_.isEmpty(orgList)) {
+        _.forEach(orgList, (item) => {
+          const id = item.orgID;
+          let name = item.orgName;
+          if (id === 486) {
+            name = 'Demo Org';
+          }
+          proxyOrgList.push({ key: id, text: name, value: id });
+        });
+      }
+      userName = userData.user.firstName;
+    }
+    const actionComponents = "";
+    const toastMessages = this.props.Global.messages;
+    const loggedIn = this.props.Global.isLoggedIn;
+    const menuData = [
+      {
+        group: this.props.intl.formatMessage(messages.creativesDashboard),
+        items: [
+          {
+            link: '/sms',
+            text: this.props.intl.formatMessage(messages.sms),
+            value: 'SMS',
+          },
+          {
+            link: '/wechat',
+            text: this.props.intl.formatMessage(messages.wechat),
+            value: 'WECHAT',
+          },
+          {
+            link: '/mobilepush',
+            text: 'Mobile Push',
+            value: 'MOBILEPUSH',
+          },
+          {
+            link: '/assets',
+            text: this.props.intl.formatMessage(messages.gallery),
+            value: 'GALLERY',
+          },
+          {
+            link: '/email',
+            text: this.props.intl.formatMessage(messages.email),
+            value: 'EMAIL',
+          },
+          {
+            link: '/ebill',
+            text: this.props.intl.formatMessage(messages.ebill),
+            value: 'EBILL',
+          },
+          {
+            link: '/line',
+            text: 'Line',
+            value: 'LINE',
+          },
+        ],
+      },
+      {
+        group: this.props.intl.formatMessage(messages.campaignsDashboard),
+        items: [
+          {
+            link: '/campaign/index',
+            text: this.props.intl.formatMessage(messages.campaignsHome),
+            value: 'Campaigns Home',
+            external: true,
+          },
+        ],
+      },
+    ];
+    return (
+      <CapWrapper>
+        <Helmet
+          titleTemplate="Capillary - %s"
+          defaultTitle="App Name"
+          meta={[
+            { name: 'description', content: 'App Name' },
+          ]}
+        />
+        <div className="wrapper">
+          {loggedIn && type !== 'embedded' ?
+            <TopBar
+              proxyOrgList={proxyOrgList}
+              userName={userName}
+              orgName={defaultOrgName}
+              orgID={defaultOrgId}
+              changeOrg={this.changeOrg}
+              navigateToDashboard={navigateToDashboard}
+              logout={this.logout}
+            /> : ''}
+          <div className="main">
+            {loggedIn && type !== 'embedded' && this.props.location.pathname.indexOf('v2') === -1 ? <div id="cap-sidebar" className={'sidebar'}>
+              <Sidebar
+                menuData={menuData}
+                actionComponents={actionComponents}
+                router={this.props.router}
+              />
+            </div> : '' }
+            <div className="main-content">
+              {React.Children.toArray(this.props.children)}
+            </div>
+          </div>
+        </div>
+        {(toastMessages && toastMessages.length > 0) &&
+          toastMessages.map((message) => CapNotification[message.type]({message: message.text, key: message.text, duration: message.duration || 5})
+          )
+        }
+        {this.props.Global.fetching_userdata &&
+          <div className="cap-loader-box">
+            <img
+              className="loader-image"
+              src="https://s3.amazonaws.com/fileservice.in/intouch_creative_assets/88561f46de9407021cad.gif"
+              alt="Capillary"/>
+          </div>
+        }
+      </CapWrapper>
+    );
+  }
+}
+
+Cap.propTypes = {
+  children: PropTypes.node,
+  actions: PropTypes.object.isRequired,
+  Global: PropTypes.object,
+  router: PropTypes.object,
+  appActions: PropTypes.object,
+  locationActions: PropTypes.object,
+  location: PropTypes.object,
+  intl: intlShape.isRequired,
+};
+
+const mapStateToProps = createStructuredSelector({
+  Global: makeSelectAuthenticated(),
+  User: makeSelectUser(),
+});
+
+function mapDispatchToProps(dispatch) {
+  return {
+    actions: bindActionCreators(actions, dispatch),
+    appActions: bindActionCreators(appActions, dispatch),
+    locationActions: bindActionCreators(locationActions, dispatch),
+  };
+}
+
+export default connect(mapStateToProps, mapDispatchToProps)(injectIntl(Cap));

package/v2Containers/Cap/messsages.js

@@ -0,0 +1,63 @@
+import { defineMessages } from 'react-intl';
+export default defineMessages({
+  "sms": {
+    id: 'reon.components.Cap.sms',
+    defaultMessage: 'SMS',
+  },
+  "wechat": {
+    id: 'reon.components.Cap.wechat',
+    defaultMessage: 'WeChat',
+  },
+  "gallery": {
+    id: 'reon.components.Cap.gallery',
+    defaultMessage: 'Gallery',
+  },
+  "creativesDashboard": {
+    id: 'reon.components.Cap.creativesDashboard',
+    defaultMessage: 'Creatives',
+  },
+  "creatives": {
+    id: 'reon.components.Cap.creatives',
+    defaultMessage: 'Creatives',
+  },
+  "campaigns": {
+    id: 'reon.components.Cap.campaigns',
+    defaultMessage: 'Campaigns',
+  },
+  "loyalty": {
+    id: 'reon.components.Cap.loyalty',
+    defaultMessage: 'Loyalty',
+  },
+  "member care": {
+    id: 'reon.components.Cap.memberCare',
+    defaultMessage: 'Member Care',
+  },
+  "workbench": {
+    id: 'reon.components.Cap.Workbench',
+    defaultMessage: 'WorkBench',
+  },
+  "store care": {
+    id: 'reon.components.Cap.storeCare',
+    defaultMessage: 'Store Care',
+  },
+  "store performance": {
+    id: 'reon.components.Cap.storePerformance',
+    defaultMessage: 'Store Performance',
+  },
+  "email": {
+    id: 'reon.components.Cap.email',
+    defaultMessage: 'Email',
+  },
+  "ebill": {
+    id: 'reon.components.Cap.ebill',
+    defaultMessage: 'Ebill',
+  },
+  "campaignsDashboard": {
+    id: 'reon.components.campaignsDashboard',
+    defaultMessage: 'Campaigns',
+  },
+  "campaignsHome": {
+    id: 'reon.components.campaignsHome',
+    defaultMessage: "Campaigns Home",
+  },
+});

package/v2Containers/Cap/reducer.js

@@ -0,0 +1,111 @@
+/**
+ * Created by vivek on 22/5/17.
+ */
+import { fromJS } from 'immutable';
+import _ from 'lodash';
+import * as types from './constants';
+import initialState from '../../initialState';
+
+function capReducer(state = fromJS(initialState.cap), action) {
+  switch (action.type) {
+    case types.LOGIN_REQUEST:
+      return state.set('login_progress', true);
+    case types.LOGIN_SUCCESS:
+      return state
+        .set('login_progress', false)
+        .set('token', action.res.token)
+        .set('user', fromJS(action.res.user))
+        .set('message', '')
+        .set('authenticated', true)
+        .set('isLoggedIn', true);
+    case types.LOGIN_FAILURE:
+      return state
+        .set('login_progress', false)
+        .set('message', action.error.message);
+    case types.LOGOUT_REQUEST:
+      return state.set('login_progress', false);
+    case types.LOGOUT_SUCCESS:
+      return state;
+    case types.LOGOUT_FAILURE:
+      return state;
+    case types.SWITCH_ORG_REQUEST:
+      return state
+        .set('settingProxyOrg', true)
+        .set('changeProxyOrgSuccess', false);
+    case types.SWITCH_ORG_SUCCESS:
+      return state
+        .set('orgID', action.orgID)
+        .set('settingProxyOrg', false)
+        .set('changeProxyOrgSuccess', action.isSuccess);
+    case types.SWITCH_ORG_FAILURE:
+      return state
+        .set('settingProxyOrg', false)
+        .set('changeProxyOrgSuccess', false);
+    case types.ADD_MESSAGE: {
+      const message = {
+        messageId: action.message.id,
+        title: action.message.title,
+        text: action.message.text,
+        type: action.message.type,
+        hideProgressBar: action.message.hideProgressBar,
+      };
+      return state
+      .set('messages', fromJS(state.get('messages').concat(message)));
+    }
+    case types.REMOVE_MESSAGE: {
+      const messageQueue = state.get('messages').toJS();
+      const messageIndex = _.findIndex(messageQueue, { messageId: action.messageIndex });
+      messageQueue.splice(messageIndex, 1);
+      return state
+      .set('messages', fromJS(messageQueue));
+    }
+    case types.GET_USER_DATA_REQUEST:
+      return state
+        .set('fetching_userdata', true)
+        .set('isLoggedIn', false);
+    case types.GET_USER_DATA_SUCCESS:
+      return state
+        .set('fetching_userdata', false)
+        .set('user', fromJS(action.userData))
+        .set('currentOrgDetails', fromJS(action.currentOrgDetails))
+        .set('isLoggedIn', true)
+        .set('orgID', action.currentOrgId);
+    case types.GET_USER_DATA_FAILURE:
+      return state
+        .set('fetching_userdata', false)
+        .set('isLoggedIn', false);
+    case types.GET_SCHEMA_FOR_ENTITY_REQUEST:
+      return state
+        .set('fetchingSchema', true);
+    case types.GET_SCHEMA_FOR_ENTITY_FAILURE:
+      return state
+        .set('fetchingSchema', false);
+    case types.GET_SCHEMA_FOR_ENTITY_SUCCESS: {
+      const stateMeta = state.get('metaEntities');
+      console.log('stateMeta', stateMeta);
+      return state
+        .set('fetchingSchema', false)
+        .set('metaEntities', {
+          layouts: action.data && action.entityType === 'LAYOUT' ? action.data.metaEntities : stateMeta.layouts,
+          tags: action.data && action.entityType === 'TAG' ? action.data.metaEntities : stateMeta.tags,
+        });
+    }
+    case types.CLEAR_META_ENTITIES:
+      return state.set('metaEntities', {
+        layouts: [],
+        tags: [],
+      });
+    // eslint-disable-next-line no-case-declarations
+    case types.HIDE_TAGS:
+      const metaEntities = {tags: {}, layouts: state.get('metaEntities').layouts};
+      metaEntities.tags.standard = _.filter(state.get('metaEntities').tags.standard, (tag) => action.tagList.indexOf(tag.definition.value) === -1);
+      metaEntities.tags.custom = _.filter(state.get('metaEntities').tags.custom, (tag) => action.tagList.indexOf(tag.name) === -1);
+      return state.setIn(['metaEntities'], metaEntities);
+    case types.SET_INJECTED_TAGS:
+      return state.set('injectedTags', action.injectedTags);
+    default:
+      return state;
+  }
+}
+
+export default capReducer;

package/v2Containers/Cap/sagas.js

@@ -0,0 +1,143 @@
+import { fork, take, call, put, cancelled, cancel, takeLatest } from 'redux-saga/effects';
+import { LOCATION_CHANGE } from 'react-router-redux';
+// import { normalize } from 'normalizr';
+import * as Api from '../../services/api';
+import * as LocalStorage from '../../services/localStorageApi';
+import * as types from './constants';
+import config from '../../config/app';
+import pathConfig from '../../config/path';
+// import {makeSelectOrgId} from './selectors';
+
+function* authorize(user) {
+  try {
+    const res = yield call(Api.authorize, user);
+    yield call(LocalStorage.saveItem, 'token', res.token);
+    yield call(LocalStorage.saveItem, 'orgID', res.user.orgID);
+    yield call(LocalStorage.saveItem, 'user', res.user);
+    // yield call(LocalStorage.saveItem, 'isLoggedIn', true);
+    yield put({ type: types.LOGIN_SUCCESS, res });
+  } catch (error) {
+    yield put({ type: types.LOGIN_FAILURE, error });
+  } finally {
+    if (yield cancelled()) {
+      // reducer will clear out login_progress on logout request
+      // So this block is not exactly required
+    }
+  }
+}
+
+function* switchOrg({orgID}) {
+  try {
+    LocalStorage.saveItem('orgID', orgID);
+    const res = yield call(Api.changeProxyOrg, orgID);
+    yield [put({ type: types.SWITCH_ORG_SUCCESS, orgID, isSuccess: res.success })];
+  } catch (error) {
+    yield put({ type: types.SWITCH_ORG_FAILURE, error });
+  }
+}
+
+function* loginFlow() {
+  const condition = true;
+  while (condition) {
+    const { user } = yield take(types.LOGIN_REQUEST);
+    const task = yield fork(authorize, user);
+    const action = yield take([types.LOGOUT_REQUEST, types.LOGIN_FAILURE]);
+    if (action.type === types.LOGOUT_REQUEST) {
+      yield cancel(task);
+    }
+    // yield call(LocalStorage.clearItem, 'token');
+    // yield call(LocalStorage.clearItem, 'orgID');
+    // yield call(LocalStorage.clearItem, 'user');
+  }
+}
+
+function* logoutFlow() {
+  try {
+    const serverLogout = yield call(Api.logout);
+    if (serverLogout.success && serverLogout.success === true) {
+      const loginUrl = (process.env.NODE_ENV === 'production') ?
+        `${pathConfig.publicPath}${config.production.login_url}` : `${pathConfig.publicPath}${config.development.login_url}`;
+      yield [put({type: types.LOGOUT_SUCCESS})];
+      yield call(LocalStorage.clearItem, 'token');
+      yield call(LocalStorage.clearItem, 'orgID');
+      yield call(LocalStorage.clearItem, 'user');
+      yield call(LocalStorage.clearItem, 'isLoggedIn');
+      window.location.href = loginUrl;
+    }
+  } catch (error) {
+    yield put({ type: types.LOGOUT_FAILURE, error });
+  }
+}
+
+export function* fetchUserInfo() {
+  try {
+    const result = yield call(Api.getUserData);
+    const userData = result.user;
+    // const orgId = yield select(makeSelectOrgId());
+    // yield put({type: types.GET_ORG_DETAILS_REQUEST, orgId});
+    const currentOrgDetails = result.currentOrgDetails;
+    if (!(currentOrgDetails && currentOrgDetails.basic_details && currentOrgDetails.basic_details.base_language && (currentOrgDetails.basic_details.base_language !== "" || currentOrgDetails.basic_details.base_language === null))) {
+      currentOrgDetails.basic_details.base_language = 'en';
+    }
+    if (!(currentOrgDetails && currentOrgDetails.basic_details && currentOrgDetails.basic_details.supported_languages && currentOrgDetails.basic_details.supported_languages.length > 0)) {
+      currentOrgDetails.basic_details.supported_languages = [
+        {
+          lang_id: 69,
+          language: "English",
+          iso_code: "en",
+        },
+      ];
+    }
+    yield call(LocalStorage.saveItem, 'orgID', result.currentOrgId);
+    yield call(LocalStorage.saveItem, 'user', userData);
+    yield put({type: types.GET_USER_DATA_SUCCESS, userData, currentOrgId: result.currentOrgId, currentOrgDetails});
+  } catch (error) {
+    yield call(LocalStorage.clearItem, 'user');
+    yield put({
+      type: types.GET_USER_DATA_FAILURE,
+      error,
+    });
+  }
+}
+
+export function* fetchSchemaForEntity(queryParams) {
+  try {
+    console.log('saga fetch Schema For Entity', queryParams);
+    const result = yield call(Api.fetchSchemaForEntity, queryParams);
+    console.log('cap saga', result);
+    // const sidebar = result.response.sidebar;
+    yield put({ type: types.GET_SCHEMA_FOR_ENTITY_SUCCESS, data: result.response, statusCode: result.status ? result.status.code : '', entityType: queryParams.queryParams.type });
+  } catch (error) {
+    yield put({ type: types.GET_SCHEMA_FOR_ENTITY_FAILURE, error });
+  }
+}
+
+
+function* watchFetchSchemaForEntity() {
+  console.log('inside watch get schema');
+  const watcher = yield takeLatest(types.GET_SCHEMA_FOR_ENTITY_REQUEST, fetchSchemaForEntity);
+  yield take(LOCATION_CHANGE);
+  yield cancel(watcher);
+}
+
+
+function* watchForOrgChange() {
+  yield takeLatest(types.SWITCH_ORG_REQUEST, switchOrg);
+}
+
+function* watchForLogoutFlow() {
+  yield takeLatest(types.LOGOUT_REQUEST, logoutFlow);
+}
+
+function* watchForFetchUserInfo() {
+  yield takeLatest(types.GET_USER_DATA_REQUEST, fetchUserInfo);
+}
+
+
+export default [
+  loginFlow,
+  watchForOrgChange,
+  watchForLogoutFlow,
+  watchForFetchUserInfo,
+  watchFetchSchemaForEntity,
+];