ref(sendInvitesForItems): convert to action.

react/features/invite/actions.js

 // @flow
 
+import { getInviteURL } from '../base/connection';
+import { inviteVideoRooms } from '../videosipgw';
+
 import {
     BEGIN_ADD_PEOPLE,
     UPDATE_DIAL_IN_NUMBERS_FAILED,
     UPDATE_DIAL_IN_NUMBERS_SUCCESS
 } from './actionTypes';
-import { getDialInConferenceID, getDialInNumbers } from './functions';
+import {
+    getDialInConferenceID,
+    getDialInNumbers,
+    getDigitsOnly,
+    invitePeopleAndChatRooms
+} from './functions';
+
+const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /**
  * Creates a (redux) action to signal that a click/tap has been performed on
             });
     };
 }
+
+/**
+ * Send invites for a list of items (may be a combination of users, rooms, phone
+ * numbers, and video rooms).
+ *
+ * @param  {Array<Object>} invites - Items for which invites should be sent.
+ * @returns {Promise} Promise containing the list of invites that were not sent.
+ */
+export function sendInvitesForItems(invites: Array<Object>) {
+    return (
+            dispatch: Dispatch<*>,
+            getState: Function): Promise<Array<Object>> => {
+        let allInvitePromises = [];
+        let invitesLeftToSend = [ ...invites ];
+        const state = getState();
+        const { conference } = state['features/base/conference'];
+        const { inviteServiceUrl } = state['features/base/config'];
+        const inviteUrl = getInviteURL(state);
+        const jwt = state['features/base/jwt'].jwt;
+
+        // First create all promises for dialing out.
+        if (conference) {
+            const phoneNumbers
+                = invitesLeftToSend.filter(({ type }) => type === 'phone');
+
+            // For each number, dial out. On success, remove the number from
+            // {@link invitesLeftToSend}.
+            const phoneInvitePromises = phoneNumbers.map(item => {
+                const numberToInvite = getDigitsOnly(item.number);
+
+                return conference.dial(numberToInvite)
+                     .then(() => {
+                         invitesLeftToSend
+                             = invitesLeftToSend.filter(invite =>
+                                 invite !== item);
+                     })
+                     .catch(error => logger.error(
+                         'Error inviting phone number:', error));
+            });
+
+            allInvitePromises = allInvitePromises.concat(phoneInvitePromises);
+        }
+
+        const usersAndRooms = invitesLeftToSend.filter(item =>
+            item.type === 'user' || item.type === 'room');
+
+        if (usersAndRooms.length) {
+            // Send a request to invite all the rooms and users. On success,
+            // filter all rooms and users from {@link invitesLeftToSend}.
+            const peopleInvitePromise = invitePeopleAndChatRooms(
+                inviteServiceUrl,
+                inviteUrl,
+                jwt,
+                usersAndRooms)
+                .then(() => {
+                    invitesLeftToSend = invitesLeftToSend.filter(item =>
+                        item.type !== 'user' && item.type !== 'room');
+                })
+                .catch(error => logger.error(
+                    'Error inviting people:', error));
+
+            allInvitePromises.push(peopleInvitePromise);
+        }
+
+        // Sipgw calls are fire and forget. Invite them to the conference
+        // then immediately remove them from {@link invitesLeftToSend}.
+        const vrooms = invitesLeftToSend.filter(item =>
+            item.type === 'videosipgw');
+
+        conference
+            && vrooms.length > 0
+            && dispatch(inviteVideoRooms(conference, vrooms));
+
+        invitesLeftToSend = invitesLeftToSend.filter(item =>
+            item.type !== 'videosipgw');
+
+        return (
+            Promise.all(allInvitePromises)
+                .then(() => invitesLeftToSend)
+        );
+    };
+}

react/features/invite/components/AddPeopleDialog.web.js

 import { connect } from 'react-redux';
 
 import { createInviteDialogEvent, sendAnalytics } from '../../analytics';
