| /** |
| * @license |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * 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. |
| */ |
| (function() { |
| 'use strict'; |
| |
| const Defs = {}; |
| |
| /** |
| * @typedef {{ |
| * basePatchNum: (string|number), |
| * patchNum: (number), |
| * }} |
| */ |
| Defs.patchRange; |
| |
| /** |
| * @typedef {{ |
| * url: string, |
| * fetchOptions: (Object|null|undefined), |
| * anonymizedUrl: (string|undefined), |
| * }} |
| */ |
| Defs.FetchRequest; |
| |
| /** |
| * Object to describe a request for passing into _fetchJSON or _fetchRawJSON. |
| * - url is the URL for the request (excluding get params) |
| * - errFn is a function to invoke when the request fails. |
| * - cancelCondition is a function that, if provided and returns true, will |
| * cancel the response after it resolves. |
| * - params is a key-value hash to specify get params for the request URL. |
| * @typedef {{ |
| * url: string, |
| * errFn: (function(?Response, string=)|null|undefined), |
| * cancelCondition: (function()|null|undefined), |
| * params: (Object|null|undefined), |
| * fetchOptions: (Object|null|undefined), |
| * anonymizedUrl: (string|undefined), |
| * reportUrlAsIs: (boolean|undefined), |
| * }} |
| */ |
| Defs.FetchJSONRequest; |
| |
| /** |
| * @typedef {{ |
| * changeNum: (string|number), |
| * endpoint: string, |
| * patchNum: (string|number|null|undefined), |
| * errFn: (function(?Response, string=)|null|undefined), |
| * params: (Object|null|undefined), |
| * fetchOptions: (Object|null|undefined), |
| * anonymizedEndpoint: (string|undefined), |
| * reportEndpointAsIs: (boolean|undefined), |
| * }} |
| */ |
| Defs.ChangeFetchRequest; |
| |
| /** |
| * Object to describe a request for passing into _send. |
| * - method is the HTTP method to use in the request. |
| * - url is the URL for the request |
| * - body is a request payload. |
| * TODO (beckysiegel) remove need for number at least. |
| * - errFn is a function to invoke when the request fails. |
| * - cancelCondition is a function that, if provided and returns true, will |
| * cancel the response after it resolves. |
| * - contentType is the content type of the body. |
| * - headers is a key-value hash to describe HTTP headers for the request. |
| * - parseResponse states whether the result should be parsed as a JSON |
| * object using getResponseObject. |
| * @typedef {{ |
| * method: string, |
| * url: string, |
| * body: (string|number|Object|null|undefined), |
| * errFn: (function(?Response, string=)|null|undefined), |
| * contentType: (string|null|undefined), |
| * headers: (Object|undefined), |
| * parseResponse: (boolean|undefined), |
| * anonymizedUrl: (string|undefined), |
| * reportUrlAsIs: (boolean|undefined), |
| * }} |
| */ |
| Defs.SendRequest; |
| |
| /** |
| * @typedef {{ |
| * changeNum: (string|number), |
| * method: string, |
| * patchNum: (string|number|undefined), |
| * endpoint: string, |
| * body: (string|number|Object|null|undefined), |
| * errFn: (function(?Response, string=)|null|undefined), |
| * contentType: (string|null|undefined), |
| * headers: (Object|undefined), |
| * parseResponse: (boolean|undefined), |
| * anonymizedEndpoint: (string|undefined), |
| * reportEndpointAsIs: (boolean|undefined), |
| * }} |
| */ |
| Defs.ChangeSendRequest; |
| |
| const DiffViewMode = { |
| SIDE_BY_SIDE: 'SIDE_BY_SIDE', |
| UNIFIED: 'UNIFIED_DIFF', |
| }; |
| const JSON_PREFIX = ')]}\''; |
| const MAX_PROJECT_RESULTS = 25; |
| const MAX_UNIFIED_DEFAULT_WINDOW_WIDTH_PX = 900; |
| const PARENT_PATCH_NUM = 'PARENT'; |
| const FAILED_TO_FETCH_ERROR = 'Failed to fetch'; |
| |
| const Requests = { |
| SEND_DIFF_DRAFT: 'sendDiffDraft', |
| }; |
| |
| const CREATE_DRAFT_UNEXPECTED_STATUS_MESSAGE = |
| 'Saving draft resulted in HTTP 200 (OK) but expected HTTP 201 (Created)'; |
| const HEADER_REPORTING_BLACKLIST = /^set-cookie$/i; |
| |
| const ANONYMIZED_CHANGE_BASE_URL = '/changes/*~*'; |
| const ANONYMIZED_REVISION_BASE_URL = ANONYMIZED_CHANGE_BASE_URL + |
| '/revisions/*'; |
| |
| /** |
| * Wrapper around Map for caching server responses. Site-based so that |
| * changes to CANONICAL_PATH will result in a different cache going into |
| * effect. |
| */ |
| class SiteBasedCache { |
| constructor() { |
| // Container of per-canonical-path caches. |
| this._data = new Map(); |
| } |
| |
| // Returns the cache for the current canonical path. |
| _cache() { |
| if (!this._data.has(window.CANONICAL_PATH)) { |
| this._data.set(window.CANONICAL_PATH, new Map()); |
| } |
| return this._data.get(window.CANONICAL_PATH); |
| } |
| |
| has(key) { |
| return this._cache().has(key); |
| } |
| |
| get(key) { |
| return this._cache().get(key); |
| } |
| |
| set(key, value) { |
| this._cache().set(key, value); |
| } |
| |
| delete(key) { |
| this._cache().delete(key); |
| } |
| |
| invalidatePrefix(prefix) { |
| const newMap = new Map(); |
| for (const [key, value] of this._cache().entries()) { |
| if (!key.startsWith(prefix)) { |
| newMap.set(key, value); |
| } |
| } |
| this._data.set(window.CANONICAL_PATH, newMap); |
| } |
| } |
| |
| Polymer({ |
| is: 'gr-rest-api-interface', |
| |
| behaviors: [ |
| Gerrit.PathListBehavior, |
| Gerrit.PatchSetBehavior, |
| Gerrit.RESTClientBehavior, |
| ], |
| |
| /** |
| * Fired when an server error occurs. |
| * |
| * @event server-error |
| */ |
| |
| /** |
| * Fired when a network error occurs. |
| * |
| * @event network-error |
| */ |
| |
| /** |
| * Fired when credentials were rejected by server (e.g. expired). |
| * |
| * @event auth-error |
| */ |
| |
| /** |
| * Fired after an RPC completes. |
| * |
| * @event rpc-log |
| */ |
| |
| properties: { |
| _cache: { |
| type: Object, |
| value: new SiteBasedCache(), // Shared across instances. |
| }, |
| _credentialCheck: { |
| type: Object, |
| value: {checking: false}, // Shared across instances. |
| }, |
| _sharedFetchPromises: { |
| type: Object, |
| value: {}, // Intentional to share the object across instances. |
| }, |
| _pendingRequests: { |
| type: Object, |
| value: {}, // Intentional to share the object across instances. |
| }, |
| _etags: { |
| type: Object, |
| value: new GrEtagDecorator(), // Share across instances. |
| }, |
| /** |
| * Used to maintain a mapping of changeNums to project names. |
| */ |
| _projectLookup: { |
| type: Object, |
| value: {}, // Intentional to share the object across instances. |
| }, |
| _auth: { |
| type: Object, |
| value: Gerrit.Auth, // Share across instances. |
| }, |
| }, |
| |
| JSON_PREFIX, |
| |
| /** |
| * Wraps calls to the underlying authenticated fetch function (_auth.fetch) |
| * with timing and logging. |
| * @param {Defs.FetchRequest} req |
| */ |
| _fetch(req) { |
| const start = Date.now(); |
| const xhr = this._auth.fetch(req.url, req.fetchOptions); |
| |
| // Log the call after it completes. |
| xhr.then(res => this._logCall(req, start, res.status)); |
| |
| // Return the XHR directly (without the log). |
| return xhr; |
| }, |
| |
| /** |
| * Log information about a REST call. Because the elapsed time is determined |
| * by this method, it should be called immediately after the request |
| * finishes. |
| * @param {Defs.FetchRequest} req |
| * @param {number} startTime the time that the request was started. |
| * @param {number} status the HTTP status of the response. The status value |
| * is used here rather than the response object so there is no way this |
| * method can read the body stream. |
| */ |
| _logCall(req, startTime, status) { |
| const method = (req.fetchOptions && req.fetchOptions.method) ? |
| req.fetchOptions.method : 'GET'; |
| const elapsed = (Date.now() - startTime); |
| console.log([ |
| 'HTTP', |
| status, |
| method, |
| elapsed + 'ms', |
| req.anonymizedUrl || req.url, |
| ].join(' ')); |
| if (req.anonymizedUrl) { |
| this.fire('rpc-log', |
| {status, method, elapsed, anonymizedUrl: req.anonymizedUrl}); |
| } |
| }, |
| |
| /** |
| * Fetch JSON from url provided. |
| * Returns a Promise that resolves to a native Response. |
| * Doesn't do error checking. Supports cancel condition. Performs auth. |
| * Validates auth expiry errors. |
| * @param {Defs.FetchJSONRequest} req |
| */ |
| _fetchRawJSON(req) { |
| const urlWithParams = this._urlWithParams(req.url, req.params); |
| const fetchReq = { |
| url: urlWithParams, |
| fetchOptions: req.fetchOptions, |
| anonymizedUrl: req.reportUrlAsIs ? urlWithParams : req.anonymizedUrl, |
| }; |
| return this._fetch(fetchReq).then(res => { |
| if (req.cancelCondition && req.cancelCondition()) { |
| res.body.cancel(); |
| return; |
| } |
| return res; |
| }).catch(err => { |
| const isLoggedIn = !!this._cache.get('/accounts/self/detail'); |
| if (isLoggedIn && err && err.message === FAILED_TO_FETCH_ERROR) { |
| this.checkCredentials(); |
| return; |
| } |
| if (req.errFn) { |
| req.errFn.call(undefined, null, err); |
| } else { |
| this.fire('network-error', {error: err}); |
| } |
| throw err; |
| }); |
| }, |
| |
| /** |
| * Fetch JSON from url provided. |
| * Returns a Promise that resolves to a parsed response. |
| * Same as {@link _fetchRawJSON}, plus error handling. |
| * @param {Defs.FetchJSONRequest} req |
| */ |
| _fetchJSON(req) { |
| return this._fetchRawJSON(req).then(response => { |
| if (!response) { |
| return; |
| } |
| if (!response.ok) { |
| if (req.errFn) { |
| req.errFn.call(null, response); |
| return; |
| } |
| this.fire('server-error', {request: req, response}); |
| return; |
| } |
| return response && this.getResponseObject(response); |
| }); |
| }, |
| |
| /** |
| * @param {string} url |
| * @param {?Object=} opt_params URL params, key-value hash. |
| * @return {string} |
| */ |
| _urlWithParams(url, opt_params) { |
| if (!opt_params) { return this.getBaseUrl() + url; } |
| |
| const params = []; |
| for (const p in opt_params) { |
| if (!opt_params.hasOwnProperty(p)) { continue; } |
| if (opt_params[p] == null) { |
| params.push(encodeURIComponent(p)); |
| continue; |
| } |
| for (const value of [].concat(opt_params[p])) { |
| params.push(`${encodeURIComponent(p)}=${encodeURIComponent(value)}`); |
| } |
| } |
| return this.getBaseUrl() + url + '?' + params.join('&'); |
| }, |
| |
| /** |
| * @param {!Object} response |
| * @return {?} |
| */ |
| getResponseObject(response) { |
| return this._readResponsePayload(response) |
| .then(payload => payload.parsed); |
| }, |
| |
| /** |
| * @param {!Object} response |
| * @return {!Object} |
| */ |
| _readResponsePayload(response) { |
| return response.text().then(text => { |
| let result; |
| try { |
| result = this._parsePrefixedJSON(text); |
| } catch (_) { |
| result = null; |
| } |
| return {parsed: result, raw: text}; |
| }); |
| }, |
| |
| /** |
| * @param {string} source |
| * @return {?} |
| */ |
| _parsePrefixedJSON(source) { |
| return JSON.parse(source.substring(JSON_PREFIX.length)); |
| }, |
| |
| getConfig(noCache) { |
| if (!noCache) { |
| return this._fetchSharedCacheURL({ |
| url: '/config/server/info', |
| reportUrlAsIs: true, |
| }); |
| } |
| |
| return this._fetchJSON({ |
| url: '/config/server/info', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| getRepo(repo, opt_errFn) { |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchSharedCacheURL({ |
| url: '/projects/' + encodeURIComponent(repo), |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*', |
| }); |
| }, |
| |
| getProjectConfig(repo, opt_errFn) { |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchSharedCacheURL({ |
| url: '/projects/' + encodeURIComponent(repo) + '/config', |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/config', |
| }); |
| }, |
| |
| getRepoAccess(repo) { |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchSharedCacheURL({ |
| url: '/access/?project=' + encodeURIComponent(repo), |
| anonymizedUrl: '/access/?project=*', |
| }); |
| }, |
| |
| getRepoDashboards(repo, opt_errFn) { |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchSharedCacheURL({ |
| url: `/projects/${encodeURIComponent(repo)}/dashboards?inherited`, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/dashboards?inherited', |
| }); |
| }, |
| |
| saveRepoConfig(repo, config, opt_errFn) { |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| const encodeName = encodeURIComponent(repo); |
| return this._send({ |
| method: 'PUT', |
| url: `/projects/${encodeName}/config`, |
| body: config, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/config', |
| }); |
| }, |
| |
| runRepoGC(repo, opt_errFn) { |
| if (!repo) { return ''; } |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| const encodeName = encodeURIComponent(repo); |
| return this._send({ |
| method: 'POST', |
| url: `/projects/${encodeName}/gc`, |
| body: '', |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/gc', |
| }); |
| }, |
| |
| /** |
| * @param {?Object} config |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| createRepo(config, opt_errFn) { |
| if (!config.name) { return ''; } |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| const encodeName = encodeURIComponent(config.name); |
| return this._send({ |
| method: 'PUT', |
| url: `/projects/${encodeName}`, |
| body: config, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*', |
| }); |
| }, |
| |
| /** |
| * @param {?Object} config |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| createGroup(config, opt_errFn) { |
| if (!config.name) { return ''; } |
| const encodeName = encodeURIComponent(config.name); |
| return this._send({ |
| method: 'PUT', |
| url: `/groups/${encodeName}`, |
| body: config, |
| errFn: opt_errFn, |
| anonymizedUrl: '/groups/*', |
| }); |
| }, |
| |
| getGroupConfig(group, opt_errFn) { |
| return this._fetchJSON({ |
| url: `/groups/${encodeURIComponent(group)}/detail`, |
| errFn: opt_errFn, |
| anonymizedUrl: '/groups/*/detail', |
| }); |
| }, |
| |
| /** |
| * @param {string} repo |
| * @param {string} ref |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| deleteRepoBranches(repo, ref, opt_errFn) { |
| if (!repo || !ref) { return ''; } |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| const encodeName = encodeURIComponent(repo); |
| const encodeRef = encodeURIComponent(ref); |
| return this._send({ |
| method: 'DELETE', |
| url: `/projects/${encodeName}/branches/${encodeRef}`, |
| body: '', |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/branches/*', |
| }); |
| }, |
| |
| /** |
| * @param {string} repo |
| * @param {string} ref |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| deleteRepoTags(repo, ref, opt_errFn) { |
| if (!repo || !ref) { return ''; } |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| const encodeName = encodeURIComponent(repo); |
| const encodeRef = encodeURIComponent(ref); |
| return this._send({ |
| method: 'DELETE', |
| url: `/projects/${encodeName}/tags/${encodeRef}`, |
| body: '', |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/tags/*', |
| }); |
| }, |
| |
| /** |
| * @param {string} name |
| * @param {string} branch |
| * @param {string} revision |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| createRepoBranch(name, branch, revision, opt_errFn) { |
| if (!name || !branch || !revision) { return ''; } |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| const encodeName = encodeURIComponent(name); |
| const encodeBranch = encodeURIComponent(branch); |
| return this._send({ |
| method: 'PUT', |
| url: `/projects/${encodeName}/branches/${encodeBranch}`, |
| body: revision, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/branches/*', |
| }); |
| }, |
| |
| /** |
| * @param {string} name |
| * @param {string} tag |
| * @param {string} revision |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| createRepoTag(name, tag, revision, opt_errFn) { |
| if (!name || !tag || !revision) { return ''; } |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| const encodeName = encodeURIComponent(name); |
| const encodeTag = encodeURIComponent(tag); |
| return this._send({ |
| method: 'PUT', |
| url: `/projects/${encodeName}/tags/${encodeTag}`, |
| body: revision, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/tags/*', |
| }); |
| }, |
| |
| /** |
| * @param {!string} groupName |
| * @returns {!Promise<boolean>} |
| */ |
| getIsGroupOwner(groupName) { |
| const encodeName = encodeURIComponent(groupName); |
| const req = { |
| url: `/groups/?owned&q=${encodeName}`, |
| anonymizedUrl: '/groups/owned&q=*', |
| }; |
| return this._fetchSharedCacheURL(req) |
| .then(configs => configs.hasOwnProperty(groupName)); |
| }, |
| |
| getGroupMembers(groupName, opt_errFn) { |
| const encodeName = encodeURIComponent(groupName); |
| return this._fetchJSON({ |
| url: `/groups/${encodeName}/members/`, |
| errFn: opt_errFn, |
| anonymizedUrl: '/groups/*/members', |
| }); |
| }, |
| |
| getIncludedGroup(groupName) { |
| return this._fetchJSON({ |
| url: `/groups/${encodeURIComponent(groupName)}/groups/`, |
| anonymizedUrl: '/groups/*/groups', |
| }); |
| }, |
| |
| saveGroupName(groupId, name) { |
| const encodeId = encodeURIComponent(groupId); |
| return this._send({ |
| method: 'PUT', |
| url: `/groups/${encodeId}/name`, |
| body: {name}, |
| anonymizedUrl: '/groups/*/name', |
| }); |
| }, |
| |
| saveGroupOwner(groupId, ownerId) { |
| const encodeId = encodeURIComponent(groupId); |
| return this._send({ |
| method: 'PUT', |
| url: `/groups/${encodeId}/owner`, |
| body: {owner: ownerId}, |
| anonymizedUrl: '/groups/*/owner', |
| }); |
| }, |
| |
| saveGroupDescription(groupId, description) { |
| const encodeId = encodeURIComponent(groupId); |
| return this._send({ |
| method: 'PUT', |
| url: `/groups/${encodeId}/description`, |
| body: {description}, |
| anonymizedUrl: '/groups/*/description', |
| }); |
| }, |
| |
| saveGroupOptions(groupId, options) { |
| const encodeId = encodeURIComponent(groupId); |
| return this._send({ |
| method: 'PUT', |
| url: `/groups/${encodeId}/options`, |
| body: options, |
| anonymizedUrl: '/groups/*/options', |
| }); |
| }, |
| |
| getGroupAuditLog(group, opt_errFn) { |
| return this._fetchSharedCacheURL({ |
| url: '/groups/' + group + '/log.audit', |
| errFn: opt_errFn, |
| anonymizedUrl: '/groups/*/log.audit', |
| }); |
| }, |
| |
| saveGroupMembers(groupName, groupMembers) { |
| const encodeName = encodeURIComponent(groupName); |
| const encodeMember = encodeURIComponent(groupMembers); |
| return this._send({ |
| method: 'PUT', |
| url: `/groups/${encodeName}/members/${encodeMember}`, |
| parseResponse: true, |
| anonymizedUrl: '/groups/*/members/*', |
| }); |
| }, |
| |
| saveIncludedGroup(groupName, includedGroup, opt_errFn) { |
| const encodeName = encodeURIComponent(groupName); |
| const encodeIncludedGroup = encodeURIComponent(includedGroup); |
| const req = { |
| method: 'PUT', |
| url: `/groups/${encodeName}/groups/${encodeIncludedGroup}`, |
| errFn: opt_errFn, |
| anonymizedUrl: '/groups/*/groups/*', |
| }; |
| return this._send(req).then(response => { |
| if (response.ok) { |
| return this.getResponseObject(response); |
| } |
| }); |
| }, |
| |
| deleteGroupMembers(groupName, groupMembers) { |
| const encodeName = encodeURIComponent(groupName); |
| const encodeMember = encodeURIComponent(groupMembers); |
| return this._send({ |
| method: 'DELETE', |
| url: `/groups/${encodeName}/members/${encodeMember}`, |
| anonymizedUrl: '/groups/*/members/*', |
| }); |
| }, |
| |
| deleteIncludedGroup(groupName, includedGroup) { |
| const encodeName = encodeURIComponent(groupName); |
| const encodeIncludedGroup = encodeURIComponent(includedGroup); |
| return this._send({ |
| method: 'DELETE', |
| url: `/groups/${encodeName}/groups/${encodeIncludedGroup}`, |
| anonymizedUrl: '/groups/*/groups/*', |
| }); |
| }, |
| |
| getVersion() { |
| return this._fetchSharedCacheURL({ |
| url: '/config/server/version', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| getDiffPreferences() { |
| return this.getLoggedIn().then(loggedIn => { |
| if (loggedIn) { |
| return this._fetchSharedCacheURL({ |
| url: '/accounts/self/preferences.diff', |
| reportUrlAsIs: true, |
| }); |
| } |
| // These defaults should match the defaults in |
| // java/com/google/gerrit/extensions/client/DiffPreferencesInfo.java |
| // NOTE: There are some settings that don't apply to PolyGerrit |
| // (Render mode being at least one of them). |
| return Promise.resolve({ |
| auto_hide_diff_table_header: true, |
| context: 10, |
| cursor_blink_rate: 0, |
| font_size: 12, |
| ignore_whitespace: 'IGNORE_NONE', |
| intraline_difference: true, |
| line_length: 100, |
| line_wrapping: false, |
| show_line_endings: true, |
| show_tabs: true, |
| show_whitespace_errors: true, |
| syntax_highlighting: true, |
| tab_size: 8, |
| theme: 'DEFAULT', |
| }); |
| }); |
| }, |
| |
| getEditPreferences() { |
| return this.getLoggedIn().then(loggedIn => { |
| if (loggedIn) { |
| return this._fetchSharedCacheURL({ |
| url: '/accounts/self/preferences.edit', |
| reportUrlAsIs: true, |
| }); |
| } |
| // These defaults should match the defaults in |
| // java/com/google/gerrit/extensions/client/EditPreferencesInfo.java |
| return Promise.resolve({ |
| auto_close_brackets: false, |
| cursor_blink_rate: 0, |
| hide_line_numbers: false, |
| hide_top_menu: false, |
| indent_unit: 2, |
| indent_with_tabs: false, |
| key_map_type: 'DEFAULT', |
| line_length: 100, |
| line_wrapping: false, |
| match_brackets: true, |
| show_base: false, |
| show_tabs: true, |
| show_whitespace_errors: true, |
| syntax_highlighting: true, |
| tab_size: 8, |
| theme: 'DEFAULT', |
| }); |
| }); |
| }, |
| |
| /** |
| * @param {?Object} prefs |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| savePreferences(prefs, opt_errFn) { |
| // Note (Issue 5142): normalize the download scheme with lower case before |
| // saving. |
| if (prefs.download_scheme) { |
| prefs.download_scheme = prefs.download_scheme.toLowerCase(); |
| } |
| |
| return this._send({ |
| method: 'PUT', |
| url: '/accounts/self/preferences', |
| body: prefs, |
| errFn: opt_errFn, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {?Object} prefs |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| saveDiffPreferences(prefs, opt_errFn) { |
| // Invalidate the cache. |
| this._cache.delete('/accounts/self/preferences.diff'); |
| return this._send({ |
| method: 'PUT', |
| url: '/accounts/self/preferences.diff', |
| body: prefs, |
| errFn: opt_errFn, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {?Object} prefs |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| saveEditPreferences(prefs, opt_errFn) { |
| // Invalidate the cache. |
| this._cache.delete('/accounts/self/preferences.edit'); |
| return this._send({ |
| method: 'PUT', |
| url: '/accounts/self/preferences.edit', |
| body: prefs, |
| errFn: opt_errFn, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| getAccount() { |
| return this._fetchSharedCacheURL({ |
| url: '/accounts/self/detail', |
| reportUrlAsIs: true, |
| errFn: resp => { |
| if (!resp || resp.status === 403) { |
| this._cache.delete('/accounts/self/detail'); |
| } |
| }, |
| }); |
| }, |
| |
| getAvatarChangeUrl() { |
| return this._fetchSharedCacheURL({ |
| url: '/accounts/self/avatar.change.url', |
| reportUrlAsIs: true, |
| errFn: resp => { |
| if (!resp || resp.status === 403) { |
| this._cache.delete('/accounts/self/avatar.change.url'); |
| } |
| }, |
| }); |
| }, |
| |
| getExternalIds() { |
| return this._fetchJSON({ |
| url: '/accounts/self/external.ids', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| deleteAccountIdentity(id) { |
| return this._send({ |
| method: 'POST', |
| url: '/accounts/self/external.ids:delete', |
| body: id, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {string} userId the ID of the user usch as an email address. |
| * @return {!Promise<!Object>} |
| */ |
| getAccountDetails(userId) { |
| return this._fetchJSON({ |
| url: `/accounts/${encodeURIComponent(userId)}/detail`, |
| anonymizedUrl: '/accounts/*/detail', |
| }); |
| }, |
| |
| getAccountEmails() { |
| return this._fetchSharedCacheURL({ |
| url: '/accounts/self/emails', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {string} email |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| addAccountEmail(email, opt_errFn) { |
| return this._send({ |
| method: 'PUT', |
| url: '/accounts/self/emails/' + encodeURIComponent(email), |
| errFn: opt_errFn, |
| anonymizedUrl: '/account/self/emails/*', |
| }); |
| }, |
| |
| /** |
| * @param {string} email |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| deleteAccountEmail(email, opt_errFn) { |
| return this._send({ |
| method: 'DELETE', |
| url: '/accounts/self/emails/' + encodeURIComponent(email), |
| errFn: opt_errFn, |
| anonymizedUrl: '/accounts/self/email/*', |
| }); |
| }, |
| |
| /** |
| * @param {string} email |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| setPreferredAccountEmail(email, opt_errFn) { |
| const encodedEmail = encodeURIComponent(email); |
| const req = { |
| method: 'PUT', |
| url: `/accounts/self/emails/${encodedEmail}/preferred`, |
| errFn: opt_errFn, |
| anonymizedUrl: '/accounts/self/emails/*/preferred', |
| }; |
| return this._send(req).then(() => { |
| // If result of getAccountEmails is in cache, update it in the cache |
| // so we don't have to invalidate it. |
| const cachedEmails = this._cache.get('/accounts/self/emails'); |
| if (cachedEmails) { |
| const emails = cachedEmails.map(entry => { |
| if (entry.email === email) { |
| return {email, preferred: true}; |
| } else { |
| return {email}; |
| } |
| }); |
| this._cache.set('/accounts/self/emails', emails); |
| } |
| }); |
| }, |
| |
| /** |
| * @param {?Object} obj |
| */ |
| _updateCachedAccount(obj) { |
| // If result of getAccount is in cache, update it in the cache |
| // so we don't have to invalidate it. |
| const cachedAccount = this._cache.get('/accounts/self/detail'); |
| if (cachedAccount) { |
| // Replace object in cache with new object to force UI updates. |
| this._cache.set('/accounts/self/detail', |
| Object.assign({}, cachedAccount, obj)); |
| } |
| }, |
| |
| /** |
| * @param {string} name |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| setAccountName(name, opt_errFn) { |
| const req = { |
| method: 'PUT', |
| url: '/accounts/self/name', |
| body: {name}, |
| errFn: opt_errFn, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }; |
| return this._send(req) |
| .then(newName => this._updateCachedAccount({name: newName})); |
| }, |
| |
| /** |
| * @param {string} username |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| setAccountUsername(username, opt_errFn) { |
| const req = { |
| method: 'PUT', |
| url: '/accounts/self/username', |
| body: {username}, |
| errFn: opt_errFn, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }; |
| return this._send(req) |
| .then(newName => this._updateCachedAccount({username: newName})); |
| }, |
| |
| /** |
| * @param {string} status |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| setAccountStatus(status, opt_errFn) { |
| const req = { |
| method: 'PUT', |
| url: '/accounts/self/status', |
| body: {status}, |
| errFn: opt_errFn, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }; |
| return this._send(req) |
| .then(newStatus => this._updateCachedAccount({status: newStatus})); |
| }, |
| |
| getAccountStatus(userId) { |
| return this._fetchJSON({ |
| url: `/accounts/${encodeURIComponent(userId)}/status`, |
| anonymizedUrl: '/accounts/*/status', |
| }); |
| }, |
| |
| getAccountGroups() { |
| return this._fetchJSON({ |
| url: '/accounts/self/groups', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| getAccountAgreements() { |
| return this._fetchJSON({ |
| url: '/accounts/self/agreements', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| saveAccountAgreement(name) { |
| return this._send({ |
| method: 'PUT', |
| url: '/accounts/self/agreements', |
| body: name, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {string=} opt_params |
| */ |
| getAccountCapabilities(opt_params) { |
| let queryString = ''; |
| if (opt_params) { |
| queryString = '?q=' + opt_params |
| .map(param => { return encodeURIComponent(param); }) |
| .join('&q='); |
| } |
| return this._fetchSharedCacheURL({ |
| url: '/accounts/self/capabilities' + queryString, |
| anonymizedUrl: '/accounts/self/capabilities?q=*', |
| }); |
| }, |
| |
| getLoggedIn() { |
| return this.getAccount().then(account => { |
| return account != null; |
| }); |
| }, |
| |
| getIsAdmin() { |
| return this.getLoggedIn().then(isLoggedIn => { |
| if (isLoggedIn) { |
| return this.getAccountCapabilities(); |
| } else { |
| return Promise.resolve(); |
| } |
| }).then(capabilities => { |
| return capabilities && capabilities.administrateServer; |
| }); |
| }, |
| |
| checkCredentials() { |
| if (this._credentialCheck.checking) { |
| return; |
| } |
| this._credentialCheck.checking = true; |
| const req = {url: '/accounts/self/detail', reportUrlAsIs: true}; |
| // Skip the REST response cache. |
| return this._fetchRawJSON(req).then(res => { |
| if (!res) { return; } |
| if (res.status === 403) { |
| this.fire('auth-error'); |
| this._cache.delete('/accounts/self/detail'); |
| } else if (res.ok) { |
| return this.getResponseObject(res); |
| } |
| }).then(res => { |
| this._credentialCheck.checking = false; |
| if (res) { |
| this._cache.delete('/accounts/self/detail'); |
| } |
| return res; |
| }).catch(err => { |
| this._credentialCheck.checking = false; |
| }); |
| }, |
| |
| getDefaultPreferences() { |
| return this._fetchSharedCacheURL({ |
| url: '/config/server/preferences', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| getPreferences() { |
| return this.getLoggedIn().then(loggedIn => { |
| if (loggedIn) { |
| const req = {url: '/accounts/self/preferences', reportUrlAsIs: true}; |
| return this._fetchSharedCacheURL(req).then(res => { |
| if (this._isNarrowScreen()) { |
| res.default_diff_view = DiffViewMode.UNIFIED; |
| } else { |
| res.default_diff_view = res.diff_view; |
| } |
| return Promise.resolve(res); |
| }); |
| } |
| |
| return Promise.resolve({ |
| changes_per_page: 25, |
| default_diff_view: this._isNarrowScreen() ? |
| DiffViewMode.UNIFIED : DiffViewMode.SIDE_BY_SIDE, |
| diff_view: 'SIDE_BY_SIDE', |
| size_bar_in_change_table: true, |
| }); |
| }); |
| }, |
| |
| getWatchedProjects() { |
| return this._fetchSharedCacheURL({ |
| url: '/accounts/self/watched.projects', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {string} projects |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| saveWatchedProjects(projects, opt_errFn) { |
| return this._send({ |
| method: 'POST', |
| url: '/accounts/self/watched.projects', |
| body: projects, |
| errFn: opt_errFn, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {string} projects |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| deleteWatchedProjects(projects, opt_errFn) { |
| return this._send({ |
| method: 'POST', |
| url: '/accounts/self/watched.projects:delete', |
| body: projects, |
| errFn: opt_errFn, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {Defs.FetchJSONRequest} req |
| */ |
| _fetchSharedCacheURL(req) { |
| if (this._sharedFetchPromises[req.url]) { |
| return this._sharedFetchPromises[req.url]; |
| } |
| // TODO(andybons): Periodic cache invalidation. |
| if (this._cache.has(req.url)) { |
| return Promise.resolve(this._cache.get(req.url)); |
| } |
| this._sharedFetchPromises[req.url] = this._fetchJSON(req) |
| .then(response => { |
| if (response !== undefined) { |
| this._cache.set(req.url, response); |
| } |
| this._sharedFetchPromises[req.url] = undefined; |
| return response; |
| }).catch(err => { |
| this._sharedFetchPromises[req.url] = undefined; |
| throw err; |
| }); |
| return this._sharedFetchPromises[req.url]; |
| }, |
| |
| /** |
| * @param {string} prefix |
| */ |
| _invalidateSharedFetchPromisesPrefix(prefix) { |
| const newObject = {}; |
| Object.entries(this._sharedFetchPromises).forEach(([key, value]) => { |
| if (!key.startsWith(prefix)) { |
| newObject[key] = value; |
| } |
| }); |
| this._sharedFetchPromises = newObject; |
| this._cache.invalidatePrefix(prefix); |
| }, |
| |
| _isNarrowScreen() { |
| return window.innerWidth < MAX_UNIFIED_DEFAULT_WINDOW_WIDTH_PX; |
| }, |
| |
| /** |
| * @param {number=} opt_changesPerPage |
| * @param {string|!Array<string>=} opt_query A query or an array of queries. |
| * @param {number|string=} opt_offset |
| * @param {!Object=} opt_options |
| * @return {?Array<!Object>|?Array<!Array<!Object>>} If opt_query is an |
| * array, _fetchJSON will return an array of arrays of changeInfos. If it |
| * is unspecified or a string, _fetchJSON will return an array of |
| * changeInfos. |
| */ |
| getChanges(opt_changesPerPage, opt_query, opt_offset, opt_options) { |
| const options = opt_options || this.listChangesOptionsToHex( |
| this.ListChangesOption.LABELS, |
| this.ListChangesOption.DETAILED_ACCOUNTS |
| ); |
| // Issue 4524: respect legacy token with max sortkey. |
| if (opt_offset === 'n,z') { |
| opt_offset = 0; |
| } |
| const params = { |
| O: options, |
| S: opt_offset || 0, |
| }; |
| if (opt_changesPerPage) { params.n = opt_changesPerPage; } |
| if (opt_query && opt_query.length > 0) { |
| params.q = opt_query; |
| } |
| const iterateOverChanges = arr => { |
| for (const change of (arr || [])) { |
| this._maybeInsertInLookup(change); |
| } |
| }; |
| const req = { |
| url: '/changes/', |
| params, |
| reportUrlAsIs: true, |
| }; |
| return this._fetchJSON(req).then(response => { |
| // Response may be an array of changes OR an array of arrays of |
| // changes. |
| if (opt_query instanceof Array) { |
| // Normalize the response to look like a multi-query response |
| // when there is only one query. |
| if (opt_query.length === 1) { |
| response = [response]; |
| } |
| for (const arr of response) { |
| iterateOverChanges(arr); |
| } |
| } else { |
| iterateOverChanges(response); |
| } |
| return response; |
| }); |
| }, |
| |
| /** |
| * Inserts a change into _projectLookup iff it has a valid structure. |
| * @param {?{ _number: (number|string) }} change |
| */ |
| _maybeInsertInLookup(change) { |
| if (change && change.project && change._number) { |
| this.setInProjectLookup(change._number, change.project); |
| } |
| }, |
| |
| /** |
| * TODO (beckysiegel) this needs to be rewritten with the optional param |
| * at the end. |
| * |
| * @param {number|string} changeNum |
| * @param {?number|string=} opt_patchNum passed as null sometimes. |
| * @param {?=} endpoint |
| * @return {!Promise<string>} |
| */ |
| getChangeActionURL(changeNum, opt_patchNum, endpoint) { |
| return this._changeBaseURL(changeNum, opt_patchNum) |
| .then(url => url + endpoint); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {function(?Response, string=)=} opt_errFn |
| * @param {function()=} opt_cancelCondition |
| */ |
| getChangeDetail(changeNum, opt_errFn, opt_cancelCondition) { |
| const options = [ |
| this.ListChangesOption.ALL_COMMITS, |
| this.ListChangesOption.ALL_REVISIONS, |
| this.ListChangesOption.CHANGE_ACTIONS, |
| this.ListChangesOption.CURRENT_ACTIONS, |
| this.ListChangesOption.DETAILED_LABELS, |
| this.ListChangesOption.DOWNLOAD_COMMANDS, |
| this.ListChangesOption.MESSAGES, |
| this.ListChangesOption.SUBMITTABLE, |
| this.ListChangesOption.WEB_LINKS, |
| this.ListChangesOption.SKIP_MERGEABLE, |
| ]; |
| return this.getConfig(false).then(config => { |
| if (config.receive && config.receive.enable_signed_push) { |
| options.push(this.ListChangesOption.PUSH_CERTIFICATES); |
| } |
| const optionsHex = this.listChangesOptionsToHex(...options); |
| return this._getChangeDetail( |
| changeNum, optionsHex, opt_errFn, opt_cancelCondition) |
| .then(GrReviewerUpdatesParser.parse); |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {function(?Response, string=)=} opt_errFn |
| * @param {function()=} opt_cancelCondition |
| */ |
| getDiffChangeDetail(changeNum, opt_errFn, opt_cancelCondition) { |
| const params = this.listChangesOptionsToHex( |
| this.ListChangesOption.ALL_COMMITS, |
| this.ListChangesOption.ALL_REVISIONS, |
| this.ListChangesOption.SKIP_MERGEABLE |
| ); |
| return this._getChangeDetail(changeNum, params, opt_errFn, |
| opt_cancelCondition); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {function(?Response, string=)=} opt_errFn |
| * @param {function()=} opt_cancelCondition |
| */ |
| _getChangeDetail(changeNum, params, opt_errFn, opt_cancelCondition) { |
| return this.getChangeActionURL(changeNum, null, '/detail').then(url => { |
| const urlWithParams = this._urlWithParams(url, params); |
| const req = { |
| url, |
| errFn: opt_errFn, |
| cancelCondition: opt_cancelCondition, |
| params: {O: params}, |
| fetchOptions: this._etags.getOptions(urlWithParams), |
| anonymizedUrl: '/changes/*~*/detail?O=' + params, |
| }; |
| return this._fetchRawJSON(req).then(response => { |
| if (response && response.status === 304) { |
| return Promise.resolve(this._parsePrefixedJSON( |
| this._etags.getCachedPayload(urlWithParams))); |
| } |
| |
| if (response && !response.ok) { |
| if (opt_errFn) { |
| opt_errFn.call(null, response); |
| } else { |
| this.fire('server-error', {request: req, response}); |
| } |
| return; |
| } |
| |
| const payloadPromise = response ? |
| this._readResponsePayload(response) : |
| Promise.resolve(null); |
| |
| return payloadPromise.then(payload => { |
| if (!payload) { return null; } |
| this._etags.collect(urlWithParams, response, payload.raw); |
| this._maybeInsertInLookup(payload.parsed); |
| |
| return payload.parsed; |
| }); |
| }); |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string} patchNum |
| */ |
| getChangeCommitInfo(changeNum, patchNum) { |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/commit?links', |
| patchNum, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {Defs.patchRange} patchRange |
| * @param {number=} opt_parentIndex |
| */ |
| getChangeFiles(changeNum, patchRange, opt_parentIndex) { |
| let params = undefined; |
| if (this.isMergeParent(patchRange.basePatchNum)) { |
| params = {parent: this.getParentIndex(patchRange.basePatchNum)}; |
| } else if (!this.patchNumEquals(patchRange.basePatchNum, 'PARENT')) { |
| params = {base: patchRange.basePatchNum}; |
| } |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/files', |
| patchNum: patchRange.patchNum, |
| params, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {Defs.patchRange} patchRange |
| */ |
| getChangeEditFiles(changeNum, patchRange) { |
| let endpoint = '/edit?list'; |
| let anonymizedEndpoint = endpoint; |
| if (patchRange.basePatchNum !== 'PARENT') { |
| endpoint += '&base=' + encodeURIComponent(patchRange.basePatchNum + ''); |
| anonymizedEndpoint += '&base=*'; |
| } |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint, |
| anonymizedEndpoint, |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string} patchNum |
| * @param {string} query |
| * @return {!Promise<!Object>} |
| */ |
| queryChangeFiles(changeNum, patchNum, query) { |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: `/files?q=${encodeURIComponent(query)}`, |
| patchNum, |
| anonymizedEndpoint: '/files?q=*', |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {Defs.patchRange} patchRange |
| * @return {!Promise<!Array<!Object>>} |
| */ |
| getChangeOrEditFiles(changeNum, patchRange) { |
| if (this.patchNumEquals(patchRange.patchNum, this.EDIT_NAME)) { |
| return this.getChangeEditFiles(changeNum, patchRange).then(res => |
| res.files); |
| } |
| return this.getChangeFiles(changeNum, patchRange); |
| }, |
| |
| /** |
| * The closure compiler doesn't realize this.specialFilePathCompare is |
| * valid. |
| * @suppress {checkTypes} |
| */ |
| getChangeFilePathsAsSpeciallySortedArray(changeNum, patchRange) { |
| return this.getChangeFiles(changeNum, patchRange).then(files => { |
| return Object.keys(files).sort(this.specialFilePathCompare); |
| }); |
| }, |
| |
| getChangeRevisionActions(changeNum, patchNum) { |
| const req = { |
| changeNum, |
| endpoint: '/actions', |
| patchNum, |
| reportEndpointAsIs: true, |
| }; |
| return this._getChangeURLAndFetch(req).then(revisionActions => { |
| // The rebase button on change screen is always enabled. |
| if (revisionActions.rebase) { |
| revisionActions.rebase.rebaseOnCurrent = |
| !!revisionActions.rebase.enabled; |
| revisionActions.rebase.enabled = true; |
| } |
| return revisionActions; |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {string} inputVal |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| getChangeSuggestedReviewers(changeNum, inputVal, opt_errFn) { |
| const params = {n: 10}; |
| if (inputVal) { params.q = inputVal; } |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/suggest_reviewers', |
| errFn: opt_errFn, |
| params, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| */ |
| getChangeIncludedIn(changeNum) { |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/in', |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| _computeFilter(filter) { |
| if (filter && filter.startsWith('^')) { |
| filter = '&r=' + encodeURIComponent(filter); |
| } else if (filter) { |
| filter = '&m=' + encodeURIComponent(filter); |
| } else { |
| filter = ''; |
| } |
| return filter; |
| }, |
| |
| /** |
| * @param {string} filter |
| * @param {number} groupsPerPage |
| * @param {number=} opt_offset |
| */ |
| _getGroupsUrl(filter, groupsPerPage, opt_offset) { |
| const offset = opt_offset || 0; |
| |
| return `/groups/?n=${groupsPerPage + 1}&S=${offset}` + |
| this._computeFilter(filter); |
| }, |
| |
| /** |
| * @param {string} filter |
| * @param {number} reposPerPage |
| * @param {number=} opt_offset |
| */ |
| _getReposUrl(filter, reposPerPage, opt_offset) { |
| const defaultFilter = 'state:active OR state:read-only'; |
| const namePartDelimiters = /[@.\-\s\/_]/g; |
| const offset = opt_offset || 0; |
| |
| if (filter && !filter.includes(':') && filter.match(namePartDelimiters)) { |
| // The query language specifies hyphens as operators. Split the string |
| // by hyphens and 'AND' the parts together as 'inname:' queries. |
| // If the filter includes a semicolon, the user is using a more complex |
| // query so we trust them and don't do any magic under the hood. |
| const originalFilter = filter; |
| filter = ''; |
| originalFilter.split(namePartDelimiters).forEach(part => { |
| if (part) { |
| filter += (filter === '' ? 'inname:' : ' AND inname:') + part; |
| } |
| }); |
| } |
| // Check if filter is now empty which could be either because the user did |
| // not provide it or because the user provided only a split character. |
| if (!filter) { |
| filter = defaultFilter; |
| } |
| |
| filter = filter.trim(); |
| const encodedFilter = encodeURIComponent(filter); |
| |
| return `/projects/?n=${reposPerPage + 1}&S=${offset}` + |
| `&query=${encodedFilter}`; |
| }, |
| |
| invalidateGroupsCache() { |
| this._invalidateSharedFetchPromisesPrefix('/groups/?'); |
| }, |
| |
| invalidateReposCache() { |
| this._invalidateSharedFetchPromisesPrefix('/projects/?'); |
| }, |
| |
| /** |
| * @param {string} filter |
| * @param {number} groupsPerPage |
| * @param {number=} opt_offset |
| * @return {!Promise<?Object>} |
| */ |
| getGroups(filter, groupsPerPage, opt_offset) { |
| const url = this._getGroupsUrl(filter, groupsPerPage, opt_offset); |
| |
| return this._fetchSharedCacheURL({ |
| url, |
| anonymizedUrl: '/groups/?*', |
| }); |
| }, |
| |
| /** |
| * @param {string} filter |
| * @param {number} reposPerPage |
| * @param {number=} opt_offset |
| * @return {!Promise<?Object>} |
| */ |
| getRepos(filter, reposPerPage, opt_offset) { |
| const url = this._getReposUrl(filter, reposPerPage, opt_offset); |
| |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchSharedCacheURL({ |
| url, |
| anonymizedUrl: '/projects/?*', |
| }); |
| }, |
| |
| setRepoHead(repo, ref) { |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._send({ |
| method: 'PUT', |
| url: `/projects/${encodeURIComponent(repo)}/HEAD`, |
| body: {ref}, |
| anonymizedUrl: '/projects/*/HEAD', |
| }); |
| }, |
| |
| /** |
| * @param {string} filter |
| * @param {string} repo |
| * @param {number} reposBranchesPerPage |
| * @param {number=} opt_offset |
| * @param {?function(?Response, string=)=} opt_errFn |
| * @return {!Promise<?Object>} |
| */ |
| getRepoBranches(filter, repo, reposBranchesPerPage, opt_offset, opt_errFn) { |
| const offset = opt_offset || 0; |
| const count = reposBranchesPerPage + 1; |
| filter = this._computeFilter(filter); |
| repo = encodeURIComponent(repo); |
| const url = `/projects/${repo}/branches?n=${count}&S=${offset}${filter}`; |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchJSON({ |
| url, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/branches?*', |
| }); |
| }, |
| |
| /** |
| * @param {string} filter |
| * @param {string} repo |
| * @param {number} reposTagsPerPage |
| * @param {number=} opt_offset |
| * @param {?function(?Response, string=)=} opt_errFn |
| * @return {!Promise<?Object>} |
| */ |
| getRepoTags(filter, repo, reposTagsPerPage, opt_offset, opt_errFn) { |
| const offset = opt_offset || 0; |
| const encodedRepo = encodeURIComponent(repo); |
| const n = reposTagsPerPage + 1; |
| const encodedFilter = this._computeFilter(filter); |
| const url = `/projects/${encodedRepo}/tags` + `?n=${n}&S=${offset}` + |
| encodedFilter; |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchJSON({ |
| url, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/tags', |
| }); |
| }, |
| |
| /** |
| * @param {string} filter |
| * @param {number} pluginsPerPage |
| * @param {number=} opt_offset |
| * @param {?function(?Response, string=)=} opt_errFn |
| * @return {!Promise<?Object>} |
| */ |
| getPlugins(filter, pluginsPerPage, opt_offset, opt_errFn) { |
| const offset = opt_offset || 0; |
| const encodedFilter = this._computeFilter(filter); |
| const n = pluginsPerPage + 1; |
| const url = `/plugins/?all&n=${n}&S=${offset}${encodedFilter}`; |
| return this._fetchJSON({ |
| url, |
| errFn: opt_errFn, |
| anonymizedUrl: '/plugins/?all', |
| }); |
| }, |
| |
| getRepoAccessRights(repoName, opt_errFn) { |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchJSON({ |
| url: `/projects/${encodeURIComponent(repoName)}/access`, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/access', |
| }); |
| }, |
| |
| setRepoAccessRights(repoName, repoInfo) { |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._send({ |
| method: 'POST', |
| url: `/projects/${encodeURIComponent(repoName)}/access`, |
| body: repoInfo, |
| anonymizedUrl: '/projects/*/access', |
| }); |
| }, |
| |
| setRepoAccessRightsForReview(projectName, projectInfo) { |
| return this._send({ |
| method: 'PUT', |
| url: `/projects/${encodeURIComponent(projectName)}/access:review`, |
| body: projectInfo, |
| parseResponse: true, |
| anonymizedUrl: '/projects/*/access:review', |
| }); |
| }, |
| |
| /** |
| * @param {string} inputVal |
| * @param {number} opt_n |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| getSuggestedGroups(inputVal, opt_n, opt_errFn) { |
| const params = {s: inputVal}; |
| if (opt_n) { params.n = opt_n; } |
| return this._fetchJSON({ |
| url: '/groups/', |
| errFn: opt_errFn, |
| params, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {string} inputVal |
| * @param {number} opt_n |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| getSuggestedProjects(inputVal, opt_n, opt_errFn) { |
| const params = { |
| m: inputVal, |
| n: MAX_PROJECT_RESULTS, |
| type: 'ALL', |
| }; |
| if (opt_n) { params.n = opt_n; } |
| return this._fetchJSON({ |
| url: '/projects/', |
| errFn: opt_errFn, |
| params, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {string} inputVal |
| * @param {number} opt_n |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| getSuggestedAccounts(inputVal, opt_n, opt_errFn) { |
| if (!inputVal) { |
| return Promise.resolve([]); |
| } |
| const params = {suggest: null, q: inputVal}; |
| if (opt_n) { params.n = opt_n; } |
| return this._fetchJSON({ |
| url: '/accounts/', |
| errFn: opt_errFn, |
| params, |
| anonymizedUrl: '/accounts/?n=*', |
| }); |
| }, |
| |
| addChangeReviewer(changeNum, reviewerID) { |
| return this._sendChangeReviewerRequest('POST', changeNum, reviewerID); |
| }, |
| |
| removeChangeReviewer(changeNum, reviewerID) { |
| return this._sendChangeReviewerRequest('DELETE', changeNum, reviewerID); |
| }, |
| |
| _sendChangeReviewerRequest(method, changeNum, reviewerID) { |
| return this.getChangeActionURL(changeNum, null, '/reviewers') |
| .then(url => { |
| let body; |
| switch (method) { |
| case 'POST': |
| body = {reviewer: reviewerID}; |
| break; |
| case 'DELETE': |
| url += '/' + encodeURIComponent(reviewerID); |
| break; |
| default: |
| throw Error('Unsupported HTTP method: ' + method); |
| } |
| |
| return this._send({method, url, body}); |
| }); |
| }, |
| |
| getRelatedChanges(changeNum, patchNum) { |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/related', |
| patchNum, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| getChangesSubmittedTogether(changeNum) { |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/submitted_together?o=NON_VISIBLE_CHANGES', |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| getChangeConflicts(changeNum) { |
| const options = this.listChangesOptionsToHex( |
| this.ListChangesOption.CURRENT_REVISION, |
| this.ListChangesOption.CURRENT_COMMIT |
| ); |
| const params = { |
| O: options, |
| q: 'status:open is:mergeable conflicts:' + changeNum, |
| }; |
| return this._fetchJSON({ |
| url: '/changes/', |
| params, |
| anonymizedUrl: '/changes/conflicts:*', |
| }); |
| }, |
| |
| getChangeCherryPicks(project, changeID, changeNum) { |
| const options = this.listChangesOptionsToHex( |
| this.ListChangesOption.CURRENT_REVISION, |
| this.ListChangesOption.CURRENT_COMMIT |
| ); |
| const query = [ |
| 'project:' + project, |
| 'change:' + changeID, |
| '-change:' + changeNum, |
| '-is:abandoned', |
| ].join(' '); |
| const params = { |
| O: options, |
| q: query, |
| }; |
| return this._fetchJSON({ |
| url: '/changes/', |
| params, |
| anonymizedUrl: '/changes/change:*', |
| }); |
| }, |
| |
| getChangesWithSameTopic(topic, changeNum) { |
| const options = this.listChangesOptionsToHex( |
| this.ListChangesOption.LABELS, |
| this.ListChangesOption.CURRENT_REVISION, |
| this.ListChangesOption.CURRENT_COMMIT, |
| this.ListChangesOption.DETAILED_LABELS |
| ); |
| const query = [ |
| 'status:open', |
| '-change:' + changeNum, |
| `topic:"${topic}"`, |
| ].join(' '); |
| const params = { |
| O: options, |
| q: query, |
| }; |
| return this._fetchJSON({ |
| url: '/changes/', |
| params, |
| anonymizedUrl: '/changes/topic:*', |
| }); |
| }, |
| |
| getReviewedFiles(changeNum, patchNum) { |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/files?reviewed', |
| patchNum, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string} patchNum |
| * @param {string} path |
| * @param {boolean} reviewed |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| saveFileReviewed(changeNum, patchNum, path, reviewed, opt_errFn) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: reviewed ? 'PUT' : 'DELETE', |
| patchNum, |
| endpoint: `/files/${encodeURIComponent(path)}/reviewed`, |
| errFn: opt_errFn, |
| anonymizedEndpoint: '/files/*/reviewed', |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string} patchNum |
| * @param {!Object} review |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| saveChangeReview(changeNum, patchNum, review, opt_errFn) { |
| const promises = [ |
| this.awaitPendingDiffDrafts(), |
| this.getChangeActionURL(changeNum, patchNum, '/review'), |
| ]; |
| return Promise.all(promises).then(([, url]) => { |
| return this._send({ |
| method: 'POST', |
| url, |
| body: review, |
| errFn: opt_errFn, |
| }); |
| }); |
| }, |
| |
| getChangeEdit(changeNum, opt_download_commands) { |
| const params = opt_download_commands ? {'download-commands': true} : null; |
| return this.getLoggedIn().then(loggedIn => { |
| if (!loggedIn) { return false; } |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/edit/', |
| params, |
| reportEndpointAsIs: true, |
| }); |
| }); |
| }, |
| |
| /** |
| * @param {string} project |
| * @param {string} branch |
| * @param {string} subject |
| * @param {string=} opt_topic |
| * @param {boolean=} opt_isPrivate |
| * @param {boolean=} opt_workInProgress |
| * @param {string=} opt_baseChange |
| * @param {string=} opt_baseCommit |
| */ |
| createChange(project, branch, subject, opt_topic, opt_isPrivate, |
| opt_workInProgress, opt_baseChange, opt_baseCommit) { |
| return this._send({ |
| method: 'POST', |
| url: '/changes/', |
| body: { |
| project, |
| branch, |
| subject, |
| topic: opt_topic, |
| is_private: opt_isPrivate, |
| work_in_progress: opt_workInProgress, |
| base_change: opt_baseChange, |
| base_commit: opt_baseCommit, |
| }, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {string} path |
| * @param {number|string} patchNum |
| */ |
| getFileContent(changeNum, path, patchNum) { |
| // 404s indicate the file does not exist yet in the revision, so suppress |
| // them. |
| const suppress404s = res => { |
| if (res && res.status !== 404) { this.fire('server-error', {res}); } |
| return res; |
| }; |
| const promise = this.patchNumEquals(patchNum, this.EDIT_NAME) ? |
| this._getFileInChangeEdit(changeNum, path) : |
| this._getFileInRevision(changeNum, path, patchNum, suppress404s); |
| |
| return promise.then(res => { |
| if (!res.ok) { return res; } |
| |
| // The file type (used for syntax highlighting) is identified in the |
| // X-FYI-Content-Type header of the response. |
| const type = res.headers.get('X-FYI-Content-Type'); |
| return this.getResponseObject(res).then(content => { |
| return {content, type, ok: true}; |
| }); |
| }); |
| }, |
| |
| /** |
| * Gets a file in a specific change and revision. |
| * @param {number|string} changeNum |
| * @param {string} path |
| * @param {number|string} patchNum |
| * @param {?function(?Response, string=)=} opt_errFn |
| */ |
| _getFileInRevision(changeNum, path, patchNum, opt_errFn) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'GET', |
| patchNum, |
| endpoint: `/files/${encodeURIComponent(path)}/content`, |
| errFn: opt_errFn, |
| headers: {Accept: 'application/json'}, |
| anonymizedEndpoint: '/files/*/content', |
| }); |
| }, |
| |
| /** |
| * Gets a file in a change edit. |
| * @param {number|string} changeNum |
| * @param {string} path |
| */ |
| _getFileInChangeEdit(changeNum, path) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'GET', |
| endpoint: '/edit/' + encodeURIComponent(path), |
| headers: {Accept: 'application/json'}, |
| anonymizedEndpoint: '/edit/*', |
| }); |
| }, |
| |
| rebaseChangeEdit(changeNum) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'POST', |
| endpoint: '/edit:rebase', |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| deleteChangeEdit(changeNum) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'DELETE', |
| endpoint: '/edit', |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| restoreFileInChangeEdit(changeNum, restore_path) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'POST', |
| endpoint: '/edit', |
| body: {restore_path}, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| renameFileInChangeEdit(changeNum, old_path, new_path) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'POST', |
| endpoint: '/edit', |
| body: {old_path, new_path}, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| deleteFileInChangeEdit(changeNum, path) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'DELETE', |
| endpoint: '/edit/' + encodeURIComponent(path), |
| anonymizedEndpoint: '/edit/*', |
| }); |
| }, |
| |
| saveChangeEdit(changeNum, path, contents) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'PUT', |
| endpoint: '/edit/' + encodeURIComponent(path), |
| body: contents, |
| contentType: 'text/plain', |
| anonymizedEndpoint: '/edit/*', |
| }); |
| }, |
| |
| // Deprecated, prefer to use putChangeCommitMessage instead. |
| saveChangeCommitMessageEdit(changeNum, message) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'PUT', |
| endpoint: '/edit:message', |
| body: {message}, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| publishChangeEdit(changeNum) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'POST', |
| endpoint: '/edit:publish', |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| putChangeCommitMessage(changeNum, message) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'PUT', |
| endpoint: '/message', |
| body: {message}, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| saveChangeStarred(changeNum, starred) { |
| // Some servers may require the project name to be provided |
| // alongside the change number, so resolve the project name |
| // first. |
| return this.getFromProjectLookup(changeNum).then(project => { |
| const url = '/accounts/self/starred.changes/' + |
| (project ? encodeURIComponent(project) + '~' : '') + changeNum; |
| return this._send({ |
| method: starred ? 'PUT' : 'DELETE', |
| url, |
| anonymizedUrl: '/accounts/self/starred.changes/*', |
| }); |
| }); |
| }, |
| |
| saveChangeReviewed(changeNum, reviewed) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'PUT', |
| endpoint: reviewed ? '/reviewed' : '/unreviewed', |
| }); |
| }, |
| |
| /** |
| * Send an XHR. |
| * @param {Defs.SendRequest} req |
| * @return {Promise} |
| */ |
| _send(req) { |
| const options = {method: req.method}; |
| if (req.body) { |
| options.headers = new Headers(); |
| options.headers.set( |
| 'Content-Type', req.contentType || 'application/json'); |
| options.body = typeof req.body === 'string' ? |
| req.body : JSON.stringify(req.body); |
| } |
| if (req.headers) { |
| if (!options.headers) { options.headers = new Headers(); } |
| for (const header in req.headers) { |
| if (!req.headers.hasOwnProperty(header)) { continue; } |
| options.headers.set(header, req.headers[header]); |
| } |
| } |
| const url = req.url.startsWith('http') ? |
| req.url : this.getBaseUrl() + req.url; |
| const fetchReq = { |
| url, |
| fetchOptions: options, |
| anonymizedUrl: req.reportUrlAsIs ? url : req.anonymizedUrl, |
| }; |
| const xhr = this._fetch(fetchReq).then(response => { |
| if (!response.ok) { |
| if (req.errFn) { |
| return req.errFn.call(undefined, response); |
| } |
| this.fire('server-error', {request: fetchReq, response}); |
| } |
| return response; |
| }).catch(err => { |
| this.fire('network-error', {error: err}); |
| if (req.errFn) { |
| return req.errFn.call(undefined, null, err); |
| } else { |
| throw err; |
| } |
| }); |
| |
| if (req.parseResponse) { |
| return xhr.then(res => this.getResponseObject(res)); |
| } |
| |
| return xhr; |
| }, |
| |
| /** |
| * Public version of the _send method preserved for plugins. |
| * @param {string} method |
| * @param {string} url |
| * @param {?string|number|Object=} opt_body passed as null sometimes |
| * and also apparently a number. TODO (beckysiegel) remove need for |
| * number at least. |
| * @param {?function(?Response, string=)=} opt_errFn |
| * passed as null sometimes. |
| * @param {?string=} opt_contentType |
| * @param {Object=} opt_headers |
| */ |
| send(method, url, opt_body, opt_errFn, opt_contentType, |
| opt_headers) { |
| return this._send({ |
| method, |
| url, |
| body: opt_body, |
| errFn: opt_errFn, |
| contentType: opt_contentType, |
| headers: opt_headers, |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string} basePatchNum Negative values specify merge parent |
| * index. |
| * @param {number|string} patchNum |
| * @param {string} path |
| * @param {string=} opt_whitespace the ignore-whitespace level for the diff |
| * algorithm. |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| getDiff(changeNum, basePatchNum, patchNum, path, opt_whitespace, |
| opt_errFn) { |
| const params = { |
| context: 'ALL', |
| intraline: null, |
| whitespace: opt_whitespace || 'IGNORE_NONE', |
| }; |
| if (this.isMergeParent(basePatchNum)) { |
| params.parent = this.getParentIndex(basePatchNum); |
| } else if (!this.patchNumEquals(basePatchNum, PARENT_PATCH_NUM)) { |
| params.base = basePatchNum; |
| } |
| const endpoint = `/files/${encodeURIComponent(path)}/diff`; |
| |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint, |
| patchNum, |
| errFn: opt_errFn, |
| params, |
| anonymizedEndpoint: '/files/*/diff', |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string=} opt_basePatchNum |
| * @param {number|string=} opt_patchNum |
| * @param {string=} opt_path |
| * @return {!Promise<!Object>} |
| */ |
| getDiffComments(changeNum, opt_basePatchNum, opt_patchNum, opt_path) { |
| return this._getDiffComments(changeNum, '/comments', opt_basePatchNum, |
| opt_patchNum, opt_path); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string=} opt_basePatchNum |
| * @param {number|string=} opt_patchNum |
| * @param {string=} opt_path |
| * @return {!Promise<!Object>} |
| */ |
| getDiffRobotComments(changeNum, opt_basePatchNum, opt_patchNum, opt_path) { |
| return this._getDiffComments(changeNum, '/robotcomments', |
| opt_basePatchNum, opt_patchNum, opt_path); |
| }, |
| |
| /** |
| * If the user is logged in, fetch the user's draft diff comments. If there |
| * is no logged in user, the request is not made and the promise yields an |
| * empty object. |
| * |
| * @param {number|string} changeNum |
| * @param {number|string=} opt_basePatchNum |
| * @param {number|string=} opt_patchNum |
| * @param {string=} opt_path |
| * @return {!Promise<!Object>} |
| */ |
| getDiffDrafts(changeNum, opt_basePatchNum, opt_patchNum, opt_path) { |
| return this.getLoggedIn().then(loggedIn => { |
| if (!loggedIn) { return Promise.resolve({}); } |
| return this._getDiffComments(changeNum, '/drafts', opt_basePatchNum, |
| opt_patchNum, opt_path); |
| }); |
| }, |
| |
| _setRange(comments, comment) { |
| if (comment.in_reply_to && !comment.range) { |
| for (let i = 0; i < comments.length; i++) { |
| if (comments[i].id === comment.in_reply_to) { |
| comment.range = comments[i].range; |
| break; |
| } |
| } |
| } |
| return comment; |
| }, |
| |
| _setRanges(comments) { |
| comments = comments || []; |
| comments.sort((a, b) => { |
| return util.parseDate(a.updated) - util.parseDate(b.updated); |
| }); |
| for (const comment of comments) { |
| this._setRange(comments, comment); |
| } |
| return comments; |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {string} endpoint |
| * @param {number|string=} opt_basePatchNum |
| * @param {number|string=} opt_patchNum |
| * @param {string=} opt_path |
| * @return {!Promise<!Object>} |
| */ |
| _getDiffComments(changeNum, endpoint, opt_basePatchNum, |
| opt_patchNum, opt_path) { |
| /** |
| * Fetches the comments for a given patchNum. |
| * Helper function to make promises more legible. |
| * |
| * @param {string|number=} opt_patchNum |
| * @return {!Promise<!Object>} Diff comments response. |
| */ |
| const fetchComments = opt_patchNum => { |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint, |
| patchNum: opt_patchNum, |
| reportEndpointAsIs: true, |
| }); |
| }; |
| |
| if (!opt_basePatchNum && !opt_patchNum && !opt_path) { |
| return fetchComments(); |
| } |
| function onlyParent(c) { return c.side == PARENT_PATCH_NUM; } |
| function withoutParent(c) { return c.side != PARENT_PATCH_NUM; } |
| function setPath(c) { c.path = opt_path; } |
| |
| const promises = []; |
| let comments; |
| let baseComments; |
| let fetchPromise; |
| fetchPromise = fetchComments(opt_patchNum).then(response => { |
| comments = response[opt_path] || []; |
| // TODO(kaspern): Implement this on in the backend so this can |
| // be removed. |
| // Sort comments by date so that parent ranges can be propagated |
| // in a single pass. |
| comments = this._setRanges(comments); |
| |
| if (opt_basePatchNum == PARENT_PATCH_NUM) { |
| baseComments = comments.filter(onlyParent); |
| baseComments.forEach(setPath); |
| } |
| comments = comments.filter(withoutParent); |
| |
| comments.forEach(setPath); |
| }); |
| promises.push(fetchPromise); |
| |
| if (opt_basePatchNum != PARENT_PATCH_NUM) { |
| fetchPromise = fetchComments(opt_basePatchNum).then(response => { |
| baseComments = (response[opt_path] || []) |
| .filter(withoutParent); |
| baseComments = this._setRanges(baseComments); |
| baseComments.forEach(setPath); |
| }); |
| promises.push(fetchPromise); |
| } |
| |
| return Promise.all(promises).then(() => { |
| return Promise.resolve({ |
| baseComments, |
| comments, |
| }); |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {string} endpoint |
| * @param {number|string=} opt_patchNum |
| */ |
| _getDiffCommentsFetchURL(changeNum, endpoint, opt_patchNum) { |
| return this._changeBaseURL(changeNum, opt_patchNum) |
| .then(url => url + endpoint); |
| }, |
| |
| saveDiffDraft(changeNum, patchNum, draft) { |
| return this._sendDiffDraftRequest('PUT', changeNum, patchNum, draft); |
| }, |
| |
| deleteDiffDraft(changeNum, patchNum, draft) { |
| return this._sendDiffDraftRequest('DELETE', changeNum, patchNum, draft); |
| }, |
| |
| /** |
| * @returns {boolean} Whether there are pending diff draft sends. |
| */ |
| hasPendingDiffDrafts() { |
| const promises = this._pendingRequests[Requests.SEND_DIFF_DRAFT]; |
| return promises && promises.length; |
| }, |
| |
| /** |
| * @returns {!Promise<undefined>} A promise that resolves when all pending |
| * diff draft sends have resolved. |
| */ |
| awaitPendingDiffDrafts() { |
| return Promise.all(this._pendingRequests[Requests.SEND_DIFF_DRAFT] || []) |
| .then(() => { |
| this._pendingRequests[Requests.SEND_DIFF_DRAFT] = []; |
| }); |
| }, |
| |
| _sendDiffDraftRequest(method, changeNum, patchNum, draft) { |
| const isCreate = !draft.id && method === 'PUT'; |
| let endpoint = '/drafts'; |
| let anonymizedEndpoint = endpoint; |
| if (draft.id) { |
| endpoint += '/' + draft.id; |
| anonymizedEndpoint += '/*'; |
| } |
| let body; |
| if (method === 'PUT') { |
| body = draft; |
| } |
| |
| if (!this._pendingRequests[Requests.SEND_DIFF_DRAFT]) { |
| this._pendingRequests[Requests.SEND_DIFF_DRAFT] = []; |
| } |
| |
| const req = { |
| changeNum, |
| method, |
| patchNum, |
| endpoint, |
| body, |
| anonymizedEndpoint, |
| }; |
| |
| const promise = this._getChangeURLAndSend(req); |
| this._pendingRequests[Requests.SEND_DIFF_DRAFT].push(promise); |
| |
| if (isCreate) { |
| return this._failForCreate200(promise); |
| } |
| |
| return promise; |
| }, |
| |
| getCommitInfo(project, commit) { |
| return this._fetchJSON({ |
| url: '/projects/' + encodeURIComponent(project) + |
| '/commits/' + encodeURIComponent(commit), |
| anonymizedUrl: '/projects/*/comments/*', |
| }); |
| }, |
| |
| _fetchB64File(url) { |
| return this._fetch({url: this.getBaseUrl() + url}) |
| .then(response => { |
| if (!response.ok) { return Promise.reject(response.statusText); } |
| const type = response.headers.get('X-FYI-Content-Type'); |
| return response.text() |
| .then(text => { |
| return {body: text, type}; |
| }); |
| }); |
| }, |
| |
| /** |
| * @param {string} changeId |
| * @param {string|number} patchNum |
| * @param {string} path |
| * @param {number=} opt_parentIndex |
| */ |
| getB64FileContents(changeId, patchNum, path, opt_parentIndex) { |
| const parent = typeof opt_parentIndex === 'number' ? |
| '?parent=' + opt_parentIndex : ''; |
| return this._changeBaseURL(changeId, patchNum).then(url => { |
| url = `${url}/files/${encodeURIComponent(path)}/content${parent}`; |
| return this._fetchB64File(url); |
| }); |
| }, |
| |
| getImagesForDiff(changeNum, diff, patchRange) { |
| let promiseA; |
| let promiseB; |
| |
| if (diff.meta_a && diff.meta_a.content_type.startsWith('image/')) { |
| if (patchRange.basePatchNum === 'PARENT') { |
| // Note: we only attempt to get the image from the first parent. |
| promiseA = this.getB64FileContents(changeNum, patchRange.patchNum, |
| diff.meta_a.name, 1); |
| } else { |
| promiseA = this.getB64FileContents(changeNum, |
| patchRange.basePatchNum, diff.meta_a.name); |
| } |
| } else { |
| promiseA = Promise.resolve(null); |
| } |
| |
| if (diff.meta_b && diff.meta_b.content_type.startsWith('image/')) { |
| promiseB = this.getB64FileContents(changeNum, patchRange.patchNum, |
| diff.meta_b.name); |
| } else { |
| promiseB = Promise.resolve(null); |
| } |
| |
| return Promise.all([promiseA, promiseB]).then(results => { |
| const baseImage = results[0]; |
| const revisionImage = results[1]; |
| |
| // Sometimes the server doesn't send back the content type. |
| if (baseImage) { |
| baseImage._expectedType = diff.meta_a.content_type; |
| baseImage._name = diff.meta_a.name; |
| } |
| if (revisionImage) { |
| revisionImage._expectedType = diff.meta_b.content_type; |
| revisionImage._name = diff.meta_b.name; |
| } |
| |
| return {baseImage, revisionImage}; |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {?number|string=} opt_patchNum passed as null sometimes. |
| * @param {string=} opt_project |
| * @return {!Promise<string>} |
| */ |
| _changeBaseURL(changeNum, opt_patchNum, opt_project) { |
| // TODO(kaspern): For full slicer migration, app should warn with a call |
| // stack every time _changeBaseURL is called without a project. |
| const projectPromise = opt_project ? |
| Promise.resolve(opt_project) : |
| this.getFromProjectLookup(changeNum); |
| return projectPromise.then(project => { |
| let url = `/changes/${encodeURIComponent(project)}~${changeNum}`; |
| if (opt_patchNum) { |
| url += `/revisions/${opt_patchNum}`; |
| } |
| return url; |
| }); |
| }, |
| |
| /** |
| * @suppress {checkTypes} |
| * Resulted in error: Promise.prototype.then does not match formal |
| * parameter. |
| */ |
| setChangeTopic(changeNum, topic) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'PUT', |
| endpoint: '/topic', |
| body: {topic}, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @suppress {checkTypes} |
| * Resulted in error: Promise.prototype.then does not match formal |
| * parameter. |
| */ |
| setChangeHashtag(changeNum, hashtag) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'POST', |
| endpoint: '/hashtags', |
| body: hashtag, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| deleteAccountHttpPassword() { |
| return this._send({ |
| method: 'DELETE', |
| url: '/accounts/self/password.http', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @suppress {checkTypes} |
| * Resulted in error: Promise.prototype.then does not match formal |
| * parameter. |
| */ |
| generateAccountHttpPassword() { |
| return this._send({ |
| method: 'PUT', |
| url: '/accounts/self/password.http', |
| body: {generate: true}, |
| parseResponse: true, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| getAccountSSHKeys() { |
| return this._fetchSharedCacheURL({ |
| url: '/accounts/self/sshkeys', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| addAccountSSHKey(key) { |
| const req = { |
| method: 'POST', |
| url: '/accounts/self/sshkeys', |
| body: key, |
| contentType: 'plain/text', |
| reportUrlAsIs: true, |
| }; |
| return this._send(req) |
| .then(response => { |
| if (response.status < 200 && response.status >= 300) { |
| return Promise.reject(); |
| } |
| return this.getResponseObject(response); |
| }) |
| .then(obj => { |
| if (!obj.valid) { return Promise.reject(); } |
| return obj; |
| }); |
| }, |
| |
| deleteAccountSSHKey(id) { |
| return this._send({ |
| method: 'DELETE', |
| url: '/accounts/self/sshkeys/' + id, |
| anonymizedUrl: '/accounts/self/sshkeys/*', |
| }); |
| }, |
| |
| getAccountGPGKeys() { |
| return this._fetchJSON({ |
| url: '/accounts/self/gpgkeys', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| addAccountGPGKey(key) { |
| const req = { |
| method: 'POST', |
| url: '/accounts/self/gpgkeys', |
| body: key, |
| reportUrlAsIs: true, |
| }; |
| return this._send(req) |
| .then(response => { |
| if (response.status < 200 && response.status >= 300) { |
| return Promise.reject(); |
| } |
| return this.getResponseObject(response); |
| }) |
| .then(obj => { |
| if (!obj) { return Promise.reject(); } |
| return obj; |
| }); |
| }, |
| |
| deleteAccountGPGKey(id) { |
| return this._send({ |
| method: 'DELETE', |
| url: '/accounts/self/gpgkeys/' + id, |
| anonymizedUrl: '/accounts/self/gpgkeys/*', |
| }); |
| }, |
| |
| deleteVote(changeNum, account, label) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'DELETE', |
| endpoint: `/reviewers/${account}/votes/${encodeURIComponent(label)}`, |
| anonymizedEndpoint: '/reviewers/*/votes/*', |
| }); |
| }, |
| |
| setDescription(changeNum, patchNum, desc) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'PUT', patchNum, |
| endpoint: '/description', |
| body: {description: desc}, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| confirmEmail(token) { |
| const req = { |
| method: 'PUT', |
| url: '/config/server/email.confirm', |
| body: {token}, |
| reportUrlAsIs: true, |
| }; |
| return this._send(req).then(response => { |
| if (response.status === 204) { |
| return 'Email confirmed successfully.'; |
| } |
| return null; |
| }); |
| }, |
| |
| getCapabilities(token, opt_errFn) { |
| return this._fetchJSON({ |
| url: '/config/server/capabilities', |
| errFn: opt_errFn, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| getTopMenus(opt_errFn) { |
| return this._fetchJSON({ |
| url: '/config/server/top-menus', |
| errFn: opt_errFn, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| setAssignee(changeNum, assignee) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'PUT', |
| endpoint: '/assignee', |
| body: {assignee}, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| deleteAssignee(changeNum) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'DELETE', |
| endpoint: '/assignee', |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| probePath(path) { |
| return fetch(new Request(path, {method: 'HEAD'})) |
| .then(response => { |
| return response.ok; |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string=} opt_message |
| */ |
| startWorkInProgress(changeNum, opt_message) { |
| const body = {}; |
| if (opt_message) { |
| body.message = opt_message; |
| } |
| const req = { |
| changeNum, |
| method: 'POST', |
| endpoint: '/wip', |
| body, |
| reportUrlAsIs: true, |
| }; |
| return this._getChangeURLAndSend(req).then(response => { |
| if (response.status === 204) { |
| return 'Change marked as Work In Progress.'; |
| } |
| }); |
| }, |
| |
| /** |
| * @param {number|string} changeNum |
| * @param {number|string=} opt_body |
| * @param {function(?Response, string=)=} opt_errFn |
| */ |
| startReview(changeNum, opt_body, opt_errFn) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'POST', |
| endpoint: '/ready', |
| body: opt_body, |
| errFn: opt_errFn, |
| reportUrlAsIs: true, |
| }); |
| }, |
| |
| /** |
| * @suppress {checkTypes} |
| * Resulted in error: Promise.prototype.then does not match formal |
| * parameter. |
| */ |
| deleteComment(changeNum, patchNum, commentID, reason) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method: 'POST', |
| patchNum, |
| endpoint: `/comments/${commentID}/delete`, |
| body: {reason}, |
| parseResponse: true, |
| anonymizedEndpoint: '/comments/*/delete', |
| }); |
| }, |
| |
| /** |
| * Given a changeNum, gets the change. |
| * |
| * @param {number|string} changeNum |
| * @param {function(?Response, string=)=} opt_errFn |
| * @return {!Promise<?Object>} The change |
| */ |
| getChange(changeNum, opt_errFn) { |
| // Cannot use _changeBaseURL, as this function is used by _projectLookup. |
| return this._fetchJSON({ |
| url: `/changes/?q=change:${changeNum}`, |
| errFn: opt_errFn, |
| anonymizedUrl: '/changes/?q=change:*', |
| }).then(res => { |
| if (!res || !res.length) { return null; } |
| return res[0]; |
| }); |
| }, |
| |
| /** |
| * @param {string|number} changeNum |
| * @param {string=} project |
| */ |
| setInProjectLookup(changeNum, project) { |
| if (this._projectLookup[changeNum] && |
| this._projectLookup[changeNum] !== project) { |
| console.warn('Change set with multiple project nums.' + |
| 'One of them must be invalid.'); |
| } |
| this._projectLookup[changeNum] = project; |
| }, |
| |
| /** |
| * Checks in _projectLookup for the changeNum. If it exists, returns the |
| * project. If not, calls the restAPI to get the change, populates |
| * _projectLookup with the project for that change, and returns the project. |
| * |
| * @param {string|number} changeNum |
| * @return {!Promise<string|undefined>} |
| */ |
| getFromProjectLookup(changeNum) { |
| const project = this._projectLookup[changeNum]; |
| if (project) { return Promise.resolve(project); } |
| |
| const onError = response => { |
| // Fire a page error so that the visual 404 is displayed. |
| this.fire('page-error', {response}); |
| }; |
| |
| return this.getChange(changeNum, onError).then(change => { |
| if (!change || !change.project) { return; } |
| this.setInProjectLookup(changeNum, change.project); |
| return change.project; |
| }); |
| }, |
| |
| /** |
| * Alias for _changeBaseURL.then(send). |
| * @todo(beckysiegel) clean up comments |
| * @param {Defs.ChangeSendRequest} req |
| * @return {!Promise<!Object>} |
| */ |
| _getChangeURLAndSend(req) { |
| const anonymizedBaseUrl = req.patchNum ? |
| ANONYMIZED_REVISION_BASE_URL : ANONYMIZED_CHANGE_BASE_URL; |
| const anonymizedEndpoint = req.reportEndpointAsIs ? |
| req.endpoint : req.anonymizedEndpoint; |
| |
| return this._changeBaseURL(req.changeNum, req.patchNum).then(url => { |
| return this._send({ |
| method: req.method, |
| url: url + req.endpoint, |
| body: req.body, |
| errFn: req.errFn, |
| contentType: req.contentType, |
| headers: req.headers, |
| parseResponse: req.parseResponse, |
| anonymizedUrl: anonymizedEndpoint ? |
| (anonymizedBaseUrl + anonymizedEndpoint) : undefined, |
| }); |
| }); |
| }, |
| |
| /** |
| * Alias for _changeBaseURL.then(_fetchJSON). |
| * @param {Defs.ChangeFetchRequest} req |
| * @return {!Promise<!Object>} |
| */ |
| _getChangeURLAndFetch(req) { |
| const anonymizedEndpoint = req.reportEndpointAsIs ? |
| req.endpoint : req.anonymizedEndpoint; |
| const anonymizedBaseUrl = req.patchNum ? |
| ANONYMIZED_REVISION_BASE_URL : ANONYMIZED_CHANGE_BASE_URL; |
| return this._changeBaseURL(req.changeNum, req.patchNum).then(url => { |
| return this._fetchJSON({ |
| url: url + req.endpoint, |
| errFn: req.errFn, |
| params: req.params, |
| fetchOptions: req.fetchOptions, |
| anonymizedUrl: anonymizedEndpoint ? |
| (anonymizedBaseUrl + anonymizedEndpoint) : undefined, |
| }); |
| }); |
| }, |
| |
| /** |
| * Execute a change action or revision action on a change. |
| * @param {number} changeNum |
| * @param {string} method |
| * @param {string} endpoint |
| * @param {string|number|undefined} opt_patchNum |
| * @param {Object=} opt_payload |
| * @param {?function(?Response, string=)=} opt_errFn |
| * @return {Promise} |
| */ |
| executeChangeAction(changeNum, method, endpoint, opt_patchNum, opt_payload, |
| opt_errFn) { |
| return this._getChangeURLAndSend({ |
| changeNum, |
| method, |
| patchNum: opt_patchNum, |
| endpoint, |
| body: opt_payload, |
| errFn: opt_errFn, |
| }); |
| }, |
| |
| /** |
| * Get blame information for the given diff. |
| * @param {string|number} changeNum |
| * @param {string|number} patchNum |
| * @param {string} path |
| * @param {boolean=} opt_base If true, requests blame for the base of the |
| * diff, rather than the revision. |
| * @return {!Promise<!Object>} |
| */ |
| getBlame(changeNum, patchNum, path, opt_base) { |
| const encodedPath = encodeURIComponent(path); |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: `/files/${encodedPath}/blame`, |
| patchNum, |
| params: opt_base ? {base: 't'} : undefined, |
| anonymizedEndpoint: '/files/*/blame', |
| }); |
| }, |
| |
| /** |
| * Modify the given create draft request promise so that it fails and throws |
| * an error if the response bears HTTP status 200 instead of HTTP 201. |
| * @see Issue 7763 |
| * @param {Promise} promise The original promise. |
| * @return {Promise} The modified promise. |
| */ |
| _failForCreate200(promise) { |
| return promise.then(result => { |
| if (result.status === 200) { |
| // Read the response headers into an object representation. |
| const headers = Array.from(result.headers.entries()) |
| .reduce((obj, [key, val]) => { |
| if (!HEADER_REPORTING_BLACKLIST.test(key)) { |
| obj[key] = val; |
| } |
| return obj; |
| }, {}); |
| const err = new Error([ |
| CREATE_DRAFT_UNEXPECTED_STATUS_MESSAGE, |
| JSON.stringify(headers), |
| ].join('\n')); |
| // Throw the error so that it is caught by gr-reporting. |
| throw err; |
| } |
| return result; |
| }); |
| }, |
| |
| /** |
| * Fetch a project dashboard definition. |
| * https://gerrit-review.googlesource.com/Documentation/rest-api-projects.html#get-dashboard |
| * @param {string} project |
| * @param {string} dashboard |
| * @param {function(?Response, string=)=} opt_errFn |
| * passed as null sometimes. |
| * @return {!Promise<!Object>} |
| */ |
| getDashboard(project, dashboard, opt_errFn) { |
| const url = '/projects/' + encodeURIComponent(project) + '/dashboards/' + |
| encodeURIComponent(dashboard); |
| return this._fetchSharedCacheURL({ |
| url, |
| errFn: opt_errFn, |
| anonymizedUrl: '/projects/*/dashboards/*', |
| }); |
| }, |
| |
| /** |
| * @param {string} filter |
| * @return {!Promise<?Object>} |
| */ |
| getDocumentationSearches(filter) { |
| filter = filter.trim(); |
| const encodedFilter = encodeURIComponent(filter); |
| |
| // TODO(kaspern): Rename rest api from /projects/ to /repos/ once backend |
| // supports it. |
| return this._fetchSharedCacheURL({ |
| url: `/Documentation/?q=${encodedFilter}`, |
| anonymizedUrl: '/Documentation/?*', |
| }); |
| }, |
| |
| getMergeable(changeNum) { |
| return this._getChangeURLAndFetch({ |
| changeNum, |
| endpoint: '/revisions/current/mergeable', |
| parseResponse: true, |
| reportEndpointAsIs: true, |
| }); |
| }, |
| |
| deleteDraftComments(query) { |
| return this._send({ |
| method: 'POST', |
| url: '/accounts/self/drafts:delete', |
| body: {query}, |
| }); |
| }, |
| }); |
| })(); |
