Merge pull request #3533 from haiwen/dtable-database

dtable database

frontend/src/app.js

@@ -12,6 +12,7 @@ import DraftsView from './pages/drafts/drafts-view';
 import DraftContent from './pages/drafts/draft-content';
 import FilesActivities from './pages/dashboard/files-activities';
 import Starred from './pages/starred/starred';
+import DTable from './pages/dtable/dtable';
 import LinkedDevices from './pages/linked-devices/linked-devices';
 import editUtilties from './utils/editor-utilties';
 import ShareAdminLibraries from './pages/share-admin/libraries';
@@ -36,6 +37,7 @@ import './css/search.css';
 const FilesActivitiesWrapper = MainContentWrapper(FilesActivities);
 const DraftsViewWrapper = MainContentWrapper(DraftsView);
 const StarredWrapper = MainContentWrapper(Starred);
+const DTableWrapper = MainContentWrapper(DTable);
 const LinkedDevicesWrapper = MainContentWrapper(LinkedDevices);
 const SharedLibrariesWrapper = MainContentWrapper(SharedLibraries);
 const ShareAdminLibrariesWrapper = MainContentWrapper(ShareAdminLibraries);
@@ -233,6 +235,7 @@ class App extends Component {
                 />
               </DraftsViewWrapper>
               <StarredWrapper path={siteRoot + 'starred'} onShowSidePanel={this.onShowSidePanel} onSearchedClick={this.onSearchedClick} />
+              <DTableWrapper path={siteRoot + 'dtable'} onShowSidePanel={this.onShowSidePanel} onSearchedClick={this.onSearchedClick} />
               <LinkedDevicesWrapper path={siteRoot + 'linked-devices'} onShowSidePanel={this.onShowSidePanel} onSearchedClick={this.onSearchedClick} />
               <ShareAdminLibrariesWrapper path={siteRoot + 'share-admin-libs'} onShowSidePanel={this.onShowSidePanel} onSearchedClick={this.onSearchedClick} />
               <ShareAdminFoldersWrapper path={siteRoot + 'share-admin-folders'} onShowSidePanel={this.onShowSidePanel} onSearchedClick={this.onSearchedClick} />

frontend/src/components/dialog/create-table-dialog.js

@@ -0,0 +1,109 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Button, Modal, ModalHeader, Input, ModalBody, ModalFooter, Form, FormGroup, Label, Alert } from 'reactstrap';
+import { gettext } from '../../utils/constants';
+
+
+const propTypes = {
+  createTable: PropTypes.func.isRequired,
+  onAddTable: PropTypes.func.isRequired,
+};
+
+class CreateTableDialog extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      tableName: '',
+      errMessage: '',
+      isSubmitBtnActive: false,
+    };
+    this.newInput = React.createRef();
+  }
+
+  componentDidMount() {
+    this.newInput.focus();
+    this.newInput.setSelectionRange(0,0);
+  }
+
+  handleChange = (e) => {
+    if (!e.target.value.trim()) {
+      this.setState({isSubmitBtnActive: false});
+    } else {
+      this.setState({isSubmitBtnActive: true});
+    }
+
+    this.setState({
+      tableName: e.target.value, 
+    }) ;
+  }
+
+  handleSubmit = () => {
+    if (!this.state.isSubmitBtnActive) {
+      return;
+    }
+
+    let isValid = this.validateInputParams();
+    if (isValid) {
+      let newName = this.state.tableName.trim();
+      this.props.createTable(newName);
+    }
+  }
+
+  handleKeyPress = (e) => {
+    if (e.key === 'Enter') {
+      this.handleSubmit();
+      e.preventDefault();
+    }
+  }
+
+  toggle = () => {
+    this.props.onAddTable();
+  }
+
+  validateInputParams = () => {
+    let errMessage = '';
+    let tableName = this.state.tableName.trim();
+    if (!tableName.length) {
+      errMessage = gettext('Name is required');
+      this.setState({errMessage: errMessage});
+      return false;
+    }
+    if (tableName.indexOf('/') > -1) {
+      errMessage = gettext('Name should not include \'/\'.');
+      this.setState({errMessage: errMessage});
+      return false;
+    }
+    return true;
+  }
+
+  render() {
+    return (
+      <Modal isOpen={true} toggle={this.toggle}>
+        <ModalHeader toggle={this.toggle}>{gettext('New Table')}</ModalHeader>
+        <ModalBody>
+          <Form>
+            <FormGroup>
+              <Label for="tableName">{gettext('Name')}</Label>
+              <Input 
+                id="tableName" 
+                onKeyPress={this.handleKeyPress} 
+                innerRef={input => {this.newInput = input;}} 
+                value={this.state.tableName} 
+                onChange={this.handleChange}
+              />
+            </FormGroup>
+          </Form>
+          {this.state.errMessage && <Alert color="danger" className="mt-2">{this.state.errMessage}</Alert>}
+        </ModalBody>
+        <ModalFooter>
+          <Button color="secondary" onClick={this.toggle}>{gettext('Cancel')}</Button>
+          <Button color="primary" onClick={this.handleSubmit} disabled={!this.state.isSubmitBtnActive}>{gettext('Submit')}</Button>
+        </ModalFooter>
+      </Modal>
+    );
+  }
+}
+
+CreateTableDialog.propTypes = propTypes;
+
+export default CreateTableDialog;

frontend/src/components/dialog/create-workspace-dialog.js

@@ -0,0 +1,102 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Button, Modal, ModalHeader, Input, ModalBody, ModalFooter, Form, FormGroup, Label, Alert } from 'reactstrap';
+import { gettext } from '../../utils/constants';
+
+
+const propTypes = {
+  createWorkspace: PropTypes.func.isRequired,
+  onAddWorkspace: PropTypes.func.isRequired,
+};
+
+class CreateWorkspaceDialog extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      workspaceName: '',
+      errMessage: '',
+      isSubmitBtnActive: false,
+    };
+    this.newInput = React.createRef();
+  }
+
+  handleNameChange = (e) => {
+    if (!e.target.value.trim()) {
+      this.setState({isSubmitBtnActive: false});
+    } else {
+      this.setState({isSubmitBtnActive: true});
+    }
+
+    this.setState({workspaceName: e.target.value});
+  }
+
+  handleSubmit = () => {
+    let isValid= this.validateInputParams();
+    if (isValid) {
+      let workspaceName = this.state.workspaceName.trim();
+      this.props.createWorkspace(workspaceName);
+    }
+  } 
+
+  handleKeyPress = (e) => {
+    if (e.key === 'Enter') {
+      this.handleSubmit();
+      e.preventDefault();
+    }
+  }
+
+  toggle = () => {
+    this.props.onAddWorkspace();
+  }
+
+  componentDidMount() {
+    this.newInput.focus();
+  }
+
+  validateInputParams() {
+    let errMessage = '';
+    let workspaceName = this.state.workspaceName.trim();
+    if (!workspaceName.length) {
+      errMessage = gettext('Name is required');
+      this.setState({errMessage: errMessage});
+      return false;
+    }
+    if (workspaceName.indexOf('/') > -1) {
+      errMessage = gettext('Name should not include \'/\'.');
+      this.setState({errMessage: errMessage});
+      return false;
+    }
+    return true;
+  }
+
+  render() {
+    return (
+      <Modal isOpen={true} toggle={this.toggle}>
+        <ModalHeader toggle={this.toggle}>{gettext('New Workspace')}</ModalHeader>
+        <ModalBody>
+          <Form>
+            <FormGroup>
+              <Label for="workspaceName">{gettext('Name')}</Label>
+              <Input 
+                id="workspaceName"
+                onKeyPress={this.handleKeyPress} 
+                innerRef={input => {this.newInput = input;}} 
+                value={this.state.workspaceName} 
+                onChange={this.handleNameChange}
+              />
+            </FormGroup>
+          </Form>
+          {this.state.errMessage && <Alert color="danger">{this.state.errMessage}</Alert>}
+        </ModalBody>
+        <ModalFooter>
+          <Button color="secondary" onClick={this.toggle}>{gettext('Cancel')}</Button>
+          <Button color="primary" onClick={this.handleSubmit} disabled={!this.state.isSubmitBtnActive}>{gettext('Submit')}</Button>
+        </ModalFooter>
+      </Modal>
+    );
+  }
+}
+
+CreateWorkspaceDialog.propTypes = propTypes;
+
+export default CreateWorkspaceDialog;

