Send feedback metadata to JaaS feedback endpoint

conference.js

         return room && room.isCallstatsEnabled();
     },
 
-    /**
-     * Sends the given feedback through CallStats if enabled.
-     *
-     * @param overallFeedback an integer between 1 and 5 indicating the
-     * user feedback
-     * @param detailedFeedback detailed feedback from the user. Not yet used
-     */
-    sendFeedback(overallFeedback, detailedFeedback) {
-        return room.sendFeedback(overallFeedback, detailedFeedback);
-    },
-
     /**
      * Get speaker stats that track total dominant speaker time.
      *
             requestFeedbackPromise = Promise.resolve(true);
         }
 
-        // All promises are returning Promise.resolve to make Promise.all to
-        // be resolved when both Promises are finished. Otherwise Promise.all
-        // will reject on first rejected Promise and we can redirect the page
-        // before all operations are done.
-        Promise.all([
-            requestFeedbackPromise,
-            this.leaveRoomAndDisconnect()
-        ]).then(values => {
+        let feedbackResult;
+
+        requestFeedbackPromise
+        .then(res => {
+            feedbackResult = res;
+
+            return this.leaveRoomAndDisconnect();
+        })
+        .then(() => {
             this._room = undefined;
             room = undefined;
 
             if (!interfaceConfig.SHOW_PROMOTIONAL_CLOSE_PAGE) {
                 APP.API.notifyReadyToClose();
             }
-            APP.store.dispatch(maybeRedirectToWelcomePage(values[0]));
+            APP.store.dispatch(maybeRedirectToWelcomePage(feedbackResult));
         });
     },
 

react/features/base/jwt/middleware.js

             }
 
             if (jwtPayload) {
-                const { context, iss } = jwtPayload;
+                const { context, iss, sub } = jwtPayload;
 
                 action.jwt = jwt;
                 action.issuer = iss;
                     action.callee = context.callee;
                     action.group = context.group;
                     action.server = context.server;
-                    action.tenant = context.tenant;
+                    action.tenant = context.tenant || sub || undefined;
                     action.user = user;
 
                     user && _overwriteLocalParticipant(

react/features/feedback/actions.js

 
 import { FEEDBACK_REQUEST_IN_PROGRESS } from '../../../modules/UI/UIErrors';
 import { openDialog } from '../base/dialog';
+import { isVpaasMeeting } from '../billing-counter/functions';
+import { extractFqnFromPath } from '../dynamic-branding/functions';
 
 import {
     CANCEL_FEEDBACK,
     SUBMIT_FEEDBACK_SUCCESS
 } from './actionTypes';
 import { FeedbackDialog } from './components';
+import { sendFeedbackToJaaSRequest } from './functions';
 
 declare var config: Object;
-declare var interfaceConfig: Object;
 
 /**
  * Caches the passed in feedback in the redux store.
     });
 }
 
+/**
+ * Sends feedback metadata to JaaS endpoint.
+ *
+ * @param {JitsiConference} conference - The JitsiConference that is being rated.
+ * @param {Object} feedback - The feedback message and score.
+ *
+ * @returns {Promise}
+ */
+export function sendJaasFeedbackMetadata(conference: Object, feedback: Object) {
+    return (dispatch: Dispatch<any>, getState: Function): Promise<any> => {
+        const state = getState();
+        const { jaasFeedbackMetadataURL } = state['features/base/config'];
+
+        const { jwt, user, tenant } = state['features/base/jwt'];
+
+        if (!isVpaasMeeting(state) || !jaasFeedbackMetadataURL) {
+            return Promise.resolve();
+        }
+
+        const meetingFqn = extractFqnFromPath(state['features/base/connection'].locationURL.pathname);
+        const feedbackData = {
+            ...feedback,
+            sessionId: conference.getMeetingUniqueId(),
+            userId: user.id,
+            meetingFqn,
+            jwt,
+            tenant
+        };
+
+        return sendFeedbackToJaaSRequest(jaasFeedbackMetadataURL, feedbackData);
+    };
+}
+
 /**
  * Send the passed in feedback.
  *
         score: number,
         message: string,
         conference: Object) {
-    return (dispatch: Dispatch<any>) => conference.sendFeedback(score, message)
-        .then(
-            () => dispatch({ type: SUBMIT_FEEDBACK_SUCCESS }),
-            error => {
-                dispatch({
-                    type: SUBMIT_FEEDBACK_ERROR,
-                    error
-                });
-
-                return Promise.reject(error);
-            }
-        );
+    return (dispatch: Dispatch<any>) =>
+        conference.sendFeedback(score, message)
+        .then(() => dispatch({ type: SUBMIT_FEEDBACK_SUCCESS }))
+        .then(() => dispatch(sendJaasFeedbackMetadata(conference, { score,
+            message }))
+        .catch(error => {
+            dispatch({
+                type: SUBMIT_FEEDBACK_ERROR,
+                error
+            });
+
+            return Promise.reject(error);
+        }));
 }

react/features/feedback/functions.js

+// @flow
+
+import logger from './logger';
+
+/**
+ * Sends feedback metadata to JaaS endpoints.
+ *
+ * @param {string} url - The JaaS metadata endpoint URL.
+ * @param {Object} feedbackData - The feedback data object.
+ * @returns {Promise}
+ */
+export async function sendFeedbackToJaaSRequest(url: string, feedbackData: Object) {
+    const {
+        jwt,
+        sessionId,
+        meetingFqn,
+        score,
+        message,
+        userId,
+        tenant
+    } = feedbackData;
+    const headers = {
+        'Authorization': `Bearer ${jwt}`,
+        'Content-Type': 'application/json'
+    };
+    const data = {
+        sessionId,
+        meetingFqn,
+        userId,
+        tenant,
+        submitted: new Date().getTime(),
+        rating: score,
+        comments: message
+    };
+
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(data)
+        });
+
+        if (!res.ok) {
+            logger.error('Status error:', res.status);
+        }
+    } catch (err) {
+        logger.error('Could not send request', err);
+    }
+}
+

react/features/feedback/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/feedback');