Add account to antenna webui

app/javascript/mastodon/actions/antennas.js

@@ -0,0 +1,179 @@
+import api from '../api';
+import { importFetchedAccounts } from './importer';
+
+export const ANTENNAS_FETCH_REQUEST = 'ANTENNAS_FETCH_REQUEST';
+export const ANTENNAS_FETCH_SUCCESS = 'ANTENNAS_FETCH_SUCCESS';
+export const ANTENNAS_FETCH_FAIL    = 'ANTENNAS_FETCH_FAIL';
+
+export const ANTENNA_ACCOUNTS_FETCH_REQUEST = 'ANTENNA_ACCOUNTS_FETCH_REQUEST';
+export const ANTENNA_ACCOUNTS_FETCH_SUCCESS = 'ANTENNA_ACCOUNTS_FETCH_SUCCESS';
+export const ANTENNA_ACCOUNTS_FETCH_FAIL    = 'ANTENNA_ACCOUNTS_FETCH_FAIL';
+
+export const ANTENNA_EDITOR_ADD_ACCOUNT_REQUEST = 'ANTENNA_EDITOR_ADD_ACCOUNT_REQUEST';
+export const ANTENNA_EDITOR_ADD_ACCOUNT_SUCCESS = 'ANTENNA_EDITOR_ADD_ACCOUNT_SUCCESS';
+export const ANTENNA_EDITOR_ADD_ACCOUNT_FAIL    = 'ANTENNA_EDITOR_ADD_ACCOUNT_FAIL';
+
+export const ANTENNA_EDITOR_REMOVE_ACCOUNT_REQUEST = 'ANTENNA_EDITOR_REMOVE_ACCOUNT_REQUEST';
+export const ANTENNA_EDITOR_REMOVE_ACCOUNT_SUCCESS = 'ANTENNA_EDITOR_REMOVE_ACCOUNT_SUCCESS';
+export const ANTENNA_EDITOR_REMOVE_ACCOUNT_FAIL    = 'ANTENNA_EDITOR_REMOVE_ACCOUNT_FAIL';
+
+export const ANTENNA_ADDER_ANTENNAS_FETCH_REQUEST = 'ANTENNA_ADDER_ANTENNAS_FETCH_REQUEST';
+export const ANTENNA_ADDER_ANTENNAS_FETCH_SUCCESS = 'ANTENNA_ADDER_ANTENNAS_FETCH_SUCCESS';
+export const ANTENNA_ADDER_ANTENNAS_FETCH_FAIL    = 'ANTENNA_ADDER_ANTENNAS_FETCH_FAIL';
+
+export const ANTENNA_ADDER_RESET = 'ANTENNA_ADDER_RESET';
+export const ANTENNA_ADDER_SETUP = 'ANTENNA_ADDER_SETUP';
+
+export const fetchAntennas = () => (dispatch, getState) => {
+  dispatch(fetchAntennasRequest());
+
+  api(getState).get('/api/v1/antennas')
+    .then(({ data }) => dispatch(fetchAntennasSuccess(data)))
+    .catch(err => dispatch(fetchAntennasFail(err)));
+};
+
+export const fetchAntennasRequest = () => ({
+  type: ANTENNAS_FETCH_REQUEST,
+});
+
+export const fetchAntennasSuccess = antennas => ({
+  type: ANTENNAS_FETCH_SUCCESS,
+  antennas,
+});
+
+export const fetchAntennasFail = error => ({
+  type: ANTENNAS_FETCH_FAIL,
+  error,
+});
+
+export const fetchAntennaAccounts = antennaId => (dispatch, getState) => {
+  dispatch(fetchAntennaAccountsRequest(antennaId));
+
+  api(getState).get(`/api/v1/antennas/${antennaId}/accounts`, { params: { limit: 0 } }).then(({ data }) => {
+    dispatch(importFetchedAccounts(data));
+    dispatch(fetchAntennaAccountsSuccess(antennaId, data));
+  }).catch(err => dispatch(fetchAntennaAccountsFail(antennaId, err)));
+};
+
+export const fetchAntennaAccountsRequest = id => ({
+  type: ANTENNA_ACCOUNTS_FETCH_REQUEST,
+  id,
+});
+
+export const fetchAntennaAccountsSuccess = (id, accounts, next) => ({
+  type: ANTENNA_ACCOUNTS_FETCH_SUCCESS,
+  id,
+  accounts,
+  next,
+});
+
+export const fetchAntennaAccountsFail = (id, error) => ({
+  type: ANTENNA_ACCOUNTS_FETCH_FAIL,
+  id,
+  error,
+});
+
+export const addAccountToAntenna = (antennaId, accountId) => (dispatch, getState) => {
+  dispatch(addAccountToAntennaRequest(antennaId, accountId));
+
+  api(getState).post(`/api/v1/antennas/${antennaId}/accounts`, { account_ids: [accountId] })
+    .then(() => dispatch(addAccountToAntennaSuccess(antennaId, accountId)))
+    .catch(err => dispatch(addAccountToAntennaFail(antennaId, accountId, err)));
+};
+
+export const addAccountToAntennaRequest = (antennaId, accountId) => ({
+  type: ANTENNA_EDITOR_ADD_ACCOUNT_REQUEST,
+  antennaId,
+  accountId,
+});
+
+export const addAccountToAntennaSuccess = (antennaId, accountId) => ({
+  type: ANTENNA_EDITOR_ADD_ACCOUNT_SUCCESS,
+  antennaId,
+  accountId,
+});
+
+export const addAntennaToAntennaFail = (antennaId, accountId, error) => ({
+  type: ANTENNA_EDITOR_ADD_ACCOUNT_FAIL,
+  antennaId,
+  accountId,
+  error,
+});
+
+export const removeAccountFromAntennaEditor = accountId => (dispatch, getState) => {
+  dispatch(removeAccountFromAntenna(getState().getIn(['antennaEditor', 'antennaId']), accountId));
+};
+
+export const removeAccountFromAntenna = (antennaId, accountId) => (dispatch, getState) => {
+  dispatch(removeAccountFromAntennaRequest(antennaId, accountId));
+
+  api(getState).delete(`/api/v1/antennas/${antennaId}/accounts`, { params: { account_ids: [accountId] } })
+    .then(() => dispatch(removeAccountFromAntennaSuccess(antennaId, accountId)))
+    .catch(err => dispatch(removeAccountFromAntennaFail(antennaId, accountId, err)));
+};
+
+export const removeAccountFromAntennaRequest = (antennaId, accountId) => ({
+  type: ANTENNA_EDITOR_REMOVE_ACCOUNT_REQUEST,
+  antennaId,
+  accountId,
+});
+
+export const removeAccountFromAntennaSuccess = (antennaId, accountId) => ({
+  type: ANTENNA_EDITOR_REMOVE_ACCOUNT_SUCCESS,
+  antennaId,
+  accountId,
+});
+
+export const removeAccountFromAntennaFail = (antennaId, accountId, error) => ({
+  type: ANTENNA_EDITOR_REMOVE_ACCOUNT_FAIL,
+  antennaId,
+  accountId,
+  error,
+});
+
+export const addToAntennaAdder = antennaId => (dispatch, getState) => {
+  dispatch(addAccountToAntenna(antennaId, getState().getIn(['antennaAdder', 'accountId'])));
+};
+
+export const removeFromAntennaAdder = antennaId => (dispatch, getState) => {
+  dispatch(removeAccountFromAntenna(antennaId, getState().getIn(['antennaAdder', 'accountId'])));
+};
+
+export const fetchAccountAntennas = accountId => (dispatch, getState) => {
+  dispatch(fetchAccountAntennasRequest(accountId));
+
+  api(getState).get(`/api/v1/accounts/${accountId}/antennas`)
+    .then(({ data }) => dispatch(fetchAccountAntennasSuccess(accountId, data)))
+    .catch(err => dispatch(fetchAccountAntennasFail(accountId, err)));
+};
+
+export const fetchAccountAntennasRequest = id => ({
+  type: ANTENNA_ADDER_ANTENNAS_FETCH_REQUEST,
+  id,
+});
+
+export const fetchAccountAntennasSuccess = (id, antennas) => ({
+  type: ANTENNA_ADDER_ANTENNAS_FETCH_SUCCESS,
+  id,
+  antennas,
+});
+
+export const fetchAccountAntennasFail = (id, err) => ({
+  type: ANTENNA_ADDER_ANTENNAS_FETCH_FAIL,
+  id,
+  err,
+});
+
+export const resetAntennaAdder = () => ({
+  type: ANTENNA_ADDER_RESET,
+});
+
+export const setupAntennaAdder = accountId => (dispatch, getState) => {
+  dispatch({
+    type: ANTENNA_ADDER_SETUP,
+    account: getState().getIn(['accounts', accountId]),
+  });
+  dispatch(fetchAntennas());
+  dispatch(fetchAccountAntennas(accountId));
+};
+