frontend/src/components/dialog/delete-table-dialog.js

@@ -0,0 +1,39 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { gettext } from '../../utils/constants';
+import { Button, Modal, ModalHeader, ModalBody, ModalFooter } from 'reactstrap';
+
+const propTypes = {
+  currentTable: PropTypes.object.isRequired,
+  deleteCancel: PropTypes.func.isRequired,
+  handleSubmit: PropTypes.func.isRequired,
+};
+
+class DeleteTableDialog extends React.Component {
+
+  toggle = () => {
+    this.props.deleteCancel();
+  }
+  
+  render() {
+    let currentTable = this.props.currentTable;
+    let name = currentTable.name;
+
+    return (
+      <Modal isOpen={true} toggle={this.toggle}>
+        <ModalHeader toggle={this.toggle}>{gettext('Delete Table')}</ModalHeader>
+        <ModalBody>
+          <p>{gettext('Are you sure to delete')}{' '}<b>{name}</b> ?</p>
+        </ModalBody>
+        <ModalFooter>
+          <Button color="secondary" onClick={this.toggle}>{gettext('Cancel')}</Button>
+          <Button color="primary" onClick={this.props.handleSubmit}>{gettext('Delete')}</Button>
+        </ModalFooter>
+      </Modal>
+    );
+  }
+}
+
+DeleteTableDialog.propTypes = propTypes;
+
+export default DeleteTableDialog;

frontend/src/components/dialog/delete-workspace-dialog.js

@@ -0,0 +1,39 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { gettext } from '../../utils/constants';
+import { Button, Modal, ModalHeader, ModalBody, ModalFooter } from 'reactstrap';
+
+const propTypes = {
+  currentWorkspace: PropTypes.object.isRequired,
+  deleteCancel: PropTypes.func.isRequired,
+  handleSubmit: PropTypes.func.isRequired,
+};
+
+class DeleteWorkspaceDialog extends React.Component {
+
+  toggle = () => {
+    this.props.deleteCancel();
+  }
+  
+  render() {
+    let currentWorkspace = this.props.currentWorkspace;
+    let name = currentWorkspace.name;
+
+    return (
+      <Modal isOpen={true} toggle={this.toggle}>
+        <ModalHeader toggle={this.toggle}>{gettext('Delete Workspace')}</ModalHeader>
+        <ModalBody>
+          <p>{gettext('Are you sure to delete')}{' '}<b>{name}</b> ?</p>
+        </ModalBody>
+        <ModalFooter>
+          <Button color="secondary" onClick={this.toggle}>{gettext('Cancel')}</Button>
+          <Button color="primary" onClick={this.props.handleSubmit}>{gettext('Delete')}</Button>
+        </ModalFooter>
+      </Modal>
+    );
+  }
+}
+
+DeleteWorkspaceDialog.propTypes = propTypes;
+
+export default DeleteWorkspaceDialog;

frontend/src/components/main-side-nav.js

