| // 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 { get } from '../../core/ajax'; |
| import DatabasesBase from '../databases/base'; |
| import Stores from './stores'; |
| import ActionTypes from './actiontypes'; |
| import * as API from './api'; |
| |
| function getDatabaseDetails (dbList, fullDbList) { |
| const databaseDetails = []; |
| const failedDbs = []; |
| let seen = 0; |
| |
| dbList.forEach((db) => { |
| const url = FauxtonAPI.urls('databaseBaseURL', 'server', db); |
| |
| fetch(url) |
| .then((res) => { |
| databaseDetails.push(res); |
| }).catch(() => { |
| failedDbs.push(db); |
| }).then(() => { |
| seen++; |
| if (seen !== dbList.length) { |
| return; |
| } |
| updateDatabases({ |
| dbList: dbList, |
| databaseDetails: databaseDetails, |
| failedDbs: failedDbs, |
| fullDbList: fullDbList |
| }); |
| }); |
| }); |
| } |
| |
| function fetch (url) { |
| return get(url).then(res => { |
| if (res.error) { |
| throw new Error(res.reason || res.error); |
| } |
| return res; |
| }); |
| } |
| |
| function getDatabaseList () { |
| const url = FauxtonAPI.urls('allDBs', 'server'); |
| |
| return fetch(url); |
| } |
| |
| function paginate (list, page, perPage) { |
| const start = (page - 1) * perPage; |
| const end = page * perPage; |
| return list.slice(start, end); |
| } |
| |
| function updateDatabases (options) { |
| FauxtonAPI.dispatch({ |
| type: ActionTypes.DATABASES_UPDATE, |
| options: options |
| }); |
| } |
| |
| export default { |
| getDatabaseList, |
| paginate, |
| getDatabaseDetails, |
| fetch, |
| updateDatabases, |
| |
| init({page, limit}) { |
| this.setStartLoading(); |
| this.setPage(page); |
| if (limit) { |
| this.setLimit(limit); |
| } |
| |
| getDatabaseList(limit, page) |
| .then((fullDbList) => { |
| const paginatedDbList = paginate(fullDbList, page, limit); |
| |
| this.updateDatabases({ |
| dbList: paginatedDbList, |
| databaseDetails: [], |
| failedDbs: [], |
| fullDbList: fullDbList |
| }); |
| |
| getDatabaseDetails(paginatedDbList, fullDbList); |
| }); |
| }, |
| |
| setPage(page) { |
| FauxtonAPI.dispatch({ |
| type: ActionTypes.DATABASES_SETPAGE, |
| options: { |
| page |
| } |
| }); |
| }, |
| |
| setLimit(limit) { |
| FauxtonAPI.dispatch({ |
| type: ActionTypes.DATABASES_SETLIMIT, |
| options: { |
| limit |
| } |
| }); |
| }, |
| |
| setStartLoading() { |
| FauxtonAPI.dispatch({ |
| type: ActionTypes.DATABASES_STARTLOADING |
| }); |
| }, |
| |
| setLoadComplete() { |
| FauxtonAPI.dispatch({ |
| type: ActionTypes.DATABASES_LOADCOMPLETE |
| }); |
| }, |
| |
| createNewDatabase(databaseName, partitioned) { |
| if (_.isNull(databaseName) || databaseName.trim().length === 0) { |
| FauxtonAPI.addNotification({ |
| msg: 'Please enter a valid database name', |
| type: 'error', |
| clear: true |
| }); |
| return; |
| } |
| databaseName = databaseName.trim(); |
| // name accepted, make sure prompt can be removed |
| FauxtonAPI.dispatch({ |
| type: ActionTypes.DATABASES_SET_PROMPT_VISIBLE, |
| options: { |
| visible: false |
| } |
| }); |
| |
| const db = Stores.databasesStore.obtainNewDatabaseModel(databaseName, partitioned); |
| FauxtonAPI.addNotification({ msg: 'Creating database.' }); |
| db.save().done(() => { |
| FauxtonAPI.addNotification({ |
| msg: 'Database created successfully', |
| type: 'success', |
| clear: true |
| }); |
| const route = FauxtonAPI.urls('allDocs', 'app', app.utils.safeURLName(databaseName)); |
| app.router.navigate(route, { trigger: true }); |
| } |
| ).fail((xhr) => { |
| const responseText = JSON.parse(xhr.responseText).reason; |
| FauxtonAPI.addNotification({ |
| msg: 'Create database failed: ' + responseText, |
| type: 'error', |
| clear: true |
| }); |
| } |
| ); |
| }, |
| |
| jumpToDatabase(databaseName) { |
| if (_.isNull(databaseName) || databaseName.trim().length === 0) { |
| return; |
| } |
| |
| databaseName = databaseName.trim(); |
| |
| const url = FauxtonAPI.urls('allDocs', 'app', app.utils.safeURLName(databaseName), ''); |
| // use the next cpu tick to allow react-select to unmount prorperly |
| return setTimeout(() => { FauxtonAPI.navigate(url); }); |
| }, |
| |
| fetchAllDbsWithKey(id, callback) { |
| const query = '?' + app.utils.queryParams({ |
| startkey: JSON.stringify(id), |
| endkey: JSON.stringify(id + '\u9999'), |
| limit: 30 |
| }); |
| |
| const url = Helpers.getServerUrl(`/_all_dbs${query}`); |
| get(url).then((dbs) => { |
| const options = dbs.map(db => { |
| return { |
| value: db, |
| label: db |
| }; |
| }); |
| callback(null, { options: options }); |
| }); |
| }, |
| |
| setPartitionedDatabasesAvailable(available) { |
| const action = { |
| type: ActionTypes.DATABASES_PARTITIONED_DB_AVAILABLE, |
| options: { |
| available |
| } |
| }; |
| FauxtonAPI.dispatch(action); |
| FauxtonAPI.reduxDispatch(action); |
| }, |
| |
| checkPartitionedQueriesIsAvailable() { |
| const exts = FauxtonAPI.getExtensions(DatabasesBase.PARTITONED_DB_CHECK_EXTENSION); |
| let promises = exts.map(checkFunction => { |
| return checkFunction(); |
| }); |
| FauxtonAPI.Promise.all(promises).then(results => { |
| const isAvailable = results.every(check => check === true); |
| this.setPartitionedDatabasesAvailable(isAvailable); |
| }).catch(() => { |
| // ignore as the default is false |
| }); |
| }, |
| |
| // Fetches and sets metadata info for the selected database, which is defined by the current URL |
| // This function is intended to be called by the routers if needed by the components in the page. |
| fetchSelectedDatabaseInfo(databaseName) { |
| FauxtonAPI.reduxDispatch({ |
| type: ActionTypes.DATABASES_FETCH_SELECTED_DB_METADATA |
| }); |
| API.fetchDatabaseInfo(databaseName).then(res => { |
| if (!res.db_name) { |
| const details = res.reason ? res.reason : ''; |
| throw new Error('Failed to fetch database info. ' + details); |
| } |
| FauxtonAPI.reduxDispatch({ |
| type: ActionTypes.DATABASES_FETCH_SELECTED_DB_METADATA_SUCCESS, |
| options: { |
| metadata: res |
| } |
| }); |
| }).catch(err => { |
| FauxtonAPI.addNotification({ |
| msg: err.message, |
| type: 'error', |
| clear: true |
| }); |
| }); |
| } |
| }; |