def test_get_all_with_parent_id(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
item = api.create(ContentType.Folder, workspace, None, 'parent', True)
item2 = api.create(ContentType.File, workspace, item, 'file1', True)
item3 = api.create(ContentType.File, workspace, None, 'file2', True)
parent_id = item.content_id
child_id = item2.content_id
uid = user.user_id
wid = workspace.workspace_id
transaction.commit()
# Refresh instances after commit
user = uapi.get_one(uid)
workspace = WorkspaceApi(user).get_one(wid)
api = ContentApi(user)
items = api.get_all(None, ContentType.Any, workspace)
eq_(3, len(items))
items2 = api.get_all(parent_id, ContentType.File, workspace)
eq_(1, len(items2))
eq_(child_id, items2[0].content_id)
def test_search_in_description(self):
# HACK - D.A. - 2015-03-09
# This test is based on a bug which does NOT return results found
# at root of a workspace (eg a folder)
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
a = api.create(ContentType.Folder, workspace, None,
'this is randomized folder', True)
p = api.create(ContentType.Page, workspace, a,
'this is dummy label content', True)
with new_revision(p):
p.description = 'This is some amazing test'
api.save(p)
original_id = p.content_id
res = api.search(['dummy'])
eq_(1, len(res.all()))
item = res.all()[0]
eq_(original_id, item.content_id)
def test_get_all_with_filter(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
item = api.create(ContentType.Folder, workspace, None,
'thefolder', True)
item2 = api.create(ContentType.File, workspace, None, 'thefile', True)
uid = user.user_id
wid = workspace.workspace_id
transaction.commit()
# Refresh instances after commit
user = uapi.get_one(uid)
workspace = WorkspaceApi(user).get_one(wid)
api = ContentApi(user)
items = api.get_all(None, ContentType.Any, workspace)
eq_(2, len(items))
items2 = api.get_all(None, ContentType.File, workspace)
eq_(1, len(items2))
eq_('thefile', items2[0].label)
items3 = api.get_all(None, ContentType.Folder, workspace)
eq_(1, len(items3))
eq_('thefolder', items3[0].label)
def test_archive(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
item = api.create(ContentType.Folder, workspace, None,
'not_archived', True)
item2 = api.create(ContentType.Folder, workspace, None,
'to_archive', True)
uid = user.user_id
wid = workspace.workspace_id
transaction.commit()
# Refresh instances after commit
user = uapi.get_one(uid)
workspace = WorkspaceApi(user).get_one(wid)
api = ContentApi(user)
items = api.get_all(None, ContentType.Any, workspace)
eq_(2, len(items))
items = api.get_all(None, ContentType.Any, workspace)
with new_revision(items[0]):
api.archive(items[0])
transaction.commit()
# Refresh instances after commit
user = uapi.get_one(uid)
workspace = WorkspaceApi(user).get_one(wid)
api = ContentApi(user)
items = api.get_all(None, ContentType.Any, workspace)
eq_(1, len(items))
transaction.commit()
# Refresh instances after commit
user = uapi.get_one(uid)
workspace = WorkspaceApi(user).get_one(wid)
api = ContentApi(user)
# Test that the item is still available if "show deleted" is activated
api = ContentApi(None, show_archived=True)
items = api.get_all(None, ContentType.Any, workspace)
eq_(2, len(items))
def test_search_in_label_or_description(self):
# HACK - D.A. - 2015-03-09
# This test is based on a bug which does NOT return results found
# at root of a workspace (eg a folder)
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
a = api.create(ContentType.Folder, workspace, None,
'this is randomized folder', True)
p1 = api.create(ContentType.Page, workspace, a,
'this is dummy label content', True)
p2 = api.create(ContentType.Page, workspace, a, 'Hey ! Jon !', True)
with new_revision(p1):
p1.description = 'This is some amazing test'
with new_revision(p2):
p2.description = 'What\'s up ?'
api.save(p1)
api.save(p2)
id1 = p1.content_id
id2 = p2.content_id
eq_(1, DBSession.query(Workspace).filter(Workspace.label == 'test workspace').count())
eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'this is randomized folder').count())
eq_(2, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'this is dummy label content').count())
eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.description == 'This is some amazing test').count())
eq_(2, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.label == 'Hey ! Jon !').count())
eq_(1, DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.description == 'What\'s up ?').count())
res = api.search(['dummy', 'jon'])
eq_(2, len(res.all()))
eq_(True, id1 in [o.content_id for o in res.all()])
eq_(True, id2 in [o.content_id for o in res.all()])
def test_mark_read(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user_a = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
user_b = uapi.create_user(email='*****@*****.**',
groups=groups, save_now=True)
wapi = WorkspaceApi(user_a)
workspace = wapi.create_workspace(
'test workspace',
save_now=True)
role_api = RoleApi(user_a)
role_api.create_one(user_b, workspace, UserRoleInWorkspace.READER, False)
cont_api_a = ContentApi(user_a)
cont_api_b = ContentApi(user_b)
page_1 = cont_api_a.create(ContentType.Page, workspace, None,
'this is a page', do_save=True)
for rev in page_1.revisions:
eq_(user_b not in rev.read_by.keys(), True)
cont_api_b.mark_read(page_1)
for rev in page_1.revisions:
eq_(user_b in rev.read_by.keys(), True)
def post(self, label='', content=''):
workspace = tmpl_context.workspace
api = ContentApi(tmpl_context.current_user)
page = api.create(ContentType.Page, workspace, tmpl_context.folder, label)
page.description = content
api.save(page, ActionDescription.CREATION, do_notify=True)
tg.flash(_('Page created'), CST.STATUS_OK)
tg.redirect(tg.url('/workspaces/{}/folders/{}/pages/{}').format(tmpl_context.workspace_id, tmpl_context.folder_id, page.content_id))
def post(self, label='', file_data=None):
# TODO - SECURE THIS
workspace = tmpl_context.workspace
api = ContentApi(tmpl_context.current_user)
file = api.create(ContentType.File, workspace, tmpl_context.folder, label)
api.update_file_data(file, file_data.filename, file_data.type, file_data.file.read())
api.save(file, ActionDescription.CREATION)
tg.flash(_('File created'), CST.STATUS_OK)
tg.redirect(tg.url('/workspaces/{}/folders/{}/files/{}').format(tmpl_context.workspace_id, tmpl_context.folder_id, file.content_id))
def test_set_status_unknown_status(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
c = api.create(ContentType.Folder, workspace, None, 'parent', True)
api.set_status(c, 'unknown-status')
def post(self, label='', content='', parent_id=None):
"""
Creates a new thread. Actually, on POST, the content will be included in a user comment instead of being the thread description
:param label:
:param content:
:return:
"""
# TODO - SECURE THIS
workspace = tmpl_context.workspace
api = ContentApi(tmpl_context.current_user)
thread = api.create(ContentType.Thread, workspace, tmpl_context.folder, label)
# FIXME - DO NOT DUPLCIATE FIRST MESSAGE thread.description = content
api.save(thread, ActionDescription.CREATION, do_notify=False)
comment = api.create(ContentType.Comment, workspace, thread, label)
comment.label = ''
comment.description = content
api.save(comment, ActionDescription.COMMENT, do_notify=False)
api.do_notify(thread)
tg.flash(_('Thread created'), CST.STATUS_OK)
tg.redirect(self._std_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, thread.content_id))
def test_set_status_ok(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
c = api.create(ContentType.Folder, workspace, None, 'parent', True)
for new_status in ['open', 'closed-validated', 'closed-unvalidated',
'closed-deprecated']:
api.set_status(c, new_status)
eq_(new_status, c.status)
eq_(ActionDescription.STATUS_UPDATE, c.revision_type)
def post(self, label, parent_id=None, can_contain_folders=False, can_contain_threads=False, can_contain_files=False, can_contain_pages=False):
# TODO - SECURE THIS
workspace = tmpl_context.workspace
api = ContentApi(tmpl_context.current_user)
redirect_url_tmpl = '/workspaces/{}/folders/{}'
redirect_url = ''
try:
parent = None
if parent_id:
parent = api.get_one(int(parent_id), ContentType.Folder, workspace)
folder = api.create(ContentType.Folder, workspace, parent, label)
subcontent = dict(
folder = True if can_contain_folders=='on' else False,
thread = True if can_contain_threads=='on' else False,
file = True if can_contain_files=='on' else False,
page = True if can_contain_pages=='on' else False
)
api.set_allowed_content(folder, subcontent)
api.save(folder)
tg.flash(_('Folder created'), CST.STATUS_OK)
redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id, folder.content_id)
except Exception as e:
logger.error(self, 'An unexpected exception has been catched. Look at the traceback below.')
traceback.print_exc()
tg.flash(_('Folder not created: {}').format(e.with_traceback()), CST.STATUS_ERROR)
if parent_id:
redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id, parent_id)
else:
redirect_url = '/workspaces/{}'.format(tmpl_context.workspace_id)
####
#
# INFO - D.A. - 2014-10-22 - Do not put redirect in a
# try/except block as redirect is using exceptions!
#
tg.redirect(tg.url(redirect_url))
def test_create_comment_ok(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
p = api.create(ContentType.Page, workspace, None, 'this_is_a_page')
c = api.create_comment(workspace, p, 'this is the comment', True)
eq_(Content, c.__class__)
eq_(p.content_id, c.parent_id)
eq_(user, c.owner)
eq_(workspace, c.workspace)
eq_(ContentType.Comment, c.type)
eq_('this is the comment', c.description)
eq_('', c.label)
eq_(ActionDescription.COMMENT, c.revision_type)
def test_delete_undelete(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user1 = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
u1id = user1.user_id
workspace = WorkspaceApi(user1).create_workspace('test workspace',
save_now=True)
wid = workspace.workspace_id
user2 = uapi.create_user()
user2.email = '*****@*****.**'
uapi.save(user2)
RoleApi(user1).create_one(user2, workspace,
UserRoleInWorkspace.CONTENT_MANAGER,
with_notif=True,
flush=True)
# show archived is used at the top end of the test
api = ContentApi(user1, show_deleted=True)
p = api.create(ContentType.File, workspace, None,
'this_is_a_page', True)
u1id = user1.user_id
u2id = user2.user_id
pcid = p.content_id
poid = p.owner_id
transaction.commit()
####
user1 = UserApi(None).get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
content = api.get_one(pcid, ContentType.Any, workspace)
eq_(u1id, content.owner_id)
eq_(poid, content.owner_id)
u2 = UserApi(None).get_one(u2id)
api2 = ContentApi(u2, show_deleted=True)
content2 = api2.get_one(pcid, ContentType.Any, workspace)
with new_revision(content2):
api2.delete(content2)
api2.save(content2)
transaction.commit()
####
user1 = UserApi(None).get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
# show archived is used at the top end of the test
api = ContentApi(user1, show_deleted=True)
u2 = UserApi(None).get_one(u2id)
api2 = ContentApi(u2, show_deleted=True)
updated = api2.get_one(pcid, ContentType.Any, workspace)
eq_(u2id, updated.owner_id,
'the owner id should be {} (found {})'.format(u2id,
updated.owner_id))
eq_(True, updated.is_deleted)
eq_(ActionDescription.DELETION, updated.revision_type)
####
updated2 = api.get_one(pcid, ContentType.Any, workspace)
with new_revision(updated2):
api.undelete(updated2)
api.save(updated2)
eq_(False, updated2.is_deleted)
eq_(ActionDescription.UNDELETION, updated2.revision_type)
eq_(u1id, updated2.owner_id)
def test_update_file_data(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user1 = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user1).create_workspace('test workspace',
save_now=True)
wid = workspace.workspace_id
user2 = uapi.create_user()
user2.email = '*****@*****.**'
uapi.save(user2)
RoleApi(user1).create_one(user2, workspace,
UserRoleInWorkspace.CONTENT_MANAGER,
with_notif=True,
flush=True)
# Test starts here
api = ContentApi(user1)
p = api.create(ContentType.File, workspace, None,
'this_is_a_page', True)
u1id = user1.user_id
u2id = user2.user_id
pcid = p.content_id
poid = p.owner_id
api.save(p)
transaction.commit()
# Refresh instances after commit
user1 = uapi.get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
api = ContentApi(user1)
content = api.get_one(pcid, ContentType.Any, workspace)
eq_(u1id, content.owner_id)
eq_(poid, content.owner_id)
u2 = UserApi(None).get_one(u2id)
api2 = ContentApi(u2)
content2 = api2.get_one(pcid, ContentType.Any, workspace)
with new_revision(content2):
api2.update_file_data(content2, 'index.html', 'text/html',
b'<html>hello world</html>')
api2.save(content2)
transaction.commit()
# Refresh instances after commit
user1 = uapi.get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
updated = api.get_one(pcid, ContentType.Any, workspace)
eq_(u2id, updated.owner_id,
'the owner id should be {} (found {})'.format(u2id,
updated.owner_id))
eq_('this_is_a_page.html', updated.file_name)
eq_('text/html', updated.file_mimetype)
eq_(b'<html>hello world</html>', updated.file_content)
eq_(ActionDescription.REVISION, updated.revision_type)
def test_update(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user1 = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
workspace = WorkspaceApi(user1).create_workspace('test workspace',
save_now=True)
wid = workspace.workspace_id
user2 = uapi.create_user()
user2.email = '*****@*****.**'
uapi.save(user2)
RoleApi(user1).create_one(user2, workspace,
UserRoleInWorkspace.CONTENT_MANAGER,
with_notif=False,
flush=True)
# Test starts here
api = ContentApi(user1)
p = api.create(ContentType.Page, workspace, None,
'this_is_a_page', True)
u1id = user1.user_id
u2id = user2.user_id
pcid = p.content_id
poid = p.owner_id
transaction.commit()
# Refresh instances after commit
user1 = uapi.get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
api = ContentApi(user1)
content = api.get_one(pcid, ContentType.Any, workspace)
eq_(u1id, content.owner_id)
eq_(poid, content.owner_id)
u2 = UserApi(None).get_one(u2id)
api2 = ContentApi(u2)
content2 = api2.get_one(pcid, ContentType.Any, workspace)
with new_revision(content2):
api2.update_content(content2, 'this is an updated page', 'new content')
api2.save(content2)
transaction.commit()
# Refresh instances after commit
user1 = uapi.get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
api = ContentApi(user1)
updated = api.get_one(pcid, ContentType.Any, workspace)
eq_(u2id, updated.owner_id,
'the owner id should be {} (found {})'.format(u2id,
updated.owner_id))
eq_('this is an updated page', updated.label)
eq_('new content', updated.description)
eq_(ActionDescription.EDITION, updated.revision_type)
class Workspace(DAVCollection):
"""
Workspace resource corresponding to tracim's workspaces.
Direct children can only be folders, though files might come later on and are supported
"""
def __init__(self, path: str, environ: dict, workspace: data.Workspace):
super(Workspace, self).__init__(path, environ)
self.workspace = workspace
self.content = None
self.user = UserApi(None).get_one_by_email(
environ['http_authenticator.username'])
self.content_api = ContentApi(self.user, show_temporary=True)
self._file_count = 0
def __repr__(self) -> str:
return "<DAVCollection: Workspace (%d)>" % self.workspace.workspace_id
def getPreferredPath(self):
return self.path
def getCreationDate(self) -> float:
return mktime(self.workspace.created.timetuple())
def getDisplayName(self) -> str:
return self.workspace.label
def getLastModified(self) -> float:
print("hm....", self.path)
return mktime(self.workspace.updated.timetuple())
def getMemberNames(self) -> [str]:
retlist = []
children = self.content_api.get_all(
parent_id=self.content.id if self.content is not None else None,
workspace=self.workspace)
for content in children:
# the purpose is to display .history only if there's at least one content's type that has a history
if content.type != ContentType.Folder:
self._file_count += 1
retlist.append(content.get_label())
return retlist
def getMember(self, content_label: str) -> _DAVResource:
return self.provider.getResourceInst(
'%s/%s' %
(self.path, self.provider.transform_to_display(content_label)),
self.environ)
def createEmptyResource(self, file_name: str):
"""
[For now] we don't allow to create files right under workspaces.
Though if we come to allow it, deleting the error's raise will make it possible.
"""
# TODO : remove commentary here raise DAVError(HTTP_FORBIDDEN)
if '/.deleted/' in self.path or '/.archived/' in self.path:
raise DAVError(HTTP_FORBIDDEN)
return FakeFileStream(file_name=file_name,
content_api=self.content_api,
workspace=self.workspace,
content=None,
parent=self.content,
path=self.path + '/' + file_name)
def createCollection(self, label: str) -> 'Folder':
"""
Create a new folder for the current workspace. As it's not possible for the user to choose
which types of content are allowed in this folder, we allow allow all of them.
This method return the DAVCollection created.
"""
if '/.deleted/' in self.path or '/.archived/' in self.path:
raise DAVError(HTTP_FORBIDDEN)
folder = self.content_api.create(content_type=ContentType.Folder,
workspace=self.workspace,
label=label,
parent=self.content)
subcontent = dict(folder=True, thread=True, file=True, page=True)
self.content_api.set_allowed_content(folder, subcontent)
self.content_api.save(folder)
transaction.commit()
return Folder(
'%s/%s' % (self.path, self.provider.transform_to_display(label)),
self.environ, folder, self.workspace)
def delete(self):
"""For now, it is not possible to delete a workspace through the webdav client."""
raise DAVError(HTTP_FORBIDDEN)
def supportRecursiveMove(self, destpath):
return True
def moveRecursive(self, destpath):
if dirname(normpath(
destpath)) == self.environ['http_authenticator.realm']:
self.workspace.label = basename(normpath(destpath))
transaction.commit()
else:
raise DAVError(HTTP_FORBIDDEN)
def getMemberList(self) -> [_DAVResource]:
members = []
children = self.content_api.get_all(None, ContentType.Any,
self.workspace)
for content in children:
content_path = '%s/%s' % (self.path,
self.provider.transform_to_display(
content.get_label()))
if content.type == ContentType.Folder:
members.append(
Folder(content_path, self.environ, self.workspace,
content))
elif content.type == ContentType.File:
self._file_count += 1
members.append(File(content_path, self.environ, content))
else:
self._file_count += 1
members.append(OtherFile(content_path, self.environ, content))
if self._file_count > 0 and self.provider.show_history():
members.append(
HistoryFolder(path=self.path + '/' + ".history",
environ=self.environ,
content=self.content,
workspace=self.workspace,
type=HistoryType.Standard))
if self.provider.show_delete():
members.append(
DeletedFolder(path=self.path + '/' + ".deleted",
environ=self.environ,
content=self.content,
workspace=self.workspace))
if self.provider.show_archive():
members.append(
ArchivedFolder(path=self.path + '/' + ".archived",
environ=self.environ,
content=self.content,
workspace=self.workspace))
return members
class Workspace(DAVCollection):
"""
Workspace resource corresponding to tracim's workspaces.
Direct children can only be folders, though files might come later on and are supported
"""
def __init__(self, path: str, environ: dict, workspace: data.Workspace):
super(Workspace, self).__init__(path, environ)
self.workspace = workspace
self.content = None
self.user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
self.content_api = ContentApi(self.user, show_temporary=True)
self._file_count = 0
def __repr__(self) -> str:
return "<DAVCollection: Workspace (%d)>" % self.workspace.workspace_id
def getPreferredPath(self):
return self.path
def getCreationDate(self) -> float:
return mktime(self.workspace.created.timetuple())
def getDisplayName(self) -> str:
return self.workspace.label
def getLastModified(self) -> float:
return mktime(self.workspace.updated.timetuple())
def getMemberNames(self) -> [str]:
retlist = []
children = self.content_api.get_all(
parent_id=self.content.id if self.content is not None else None,
workspace=self.workspace
)
for content in children:
# the purpose is to display .history only if there's at least one content's type that has a history
if content.type != ContentType.Folder:
self._file_count += 1
retlist.append(content.get_label_as_file())
return retlist
def getMember(self, content_label: str) -> _DAVResource:
return self.provider.getResourceInst(
'%s/%s' % (self.path, transform_to_display(content_label)),
self.environ
)
def createEmptyResource(self, file_name: str):
"""
[For now] we don't allow to create files right under workspaces.
Though if we come to allow it, deleting the error's raise will make it possible.
"""
# TODO : remove commentary here raise DAVError(HTTP_FORBIDDEN)
if '/.deleted/' in self.path or '/.archived/' in self.path:
raise DAVError(HTTP_FORBIDDEN)
content = None
# Note: To prevent bugs, check here again if resource already exist
path = os.path.join(self.path, file_name)
resource = self.provider.getResourceInst(path, self.environ)
if resource:
content = resource.content
return FakeFileStream(
file_name=file_name,
content_api=self.content_api,
workspace=self.workspace,
content=content,
parent=self.content,
path=self.path + '/' + file_name
)
def createCollection(self, label: str) -> 'Folder':
"""
Create a new folder for the current workspace. As it's not possible for the user to choose
which types of content are allowed in this folder, we allow allow all of them.
This method return the DAVCollection created.
"""
if '/.deleted/' in self.path or '/.archived/' in self.path:
raise DAVError(HTTP_FORBIDDEN)
folder = self.content_api.create(
content_type=ContentType.Folder,
workspace=self.workspace,
label=label,
parent=self.content
)
subcontent = dict(
folder=True,
thread=True,
file=True,
page=True
)
self.content_api.set_allowed_content(folder, subcontent)
self.content_api.save(folder)
transaction.commit()
return Folder('%s/%s' % (self.path, transform_to_display(label)),
self.environ, folder,
self.workspace)
def delete(self):
"""For now, it is not possible to delete a workspace through the webdav client."""
raise DAVError(HTTP_FORBIDDEN)
def supportRecursiveMove(self, destpath):
return True
def moveRecursive(self, destpath):
if dirname(normpath(destpath)) == self.environ['http_authenticator.realm']:
self.workspace.label = basename(normpath(destpath))
transaction.commit()
else:
raise DAVError(HTTP_FORBIDDEN)
def getMemberList(self) -> [_DAVResource]:
members = []
children = self.content_api.get_all(False, ContentType.Any, self.workspace)
for content in children:
content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
if content.type == ContentType.Folder:
members.append(Folder(content_path, self.environ, self.workspace, content))
elif content.type == ContentType.File:
self._file_count += 1
members.append(File(content_path, self.environ, content))
else:
self._file_count += 1
members.append(OtherFile(content_path, self.environ, content))
if self._file_count > 0 and self.provider.show_history():
members.append(
HistoryFolder(
path=self.path + '/' + ".history",
environ=self.environ,
content=self.content,
workspace=self.workspace,
type=HistoryType.Standard
)
)
if self.provider.show_delete():
members.append(
DeletedFolder(
path=self.path + '/' + ".deleted",
environ=self.environ,
content=self.content,
workspace=self.workspace
)
)
if self.provider.show_archive():
members.append(
ArchivedFolder(
path=self.path + '/' + ".archived",
environ=self.environ,
content=self.content,
workspace=self.workspace
)
)
return members
def test_mark_read__workspace(self):
uapi = UserApi(None)
groups = [
GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)
]
user_a = uapi.create_user(email='this.is@user',
groups=groups,
save_now=True)
user_b = uapi.create_user(email='*****@*****.**',
groups=groups,
save_now=True)
wapi = WorkspaceApi(user_a)
workspace1 = wapi.create_workspace('test workspace n°1', save_now=True)
workspace2 = wapi.create_workspace('test workspace n°2', save_now=True)
role_api1 = RoleApi(user_a)
role_api1.create_one(user_b, workspace1, UserRoleInWorkspace.READER,
False)
role_api2 = RoleApi(user_a)
role_api2.create_one(user_b, workspace2, UserRoleInWorkspace.READER,
False)
cont_api_a = ContentApi(user_a)
cont_api_b = ContentApi(user_b)
# Creates page_1 & page_2 in workspace 1
# and page_3 & page_4 in workspace 2
page_1 = cont_api_a.create(ContentType.Page,
workspace1,
None,
'this is a page',
do_save=True)
page_2 = cont_api_a.create(ContentType.Page,
workspace1,
None,
'this is page1',
do_save=True)
page_3 = cont_api_a.create(ContentType.Thread,
workspace2,
None,
'this is page2',
do_save=True)
page_4 = cont_api_a.create(ContentType.File,
workspace2,
None,
'this is page3',
do_save=True)
for rev in page_1.revisions:
eq_(user_b not in rev.read_by.keys(), True)
for rev in page_2.revisions:
eq_(user_b not in rev.read_by.keys(), True)
for rev in page_3.revisions:
eq_(user_b not in rev.read_by.keys(), True)
for rev in page_4.revisions:
eq_(user_b not in rev.read_by.keys(), True)
# Set as read the workspace n°1
cont_api_b.mark_read__workspace(workspace=workspace1)
for rev in page_1.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_2.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_3.revisions:
eq_(user_b not in rev.read_by.keys(), True)
for rev in page_4.revisions:
eq_(user_b not in rev.read_by.keys(), True)
# Set as read the workspace n°2
cont_api_b.mark_read__workspace(workspace=workspace2)
for rev in page_1.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_2.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_3.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_4.revisions:
eq_(user_b in rev.read_by.keys(), True)
def insert(self):
admin = self._session.query(model.User) \
.filter(model.User.email == '*****@*****.**') \
.one()
bob = self._session.query(model.User) \
.filter(model.User.email == '*****@*****.**') \
.one()
admin_workspace_api = WorkspaceApi(admin)
bob_workspace_api = WorkspaceApi(bob)
content_api = ContentApi(admin)
role_api = RoleApi(admin)
# Workspaces
w1 = admin_workspace_api.create_workspace('w1', save_now=True)
w2 = bob_workspace_api.create_workspace('w2', save_now=True)
w3 = admin_workspace_api.create_workspace('w3', save_now=True)
# Workspaces roles
role_api.create_one(
user=bob,
workspace=w1,
role_level=UserRoleInWorkspace.CONTENT_MANAGER,
with_notif=False,
)
# Folders
w1f1 = content_api.create(
content_type=ContentType.Folder,
workspace=w1,
label='w1f1',
do_save=True,
)
w1f2 = content_api.create(
content_type=ContentType.Folder,
workspace=w1,
label='w1f2',
do_save=True,
)
w2f1 = content_api.create(
content_type=ContentType.Folder,
workspace=w2,
label='w2f1',
do_save=True,
)
w2f2 = content_api.create(
content_type=ContentType.Folder,
workspace=w2,
label='w2f2',
do_save=True,
)
w3f1 = content_api.create(
content_type=ContentType.Folder,
workspace=w3,
label='w3f3',
do_save=True,
)
# Pages, threads, ..
w1f1p1 = content_api.create(
content_type=ContentType.Page,
workspace=w1,
parent=w1f1,
label='w1f1p1',
do_save=True,
)
w1f1t1 = content_api.create(
content_type=ContentType.Thread,
workspace=w1,
parent=w1f1,
label='w1f1t1',
do_save=False,
)
w1f1t1.description = 'w1f1t1 description'
self._session.add(w1f1t1)
w1f1d1_txt = content_api.create(
content_type=ContentType.File,
workspace=w1,
parent=w1f1,
label='w1f1d1',
do_save=False,
)
w1f1d1_txt.file_extension = '.txt'
w1f1d1_txt.depot_file = FileIntent(
b'w1f1d1 content',
'w1f1d1.txt',
'text/plain',
)
self._session.add(w1f1d1_txt)
w1f1d2_html = content_api.create(
content_type=ContentType.File,
workspace=w1,
parent=w1f1,
label='w1f1d2',
do_save=False,
)
w1f1d2_html.file_extension = '.html'
w1f1d2_html.depot_file = FileIntent(
b'<p>w1f1d2 content</p>',
'w1f1d2.html',
'text/html',
)
self._session.add(w1f1d2_html)
w1f1f1 = content_api.create(
content_type=ContentType.Folder,
workspace=w1,
label='w1f1f1',
parent=w1f1,
do_save=True,
)
w2f1p1 = content_api.create(
content_type=ContentType.Page,
workspace=w2,
parent=w2f1,
label='w2f1p1',
do_save=True,
)
self._session.flush()
def test_update(self):
uapi = UserApi(None)
groups = [
GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)
]
user1 = uapi.create_user(email='this.is@user',
groups=groups,
save_now=True)
workspace = WorkspaceApi(user1).create_workspace('test workspace',
save_now=True)
wid = workspace.workspace_id
user2 = uapi.create_user()
user2.email = '*****@*****.**'
uapi.save(user2)
RoleApi(user1).create_one(user2,
workspace,
UserRoleInWorkspace.CONTENT_MANAGER,
with_notif=False,
flush=True)
# Test starts here
api = ContentApi(user1)
p = api.create(ContentType.Page, workspace, None, 'this_is_a_page',
True)
u1id = user1.user_id
u2id = user2.user_id
pcid = p.content_id
poid = p.owner_id
transaction.commit()
# Refresh instances after commit
user1 = uapi.get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
api = ContentApi(user1)
content = api.get_one(pcid, ContentType.Any, workspace)
eq_(u1id, content.owner_id)
eq_(poid, content.owner_id)
u2 = UserApi(None).get_one(u2id)
api2 = ContentApi(u2)
content2 = api2.get_one(pcid, ContentType.Any, workspace)
with new_revision(content2):
api2.update_content(content2, 'this is an updated page',
'new content')
api2.save(content2)
transaction.commit()
# Refresh instances after commit
user1 = uapi.get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
api = ContentApi(user1)
updated = api.get_one(pcid, ContentType.Any, workspace)
eq_(
u2id, updated.owner_id,
'the owner id should be {} (found {})'.format(
u2id, updated.owner_id))
eq_('this is an updated page', updated.label)
eq_('new content', updated.description)
eq_(ActionDescription.EDITION, updated.revision_type)
def test_update_file_data(self):
uapi = UserApi(None)
groups = [
GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)
]
user1 = uapi.create_user(email='this.is@user',
groups=groups,
save_now=True)
workspace = WorkspaceApi(user1).create_workspace('test workspace',
save_now=True)
wid = workspace.workspace_id
user2 = uapi.create_user()
user2.email = '*****@*****.**'
uapi.save(user2)
RoleApi(user1).create_one(user2,
workspace,
UserRoleInWorkspace.CONTENT_MANAGER,
with_notif=True,
flush=True)
# Test starts here
api = ContentApi(user1)
p = api.create(ContentType.File, workspace, None, 'this_is_a_page',
True)
u1id = user1.user_id
u2id = user2.user_id
pcid = p.content_id
poid = p.owner_id
api.save(p)
transaction.commit()
# Refresh instances after commit
user1 = uapi.get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
api = ContentApi(user1)
content = api.get_one(pcid, ContentType.Any, workspace)
eq_(u1id, content.owner_id)
eq_(poid, content.owner_id)
u2 = UserApi(None).get_one(u2id)
api2 = ContentApi(u2)
content2 = api2.get_one(pcid, ContentType.Any, workspace)
with new_revision(content2):
api2.update_file_data(content2, 'index.html', 'text/html',
b'<html>hello world</html>')
api2.save(content2)
transaction.commit()
# Refresh instances after commit
user1 = uapi.get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
updated = api.get_one(pcid, ContentType.Any, workspace)
eq_(
u2id, updated.owner_id,
'the owner id should be {} (found {})'.format(
u2id, updated.owner_id))
eq_('this_is_a_page.html', updated.file_name)
eq_('text/html', updated.file_mimetype)
eq_(b'<html>hello world</html>', updated.file_content)
eq_(ActionDescription.REVISION, updated.revision_type)
def insert(self):
admin = self._session.query(model.User) \
.filter(model.User.email == '*****@*****.**') \
.one()
bob = self._session.query(model.User) \
.filter(model.User.email == '*****@*****.**') \
.one()
admin_workspace_api = WorkspaceApi(admin)
bob_workspace_api = WorkspaceApi(bob)
content_api = ContentApi(admin)
role_api = RoleApi(admin)
# Workspaces
w1 = admin_workspace_api.create_workspace('w1', save_now=True)
w2 = bob_workspace_api.create_workspace('w2', save_now=True)
w3 = admin_workspace_api.create_workspace('w3', save_now=True)
# Workspaces roles
role_api.create_one(
user=bob,
workspace=w1,
role_level=UserRoleInWorkspace.CONTENT_MANAGER,
with_notif=False,
)
# Folders
w1f1 = content_api.create(
content_type=ContentType.Folder,
workspace=w1,
label='w1f1',
do_save=True,
)
w1f2 = content_api.create(
content_type=ContentType.Folder,
workspace=w1,
label='w1f2',
do_save=True,
)
w2f1 = content_api.create(
content_type=ContentType.Folder,
workspace=w2,
label='w2f1',
do_save=True,
)
w2f2 = content_api.create(
content_type=ContentType.Folder,
workspace=w2,
label='w2f2',
do_save=True,
)
w3f1 = content_api.create(
content_type=ContentType.Folder,
workspace=w3,
label='w3f3',
do_save=True,
)
# Pages, threads, ..
w1f1p1 = content_api.create(
content_type=ContentType.Page,
workspace=w1,
parent=w1f1,
label='w1f1p1',
do_save=True,
)
w1f1t1 = content_api.create(
content_type=ContentType.Thread,
workspace=w1,
parent=w1f1,
label='w1f1t1',
do_save=False,
)
w1f1t1.description = 'w1f1t1 description'
self._session.add(w1f1t1)
w1f1d1_txt = content_api.create(
content_type=ContentType.File,
workspace=w1,
parent=w1f1,
label='w1f1d1',
do_save=False,
)
w1f1d1_txt.file_extension = '.txt'
w1f1d1_txt.file_content = b'w1f1d1 content'
self._session.add(w1f1d1_txt)
w1f1d2_html = content_api.create(
content_type=ContentType.File,
workspace=w1,
parent=w1f1,
label='w1f1d2',
do_save=False,
)
w1f1d2_html.file_extension = '.html'
w1f1d2_html.file_content = b'<p>w1f1d2 content</p>'
self._session.add(w1f1d2_html)
w1f1f1 = content_api.create(
content_type=ContentType.Folder,
workspace=w1,
label='w1f1f1',
parent=w1f1,
do_save=True,
)
w2f1p1 = content_api.create(
content_type=ContentType.Page,
workspace=w2,
parent=w2f1,
label='w2f1p1',
do_save=True,
)
self._session.flush()
def test_archive_unarchive(self):
uapi = UserApi(None)
groups = [
GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)
]
user1 = uapi.create_user(email='this.is@user',
groups=groups,
save_now=True)
u1id = user1.user_id
workspace = WorkspaceApi(user1).create_workspace('test workspace',
save_now=True)
wid = workspace.workspace_id
user2 = uapi.create_user()
user2.email = '*****@*****.**'
uapi.save(user2)
RoleApi(user1).create_one(user2,
workspace,
UserRoleInWorkspace.CONTENT_MANAGER,
with_notif=True,
flush=True)
# show archived is used at the top end of the test
api = ContentApi(user1, show_archived=True)
p = api.create(ContentType.File, workspace, None, 'this_is_a_page',
True)
u1id = user1.user_id
u2id = user2.user_id
pcid = p.content_id
poid = p.owner_id
transaction.commit()
####
# refresh after commit
user1 = UserApi(None).get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
content = api.get_one(pcid, ContentType.Any, workspace)
eq_(u1id, content.owner_id)
eq_(poid, content.owner_id)
u2 = UserApi(None).get_one(u2id)
api2 = ContentApi(u2, show_archived=True)
content2 = api2.get_one(pcid, ContentType.Any, workspace)
with new_revision(content2):
api2.archive(content2)
api2.save(content2)
transaction.commit()
# refresh after commit
user1 = UserApi(None).get_one(u1id)
workspace = WorkspaceApi(user1).get_one(wid)
u2 = UserApi(None).get_one(u2id)
api = ContentApi(user1, show_archived=True)
api2 = ContentApi(u2, show_archived=True)
updated = api2.get_one(pcid, ContentType.Any, workspace)
eq_(
u2id, updated.owner_id,
'the owner id should be {} (found {})'.format(
u2id, updated.owner_id))
eq_(True, updated.is_archived)
eq_(ActionDescription.ARCHIVING, updated.revision_type)
####
updated2 = api.get_one(pcid, ContentType.Any, workspace)
with new_revision(updated):
api.unarchive(updated)
api.save(updated2)
eq_(False, updated2.is_archived)
eq_(ActionDescription.UNARCHIVING, updated2.revision_type)
eq_(u1id, updated2.owner_id)
def test_mark_read__workspace(self):
uapi = UserApi(None)
groups = [GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)]
user_a = uapi.create_user(email='this.is@user',
groups=groups, save_now=True)
user_b = uapi.create_user(email='*****@*****.**',
groups=groups, save_now=True)
wapi = WorkspaceApi(user_a)
workspace1 = wapi.create_workspace(
'test workspace n°1',
save_now=True)
workspace2 = wapi.create_workspace(
'test workspace n°2',
save_now=True)
role_api1 = RoleApi(user_a)
role_api1.create_one(user_b, workspace1, UserRoleInWorkspace.READER,
False)
role_api2 = RoleApi(user_a)
role_api2.create_one(user_b, workspace2, UserRoleInWorkspace.READER,
False)
cont_api_a = ContentApi(user_a)
cont_api_b = ContentApi(user_b)
# Creates page_1 & page_2 in workspace 1
# and page_3 & page_4 in workspace 2
page_1 = cont_api_a.create(ContentType.Page, workspace1, None,
'this is a page', do_save=True)
page_2 = cont_api_a.create(ContentType.Page, workspace1, None,
'this is page1', do_save=True)
page_3 = cont_api_a.create(ContentType.Thread, workspace2, None,
'this is page2', do_save=True)
page_4 = cont_api_a.create(ContentType.File, workspace2, None,
'this is page3', do_save=True)
for rev in page_1.revisions:
eq_(user_b not in rev.read_by.keys(), True)
for rev in page_2.revisions:
eq_(user_b not in rev.read_by.keys(), True)
for rev in page_3.revisions:
eq_(user_b not in rev.read_by.keys(), True)
for rev in page_4.revisions:
eq_(user_b not in rev.read_by.keys(), True)
# Set as read the workspace n°1
cont_api_b.mark_read__workspace(workspace=workspace1)
for rev in page_1.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_2.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_3.revisions:
eq_(user_b not in rev.read_by.keys(), True)
for rev in page_4.revisions:
eq_(user_b not in rev.read_by.keys(), True)
# Set as read the workspace n°2
cont_api_b.mark_read__workspace(workspace=workspace2)
for rev in page_1.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_2.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_3.revisions:
eq_(user_b in rev.read_by.keys(), True)
for rev in page_4.revisions:
eq_(user_b in rev.read_by.keys(), True)
def test_search_in_label_or_description(self):
# HACK - D.A. - 2015-03-09
# This test is based on a bug which does NOT return results found
# at root of a workspace (eg a folder)
uapi = UserApi(None)
groups = [
GroupApi(None).get_one(Group.TIM_USER),
GroupApi(None).get_one(Group.TIM_MANAGER),
GroupApi(None).get_one(Group.TIM_ADMIN)
]
user = uapi.create_user(email='this.is@user',
groups=groups,
save_now=True)
workspace = WorkspaceApi(user).create_workspace('test workspace',
save_now=True)
api = ContentApi(user)
a = api.create(ContentType.Folder, workspace, None,
'this is randomized folder', True)
p1 = api.create(ContentType.Page, workspace, a,
'this is dummy label content', True)
p2 = api.create(ContentType.Page, workspace, a, 'Hey ! Jon !', True)
with new_revision(p1):
p1.description = 'This is some amazing test'
with new_revision(p2):
p2.description = 'What\'s up ?'
api.save(p1)
api.save(p2)
id1 = p1.content_id
id2 = p2.content_id
eq_(
1,
DBSession.query(Workspace).filter(
Workspace.label == 'test workspace').count())
eq_(
1,
DBSession.query(ContentRevisionRO).filter(
ContentRevisionRO.label ==
'this is randomized folder').count())
eq_(
2,
DBSession.query(ContentRevisionRO).filter(
ContentRevisionRO.label ==
'this is dummy label content').count())
eq_(
1,
DBSession.query(ContentRevisionRO).filter(
ContentRevisionRO.description ==
'This is some amazing test').count())
eq_(
2,
DBSession.query(ContentRevisionRO).filter(
ContentRevisionRO.label == 'Hey ! Jon !').count())
eq_(
1,
DBSession.query(ContentRevisionRO).filter(
ContentRevisionRO.description == 'What\'s up ?').count())
res = api.search(['dummy', 'jon'])
eq_(2, len(res.all()))
eq_(True, id1 in [o.content_id for o in res.all()])
eq_(True, id2 in [o.content_id for o in res.all()])
