def target(self):
query = make_query(**{
'sort': self.request.params.get('sort'),
'term': self.request.params.get('term'),
'order': self.request.params.get('order'),
'b_page': self.request.params.get('b_page'),
'size': self.request.params.get('size'),
})
came_from = make_url(self.request, node=self.model.root, query=query)
query = make_query(**{
UX_IDENT: UX_FRONTEND,
'submitter_came_from': urllib2.quote(came_from),
})
return make_url(self.request, node=self.model, query=query)
def vocab(self):
ret = list()
path = node_path(self.model)
count = self.table_tile.item_count
slicesize = self.table_tile.slicesize
pages = count // slicesize
if count % slicesize != 0:
pages += 1
current = self.request.params.get('b_page', '0')
params = {
'sort': self.table_tile.sort_column,
'order': self.table_tile.sort_order,
'size': slicesize,
'term': self.table_tile.filter_term,
}
for term in self.table_tile.query_whitelist:
params[term] = self.request.params.get(term, '')
for i in range(pages):
params['b_page'] = str(i)
query = make_query(**params)
url = make_url(
self.request,
path=path,
# resource=self.related_view,
query=query
)
ret.append({
'page': '%i' % (i + 1),
'current': current == str(i),
'visible': True,
'url': url,
})
return ret
def render(self):
model = self.model
title = model.metadata.get('title', model.name)
if not model.properties.action_delete:
ts = _('object_not_deletable',
default='Object "${title}" not deletable',
mapping={'title': title})
localizer = get_localizer(self.request)
message = localizer.translate(ts)
ajax_message(self.request, message, 'error')
return u''
content_tile = model.properties.action_delete_tile
if not content_tile:
content_tile = 'content'
parent = model.parent
del parent[model.name]
if hasattr(parent, '__call__'):
parent()
query = make_query(contenttile=content_tile)
url = make_url(self.request, node=parent, query=query)
ajax_continue(self.request, self.continuation(url))
if self.show_confirm_deleted:
ts = _('deleted_object',
default='Deleted: ${title}',
mapping={'title': title})
localizer = get_localizer(self.request)
message = localizer.translate(ts)
ajax_message(self.request, message, 'info')
return u''
def wrap_ajax_target(rendered, widget, data):
if widget.attrs.get('target'):
target = widget.attrs.get('target')
if callable(target):
target = target()
referencable = widget.attrs['referencable']
if callable(referencable):
referencable = referencable()
if type(referencable) in [types.ListType, types.TupleType]:
referencable = ','.join(referencable)
root = widget.attrs['root']
if callable(root):
root = root()
selected = ''
if widget.attrs['multivalued'] and data.value:
selected = ','.join(data.value)
elif data.value and data.value[0]:
selected = data.value[0]
query = make_query(**{
'root': root,
'referencable': referencable,
'selected': selected,
})
target = '%s%s' % (target, query)
attrs = {
'ajax:target': target,
}
return tag('span', rendered, **attrs)
return rendered
def vocab(self):
ret = list()
path = node_path(self.model)
count = self.table_tile.item_count
slicesize = self.table_tile.slicesize
pages = count / slicesize
if count % slicesize != 0:
pages += 1
current = self.request.params.get('b_page', '0')
params = {
'sort': self.table_tile.sort_column,
'order': self.table_tile.sort_order,
'size': slicesize,
'term': self.table_tile.filter_term,
}
for term in self.table_tile.query_whitelist:
params[term] = self.request.params.get(term, '')
for i in range(pages):
params['b_page'] = str(i)
query = make_query(**params)
url = make_url(
self.request,
path=path,
#resource=self.related_view,
query=query)
ret.append({
'page': '%i' % (i + 1),
'current': current == str(i),
'visible': True,
'url': url,
})
return ret
def sort_target(self, sort, order):
query = make_query(
filter=self.filter_term,
b_page=self.current_page,
sort=sort,
order=order)
return safe_decode(make_url(self.request, node=self.model, query=query))
def wrap_ajax_target(rendered, widget, data):
if widget.attrs.get('target'):
target = widget.attrs.get('target')
if callable(target):
target = target()
referencable = widget.attrs['referencable']
if callable(referencable):
referencable = referencable()
if type(referencable) in [types.ListType, types.TupleType]:
referencable = ','.join(referencable)
root = widget.attrs['root']
if callable(root):
root = root()
selected = ''
if widget.attrs['multivalued'] and data.value:
selected = ','.join(data.value)
elif data.value and data.value[0]:
selected = data.value[0]
query = make_query(**{
'root': root,
'referencable': referencable,
'selected': selected,
})
target = '%s%s' % (target, query)
attrs = {
'ajax:target': target,
}
return tag('span', rendered, **attrs)
return rendered
def render(self):
model = self.model
title = model.metadata.get('title', model.name)
if not model.properties.action_delete:
ts = _('object_not_deletable',
default='Object "${title}" not deletable',
mapping={'title': title})
localizer = get_localizer(self.request)
message = localizer.translate(ts)
ajax_message(self.request, message, 'error')
return u''
content_tile = model.properties.action_delete_tile
if not content_tile:
content_tile = 'content'
parent = model.parent
del parent[model.name]
if hasattr(parent, '__call__'):
parent()
query = make_query(contenttile=content_tile)
url = make_url(self.request, node=parent, query=query)
ajax_continue(self.request, self.continuation(url))
if self.show_confirm_deleted:
ts = _('deleted_object',
default='Deleted: ${title}',
mapping={'title': title})
localizer = get_localizer(self.request)
message = localizer.translate(ts)
ajax_message(self.request, message, 'info')
return u''
def wrap_ajax_target(rendered, widget, data):
if widget.attrs.get('target'):
target = widget.attrs.get('target')
if callable(target):
target = target(widget, data)
referencable = widget.attrs['referencable']
if callable(referencable):
referencable = referencable(widget, data)
if type(referencable) in compat.ITER_TYPES:
referencable = ','.join(referencable)
root = widget.attrs['root']
if callable(root):
root = root(widget, data)
selected = ''
if widget.attrs['multivalued'] and data.value:
selected = ','.join(data.value)
elif data.value and data.value[0]:
selected = data.value[0]
query = make_query(**{
'root': root,
'referencable': referencable,
'selected': selected,
})
target = '{}{}'.format(target, query)
attrs = {
'ajax:target': target,
}
return tag('span', rendered, **attrs)
# XXX: referencebrowser not works without target, check if case
# necessary. raise error here?
return rendered
def batch_target(self, path, b_page):
query = make_query(
b_page=str(b_page),
filter=self.filter_term,
sort=self.sort_column,
order=self.sort_order)
return safe_decode(make_url(self.request, path=path, query=query))
def references(self, start, end):
ret = list()
for record in self.visible_references[start:end]:
# ref title and path
title = self.reference_title(record)
path = self.reference_path(record)
# case rendered in frontend
if self.is_frontend:
query = make_query(**{
UX_IDENT: UX_FRONTEND,
'submitter_came_from': submitter_came_from(self.request),
})
ref = self._make_reference(
title,
target=make_url(self.request, path=path, query=query),
overlay=self.reference_tile,
icon=self.icon,
path=self.reference_permalink(record)
)
# case rendered in backend
else:
ref = self._make_reference(
title,
target=make_url(self.request, path=path),
event='contextchanged:#layout',
icon=self.icon,
path='target'
)
ret.append(ref)
return ret
def wrap_ajax_target(rendered, widget, data):
if widget.attrs.get('target'):
target = widget.attrs.get('target')
if callable(target):
target = target(widget, data)
referencable = widget.attrs['referencable']
if callable(referencable):
referencable = referencable(widget, data)
if type(referencable) in compat.ITER_TYPES:
referencable = ','.join(referencable)
root = widget.attrs['root']
if callable(root):
root = root(widget, data)
selected = ''
if widget.attrs['multivalued'] and data.value:
selected = ','.join(data.value)
elif data.value and data.value[0]:
selected = data.value[0]
query = make_query(**{
'root': root,
'referencable': referencable,
'selected': selected,
})
target = '{}{}'.format(target, query)
attrs = {
'ajax:target': target,
}
return tag('span', rendered, **attrs)
# XXX: referencebrowser not works without target, check if case
# necessary. raise error here?
return rendered
def wrap_ajax_target(rendered, widget, data):
target = widget.attrs['target']
if not target:
request = data.request.request
request = request if request else get_current_request()
target = make_url(request, node=get_root())
if callable(target):
target = target(widget, data)
referencable = widget.attrs['referencable']
if callable(referencable):
referencable = referencable(widget, data)
if type(referencable) in compat.ITER_TYPES:
referencable = ','.join(referencable)
if not referencable:
referencable = ''
root = widget.attrs['root']
if callable(root):
root = root(widget, data)
value = fetch_reference_value(widget, data)
selected = ''
if widget.attrs['multivalued'] and value:
selected = ','.join(value)
elif value:
selected = value
query = make_query(**{
'root': root,
'referencable': referencable,
'selected': selected,
})
target = '{}{}'.format(target, query)
attrs = {
'ajax:target': target,
}
return tag('span', rendered, **attrs)
def vocab(self):
ret = list()
path = nodepath(self.model)
count = self.references_tile.item_count
slicesize = self.references_tile.slicesize
pages = count / slicesize
if count % slicesize != 0:
pages += 1
current = self.request.params.get('b_page', '0')
params = {
UX_IDENT: UX_FRONTEND,
'submitter_came_from': submitter_came_from(self.request),
'size': slicesize,
}
for i in range(pages):
params['b_page'] = str(i)
query = make_query(**params)
url = make_url(self.request, path=path, query=query)
ret.append({
'page': '%i' % (i + 1),
'current': current == str(i),
'visible': True,
'url': url,
})
return ret
def make_refbrowser_query(request, **kw):
params = {
'root': request.params['root'],
'referencable': request.params['referencable'],
'selected': request.params['selected'],
}
params.update(kw)
return make_query(**params)
def next(self, request):
came_from_url = urllib2.unquote(request.get('authoring_came_from'))
came_from_url += make_query(**{
UX_IDENT: UX_FRONTEND,
'submitter_came_from': submitter_came_from(self.request),
})
came_from_tile = request.get('came_from_tile')
return [AjaxOverlay(action=came_from_tile, target=came_from_url)]
def make_refbrowser_query(request, **kw):
params = {
'root': request.params['root'],
'referencable': request.params['referencable'],
'selected': request.params['selected'],
}
params.update(kw)
return make_query(**params)
def image_src(self):
a_type = self.model.attrs['attachment_type']
if a_type == 'image':
query = make_query(scale='mini')
return make_url(self.request,
node=self.model,
resource='download',
query=query)
def fillchildren(self, model, path, tree):
"""XXX: consider cone.app.interfaces.INavigationLeaf
"""
curpath = None
if path:
curpath = path[0]
default_child = None
if model.properties.default_child:
if not curpath or curpath == model.properties.default_child:
default_child = model[model.properties.default_child]
if default_child and default_child.properties.hide_if_default:
model = default_child
default_child = None
if path:
path = path[1:]
if path:
curpath = path[0]
if default_child:
if not curpath:
curpath = model.properties.default_child
for key in model:
node = model[key]
if not self.request.has_permission('view', node):
continue
if not node.properties.get('in_navtree'):
continue
title = node.metadata.title
if title:
title = safe_decode(title)
url = make_url(self.request, node=node)
query = make_query(
contenttile=node.properties.default_content_tile)
target = make_url(self.request, node=node, query=query)
curnode = curpath == safe_decode(key)
icon = node_icon(node)
css = ''
if IWorkflowState.providedBy(node):
css = 'state-%s' % node.state
child = self.navtreeitem(title, url, target, node_path(node), icon,
css)
child['showchildren'] = curnode
if curnode:
child['selected'] = True
if default_child:
self.fillchildren(default_child, path[1:], child)
else:
self.fillchildren(node, path[1:], child)
else:
selected_path = node_path(self.model)
if default_child:
selected_path.append(default_child.name)
selected = False
# XXX: probably superfluous. keep as of cone.app 1.1
# if selected_path == node_path(node):
# selected = True
child['selected'] = selected
tree['children'].append(child)
def fillchildren(self, model, path, tree):
"""XXX: consider cone.app.interfaces.INavigationLeaf
"""
curpath = None
if path:
curpath = path[0]
default_child = None
if model.properties.default_child:
if not curpath or curpath == model.properties.default_child:
default_child = model[model.properties.default_child]
if default_child and default_child.properties.hide_if_default:
model = default_child
default_child = None
if path:
path = path[1:]
if path:
curpath = path[0]
if default_child:
if not curpath:
curpath = model.properties.default_child
for key in model:
node = model[key]
if not self.request.has_permission('view', node):
continue
if not node.properties.get('in_navtree'):
continue
title = node.metadata.title
if title:
title = safe_decode(title)
url = make_url(self.request, node=node)
query = make_query(contenttile=node.properties.default_content_tile)
target = make_url(self.request, node=node, query=query)
curnode = curpath == safe_decode(key)
icon = node_icon(node)
css = ''
if IWorkflowState.providedBy(node):
css = 'state-%s' % node.state
child = self.navtreeitem(
title, url, target, node_path(node), icon, css)
child['showchildren'] = curnode
if curnode:
child['selected'] = True
if default_child:
self.fillchildren(default_child, path[1:], child)
else:
self.fillchildren(node, path[1:], child)
else:
selected_path = node_path(self.model)
if default_child:
selected_path.append(default_child.name)
selected = False
# XXX: probably superfluous. keep as of cone.app 1.1
# if selected_path == node_path(node):
# selected = True
child['selected'] = selected
tree['children'].append(child)
def test_make_query(self):
self.assertEqual(make_query(foo=None), None)
self.assertEqual(make_query(foo=[]), None)
self.assertEqual(make_query(foo='123'), '?foo=123')
self.assertEqual(make_query(foo=['456', '789']), '?foo=456&foo=789')
self.assertEqual(make_query(foo=1), '?foo=1')
self.assertEqual(make_query(foo=1.), '?foo=1.0')
self.assertEqual(make_query(foo='foo', bar='bar'), '?bar=bar&foo=foo')
self.assertEqual(
make_query(quote_params=('foo', ),
foo='http://example.com?param=value'),
'?foo=http%3A//example.com%3Fparam%3Dvalue')
self.assertEqual(
make_query(came_from='http://example.com?param=value'),
'?came_from=http%3A//example.com%3Fparam%3Dvalue')
def next(self, request):
came_from_url = urllib2.unquote(request.get('authoring_came_from'))
came_from_url += make_query(**{
UX_IDENT: UX_FRONTEND,
'submitter_came_from': submitter_came_from(self.request),
})
came_from_tile = request.get('came_from_tile')
root_url = make_url(self.request, node=self.model.root)
return [AjaxOverlay(action=came_from_tile, target=came_from_url),
AjaxEvent(root_url, 'datachanged', '#chronotope-map')]
def target(self):
container = self.model.parent
default_child = container.properties.default_child
if default_child and self.model.name == default_child:
container = container.parent
contenttile = self.model.properties.action_up_tile
if not contenttile:
contenttile = 'listing'
query = make_query(contenttile=contenttile)
return make_url(self.request, node=container, query=query)
def next(self, request):
came_from_url = urllib2.unquote(request.get('authoring_came_from'))
root_url = make_url(self.request, node=self.model.root)
if not came_from_url:
if request.get('action.{0}.cancel'.format(self.form_name)):
return [AjaxOverlay(close=True)]
query = make_query(**{
UX_IDENT: UX_FRONTEND,
})
url = make_url(self.request, node=self.model, query=query)
return [AjaxOverlay(action='location', target=url),
AjaxEvent(root_url, 'datachanged', '#chronotope-map')]
came_from_url += make_query(**{
UX_IDENT: UX_FRONTEND,
'submitter_came_from': submitter_came_from(self.request),
})
came_from_tile = request.get('came_from_tile')
return [AjaxOverlay(action=came_from_tile, target=came_from_url),
AjaxEvent(root_url, 'datachanged', '#chronotope-map')]
def fillchildren(self, model, path, tree):
"""XXX: consider cone.app.interfaces.INavigationLeaf
"""
curpath = None
if path:
curpath = path[0]
default_child = None
if model.properties.default_child:
if not curpath or curpath == model.properties.default_child:
default_child = model[model.properties.default_child]
if default_child and default_child.properties.hide_if_default:
model = default_child
default_child = None
if path:
path = path[1:]
if path:
curpath = path[0]
if default_child:
if not curpath:
curpath = model.properties.default_child
for key in model:
node = model[key]
if not has_permission("view", node, self.request):
continue
if not node.properties.get("in_navtree"):
continue
title = node.metadata.title
if title:
title = safe_decode(title)
url = make_url(self.request, node=node)
query = make_query(contenttile=node.properties.default_content_tile)
target = make_url(self.request, node=node, query=query)
curnode = curpath == key and True or False
icon = node_icon(self.request, node)
css = ""
if IWorkflowState.providedBy(node):
css = "state-%s" % node.state
child = self.navtreeitem(title, url, target, nodepath(node), icon, css)
child["showchildren"] = curnode
if curnode:
child["selected"] = True
if default_child:
self.fillchildren(default_child, path[1:], child)
else:
self.fillchildren(node, path[1:], child)
else:
selected_path = nodepath(self.model)
if default_child:
selected_path.append(default_child.name)
selected = False
if selected_path == nodepath(node):
selected = True
child["selected"] = selected
tree["children"].append(child)
def make_query(self, params):
"""Create query considering ``query_whitelist``.
:param params: Dictionary with query parameters.
:return: Query as string.
"""
p = dict()
for param in self.query_whitelist:
p[param] = self.request.params.get(param, '')
p.update(params)
return make_query(**p)
def make_query(self, params):
"""Create query considering ``query_whitelist``.
:param params: Dictionary with query parameters.
:return: Query as string.
"""
p = dict()
for param in self.query_whitelist:
p[param] = self.request.params.get(param, '')
p.update(params)
return make_query(**p)
def contents(self):
url = submitter_came_from(self.request)
if not url:
query = make_query(**{UX_IDENT: UX_FRONTEND})
url = make_url(self.request, node=self.model.root, query=query)
return {
'btn': 'default',
'target': url,
'overlay': 'submitter_contents',
'icon': 'glyphicon glyphicon-th-list',
'title': _('my_items', default=u'My Items'),
}
def next(self, request):
next_resource = self.request.environ.get('next_resource')
if next_resource:
query = make_query(pid=next_resource)
url = make_url(request.request, node=self.model.parent, query=query)
else:
url = make_url(request.request, node=self.model.parent)
if self.ajax_request:
return [
AjaxAction(url, 'leftcolumn', 'replace', '.left_column'),
AjaxAction(url, 'rightcolumn', 'replace', '.right_column'),
]
return HTTPFound(location=url)
def next(self, request):
next_resource = self.request.environ.get('next_resource')
if next_resource:
query = make_query(pid=next_resource)
url = make_url(request.request, node=self.model.parent, query=query)
else:
url = make_url(request.request, node=self.model.parent)
if self.ajax_request:
return [
AjaxAction(url, 'leftcolumn', 'replace', '.left_column'),
AjaxAction(url, 'rightcolumn', 'replace', '.right_column'),
]
return HTTPFound(location=url)
def __get__(self, obj, objtype=None):
if obj is None:
return self
appuser = obj.model
user = appuser.model
related_ids = user.membership.keys()
# always True if we list members only, otherwise will be set
# in the loop below
related = self.related_only
if self.related_only:
groups = user.membership
else:
groups = obj.model.root['groups'].ldap_groups
ret = list()
col_1_attr = obj.group_attrs
# XXX: These should be the mapped attributes - lack of backend support
for id in groups.keys():
group = groups[id]
# XXX: resource was only set for alluserlisting
item_target = make_url(obj.request, node=group, resource=id)
action_query = make_query(id=id)
action_target = make_url(obj.request,
node=appuser,
query=action_query)
if not self.related_only:
related = id in related_ids
action_id = 'add_item'
action_enabled = not bool(related)
action_title = 'Add user to selected group'
add_item_action = obj.create_action(action_id, action_enabled,
action_title, action_target)
action_id = 'remove_item'
action_enabled = bool(related)
action_title = 'Remove user from selected group'
remove_item_action = obj.create_action(action_id, action_enabled,
action_title, action_target)
actions = [add_item_action, remove_item_action]
val_1 = group.attrs[col_1_attr]
content = obj.item_content(val_1)
item = obj.create_item(val_1, item_target, content, False, actions)
ret.append(item)
return ret
def __get__(self, obj, objtype=None):
if obj is None:
return self
appuser = obj.model
user = appuser.model
related_ids = user.membership.keys()
# always True if we list members only, otherwise will be set
# in the loop below
related = self.related_only
if self.related_only:
groups = user.membership
else:
groups = obj.model.root['groups'].ldap_groups
ret = list()
col_1_attr = obj.group_attrs
# XXX: These should be the mapped attributes - lack of backend support
for id in groups.keys():
group = groups[id]
# XXX: resource was only set for alluserlisting
item_target = make_url(obj.request, node=group, resource=id)
action_query = make_query(id=id)
action_target = make_url(obj.request,
node=appuser,
query=action_query)
if not self.related_only:
related = id in related_ids
action_id = 'add_item'
action_enabled = not bool(related)
action_title = 'Add user to selected group'
add_item_action = obj.create_action(
action_id, action_enabled, action_title, action_target)
action_id = 'remove_item'
action_enabled = bool(related)
action_title = 'Remove user from selected group'
remove_item_action = obj.create_action(
action_id, action_enabled, action_title, action_target)
actions = [add_item_action, remove_item_action]
val_1 = group.attrs[col_1_attr]
content = obj.item_content(val_1)
item = obj.create_item(val_1, item_target, content, False, actions)
ret.append(item)
return ret
def test_make_query(self):
self.assertEqual(make_query(foo=None), None)
self.assertEqual(make_query(foo=[]), None)
self.assertEqual(make_query(foo='123'), '?foo=123')
self.assertEqual(make_query(foo=['456', '789']), '?foo=456&foo=789')
self.assertEqual(make_query(foo=1), '?foo=1')
self.assertEqual(make_query(foo=1.), '?foo=1.0')
self.assertEqual(make_query(foo='foo', bar='bar'), '?bar=bar&foo=foo')
self.assertEqual(
make_query(
quote_params=('foo',),
foo='http://example.com?param=value'
),
'?foo=http%3A//example.com%3Fparam%3Dvalue'
)
self.assertEqual(
make_query(came_from='http://example.com?param=value'),
'?came_from=http%3A//example.com%3Fparam%3Dvalue'
)
def vocab(self):
ret = list()
path = node_path(self.model)
current = self.request.params.get('b_page', '0')
for i in range(10):
query = make_query(b_page=str(i))
url = make_url(self.request, path=path, query=query)
ret.append({
'page': '%i' % i,
'current': current == str(i),
'visible': True,
'url': url
})
return ret
def vocab(self):
ret = list()
path = node_path(self.model)
current = self.request.params.get('b_page', '0')
for i in range(10):
query = make_query(b_page=str(i))
url = make_url(self.request, path=path, query=query)
ret.append({
'page': '%i' % i,
'current': current == str(i),
'visible': True,
'url': url
})
return ret
def vocab(self):
ret = list()
path = nodepath(self.model)
count = len(self.model.keys())
pages = count / self.contents.slicesize
if count % self.contents.slicesize != 0:
pages += 1
current = self.request.params.get("b_page", "0")
sort = self.request.params.get("sort", "")
for i in range(pages):
query = make_query(b_page=str(i), sort=sort)
url = make_url(self.request, path=path, query=query)
ret.append({"page": "%i" % (i + 1), "current": current == str(i), "visible": True, "url": url})
return ret
def make_item(self, info_name, info):
model = self.model
request = self.request
props = Properties()
query = make_query(factory=info_name)
url = make_url(request, node=model, resource='add', query=query)
props.url = url
target = make_url(request, node=model, query=query)
props.target = target
props.title = info.title
icon = info.icon
if not icon:
icon = app_config().default_node_icon
props.icon = icon
return props
def make_item(self, info_name, info):
model = self.model
request = self.request
props = Properties()
query = make_query(factory=info_name)
url = make_url(request, node=model, resource='add', query=query)
props.url = url
target = make_url(request, node=model, query=query)
props.target = target
props.title = info.title
icon = info.icon
if not icon:
icon = app_config().default_node_icon
props.icon = icon
return props
def create_item(self, node, props, empty_title, selected):
md = node.metadata
item = dict()
item['id'] = node.name
if empty_title:
item['title'] = ''
item['description'] = md.title
else:
item['title'] = md.title
item['description'] = md.description
item['url'] = make_url(self.request, node=node)
query = make_query(contenttile=props.default_content_tile)
item['target'] = make_url(self.request, node=node, query=query)
item['selected'] = selected
item['icon'] = node_icon(node)
return item
def create_item(self, node, props, empty_title, selected):
md = node.metadata
item = dict()
item["id"] = node.name
if empty_title:
item["title"] = ""
item["description"] = md.title
else:
item["title"] = md.title
item["description"] = md.description
item["url"] = make_url(self.request, node=node)
query = make_query(contenttile=props.default_content_tile)
item["target"] = make_url(self.request, node=node, query=query)
item["selected"] = selected
item["icon"] = node_icon(self.request, node)
return item
def create_item(self, node, props, empty_title, selected):
md = node.metadata
item = dict()
item['id'] = node.name
if empty_title:
item['title'] = ''
item['description'] = md.title
else:
item['title'] = md.title
item['description'] = md.description
item['url'] = make_url(self.request, node=node)
query = make_query(contenttile=props.default_content_tile)
item['target'] = make_url(self.request, node=node, query=query)
item['selected'] = selected
item['icon'] = node_icon(self.request, node)
return item
def extract_locations(request, record, result):
cls = record.__class__
if cls is LocationRecord:
# check ignoring not authenticated
authenticated = bool(authenticated_userid(request))
if not authenticated and record.state != 'published':
submitter = get_submitter(request)
# no submitter, ignore
if not submitter:
return
# wrong submitter, ignore
if record.submitter != submitter:
return
# wrong state, ignore
if record.state != 'draft':
return
uid = str(record.uid)
query = make_query(**{UX_IDENT: UX_FRONTEND})
target = make_url(
request,
path=[value_containers[cls], uid],
query=query,
)
result[uid] = {
'value': value_extractors[cls](record),
'action': value_actions[cls],
'target': target,
'lat': record.lat,
'lon': record.lon,
'state': record.state,
}
elif cls is FacilityRecord:
for location in record.location:
extract_locations(request, location, result)
elif cls is OccasionRecord:
for location in record.location:
extract_locations(request, location, result)
for facility in record.facility:
extract_locations(request, facility, result)
elif cls is AttachmentRecord:
for location in record.location:
extract_locations(request, location, result)
for facility in record.facility:
extract_locations(request, facility, result)
for occasion in record.occasion:
extract_locations(request, occasion, result)
def search(self, request, query):
result = list()
for record in fulltext_search(request, query, SEARCH_LIMIT):
cls = record.__class__
uid = str(record.uid)
query = make_query(**{UX_IDENT: UX_FRONTEND})
target = make_url(request,
path=[value_containers[cls], uid],
query=query)
suggestion = {
'uid': uid,
'value': value_extractors[cls](record),
'action': value_actions[cls],
'target': target,
'icon': value_icons[cls],
}
result.append(suggestion)
return result
def vocab(self):
ret = list()
path = nodepath(self.model)
count = len(self.items)
pages = count / self.slicesize
if count % self.slicesize != 0:
pages += 1
current = self.request.params.get('b_page', '0')
for i in range(pages):
query = make_query(b_page=str(i))
url = make_url(self.request, path=path, query=query)
ret.append({
'page': '%i' % (i + 1),
'current': current == str(i),
'visible': True,
'url': url,
})
return ret
def edit(self):
if not self.can_edit:
return None
params = {
UX_IDENT: UX_FRONTEND,
'authoring_came_from': self.authoring_came_from,
'submitter_came_from': submitter_came_from(self.request),
}
params.update(self.additional_editing_params)
query = make_query(**params)
url = make_url(self.request, node=self.model, query=query)
return {
'btn': 'default',
'target': url,
'overlay': 'overlayedit',
'icon': 'glyphicon glyphicon-pencil',
'title': _('edit', default=u'Edit'),
}
def vocab(self):
ret = list()
path = nodepath(self.model)
count = len(self.items)
pages = count / self.slicesize
if count % self.slicesize != 0:
pages += 1
current = self.request.params.get('b_page', '0')
for i in range(pages):
query = make_query(b_page=str(i))
url = make_url(self.request, path=path, query=query)
ret.append({
'page': '%i' % (i + 1),
'current': current == str(i),
'visible': True,
'url': url,
})
return ret
def vocab(self):
ret = list()
path = node_path(self.model)
current = self.request.params.get('b_page', '0')
for i in range(10):
query = make_query(b_page=str(i))
href = make_url(self.request,
path=path,
resource='someview',
query=query)
target = make_url(self.request, path=path, query=query)
ret.append({
'page': '%i' % i,
'current': current == str(i),
'visible': True,
'href': href,
'target': target,
})
return ret
def items(self):
ret = list()
addables = self.model.nodeinfo.addables
if not addables:
return ret
for addable in addables:
info = getNodeInfo(addable)
if not info:
continue
query = make_query(factory=addable)
url = make_url(self.request, node=self.model,
resource='add', query=query)
target = make_url(self.request, node=self.model, query=query)
props = Properties()
props.url = url
props.target = target
props.title = info.title
props.icon = info.icon
ret.append(props)
return ret
def transitions(self):
self.do_transition()
ret = list()
try:
workflow = self.workflow
transitions = workflow.get_transitions(
self.model, self.request, from_state=self.model.state)
except (WorkflowError, AttributeError) as e:
logger.error("transitions error: %s" % str(e))
return ret
workflow_tsf = self.model.workflow_tsf
for transition in transitions:
query = make_query(do_transition=transition['name'])
target = make_url(self.request, node=self.model, query=query)
props = Properties()
props.target = target
if workflow_tsf:
props.title = workflow_tsf(transition['name'])
else:
props.title = transition['name']
ret.append(props)
return ret
def render(self):
cut = extract_copysupport_cookie(self.request, 'cut')
copy = extract_copysupport_cookie(self.request, 'copy')
localizer = get_localizer(self.request)
if not cut and not copy:
message = localizer.translate(
_('nothing_to_paste', default='Nothing to paste'))
ajax_message(self.request, message)
return u''
urls = copy and copy or cut
paths = paths_from_urls(urls)
call_sources = set()
errors = list()
success = 0
for path in paths:
node = self.model.root
for key in path:
node = node[key]
if not node.node_info_name:
message = localizer.translate(_(
'cannot_paste_unknown_source',
default="Cannot paste '${name}'. Unknown source"),
mapping={'name': node.name})
errors.append(message)
continue
if not self.model.node_info_name:
message = localizer.translate(
_('cannot_paste_unknown_target',
default="Cannot paste to '${name}'. Unknown target"),
mapping={'name': self.model.name})
errors.append(message)
continue
if node.node_info_name not in self.model.nodeinfo.addables:
message = localizer.translate(
_('cannot_paste_cardinality_violation',
default=("Violation. '${target}' is not allowed to "
"contain '${source}'")),
mapping={
'target': self.model.nodeinfo.title,
'source': node.nodeinfo.title
})
errors.append(message)
continue
source = node.parent
if copy:
node = source[node.name].deepcopy()
else:
in_model = False
for parent in LocationIterator(self.model):
if parent is node:
message = localizer.translate(
_('cannot_paste_self_containment',
default=("Cannot paste cut object to child "
"of it: ${name}")),
mapping={'name': parent.name})
errors.append(message)
in_model = True
break
if in_model:
continue
node = source.detach(node.name)
node.__parent__ = self.model
self.model[choose_name(self.model, node.name)] = node
if cut:
call_sources.add(source)
success += 1
if success > 0:
self.model()
for source in call_sources:
source()
message = localizer.translate(_('pasted_items',
default="Pasted ${count} items"),
mapping={'count': success})
if errors:
failed = localizer.translate(_(
'pasting_items_failed',
default="Pasting of ${count} items failed"),
mapping={'count': len(errors)})
failed = "<br /><strong>%s</strong>" % failed
message += "<br />".join([failed] + errors)
ajax_message(self.request, message)
content_tile = self.model.properties.action_paste_tile
if not content_tile:
content_tile = 'listing'
query = make_query(contenttile=content_tile)
url = make_url(self.request, node=self.model, query=query)
event = AjaxEvent(url, 'contextchanged', '#layout')
ajax_continue(self.request, event)
res = self.request.response
res.delete_cookie(cookie_name(copy and 'copy' or 'cut'))
return u''
def listing_items(self):
can_delete = self.request.has_permission(
self.delete_permission,
self.model
)
try:
ret = list()
localmanager_ids = self.localmanager_ids
# if localmanager ids not none but empty, no access to any
# principals
if localmanager_ids is not None and not localmanager_ids:
return ret
attrlist = self.listing_attrs
sort_attr = self.sort_attr
# build criteria from filter term
criteria = None
filter_term = self.filter_term
if filter_term:
criteria = dict()
for attr in attrlist:
criteria[attr] = filter_term
principals = self.model.backend
result = principals.search(
criteria=criteria,
attrlist=attrlist,
or_search=True
)
for key, attrs in result:
# reduce result by localmanager ids if not None
if localmanager_ids is not None and key not in localmanager_ids:
continue
actions = list()
if can_delete:
action_id = 'delete_item'
action_title = self.delete_label
action_target = make_url(
self.request,
node=self.model,
resource=key
)
delete_action = self.create_action(
action_id,
True,
action_title,
action_target
)
actions = [delete_action]
vals = [self.extract_raw(attrs, attr) for attr in attrlist]
sort = self.extract_raw(attrs, sort_attr)
query = make_query(
pid=key,
came_from=make_url(self.request, node=self.model)
)
target = make_url(self.request, node=self.model, query=query)
content = self.item_content(*vals)
current = self.current_id == key
ret.append(self.create_item(
sort,
target,
content,
current,
actions
))
return ret
except Exception:
logger.exception('Failed to query listing items')
return list()
def item_target(self, node):
query = make_query(contenttile=node.properties.default_content_tile)
return make_url(self.request, node=node, query=query)
def filter_target(self):
query = make_query(dict(sort=self.sort_column, order=self.sort_order))
return safe_decode(make_url(self.request, node=self.model, query=query))
class Principals(object):
"""Descriptor to return principal items for listing
"""
def __init__(self, members_only=False):
self.members_only = members_only
def __get__(self, obj, objtype=None):
if obj is None:
return self
appgroup = obj.model
group = appgroup.model
member_ids = group.keys()
# always True if we list members only, otherwise will be set
# in the loop below
related = self.members_only
# XXX: so far only users as members of groups, for
# group-in-group we need to prefix groups
if self.members_only:
users = group
else:
users = obj.model.root['users'].ldap_users
col_1_attr, col_2_attr, col_3_attr, sort_attr = obj.user_attrs
ret = list()
try:
attrlist = [col_1_attr, col_2_attr, col_3_attr]
result = users.search(attrlist=attrlist)
except Exception, e:
print 'Query Failed: ' + str(e)
return []
# XXX: These should be the mapped attributes - lack of backend support
for id, attrs in result:
# XXX: resource was only set for alluserlisting
try:
user = users[id]
except KeyError, e:
# XXX logging
print e
continue
item_target = make_url(obj.request, node=user, resource=id)
action_query = make_query(id=id)
action_target = make_url(obj.request,
node=appgroup,
query=action_query)
if not self.members_only:
related = id in member_ids
action_id = 'add_item'
action_enabled = not bool(related)
action_title = 'Add user to selected group'
add_item_action = obj.create_action(
action_id, action_enabled, action_title, action_target)
action_id = 'remove_item'
action_enabled = bool(related)
action_title = 'Remove user from selected group'
remove_item_action = obj.create_action(
action_id, action_enabled, action_title, action_target)
actions = [add_item_action, remove_item_action]
val_1 = obj.extract_raw(attrs, col_1_attr)
val_2 = obj.extract_raw(attrs, col_2_attr)
val_3 = obj.extract_raw(attrs, col_3_attr)
content = obj.item_content(val_1, val_2, val_3)
sort = obj.extract_raw(attrs, sort_attr)
current = False
item = obj.create_item(sort, item_target, content, current, actions)
ret.append(item)
def listing_items(self):
appuser = self.model
user = appuser.model
groups = user.groups
related_ids = [g.name for g in groups]
# Always True if we list members only, otherwise will be set
# in the loop below
related = self.related_only
if not related:
groups = self.model.root['groups'].backend.values()
# reduce for local manager
if self.model.local_manager_consider_for_user:
local_gids = self.model.local_manager_target_gids
groups = [g for g in groups if g.name in local_gids]
attrlist = self.group_attrs
sort_attr = self.group_default_sort_column
filter_term = self.unquoted_param_value('filter')
can_change = self.request.has_permission(
'manage_membership',
self.model.parent
)
ret = list()
for group in groups:
attrs = group.attrs
# reduce by search term
if filter_term:
s_attrs = [attrs[attr] for attr in attrlist]
if not fnmatch.filter(s_attrs, filter_term):
continue
gid = group.name
item_target = make_url(self.request, path=group.path[1:])
action_query = make_query(id=gid)
action_target = make_url(
self.request,
node=appuser,
query=action_query
)
if not self.related_only:
related = gid in related_ids
actions = list()
if can_change:
action_id = 'add_item'
action_enabled = not bool(related)
action_title = _(
'add_user_to_selected_group',
default='Add user to selected group'
)
add_item_action = self.create_action(
action_id,
action_enabled,
action_title,
action_target
)
actions.append(add_item_action)
action_id = 'remove_item'
action_enabled = bool(related)
action_title = _(
'remove_user_from_selected_group',
default='Remove user from selected group'
)
remove_item_action = self.create_action(
action_id,
action_enabled,
action_title,
action_target
)
actions.append(remove_item_action)
vals = [self.extract_raw(attrs, attr) for attr in attrlist]
sort = self.extract_raw(attrs, sort_attr)
content = self.item_content(*vals)
current = False
item = self.create_item(
sort,
item_target,
content,
current,
actions
)
ret.append(item)
return ret
def target(self):
related_view = get_related_view(self.request)
if related_view and not ILeaf.providedBy(self.model):
query = make_query(contenttile=related_view)
return make_url(self.request, node=self.model, query=query)
return super(ContentsViewLink, self).target
def target(self):
query = make_query(contenttile='edit')
return make_url(self.request, node=self.model, query=query)
def add_target(self):
return make_url(self.request,
node=self.model.root['users'],
query=make_query(factory=u'user'))
def principals_target(self):
query = make_query(pid=self.model.name)
return make_url(self.request, node=self.model.parent, query=query)
def listing_items(self):
appgroup = self.model
group = appgroup.model
member_ids = group.keys()
# Always True if we list members only, otherwise will be set
# in the loop below
related = self.members_only
# XXX: so far only users as members of groups, for
# group-in-group we need to prefix groups
if related:
users = group.users
else:
# XXX: speedup
users = group.root.users.values()
# reduce for local manager
if self.model.local_manager_consider_for_user:
local_uids = self.model.local_manager_target_uids
users = [u for u in users if u.name in local_uids]
attrlist = self.user_attrs
sort_attr = self.user_default_sort_column
filter_term = self.unquoted_param_value('filter')
can_change = self.request.has_permission('manage_membership',
self.model.parent)
ret = list()
for user in users:
attrs = user.attrs
# reduce by search term
if filter_term:
s_attrs = [attrs[attr] for attr in attrlist]
if not fnmatch.filter(s_attrs, filter_term):
continue
uid = user.name
item_target = make_url(self.request, path=user.path[1:])
action_query = make_query(id=uid)
action_target = make_url(self.request,
node=appgroup,
query=action_query)
if not self.members_only:
related = uid in member_ids
actions = list()
if can_change:
action_id = 'add_item'
action_enabled = not bool(related)
action_title = _('add_user_to_selected_group',
default='Add user to selected group')
add_item_action = self.create_action(action_id, action_enabled,
action_title,
action_target)
actions.append(add_item_action)
action_id = 'remove_item'
action_enabled = bool(related)
action_title = _('remove_user_from_selected_group',
default='Remove user from selected group')
remove_item_action = self.create_action(
action_id, action_enabled, action_title, action_target)
actions.append(remove_item_action)
vals = [self.extract_raw(attrs, attr) for attr in attrlist]
sort = self.extract_raw(attrs, sort_attr)
content = self.item_content(*vals)
current = False
item = self.create_item(sort, item_target, content, current,
actions)
ret.append(item)
return ret
