haiwen/seahub
1
0
Fork 0
mirror of https://github.com/haiwen/seahub.git synced 2025-04-28 03:10:45 +00:00
Code Issues Releases Wiki Activity

Merge pull request #3704 from haiwen/dtable-upgrade

Browse Source 
dtable upgrade
This commit is contained in:
Daniel Pan 2019-06-25 16:46:39 +08:00 committed by GitHub
commit 837dfff28f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 524 additions and 672 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
frontend/src/app.js
View File

@ -37,7 +37,6 @@ 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);
@ -235,7 +234,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} />
<DTable 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} />

49
frontend/src/components/dialog/create-table-dialog.js
View File

@ -1,12 +1,15 @@
import React from 'react';
import PropTypes from 'prop-types';
import Select from 'react-select';
import makeAnimated from 'react-select/lib/animated';
import { seafileAPI } from '../../utils/seafile-api.js';
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,
createDTable: PropTypes.func.isRequired,
onAddDTable: PropTypes.func.isRequired,
};
class CreateTableDialog extends React.Component {
@ -16,6 +19,8 @@ class CreateTableDialog extends React.Component {
tableName: '',
errMessage: '',
isSubmitBtnActive: false,
selectedOption: null,
options:[],
};
this.newInput = React.createRef();
}
@ -23,6 +28,26 @@ class CreateTableDialog extends React.Component {
componentDidMount() {
this.newInput.focus();
this.newInput.setSelectionRange(0,0);
let options = [];
seafileAPI.getAccountInfo().then((res) => {
let obj = {};
console.log(res);
obj.value = 'Personal';
obj.email = res.data.email;
obj.label = 'Personal';
options.push(obj);
seafileAPI.listGroups().then((res) => {
for (let i = 0 ; i < res.data.length; i++) {
let obj = {};
obj.value = res.data[i].name;
obj.email = res.data[i].id + '@seafile_group';
obj.label = res.data[i].name;
options.push(obj);
}
this.setState({options: options});
});
});
}
handleChange = (e) => {
@ -37,6 +62,10 @@ class CreateTableDialog extends React.Component {
}) ;
}
handleSelectChange = (option) => {
this.setState({selectedOption: option});
}
handleSubmit = () => {
if (!this.state.isSubmitBtnActive) {
return;
@ -45,7 +74,8 @@ class CreateTableDialog extends React.Component {
let isValid = this.validateInputParams();
if (isValid) {
let newName = this.state.tableName.trim();
this.props.createTable(newName);
let owner = this.state.selectedOption;
this.props.createDTable(newName, owner.email);
}
}
@ -57,7 +87,7 @@ class CreateTableDialog extends React.Component {
}
toggle = () => {
this.props.onAddTable();
this.props.onAddDTable();
}
validateInputParams = () => {
@ -94,6 +124,17 @@ class CreateTableDialog extends React.Component {
</FormGroup>
</Form>
{this.state.errMessage && <Alert color="danger" className="mt-2">{this.state.errMessage}</Alert>}
<Label>{gettext('Belong to')}</Label>
<Select
isClearable
isMulti={false}
maxMenuHeight={200}
hideSelectedOptions={true}
components={makeAnimated()}
placeholder=''
options={this.state.options}
onChange={this.handleSelectChange}
/>
</ModalBody>
<ModalFooter>
<Button color="secondary" onClick={this.toggle}>{gettext('Cancel')}</Button>

102
frontend/src/components/dialog/create-workspace-dialog.js
View File

@ -1,102 +0,0 @@
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;

39
frontend/src/components/dialog/delete-workspace-dialog.js
View File

@ -1,39 +0,0 @@
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;

247
frontend/src/pages/dtable/dtable.js
View File

@ -1,12 +1,12 @@
import React, { Component, Fragment } from 'react';
import PropTypes from 'prop-types';
import { Dropdown, DropdownToggle, DropdownMenu, DropdownItem } from 'reactstrap';
import MediaQuery from 'react-responsive';
import { Dropdown, DropdownToggle, DropdownMenu, DropdownItem, Button } from 'reactstrap';
import moment from 'moment';
import { seafileAPI } from '../../utils/seafile-api';
import { gettext, siteRoot } from '../../utils/constants';
import CommonToolbar from '../../components/toolbar/common-toolbar';
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';
@ -110,7 +110,7 @@ class Table extends Component {
}
</td>
<td>{table.modifier}</td>
<td>{moment(table.mtime).fromNow()}</td>
<td>{moment(table.updated_at).fromNow()}</td>
<td>
{this.state.active &&
<Dropdown isOpen={this.state.dropdownOpen} toggle={this.dropdownToggle} direction="down" className="mx-1 old-history-more-operation">
@ -146,8 +146,6 @@ Table.propTypes = tablePropTypes;
const workspacePropTypes = {
workspace: PropTypes.object.isRequired,
renameWorkspace: PropTypes.func.isRequired,
deleteWorkspace: PropTypes.func.isRequired,
};
class Workspace extends Component {
@ -157,10 +155,6 @@ class Workspace extends Component {
this.state = {
tableList: this.props.workspace.table_list,
errorMsg: '',
isWorkspaceRenaming: false,
isWorkspaceDeleting: false,
isShowAddTableDialog: false,
dropdownOpen: false,
isItemFreezed: false,
};
}
@ -173,25 +167,6 @@ class Workspace extends Component {
this.setState({isItemFreezed: 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) => {
@ -223,30 +198,6 @@ class Workspace extends Component {
});
}
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 });
}
componentWillReceiveProps(nextProps) {
if (nextProps.workspace.table_list !== this.props.workspace.table_list) {
this.setState({
@ -260,54 +211,7 @@ class Workspace extends Component {
return(
<div className="workspace my-2">
<Fragment>
{this.state.isWorkspaceRenaming &&
<Rename
hasSuffix={false}
name={workspace.name}
onRenameConfirm={this.onRenameWorkspaceConfirm}
onRenameCancel={this.onRenameWorkspaceCancel}
/>
}
{!this.state.isWorkspaceRenaming &&
<span className="mb-2 workspace-name-container">
<span className="workspace-name">{workspace.name}</span>
<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}
/>
}
</span>
}
</Fragment>
<div className="d-flex add-table-btn-container">
<div className="add-table-btn cursor-pointer" onClick={this.onAddTable}>
<i className="fa fa-plus"></i>
</div>
{this.state.isShowAddTableDialog &&
<CreateTableDialog
onAddTable={this.onAddTable}
createTable={this.createTable}
/>
}
<span>{gettext('Add a DTable')}</span>
</div>
<div>{workspace.owner_name}</div>
<table width="100%" className="table-vcenter">
<colgroup>
<col width="4%"/><col width="31%"/><col width="30%"/><col width="27%"/><col width="8%"/>
@ -336,6 +240,12 @@ class Workspace extends Component {
Workspace.propTypes = workspacePropTypes;
const dtablePropTypes = {
onShowSidePanel: PropTypes.func.isRequired,
onSearchedClick: PropTypes.func.isRequired,
};
class DTable extends Component {
constructor(props) {
super(props);
@ -343,60 +253,28 @@ class DTable extends Component {
loading: true,
errorMsg: '',
workspaceList: [],
isShowAddWorkspaceDialog: false,
isShowAddDTableDialog: false,
};
}
onAddWorkspace = () => {
onAddDTable = () => {
this.setState({
isShowAddWorkspaceDialog: !this.state.isShowAddWorkspaceDialog,
isShowAddDTableDialog: !this.state.isShowAddDTableDialog,
});
}
createWorkspace = (name) => {
seafileAPI.createWorkspace(name).then((res) => {
this.state.workspaceList.push(res.data.workspace);
this.setState({workspaceList: this.state.workspaceList});
createDTable = (tableName, owner) => {
seafileAPI.createTable(tableName, owner).then(() => {
this.listWorkspaces();
}).catch((error) => {
if(error.response) {
this.setState({errorMsg: gettext('Error')});
}
});
this.onAddWorkspace();
this.onAddDTable();
}
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() {
listWorkspaces = () => {
seafileAPI.listWorkspaces().then((res) => {
this.setState({
loading: false,
@ -417,48 +295,67 @@ class DTable extends Component {
});
}
componentDidMount() {
this.listWorkspaces();
}
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>
<div className="main-panel-north border-left-show">
<div className="cur-view-toolbar">
<span className="sf2-icon-menu side-nav-toggle hidden-md-up d-md-none" title="Side Nav Menu" onClick={this.props.onShowSidePanel}></span>
<div className="operation">
<Fragment>
{this.state.workspaceList.map((workspace, index) => {
return (
<Workspace
key={index}
workspace={workspace}
renameWorkspace={this.renameWorkspace}
deleteWorkspace={this.deleteWorkspace}
/>
);
})}
<div className="my-2">
<span className="add-workspace cursor-pointer" onClick={this.onAddWorkspace}>
<i className="fa fa-plus"></i>{' '}{gettext('Add a Workspace')}
</span>
{this.state.isShowAddWorkspaceDialog &&
<CreateWorkspaceDialog
createWorkspace={this.createWorkspace}
onAddWorkspace={this.onAddWorkspace}
/>
}
</div>
<MediaQuery query="(min-width: 768px)">
<Button className="btn btn-secondary operation-item" onClick={this.onAddDTable}>{gettext('New DTable')}</Button>
</MediaQuery>
<MediaQuery query="(max-width: 767.8px)">
<Button className="btn btn-secondary operation-item my-1" onClick={this.onAddDTable}>{gettext('New DTable')}</Button>
</MediaQuery>
</Fragment>
}
</div>
</div>
<CommonToolbar onSearchedClick={this.props.onSearchedClick} />
</div>
<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>
{this.state.workspaceList.map((workspace, index) => {
return (
<Workspace
key={index}
workspace={workspace}
/>
);
})}
<div className="my-2">
{this.state.isShowAddDTableDialog &&
<CreateTableDialog
createDTable={this.createDTable}
onAddDTable={this.onAddDTable}
/>
}
</div>
</Fragment>
}
</div>
</div>
</div>
</div>
</Fragment>
);
}
}
DTable.propTypes = dtablePropTypes;
export default DTable;

489
seahub/api2/endpoints/dtable.py
View File

@ -13,16 +13,15 @@ from django.shortcuts import render
from django.utils.translation import ugettext as _
from pysearpc import SearpcError
from seaserv import seafile_api, edit_repo
from seaserv import seafile_api, ccnet_api
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
from seahub.dtable.models import Workspaces
from seahub.tags.models import FileUUIDMap
from seahub.dtable.models import Workspaces, DTables
from seahub.base.templatetags.seahub_tags import email2nickname
from seahub.utils.timeutils import timestamp_to_isoformat_timestr
from seahub.group.utils import group_id_to_name, is_group_member
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, \
gen_file_get_url, get_file_type_and_ext, IMAGE
@ -47,111 +46,146 @@ class WorkspacesView(APIView):
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)
username = request.user.username
workspace_list = []
for workspace in workspaces:
org_id = -1
if is_org_context(request):
org_id = request.user.org.org_id
if org_id > 0:
groups = ccnet_api.get_org_groups_by_user(org_id, username)
else:
groups = ccnet_api.get_groups(username, return_ancestors=True)
owner_list = list()
owner_list.append(username)
for group in groups:
group_user = '%s@seafile_group' % group.id
owner_list.append(group_user)
workspace_list = list()
for owner in owner_list:
try:
workspace = Workspaces.objects.get_workspace_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)
if not workspace:
if '@seafile_group' in owner:
continue
# permission check
if not request.user.permissions.can_add_repo():
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
try:
if org_id > 0:
repo_id = seafile_api.create_org_repo(
_("My Workspace"),
_("My Workspace"),
"dtable@seafile",
org_id
)
else:
repo_id = seafile_api.create_repo(
_("My Workspace"),
_("My Workspace"),
"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)
workspace = Workspaces.objects.create_workspace(owner, repo_id)
# resource check
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:
if table_obj.obj_name[-7:] != FILE_TYPE:
continue
table = dict()
table["name"] = table_obj.obj_name[:-7]
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)
if '@seafile_group' in owner:
group_id = int(owner.split('@')[0])
owner_name = group_id_to_name(group_id)
else:
owner_name = email2nickname(owner)
table_list = DTables.objects.get_dtable_by_workspace(workspace)
res = workspace.to_dict()
res["owner_name"] = owner_name
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):
class DTablesView(APIView):
authentication_classes = (TokenAuthentication, SessionAuthentication)
permission_classes = (IsAuthenticated, )
throttle_classes = (UserRateThrottle, )
def put(self, request, workspace_id):
"""rename a workspace
def post(self, request):
"""create a table file
"""
# argument check
workspace_name = request.data.get('name')
if not workspace_name:
table_owner = request.POST.get('owner')
if not table_owner:
error_msg = 'owner invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
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(workspace_name):
table_file_name = table_name + FILE_TYPE
if not is_valid_dirent_name(table_file_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)
workspace = Workspaces.objects.get_workspace_by_owner(table_owner)
if not workspace:
error_msg = 'Workspace %s not found.' % workspace_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
if not request.user.permissions.can_add_repo():
error_msg = 'Permission denied.'
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(
_("My Workspace"),
_("My Workspace"),
"dtable@seafile",
org_id
)
else:
repo_id = seafile_api.create_repo(
_("My Workspace"),
_("My Workspace"),
"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)
try:
workspace = Workspaces.objects.create_workspace(table_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)
repo_id = workspace.repo_id
repo = seafile_api.get_repo(repo_id)
@ -161,10 +195,15 @@ class WorkspaceView(APIView):
# 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 '@seafile_group' in table_owner:
group_id = int(table_owner.split('@')[0])
if not is_group_member(group_id, username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
else:
if username != table_owner:
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
# repo status check
repo_status = repo.status
@ -172,82 +211,24 @@ class WorkspaceView(APIView):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
# create new empty table
table_file_name = check_filename_with_rename(repo_id, '/', table_file_name)
try:
edit_repo(repo_id, workspace_name, '', username)
except Exception as e:
seafile_api.post_empty_file(repo_id, '/', table_file_name, username)
except SearpcError as e:
logger.error(e)
error_msg = 'Internal Server Error.'
error_msg = 'Internal Server Error'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
try:
workspace.name = workspace_name
workspace.save()
dtable = DTables.objects.create_dtable(table_owner, workspace, table_name)
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error.'
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:
if table_obj.obj_name[-7:] != FILE_TYPE:
continue
table = dict()
table["name"] = table_obj.obj_name[:-7]
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)
return Response({"table": dtable.to_dict()}, status=status.HTTP_201_CREATED)
class DTableView(APIView):
@ -282,19 +263,30 @@ class DTableView(APIView):
error_msg = 'Library %s not found.' % repo_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
dtable = DTables.objects.get_dtable(workspace, table_name)
if not dtable:
error_msg = 'dtable %s not found.' % table_name
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
table_file_name = table_name + FILE_TYPE
table_path = normalize_file_path(table_file_name)
table_file_id = seafile_api.get_file_id_by_path(repo_id, table_path)
if not table_file_id:
error_msg = 'table %s not found.' % table_name
error_msg = 'file %s not found.' % table_file_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)
if '@seafile_group' in owner:
group_id = int(owner.split('@')[0])
if not is_group_member(group_id, username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
else:
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')
@ -303,64 +295,6 @@ class DTableView(APIView):
use_onetime = False if reuse == '1' else True
return get_repo_file(request, repo_id, table_file_id, table_file_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)
table_file_name = table_name + FILE_TYPE
if not is_valid_dirent_name(table_file_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_file_name = check_filename_with_rename(repo_id, '/', table_file_name)
try:
seafile_api.post_empty_file(repo_id, '/', table_file_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_file_name)
table_obj = seafile_api.get_dirent_by_path(repo_id, table_path)
table = dict()
table["name"] = table_obj.obj_name[:-7]
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
"""
@ -396,19 +330,30 @@ class DTableView(APIView):
error_msg = 'Library %s not found.' % repo_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
dtable = DTables.objects.get_dtable(workspace, old_table_name)
if not dtable:
error_msg = 'dtable %s not found.' % old_table_name
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
old_table_file_name = old_table_name + FILE_TYPE
old_table_path = normalize_file_path(old_table_file_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
error_msg = 'file %s not found.' % old_table_file_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)
if '@seafile_group' in owner:
group_id = int(owner.split('@')[0])
if not is_group_member(group_id, username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
else:
if username != owner:
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
# repo status check
repo_status = repo.status
@ -419,20 +364,22 @@ class DTableView(APIView):
# rename table
new_table_file_name = check_filename_with_rename(repo_id, '/', new_table_file_name)
try:
seafile_api.rename_file(repo_id, '/', old_table_file_name, new_table_file_name, owner)
seafile_api.rename_file(repo_id, '/', old_table_file_name, new_table_file_name, username)
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_file_name)
table_obj = seafile_api.get_dirent_by_path(repo_id, new_table_path)
table = dict()
table["name"] = table_obj.obj_name[:-7]
table["mtime"] = timestamp_to_isoformat_timestr(table_obj.mtime)
table["modifier"] = email2nickname(table_obj.modifier) if table_obj.modifier else email2nickname(owner)
try:
dtable.name = new_table_name
dtable.modifier = username
dtable.save()
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({"table": table}, status=status.HTTP_200_OK)
return Response({"table": dtable.to_dict()}, status=status.HTTP_200_OK)
def delete(self, request, workspace_id):
"""delete a table
@ -456,17 +403,29 @@ class DTableView(APIView):
error_msg = 'Library %s not found.' % repo_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
dtable = DTables.objects.get_dtable(workspace, table_name)
if not dtable:
error_msg = 'dtable %s not found.' % table_name
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
table_path = normalize_file_path(table_file_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)
error_msg = 'file %s not found.' % table_file_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)
if '@seafile_group' in owner:
group_id = int(owner.split('@')[0])
if not is_group_member(group_id, username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
else:
if username != owner:
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
# repo status check
repo_status = repo.status
@ -475,8 +434,7 @@ class DTableView(APIView):
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
# delete asset
uuid = FileUUIDMap.objects.get_or_create_fileuuidmap(repo_id, '/', table_file_name, is_dir=False)
asset_dir_path = '/asset/' + str(uuid.uuid)
asset_dir_path = '/asset/' + str(dtable.uuid)
asset_dir_id = seafile_api.get_dir_id_by_path(repo_id, asset_dir_path)
if asset_dir_id:
parent_dir = os.path.dirname(asset_dir_path)
@ -488,9 +446,6 @@ class DTableView(APIView):
error_msg = 'Internal Server Error'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
# delete uuid
uuid.delete()
# delete table
try:
seafile_api.del_file(repo_id, '/', table_file_name, owner)
@ -499,6 +454,13 @@ class DTableView(APIView):
error_msg = 'Internal Server Error'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
try:
DTables.objects.delete_dtable(workspace, table_name)
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)
@ -511,6 +473,12 @@ class DTableUpdateLinkView(APIView):
def get(self, request, workspace_id):
"""get table file update 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)
# resource check
workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
if not workspace:
@ -523,21 +491,35 @@ class DTableUpdateLinkView(APIView):
error_msg = 'Library %s not found.' % repo_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
dtable = DTables.objects.get_dtable(workspace, table_name)
if not dtable:
error_msg = 'dtable %s not found.' % 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)
if '@seafile_group' in owner:
group_id = int(owner.split('@')[0])
if not is_group_member(group_id, username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
else:
if username != owner:
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
try:
token = seafile_api.get_fileserver_access_token(repo_id, 'dummy', 'update',
owner, use_onetime=False)
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)
dtable.modifier = username
dtable.save()
url = gen_file_upload_url(token, 'update-api')
return Response(url)
@ -556,7 +538,6 @@ class DTableAssetUploadLinkView(APIView):
if not table_name:
error_msg = 'name invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
table_file_name = table_name + FILE_TYPE
# resource check
workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
@ -570,6 +551,11 @@ class DTableAssetUploadLinkView(APIView):
error_msg = 'Library %s not found.' % repo_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
dtable = DTables.objects.get_dtable(workspace, table_name)
if not dtable:
error_msg = 'dtable %s not found.' % table_name
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
# permission check
username = request.user.username
owner = workspace.owner
@ -586,16 +572,16 @@ class DTableAssetUploadLinkView(APIView):
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
upload_link = gen_file_upload_url(token, 'upload-api')
uuid = FileUUIDMap.objects.get_or_create_fileuuidmap(repo_id, '/',
table_file_name,
is_dir=False)
# create asset dir
asset_dir_path = '/asset/' + str(uuid.uuid)
asset_dir_path = '/asset/' + str(dtable.uuid)
asset_dir_id = seafile_api.get_dir_id_by_path(repo_id, asset_dir_path)
if not asset_dir_id:
seafile_api.mkdir_with_parents(repo_id, '/', asset_dir_path[1:], owner)
dtable.modifier = username
dtable.save()
res = dict()
res['upload_link'] = upload_link
res['parent_path'] = asset_dir_path
@ -615,6 +601,10 @@ def dtable_file_view(request, workspace_id, name):
if not repo:
raise Http404
dtable = DTables.objects.get_dtable(workspace, name)
if not dtable:
return render_error(request, _(u'Table does not exist'))
table_file_name = name + FILE_TYPE
table_path = normalize_file_path(table_file_name)
table_file_id = seafile_api.get_file_id_by_path(repo_id, table_path)
@ -624,8 +614,15 @@ def dtable_file_view(request, workspace_id, name):
# permission check
username = request.user.username
owner = workspace.owner
if username != owner:
return render_permission_error(request, _(u'Unable to view file'))
if '@seafile_group' in owner:
group_id = int(owner.split('@')[0])
if not is_group_member(group_id, username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
else:
if username != owner:
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
return_dict = {
'share_link_expire_days_default': SHARE_LINK_EXPIRE_DAYS_DEFAULT,
@ -660,6 +657,10 @@ def dtable_asset_access(request, workspace_id, dtable_id, path):
if not repo:
raise Http404
dtable = DTables.objects.get_dtable_by_uuid(dtable_id)
if not dtable:
raise Http404
asset_path = normalize_file_path(os.path.join('/asset', dtable_id, path))
asset_id = seafile_api.get_file_id_by_path(repo_id, asset_path)
if not asset_id:

36
seahub/dtable/migrations/0001_initial.py
View File

@ -1,8 +1,10 @@
# -*- coding: utf-8 -*-
# Generated by Django 1.11.15 on 2019-06-05 05:21
# Generated by Django 1.11.15 on 2019-06-25 05:37
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
import uuid
class Migration(migrations.Migration):
@ -13,21 +15,41 @@ class Migration(migrations.Migration):
]
operations = [
migrations.CreateModel(
name='DTables',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('uuid', models.UUIDField(default=uuid.uuid4, unique=True)),
('name', models.CharField(max_length=255)),
('creator', models.CharField(max_length=255)),
('modifier', models.CharField(max_length=255)),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
],
options={
'db_table': 'dtables',
},
),
migrations.CreateModel(
name='Workspaces',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(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)),
('name', models.CharField(max_length=255, null=True)),
('owner', models.CharField(max_length=255, unique=True)),
('repo_id', models.CharField(max_length=36, unique=True)),
('created_at', models.DateTimeField(auto_now_add=True)),
],
options={
'db_table': 'workspaces',
},
),
migrations.AddField(
model_name='dtables',
name='workspace',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='dtable.Workspaces'),
),
migrations.AlterUniqueTogether(
name='workspaces',
unique_together=set([('owner', 'repo_id')]),
name='dtables',
unique_together=set([('workspace', 'name')]),
),
]

106
seahub/dtable/models.py
View File

@ -1,17 +1,20 @@
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import uuid
from django.db import models
from seaserv import seafile_api
from seahub.utils.timeutils import timestamp_to_isoformat_timestr, datetime_to_isoformat_timestr
from seahub.base.templatetags.seahub_tags import email2nickname
class WorkspacesManager(models.Manager):
def get_workspaces_by_owner(self, owner):
def get_workspace_by_owner(self, owner):
try:
return super(WorkspacesManager, self).filter(owner=owner)
return super(WorkspacesManager, self).get(owner=owner)
except self.model.DoesNotExist:
return None
@ -21,11 +24,11 @@ class WorkspacesManager(models.Manager):
except self.model.DoesNotExist:
return None
def create_workspace(self, name, owner, repo_id):
def create_workspace(self, owner, repo_id):
try:
return super(WorkspacesManager, self).get(name=name, owner=owner, repo_id=repo_id)
return super(WorkspacesManager, self).get(owner=owner, repo_id=repo_id)
except self.model.DoesNotExist:
workspace = self.model(name=name, owner=owner, repo_id=repo_id)
workspace = self.model(owner=owner, repo_id=repo_id)
workspace.save()
return workspace
@ -40,15 +43,14 @@ class WorkspacesManager(models.Manager):
class Workspaces(models.Model):
name = models.CharField(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)
name = models.CharField(max_length=255, null=True)
owner = models.CharField(max_length=255, unique=True)
repo_id = models.CharField(max_length=36, unique=True)
created_at = models.DateTimeField(auto_now_add=True)
objects = WorkspacesManager()
class Meta:
unique_together = (('owner', 'repo_id'),)
db_table = 'workspaces'
@property
@ -65,8 +67,86 @@ class Workspaces(models.Model):
return {
'id': self.pk,
'name': self.name,
'owner': self.owner,
'repo_id': self.repo_id,
'created_at': datetime_to_isoformat_timestr(self.created_at),
}
class DTablesManager(models.Manager):
def get_dtable_by_workspace(self, workspace):
try:
dtables = super(DTablesManager, self).filter(workspace=workspace)
dtable_list = list()
for dtable in dtables:
dtable_dict = dict()
dtable_dict['id'] = dtable.pk
dtable_dict['workspace_id'] = dtable.workspace_id
dtable_dict['uuid'] = dtable.uuid
dtable_dict['name'] = dtable.name
dtable_dict['creator'] = email2nickname(dtable.creator)
dtable_dict['modifier'] = email2nickname(dtable.modifier)
dtable_dict['created_at'] = datetime_to_isoformat_timestr(dtable.created_at)
dtable_dict['updated_at'] = datetime_to_isoformat_timestr(dtable.updated_at)
dtable_list.append(dtable_dict)
return dtable_list
except self.model.DoesNotExist:
return None
def create_dtable(self, owner, workspace, name):
try:
return super(DTablesManager, self).get(workspace=workspace, name=name)
except self.model.DoesNotExist:
dtable = self.model(workspace=workspace, name=name,
creator=owner, modifier=owner)
dtable.save()
return dtable
def get_dtable(self, workspace, name):
try:
return super(DTablesManager, self).get(workspace=workspace, name=name)
except self.model.DoesNotExist:
return None
def get_dtable_by_uuid(self, uuid):
try:
return super(DTablesManager, self).get(uuid=uuid)
except self.model.DoesNotExist:
return None
def delete_dtable(self, workspace, name):
try:
dtable = super(DTablesManager, self).get(workspace=workspace, name=name)
dtable.delete()
return True
except self.model.DoesNotExist:
return False
class DTables(models.Model):
workspace = models.ForeignKey(Workspaces, on_delete=models.CASCADE, db_index=True)
uuid = models.UUIDField(unique=True, default=uuid.uuid4)
name = models.CharField(max_length=255)
creator = models.CharField(max_length=255)
modifier = models.CharField(max_length=255)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
objects = DTablesManager()
class Meta:
unique_together = (('workspace', 'name'),)
db_table = 'dtables'
def to_dict(self):
return {
'id': self.pk,
'workspace_id': self.workspace_id,
'uuid': self.uuid,
'name': self.name,
'creator': email2nickname(self.creator),
'modifier': email2nickname(self.modifier),
'created_at': datetime_to_isoformat_timestr(self.created_at),
'updated_at': datetime_to_isoformat_timestr(self.updated_at),
}

4
seahub/urls.py
View File

@ -89,7 +89,7 @@ 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, \
from seahub.api2.endpoints.dtable import WorkspacesView, DTableView, DTablesView, \
DTableUpdateLinkView, DTableAssetUploadLinkView, dtable_file_view, dtable_asset_access
# Admin
@ -363,7 +363,7 @@ urlpatterns = [
# 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/dtables/$', DTablesView.as_view(), name='api-v2.1-dtables'),
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'^api/v2.1/workspace/(?P<workspace_id>\d+)/dtable-asset-upload-link/$', DTableAssetUploadLinkView.as_view(), name='api-v2.1-workspace-dtable-asset-upload-link'),

108
tests/api/endpoints/test_dtable.py
View File

@ -13,13 +13,20 @@ class WorkspacesViewTest(BaseTestCase):
def setUp(self):
self.workspace = Workspaces.objects.create_workspace(
"workspace1",
self.user.username,
self.repo.id
)
self.url = reverse('api-v2.1-workspaces')
self.login_as(self.user)
def tearDown(self):
assert len(Workspaces.objects.all()) == 1
workspace = Workspaces.objects.get_workspace_by_owner(self.user.username)
workspace_id = workspace.id
Workspaces.objects.delete_workspace(workspace_id)
def test_can_list(self):
assert len(Workspaces.objects.all()) == 1
@ -43,83 +50,28 @@ class WorkspacesViewTest(BaseTestCase):
assert json_resp["workspace_list"] == []
assert len(Workspaces.objects.all()) == 1
def test_can_create(self):
assert len(Workspaces.objects.all()) == 1
resp = self.client.post(self.url, {'name': 'workspace2'})
self.assertEqual(201, resp.status_code)
assert len(Workspaces.objects.all()) == 2
json_resp = json.loads(resp.content)
assert json_resp["workspace"]["name"] == 'workspace2'
class WorkspaceViewTest(BaseTestCase):
def setUp(self):
self.workspace = Workspaces.objects.create_workspace(
"workspace3",
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' % 'workspace4'
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"] == 'workspace4'
def test_rename_with_invalid_permission(self):
self.logout()
self.login_as(self.admin)
data = 'name=%s' % 'workspace5'
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' % 'workspace6'
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': 'workspace3'})
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': 'workspace3'})
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.url1 = reverse('api-v2.1-dtables')
self.url2 = reverse('api-v2.1-workspace-dtable', args=[self.workspace.id])
self.login_as(self.user)
def tearDown(self):
assert len(Workspaces.objects.all()) == 1
workspace = Workspaces.objects.get_workspace_by_owner(self.user.username)
workspace_id = workspace.id
Workspaces.objects.delete_workspace(workspace_id)
def test_can_create(self):
resp = self.client.post(self.url, {'name': 'table1'})
resp = self.client.post(self.url1, {'name': 'table1', 'owner': self.user.username})
self.assertEqual(201, resp.status_code)
json_resp = json.loads(resp.content)
@ -130,18 +82,18 @@ class DTableTest(BaseTestCase):
resp = self.client.delete(url, {}, 'application/x-www-form-urlencoded')
self.assertEqual(200, resp.status_code)
resp = self.client.post(self.url, {'name': 'table2'})
resp = self.client.post(self.url1, {'name': 'table2'})
self.assertEqual(404, resp.status_code)
def test_can_rename(self):
resp = self.client.post(self.url, {'name': 'table3'})
resp = self.client.post(self.url1, {'name': 'table1', 'owner': self.user.username})
self.assertEqual(201, resp.status_code)
json_resp = json.loads(resp.content)
assert json_resp["table"]["name"] == 'table3'
resp = self.client.put(
self.url,
self.url2,
'old_name=table3&new_name=table4',
'application/x-www-form-urlencoded'
)
@ -152,7 +104,7 @@ class DTableTest(BaseTestCase):
assert json_resp["table"]["name"] == 'table4'
def test_rename_with_invalid_workspace(self):
resp = self.client.post(self.url, {'name': 'table5'})
resp = self.client.post(self.url1, {'name': 'table1', 'owner': self.user.username})
self.assertEqual(201, resp.status_code)
json_resp = json.loads(resp.content)
@ -164,7 +116,7 @@ class DTableTest(BaseTestCase):
self.assertEqual(200, resp.status_code)
resp = self.client.put(
self.url,
self.url2,
'old_name=table5&new_name=table6',
'application/x-www-form-urlencoded'
)
@ -172,18 +124,18 @@ class DTableTest(BaseTestCase):
self.assertEqual(404, resp.status_code)
def test_can_delete(self):
resp = self.client.post(self.url, {'name': 'table7'})
resp = self.client.post(self.url1, {'name': 'table1', 'owner': self.user.username})
self.assertEqual(201, resp.status_code)
json_resp = json.loads(resp.content)
assert json_resp["table"]["name"] == 'table7'
data = 'name=%s' % 'table7'
resp = self.client.delete(self.url, data, 'application/x-www-form-urlencoded')
resp = self.client.delete(self.url2, 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': 'table8'})
resp = self.client.post(self.url1, {'name': 'table1', 'owner': self.user.username})
self.assertEqual(201, resp.status_code)
json_resp = json.loads(resp.content)
@ -193,11 +145,11 @@ class DTableTest(BaseTestCase):
self.login_as(self.admin)
data = 'name=%s' % 'table8'
resp = self.client.delete(self.url, data, 'application/x-www-form-urlencoded')
resp = self.client.delete(self.url2, 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': 'table9'})
resp = self.client.post(self.url1, {'name': 'table1', 'owner': self.user.username})
self.assertEqual(201, resp.status_code)
json_resp = json.loads(resp.content)
@ -206,5 +158,5 @@ class DTableTest(BaseTestCase):
seafile_api.set_repo_status(self.workspace.repo_id, 1)
data = 'name=%s' % 'table9'
resp = self.client.delete(self.url, data, 'application/x-www-form-urlencoded')
resp = self.client.delete(self.url2, data, 'application/x-www-form-urlencoded')
self.assertEqual(403, resp.status_code)

13
tests/seahub/dtable/test_models.py
View File

@ -6,17 +6,18 @@ from seahub.test_utils import BaseTestCase
class WorkspacesManagerTest(BaseTestCase):
def test_get_workspaces_by_owner(self):
def test_get_workspace_by_owner(self):
assert len(Workspaces.objects.all()) == 0
Workspaces.objects.create_workspace("test_name", self.user.username, self.repo.id)
Workspaces.objects.create_workspace(self.user.username, self.repo.id)
workspace_list = Workspaces.objects.get_workspaces_by_owner(self.user.username)
workspace = Workspaces.objects.get_workspace_by_owner(self.user.username)
assert len(workspace_list) == 1
assert workspace is not None
assert len(Workspaces.objects.all()) == 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)
workspace = Workspaces.objects.create_workspace(self.user.username, self.repo.id)
assert workspace is not None
workspace_id = workspace.id
@ -26,7 +27,7 @@ class WorkspacesManagerTest(BaseTestCase):
def test_delete_workspace(self):
assert len(Workspaces.objects.all()) == 0
workspace = Workspaces.objects.create_workspace("test_name", self.user.username, self.repo.id)
workspace = Workspaces.objects.create_workspace(self.user.username, self.repo.id)
assert len(Workspaces.objects.all()) == 1
workspace_id = workspace.id