-import { getInviteURL } from '../../base/connection';
 import { Dialog, hideDialog } from '../../base/dialog';
 import { translate } from '../../base/i18n';
 import { MultiSelectAutocomplete } from '../../base/react';
-import { inviteVideoRooms } from '../../videosipgw';
 
 import {
-    sendInvitesForItems,
-    getInviteResultsForQuery
+    getInviteResultsForQuery,
+    getInviteTypeCounts
 } from '../functions';
+import { sendInvitesForItems } from '../actions';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
          */
         _dialOutAuthUrl: PropTypes.string,
 
-        /**
-         * The URL pointing to the service allowing for people invite.
-         */
-        _inviteServiceUrl: PropTypes.string,
-
-        /**
-         * The url of the conference to invite people to.
-         */
-        _inviteUrl: PropTypes.string,
-
         /**
          * The JWT token.
          */
         dialOutEnabled: PropTypes.bool,
 
         /**
-         * The function closing the dialog.
-         */
-        hideDialog: PropTypes.func,
-
-        /**
-         * Used to invite video rooms.
+         * The redux dispatch method.
          */
-        inviteVideoRooms: PropTypes.func,
+        dispatch: PropTypes.func,
 
         /**
          * Invoked to obtain translated strings.
         );
     }
 
-    /**
-     * Helper for determining how many of each type of user is being invited.
-     * Used for logging and sending analytics related to invites.
-     *
-     * @param {Array} inviteItems - An array with the invite items, as created
-     * in {@link _parseQueryResults}.
-     * @private
-     * @returns {Object} An object with keys as user types and values as the
-     * number of invites for that type.
-     */
-    _getInviteTypeCounts(inviteItems = []) {
-        const inviteTypeCounts = {};
-
-        inviteItems.forEach(i => {
-            const type = i.item.type;
-
-            if (!inviteTypeCounts[type]) {
-                inviteTypeCounts[type] = 0;
-            }
-
-            inviteTypeCounts[type]++;
-        });
-
-        return inviteTypeCounts;
-    }
-
     _isAddDisabled: () => boolean;
 
     /**
      * @returns {void}
      */
     _onSubmit() {
-        const inviteTypeCounts
-            = this._getInviteTypeCounts(this.state.inviteItems);
+        const { inviteItems } = this.state;
+        const items = inviteItems.map(item => item.item);
+        const inviteTypeCounts = getInviteTypeCounts(items);
 
         sendAnalytics(createInviteDialogEvent(
             'clicked', 'inviteButton', {
             addToCallInProgress: true
         });
 
-        const {
-            _conference,
-            _inviteServiceUrl,
-            _inviteUrl,
-            _jwt
-        } = this.props;
-
-        const inviteItems = this.state.inviteItems;
-        const items = inviteItems.map(item => item.item);
-
-        const options = {
-            conference: _conference,
-            inviteServiceUrl: _inviteServiceUrl,
-            inviteUrl: _inviteUrl,
-            inviteVideoRooms: this.props.inviteVideoRooms,
-            jwt: _jwt
-        };
+        const { dispatch } = this.props;
 
-        sendInvitesForItems(items, options)
+        dispatch(sendInvitesForItems(items))
             .then(invitesLeftToSend => {
                 // If any invites are left that means something failed to send
                 // so treat it as an error.
                 if (invitesLeftToSend.length) {
                     const erroredInviteTypeCounts
-                        = this._getInviteTypeCounts(invitesLeftToSend);
+                        = getInviteTypeCounts(invitesLeftToSend);
 
                     logger.error(`${invitesLeftToSend.length} invites failed`,
                         erroredInviteTypeCounts);
                     addToCallInProgress: false
                 });
 
-                this.props.hideDialog();
+                dispatch(hideDialog());
             });
     }
 
  * @param {Object} state - The Redux state.
  * @private
  * @returns {{
- *     _conference: Object,
  *     _dialOutAuthUrl: string,
- *     _inviteServiceUrl: string,
- *     _inviteUrl: string,
  *     _jwt: string,
  *     _peopleSearchQueryTypes: Array<string>,
  *     _peopleSearchUrl: string
  * }}
  */
 function _mapStateToProps(state) {
-    const { conference } = state['features/base/conference'];
     const {
         dialOutAuthUrl,
-        inviteServiceUrl,
         peopleSearchQueryTypes,
         peopleSearchUrl
     } = state['features/base/config'];
 
     return {
-        _conference: conference,
         _dialOutAuthUrl: dialOutAuthUrl,
-        _inviteServiceUrl: inviteServiceUrl,
-        _inviteUrl: getInviteURL(state),
         _jwt: state['features/base/jwt'].jwt,
         _peopleSearchQueryTypes: peopleSearchQueryTypes,
         _peopleSearchUrl: peopleSearchUrl
     };
 }
 
