@capillarytech/creatives-library 0.0.1

package/containers/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.campaignsDashboard',
+    defaultMessage: "Campaigns Home",
+  },
+});

package/containers/Cap/reducer.js

@@ -0,0 +1,98 @@
+/**
+ * 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), 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,
+        });
+    }
+    default:
+      return state;
+  }
+}
+
+export default capReducer;

package/containers/Cap/sagas.js

@@ -0,0 +1,130 @@
+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});
+    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: result.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,
+];

package/containers/Cap/selectors.js

@@ -0,0 +1,53 @@
+// makeSelectLocationState expects a plain JS object for the routing state
+import { createSelector } from 'reselect';
+const selectCapDomain = (state) => state.get('cap');
+
+const makeSelectAuthenticated = () => createSelector(
+  selectCapDomain,
+  (globalState) => globalState.toJS()
+);
+
+const makeSelectMessage = () => createSelector(
+  selectCapDomain,
+  (globalState) => globalState.get('messages').toJS()
+);
+
+const makeSelectMetaEntities = () => createSelector(
+  selectCapDomain,
+  (globalState) => globalState.get('metaEntities')
+);
+
+const makeSelectLocationState = () => {
+  let prevRoutingState;
+  let prevRoutingStateJS;
+
+  return (state) => {
+    const routingState = state.get('route'); // or state.route
+
+    if (!routingState.equals(prevRoutingState)) {
+      prevRoutingState = routingState;
+      prevRoutingStateJS = routingState.toJS();
+    }
+
+    return prevRoutingStateJS;
+  };
+};
+
+const makeSelectOrgId = () => createSelector(
+  selectCapDomain,
+  (globalState) => globalState.get('orgID')
+);
+
+const makeSelectUser = () => createSelector(
+  selectCapDomain,
+  (globalState) => globalState.get('user')
+);
+
+export {
+  makeSelectLocationState,
+  makeSelectAuthenticated,
+  makeSelectMessage,
+  makeSelectOrgId,
+  makeSelectMetaEntities,
+  makeSelectUser,
+};

package/containers/Cap/tests/index.test.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import { shallow } from 'enzyme';
+
+import Cap from '../index';
+
+describe('<Cap />', () => {
+  it('should render its children', () => {
+    const children = (<h1>Test</h1>);
+    const renderedComponent = shallow(
+      <Cap>
+        {children}
+      </Cap>
+    );
+    expect(renderedComponent.contains(children)).toBe(true);
+  });
+});

package/containers/Cap/tests/selectors.test.js

@@ -0,0 +1,28 @@
+import { fromJS } from 'immutable';
+
+import { makeSelectLocationState } from 'containers/Cap/selectors';
+
+describe('makeSelectLocationState', () => {
+  it('should select the route as a plain JS object', () => {
+    const route = fromJS({
+      locationBeforeTransitions: null,
+    });
+    const mockedState = fromJS({
+      route,
+    });
+    expect(makeSelectLocationState()(mockedState)).toEqual(route.toJS());
+  });
+
+  it('should return cached js routeState for same concurrent calls', () => {
+    const route = fromJS({
+      locationBeforeTransitions: null,
+    });
+    const mockedState = fromJS({
+      route,
+    });
+    const selectLocationState = makeSelectLocationState();
+
+    const firstRouteStateJS = selectLocationState(mockedState);
+    expect(selectLocationState(mockedState)).toBe(firstRouteStateJS);
+  });
+});

package/containers/Dashboard/actions.js

@@ -0,0 +1,15 @@
+/*
+ *
+ * Dashboard actions
+ *
+ */
+
+import {
+  DEFAULT_ACTION,
+} from './constants';
+
+export function defaultAction() {
+  return {
+    type: DEFAULT_ACTION,
+  };
+}

package/containers/Dashboard/constants.js

@@ -0,0 +1,7 @@
+/*
+ *
+ * Dashboard constants
+ *
+ */
+
+export const DEFAULT_ACTION = 'app/Dashboard/DEFAULT_ACTION';

package/containers/Dashboard/index.js

