| // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| // use this file except in compliance with the License. You may obtain a copy of |
| // the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| // License for the specific language governing permissions and limitations under |
| // the License. |
| |
| import app from "../../app"; |
| import Helpers from '../../helpers'; |
| import FauxtonAPI from "../../core/api"; |
| import { post } from "../../core/ajax"; |
| import Documents from "./shared-resources"; |
| |
| Documents.QueryParams = (function () { |
| var _eachParams = function (params, action) { |
| // clone to avoid in-place modification |
| var result = _.clone(params); |
| |
| _.each(['startkey', 'endkey', 'key'], function (key) { |
| if (_.has(result, key)) { |
| result[key] = action(result[key]); |
| } |
| }); |
| |
| return result; |
| }; |
| |
| return { |
| parse: function (params) { |
| return _eachParams(params, JSON.parse); |
| }, |
| |
| stringify: function (params) { |
| return _eachParams(params, JSON.stringify); |
| } |
| }; |
| })(); |
| |
| |
| Documents.DdocInfo = FauxtonAPI.Model.extend({ |
| idAttribute: "_id", |
| documentation: function () { |
| return FauxtonAPI.constants.DOC_URLS.GENERAL; |
| }, |
| initialize: function (_attrs, options) { |
| this.database = options.database; |
| }, |
| |
| url: function (context) { |
| if (!context) { |
| context = 'server'; |
| } |
| |
| return FauxtonAPI.urls('designDocs', context, this.database.safeID(), this.safeID()); |
| }, |
| |
| // Need this to work around backbone router thinking _design/foo |
| // is a separate route. Alternatively, maybe these should be |
| // treated separately. For instance, we could default into the |
| // json editor for docs, or into a ddoc specific page. |
| safeID: function () { |
| var ddoc = this.id.replace(/^_design\//, ""); |
| return "_design/" + app.utils.safeURLName(ddoc); |
| } |
| }); |
| |
| Documents.NewDoc = Documents.Doc.extend({ |
| fetch: function () { |
| const prefix = this.partitionKey ? (this.partitionKey + ':') : ''; |
| return Helpers.getUUID().then((res) => { |
| if (res.uuids) { |
| this.set("_id", prefix + res.uuids[0]); |
| } else { |
| this.set("_id", prefix + 'enter_document_id'); |
| } |
| return res; |
| }).catch(() => { |
| // Don't throw error so the user is still able |
| // to edit the new doc |
| this.set("_id", prefix + 'enter_document_id'); |
| }); |
| } |
| }); |
| |
| Documents.BulkDeleteDoc = FauxtonAPI.Model.extend({ |
| idAttribute: "_id" |
| }); |
| |
| Documents.BulkDeleteDocCollection = FauxtonAPI.Collection.extend({ |
| |
| model: Documents.BulkDeleteDoc, |
| |
| sync: function () { |
| |
| }, |
| |
| initialize: function (models, options) { |
| this.databaseId = options.databaseId; |
| }, |
| |
| url: function () { |
| return FauxtonAPI.urls('bulk_docs', 'server', this.databaseId, ''); |
| }, |
| |
| bulkDelete: function () { |
| const payload = this.createPayload(this.toJSON()); |
| return new FauxtonAPI.Promise((resolve, reject) => { |
| post(this.url(), payload).then(res => { |
| if (res.error) { |
| throw new Error(res.reason || res.error); |
| } |
| this.handleResponse(res, resolve, reject); |
| }).catch(() => { |
| const ids = _.reduce(this.toArray(), (acc, doc) => { |
| acc.push(doc.id); |
| return acc; |
| }, []); |
| this.trigger('error', ids); |
| reject(ids); |
| }); |
| }); |
| }, |
| |
| handleResponse: function (res, resolve, reject) { |
| var ids = _.reduce(res, function (ids, doc) { |
| if (doc.error) { |
| ids.errorIds.push(doc.id); |
| } |
| |
| if (!doc.error) { |
| ids.successIds.push(doc.id); |
| } |
| |
| return ids; |
| }, { errorIds: [], successIds: [] }); |
| |
| this.removeDocuments(ids.successIds); |
| |
| if (ids.errorIds.length) { |
| this.trigger('error', ids.errorIds); |
| } |
| |
| // This is kind of tricky. If there are no documents deleted then rejects |
| // otherwise resolve with list of successful and failed documents |
| if (!_.isEmpty(ids.successIds)) { |
| resolve(ids); |
| } else { |
| reject(ids.errorIds); |
| } |
| |
| this.trigger('updated'); |
| }, |
| |
| removeDocuments: function (ids) { |
| _.each(ids, (id) => { |
| this.remove(this.get(id)); |
| }); |
| |
| this.trigger('removed', ids); |
| }, |
| |
| createPayload: function (documents) { |
| var documentList = documents; |
| |
| return { |
| docs: documentList |
| }; |
| } |
| }); |
| |
| Documents.MangoBulkDeleteDocCollection = Documents.BulkDeleteDocCollection.extend({ |
| url: function () { |
| return Helpers.getServerUrl(`/${this.databaseId}/_index/_bulk_delete`); |
| }, |
| |
| createPayload: function (documents) { |
| var documentList = documents |
| .filter(function (doc) { |
| return doc._id !== '_all_docs'; |
| }) |
| .map(function (doc) { |
| return doc._id; |
| }); |
| |
| return { |
| docids: documentList |
| }; |
| } |
| |
| }); |
| |
| export default Documents; |