5 files changed, 505 insertions, 0 deletions

diff --git a/src/features/announcements/actions.js b/src/features/announcements/actions.js
new file mode 100644
index 000000000..bab496314
--- /dev/null
+++ b/src/features/announcements/actions.js
@@ -0,0 +1,10 @@
+import PropTypes from 'prop-types';
+import { createActionsFromDefinitions } from '../../actions/lib/actions';
+
+export const announcementActions = createActionsFromDefinitions({
+  show: {
+    targetVersion: PropTypes.string,
+  },
+}, PropTypes.checkPropTypes);
+
+export default announcementActions;
diff --git a/src/features/announcements/api.js b/src/features/announcements/api.js
new file mode 100644
index 000000000..a581bd8de
--- /dev/null
+++ b/src/features/announcements/api.js
@@ -0,0 +1,33 @@
+import { remote } from 'electron';
+import Request from '../../stores/lib/Request';
+import { API, API_VERSION } from '../../environment';
+
+const debug = require('debug')('Franz:feature:announcements:api');
+
+export const announcementsApi = {
+  async getCurrentVersion() {
+    debug('getting current version of electron app');
+    return Promise.resolve(remote.app.getVersion());
+  },
+
+  async getChangelog(version) {
+    debug('fetching release changelog from Github');
+    const url = `https://api.github.com/repos/meetfranz/franz/releases/tags/v${version}`;
+    const request = await window.fetch(url, { method: 'GET' });
+    if (!request.ok) return null;
+    const data = await request.json();
+    return data.body;
+  },
+
+  async getAnnouncement(version) {
+    debug('fetching release announcement from api');
+    const url = `${API}/${API_VERSION}/announcements/${version}`;
+    const response = await window.fetch(url, { method: 'GET' });
+    if (!response.ok) return null;
+    return response.json();
+  },
+};
+
+export const getCurrentVersionRequest = new Request(announcementsApi, 'getCurrentVersion');
+export const getChangelogRequest = new Request(announcementsApi, 'getChangelog');
+export const getAnnouncementRequest = new Request(announcementsApi, 'getAnnouncement');
diff --git a/src/features/announcements/components/AnnouncementScreen.js b/src/features/announcements/components/AnnouncementScreen.js
new file mode 100644
index 000000000..dfce6cdd5
--- /dev/null
+++ b/src/features/announcements/components/AnnouncementScreen.js
@@ -0,0 +1,286 @@
+import React, { Component } from 'react';
+import marked from 'marked';
+import PropTypes from 'prop-types';
+import { inject, observer } from 'mobx-react';
+import { defineMessages, intlShape } from 'react-intl';
+import injectSheet from 'react-jss';
+import { Button } from '@meetfranz/forms';
+
+import { announcementsStore } from '../index';
+import UIStore from '../../../stores/UIStore';
+import { gaEvent } from '../../../lib/analytics';
+
+const renderer = new marked.Renderer();
+
+renderer.link = (href, title, text) => `<a target="_blank" href="${href}" title="${title}">${text}</a>`;
+
+const markedOptions = { sanitize: true, renderer };
+
+const messages = defineMessages({
+  headline: {
+    id: 'feature.announcements.changelog.headline',
+    defaultMessage: '!!!Changes in Franz {version}',
+  },
+});
+
+const smallScreen = '1000px';
+
+const styles = theme => ({
+  container: {
+    background: theme.colorBackground,
+    position: 'absolute',
+    top: 0,
+    zIndex: 140,
+    width: '100%',
+    height: '100%',
+    overflowY: 'auto',
+  },
+  headline: {
+    color: theme.colorHeadline,
+    margin: [25, 0, 40],
+    // 'max-width': 500,
+    'text-align': 'center',
+    'line-height': '1.3em',
+  },
+  announcement: {
+    height: 'auto',
+
+    [`@media(min-width: ${smallScreen})`]: {
+      display: 'flex',
+      flexDirection: 'column',
+      justifyContent: 'center',
+      height: '100vh',
+    },
+  },
+  main: {
+    display: 'flex',
+    flexDirection: 'column',
+    flexGrow: 1,
+    justifyContent: 'center',
+
+    '& h1': {
+      margin: [40, 0, 15],
+      fontSize: 70,
+      color: theme.styleTypes.primary.accent,
+      textAlign: 'center',
+
+      [`@media(min-width: ${smallScreen})`]: {
+        marginTop: 0,
+      },
+    },
+    '& h2': {
+      fontSize: 30,
+      fontWeight: 300,
+      color: theme.colorText,
+      textAlign: 'center',
+      marginBottom: 60,
+    },
+  },
+  mainBody: {
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'center',
+    width: 'calc(100% - 80px)',
+    height: 'auto',
+    margin: '0 auto',
+    [`@media(min-width: ${smallScreen})`]: {
+      flexDirection: 'row',
+      justifyContent: 'center',
+    },
+  },
+  mainImage: {
+    minWidth: 250,
+    maxWidth: 400,
+    margin: '0 auto',
+    marginBottom: 40,
+    '& img': {
+      width: '100%',
+    },
+    [`@media(min-width: ${smallScreen})`]: {
+      margin: 0,
+    },
+  },
+  mainText: {
+    height: 'auto',
+    maxWidth: 600,
+    textAlign: 'center',
+    '& p': {
+      lineHeight: '1.5em',
+    },
+    [`@media(min-width: ${smallScreen})`]: {
+      textAlign: 'left',
+    },
+  },
+  mainCtaButton: {
+    textAlign: 'center',
+    marginTop: 40,
+    [`@media(min-width: ${smallScreen})`]: {
+      textAlign: 'left',
+    },
+  },
+  spotlight: {
+    height: 'auto',
+    background: theme.announcements.spotlight.background,
+    padding: [40, 0],
+    marginTop: 80,
+    [`@media(min-width: ${smallScreen})`]: {
+      marginTop: 0,
+      justifyContent: 'center',
+      alignItems: 'flex-start',
+      display: 'flex',
+      flexDirection: 'row',
+    },
+  },
+  spotlightTopicContainer: {
+    textAlign: 'center',
+    marginBottom: 20,
+
+    [`@media(min-width: ${smallScreen})`]: {
+      marginBottom: 0,
+      minWidth: 250,
+      maxWidth: 330,
+      width: '100%',
+      textAlign: 'right',
+      marginRight: 60,
+    },
+  },
+  spotlightContentContainer: {
+    textAlign: 'center',
+    [`@media(min-width: ${smallScreen})`]: {
+      height: 'auto',
+      maxWidth: 600,
+      paddingRight: 40,
+      textAlign: 'left',
+    },
+    '& p': {
+      lineHeight: '1.5em',
+    },
+  },
+  spotlightTopic: {
+    fontSize: 20,
+    marginBottom: 5,
+    letterSpacing: 0,
+    fontWeight: 100,
+  },
+  spotlightSubject: {
+    fontSize: 20,
+  },
+  changelog: {
+    padding: [0, 60],
+    maxWidth: 700,
+    margin: [100, 'auto'],
+    height: 'auto',
+
+    '& h3': {
+      fontSize: '24px',
+      margin: '1.5em 0 1em 0',
+    },
+    '& li': {
+      marginBottom: '1em',
+      lineHeight: '1.4em',
+    },
+    '& div': {
+      height: 'auto',
+    },
+  },
+});
+
+
+@inject('stores', 'actions') @injectSheet(styles) @observer
+class AnnouncementScreen extends Component {
+  static propTypes = {
+    classes: PropTypes.object.isRequired,
+    stores: PropTypes.shape({
+      ui: PropTypes.instanceOf(UIStore).isRequired,
+    }).isRequired,
+  };
+
+  static contextTypes = {
+    intl: intlShape,
+  };
+
+  render() {
+    const { classes, stores } = this.props;
+    const { intl } = this.context;
+    const { changelog, announcement } = announcementsStore;
+    const themeImage = stores.ui.isDarkThemeActive ? 'dark' : 'light';
+    return (
+      <div className={classes.container}>
+        {announcement && (
+          <div className={classes.announcement}>
+            <div className={classes.main}>
+              <h1>{announcement.main.headline}</h1>
+              <h2>{announcement.main.subHeadline}</h2>
+              <div className={classes.mainBody}>
+                <div className={classes.mainImage}>
+                  <img
+                    src={announcement.main.image[themeImage]}
+                    alt=""
+                  />
+                </div>
+                <div className={classes.mainText}>
+                  <div
+                    dangerouslySetInnerHTML={{
+                      __html: marked(announcement.main.text, markedOptions),
+                    }}
+                  />
+                  <div className={classes.mainCtaButton}>
+                    <Button
+                      label={announcement.main.cta.label}
+                      onClick={() => {
+                        const { analytics } = announcement.main.cta;
+                        window.location.href = `#${announcement.main.cta.href}`;
+                        gaEvent(analytics.category, analytics.action, announcement.main.cta.label);
+                      }}
+                    />
+                  </div>
+                </div>
+              </div>
+            </div>
+            {announcement.spotlight && (
+              <div className={classes.spotlight}>
+                <div className={classes.spotlightTopicContainer}>
+                  <h2 className={classes.spotlightTopic}>{announcement.spotlight.title}</h2>
+                  <h3 className={classes.spotlightSubject}>{announcement.spotlight.subject}</h3>
+                </div>
+                <div className={classes.spotlightContentContainer}>
+                  <div
+                    dangerouslySetInnerHTML={{
+                      __html: marked(announcement.spotlight.text, markedOptions),
+                    }}
+                  />
+                  <div className={classes.mainCtaButton}>
+                    <Button
+                      label={announcement.spotlight.cta.label}
+                      onClick={() => {
+                        const { analytics } = announcement.spotlight.cta;
+                        window.location.href = `#${announcement.spotlight.cta.href}`;
+                        gaEvent(analytics.category, analytics.action, announcement.spotlight.cta.label);
+                      }}
+                    />
+                  </div>
+                </div>
+              </div>
+            )}
+          </div>
+        )}
+        {changelog && (
+          <div className={classes.changelog}>
+            <h1 className={classes.headline}>
+              {intl.formatMessage(messages.headline, {
+                version: announcementsStore.currentVersion,
+              })}
+            </h1>
+            <div
+              dangerouslySetInnerHTML={{
+                __html: marked(changelog, markedOptions),
+              }}
+            />
+          </div>
+        )}
+      </div>
+    );
+  }
+}
+
+export default AnnouncementScreen;
diff --git a/src/features/announcements/index.js b/src/features/announcements/index.js
new file mode 100644
index 000000000..4658b976f
--- /dev/null
+++ b/src/features/announcements/index.js
@@ -0,0 +1,32 @@
+import { reaction } from 'mobx';
+import { AnnouncementsStore } from './store';
+
+const debug = require('debug')('Franz:feature:announcements');
+
+export const GA_CATEGORY_ANNOUNCEMENTS = 'Announcements';
+
+export const announcementsStore = new AnnouncementsStore();
+
+export default function initAnnouncements(stores, actions) {
+  // const { features } = stores;
+
+  // Toggle workspace feature
+  reaction(
+    () => (
+      true
+      // features.features.isAnnouncementsEnabled
+    ),
+    (isEnabled) => {
+      if (isEnabled) {
+        debug('Initializing `announcements` feature');
+        announcementsStore.start(stores, actions);
+      } else if (announcementsStore.isFeatureActive) {
+        debug('Disabling `announcements` feature');
+        announcementsStore.stop();
+      }
+    },
+    {
+      fireImmediately: true,
+    },
+  );
+}
diff --git a/src/features/announcements/store.js b/src/features/announcements/store.js
new file mode 100644
index 000000000..7ecc0e346
--- /dev/null
+++ b/src/features/announcements/store.js
@@ -0,0 +1,144 @@
+import {
+  action,
+  computed,
+  observable,
+  reaction,
+} from 'mobx';
+import semver from 'semver';
+import localStorage from 'mobx-localstorage';
+
+import { FeatureStore } from '../utils/FeatureStore';
+import { GA_CATEGORY_ANNOUNCEMENTS } from '.';
+import { getAnnouncementRequest, getChangelogRequest, getCurrentVersionRequest } from './api';
+import { announcementActions } from './actions';
+import { createActionBindings } from '../utils/ActionBinding';
+import { createReactions } from '../../stores/lib/Reaction';
+import { gaEvent } from '../../lib/analytics';
+
+const LOCAL_STORAGE_KEY = 'announcements';
+
+const debug = require('debug')('Franz:feature:announcements:store');
+
+export class AnnouncementsStore extends FeatureStore {
+  @observable targetVersion = null;
+
+  @observable isAnnouncementVisible = false;
+
+  @observable isFeatureActive = false;
+
+  @computed get changelog() {
+    return getChangelogRequest.result;
+  }
+
+  @computed get announcement() {
+    return getAnnouncementRequest.result;
+  }
+
+  @computed get areNewsAvailable() {
+    const isChangelogAvailable = getChangelogRequest.wasExecuted && !!this.changelog;
+    const isAnnouncementAvailable = getAnnouncementRequest.wasExecuted && !!this.announcement;
+    return isChangelogAvailable || isAnnouncementAvailable;
+  }
+
+  @computed get settings() {
+    return localStorage.getItem(LOCAL_STORAGE_KEY) || {};
+  }
+
+  @computed get lastSeenAnnouncementVersion() {
+    return this.settings.lastSeenAnnouncementVersion || null;
+  }
+
+  @computed get currentVersion() {
+    return getCurrentVersionRequest.result;
+  }
+
+  @computed get isNewUser() {
+    return this.stores.settings.stats.appStarts <= 1;
+  }
+
+  async start(stores, actions) {
+    debug('AnnouncementsStore::start');
+    this.stores = stores;
+    this.actions = actions;
+    getCurrentVersionRequest.execute();
+
+    this._registerActions(createActionBindings([
+      [announcementActions.show, this._showAnnouncement],
+    ]));
+
+    this._reactions = createReactions([
+      this._fetchAnnouncements,
+      this._showAnnouncementToUsersWhoUpdatedApp,
+    ]);
+    this._registerReactions(this._reactions);
+    this.isFeatureActive = true;
+  }
+
+  stop() {
+    super.stop();
+    debug('AnnouncementsStore::stop');
+    this.isFeatureActive = false;
+    this.isAnnouncementVisible = false;
+  }
+
+  // ======= HELPERS ======= //
+
+  _updateSettings = (changes) => {
+    localStorage.setItem(LOCAL_STORAGE_KEY, {
+      ...this.settings,
+      ...changes,
+    });
+  };
+
+  // ======= ACTIONS ======= //
+
+  @action _showAnnouncement = ({ targetVersion } = {}) => {
+    if (!this.areNewsAvailable) return;
+    this.targetVersion = targetVersion || this.currentVersion;
+    this.isAnnouncementVisible = true;
+    this.actions.service.blurActive();
+    this._updateSettings({
+      lastSeenAnnouncementVersion: this.currentVersion,
+    });
+    const dispose = reaction(
+      () => this.stores.services.active,
+      () => {
+        this._hideAnnouncement();
+        dispose();
+      },
+    );
+
+    gaEvent(GA_CATEGORY_ANNOUNCEMENTS, 'show');
+  };
+
+  @action _hideAnnouncement() {
+    this.isAnnouncementVisible = false;
+  }
+
+  // ======= REACTIONS ========
+
+  _showAnnouncementToUsersWhoUpdatedApp = () => {
+    const { announcement, isNewUser } = this;
+    // Check if there is an announcement and on't show announcements to new users
+    if (!announcement || isNewUser) return;
+
+    // Check if the user has already used current version (= has seen the announcement)
+    const { currentVersion, lastSeenAnnouncementVersion } = this;
+    if (semver.gt(currentVersion, lastSeenAnnouncementVersion || '0.0.0')) {
+      debug(`${currentVersion} < ${lastSeenAnnouncementVersion}: announcement is shown`);
+      this._showAnnouncement();
+    }
+  };
+
+  _fetchAnnouncements = () => {
+    const targetVersion = this.targetVersion || this.currentVersion;
+    if (!targetVersion) return;
+    getChangelogRequest.execute(targetVersion);
+    // We only fetch announcements for current / older versions
+    if (targetVersion <= this.currentVersion) {
+      getAnnouncementRequest.execute(targetVersion);
+    } else {
+      getAnnouncementRequest.reset();
+    }
+  }
+}