app/javascript/mastodon/features/account/components/header.jsx

@@ -53,6 +53,7 @@ const messages = defineMessages({
   endorse: { id: 'account.endorse', defaultMessage: 'Feature on profile' },
   unendorse: { id: 'account.unendorse', defaultMessage: 'Don\'t feature on profile' },
   add_or_remove_from_list: { id: 'account.add_or_remove_from_list', defaultMessage: 'Add or Remove from lists' },
+  add_or_remove_from_antenna: { id: 'account.add_or_remove_from_antenna', defaultMessage: 'Add or Remove from antennas' },
   admin_account: { id: 'status.admin_account', defaultMessage: 'Open moderation interface for @{name}' },
   admin_domain: { id: 'status.admin_domain', defaultMessage: 'Open moderation interface for {domain}' },
   languages: { id: 'account.languages', defaultMessage: 'Change subscribed languages' },
@@ -98,6 +99,7 @@ class Header extends ImmutablePureComponent {
     onUnblockDomain: PropTypes.func.isRequired,
     onEndorseToggle: PropTypes.func.isRequired,
     onAddToList: PropTypes.func.isRequired,
+    onAddToAntenna: PropTypes.func.isRequired,
     onEditAccountNote: PropTypes.func.isRequired,
     onChangeLanguages: PropTypes.func.isRequired,
     onInteractionModal: PropTypes.func.isRequired,
@@ -263,8 +265,9 @@ class Header extends ImmutablePureComponent {
 
         menu.push({ text: intl.formatMessage(account.getIn(['relationship', 'endorsed']) ? messages.unendorse : messages.endorse), action: this.props.onEndorseToggle });
         menu.push({ text: intl.formatMessage(messages.add_or_remove_from_list), action: this.props.onAddToList });
-        menu.push(null);
       }
+      menu.push({ text: intl.formatMessage(messages.add_or_remove_from_antenna), action: this.props.onAddToAntenna });
+      menu.push(null);
 
       if (account.getIn(['relationship', 'muting'])) {
         menu.push({ text: intl.formatMessage(messages.unmute, { name: account.get('username') }), action: this.props.onMute });

app/javascript/mastodon/features/account_timeline/components/header.jsx

@@ -22,6 +22,7 @@ export default class Header extends ImmutablePureComponent {
     onUnblockDomain: PropTypes.func.isRequired,
     onEndorseToggle: PropTypes.func.isRequired,
     onAddToList: PropTypes.func.isRequired,
+    onAddToAntenna: PropTypes.func.isRequired,
     onChangeLanguages: PropTypes.func.isRequired,
     onInteractionModal: PropTypes.func.isRequired,
     onOpenAvatar: PropTypes.func.isRequired,
@@ -90,6 +91,10 @@ export default class Header extends ImmutablePureComponent {
     this.props.onAddToList(this.props.account);
   };
 
+  handleAddToAntenna = () => {
+    this.props.onAddToAntenna(this.props.account);
+  };
+
   handleEditAccountNote = () => {
     this.props.onEditAccountNote(this.props.account);
   };
@@ -131,6 +136,7 @@ export default class Header extends ImmutablePureComponent {
           onUnblockDomain={this.handleUnblockDomain}
           onEndorseToggle={this.handleEndorseToggle}
           onAddToList={this.handleAddToList}
+          onAddToAntenna={this.handleAddToAntenna}
           onEditAccountNote={this.handleEditAccountNote}
           onChangeLanguages={this.handleChangeLanguages}
           onInteractionModal={this.handleInteractionModal}

app/javascript/mastodon/features/account_timeline/containers/header_container.jsx

@@ -146,6 +146,12 @@ const mapDispatchToProps = (dispatch, { intl }) => ({
     }));
   },
 
+  onAddToAntenna (account) {
+    dispatch(openModal('ANTENNA_ADDER', {
+      accountId: account.get('id'),
+    }));
+  },
+
   onChangeLanguages (account) {
     dispatch(openModal('SUBSCRIBED_LANGUAGES', {
       accountId: account.get('id'),

app/javascript/mastodon/features/antenna_adder/components/account.jsx

@@ -0,0 +1,43 @@
+import React from 'react';
+import { connect } from 'react-redux';
+import { makeGetAccount } from '../../../selectors';
+import ImmutablePureComponent from 'react-immutable-pure-component';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import Avatar from '../../../components/avatar';
+import DisplayName from '../../../components/display_name';
+import { injectIntl } from 'react-intl';
+
+const makeMapStateToProps = () => {
+  const getAccount = makeGetAccount();
+
+  const mapStateToProps = (state, { accountId }) => ({
+    account: getAccount(state, accountId),
+  });
+
+  return mapStateToProps;
+};
+
+
+export default @connect(makeMapStateToProps)
+@injectIntl
+class Account extends ImmutablePureComponent {
+
+  static propTypes = {
+    account: ImmutablePropTypes.map.isRequired,
+  };
+
+  render () {
+    const { account } = this.props;
+    return (
+      <div className='account'>
+        <div className='account__wrapper'>
+          <div className='account__display-name'>
+            <div className='account__avatar-wrapper'><Avatar account={account} size={36} /></div>
+            <DisplayName account={account} />
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+}

app/javascript/mastodon/features/antenna_adder/components/antenna.jsx

@@ -0,0 +1,69 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { connect } from 'react-redux';
+import ImmutablePureComponent from 'react-immutable-pure-component';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import IconButton from '../../../components/icon_button';
+import { defineMessages, injectIntl } from 'react-intl';
+import { removeFromAntennaAdder, addToAntennaAdder } from '../../../actions/antennas';
+import Icon from 'mastodon/components/icon';
+
+const messages = defineMessages({
+  remove: { id: 'lists.account.remove', defaultMessage: 'Remove from list' },
+  add: { id: 'lists.account.add', defaultMessage: 'Add to list' },
+});
+
+const MapStateToProps = (state, { antennaId, added }) => ({
+  antenna: state.get('antennas').get(antennaId),
+  added: typeof added === 'undefined' ? state.getIn(['antennaAdder', 'antennas', 'items']).includes(antennaId) : added,
+});
+
+const mapDispatchToProps = (dispatch, { antennaId }) => ({
+  onRemove: () => dispatch(removeFromAntennaAdder(antennaId)),
+  onAdd: () => dispatch(addToAntennaAdder(antennaId)),
+});
+
+export default @connect(MapStateToProps, mapDispatchToProps)
+@injectIntl
+class Antenna extends ImmutablePureComponent {
+
+  static propTypes = {
+    antenna: ImmutablePropTypes.map.isRequired,
+    intl: PropTypes.object.isRequired,
+    onRemove: PropTypes.func.isRequired,
+    onAdd: PropTypes.func.isRequired,
+    added: PropTypes.bool,
+  };
+
+  static defaultProps = {
+    added: false,
+  };
+
+  render () {
+    const { antenna, intl, onRemove, onAdd, added } = this.props;
+
+    let button;
+
+    if (added) {
+      button = <IconButton icon='times' title={intl.formatMessage(messages.remove)} onClick={onRemove} />;
+    } else {
+      button = <IconButton icon='plus' title={intl.formatMessage(messages.add)} onClick={onAdd} />;
+    }
+
+    return (
+      <div className='list'>
+        <div className='list__wrapper'>
+          <div className='list__display-name'>
+            <Icon id='wifi' className='column-link__icon' fixedWidth />
+            {antenna.get('title')}
+          </div>
+
+          <div className='account__relationship'>
+            {button}
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+}

app/javascript/mastodon/features/antenna_adder/index.jsx

@@ -0,0 +1,69 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import ImmutablePropTypes from 'react-immutable-proptypes';
+import { connect } from 'react-redux';
+import ImmutablePureComponent from 'react-immutable-pure-component';
+import { injectIntl } from 'react-intl';
+import { setupAntennaAdder, resetAntennaAdder } from '../../actions/antennas';
+import { createSelector } from 'reselect';
+import Antenna from './components/antenna';
+import Account from './components/account';
+// hack
+
+const getOrderedAntennas = createSelector([state => state.get('antennas')], antennas => {
+  if (!antennas) {
+    return antennas;
+  }
+
+  return antennas.toList().filter(item => !!item).sort((a, b) => a.get('title').localeCompare(b.get('title')));
+});
+
+const mapStateToProps = state => ({
+  antennaIds: getOrderedAntennas(state).map(antenna=>antenna.get('id')),
+});
+
+const mapDispatchToProps = dispatch => ({
+  onInitialize: accountId => dispatch(setupAntennaAdder(accountId)),
+  onReset: () => dispatch(resetAntennaAdder()),
+});
+
+export default @connect(mapStateToProps, mapDispatchToProps)
+@injectIntl
+class AntennaAdder extends ImmutablePureComponent {
+
+  static propTypes = {
+    accountId: PropTypes.string.isRequired,
+    onClose: PropTypes.func.isRequired,
+    intl: PropTypes.object.isRequired,
+    onInitialize: PropTypes.func.isRequired,
+    onReset: PropTypes.func.isRequired,
+    antennaIds: ImmutablePropTypes.list.isRequired,
+  };
+
+  componentDidMount () {
+    const { onInitialize, accountId } = this.props;
+    onInitialize(accountId);
+  }
+
+  componentWillUnmount () {
+    const { onReset } = this.props;
+    onReset();
+  }
+
+  render () {
+    const { accountId, antennaIds } = this.props;
+
+    return (
+      <div className='modal-root__modal list-adder'>
+        <div className='list-adder__account'>
+          <Account accountId={accountId} />
+        </div>
+
+        <div className='list-adder__lists'>
+          {antennaIds.map(AntennaId => <Antenna key={AntennaId} antennaId={AntennaId} />)}
+        </div>
+      </div>
+    );
+  }
+
+}

app/javascript/mastodon/features/ui/components/modal_root.jsx

@@ -20,6 +20,7 @@ import {
   EmbedModal,
   ListEditor,
   ListAdder,
+  AntennaAdder,
   CompareHistoryModal,
   FilterModal,
   InteractionModal,
@@ -43,6 +44,7 @@ const MODAL_COMPONENTS = {
   'LIST_EDITOR': ListEditor,
   'FOCAL_POINT': () => Promise.resolve({ default: FocalPointModal }),
   'LIST_ADDER': ListAdder,
+  'ANTENNA_ADDER': AntennaAdder,
   'COMPARE_HISTORY': CompareHistoryModal,
   'FILTER': FilterModal,
   'SUBSCRIBED_LANGUAGES': SubscribedLanguagesModal,

app/javascript/mastodon/features/ui/util/async-components.js

@@ -150,6 +150,10 @@ export function ListAdder () {
   return import(/*webpackChunkName: "features/list_adder" */'../../list_adder');
 }
 
+export function AntennaAdder () {
+  return import(/*webpackChunkName: "features/antenna_adder" */'../../antenna_adder');
+}
+
 export function Tesseract () {
   return import(/*webpackChunkName: "tesseract" */'tesseract.js');
 }

app/javascript/mastodon/reducers/antenna_adder.js

@@ -0,0 +1,47 @@
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
+import {
+  ANTENNA_ADDER_RESET,
+  ANTENNA_ADDER_SETUP,
+  ANTENNA_ADDER_ANTENNAS_FETCH_REQUEST,
+  ANTENNA_ADDER_ANTENNAS_FETCH_SUCCESS,
+  ANTENNA_ADDER_ANTENNAS_FETCH_FAIL,
+  ANTENNA_EDITOR_ADD_ACCOUNT_SUCCESS,
+  ANTENNA_EDITOR_REMOVE_ACCOUNT_SUCCESS,
+} from '../actions/antennas';
+
+const initialState = ImmutableMap({
+  accountId: null,
+
+  antennas: ImmutableMap({
+    items: ImmutableList(),
+    loaded: false,
+    isLoading: false,
+  }),
+});
+
+export default function antennaAdderReducer(state = initialState, action) {
+  switch(action.type) {
+  case ANTENNA_ADDER_RESET:
+    return initialState;
+  case ANTENNA_ADDER_SETUP:
+    return state.withMutations(map => {
+      map.set('accountId', action.account.get('id'));
+    });
+  case ANTENNA_ADDER_ANTENNAS_FETCH_REQUEST:
+    return state.setIn(['antennas', 'isLoading'], true);
+  case ANTENNA_ADDER_ANTENNAS_FETCH_FAIL:
+    return state.setIn(['antennas', 'isLoading'], false);
+  case ANTENNA_ADDER_ANTENNAS_FETCH_SUCCESS:
+    return state.update('antennas', antennas => antennas.withMutations(map => {
+      map.set('isLoading', false);
+      map.set('loaded', true);
+      map.set('items', ImmutableList(action.antennas.map(item => item.id)));
+    }));
+  case ANTENNA_EDITOR_ADD_ACCOUNT_SUCCESS:
+    return state.updateIn(['antennas', 'items'], antenna => antenna.unshift(action.antennaId));
+  case ANTENNA_EDITOR_REMOVE_ACCOUNT_SUCCESS:
+    return state.updateIn(['antennas', 'items'], antenna => antenna.filterNot(item => item === action.antennaId));
+  default:
+    return state;
+  }
+}

app/javascript/mastodon/reducers/antenna_editor.js

@@ -0,0 +1,36 @@
+import { Map as ImmutableMap, List as ImmutableList } from 'immutable';
+import {
+  ANTENNA_ACCOUNTS_FETCH_REQUEST,
+  ANTENNA_ACCOUNTS_FETCH_SUCCESS,
+  ANTENNA_ACCOUNTS_FETCH_FAIL,
+} from '../actions/antennas';
+
+const initialState = ImmutableMap({
+  antennaId: null,
+  isSubmitting: false,
+  isChanged: false,
+  title: '',
+
+  accounts: ImmutableMap({
+    items: ImmutableList(),
+    loaded: false,
+    isLoading: false,
+  }),
+});
+
+export default function antennaEditorReducer(state = initialState, action) {
+  switch(action.type) {
+  case ANTENNA_ACCOUNTS_FETCH_REQUEST:
+    return state.setIn(['accounts', 'isLoading'], true);
+  case ANTENNA_ACCOUNTS_FETCH_FAIL:
+    return state.setIn(['accounts', 'isLoading'], false);
+  case ANTENNA_ACCOUNTS_FETCH_SUCCESS:
+    return state.update('accounts', accounts => accounts.withMutations(map => {
+      map.set('isLoading', false);
+      map.set('loaded', true);
+      map.set('items', ImmutableList(action.accounts.map(item => item.id)));
+    }));
+  default:
+    return state;
+  }
+}

app/javascript/mastodon/reducers/antennas.js

@@ -0,0 +1,25 @@
+import {
+  ANTENNAS_FETCH_SUCCESS,
+} from '../actions/antennas';
+import { Map as ImmutableMap, fromJS } from 'immutable';
+
+const initialState = ImmutableMap();
+
+const normalizeAntenna = (state, antenna) => state.set(antenna.id, fromJS(antenna));
+
+const normalizeAntennas = (state, antennas) => {
+  antennas.forEach(antenna => {
+    state = normalizeAntenna(state, antenna);
+  });
+
+  return state;
+};
+
+export default function antennas(state = initialState, action) {
+  switch(action.type) {
+  case ANTENNAS_FETCH_SUCCESS:
+    return normalizeAntennas(state, action.antennas);
+  default:
+    return state;
+  }
+}

app/javascript/mastodon/reducers/index.js

@@ -28,6 +28,9 @@ import custom_emojis from './custom_emojis';
 import lists from './lists';
 import listEditor from './list_editor';
 import listAdder from './list_adder';
+import antennas from './antennas';
+import antennaEditor from './antenna_editor';
+import antennaAdder from './antenna_adder';
 import filters from './filters';
 import conversations from './conversations';
 import suggestions from './suggestions';
@@ -74,6 +77,9 @@ const reducers = {
   lists,
   listEditor,
   listAdder,
+  antennas,
+  antennaEditor,
+  antennaAdder,
   filters,
   conversations,
   suggestions,