@capillarytech/creatives-library 0.0.1

package/components/DateFilter/index.js

@@ -0,0 +1,347 @@
+/**
+*
+* DateFilter
+*
+*/
+
+import React, { PropTypes } from 'react';
+// import styled from 'styled-components';
+
+import { FormattedMessage } from 'react-intl';
+import { Popup, Input, Button, Grid, Checkbox, Dimmer, Loader } from 'semantic-ui-react';
+import DateRange from 'components/DateRange';
+import moment from 'moment';
+import _ from 'lodash';
+import messages from './messages';
+
+class DateFilter extends React.Component { // eslint-disable-line react/prefer-stateless-function
+  constructor(props) {
+    super(props);
+    this.state = {
+      selectedDateRange: this.props.selectedDateRange,
+      showChartCompareOptions: this.props.isCompareSelected,
+      compareDateRange: this.props.compareDateRange,
+      selectedDateText: '',
+      isDateSelectorOpen: false,
+      loading: this.props.loading,
+      openCustomDatePicker: false,
+      compareCustomDateSelected: false,
+      customDateSelected: false,
+      pastStateData: {},
+      componentWidth: 270,
+    };
+    this.handleToggleDateSelector = this.handleToggleDateSelector.bind(this);
+    this.renderDateSelector = this.renderDateSelector.bind(this);
+    this.handleDateTypeClick = this.handleDateTypeClick.bind(this);
+    this.printSelectedDate = this.printSelectedDate.bind(this);
+    this.handleCancel = this.handleCancel.bind(this);
+    this.handleChartCompareToggle = this.handleChartCompareToggle.bind(this);
+    this.handleCompareDateChange = this.handleCompareDateChange.bind(this);
+    this.handleCustomDatePickerCancel = this.handleCustomDatePickerCancel.bind(this);
+    this.handleDatePickerApply = this.handleDatePickerApply.bind(this);
+    this.compareDateValueSetting = this.compareDateValueSetting.bind(this);
+    this.handleApply = this.handleApply.bind(this);
+    this.restoreInitialState = this.restoreInitialState.bind(this);
+    this.storeInitialState = this.storeInitialState.bind(this);
+  }
+
+  componentWillMount() {
+    const dateText = this.printSelectedDate(this.state.selectedDateRange.startDate, this.state.selectedDateRange.endDate, this.state.selectedDateRange.dateType);
+    this.setState({ selectedDateText: dateText });
+    this.setState({ loading: false });
+    this.storeInitialState();
+  }
+
+  componentDidMount() {
+  }
+
+  componentWillReceiveProps(nextProp) {
+    this.setState({ selectedDateRange: nextProp.selectedDateRange, showChartCompareOptions: nextProp.isCompareSelected }, () => {
+      let dateText = this.printSelectedDate(this.state.selectedDateRange.startDate, this.state.selectedDateRange.endDate, this.state.selectedDateRange.dateType);
+      if (this.state.showChartCompareOptions) {
+        this.setState({ componentWidth: 450 });
+        dateText = `${dateText} vs ${this.printSelectedDate(this.state.compareDateRange.startDate, this.state.compareDateRange.endDate, this.state.compareDateRange.dateType, true)}`;
+      } else {
+        this.setState({ componentWidth: 270 });
+      }
+      this.setState({ selectedDateText: dateText });
+    });
+    this.storeInitialState();
+  }
+
+  storeInitialState() {
+    const stateData = _.cloneDeep(this.state);
+    const tmpState = {
+      selectedDateRange: stateData.selectedDateRange,
+      showChartCompareOptions: stateData.showChartCompareOptions,
+      compareDateRange: stateData.compareDateRange,
+    };
+    this.setState({ pastStateData: tmpState });
+  }
+
+  handleToggleDateSelector() {
+    this.setState({ isDateSelectorOpen: !this.state.isDateSelectorOpen });
+  }
+
+  handleDateTypeClick(specifier) {
+    const date = this.state.selectedDateRange;
+    if (specifier !== 'custom') {
+      date.dateType = specifier;
+      if (specifier === 'week') {
+        date.startDate = moment().isoWeekday(1);
+      } else {
+        date.startDate = moment().startOf(specifier);
+      }
+      date.endDate = moment();
+      this.setState({ selectedDateRange: date }, () => {
+        if (this.state.showChartCompareOptions) {
+          this.compareDateValueSetting(specifier);
+        }
+      });
+    } else {
+      this.setState({ customDateSelected: true, openCustomDatePicker: true });
+    }
+  }
+
+  printSelectedDate(startDate, endDate, specifier, isCompare) {
+    let specifierType = '';
+    if (isCompare) {
+      if (specifier === 'week') {
+        specifierType = 'Previous Week';
+      } else if (specifier === 'month') {
+        specifierType = 'Previous Month';
+      } else if (specifier === 'year') {
+        specifierType = 'Previous Year';
+      } else {
+        specifierType = 'Custom';
+      }
+    }
+    if (!isCompare) {
+      if (specifier === 'week') {
+        specifierType = 'WTD';
+      } else if (specifier === 'month') {
+        specifierType = 'MTD';
+      } else if (specifier === 'year') {
+        specifierType = 'YTD';
+      } else {
+        specifierType = 'Custom';
+      }
+    }
+
+    let tmpDateString = '';
+    if (moment(startDate).year() === moment(endDate).year()) {
+      tmpDateString = `${specifierType} ( ${moment(startDate).format('MMM D').toString()} - ${moment(endDate).format('MMM D YYYY').toString()} )`;
+    } else {
+      tmpDateString = `${specifierType} ( ${moment(startDate).format('MMM D YYYY').toString()} - ${moment(endDate).format('MMM D YYYY').toString()} )`;
+    }
+    return tmpDateString;
+  }
+
+  handleCancel() {
+    this.setState({ isDateSelectorOpen: false });
+    if (this.props.handleCancel !== undefined) {
+      this.props.handleCancel();
+    }
+
+    //  Need to improve this function
+    this.restoreInitialState();
+  }
+
+  compareDateValueSetting(specifier) {
+    const dateRange = (this.state.compareDateRange) ? this.state.compareDateRange : _.cloneDeep(this.state.selectedDateRange);
+    if (specifier === 'week') {
+      dateRange.startDate = moment(this.state.selectedDateRange.startDate).subtract(7, 'days');
+      dateRange.endDate = moment(this.state.selectedDateRange.endDate).subtract(7, 'days');
+      dateRange.dateType = specifier;
+    } else if (specifier === 'month') {
+      dateRange.startDate = moment(this.state.selectedDateRange.startDate).subtract(1, 'months');
+      dateRange.endDate = moment(this.state.selectedDateRange.endDate).subtract(1, 'months');
+      dateRange.dateType = specifier;
+    } else if (specifier === 'year' || specifier === 'custom') {
+      dateRange.startDate = moment(this.state.selectedDateRange.startDate).subtract(1, 'years');
+      dateRange.endDate = moment(this.state.selectedDateRange.endDate).subtract(1, 'years');
+      dateRange.dateType = specifier;
+    }
+    this.setState({ compareDateRange: dateRange });
+  }
+
+  handleChartCompareToggle() {
+    this.setState({ showChartCompareOptions: !this.state.showChartCompareOptions });
+    const compareDateType = (this.state.compareDateRange) ? this.state.compareDateRange.dateType : this.state.selectedDateRange.dateType;
+    this.compareDateValueSetting(compareDateType);
+  }
+
+  handleCompareDateChange(specifier) {
+    if (specifier === 'custom') {
+      this.setState({ compareCustomDateSelected: true, openCustomDatePicker: true });
+    } else {
+      this.compareDateValueSetting(specifier);
+    }
+  }
+
+  handleCustomDatePickerCancel(e) {
+    if (e) {
+      e.preventDefault();
+    }
+    this.setState({ customDateSelected: false });
+    this.setState({ compareCustomDateSelected: false });
+    this.setState({ openCustomDatePicker: false });
+  }
+
+  handleDatePickerApply(startDate, endDate, dateType) {
+    if (this.state.customDateSelected) {
+      const dateRange = _.cloneDeep(this.state.selectedDateRange);
+      dateRange.startDate = startDate;
+      dateRange.endDate = endDate;
+      dateRange.dateType = dateType;
+      this.setState({ selectedDateRange: dateRange });
+      this.setState({ customDateSelected: false });
+    } else {
+      const dateRange = _.cloneDeep(this.state.compareDateRange);
+      dateRange.startDate = startDate;
+      dateRange.endDate = endDate;
+      dateRange.dateType = dateType;
+      this.setState({ compareDateRange: dateRange });
+      this.setState({ compareCustomDateSelected: false });
+    }
+  }
+
+  handleApply() {
+    let dateText = this.printSelectedDate(this.state.selectedDateRange.startDate, this.state.selectedDateRange.endDate, this.state.selectedDateRange.dateType);
+    if (this.state.showChartCompareOptions) {
+      this.setState({ componentWidth: 450 });
+      dateText = `${dateText} vs ${this.printSelectedDate(this.state.compareDateRange.startDate, this.state.compareDateRange.endDate, this.state.compareDateRange.dateType, true)}`;
+    } else {
+      this.setState({ componentWidth: 270 });
+    }
+    this.setState({ selectedDateText: dateText });
+    this.setState({ isDateSelectorOpen: false });
+    this.props.handleApply(this.state.selectedDateRange, this.state.showChartCompareOptions, this.state.compareDateRange);
+  }
+
+  restoreInitialState() {
+    this.setState({ selectedDateRange: this.state.pastStateData.selectedDateRange });
+    this.setState({ compareDateRange: this.state.pastStateData.compareDateRange, showChartCompareOptions: this.state.pastStateData.showChartCompareOptions });
+  }
+
+  renderDateSelector() {
+    const dateType = this.state.selectedDateRange.dateType;
+    return (
+      <div className="date-filter-wrapper">
+        { this.state.loading ? <Dimmer active inverted className={'hide'}><Loader inverted><FormattedMessage {...messages.loaderMessage} /> </Loader></Dimmer> :
+        <Grid>
+          <Grid.Row className={this.state.openCustomDatePicker ? 'hide' : ''}>
+            <Grid.Column width={16}>
+              <Button.Group fluid className="btn-group till-date">
+                <Button className={dateType === 'week' ? 'active' : ''} onClick={() => this.handleDateTypeClick('week')}>WTD</Button>
+                <Button className={dateType === 'month' ? 'active' : ''} onClick={() => this.handleDateTypeClick('month')}>MTD</Button>
+                <Button className={dateType === 'year' ? 'active' : ''} onClick={() => this.handleDateTypeClick('year')}>YTD</Button>
+                <Button className={dateType === 'custom' ? 'active' : ''} onClick={() => this.handleDateTypeClick('custom')}>Custom</Button>
+              </Button.Group>
+            </Grid.Column>
+            <Grid.Column width={16} className="selectedDateText">
+              {this.printSelectedDate(this.state.selectedDateRange.startDate, this.state.selectedDateRange.endDate, this.state.selectedDateRange.dateType)}
+              {dateType === 'custom' ? <span className="editSelectedDate" onClick={() => this.handleDateTypeClick('custom')}><FormattedMessage {...messages.editText} /></span> : ''}
+            </Grid.Column>
+          </Grid.Row>
+          <Grid.Row className={this.state.openCustomDatePicker ? 'hide' : 'compareDateToggle'}>
+            <Grid.Column width={16}>
+              <Checkbox className={!this.props.compareMode ? 'hide' : 'dateCompareCheckbox'} checked={this.state.showChartCompareOptions} label="Compare" onClick={this.handleChartCompareToggle} />
+            </Grid.Column>
+          </Grid.Row>
+          { this.state.showChartCompareOptions ?
+            <Grid.Row className={!this.state.openCustomDatePicker ? '' : 'hide'}>
+              <Grid.Column width={16}>
+                <Button.Group fluid className="btn-group till-date">
+                  {dateType !== 'week' ? '' :
+                  <Button className={this.state.compareDateRange.dateType !== 'week' ? '' : 'active'} onClick={() => this.handleCompareDateChange('week')}>Previous Week</Button> }
+                  {dateType !== 'month' ? '' :
+                  <Button className={this.state.compareDateRange.dateType !== 'month' ? '' : 'active'} onClick={() => this.handleCompareDateChange('month')}>Previous Month</Button>}
+                  <Button className={this.state.compareDateRange.dateType === 'year' ? 'active' : ''} onClick={() => this.handleCompareDateChange('year')}>Previous Year</Button>
+                  <Button className={this.state.compareDateRange.dateType === 'custom' ? 'active' : ''} onClick={() => this.handleCompareDateChange('custom')}>Custom</Button>
+                </Button.Group>
+              </Grid.Column>
+              <Grid.Column width={16} className="selectedDateText">
+                {this.printSelectedDate(this.state.compareDateRange.startDate, this.state.compareDateRange.endDate, this.state.compareDateRange.dateType, true)}
+                {this.state.compareDateRange.dateType === 'custom' ? <span className="editSelectedDate" onClick={() => this.handleCompareDateChange('custom')}><FormattedMessage {...messages.editText} /></span> : ''}
+              </Grid.Column>
+            </Grid.Row>
+            : ''
+          }
+          <Grid.Row className={this.state.openCustomDatePicker ? 'hide' : ''}>
+            <Grid.Column width={16}>
+              <Button primary onClick={this.handleApply}>Apply</Button>
+              <Button basic onClick={this.handleCancel}>Cancel</Button>
+            </Grid.Column>
+          </Grid.Row>
+
+          { this.state.customDateSelected ?
+            <Grid.Row className={!this.state.openCustomDatePicker ? 'hide' : ''}>
+              <Grid.Column className="selectDateRangeTitle" width={16}>
+                <a href="" className="backButton" onClick={this.handleCustomDatePickerCancel}><i className="material-icons">keyboard_backspace</i></a>
+                <span className="dateRangeTitle">Select Date Range</span>
+              </Grid.Column>
+              <Grid.Column width={16} className="dateRangeWrapper">
+                <DateRange prevSelectedDate={this.state.selectedDateRange} handleDatePickerApply={this.handleDatePickerApply} handleDatePickerCancel={this.handleCustomDatePickerCancel} />
+              </Grid.Column>
+              {/* { this.state.showChartCompareOptions ? <Grid.Column width={16}>
+                {this.printSelectedDate(this.props.selectedDateRange.startDate, this.props.selectedDateRange.endDate, this.state.selectedDateRange.dateType)} vs
+              </Grid.Column> : '' } */}
+            </Grid.Row> : ''
+          }
+
+          { this.state.compareCustomDateSelected ?
+            <Grid.Row className={!this.state.openCustomDatePicker ? 'hide' : ''}>
+              <Grid.Column width={16}>
+                <a href="" className="backButton" onClick={this.handleCustomDatePickerCancel}><i className="material-icons">keyboard_backspace</i></a>
+                <span className="dateRangeTitle">Select Date Range</span>
+              </Grid.Column>
+              <Grid.Column width={16}>
+                {this.printSelectedDate(this.state.selectedDateRange.startDate, this.state.selectedDateRange.endDate, this.state.selectedDateRange.dateType)} vs
+              </Grid.Column>
+              <Grid.Column width={16} className="dateRangeWrapper">
+                <DateRange prevSelectedDate={this.state.compareDateRange} handleDatePickerApply={this.handleDatePickerApply} handleDatePickerCancel={this.handleCustomDatePickerCancel} />
+              </Grid.Column>
+            </Grid.Row> : ''
+          }
+        </Grid>}
+      </div>
+    );
+  }
+
+  render() {
+    const { isDateSelectorOpen } = this.state;
+    // const loading = this.state.loading;
+    return (
+      <span>
+        <Popup
+          trigger={
+            <Input
+              id="compareDate"
+              style={{ width: `${this.state.componentWidth}px` }}
+              readOnly
+              icon="caret down"
+              value={this.state.selectedDateText}
+            />
+          }
+          content={this.renderDateSelector()}
+          on="click"
+          open={isDateSelectorOpen}
+          onOpen={this.handleToggleDateSelector}
+        />
+      </span>
+    );
+  }
+}
+
+DateFilter.propTypes = {
+  selectedDateRange: PropTypes.object.isRequired,
+  compareMode: PropTypes.bool,
+  compareDateRange: PropTypes.object,
+  isCompareSelected: PropTypes.bool,
+  handleApply: PropTypes.func.isRequired,
+  handleCancel: PropTypes.func,
+  loading: PropTypes.bool,
+};
+
+export default DateFilter;