@@ -0,0 +1,53 @@
+import React, { PropTypes } from 'react';
+import { connect } from 'react-redux';
+import Helmet from 'react-helmet';
+import { bindActionCreators } from 'redux';
+import { FormattedMessage } from 'react-intl';
+import { createStructuredSelector } from 'reselect';
+import makeSelectDashboard from './selectors';
+import messages from './messages';
+import { UserIsAuthenticated } from '../../utils/authWrapper';
+import * as actions from './actions';
+import PageHeader from '../../components/PageHeader';
+import BreadCrumbs from '../../components/BreadCrumbs/index';
+export class Dashboard extends React.Component { // eslint-disable-line react/prefer-stateless-function
+  render() {
+    const breadCrumbLocations = [
+      {
+        text: <FormattedMessage {...messages.header} />,
+        url: '',
+        disabled: true,
+      },
+    ];
+    return (
+      <div>
+        <FormattedMessage {...messages.header}>{(message) => (<Helmet
+          title={message}
+          meta={[
+            { name: 'description', content: 'Dashboard' },
+          ]}
+        />)}
+        </FormattedMessage>
+        <BreadCrumbs locations={breadCrumbLocations} />
+        <PageHeader pageHeading={<FormattedMessage {...messages.header} />} />
+      </div>
+    );
+  }
+}
+
+Dashboard.propTypes = {
+  actions: PropTypes.object,
+};
+
+const mapStateToProps = createStructuredSelector({
+  Dashboard: makeSelectDashboard(),
+});
+
+
+function mapDispatchToProps(dispatch) {
+  return {
+    actions: bindActionCreators(actions, dispatch),
+  };
+}
+
+export default UserIsAuthenticated(connect(mapStateToProps, mapDispatchToProps)(Dashboard));

package/containers/Dashboard/messages.js

@@ -0,0 +1,13 @@
+/*
+ * Dashboard Messages
+ *
+ * This contains all the text for the Dashboard component.
+ */
+import { defineMessages } from 'react-intl';
+
+export default defineMessages({
+  header: {
+    id: 'app.containers.Dashboard.header',
+    defaultMessage: 'Dashboard',
+  },
+});

package/containers/Dashboard/reducer.js

@@ -0,0 +1,21 @@
+/*
+ *
+ * Dashboard reducer
+ *
+ */
+
+import { fromJS } from 'immutable';
+import { DEFAULT_ACTION } from './constants';
+
+const initialState = fromJS({});
+
+function dashboardReducer(state = initialState, action) {
+  switch (action.type) {
+    case DEFAULT_ACTION:
+      return state;
+    default:
+      return state;
+  }
+}
+
+export default dashboardReducer;

package/containers/Dashboard/sagas.js

@@ -0,0 +1,11 @@
+// import { take, call, put, select } from 'redux-saga/effects';
+
+// Individual exports for testing
+export function* defaultSaga() {
+  // See example in containers/HomePage/sagas.js
+}
+
+// All sagas to be loaded
+export default [
+  defaultSaga,
+];

package/containers/Dashboard/selectors.js

@@ -0,0 +1,25 @@
+import { createSelector } from 'reselect';
+
+/**
+ * Direct selector to the dashboard state domain
+ */
+const selectDashboardDomain = () => (state) => state.get('cap');
+
+/**
+ * Other specific selectors
+ */
+
+
+/**
+ * Default selector used by Dashboard
+ */
+
+const makeSelectDashboard = () => createSelector(
+  selectDashboardDomain(),
+  (substate) => substate.toJS()
+);
+
+export default makeSelectDashboard;
+export {
+  selectDashboardDomain,
+};

package/containers/Dashboard/tests/actions.test.js

@@ -0,0 +1,18 @@
+
+import {
+  defaultAction,
+} from '../actions';
+import {
+  DEFAULT_ACTION,
+} from '../constants';
+
+describe('Dashboard actions', () => {
+  describe('Default Action', () => {
+    it('has a type of DEFAULT_ACTION', () => {
+      const expected = {
+        type: DEFAULT_ACTION,
+      };
+      expect(defaultAction()).toEqual(expected);
+    });
+  });
+});

package/containers/Dashboard/tests/index.test.js

@@ -0,0 +1,10 @@
+// import React from 'react';
+// import { shallow } from 'enzyme';
+
+// import { Dashboard } from '../index';
+
+describe('<Dashboard />', () => {
+  it('Expect to have unit tests specified', () => {
+    expect(true).toEqual(false);
+  });
+});

