@capillarytech/creatives-library 0.0.1

package/containers/Sms/Edit/messages.js

@@ -0,0 +1,85 @@
+/*
+ * Edit Messages
+ *
+ * This contains all the text for the Edit component.
+ */
+import { defineMessages } from 'react-intl';
+
+export default defineMessages({
+  saveTemplateLoader: {
+    id: 'app.containers.Edit.saveTemplateLoader',
+    defaultMessage: 'Saving Template...',
+  },
+  getTemplateDetailsLoader: {
+    id: 'app.containers.Edit.getTemplateDetailsLoader',
+    defaultMessage: 'Getting template details...',
+  },
+  "Message": {
+    id: 'app.containers.Edit.messageLabel',
+    defaultMessage: 'Message',
+  },
+  "Template name cannot be empty.": {
+    id: 'app.containers.Edit.emptyTemplateErrorMessage',
+    defaultMessage: "Template name cannot be empty.",
+  },
+  "Enter template name": {
+    id: 'app.containers.Edit.templateNamePlaceHolder',
+    defaultMessage: "Enter template name",
+  },
+  "Discard changes": {
+    id: 'app.containers.Edit.discardChangesButton',
+    defaultMessage: "Discard changes",
+  },
+  "Cancel": {
+    id: 'app.containers.Edit.cancelButton',
+    defaultMessage: "Cancel",
+  },
+  "Save": {
+    id: 'app.containers.Edit.saveButton',
+    defaultMessage: "Save",
+  },
+  "Version": {
+    id: 'app.containers.Edit.versionLabel',
+    defaultMessage: "Version",
+  },
+  "Mark as Final": {
+    id: 'app.containers.Edit.markFinalVersionLabel',
+    defaultMessage: "Mark as Final",
+  },
+  "Duplicate": {
+    id: 'app.containers.Edit.duplicateLabel',
+    defaultMessage: "Duplicate",
+  },
+  "Rename": {
+    id: 'app.containers.Edit.renameLabel',
+    defaultMessage: "Rename",
+  },
+  "Delete": {
+    id: 'app.containers.Edit.deleteLabel',
+    defaultMessage: "Delete",
+  },
+  "Please check if you intend to use unicode characters.": {
+    id: 'app.containers.Edit.unicodeErrorMessage',
+    defaultMessage: "Please check if you intend to use unicode characters.",
+  },
+  "Allow Unicode characters": {
+    id: 'app.containers.Edit.unicodeLabel',
+    defaultMessage: "Allow Unicode characters",
+  },
+  "Tags": {
+    id: 'app.containers.Edit.tagsLabel',
+    defaultMessage: "Tags",
+  },
+  "New Version": {
+    id: 'app.containers.Edit.newVersionLabel',
+    defaultMessage: "New Version",
+  },
+  "Template content has unsupported/missing tags!": {
+    id: 'app.containers.Edit.tagsErrorMessage',
+    defaultMessage: "Template content has unsupported/missing tags!",
+  },
+  "Please input sms template content.": {
+    id: 'app.containers.Edit.smsEditorPlaceholder',
+    defaultMessage: "Please input sms template content.",
+  },
+});

package/containers/Sms/Edit/reducer.js

@@ -0,0 +1,47 @@
+/*
+ *
+ * Create reducer
+ *
+ */
+
+import { fromJS } from 'immutable';
+import * as types from './constants';
+
+const initialState = fromJS({
+  editTemplateInProgress: false,
+  editResponse: {},
+  getTemplateDetailsInProgress: false,
+  templateDetails: {},
+});
+
+function editReducer(state = initialState, action) {
+  switch (action.type) {
+    case types.DEFAULT_ACTION:
+      return state;
+    case types.EDIT_TEMPLATE_REQUEST:
+      return state
+        .set('editTemplateInProgress', true)
+        .set('editTemplateError', false);
+    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);
+    case types.GET_TEMPLATE_DETAILS_REQUEST:
+      return state.set('getTemplateDetailsInProgress', true);
+    case types.GET_TEMPLATE_DETAILS_SUCCESS:
+      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', {});
+    default:
+      return state;
+  }
+}
+
+export default editReducer;

package/containers/Sms/Edit/sagas.js