package/components/DateFilter/messages.js

@@ -0,0 +1,17 @@
+/*
+ * DateFilter Messages
+ *
+ * This contains all the text for the DateFilter component.
+ */
+import { defineMessages } from 'react-intl';
+
+export default defineMessages({
+  loaderMessage: {
+    id: 'reon.components.DateFilter.loaderMessage',
+    defaultMessage: 'Fetching Data',
+  },
+  editText: {
+    id: 'reon.components.DateFilter.editText',
+    defaultMessage: 'Edit',
+  },
+});

package/components/DateFilter/tests/index.test.js

@@ -0,0 +1,15 @@
+// import React from 'react';
+// import { shallow } from 'enzyme';
+//
+// import moment from 'moment';
+// import DateFilter from '../index';
+
+// describe('<DateFilter />', () => {
+//   it('Expect to have unit tests specified', () => {
+//     expect(true).toEqual(false);
+//   });
+//   it('Expect to have selectDateRange Prop', () => {
+//     const wrapper = shallow(<DateFilter selectedDateRange={moment()} />);
+//     expect(wrapper.props().selectedDateRange).toEqual(moment());
+//   });
+// });

package/components/DateRange/index.js

@@ -0,0 +1,111 @@
+/**
+*
+* DateRange
+*
+*/
+
+import React, { PropTypes } from 'react';
+// import styled from 'styled-components';
+
+import { FormattedMessage } from 'react-intl';
+import { Grid, Button } from 'semantic-ui-react';
+
+import DatePicker from 'react-datepicker';
+import 'react-datepicker/dist/react-datepicker.css';
+
+import moment from 'moment';
+
+class DateRange extends React.Component { // eslint-disable-line react/prefer-stateless-function
+  constructor(props) {
+    super(props);
+    this.state = {
+      startDate: this.props.prevSelectedDate.startDate,
+      endDate: this.props.prevSelectedDate.endDate,
+    };
+
+    this.handleChangeStart = this.handleChangeStart.bind(this);
+    this.handleChangeEnd = this.handleChangeEnd.bind(this);
+    this.closeAndUpdate = this.closeAndUpdate.bind(this);
+    this.closeAndCancel = this.closeAndCancel.bind(this);
+  }
+
+  handleChangeStart(date) {
+    this.setState({ startDate: date });
+  }
+
+  handleChangeEnd(date) {
+    this.setState({ endDate: date });
+  }
+
+  closeAndUpdate() {
+    this.props.handleDatePickerApply(this.state.startDate, this.state.endDate, 'custom');
+    this.props.handleDatePickerCancel();
+  }
+
+  closeAndCancel() {
+    this.props.handleDatePickerCancel();
+  }
+
+  render() {
+    const { startDate, endDate } = this.state;
+
+    return (
+      <Grid className="dateRangeWrapper" columns={2}>
+        <Grid.Row className="selectedDateTitleWrapper">
+          <Grid.Column style={{ paddingLeft: 0, paddingBottom: `${8}px` }}>
+            <span className="selectedDateTitle">From</span>
+            <input className="selectedDateRange" type="text" readOnly defaultValue={moment(startDate).format('MM/DD/YYYY').toString()} />
+            <i className="calenderIcon material-icons">today</i>
+          </Grid.Column>
+          <Grid.Column style={{ paddingLeft: 0 }}>
+            <span className="selectedDateTitle">To</span>
+            <input className="selectedDateRange" readOnly type="text" defaultValue={moment(endDate).format('MM/DD/YYYY').toString()} />
+            <i className="calenderIcon material-icons">today</i>
+          </Grid.Column>
+        </Grid.Row>
+        <Grid.Row style={{ paddingTop: 0, paddingBottom: `${2}px` }}>
+          <Grid.Column style={{ paddingLeft: 0 }}>
+            <DatePicker
+              inline
+              selected={startDate}
+              startDate={startDate}
+              endDate={endDate}
+              onChange={this.handleChangeStart}
+              showMonthDropdown
+              showYearDropdown
+              dropdownMode="select"
+            />
+          </Grid.Column>
+          <Grid.Column style={{ paddingLeft: 0 }}>
+            <DatePicker
+              inline
+              selected={endDate}
+              startDate={startDate}
+              endDate={endDate}
+              minDate={startDate}
+              maxDate={moment()}
+              onChange={this.handleChangeEnd}
+              showMonthDropdown
+              showYearDropdown
+              dropdownMode="select"
+            />
+          </Grid.Column>
+        </Grid.Row>
+        <Grid.Row>
+          <Grid.Column width={16} style={{ paddingLeft: 0 }}>
+            <Button onClick={this.closeAndUpdate} className="btn-primary" floated="left"><FormattedMessage id="customdatepicker.done" defaultMessage="Done" /></Button>
+            <Button onClick={this.closeAndCancel} className="btn-secondary" floated="left"><FormattedMessage id="customdatepicker.cancel" defaultMessage="Cancel" /></Button>
+          </Grid.Column>
+        </Grid.Row>
+      </Grid>
+    );
+  }
+}
+
+DateRange.propTypes = {
+  prevSelectedDate: PropTypes.object.isRequired,
+  handleDatePickerCancel: PropTypes.func,
+  handleDatePickerApply: PropTypes.func,
+};
+
+export default DateRange;