-export default translate(
-    connect(
-            _mapStateToProps,
-            /* mapDispatchToProps */ {
-                hideDialog,
-                inviteVideoRooms
-            })(
-        AddPeopleDialog));
+export default translate(connect(_mapStateToProps)(AddPeopleDialog));

react/features/invite/functions.js

  * @private
  * @returns {string} A string with only numbers.
  */
-function getDigitsOnly(text: string = ''): string {
+export function getDigitsOnly(text: string = ''): string {
     return text.replace(/\D/g, '');
 }
 
  * type items to invite.
  * @returns {Promise} - The promise created by the request.
  */
-function invitePeopleAndChatRooms( // eslint-disable-line max-params
+export function invitePeopleAndChatRooms( // eslint-disable-line max-params
         inviteServiceUrl: string,
         inviteUrl: string,
         jwt: string,
 }
 
 /**
- * Type of the options to use when sending invites.
- */
-export type SendInvitesOptions = {
-
-    /**
-     * Conference object used to dial out.
-     */
-    conference: Object,
-
-    /**
-     * The URL to send invites through.
-     */
-    inviteServiceUrl: string,
-
-    /**
-     * The URL sent with each invite.
-     */
-    inviteUrl: string,
-
-    /**
-     * The function to use to invite video rooms.
-     *
-     * @param  {Object} The conference to which the video rooms should be
-     * invited.
-     * @param  {Array<Object>} The list of rooms that should be invited.
-     * @returns {void}
-     */
-    inviteVideoRooms: (Object, Array<Object>) => void,
-
-    /**
-     * The jwt token to pass to the invite service.
-     */
-    jwt: string
-};
-
-/**
- * Send invites for a list of items (may be a combination of users, rooms, phone
- * numbers, and video rooms).
+ * Helper for determining how many of each type of user is being invited.
+ * Used for logging and sending analytics related to invites.
  *
- * @param  {Array<Object>} invites - Items for which invites should be sent.
- * @param  {SendInvitesOptions} options - Options to use when sending the
- * provided invites.
- * @returns {Promise} Promise containing the list of invites that were not sent.
+ * @param {Array} inviteItems - An array with the invite items, as created
+ * in {@link _parseQueryResults}.
+ * @private
+ * @returns {Object} An object with keys as user types and values as the
+ * number of invites for that type.
  */
-export function sendInvitesForItems(
-        invites: Array<Object>,
-        options: SendInvitesOptions
-): Promise<Array<Object>> {
-
-    const {
-        conference,
-        inviteServiceUrl,
-        inviteUrl,
-        inviteVideoRooms,
-        jwt
-    } = options;
-
-    let allInvitePromises = [];
-    let invitesLeftToSend = [ ...invites ];
+export function getInviteTypeCounts(inviteItems: Array<Object> = []) {
+    const inviteTypeCounts = {};
 
-    // First create all promises for dialing out.
-    if (conference) {
-        const phoneNumbers = invitesLeftToSend.filter(
-            item => item.type === 'phone');
+    inviteItems.forEach(({ type }) => {
 
-        // For each number, dial out. On success, remove the number from
-        // {@link invitesLeftToSend}.
-        const phoneInvitePromises = phoneNumbers.map(item => {
-            const numberToInvite = getDigitsOnly(item.number);
-
-            return conference.dial(numberToInvite)
-                    .then(() => {
-                        invitesLeftToSend
-                            = invitesLeftToSend.filter(invite =>
-                                invite !== item);
-                    })
-                    .catch(error => logger.error(
-                        'Error inviting phone number:', error));
-
-        });
-
-        allInvitePromises = allInvitePromises.concat(phoneInvitePromises);
-    }
-
-    const usersAndRooms = invitesLeftToSend.filter(item =>
-        item.type === 'user' || item.type === 'room');
-
-    if (usersAndRooms.length) {
-        // Send a request to invite all the rooms and users. On success,
-        // filter all rooms and users from {@link invitesLeftToSend}.
-        const peopleInvitePromise = invitePeopleAndChatRooms(
-            inviteServiceUrl,
-            inviteUrl,
-            jwt,
-            usersAndRooms)
-            .then(() => {
-                invitesLeftToSend = invitesLeftToSend.filter(item =>
-                    item.type !== 'user' && item.type !== 'room');
-            })
-            .catch(error => logger.error(
-                'Error inviting people:', error));
-
-        allInvitePromises.push(peopleInvitePromise);
-    }
-
-    // Sipgw calls are fire and forget. Invite them to the conference
-    // then immediately remove them from {@link invitesLeftToSend}.
-    const vrooms = invitesLeftToSend.filter(item =>
-        item.type === 'videosipgw');
-
-    conference
-        && vrooms.length > 0
-        && inviteVideoRooms(conference, vrooms);
+        if (!inviteTypeCounts[type]) {
+            inviteTypeCounts[type] = 0;
+        }
 
-    invitesLeftToSend = invitesLeftToSend.filter(item =>
-        item.type !== 'videosipgw');
+        inviteTypeCounts[type]++;
+    });
 
-    return Promise.all(allInvitePromises)
-        .then(() => invitesLeftToSend);
+    return inviteTypeCounts;
 }

react/features/invite/middleware.native.js

 
 import { MiddlewareRegistry } from '../base/redux';
 import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from '../app';
-import { getInviteURL } from '../base/connection';
-import { inviteVideoRooms } from '../videosipgw';
 
 import {
     BEGIN_ADD_PEOPLE,
 import {
     getInviteResultsForQuery,
     isAddPeopleEnabled,
-    isDialOutEnabled,
-    sendInvitesForItems
+    isDialOutEnabled
 } from './functions';
+import { sendInvitesForItems } from './actions';
 import './middleware.any';
 
 /**
  */
 function _onInvite(
         { addPeopleControllerScope, externalAPIScope, invitees }) {
-    const { getState } = this; // eslint-disable-line no-invalid-this
-    const state = getState();
+    const { dispatch, getState } = this; // eslint-disable-line no-invalid-this
 
     // If there are multiple JitsiMeetView instances alive, they will all get
     // the event, since there is a single bridge, so make sure we don't act if
     // the event is not for us.
-    if (state['features/app'].app.props.externalAPIScope !== externalAPIScope) {
+    if (getState()['features/app'].app.props.externalAPIScope
+            !== externalAPIScope) {
         return;
     }
 
-    const { conference } = state['features/base/conference'];
-    const { inviteServiceUrl } = state['features/base/config'];
-    const options = {
-        conference,
-        inviteServiceUrl,
-        inviteUrl: getInviteURL(state),
-        inviteVideoRooms,
-        jwt: state['features/base/jwt'].jwt
-    };
-
-    sendInvitesForItems(invitees, options)
+    dispatch(sendInvitesForItems(invitees))
         .then(failedInvitees =>
             Invite.inviteSettled(
                 externalAPIScope,