ToS for ISes/IMs: prompt on use screen

res/css/_components.scss

@@ -70,6 +70,7 @@
 @import "./views/dialogs/_SetPasswordDialog.scss";
 @import "./views/dialogs/_SettingsDialog.scss";
 @import "./views/dialogs/_ShareDialog.scss";
+@import "./views/dialogs/_TermsDialog.scss";
 @import "./views/dialogs/_UnknownDeviceDialog.scss";
 @import "./views/dialogs/_UploadConfirmDialog.scss";
 @import "./views/dialogs/_UserSettingsDialog.scss";

res/css/views/dialogs/_TermsDialog.scss

@@ -0,0 +1,35 @@
+/*
+Copyright 2019 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+.mx_TermsDialog_termsTableHeader {
+    font-weight: bold;
+    text-align: left;
+}
+
+.mx_TermsDialog_termsTable {
+    font-size: 12px;
+}
+
+.mx_TermsDialog_service, .mx_TermsDialog_summary {
+    padding-right: 10px;
+}
+
+.mx_TermsDialog_link {
+    mask-image: url('$(res)/img/external-link.svg');
+    background-color: $accent-color;
+    width: 10px;
+    height: 10px;
+}

src/FromWidgetPostMessageApi.js

@@ -19,10 +19,9 @@ import URL from 'url';
 import dis from './dispatcher';
 import WidgetMessagingEndpoint from './WidgetMessagingEndpoint';
 import ActiveWidgetStore from './stores/ActiveWidgetStore';
-import sdk from "./index";
-import Modal from "./Modal";
 import MatrixClientPeg from "./MatrixClientPeg";
 import RoomViewStore from "./stores/RoomViewStore";
+import { showIntegrationsManager } from './integrations/integrations';
 
 const WIDGET_API_VERSION = '0.0.2'; // Current API version
 const SUPPORTED_WIDGET_API_VERSIONS = [
@@ -193,13 +192,11 @@ export default class FromWidgetPostMessageApi {
             const integType = (data && data.integType) ? data.integType : null;
             const integId = (data && data.integId) ? data.integId : null;
 
-            // The dialog will take care of scalar auth for us
-            const IntegrationsManager = sdk.getComponent("views.settings.IntegrationsManager");
-            Modal.createTrackedDialog('Integrations Manager', '', IntegrationsManager, {
+            showIntegrationsManager({
                 room: MatrixClientPeg.get().getRoom(RoomViewStore.getRoomId()),
                 screen: 'type_' + integType,
                 integrationId: integId,
-            }, "mx_IntegrationsManager");
+            });
         } else if (action === 'set_always_on_screen') {
             // This is a new message: there is no reason to support the deprecated widgetData here
             const data = event.data.data;

src/ScalarAuthClient.js

@@ -1,5 +1,6 @@
 /*
 Copyright 2016 OpenMarket Ltd
+Copyright 2019 The Matrix.org Foundation C.I.C.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -16,11 +17,14 @@ limitations under the License.
 
 import Promise from 'bluebird';
 import SettingsStore from "./settings/SettingsStore";
+import { Service, presentTermsForServices, TermsNotSignedError } from './Terms';
 const request = require('browser-request');
 
 const SdkConfig = require('./SdkConfig');
 const MatrixClientPeg = require('./MatrixClientPeg');
 
+import * as Matrix from 'matrix-js-sdk';
+
 // The version of the integration manager API we're intending to work with
 const imApiVersion = "1.1";
 
@@ -55,23 +59,11 @@ class ScalarAuthClient {
         if (!token) {
             return this.registerForToken();
         } else {
-            return this.validateToken(token).then(userId => {
-                const me = MatrixClientPeg.get().getUserId();
-                if (userId !== me) {
-                    throw new Error("Scalar token is owned by someone else: " + me);
-                }
-                return token;
-            }).catch(err => {
-                console.error(err);
-
-                // Something went wrong - try to get a new token.
-                console.warn("Registering for new scalar token");
-                return this.registerForToken();
-            });
+            return this._checkToken(token);
         }
     }
 
-    validateToken(token) {
+    _getAccountName(token) {
         const url = SdkConfig.get().integrations_rest_url + "/account";
 
         return new Promise(function(resolve, reject) {
@@ -83,8 +75,10 @@ class ScalarAuthClient {
             }, (err, response, body) => {
                 if (err) {
                     reject(err);
+                } else if (body && body.errcode === 'M_TERMS_NOT_SIGNED') {
+                    reject(new TermsNotSignedError());
                 } else if (response.statusCode / 100 !== 2) {
-                    reject({statusCode: response.statusCode});
+                    reject(body);
                 } else if (!body || !body.user_id) {
                     reject(new Error("Missing user_id in response"));
                 } else {
@@ -94,11 +88,35 @@ class ScalarAuthClient {
         });
     }
 
+    _checkToken(token) {
+        return this._getAccountName(token).then(userId => {
+            const me = MatrixClientPeg.get().getUserId();
+            if (userId !== me) {
+                throw new Error("Scalar token is owned by someone else: " + me);
+            }
+            return token;
+        }).catch((e) => {
+            if (e instanceof TermsNotSignedError) {
+                console.log("Integrations manager requires new terms to be agreed to");
+                return presentTermsForServices([new Service(
+                    Matrix.SERVICE_TYPES.IM,
+                    SdkConfig.get().integrations_rest_url,
+                    token,
+                )]).then(() => {
+                    return token;
+                });
+            }
+        });
+    }
+
     registerForToken() {
         // Get openid bearer token from the HS as the first part of our dance
         return MatrixClientPeg.get().getOpenIdToken().then((tokenObject) => {
             // Now we can send that to scalar and exchange it for a scalar token
             return this.exchangeForScalarToken(tokenObject);
+        }).then((tokenObject) => {
+            // Validate it (this mostly checks to see if the IM needs us to agree to some terms)
+            return this._checkToken(tokenObject);
         }).then((tokenObject) => {
             window.localStorage.setItem("mx_scalar_token", tokenObject);
             return tokenObject;

src/Terms.js

@@ -0,0 +1,109 @@
+/*
+Copyright 2019 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import Promise from 'bluebird';
+
+import MatrixClientPeg from './MatrixClientPeg';
+import sdk from './';
+import Modal from './Modal';
+
+export class TermsNotSignedError extends Error {}
+
+/**
+ * Class representing a service that may have terms & conditions that
+ * require agreement fro mthe user before the user can use that service.
+ */
+export class Service {
+    /**
+     * @param {MatrixClient.SERVICE_TYPES} serviceType The type of service
+     * @param {string} baseUrl The Base URL of the service (ie. before '/_matrix')
+     * @param {string} accessToken The user's access token for the service
+     */
+    constructor(serviceType, baseUrl, accessToken) {
+        this.serviceType = serviceType;
+        this.baseUrl = baseUrl;
+        this.accessToken = accessToken;
+    }
+}
+
+/**
+ * Present a popup to the user prompting them to agree to terms and conditions
+ *
+ * @param {Service[]} services Object with keys 'servicetype', 'baseurl', '
+ * @param {function} dialogTermsInteractionCallback Function called with an array of:
+ *     { service: {Service}, terms: {terms response from API} }
+ *     Must return a Promise which resolves with a list of URLs of documents agreed to
+ * @returns {Promise} resolves when the user agreed to all necessary terms or rejects
+ *     if they cancel.
+ */
+export function presentTermsForServices(services) {
+    return startTermsFlow(services, dialogTermsInteractionCallback);
+}
+
+export async function startTermsFlow(services, interactionCallback) {
+    const termsPromises = services.map(
+        (s) => MatrixClientPeg.get().getTerms(s.serviceType, s.baseUrl, s.accessToken),
+    );
+
+    const terms = await Promise.all(termsPromises);
+    const termsAndServices = terms.map((t, i) => { return { 'service': services[i], 'terms': t.policies }; });
+
+    const agreedUrls = await interactionCallback(termsAndServices);
+    console.log("User has agreed to URLs", agreedUrls);
+
+    const agreePromises = termsAndServices.map((termsAndService) => {
+        // filter the agreed URL list for ones that are actually for this service
+        // (one URL may be used for multiple services)
+        // Not a particularly efficient loop but probably fine given the numbers involved
+        const urlsForService = agreedUrls.filter((url) => {
+            for (const terms of Object.values(termsAndService.terms)) {
+                for (const lang of Object.keys(terms)) {
+                    if (lang === 'version') continue;
+                    if (terms[lang].url === url) return true;
+                }
+            }
+            return false;
+        });
+
+        if (urlsForService.length === 0) return Promise.resolve();
+
+        return MatrixClientPeg.get().agreeToTerms(
+            termsAndService.service.serviceType,
+            termsAndService.service.baseUrl,
+            termsAndService.service.accessToken,
+            urlsForService,
+        );
+    });
+    return Promise.all(agreePromises);
+}
+
+function dialogTermsInteractionCallback(termsWithServices) {
+    return new Promise((resolve, reject) => {
+        console.log("Terms that need agreement", termsWithServices);
+        const TermsDialog = sdk.getComponent("views.dialogs.TermsDialog");
+
+        Modal.createTrackedDialog('Terms of Service', '', TermsDialog, {
+            termsWithServices: termsWithServices,
+            onFinished: (done, agreedUrls) => {
+                if (!done) {
+                    reject(new TermsNotSignedError());
+                    return;
+                }
+                resolve(agreedUrls);
+            },
+        });
+    });
+}