@@ -0,0 +1,47 @@
+import { call, put, takeLatest, take, cancel } from 'redux-saga/effects';
+import { LOCATION_CHANGE } from 'react-router-redux';
+// import { schema, normalize } from 'normalizr';
+import * as Api from '../../../services/api';
+import * as types from './constants';
+
+// Individual exports for testing
+export function* editTemplate(template) {
+  try {
+    console.log('saga editTemplate', template);
+    const result = yield call(Api.editTemplate, template);
+    console.log('saga editTemplate success', result);
+    // const sidebar = result.response.sidebar;
+    yield put({ type: types.EDIT_TEMPLATE_SUCCESS, data: result.response, statusCode: result.status ? result.status.code : '' });
+  } catch (error) {
+    yield put({ type: types.EDIT_TEMPLATE_FAILURE, error });
+  }
+}
+
+export function* getTemplateDetails(id) {
+  try {
+    console.log('saga get Template details', id);
+    const result = yield call(Api.getTemplateDetails, id);
+    // const sidebar = result.response.sidebar;
+    yield put({ type: types.GET_TEMPLATE_DETAILS_SUCCESS, data: result.response });
+  } catch (error) {
+    yield put({ type: types.GET_TEMPLATE_DETAILS_FAILURE, error });
+  }
+}
+
+
+function* watchEditTemplate() {
+  const watcher = yield takeLatest(types.EDIT_TEMPLATE_REQUEST, editTemplate);
+  yield take(LOCATION_CHANGE);
+  yield cancel(watcher);
+}
+
+function* watchGetTemplateDetails() {
+  const watcher = yield takeLatest(types.GET_TEMPLATE_DETAILS_REQUEST, getTemplateDetails);
+  yield take(LOCATION_CHANGE);
+  yield cancel(watcher);
+}
+
+// All sagas to be loaded
+export default [
+  watchEditTemplate, watchGetTemplateDetails,
+];

package/containers/Sms/Edit/selectors.js

@@ -0,0 +1,32 @@
+import { createSelector } from 'reselect';
+
+/**
+ * Direct selector to the create state domain
+ */
+const selectSmsEditDomain = () => (state) => state.get('edit');
+
+/**
+ * Other specific selectors
+ */
+
+
+/**
+ * Default selector used by Create
+ */
+
+const makeSelectEdit = () => createSelector(
+  selectSmsEditDomain(),
+  (substate) => substate.toJS()
+);
+
+const makeSelectEditResponse = () => createSelector(
+  selectSmsEditDomain(), (dimensionState) => dimensionState.get('editResponse')
+);
+
+const makeSelectTemplateDetailsResponse = () => createSelector(
+  selectSmsEditDomain(), (dimensionState) => dimensionState.get('templateDetails')
+);
+
+export {
+  makeSelectEdit, makeSelectEditResponse, makeSelectTemplateDetailsResponse,
+};

package/containers/Sms/Edit/tests/actions.test.js

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

package/containers/Sms/Edit/tests/index.test.js

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

package/containers/Sms/Edit/tests/reducer.test.js

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

package/containers/Sms/Edit/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/Sms/Edit/tests/selectors.test.js

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

package/containers/TagList/_tagList.scss

@@ -0,0 +1,8 @@
+.ant-tree li span.ant-tree-switcher {
+  margin-left: 0 !important ;
+}
+
+.ant-tree{
+  max-height: 300px;
+  overflow-y: auto;
+}

package/containers/TagList/actions.js

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

package/containers/TagList/constants.js

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

package/containers/TagList/index.js