package/containers/Dashboard/tests/reducer.test.js

@@ -0,0 +1,9 @@
+
+import { fromJS } from 'immutable';
+import dashboardReducer from '../reducer';
+
+describe('dashboardReducer', () => {
+  it('returns the initial state', () => {
+    expect(dashboardReducer(undefined, {})).toEqual(fromJS({}));
+  });
+});

package/containers/Dashboard/tests/sagas.test.js

@@ -0,0 +1,15 @@
+/**
+ * Test  sagas
+ */
+
+/* eslint-disable redux-saga/yield-effects */
+// import { take, call, put, select } from 'redux-saga/effects';
+// import { defaultSaga } from '../sagas';
+
+// const generator = defaultSaga();
+
+describe('defaultSaga Saga', () => {
+  it('Expect to have unit tests specified', () => {
+    expect(true).toEqual(false);
+  });
+});

package/containers/Dashboard/tests/selectors.test.js

@@ -0,0 +1,10 @@
+// import { fromJS } from 'immutable';
+// import { makeSelectDashboardDomain } from '../selectors';
+
+// const selector = makeSelectDashboardDomain();
+
+describe('makeSelectDashboardDomain', () => {
+  it('Expect to have unit tests specified', () => {
+    expect(true).toEqual(false);
+  });
+});

package/containers/Ebill/actions.js

@@ -0,0 +1,43 @@
+/*
+ *
+ * Ebill actions
+ *
+ */
+
+import * as types from './constants';
+
+export function createTemplate(template) {
+  return {
+    type: types.CREATE_TEMPLATE_REQUEST,
+    template,
+  };
+}
+
+export function getTemplateDetails(id, channel) {
+  console.log('getting template', id, channel);
+  return {
+    type: types.GET_TEMPLATE_DETAILS_REQUEST,
+    id,
+    channel,
+  };
+}
+
+export function getCmsData(cmsType, projectId) {
+  return {
+    type: types.GET_CMS_EDITOR_DATA_REQUEST,
+    cmsType,
+    projectId,
+  };
+}
+
+export function clearCRUDResponse() {
+  return {
+    type: types.CLEAR_EBILL_CRUD_RESPONSE_REQUEST,
+  };
+}
+
+export function clearStoreValues() {
+  return {
+    type: types.CLEAR_ALL_VALUES,
+  };
+}

package/containers/Ebill/constants.js

@@ -0,0 +1,20 @@
+/*
+ *
+ * Ebill constants
+ *
+ */
+
+export const CREATE_TEMPLATE_REQUEST = 'app/containers/Ebill/CREATE_TEMPLATE_REQUEST';
+export const CREATE_TEMPLATE_SUCCESS = 'app/containers/Ebill/CREATE_TEMPLATE_SUCCESS';
+export const CREATE_TEMPLATE_FAILURE = 'app/containers/Ebill/CREATE_TEMPLATE_FAILURE';
+
+export const GET_TEMPLATE_DETAILS_REQUEST = 'app/containers/Ebill/GET_TEMPLATE_DETAILS_REQUEST';
+export const GET_TEMPLATE_DETAILS_SUCCESS = 'app/containers/Ebill/GET_TEMPLATE_DETAILS_SUCCESS';
+export const GET_TEMPLATE_DETAILS_FAILURE = 'app/containers/Ebill/GET_TEMPLATE_DETAILS_FAILURE';
+
+export const GET_CMS_EDITOR_DATA_REQUEST = 'app/containers/Ebill/GET_CMS_EDITOR_DATA_REQUEST';
+export const GET_CMS_EDITOR_DATA_SUCCESS = 'app/containers/Ebill/GET_CMS_EDITOR_DATA_SUCCESS';
+export const GET_CMS_EDITOR_DATA_FAILURE = 'app/containers/Ebill/GET_CMS_EDITOR_DATA_FAILURE';
+
+export const CLEAR_EBILL_CRUD_RESPONSE_REQUEST = 'app/containers/Ebill/CLEAR_EBILL_CRUD_RESPONSE_REQUEST';
+export const CLEAR_ALL_VALUES = "app/containers/Ebill/CLEAR_ALL_VALUES";