@@ -182,6 +182,16 @@ class MainSideNav extends React.Component {
             </li>
           </ul>
 
+          <h3 className="sf-heading">{gettext('Database')}</h3>
+          <ul className="nav nav-pills flex-column nav-container">
+            <li className="nav-item">
+              <Link className={`nav-link ellipsis ${this.getActiveClass('dtable')}`} to={siteRoot + 'dtable/'} title='DTable' onClick={() => this.tabItemClick('dtable')}>
+                <span className="sf2-icon-star" aria-hidden="true"></span>
+                <span className="nav-text">DTable</span>
+              </Link>
+            </li>
+          </ul>
+
           <h3 className="sf-heading">{gettext('Tools')}</h3>
           <ul className="nav nav-pills flex-column nav-container">
             <li className="nav-item">

frontend/src/pages/data-grid/app-main.js

@@ -9,7 +9,7 @@ import GridHeaderContextMenu from './grid-header-contextmenu';
 import GridContentContextMenu from './grid-content-contextmenu';
 import DTableStore from './store/dtable-store';
 
-const { repoID, filePath } = window.app.pageOptions;
+const { workspaceID, fileName } = window.app.pageOptions;
 
 const DEFAULT_DATA = {
   columns:  [
@@ -38,7 +38,7 @@ class AppMain extends React.Component {
 
   componentDidMount() {
 
-    seafileAPI.getFileDownloadLink(repoID, filePath).then(res => {
+    seafileAPI.getTableDownloadLink(workspaceID, fileName).then(res => {
       let url = res.data;
       seafileAPI.getFileContent(url).then(res => {
         let data = res.data ? res.data : JSON.stringify(DEFAULT_DATA);

frontend/src/pages/dtable/dtable.js

@@ -0,0 +1,458 @@
+import React, { Component, Fragment } from 'react';
+import PropTypes from 'prop-types';
+import { Button, Dropdown, DropdownToggle, DropdownMenu, DropdownItem } from 'reactstrap';
+import moment from 'moment';
+import { seafileAPI } from '../../utils/seafile-api';
+import { gettext, siteRoot } from '../../utils/constants';
+import Loading from '../../components/loading';
+import CreateWorkspaceDialog from '../../components/dialog/create-workspace-dialog';
+import DeleteWorkspaceDialog from '../../components/dialog/delete-workspace-dialog';
+import CreateTableDialog from '../../components/dialog/create-table-dialog';
+import DeleteTableDialog from '../../components/dialog/delete-table-dialog';
+import Rename from '../../components/rename';
+
+moment.locale(window.app.config.lang);
+
+
+const tablePropTypes = {
+  table: PropTypes.object.isRequired,
+  workspaceID: PropTypes.string.isRequired,
+  renameTable: PropTypes.func.isRequired,
+  deleteTable: PropTypes.func.isRequired,
+};
+
+class Table extends Component {
+
+  constructor(props) {
+    super(props);
+    this.state = {
+      isTableRenaming: false,
+      isTableDeleting: false,
+      dropdownOpen: false,
+      active: false,
+    };
+  }
+
+  onRenameTableCancel = () => {
+    this.setState({isTableRenaming: !this.state.isTableRenaming});
+  }
+
+  onRenameTableConfirm = (newTableName) => {
+    let oldTableName = this.props.table.name;
+    this.props.renameTable(oldTableName, newTableName);
+    this.onRenameTableCancel();
+  }
+
+  onDeleteTableCancel = () => {
+    this.setState({isTableDeleting: !this.state.isTableDeleting});
+  }
+
+  onDeleteTableSubmit = () => {
+    let tableName = this.props.table.name;
+    console.log(tableName);
+    this.props.deleteTable(tableName);
+    this.onDeleteTableCancel();
+  }
+
+  dropdownToggle = () => {
+    this.setState({ dropdownOpen: !this.state.dropdownOpen });
+  }
+
+  onMouseEnter = () => {
+    this.setState({
+      active: true
+    });
+  }
+
+  onMouseLeave = () => {
+    this.setState({
+      active: false
+    });
+  }
+
+  render() {
+
+    let table = this.props.table;
+    let tableHref = siteRoot + 'workspace/' + this.props.workspaceID + '/dtable/' + table.name + '/';
+
+    return (
+      <tr onMouseEnter={this.onMouseEnter} onMouseLeave={this.onMouseLeave}>
+        <td></td>
+        <td>
+          {this.state.isTableRenaming &&
+            <Rename
+              hasSuffix={true}
+              name={table.name}
+              onRenameConfirm={this.onRenameTableConfirm}
+              onRenameCancel={this.onRenameTableCancel}
+            />
+          }
+          {!this.state.isTableRenaming &&
+            <a href={tableHref} target="_blank">{table.name}</a>
+          }
+        </td>
+        <td>{table.modifier}</td>
+        <td>{moment(table.mtime).fromNow()}</td>
+        <td>
+          {this.state.active &&
+            <Dropdown isOpen={this.state.dropdownOpen} toggle={this.dropdownToggle} direction="down" className="mx-1 old-history-more-operation">
+              <DropdownToggle
+                tag='i'
+                className='fa fa-ellipsis-v'
+                title={gettext('More Operations')}
+                data-toggle="dropdown" 
+                aria-expanded={this.state.dropdownOpen}
+              >
+              </DropdownToggle>
+              <DropdownMenu className="drop-list" right={true}>
+                <DropdownItem onClick={this.onRenameTableCancel}>{gettext('Rename')}</DropdownItem>
+                <DropdownItem onClick={this.onDeleteTableCancel}>{gettext('Delete')}</DropdownItem>
+              </DropdownMenu>
+            </Dropdown>
+          }
+          {this.state.isTableDeleting &&
+            <DeleteTableDialog
+              currentTable={table}
+              deleteCancel={this.onDeleteTableCancel}
+              handleSubmit={this.onDeleteTableSubmit}
+            />
+          }
+        </td>
+      </tr>
+    );
+  }
+}
+
+Table.propTypes = tablePropTypes;
+
+
+const workspacePropTypes = {
+  workspace: PropTypes.object.isRequired,
+  renameWorkspace: PropTypes.func.isRequired,
+  deleteWorkspace: PropTypes.func.isRequired,
+};
+
+class Workspace extends Component {
+
+  constructor(props) {
+    super(props);
+    this.state = {
+      tableList: this.props.workspace.table_list,
+      errorMsg: '',
+      isWorkspaceRenaming: false,
+      isWorkspaceDeleting: false,
+      isShowAddTableDialog: false,
+      dropdownOpen: false,
+    };
+  }
+
+  onAddTable = () => {
+    this.setState({
+      isShowAddTableDialog: !this.state.isShowAddTableDialog,
+    });
+  }
+
+  createTable = (tableName) => {
+    let workspaceID = this.props.workspace.id;
+    seafileAPI.createTable(workspaceID, tableName).then((res) => {
+      this.state.tableList.push(res.data.table);
+      this.setState({tableList: this.state.tableList});
+    }).catch((error) => {
+      if(error.response) {
+        this.setState({errorMsg: gettext('Error')});
+      }
+    });
+    this.onAddTable();
+  }
+
+  renameTable = (oldTableName, newTableName) => {
+    let workspaceID = this.props.workspace.id;
+    seafileAPI.renameTable(workspaceID, oldTableName, newTableName).then((res) => {
+      let tableList = this.state.tableList.map((table) => {
+        if (table.name === oldTableName) {
+          table = res.data.table;
+        }
+        return table;
+      });
+      this.setState({tableList: tableList});
+    }).catch((error) => {
+      if(error.response) {
+        this.setState({errorMsg: gettext('Error')});
+      }
+    });
+  }
+
+  deleteTable = (tableName) => {
+    let workspaceID = this.props.workspace.id;
+    seafileAPI.deleteTable(workspaceID, tableName).then(() => {
+      let tableList = this.state.tableList.filter(table => {
+        return table.name !== tableName;
+      });
+      this.setState({tableList: tableList});
+    }).catch((error) => {
+      if(error.response) {
+        this.setState({errorMsg: gettext('Error')});
+      }
+    });
+  }
+
+  onRenameWorkspaceCancel = () => {
+    this.setState({isWorkspaceRenaming: !this.state.isWorkspaceRenaming});
+  }
+
+  onRenameWorkspaceConfirm = (newName) => {
+    let workspace = this.props.workspace;
+    this.props.renameWorkspace(workspace, newName);
+    this.onRenameWorkspaceCancel();
+  }
+
+  onDeleteWorkspaceCancel = () => {
+    this.setState({isWorkspaceDeleting: !this.state.isWorkspaceDeleting});
+  }
+
+  onDeleteWorkspaceSubmit = () => {
+    let workspace = this.props.workspace;
+    this.props.deleteWorkspace(workspace);
+    this.onDeleteWorkspaceCancel();
+  }
+
+  dropdownToggle = () => {
+    this.setState({ dropdownOpen: !this.state.dropdownOpen });
+  }
+
+  render() {
+    let workspace = this.props.workspace;
+
+    return(
+      <Fragment>
+        <tr>
+          <td colSpan='5'>
+            {this.state.isWorkspaceRenaming &&
+              <Rename
+                hasSuffix={false}
+                name={workspace.name}
+                onRenameConfirm={this.onRenameWorkspaceConfirm}
+                onRenameCancel={this.onRenameWorkspaceCancel}
+              />
+            }
+            {!this.state.isWorkspaceRenaming &&
+              <div>
+                {workspace.name}
+                <Dropdown isOpen={this.state.dropdownOpen} toggle={this.dropdownToggle} direction="down">
+                  <DropdownToggle
+                    caret={true}
+                    tag='i'
+                    title={gettext('More Operations')}
+                    data-toggle="dropdown" 
+                    aria-expanded={this.state.dropdownOpen}
+                  >
+                  </DropdownToggle>
+                  <DropdownMenu className="drop-list" right={true}>
+                    <DropdownItem onClick={this.onRenameWorkspaceCancel}>{gettext('Rename')}</DropdownItem>
+                    <DropdownItem onClick={this.onDeleteWorkspaceCancel}>{gettext('Delete')}</DropdownItem>
+                  </DropdownMenu>
+                </Dropdown>
+                {this.state.isWorkspaceDeleting &&
+                  <DeleteWorkspaceDialog
+                    currentWorkspace={workspace}
+                    deleteCancel={this.onDeleteWorkspaceCancel}
+                    handleSubmit={this.onDeleteWorkspaceSubmit}
+                  />
+                }
+              </div>
+            }
+          </td>
+        </tr>
+        {this.state.tableList.map((table, index) => {
+          return (
+            <Table
+              key={index}
+              table={table}
+              workspaceID={workspace.id}
+              renameTable={this.renameTable}
+              deleteTable={this.deleteTable}
+            />
+          );
+        })}
+        <tr>
+          <td>
+            <Button className="fa fa-plus" onClick={this.onAddTable}></Button>
+            {this.state.isShowAddTableDialog &&
+              <CreateTableDialog
+                onAddTable={this.onAddTable}
+                createTable={this.createTable}
+              />
+            }
+          </td>
+          <td colSpan='4' >{gettext('Add a DTable')}</td>
+        </tr>
+      </Fragment>
+    );
+  }
+}
+
+Workspace.propTypes = workspacePropTypes;
+
+
+const contentPropTypes = {
+  workspaceList: PropTypes.array.isRequired,
+  renameWorkspace: PropTypes.func.isRequired,
+  deleteWorkspace: PropTypes.func.isRequired,
+};
+
+class Content extends Component {
+
+  render() {
+    let workspaceList = this.props.workspaceList;
+
+    return ( 
+      <table width="100%" className="table table-hover table-vcenter">
+        <colgroup>
+          <col width="5%"/>
+          <col width="30%"/>
+          <col width="30%"/>
+          <col width="30%"/>
+          <col width="5%"/>
+        </colgroup>
+        <tbody>
+          {workspaceList.map((workspace, index) => {
+            return (
+              <Workspace
+                key={index}
+                workspace={workspace}
+                renameWorkspace={this.props.renameWorkspace}
+                deleteWorkspace={this.props.deleteWorkspace}
+              />
+            );
+          })}
+        </tbody>
+      </table>
+    );
+  }
+}
+
+Content.propTypes = contentPropTypes;
+
+
+class DTable extends Component {
+  constructor(props) {
+    super(props);
+    this.state = {
+      loading: true,
+      errorMsg: '',
+      workspaceList: [],
+      isShowAddWorkspaceDialog: false,
+    };
+  }
+
+  onAddWorkspace = () => {
+    this.setState({
+      isShowAddWorkspaceDialog: !this.state.isShowAddWorkspaceDialog,
+    });
+  }
+
+  createWorkspace = (name) => {
+    seafileAPI.createWorkspace(name).then((res) => {
+      this.state.workspaceList.push(res.data.workspace);
+      this.setState({workspaceList: this.state.workspaceList});
+    }).catch((error) => {
+      if(error.response) {
+        this.setState({errorMsg: gettext('Error')});
+      }
+    });
+    this.onAddWorkspace();
+  }
+
+  renameWorkspace = (workspace, name) => {
+    let workspaceID = workspace.id;
+    seafileAPI.renameWorkspace(workspaceID, name).then((res) => {
+      let workspaceList = this.state.workspaceList.map((workspace) => {
+        if (workspace.id === workspaceID) {
+          workspace = res.data.workspace;
+        }
+        return workspace;
+      });
+      this.setState({workspaceList: workspaceList});
+    }).catch((error) => {
+      if(error.response) {
+        this.setState({errorMsg: gettext('Error')});
+      }
+    });
+  }
+
+  deleteWorkspace = (workspace) => {
+    let workspaceID = workspace.id;
+    seafileAPI.deleteWorkspace(workspaceID).then(() => {
+      let workspaceList = this.state.workspaceList.filter(workspace => {
+        return workspace.id !== workspaceID;
+      });
+      this.setState({workspaceList: workspaceList});
+    }).catch((error) => {
+      if(error.response) {
+        this.setState({errorMsg: gettext('Error')});
+      }
+    });
+  }
+
+  componentDidMount() {
+    seafileAPI.listWorkspaces().then((res) => {
+      this.setState({
+        loading: false,
+        workspaceList: res.data.workspace_list,
+      });
+    }).catch((error) => {
+      if (error.response) {
+        this.setState({
+          loading: false,
+          errorMsg: gettext('Error')
+        });
+      } else {
+        this.setState({
+          loading: false,
+          errorMsg: gettext('Please check the network.')
+        });
+      }
+    });
+  }
+
+  render() {
+    return (
+      <div className="main-panel-center">
+        <div className="cur-view-container" id="starred">
+          <div className="cur-view-path">
+            <h3 className="sf-heading">DTable</h3>
+          </div>
+          <div className="cur-view-content">
+            {this.state.loading && <Loading />}
+            {(!this.state.loading && this.state.errorMsg) && 
+              <p className="error text-center">{this.state.errorMsg}</p>
+            }
+            {!this.state.loading &&
+              <Fragment>
+                <Content
+                  workspaceList={this.state.workspaceList}
+                  renameWorkspace={this.renameWorkspace}
+                  deleteWorkspace={this.deleteWorkspace}
+                />
+                <br />
+                <div>
+                  <Button onClick={this.onAddWorkspace} className="fa fa-plus">
+                    {gettext('Add a Workspace')}
+                  </Button>
+                  {this.state.isShowAddWorkspaceDialog &&
+                    <CreateWorkspaceDialog
+                      createWorkspace={this.createWorkspace}
+                      onAddWorkspace={this.onAddWorkspace}
+                    />
+                  }
+                </div>
+              </Fragment>
+            }
+          </div>
+        </div>
+      </div>
+    );
+  }
+}
+
+export default DTable;

frontend/src/utils/constants.js

@@ -54,6 +54,9 @@ export const canLockUnlockFile = window.app.pageOptions.canLockUnlockFile;
 export const curNoteMsg = window.app.pageOptions.curNoteMsg;
 export const curNoteID = window.app.pageOptions.curNoteID;
 
+// ctable
+export const workspaceID = window.app.pageOptions.workspaceID;
+
 // wiki
 export const slug = window.wiki ? window.wiki.config.slug : '';
 export const repoID = window.wiki ? window.wiki.config.repoId : '';

frontend/src/view-file-ctable.js

@@ -11,7 +11,7 @@ import './css/layout.css';
 import './css/file-view-data-grid.css';
 import './css/react-context-menu.css';
 
-const { repoID, fileName, filePath } = window.app.pageOptions;
+const { workspaceID, fileName, filePath } = window.app.pageOptions;
 
 class ViewFileSDB extends React.Component {
 
@@ -31,8 +31,7 @@ class ViewFileSDB extends React.Component {
 
     let data = this.refs.data_grid.serializeGridData();
 
-    let dirPath = Utils.getDirName(filePath);
+    seafileAPI.getTableUpdateLink(workspaceID).then(res => {
-    seafileAPI.getUpdateLink(repoID, dirPath).then(res => {
       let updateLink = res.data;
       seafileAPI.updateFile(updateLink, filePath, fileName, JSON.stringify(data)).then(res => {
         toaster.success(gettext('File saved.'));

seahub/api2/endpoints/dtable.py

@@ -0,0 +1,558 @@
+# -*- coding: utf-8 -*-
+
+import logging
+
+from rest_framework.views import APIView
+from rest_framework.authentication import SessionAuthentication
+from rest_framework.permissions import IsAuthenticated
+from rest_framework import status
+from rest_framework.response import Response
+from django.http import Http404
+from django.shortcuts import render
+from django.utils.translation import ugettext as _
+
+from pysearpc import SearpcError
+from seaserv import seafile_api, edit_repo, check_quota
+
+from seahub.api2.authentication import TokenAuthentication
+from seahub.api2.throttling import UserRateThrottle
+from seahub.api2.utils import api_error
+from seahub.api2.views import get_repo_file, HTTP_443_ABOVE_QUOTA
+from seahub.dtable.models import Workspaces
+from seahub.base.templatetags.seahub_tags import email2nickname
+from seahub.utils.timeutils import timestamp_to_isoformat_timestr
+from seahub.utils import is_valid_dirent_name, is_org_context, normalize_file_path, \
+     check_filename_with_rename, render_error, render_permission_error, gen_file_upload_url, \
+     get_file_type_and_ext, CTABLE
+from seahub.views.file import send_file_access_msg
+from seahub.auth.decorators import login_required
+from seahub.settings import MAX_UPLOAD_FILE_NAME_LEN, SHARE_LINK_EXPIRE_DAYS_MIN, \
+     SHARE_LINK_EXPIRE_DAYS_MAX, SHARE_LINK_EXPIRE_DAYS_DEFAULT
+
+
+logger = logging.getLogger(__name__)
+
+
+class WorkspacesView(APIView):
+
+    authentication_classes = (TokenAuthentication, SessionAuthentication)
+    permission_classes = (IsAuthenticated, )
+    throttle_classes = (UserRateThrottle, )
+
+    def get(self, request):
+        """get all workspaces
+        """
+        owner = request.user.username
+        try:
+            workspaces = Workspaces.objects.get_workspaces_by_owner(owner)
+        except Exception as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error.'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        workspace_list = []
+        for workspace in workspaces:
+            repo_id = workspace.repo_id
+            repo = seafile_api.get_repo(repo_id)
+            if not repo:
+                logger.warning('Library %s not found.' % repo_id)
+                continue
+
+            table_objs = seafile_api.list_dir_by_path(repo_id, '/')
+            table_list = list()
+            for table_obj in table_objs:
+                table = dict()
+                table["name"] = table_obj.obj_name
+                table["mtime"] = timestamp_to_isoformat_timestr(table_obj.mtime)
+                table["modifier"] = email2nickname(table_obj.modifier) if table_obj.modifier else email2nickname(owner)
+                table_list.append(table)
+
+            res = workspace.to_dict()
+            res["table_list"] = table_list
+            res["updated_at"] = workspace.updated_at
+            workspace_list.append(res)
+
+        return Response({"workspace_list": workspace_list}, status=status.HTTP_200_OK)
+
+    def post(self, request):
+        """create a workspace
+        """
+        # argument check
+        name = request.POST.get('name')
+        if not name:
+            error_msg = 'name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        if not is_valid_dirent_name(name):
+            error_msg = 'name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        # permission check
+        if not request.user.permissions.can_add_repo():
+            error_msg = 'You do not have permission to create workspace.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        org_id = -1
+        if is_org_context(request):
+            org_id = request.user.org.org_id
+
+        try:
+            if org_id > 0:
+                repo_id = seafile_api.create_org_repo(name, '', "dtable@seafile", org_id)
+            else:
+                repo_id = seafile_api.create_repo(name, '', "dtable@seafile")
+        except Exception as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error.'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        owner = request.user.username
+        try:
+            workspace = Workspaces.objects.create_workspace(name, owner, repo_id)
+        except Exception as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error.'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        res = workspace.to_dict()
+        res["table_list"] = []
+        res["updated_at"] = workspace.updated_at
+
+        return Response({"workspace": res}, status=status.HTTP_201_CREATED)
+
+
+class WorkspaceView(APIView):
+
+    authentication_classes = (TokenAuthentication, SessionAuthentication)
+    permission_classes = (IsAuthenticated, )
+    throttle_classes = (UserRateThrottle, )
+
+    def put(self, request, workspace_id):
+        """rename a workspace
+        """
+        # argument check
+        workspace_name = request.data.get('name')
+        if not workspace_name:
+            error_msg = 'name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        if not is_valid_dirent_name(workspace_name):
+            error_msg = 'name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        # resource check
+        workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+        if not workspace:
+            error_msg = 'Workspace %s not found.' % workspace_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        repo_id = workspace.repo_id
+        repo = seafile_api.get_repo(repo_id)
+        if not repo:
+            error_msg = 'Library %s not found.' % repo_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        # permission check
+        username = request.user.username
+        owner = workspace.owner
+        if username != owner:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        # repo status check
+        repo_status = repo.status
+        if repo_status != 0:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        try:
+            edit_repo(repo_id, workspace_name, '', username)
+        except Exception as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error.'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        try:
+            workspace.name = workspace_name
+            workspace.save()
+        except Exception as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error.'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        table_objs = seafile_api.list_dir_by_path(repo_id, '/')
+        table_list = list()
+        for table_obj in table_objs:
+            table = dict()
+            table["name"] = table_obj.obj_name
+            table["mtime"] = timestamp_to_isoformat_timestr(table_obj.mtime)
+            table["modifier"] = email2nickname(table_obj.modifier) if table_obj.modifier else email2nickname(owner)
+            table_list.append(table)
+
+        res = workspace.to_dict()
+        res["table_list"] = table_list
+        res["updated_at"] = workspace.updated_at
+
+        return Response({"workspace": res}, status=status.HTTP_200_OK)
+
+    def delete(self, request, workspace_id):
+        """delete a workspace
+        """
+        # resource check
+        workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+        if not workspace:
+            return Response({'success': True}, status=status.HTTP_200_OK)
+
+        repo_id = workspace.repo_id
+        repo = seafile_api.get_repo(repo_id)
+        if not repo:
+            logger.warning('Library %s not found.' % repo_id)
+
+        # permission check
+        username = request.user.username
+        owner = workspace.owner
+        if username != owner:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        if repo:
+
+            # repo status check
+            repo_status = repo.status
+            if repo_status != 0:
+                error_msg = 'Permission denied.'
+                return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+            # remove repo
+            try:
+                seafile_api.remove_repo(repo_id)
+            except Exception as e:
+                logger.error(e)
+                error_msg = 'Internal Server Error.'
+                return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        try:
+            Workspaces.objects.delete_workspace(workspace_id)
+        except Exception as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error.'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        return Response({"success": "true"}, status=status.HTTP_200_OK)
+
+
+class DTableView(APIView):
+
+    authentication_classes = (TokenAuthentication, SessionAuthentication)
+    permission_classes = (IsAuthenticated, )
+    throttle_classes = (UserRateThrottle, )
+
+    def get(self, request, workspace_id):
+        """view table file, get table download link
+        """
+        # argument check
+        table_name = request.GET.get('name', None)
+        if not table_name:
+            error_msg = 'name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        reuse = request.GET.get('reuse', '0')
+        if reuse not in ('1', '0'):
+            error_msg = 'reuse invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        # resource check
+        workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+        if not workspace:
+            error_msg = 'Workspace %s not found.' % workspace_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        repo_id = workspace.repo_id
+        repo = seafile_api.get_repo(repo_id)
+        if not repo:
+            error_msg = 'Library %s not found.' % repo_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        table_path = normalize_file_path(table_name)
+        table_file_id = seafile_api.get_file_id_by_path(repo_id, table_path)
+        if not table_file_id:
+            error_msg = 'Library %s not found.' % repo_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        # permission check
+        username = request.user.username
+        owner = workspace.owner
+        if username != owner:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        # send stats message
+        send_file_access_msg(request, repo, table_path, 'api')
+
+        op = request.GET.get('op', 'download')
+        use_onetime = False if reuse == '1' else True
+        return get_repo_file(request, repo_id, table_file_id, table_name, op, use_onetime)
+
+    def post(self, request, workspace_id):
+        """create a table file
+        """
+        # argument check
+        table_name = request.POST.get('name')
+        if not table_name:
+            error_msg = 'name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        if not is_valid_dirent_name(table_name):
+            error_msg = 'name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        # resource check
+        workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+        if not workspace:
+            error_msg = 'Workspace %s not found.' % workspace_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        repo_id = workspace.repo_id
+        repo = seafile_api.get_repo(repo_id)
+        if not repo:
+            error_msg = 'Library %s not found.' % repo_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        # permission check
+        username = request.user.username
+        owner = workspace.owner
+        if username != owner:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        # repo status check
+        repo_status = repo.status
+        if repo_status != 0:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        # create new empty table
+        table_name = check_filename_with_rename(repo_id, '/', table_name)
+
+        try:
+            seafile_api.post_empty_file(repo_id, '/', table_name, owner)
+        except SearpcError, e:
+            logger.error(e)
+            error_msg = 'Internal Server Error'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        table_path = normalize_file_path(table_name)
+        table_obj = seafile_api.get_dirent_by_path(repo_id, table_path)
+        table = dict()
+        table["name"] = table_obj.obj_name
+        table["mtime"] = timestamp_to_isoformat_timestr(table_obj.mtime)
+        table["modifier"] = email2nickname(table_obj.modifier) if table_obj.modifier else email2nickname(owner)
+
+        return Response({"table": table}, status=status.HTTP_201_CREATED)
+
+    def put(self, request, workspace_id):
+        """rename a table
+        """
+        # argument check
+        old_table_name = request.data.get('old_name')
+        if not old_table_name:
+            error_msg = 'old_name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        new_table_name = request.data.get('new_name')
+        if not new_table_name:
+            error_msg = 'new_name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        if not is_valid_dirent_name(new_table_name):
+            error_msg = 'new_name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        if len(new_table_name) > MAX_UPLOAD_FILE_NAME_LEN:
+            error_msg = 'new_name is too long.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        # resource check
+        workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+        if not workspace:
+            error_msg = 'Workspace %s not found.' % workspace_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        repo_id = workspace.repo_id
+        repo = seafile_api.get_repo(repo_id)
+        if not repo:
+            error_msg = 'Library %s not found.' % repo_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        old_table_path = normalize_file_path(old_table_name)
+        table_file_id = seafile_api.get_file_id_by_path(repo_id, old_table_path)
+        if not table_file_id:
+            error_msg = 'table %s not found.' % old_table_name
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        # permission check
+        username = request.user.username
+        owner = workspace.owner
+        if username != owner:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        # repo status check
+        repo_status = repo.status
+        if repo_status != 0:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        # rename table
+        new_table_name = check_filename_with_rename(repo_id, '/', new_table_name)
+        try:
+            seafile_api.rename_file(repo_id, '/', old_table_name, new_table_name, owner)
+        except SearpcError as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        new_table_path = normalize_file_path(new_table_name)
+        table_obj = seafile_api.get_dirent_by_path(repo_id, new_table_path)
+        table = dict()
+        table["name"] = table_obj.obj_name
+        table["mtime"] = timestamp_to_isoformat_timestr(table_obj.mtime)
+        table["modifier"] = email2nickname(table_obj.modifier) if table_obj.modifier else email2nickname(owner)
+
+        return Response({"table": table}, status=status.HTTP_200_OK)
+
+    def delete(self, request, workspace_id):
+        """delete a table
+        """
+        # argument check
+        table_name = request.data.get('name')
+        if not table_name:
+            error_msg = 'name invalid.'
+            return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
+
+        # resource check
+        workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+        if not workspace:
+            error_msg = 'Workspace %s not found.' % workspace_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        repo_id = workspace.repo_id
+        repo = seafile_api.get_repo(repo_id)
+        if not repo:
+            error_msg = 'Library %s not found.' % repo_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        table_path = normalize_file_path(table_name)
+        table_file_id = seafile_api.get_file_id_by_path(repo_id, table_path)
+        if not table_file_id:
+            return Response({'success': True}, status=status.HTTP_200_OK)
+
+        # permission check
+        username = request.user.username
+        owner = workspace.owner
+        if username != owner:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        # repo status check
+        repo_status = repo.status
+        if repo_status != 0:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        # delete table
+        try:
+            seafile_api.del_file(repo_id, '/', table_name, owner)
+        except SearpcError as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        return Response({'success': True}, status=status.HTTP_200_OK)
+
+
+class DTableUpdateLinkView(APIView):
+
+    authentication_classes = (TokenAuthentication, SessionAuthentication)
+    permission_classes = (IsAuthenticated,)
+    throttle_classes = (UserRateThrottle,)
+
+    def get(self, request, workspace_id):
+        """get table file update link
+        """
+        # resource check
+        workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+        if not workspace:
+            error_msg = 'Workspace %s not found.' % workspace_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        repo_id = workspace.repo_id
+        repo = seafile_api.get_repo(repo_id)
+        if not repo:
+            error_msg = 'Library %s not found.' % repo_id
+            return api_error(status.HTTP_404_NOT_FOUND, error_msg)
+
+        # permission check
+        username = request.user.username
+        owner = workspace.owner
+        if username != owner:
+            error_msg = 'Permission denied.'
+            return api_error(status.HTTP_403_FORBIDDEN, error_msg)
+
+        if check_quota(repo_id) < 0:
+            return api_error(HTTP_443_ABOVE_QUOTA, _(u"Out of quota."))
+
+        try:
+            token = seafile_api.get_fileserver_access_token(repo_id, 'dummy', 'update',
+                                                            request.user.username, use_onetime=False)
+        except Exception as e:
+            logger.error(e)
+            error_msg = 'Internal Server Error'
+            return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
+
+        url = gen_file_upload_url(token, 'update-api')
+        return Response(url)
+
+
+@login_required
+def dtable_file_view(request, workspace_id, name):
+
+    # resource check
+    workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+    if not workspace:
+        raise Http404
+
+    repo_id = workspace.repo_id
+    repo = seafile_api.get_repo(repo_id)
+    if not repo:
+        raise Http404
+
+    table_path = normalize_file_path(name)
+    table_file_id = seafile_api.get_file_id_by_path(repo_id, table_path)
+    if not table_file_id:
+        return render_error(request, _(u'Table does not exist'))
+
+    # permission check
+    username = request.user.username
+    owner = workspace.owner
+    if username != owner:
+        return render_permission_error(request, _(u'Unable to view file'))
+
+    filetype, fileext = get_file_type_and_ext(name)
+
+    return_dict = {
+        'share_link_expire_days_default': SHARE_LINK_EXPIRE_DAYS_DEFAULT,
+        'share_link_expire_days_min': SHARE_LINK_EXPIRE_DAYS_MIN,
+        'share_link_expire_days_max': SHARE_LINK_EXPIRE_DAYS_MAX,
+    }
+
+    if filetype == CTABLE:
+        return_dict['repo'] = repo
+        return_dict['workspace_id'] = workspace_id
+        return_dict['path'] = table_path
+        return_dict['filename'] = name
+        return_dict['filetype'] = filetype
+        return render(request, 'ctable_file_view_react.html', return_dict)
+    else:
+        return_dict['err'] = "File preview unsupported"
+        return render(request, 'unknown_file_view_react.html', return_dict)

seahub/dtable/apps.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.apps import AppConfig
+
+
+class DtableConfig(AppConfig):
+    name = 'dtable'

seahub/dtable/migrations/0001_initial.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.11.15 on 2019-05-24 03:56
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import seahub.base.fields
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='WorkSpaces',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', seahub.base.fields.LowerCaseCharField(max_length=255)),
+                ('owner', models.CharField(max_length=255)),
+                ('repo_id', models.CharField(db_index=True, max_length=36)),
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
+            ],
+            options={
+                'db_table': 'workspaces',
+            },
+        ),
+        migrations.AlterUniqueTogether(
+            name='workspaces',
+            unique_together=set([('owner', 'repo_id')]),
+        ),
+    ]

seahub/dtable/models.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+from django.db import models
+from seaserv import seafile_api
+
+from seahub.base.fields import LowerCaseCharField
+from seahub.utils.timeutils import timestamp_to_isoformat_timestr, datetime_to_isoformat_timestr
+
+
+class WorkspacesManager(models.Manager):
+
+    def get_workspaces_by_owner(self, owner):
+        try:
+            return super(WorkspacesManager, self).filter(owner=owner)
+        except self.model.DoesNotExist:
+            return None
+
+    def get_workspace_by_id(self, workspace_id):
+        try:
+            return super(WorkspacesManager, self).get(pk=workspace_id)
+        except self.model.DoesNotExist:
+            return None
+
+    def create_workspace(self, name, owner, repo_id):
+        try:
+            return super(WorkspacesManager, self).get(name=name, owner=owner, repo_id=repo_id)
+        except self.model.DoesNotExist:
+            workspace = self.model(name=name, owner=owner, repo_id=repo_id)
+            workspace.save()
+            return workspace
+
+    def delete_workspace(self, workspace_id):
+        try:
+            workspace = super(WorkspacesManager, self).get(pk=workspace_id)
+            workspace.delete()
+            return True
+        except self.model.DoesNotExist:
+            return False
+
+
+class Workspaces(models.Model):
+
+    name = LowerCaseCharField(max_length=255)
+    owner = models.CharField(max_length=255)
+    repo_id = models.CharField(max_length=36, db_index=True)
+    created_at = models.DateTimeField(auto_now_add=True, db_index=True)
+
+    objects = WorkspacesManager()
+
+    class Meta:
+        unique_together = (('owner', 'repo_id'),)
+        db_table = 'workspaces'
+
+    @property
+    def updated_at(self):
+        assert len(self.repo_id) == 36
+
+        repo = seafile_api.get_repo(self.repo_id)
+        if not repo:
+            return ''
+
+        return timestamp_to_isoformat_timestr(repo.last_modify)
+
+    def to_dict(self):
+
+        return {
+            'id': self.pk,
+            'name': self.name,
+            'owner': self.owner,
+            'repo_id': self.repo_id,
+            'created_at': datetime_to_isoformat_timestr(self.created_at),
+        }

seahub/settings.py

@@ -258,6 +258,7 @@ INSTALLED_APPS = (
     'seahub.file_tags',
     'seahub.related_files',
     'seahub.work_weixin',
+    'seahub.dtable',
 )
 
 # Enable or disable view File Scan

seahub/templates/file_view_react.html

@@ -41,6 +41,10 @@ window.app.pageOptions = {
   enableWatermark: {% if enable_watermark %}true{% else %}false{% endif %},
 
   // for {{filetype}} file
+  {% if filetype == 'ctable' %}
+  workspaceID: '{{ workspace_id }}',
+  {% endif %}
+
   {% block extra_data %}
   {% endblock %}
 };

seahub/urls.py

@@ -84,6 +84,8 @@ from seahub.api2.endpoints.related_files import RelatedFilesView, RelatedFileVie
 from seahub.api2.endpoints.webdav_secret import WebdavSecretView
 from seahub.api2.endpoints.starred_items import StarredItems
 from seahub.api2.endpoints.markdown_lint import MarkdownLintView
+from seahub.api2.endpoints.dtable import WorkspacesView, WorkspaceView, DTableView, \
+     DTableUpdateLinkView, dtable_file_view
 
 # Admin
 from seahub.api2.endpoints.admin.revision_tag import AdminTaggedItemsView
@@ -220,6 +222,7 @@ urlpatterns = [
     url(r'^my-libs/deleted/$', react_fake_view, name="my_libs_deleted"),
     url(r'^org/$', react_fake_view, name="org"),
     url(r'^invitations/$', react_fake_view, name="invitations"),
+    url(r'^dtable/$', react_fake_view, name='dtable'),
 
     ### Ajax ###
     url(r'^ajax/repo/(?P<repo_id>[-0-9a-f]{36})/dirents/$', get_dirents, name="get_dirents"),
@@ -342,6 +345,13 @@ urlpatterns = [
     # user: markdown-lint
     url(r'^api/v2.1/markdown-lint/$', MarkdownLintView.as_view(), name='api-v2.1-markdown-lint'),
 
+    # user: workspaces
+    url(r'^api/v2.1/workspaces/$', WorkspacesView.as_view(), name='api-v2.1-workspaces'),
+    url(r'^api/v2.1/workspace/(?P<workspace_id>\d+)/$', WorkspaceView.as_view(), name='api-v2.1-workspace'),
+    url(r'^api/v2.1/workspace/(?P<workspace_id>\d+)/dtable/$', DTableView.as_view(), name='api-v2.1-workspace-dtable'),
+    url(r'^api/v2.1/workspace/(?P<workspace_id>\d+)/dtable-update-link/$', DTableUpdateLinkView.as_view(), name='api-v2.1-workspace-dtable-update-link'),
+    url(r'^workspace/(?P<workspace_id>\d+)/dtable/(?P<name>.*)/$', dtable_file_view, name='dtable-file-view'),
+
     # Deprecated
     url(r'^api/v2.1/repos/(?P<repo_id>[-0-9a-f]{36})/tags/$', FileTagsView.as_view(), name="api-v2.1-filetags-view"),
     url(r'^api/v2.1/repos/(?P<repo_id>[-0-9a-f]{36})/tags/(?P<name>.*?)/$', FileTagView.as_view(), name="api-v2.1-filetag-view"),

seahub/views/file.py

@@ -734,8 +734,6 @@ def view_lib_file(request, repo_id, path):
 
         return render(request, template, return_dict)
         
-    elif filetype == CTABLE:
-        return render(request, template, return_dict)
     elif filetype == CDOC:
         return render(request, template, return_dict)    
     elif filetype == IMAGE:

tests/api/endpoints/test_dtable.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+import json
+
+from django.core.urlresolvers import reverse
+
+from seaserv import seafile_api
+
+from seahub.dtable.models import Workspaces
+from seahub.test_utils import BaseTestCase
+
+
+class WorkspacesViewTest(BaseTestCase):
+
+    def setUp(self):
+        workspace = Workspaces.objects.create_workspace("name1", self.user.username, self.repo.id)
+        self.url = reverse('api-v2.1-workspaces')
+        self.login_as(self.user)
+
+    def test_can_list(self):
+        assert len(Workspaces.objects.all()) == 1
+
+        resp = self.client.get(self.url)
+        self.assertEqual(200, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        self.assertIsNotNone(json_resp["workspace_list"])
+
+    def test_list_with_invalid_repo(self):
+        assert len(Workspaces.objects.all()) == 1
+
+        url = reverse('api2-repo', args=[self.repo.id])
+        resp = self.client.delete(url, {}, 'application/x-www-form-urlencoded')
+        self.assertEqual(200, resp.status_code)
+
+        resp = self.client.get(self.url)
+        self.assertEqual(200, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["workspace_list"] == []
+
+    def test_can_create(self):
+        assert len(Workspaces.objects.all()) == 1
+
+        resp = self.client.post(self.url, {'name': 'name2'})
+        self.assertEqual(201, resp.status_code)
+
+        assert len(Workspaces.objects.all()) == 2
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["workspace"]["name"] == 'name2'
+
+
+class WorkspaceViewTest(BaseTestCase):
+
+    def setUp(self):
+        self.workspace = Workspaces.objects.create_workspace("name1", self.user.username, self.repo.id)
+        self.url = reverse('api-v2.1-workspace', args=[self.workspace.id])
+        self.login_as(self.user)
+
+    def test_can_rename(self):
+        data = 'name=%s' % 'name2'
+        resp = self.client.put(self.url, data, 'application/x-www-form-urlencoded')
+        self.assertEqual(200, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["workspace"]["name"] == 'name2'
+
+    def test_rename_with_invalid_permission(self):
+        self.logout()
+        self.login_as(self.admin)
+
+        data = 'name=%s' % 'name2'
+        resp = self.client.put(self.url, data, 'application/x-www-form-urlencoded')
+        self.assertEqual(403, resp.status_code)
+
+    def test_rename_with_invalid_repo(self):
+        url = reverse('api2-repo', args=[self.workspace.repo_id])
+        resp = self.client.delete(url, {}, 'application/x-www-form-urlencoded')
+        self.assertEqual(200, resp.status_code)
+
+        data = 'name=%s' % 'name2'
+        resp = self.client.put(self.url, data, 'application/x-www-form-urlencoded')
+        self.assertEqual(404, resp.status_code)
+
+    def test_can_delete(self):
+        assert len(Workspaces.objects.all()) == 1
+
+        resp = self.client.delete(self.url, {'name': 'name1'})
+        self.assertEqual(200, resp.status_code)
+
+        assert len(Workspaces.objects.all()) == 0
+
+    def test_delete_with_invalid_permission(self):
+        self.logout()
+        self.login_as(self.admin)
+
+        resp = self.client.delete(self.url, {'name': 'name1'})
+        self.assertEqual(403, resp.status_code)
+
+
+class DTableTest(BaseTestCase):
+
+    def setUp(self):
+        self.workspace = Workspaces.objects.create_workspace("workspace", self.user.username, self.repo.id)
+        self.url = reverse('api-v2.1-workspace-dtable', args=[self.workspace.id])
+        self.login_as(self.user)
+
+    def test_can_create(self):
+        resp = self.client.post(self.url, {'name': 'table1'})
+        self.assertEqual(201, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["table"]["name"] == 'table1'
+
+    def test_create_with_invalid_repo(self):
+        url = reverse('api2-repo', args=[self.workspace.repo_id])
+        resp = self.client.delete(url, {}, 'application/x-www-form-urlencoded')
+        self.assertEqual(200, resp.status_code)
+
+        resp = self.client.post(self.url, {'name': 'table1'})
+        self.assertEqual(404, resp.status_code)
+
+    def test_can_rename(self):
+        resp = self.client.post(self.url, {'name': 'table4'})
+        self.assertEqual(201, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["table"]["name"] == 'table4'
+
+        old_name = json_resp["table"]["name"]
+        new_name = 'table5'
+
+        resp = self.client.put(
+            self.url,
+            'old_name=table4&new_name=table5',
+            'application/x-www-form-urlencoded'
+        )
+
+        self.assertEqual(200, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["table"]["name"] == 'table5'
+
+    def test_rename_with_invalid_workspace(self):
+        resp = self.client.post(self.url, {'name': 'table6'})
+        self.assertEqual(201, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["table"]["name"] == 'table6'
+
+        url = reverse('api-v2.1-workspace', args=[self.workspace.id])
+        resp = self.client.delete(url, {'name': 'workspace'})
+
+        self.assertEqual(200, resp.status_code)
+
+        resp = self.client.put(
+            self.url,
+            'old_name=table6&new_name=table7',
+            'application/x-www-form-urlencoded'
+        )
+
+        self.assertEqual(404, resp.status_code)
+
+    def test_can_delete(self):
+        resp = self.client.post(self.url, {'name': 'table1'})
+        self.assertEqual(201, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["table"]["name"] == 'table1'
+
+        data = 'name=%s' % 'table1'
+        resp = self.client.delete(self.url, data, 'application/x-www-form-urlencoded')
+        self.assertEqual(200, resp.status_code)
+
+    def test_delete_with_invalid_permission(self):
+        resp = self.client.post(self.url, {'name': 'table2'})
+        self.assertEqual(201, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["table"]["name"] == 'table2'
+
+        self.logout()
+        self.login_as(self.admin)
+
+        data = 'name=%s' % 'table2'
+        resp = self.client.delete(self.url, data, 'application/x-www-form-urlencoded')
+        self.assertEqual(403, resp.status_code)
+
+    def test_delete_with_repo_only_read(self):
+        resp = self.client.post(self.url, {'name': 'table3'})
+        self.assertEqual(201, resp.status_code)
+
+        json_resp = json.loads(resp.content)
+        assert json_resp["table"]["name"] == 'table3'
+
+        seafile_api.set_repo_status(self.workspace.repo_id, 1)
+
+        data = 'name=%s' % 'table3'
+        resp = self.client.delete(self.url, data, 'application/x-www-form-urlencoded')
+        self.assertEqual(403, resp.status_code)

tests/seahub/dtable/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

tests/seahub/dtable/test_models.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+from django.core.urlresolvers import reverse
+from seahub.dtable.models import Workspaces
+from seahub.test_utils import BaseTestCase
+
+
+class WorkspacesManagerTest(BaseTestCase):
+
+    def test_get_workspaces_by_owner(self):
+        assert len(Workspaces.objects.all()) == 0
+        Workspaces.objects.create_workspace("test_name", self.user.username, self.repo.id)
+
+        workspace_list = Workspaces.objects.get_workspaces_by_owner(self.user.username)
+
+        assert len(workspace_list) == 1
+
+    def test_get_workspace_by_id(self):
+        assert len(Workspaces.objects.all()) == 0
+        workspace = Workspaces.objects.create_workspace("test_name", self.user.username, self.repo.id)
+
+        assert workspace is not None
+        workspace_id = workspace.id
+
+        workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
+        assert workspace is not None
+
+    def test_delete_workspace(self):
+        assert len(Workspaces.objects.all()) == 0
+        workspace = Workspaces.objects.create_workspace("test_name", self.user.username, self.repo.id)
+
+        assert len(Workspaces.objects.all()) == 1
+        workspace_id = workspace.id
+
+        Workspaces.objects.delete_workspace(workspace_id)
+        assert len(Workspaces.objects.all()) == 0