package/components/DateRange/messages.js

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

package/components/DateRange/tests/index.test.js

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

package/components/Edmeditor/index.js

@@ -0,0 +1,63 @@
+/**
+*
+* Edmeditor
+*
+*/
+
+import React, { PropTypes } from 'react';
+// import styled from 'styled-components';
+
+// import { FormattedMessage } from 'react-intl';
+import _ from "lodash";
+// import messages from './messages';
+// const loadScript = require('load-script');
+// const defaultScriptUrl = "https://api-static.edmdesigner.com/EDMdesignerAPI.js";
+
+class Edmeditor extends React.Component { // eslint-disable-line react/prefer-stateless-function
+  constructor(props) {
+    super(props);
+    this.state = {
+      editorInstance: undefined,
+    };
+
+    // this.onLoad = this.onLoad.bind(this);
+  }
+
+  componentDidMount() {
+  }
+
+  componentWillReceiveProps(nextProps) {
+    console.log('nextProps EDM ', nextProps);
+    if (!_.isEqual(nextProps.content, this.props.content)) {
+      console.log(nextProps.content);
+      this.editorInstance.content = nextProps.content;
+    }
+  }
+
+  componentWillUnmount() {
+    this.unmounting = true;
+  }
+
+  render() {
+    return (
+      this.props.edmSrc ?
+        (<iframe id={this.props.id} className={this.props.activeClass} src={this.props.edmSrc} height="700" width="100%"></iframe>)
+      : ''
+    );
+  }
+}
+
+Edmeditor.defaultProps = {
+  id: 'edmEditor',
+  activeClass: "",
+};
+
+Edmeditor.propTypes = {
+  id: PropTypes.string,
+  activeClass: PropTypes.string,
+  content: PropTypes.any,
+  // getEditorInstanse: PropTypes.func,
+  edmSrc: PropTypes.string,
+};
+
+export default Edmeditor;

package/components/Edmeditor/messages.js

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

package/components/Edmeditor/tests/index.test.js

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