def update(self):
user = get_current()
correlations = [c for c in self.context.source_correlations \
if c.type == 0 and can_access(user, c)]
target_correlations = [c for c in self.context.target_correlations \
if c.type == 0 and can_access(user, c)]
relatedcontents = []
all_messages = {}
isactive = False
all_resources = {}
all_resources['js_links'] = []
all_resources['css_links'] = []
for correlation in correlations:
contents = correlation.targets
for content in contents:
correlation_data, resources, \
messages, action_updated = self._correlation_action(correlation)
correlation_data.update({'content': content,
'url': content.url(self.request),
'correlation': correlation})
relatedcontents.append(correlation_data)
isactive = action_updated or isactive
self._update_data(messages, resources,
all_messages, all_resources)
for correlation in target_correlations:
content = correlation.source
correlation_data, resources, \
messages, action_updated = self._correlation_action(correlation)
correlation_data.update({'content': content,
'url': content.url(self.request),
'correlation': correlation})
relatedcontents.append(correlation_data)
isactive = action_updated or isactive
self._update_data(messages, resources, all_messages, all_resources)
len_contents = len(relatedcontents)
index = str(len_contents)
if len_contents > 1:
index = '*'
message = (_(ASSOCIATION_MESSAGES[index]),
len_contents,
index)
self.message = message
result = {}
values = {
'relatedcontents': relatedcontents,
'current_user': user,
'message': message
}
body = self.content(result=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates:[item]}
item['messages'] = all_messages
item['isactive'] = isactive
result.update(all_resources)
result = merge_dicts(self.requirements_copy, result)
return result
def comm_processsecurity_validation(process, context):
if not global_user_processsecurity():
return False
source = context.source
targets = context.targets
user = get_current()
return can_access(user, source) and \
not any(not can_access(user, target) for target in targets)
def comm_processsecurity_validation(process, context):
if not global_user_processsecurity(process, context):
return False
source = context.source
targets = context.targets
user = get_current()
return can_access(user, source) and \
not any(not can_access(user, target) for target in targets)
def get_folder_content(folder, user,
add_query=None,
**args):
_filters = deepcopy(getattr(folder, 'filters', []))
objects = []
if _filters:
query = None
if add_query:
query = QUERY_OPERATORS['and'](query, add_query)
objects = find_entities(
user=user,
add_query=query,
filters=_filters,
filter_op='or',
**args)
oids = [get_oid(c) for c in folder.contents if can_access(user, c)]
if args:
contents = find_entities(
user=user,
intersect=oids,
**args)
oids = contents.ids if not isinstance(contents, list) else contents
if isinstance(objects, list):
objectmap = find_objectmap(folder)
objects = ResultSet(oids, len(oids), objectmap.object_for)
else: # ResultSet
objects.ids = list(objects.ids)
objects.ids.extend(oids)
objects.numids += len(oids)
return objects
def update(self):
user = get_current()
related_ideas = [i for i in self.context.related_ideas.keys() \
if can_access(user, i)]
result = {}
target = None
try:
editform = self.parent.parent.validated_children[0]
target = editform.viewid+'_'+editform.formid
except Exception:
pass
ideas = []
for i in related_ideas:
data = {'title': i.title,
'id': get_oid(i),
'body': renderers.render(self.idea_template,
{'idea':i}, self.request)
}
ideas.append(data)
values = {
'items': ideas,
'target' : target
}
body = self.content(result=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates:[item]}
return result
def update(self):
self.execute(None)
user = get_current()
objects = [obj for obj
in self.context.get_sub_nodes()
if can_access(user, obj)]
objects = sorted(
objects,
key=lambda e: getattr(e, 'modified_at'),
reverse=True)
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects, self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_node_dependencies_" + str(self.context.__oid__)
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(WG_MESSAGES[index], mapping={'number': len_result})
result = {}
result_body = render_small_listing_objs(
self.request, batch, user)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': _("No association"),
'empty_icon': 'glyphicon glyphicon-link'
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
user = get_current()
related_ideas = [i for i in self.context.related_ideas
if can_access(user, i)]
result = {}
target = None
try:
editform = self.parent.parent.validated_children[0]
target = editform.viewid+'_'+editform.formid
except Exception:
pass
ideas = []
for i in related_ideas:
data = {'title': i.title,
'id': get_oid(i),
'body': renderers.render(self.idea_template,
{'idea': i}, self.request)
}
ideas.append(data)
values = {
'items': ideas,
'target': target
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
user = get_current()
objects = [o for o in getattr( self.context, 'amendments', []) \
if not('archived' in o.state) and can_access(user, o)]
objects = sorted(objects,
key=lambda e: getattr(e, 'modified_at',
datetime.datetime.today()),
reverse=True)
lenamendments = len(objects)
index = str(lenamendments)
if lenamendments > 1:
index = '*'
message = (_(AMENDMENTS_MESSAGES[index]),
lenamendments,
index)
result = {}
values = {'amendments': objects,
'current_user': user,
'message': message,
'get_states_mapping': get_states_mapping
}
self.message = message
body = self.content(result=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
comment_id = self.params('comment_id')
user = get_current()
comment = None
try:
obj = get_obj(int(comment_id)) if comment_id else None
if isinstance(obj, Comment) and can_access(user, obj):
comment = obj
except Exception as error:
log.warning(error)
comment_body = ''
if comment:
comment_body = render_listing_obj(
self.request, comment, user)
values = {
'comment_body': comment_body
}
result = {}
body = self.content(
args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
result = merge_dicts(self.requirements_copy, result)
return result
def update(self):
self.execute(None)
try:
navbars = generate_navbars(self.request, self.context)
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
user = get_current()
subfolders = [sf for sf in self.context.children
if can_access(user, sf)]
subfolders = sorted(subfolders, key=lambda e: e.get_order())
result_body, result = render_listing_objs(
self.request, subfolders, user)
values = {'object': self.context,
'subfolders': result_body,
'navbar_body': navbars['navbar_body'],
'body_actions': navbars['body_actions']
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['messages'] = navbars['messages']
item['isactive'] = navbars['isactive']
result.update(navbars['resources'])
result['coordinates'] = {self.coordinates: [item]}
return result
def get_folder_children(self, node):
user = get_current(self.request)
locale = self.request.locale_name
children = node.children if node is not self.default_folder\
else self.default_folder.volatile_children
nodes = [sf for sf in children if can_access(user, sf)
and (not sf.locale or sf.locale == locale)]
nodes = sorted(nodes, key=lambda e: e.get_order())
return nodes
def update(self):
self.execute(None)
user = self.context
current_user = get_current()
def actions_getter():
return [a for a in self.context.actions \
if getattr(a.action, 'style', '') == 'button']
actions_navbar = get_actions_navbar(actions_getter, self.request,
['global-action', 'text-action'])
isactive = actions_navbar['modal-action']['isactive']
messages = actions_navbar['modal-action']['messages']
resources = actions_navbar['modal-action']['resources']
objects = []
if current_user is user:
objects = [o for o in getattr(user, 'contents', []) \
if not('archived' in o.state)]
else:
objects = [o for o in getattr(user, 'contents', []) \
if not('archived' in o.state) and\
can_access(current_user, o)]
batch = Batch(objects, self.request, default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_contents"
len_result = batch.seqlen
result_body = []
result = {}
for obj in batch:
object_values = {'object': obj,
'current_user': current_user,
'state': get_states_mapping(current_user, obj,
getattr(obj, 'state', [None])[0])
}
body = self.content(result=object_values,
template=obj.result_template)['body']
result_body.append(body)
values = {'bodies': result_body,
'length': len_result,
'batch': batch
}
contents_body = self.content(result=values,
template=SearchResultView.template)['body']
values = {'contents': (result_body and contents_body) or None,
'proposals': None,
'user': self.context,
'state': get_states_mapping(current_user, user,
getattr(user, 'state', [None])[0]),
'navbar_body': navbar_body_getter(self, actions_navbar)}
body = self.content(result=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['messages'] = messages
item['isactive'] = isactive
result.update(resources)
result['coordinates'] = {self.coordinates: [item]}
return result
def get_folder_children(self, node):
user = get_current(self.request)
locale = self.request.locale_name
children = node.children if node is not self.default_folder\
else self.default_folder.volatile_children
nodes = [
sf for sf in children
if can_access(user, sf) and (not sf.locale or sf.locale == locale)
]
nodes = sorted(nodes, key=lambda e: e.get_order())
return nodes
def update(self):
body = ''
result = {}
if self.isactive or self.params('on_demand') == 'load':
user = self.context
current_user = get_current()
objects = []
if current_user is user:
objects = list(
filter(lambda o: 'archived' not in o.state,
getattr(user, self.content_attr, [])))
else:
objects = list(
filter(
lambda o: can_access(current_user, o) and 'archived'
not in o.state, getattr(user, self.content_attr, [])))
sort_url = self.request.resource_url(
self.context,
'@@index',
query={'view_content_id': self.content_id})
objects, sort_body = sort_view_objects(self,
objects,
[self.content_type],
user,
sort_url=sort_url)
url = self.request.resource_url(
self.context,
'@@index',
query={'view_content_id': self.content_id})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results-" + self.content_id
self.title = _(self.title, mapping={'nb': batch.seqlen})
result_body, result = render_listing_objs(
self.request,
batch,
current_user,
display_state=getattr(self, 'display_state', True))
values = {
'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'sort_body': sort_body
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = getattr(self, 'isactive', False)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
user = get_current()
objects = [proposal for proposal
in self.context.related_proposals
if proposal.working_group and
'archived' not in proposal.state and
'censored' not in proposal.state and
can_access(user, proposal)]
objects = sorted(
objects,
key=lambda e: getattr(e, 'modified_at'),
reverse=True)
is_small = True
current_is_small = self.params('is_small')
if current_is_small is not None:
current_is_small = current_is_small.lower()
is_small = current_is_small == 'true'
elif self.parent or self.request.view_name == self.name:
is_small = False
url = self.request.resource_url(
self.context, self.name, query={'is_small': str(is_small)})
batch = Batch(objects, self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_idea_working_groups" + \
str(self.context.__oid__) + \
(is_small and 'is_small' or '')
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(WG_MESSAGES[index], mapping={'number': len_result})
result = {}
if is_small:
result_body = render_small_listing_objs(
self.request, batch, user)
else:
result_body, result = render_listing_objs(
self.request, batch, user)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': _("No working group created"),
'empty_icon': 'novaideo-icon icon-wg'
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
user = get_current()
objects = [
proposal for proposal in self.context.related_proposals
if proposal.working_group and 'archived' not in proposal.state and
'censored' not in proposal.state and can_access(user, proposal)
]
objects = sorted(objects,
key=lambda e: getattr(e, 'modified_at'),
reverse=True)
is_small = True
current_is_small = self.params('is_small')
if current_is_small is not None:
current_is_small = current_is_small.lower()
is_small = current_is_small == 'true'
elif self.parent or self.request.view_name == self.name:
is_small = False
url = self.request.resource_url(self.context,
self.name,
query={'is_small': str(is_small)})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_idea_working_groups" + \
str(self.context.__oid__) + \
(is_small and 'is_small' or '')
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(WG_MESSAGES[index], mapping={'number': len_result})
result = {}
if is_small:
result_body = render_small_listing_objs(self.request, batch, user)
else:
result_body, result = render_listing_objs(self.request, batch,
user)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': _("No working group created"),
'empty_icon': 'novaideo-icon icon-wg'
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def targets_choice(node, kw):
context = node.bindings['context']
request = node.bindings['request']
root = getSite()
user = get_current()
values = []
entities = find_entities([ICorrelableEntity],
states=('archived',), not_any=True)
values = [(i, i.title) for i in entities \
if can_access(user, i, request, root)] #i.actions
values.remove((context, context.title))
values = sorted(values, key=lambda p: p[1])
return Select2Widget(values=values, multiple=True, min_len=1)
def update(self):
self.execute(None)
user = get_current()
objects = [
event for event in self.context.events
if 'published' in event.state and can_access(user, event)
]
objects = sorted(objects,
key=lambda e: getattr(e, 'modified_at'),
reverse=True)
is_small = True
current_is_small = self.params('is_small')
if current_is_small is not None:
current_is_small = current_is_small.lower()
is_small = current_is_small == 'true'
elif self.parent or self.request.view_name == self.name:
is_small = False
url = self.request.resource_url(self.context,
self.name,
query={'is_small': str(is_small)})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_eventobject_events" + \
str(self.context.__oid__) + \
(is_small and 'is_small' or '')
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(EVENTS_MESSAGES[index], mapping={'number': len_result})
result = {}
if is_small:
result_body = render_small_listing_objs(self.request, batch, user)
else:
result_body, result = render_listing_objs(self.request, batch,
user)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': _("No organized event"),
'empty_icon': 'glyphicon glyphicon-calendar'
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
user = get_current()
objects = [content for content in
self.context.related_ideas
if can_access(user, content)]
objects = sorted(
objects,
key=lambda e: getattr(e, 'modified_at'),
reverse=True)
is_small = True
current_is_small = self.params('is_small')
if current_is_small is not None:
current_is_small = current_is_small.lower()
is_small = current_is_small == 'true'
elif self.parent or self.request.view_name == self.name:
is_small = False
url = self.request.resource_url(
self.context, self.name, query={'is_small': str(is_small)})
batch = Batch(objects, self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_related_ideas" + \
str(self.context.__oid__) + \
(is_small and 'is_small' or '')
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
result = {}
if is_small:
result_body = render_small_listing_objs(
self.request, batch, user)
else:
result_body, result = render_listing_objs(
self.request, batch, user)
self.title = _(ADDIDEAS_MESSAGES[index],
mapping={'number': len_result})
values = {
'bodies': result_body,
'batch': batch
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
user = get_current()
correlations = [(content, c) for content, c in
self.context.all_related_contents
if c.type == 0 and can_access(user, content)]
relatedcontents = []
all_messages = {}
isactive = False
all_resources = {}
all_resources['js_links'] = []
all_resources['css_links'] = []
for content, correlation in correlations:
correlation_data, resources, \
messages, action_updated = self._correlation_action(correlation)
correlation_data.update({'content': content,
'url': content.url,
'correlation': correlation})
relatedcontents.append(correlation_data)
isactive = action_updated or isactive
self._update_data(messages, resources, all_messages, all_resources)
len_contents = len(relatedcontents)
index = str(len_contents)
if len_contents > 1:
index = '*'
message = (_(ASSOCIATION_MESSAGES[index]),
len_contents,
index)
self.message = message
result = {}
values = {
'relatedcontents': relatedcontents,
'current_user': user,
'message': message
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
item['messages'] = all_messages
item['isactive'] = isactive
result.update(all_resources)
result = merge_dicts(self.requirements_copy, result)
return result
def search(text, content_types, user):
if text:
text = [t.lower() for t in re.split(', *', text)]
interfaces = [SEARCHABLE_CONTENT[i].__identifier__ for i in content_types]
#catalog
dace_catalog = find_catalog('dace')
novaideo_catalog = find_catalog('novaideo')
system_catalog = find_catalog('system')
#index
title_index = dace_catalog['object_title']
description_index = dace_catalog['object_description']
states_index = dace_catalog['object_states']
object_provides_index = dace_catalog['object_provides']
keywords_index = novaideo_catalog['object_keywords']
text_index = system_catalog['text']
name_index = system_catalog['name']
#query
query = None
if text:
query = keywords_index.any(text) | \
name_index.any(text) | \
states_index.any(text)
for keyword in text:
query = query | \
title_index.contains(keyword) | \
description_index.contains(keyword) | \
text_index.contains(keyword)
if query is None:
query = object_provides_index.any(interfaces)
else:
query = (query) & object_provides_index.any(interfaces)
query = (query) & states_index.notany(('archived',))
resultset = query.execute()
objects = [o for o in resultset.all() if can_access(user, o)]
objects = sorted(objects,
key=lambda e: getattr(e, 'modified_at',
datetime.datetime.today()),
reverse=True)
return objects
def update(self):
body = ''
result = {}
if self.isactive or self.params('on_demand') == 'load':
user = self.context
current_user = get_current()
objects = []
if current_user is user:
objects = list(filter(lambda o: 'archived' not in o.state,
getattr(user, self.content_attr, [])))
else:
objects = list(filter(lambda o: can_access(current_user, o) and
'archived' not in o.state,
getattr(user, self.content_attr, [])))
sort_url = self.request.resource_url(
self.context, '@@index',
query={'view_content_id': self.content_id})
objects, sort_body = sort_view_objects(
self, objects, [self.content_type], user,
sort_url=sort_url)
url = self.request.resource_url(
self.context, '@@index',
query={'view_content_id': self.content_id})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results-" + self.content_id
self.title = _(self.title, mapping={'nb': batch.seqlen})
result_body, result = render_listing_objs(
self.request, batch, current_user,
display_state=getattr(self, 'display_state', True))
values = {'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'sort_body': sort_body}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = getattr(self, 'isactive', False)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
user = get_current()
objects = [member for member
in self.context.invited_users
if can_access(user, member)]
objects = sorted(
objects,
key=lambda e: getattr(e, 'modified_at'),
reverse=True)
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects, self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_challenge_members"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(WG_MESSAGES[index], mapping={'number': len_result})
result = {}
# if included in another view
if self.parent or self.request.view_name == self.name:
result_body, result = render_listing_objs(
self.request, batch, user)
else:
result_body = render_small_listing_objs(
self.request, batch, user)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': _("No participant"),
'empty_icon': 'ion-person-stalker'
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def get_entity_popover(self):
oid_str = self.params('oid')
from novaideo.utilities.util import (
generate_listing_menu, DEFAUL_LISTING_FOOTER_ACTIONS_TEMPLATE,
ObjectRemovedException)
if oid_str:
try:
obj = get_obj(int(oid_str))
user = get_current()
if obj and can_access(user, obj):
try:
navbars = generate_listing_menu(
self.request,
obj,
descriminators=[
'communication-action', 'access-action'
],
footer_template=
DEFAUL_LISTING_FOOTER_ACTIONS_TEMPLATE,
view_type='popover')
except ObjectRemovedException:
return {'body': ''}
user = get_current()
render_dict = {
'object': obj,
'oid': oid_str,
'current_user': user,
'footer_body': navbars['footer_body'],
'access_body': navbars['access_body'],
}
body = self.content(
args=render_dict,
template=obj.templates.get('popover'))['body']
return {'body': body}
except:
pass
return {'body': ''}
def update(self):
self.execute(None)
user = get_current()
objects = [
obj for obj in self.context.get_sub_nodes()
if can_access(user, obj)
]
objects = sorted(objects,
key=lambda e: getattr(e, 'modified_at'),
reverse=True)
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_node_dependencies_" + str(
self.context.__oid__)
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(WG_MESSAGES[index], mapping={'number': len_result})
result = {}
result_body = render_small_listing_objs(self.request, batch, user)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': _("No association"),
'empty_icon': 'glyphicon glyphicon-link'
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
return result
def get_entity_popover(self):
oid_str = self.params('oid')
from novaideo.utilities.util import (
generate_listing_menu,
DEFAUL_LISTING_FOOTER_ACTIONS_TEMPLATE,
ObjectRemovedException)
if oid_str:
try:
obj = get_obj(int(oid_str))
user = get_current()
if obj and can_access(user, obj):
try:
navbars = generate_listing_menu(
self.request, obj,
descriminators=['communication-action', 'access-action'],
footer_template=DEFAUL_LISTING_FOOTER_ACTIONS_TEMPLATE,
view_type='popover')
except ObjectRemovedException:
return {'body': ''}
user = get_current()
render_dict = {
'object': obj,
'oid': oid_str,
'current_user': user,
'footer_body': navbars['footer_body'],
'access_body': navbars['access_body'],
}
body = self.content(
args=render_dict,
template=obj.templates.get('popover'))['body']
return {'body': body}
except:
pass
return {'body': ''}
def ideas_choice(node, kw):
root = getSite()
user = get_current()
values = [(i, i.title) for i in root.ideas \
if can_access(user, i) and not('archived' in i.state)]
return Select2Widget(values=values, multiple=True)
def get_related_contents(self, user):
return [r for r in self.related_contents if can_access(user, r)]
def see_processsecurity_validation(process, context):
source = context.source
targets = context.targets
user = get_current()
return can_access(user, source) and \
not any(not can_access(user, target) for target in targets)
def get_related_contents(self, user):
return [r for r in self.related_contents if can_access(user, r)]
def see_processsecurity_validation(process, context):
source = context.source
targets = context.targets
user = get_current()
return can_access(user, source) and \
not any(not can_access(user, target) for target in targets)
def bind(self):
user = get_current()
folders = [sf for sf in self.context.children
if can_access(user, sf)]
folders = sorted(folders, key=lambda e: e.get_order())
return {'folders': folders}
def update(self):
result = {}
user = get_current()
folderid = self.params('folderid')
try:
folder = get_obj(int(folderid))
except:
folder = None
# if not valid folderid
if folderid is None or folder is None:
error = ViewError()
error.principalmessage = _("Access to the requested folder has been denied")
error.causes = [_("Folder not valid")]
message = error.render_message(self.request)
item = self.adapt_item('', self.viewid)
item['messages'] = {error.type: [message]}
result['coordinates'] = {self.coordinates: [item]}
return result
# if permission denied
if folder and not can_access(user, folder):
error = ViewError()
error.principalmessage = _("Access to the requested folder has been denied")
error.causes = [_("Permission denied")]
message = error.render_message(self.request)
item = self.adapt_item('', self.viewid)
item['messages'] = {error.type: [message]}
result['coordinates'] = {self.coordinates: [item]}
return result
# calling self._add_filter will set self.filter_instance or not
template_type = getattr(folder, 'view_type', 'default')
if template_type == 'bloc':
self.wrapper_template = 'novaideo:views/smart_folder_management/templates/folder_blocs_view_wrapper.pt'
filter_body = None
filter_form, filter_data = self._add_filter(folder, user)
args = merge_with_filter_view(self, {})
objects = get_folder_content(folder, user, **args)
objects, sort_body = sort_view_objects(
self, objects,
['proposal', 'idea', 'amendment',
'file', 'person'], user)
len_result = len(objects)
self.breadcrumb = self.content(
args={'number': len_result},
template=self.breadcrumb_template)['body']
if getattr(self, 'filter_instance', None) is not None:
filter_data['filter_message'] = self.breadcrumb
filter_body = getattr(self, 'filter_instance').get_body(filter_data)
url = self.request.resource_url(
self.context, 'open', query={'folderid': folderid})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results"
result_body = []
for obj in batch:
body = render_listing_obj(
self.request, obj, user,
view_type=template_type)
if body:
result_body.append(body)
values = {
'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'sort_body': sort_body,
'row_len': math.ceil(len_result/2)
}
template = self.templates.get(template_type, 'default')
body = self.content(args=values, template=template)['body']
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
if filter_form:
result['css_links'] = filter_form['css_links']
result['js_links'] = filter_form['js_links']
return result
def ideas_choice():
user = get_current()
ideas = find_entities([Iidea], states=('archived',), not_any=True)
values = [(i, i.title) for i in ideas if can_access(user, i)]
return Select2Widget(values=values, multiple=True)