remoting/webapp/crd/js/legacy_host_list_api.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @fileoverview
   7  * REST API for host-list management.
   8  */
   9
  10 /** @suppress {duplicate} */
  11 var remoting = remoting || {};
  12
  13 (function() {
  14
  15 'use strict';
  16
  17 /**
  18  * @constructor
  19  * @implements {remoting.HostListApi}
  20  */
  21 remoting.LegacyHostListApi = function() {
  22 };
  23
  24 /** @override */
  25 remoting.LegacyHostListApi.prototype.register = function(
  26     hostName, publicKey, hostClientId) {
  27   var newHostId = base.generateUuid();
  28   return remoting.LegacyHostListApi.registerWithHostId(
  29       newHostId, hostName, publicKey, hostClientId);
  30 };
  31
  32 /**
  33  * Registers a host with the Chromoting directory using a specified
  34  * host ID, which should not be equal to the ID of any existing host.
  35  *
  36  * @param {string} newHostId The host ID of the new host.
  37  * @param {string} hostName The user-visible name of the new host.
  38  * @param {string} publicKey The public half of the host's key pair.
  39  * @param {?string} hostClientId The OAuth2 client ID of the host.
  40  * @return {!Promise<remoting.HostListApi.RegisterResult>}
  41  */
  42 remoting.LegacyHostListApi.registerWithHostId = function(
  43     newHostId, hostName, publicKey, hostClientId) {
  44   var newHostDetails = { data: {
  45     hostId: newHostId,
  46     hostName: hostName,
  47     publicKey: publicKey
  48   } };
  49
  50   return new remoting.Xhr({
  51     method: 'POST',
  52     url: remoting.settings.DIRECTORY_API_BASE_URL + '/@me/hosts',
  53     urlParams: {
  54       hostClientId: hostClientId
  55     },
  56     jsonContent: newHostDetails,
  57     acceptJson: true,
  58     useIdentity: true
  59   }).start().then(function(response) {
  60     if (response.status == 200) {
  61       var result = /** @type {!Object} */ (response.getJson());
  62       var data = base.getObjectAttr(result, 'data');
  63       var authCode = hostClientId ?
  64           base.getStringAttr(data, 'authorizationCode') :
  65           '';
  66       return {
  67         authCode: authCode,
  68         email: '',
  69         hostId: newHostId
  70       };
  71     } else {
  72       console.log(
  73           'Failed to register the host. Status: ' + response.status +
  74           ' response: ' + response.getText());
  75       throw new remoting.Error(remoting.Error.Tag.REGISTRATION_FAILED);
  76     }
  77   });
  78 };
  79
  80 /** @override */
  81 remoting.LegacyHostListApi.prototype.get = function() {
  82   var that = this;
  83   return new remoting.Xhr({
  84     method: 'GET',
  85     url: remoting.settings.DIRECTORY_API_BASE_URL + '/@me/hosts',
  86     useIdentity: true
  87   }).start().then(function(/** !remoting.Xhr.Response */ response) {
  88     return that.parseHostListResponse_(response);
  89   });
  90 };
  91
  92 /** @override */
  93 remoting.LegacyHostListApi.prototype.put =
  94     function(hostId, hostName, hostPublicKey) {
  95   return new remoting.Xhr({
  96     method: 'PUT',
  97     url: remoting.settings.DIRECTORY_API_BASE_URL + '/@me/hosts/' + hostId,
  98     jsonContent: {
  99       'data': {
 100         'hostId': hostId,
 101         'hostName': hostName,
 102         'publicKey': hostPublicKey
 103       }
 104     },
 105     useIdentity: true
 106   }).start().then(remoting.LegacyHostListApi.defaultResponse_());
 107 };
 108
 109 /** @override */
 110 remoting.LegacyHostListApi.prototype.remove = function(hostId) {
 111   return new remoting.Xhr({
 112     method: 'DELETE',
 113     url: remoting.settings.DIRECTORY_API_BASE_URL + '/@me/hosts/' + hostId,
 114     useIdentity: true
 115   }).start().then(remoting.LegacyHostListApi.defaultResponse_(
 116       [remoting.Error.Tag.NOT_FOUND]));
 117 };
 118
 119 /**
 120  * Handle the results of the host list request.  A success response will
 121  * include a JSON-encoded list of host descriptions, which is parsed and
 122  * passed to the callback.
 123  *
 124  * @param {!remoting.Xhr.Response} response
 125  * @return {!Array<!remoting.Host>}
 126  * @private
 127  */
 128 remoting.LegacyHostListApi.prototype.parseHostListResponse_ =
 129     function(response) {
 130   if (response.status == 200) {
 131     var obj = /** @type {{data: {items: Array}}} */
 132         (base.jsonParseSafe(response.getText()));
 133     if (!obj || !obj.data) {
 134       console.error('Invalid "hosts" response from server.');
 135       throw remoting.Error.unexpected();
 136     } else {
 137       var items = obj.data.items || [];
 138       var hosts = items.map(
 139         function(/** Object */ item) {
 140           var host = new remoting.Host(base.getStringAttr(item, 'hostId', ''));
 141           host.hostName = base.getStringAttr(item, 'hostName', '');
 142           host.status = base.getStringAttr(item, 'status', '');
 143           host.jabberId = base.getStringAttr(item, 'jabberId', '');
 144           host.publicKey = base.getStringAttr(item, 'publicKey', '');
 145           host.hostVersion = base.getStringAttr(item, 'hostVersion', '');
 146           host.tokenUrlPatterns =
 147               base.getArrayAttr(item, 'tokenUrlPatterns', []);
 148           host.updatedTime = base.getStringAttr(item, 'updatedTime', '');
 149           host.hostOfflineReason =
 150               base.getStringAttr(item, 'hostOfflineReason', '');
 151           host.loggingChannel =
 152               base.getStringAttr(item, 'loggingChannel', 'XMPP');
 153           return host;
 154       });
 155       return hosts;
 156     }
 157   } else {
 158     throw remoting.Error.fromHttpStatus(response.status);
 159   }
 160 };
 161
 162 /**
 163  * Generic success/failure response proxy.
 164  *
 165  * @param {Array<remoting.Error.Tag>=} opt_ignoreErrors
 166  * @return {function(!remoting.Xhr.Response):void}
 167  * @private
 168  */
 169 remoting.LegacyHostListApi.defaultResponse_ = function(opt_ignoreErrors) {
 170   /** @param {!remoting.Xhr.Response} response */
 171   var result = function(response) {
 172     var error = remoting.Error.fromHttpStatus(response.status);
 173     if (error.isNone()) {
 174       return;
 175     }
 176
 177     if (opt_ignoreErrors && error.hasTag.apply(error, opt_ignoreErrors)) {
 178       return;
 179     }
 180
 181     throw error;
 182   };
 183   return result;
 184 };
 185
 186 /** @override */
 187 remoting.LegacyHostListApi.prototype.getSupportHost = function(supportId) {
 188   return new remoting.Xhr({
 189     method: 'GET',
 190     url: remoting.settings.DIRECTORY_API_BASE_URL + '/support-hosts/' +
 191         encodeURIComponent(supportId),
 192     useIdentity: true
 193   }).start().then(function(xhrResponse) {
 194     if (xhrResponse.status == 200) {
 195       var response =
 196           /** @type {{data: {jabberId: string, publicKey: string}}} */
 197           (base.jsonParseSafe(xhrResponse.getText()));
 198       if (response && response.data &&
 199           response.data.jabberId && response.data.publicKey) {
 200         var host = new remoting.Host(supportId);
 201         host.jabberId = base.getStringAttr(response.data, 'jabberId', '');
 202         host.publicKey = base.getStringAttr(response.data, 'publicKey', '');
 203         host.hostName = host.jabberId.split('/')[0];
 204         host.loggingChannel =
 205               base.getStringAttr(response.data, 'loggingChannel', 'XMPP');
 206         return host;
 207       } else {
 208         console.error('Invalid "support-hosts" response from server.');
 209         throw remoting.Error.unexpected();
 210       }
 211     } else if (xhrResponse.status == 404) {
 212       throw new remoting.Error(remoting.Error.Tag.INVALID_ACCESS_CODE);
 213     } else {
 214       throw remoting.Error.fromHttpStatus(xhrResponse.status);
 215     }
 216   });
 217 };
 218
 219 })();