@@ -0,0 +1,227 @@
+/*
+ *
+ * TagList
+ *
+ */
+
+import React, { PropTypes } from 'react';
+import { connect } from 'react-redux';
+import { Tree } from 'antd';
+import _ from 'lodash';
+import { createStructuredSelector } from 'reselect';
+import { bindActionCreators } from 'redux';
+import makeSelectTagList from './selectors';
+import { UserIsAuthenticated } from '../../utils/authWrapper';
+import * as actions from './actions';
+import * as globalActions from '../../containers/Cap/actions';
+// import styled from styled-components;
+import CapTagList from '../../components/CapTagList';
+import './_tagList.scss';
+const TreeNode = Tree.TreeNode;
+
+export class TagList extends React.Component { // eslint-disable-line react/prefer-stateless-function
+  constructor(props) {
+    super(props);
+    this.state = {
+      loading: false,
+    };
+    this.renderTags = this.renderTags.bind(this);
+    this.populateTags = this.populateTags.bind(this);
+    this.populateTagForChildren = this.populateTagForChildren.bind(this);
+    this.transformInjectedTags = this.transformInjectedTags.bind(this);
+  }
+
+  componentDidMount() {
+    console.log('tags props', this.props);
+  }
+
+  componentWillReceiveProps(nextProps) {
+    console.log('tag next props', nextProps.injectedTags, this.props.injectedTags);
+    if (!_.isEqual(nextProps.injectedTags, this.props.injectedTags)) {
+      console.log('received new tags', nextProps);
+      this.setState({loading: false});
+    }
+    if (!_.isEqual(nextProps.tags, this.props.tags)) {
+      console.log('received new tags', nextProps);
+      this.setState({loading: false});
+    }
+  }
+
+  onSelect = (selectedKeys) => {
+    this.props.onTagSelect(selectedKeys[0]);
+  };
+
+  onClick = (e, data) => {
+    console.log('clicked ', e, data);
+  };
+
+  getTagsforContext = (data) => {
+    //this.setState({loading: true});
+    this.props.onContextChange(data);
+  }
+
+  populateTags(tagsList) {
+    console.log('populating tags', tagsList);
+    const mainTags = {};
+
+    //Form tags object with tag headers
+    _.forEach(tagsList, (temp) => {
+      const tag = temp.definition;
+      if (!tag['tag-header']) {
+        mainTags[tag.value] = {
+          name: tag.label.en,
+          desc: tag.desc ? tag.desc : tag.label.en,
+        };
+      } else if (tag['tag-header'] && mainTags[tag.value]) {
+        mainTags[tag.value].subtags = _.concat(mainTags[tag.value].subtags, tag.subtags);
+      } else if (!mainTags[tag.value]) {
+        mainTags[tag.value] = {
+          'tag-header': true,
+          name: tag.label.en,
+          desc: tag.desc ? tag.desc : tag.label.en,
+          subtags: tag.subtags,
+        };
+      }
+    });
+
+    const mainTagsCloned = _.cloneDeep(mainTags);
+    //Insert subtags in tag headers and reomve them from top level
+    const result = {};
+    _.forEach(mainTagsCloned, (tag, key) => {
+      if (tag['tag-header']) {
+        const tagWithChildren = this.populateTagForChildren(tag, mainTagsCloned, key);
+        tagWithChildren.resolved = true;
+        result[key] = tagWithChildren;
+      } else {
+        result[key] = tag;
+      }
+    });
+
+    //Delete extra tag headers
+    _.forEach(result, (tag) => {
+      if (tag['tag-header']) {
+        _.forEach(tag.subtags, (subtag, key) => {
+          if (result[key]) {
+            result[key].deleted = true;
+          }
+        });
+      }
+    });
+    //Actually delete them
+    _.forEach(result, (tag, key) => {
+      if (tag.deleted) {
+        delete result[key];
+      }
+    });
+    return result;
+  }
+
+  populateTagForChildren(targetTag, tagsObject, tagValue) {
+    const tag = targetTag;
+    if (tag && tag['tag-header'] && !tag.resolved) {
+      const tempSubTags = {};
+      _.forEach(tag.subtags, (subtag) => {
+        if (tagsObject[subtag]) {
+          const children = this.populateTagForChildren(tagsObject[subtag], tagsObject, subtag);
+          children.resolved = true;
+          tempSubTags[subtag] = children;
+        }
+      });
+      tag.subtags = tempSubTags;
+      return tag;
+    }
+    return tagsObject[tagValue];
+  }
+
+  transformInjectedTags(tags) {
+    _.forEach(tags, (tag) => {
+      const temp = tag;
+      let subKey = '';
+      Object.keys(tag).map( (k) => {
+        if (k.indexOf("subtags") !== -1) {
+          subKey = k;
+        }
+        return true;
+      });
+      if (subKey !== '') {
+        temp['tag-header'] = true;
+        if (subKey !== 'subtags') {
+          temp.subtags = _.cloneDeep(temp[subKey]);
+          delete temp[subKey];
+        }
+        temp.subtags = this.transformInjectedTags(temp.subtags);
+      }
+    });
+    return tags;
+  }
+
+  renderTags(tags) {
+    const list = [];
+    _.forEach(tags, (val, key) => {
+      if (_.has(val, 'subtags')) {
+        const temp = this.renderTags(val.subtags);
+        list.push((
+          <TreeNode title={val.name} key={key}>
+            {temp}
+          </TreeNode>
+        ));
+      } else {
+        const tempNode = (<TreeNode title={val.name} key={key}></TreeNode>);
+        list.push(tempNode);
+      }
+    });
+    return list;
+  }
+
+  render() {
+    console.log('tags props 2', this.props);
+    let tags = {};
+    let injectedTags = {};
+    if (this.props.injectedTags && !_.isEmpty(this.props.injectedTags)) {
+      injectedTags = this.transformInjectedTags(this.props.injectedTags);
+      console.log('transformed injected Tags', injectedTags);
+    }
+    if (this.props.tags && this.props.tags.length > 0) {
+      tags = this.populateTags(this.props.tags);
+      console.log('populating tags', tags);
+    }
+    tags = _.merge( {}, tags, injectedTags);
+    console.log('merged tags', tags);
+        // console.log('tag list', this.renderTags(tags));
+    return (
+      <div className={this.props.className ? this.props.className : ''}>
+        <CapTagList
+          loading={this.state.loading}
+          tags={tags}
+          onSelect={this.onSelect}
+          label={this.props.label}
+          onContextChange={this.getTagsforContext}
+          moduleFilterEnabled={this.props.moduleFilterEnabled}
+        />
+      </div>
+    );
+  }
+}
+
+TagList.propTypes = {
+  onTagSelect: PropTypes.func,
+  tags: PropTypes.array,
+  injectedTags: PropTypes.object,
+  label: PropTypes.string,
+  onContextChange: PropTypes.func,
+  moduleFilterEnabled: PropTypes.bool,
+  className: PropTypes.string,
+};
+
+const mapStateToProps = createStructuredSelector({
+  TagList: makeSelectTagList(),
+});
+
+function mapDispatchToProps(dispatch) {
+  return {
+    actions: bindActionCreators(actions, dispatch),
+    globalActions: bindActionCreators(globalActions, dispatch),
+  };
+}
+
+export default UserIsAuthenticated(connect(mapStateToProps, mapDispatchToProps)(TagList));

package/containers/TagList/messages.js

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

package/containers/TagList/reducer.js

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

package/containers/TagList/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/TagList/selectors.js

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

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

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

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

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

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

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

package/containers/TagList/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);
+  });
+});