def update(self):
self.execute(None)
vote_actions = get_vote_actions_body(self.context, self.request)
try:
navbars = generate_navbars(self.request,
self.context,
text_action=vote_actions['activators'])
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
resources = merge_dicts(navbars['resources'],
vote_actions['resources'],
('js_links', 'css_links'))
resources['js_links'] = list(set(resources['js_links']))
resources['css_links'] = list(set(resources['css_links']))
messages = vote_actions['messages']
if not messages:
messages = navbars['messages']
values = {
'registration': self.context,
'footer_body': navbars['footer_body'],
'navbar_body': navbars['navbar_body'],
'vote_actions_body': vote_actions['body']
}
result = {}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['messages'] = messages
item['isactive'] = vote_actions['isactive'] or navbars['isactive']
result.update(resources)
result['coordinates'] = {self.coordinates: [item]}
result = merge_dicts(self.requirements_copy, result)
return result
def update(self,):
if not self.validated_children:
e = ViewError()
e.principalmessage = CallViewErrorPrincipalmessage
causes = set()
for view, er in self.errors:
causes.update(er.causes)
e.causes = list(causes)
raise e
result = {}
global_result = {}
for view in self.validated_children:
try:
view_result = view.update()
except ViewError as e:
continue
if self.isexecutable and \
view.isexecutable and \
view.finished_successfully:
self.finished_successfully = True
return self.success(view_result)
currentview = view
if 'view' in view_result:
currentview = view_result['view']
global_result = merge_dicts(view_result, global_result)
if len(view_result['coordinates']) == 1 and \
len(view_result['coordinates'].items()[0][1]) == 1:
coordinate = view_result['coordinates'].items()[0][0]
item = view_result['coordinates'].items()[0][1][0]
if coordinate in result:
result[coordinate].append(item)
else:
result[coordinate] = [item]
else:
for coordinate, values in view_result['coordinates'].items():
item = values[0]
subviewid = currentview.viewid+'_'+coordinate
item['id'] = subviewid
if coordinate in result:
result[coordinate].append(item)
else:
result[coordinate] = [item]
for coordinate, items in result.items():
values = {'items': items, 'id':self.viewid+coordinate }
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
global_result['coordinates'][coordinate] = [item]
#if not (len(self.validated_children) == len(self.contexts)):
# global_result['messages']
global_result = merge_dicts(self.requirements_copy, global_result)
return global_result
def update(self):
self.execute(None)
user = get_current()
filter_form, filter_data = self._add_filter(user)
filters = [{
'metadata_filter': {
'interfaces': [ISignalableEntity],
'states': ['reported'],
}
}]
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(interfaces=[ISignalableEntity],
user=user,
filters=filters,
**args)
objects, sort_body = sort_view_objects(self, objects, ['proposal'],
user)
url = self.request.resource_url(self.context, 'seereportedcontents')
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_contents"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(self.request, batch, user)
if filter_form:
result = merge_dicts(
{
'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {
'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'sort_body': sort_body
}
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)
user = get_current()
filter_form, filter_data = self._add_filter(user)
filters = [
{'metadata_filter': {
'interfaces': [ISignalableEntity],
'states': ['reported'],
}}
]
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(
interfaces=[ISignalableEntity],
user=user,
filters=filters,
**args)
objects, sort_body = sort_view_objects(
self, objects, ['proposal'], user)
url = self.request.resource_url(
self.context, 'seereportedcontents')
batch = Batch(objects, self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_contents"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_result})
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user)
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'sort_body': sort_body}
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(), ''))
organization = self.context
current_user = get_current()
evaluation_chart = render_object_evaluation_stat(self.context, self.request)
examination_chart = render_object_examination_stat(self.context, self.request)
values = {
'organization': organization,
'state': get_states_mapping(
current_user, organization,
getattr(organization, 'state_or_none', [None])[0]),
'navbar_body': navbars['navbar_body'],
'actions_bodies': navbars['body_actions'],
'footer_body': navbars['footer_body'],
'is_portal_manager': has_role(role=('PortalManager',)),
'evaluation_chart': evaluation_chart,
'examination_chart': examination_chart,
}
result = {}
result = merge_dicts(navbars['resources'], result, ('css_links', 'js_links'))
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['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
involveds = self.context.execution_context.all_active_involveds().values()
involveds = [e['entities'] for e in involveds]
involveds = [entity for entities in involveds for entity in entities]
dace_ui_api = get_current_registry().getUtility(IDaceUIAPI,
'dace_ui_api')
all_actions = dace_ui_api.get_actions(
involveds, self.request, self.context)
action_updated, messages, \
resources, actions = dace_ui_api.update_actions(
self.request, all_actions,
False, False)
result = {}
values = {'actions': actions,
'process':self.context,
'tabid':self.__class__.__name__+'AllActions'}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['messages'] = messages
item['isactive'] = action_updated
result['coordinates'] = {self.coordinates:[item]}
result.update(resources)
result = merge_dicts(self.requirements_copy, result)
return result
def update(self):
user = get_current()
filter_form, filter_data = self._add_filter(user)
args = merge_with_filter_view(self, {})
args['request'] = self.request
filters = [
{
'metadata_filter': {
'states': ['published'],
'interfaces': [IAnswer]
}
},
]
# Answer is non a searchable element
# we need add it to the args dict
args['interfaces'] = [IAnswer]
objects = find_entities(filters=filters,
user=user,
intersect=self._get_answers(user),
**args)
objects, sort_body = sort_view_objects(self, objects, ['answer'], user,
'nbsupport')
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results-answers"
len_answers = batch.seqlen
index = str(len_answers) if len_answers <= 1 else '*'
if not self.parent:
self.title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_answers})
elif index != '*':
self.title = _('The answer')
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(self.request, batch, user)
if filter_form:
result = merge_dicts(
{
'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {
'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'filter_body': filter_body,
'sort_body': sort_body,
'view': self
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = True
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self,):
#validation
if not self.validated_children and \
not self.include_failed_views:
error = ViewError()
error.principalmessage = MutltipleViewErrorPrincipalmessage
causes = set()
for viewinstance, er in self.errors:
causes.update(er.causes)
error.causes = list(causes)
raise error
#update children
result = {}
if self.include_failed_views:
result = self._update_all_children()
else:
result = self._update_validated_children()
if not result:
error = ViewError()
error.principalmessage = MutltipleViewErrorPrincipalmessage
error.causes = MutltipleViewErrorCauses
raise error
if not isinstance(result, dict):
return result
for _coordinate in result['coordinates']:
coordinate = _coordinate
if self.merged:
coordinate = self.coordinates
items = result['coordinates'][coordinate]
isactive = False
for item in items:
if item['isactive']:
isactive = True
break
if not isactive:
self._activate(items)
if self.parent is None:
isactive = True
_item = {'isactive':isactive,
'items': items,
'view': self,
'id':self.viewid}
values = {'coordinates': coordinate,
'subitem': _item,
'parent': self}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = isactive
result['coordinates'][coordinate] = [item]
result = merge_dicts(self.requirements_copy, result)
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_all_children(self):
result = {}
for view in self.all_children:
try:
if view in self.failed_children:
error = dict(self.errors)[view]
view_result = view.failure(error)
else:
view_result = view.update()
except ViewError as e:
continue
if self.isexecutable and view.isexecutable and \
view.finished_successfully:
self.finished_successfully = True
#for wizards
view.init_stepid()
return self.success(view_result)
if not isinstance(view_result, dict):
return view_result
result = merge_dicts(view_result, result)
return result
def get_view_requirements(self):
result = self.requirements_copy
for view in self.validated_children:
view_requirements = view.get_view_requirements()
result = merge_dicts(view_requirements, result)
return result
def update(self):
result = {}
context = self.get_binding('context')
if context.is_finished:
ballot_type = context.report.ballottype
values = {
'ballot': context,
'ballot_type': ballot_type,
'tab_id': self.viewid + self.coordinates
}
ballot_type_body = self.content(
args=values,
template=ballot_type.templates.get('result'))['body']
values = {'body': ballot_type_body, 'ballot': context}
body = self.content(args={
'body': ballot_type_body,
'ballot': context
},
template=self.template)['body']
else:
values = {'body': '', 'ballot': context}
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_actions(
self,
request,
all_actions,
ignor_form=False,
ignor_actionsofactions=True,
include_resources=True):
messages = {}
#find all business actions
form_id = None
#get submited form view
if not ignor_form and '__formid__' in request.POST:
#if request.POST['__formid__'].find(object_oid) >= 0:
form_id = request.POST['__formid__']
toreplay, valid_form_id, action_updated, \
resources, allbodies_actions = self._ajax_views(
request, all_actions,
form_id, ignor_actionsofactions,
include_resources)
if toreplay:
request.POST.clear()
old_resources = resources
old_allbodies_actions = allbodies_actions
actions_toreplay = []
for context, action in list(all_actions):
try:
action.validate(context, request)
if context.__parent__:
actions_toreplay.append((context, action))
except Exception as e:
pass
action_updated, messages, \
resources, allbodies_actions = self.update_actions(
request, actions_toreplay, ignor_form,
include_resources=include_resources)
if old_resources is not None:
resources = merge_dicts(old_resources, resources,
('js_links', 'css_links'))
resources['js_links'] = list(set(resources['js_links']))
resources['css_links'] = list(set(resources['css_links']))
if old_allbodies_actions is not None:
allbodies_actions.extend(old_allbodies_actions)
return True, messages, resources, allbodies_actions
if form_id and \
not action_updated and valid_form_id and all_actions:
error = ViewError()
error.principalmessage = u"Action non realisee"
error.causes = ["Vous n'avez plus le droit de realiser cette action.",
"L'action est verrouillee par un autre utilisateur."]
message = error.render_message(request)
messages.update({error.type: [message]})
return action_updated, messages, resources, allbodies_actions
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 update(self):
self.execute(None)
user = get_current()
is_manager = has_role(user=user, role=('PortalManager', ))
filters = [
{'metadata_filter': {
'content_types': ['person']
}}
]
filter_form, filter_data = self._add_filter(user, is_manager)
args = merge_with_filter_view(self, {})
args['request'] = self.request
objects = find_entities(
user=user,
filters=filters,
**args)
objects, sort_body = sort_view_objects(
self, objects, ['person'], user)
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects, self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_users"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = self._get_title(
index=index, len_result=len_result, user=user)
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user)
novaideo_catalog = find_catalog('novaideo')
last_connection_index = novaideo_catalog['last_connection']
current_date = datetime.datetime.combine(
datetime.datetime.now(),
datetime.time(0, 0, 0, tzinfo=pytz.UTC))
inactive_users = find_users(
last_connection_index, current_date, (INACTIVITY_DURATION, None))
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {'bodies': result_body,
'batch': batch,
'is_manager': is_manager,
'inactivity_duration': INACTIVITY_DURATION,
'inactive_users': inactive_users.__len__(),
'filter_body': filter_body,
'sort_body': sort_body}
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):
body = ''
result = {}
if self.isactive or self.params('on_demand') == 'load':
user = get_current()
filter_form, filter_data = self._add_filter(user)
default_content = [self.content_type]
validated = self._get_validated({
'metadata_filter':
{'content_types': default_content,
'states': ['active', 'published']},
}, user)
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(
user=user,
filters=[validated],
**args)
objects, sort_body = sort_view_objects(
self, objects, [self.content_type], user)
url = self.request.resource_url(
self.context, '',
query={'view_content_id': self.content_id})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
self.title = _(self.title, mapping={'nb': batch.seqlen})
batch.target = "#results-" + self.content_id
filter_instance = getattr(self, 'filter_instance', None)
filter_body = None
if filter_instance:
filter_data['filter_message'] = self.title
filter_body = filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user,
display_state=getattr(self, 'display_state', True))
values = {'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'filter_body': filter_body,
'filter_class': self.filter_class,
'sort_body': sort_body,
'view': self}
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = self.isactive
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
body = ''
result = {}
if self.isactive or self.params('on_demand') == 'load':
user = get_current()
filter_form, filter_data = self._add_filter(user)
default_content = [self.content_type]
validated = self._get_validated({
'metadata_filter':
{'content_types': default_content,
'states': ['active', 'published']},
}, user)
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(
user=user,
filters=[validated],
**args)
objects, sort_body = sort_view_objects(
self, objects, [self.content_type], user)
url = self.request.resource_url(
self.context, '',
query={'view_content_id': self.content_id})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
self.title = _(self.title, mapping={'nb': batch.seqlen})
batch.target = "#results-" + self.content_id
filter_instance = getattr(self, 'filter_instance', None)
filter_body = None
if filter_instance:
filter_data['filter_message'] = self.title
filter_body = filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user,
display_state=getattr(self, 'display_state', True))
values = {'bodies': result_body,
'batch': batch,
'empty_message': self.empty_message,
'empty_icon': self.empty_icon,
'filter_body': filter_body,
'filter_class': self.filter_class,
'sort_body': sort_body,
'view': self}
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = self.isactive
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
user = get_current()
filter_form, filter_data = self._add_filter(user)
args = merge_with_filter_view(self, {})
args['request'] = self.request
objects = find_entities(user=user,
intersect=self._get_content_ids(user),
include_archived=self.include_archived,
**args)
objects, sort_body = sort_view_objects(self,
objects,
self.content_types,
user,
intersect=getattr(
self, 'sorts', None))
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_contents"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = self._get_title(index=index,
len_result=len_result,
user=user)
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(self.request,
batch,
user,
display_state=getattr(
self, 'display_state',
True))
if filter_form:
result = merge_dicts(
{
'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {
'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'sort_body': sort_body
}
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):
result = {}
values = {
'object': self.context,
'tab_id': self.viewid + self.coordinates
}
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 get_view_requirements(self):
stepidkey = STEPID + self.viewid
if stepidkey in self.request.session:
self.currentsteps = [self.nodes[self.request.session.pop(stepidkey)]]
result = self.requirements_copy
for view in self.currentsteps:
view_requirements = view.get_view_requirements()
result = merge_dicts(view_requirements, result)
return result
def update(self):
result = {}
body, resources, messages, isactive = self._rendre_comments(
self.context.comments, True)
item = self.adapt_item(body, self.viewid)
item['messages'] = messages
item['isactive'] = isactive
result['coordinates'] = {self.coordinates:[item]}
result.update(resources)
result = merge_dicts(self.requirements_copy, result)
return result
def update(self):
self.execute(None)
result = {}
allprocessesdef = [{'title':k, 'processes':v} \
for k, v in self._processes().items()]
values = {'allprocessesdef': allprocessesdef}
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)
user = get_current()
text_analyzer = get_current_registry().getUtility(
ITextAnalyzer,
'text_analyzer')
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'])
global_actions = actions_navbar['global-action']
isactive = actions_navbar['modal-action']['isactive']
messages = actions_navbar['modal-action']['messages']
resources = actions_navbar['modal-action']['resources']
result = {}
textdiff = ''
descriptiondiff = ''
keywordsdiff = []
proposal = self.context.proposal
textdiff = self.context.text_diff
soup, descriptiondiff = text_analyzer.render_html_diff(
'<div>'+getattr(proposal, 'description', '')+'</div>',
'<div>'+getattr(self.context, 'description', '')+'</div>')
for k in proposal.keywords:
if k in self.context.keywords:
keywordsdiff.append({'title': k, 'state': 'nothing'})
else:
keywordsdiff.append({'title': k, 'state': 'del'})
[keywordsdiff.append({'title': k, 'state': 'ins'}) \
for k in self.context.keywords if k not in proposal.keywords]
values = {
'amendment': self.context,
'state': get_states_mapping(
user, self.context, self.context.state[0]),
'textdiff': textdiff,
'descriptiondiff':descriptiondiff,
'keywordsdiff':keywordsdiff,
'current_user': user,
'navbar_body': navbar_body_getter(self, actions_navbar),
'end_explanation':self._end_explanation(global_actions)
}
self._add_requirements(user)
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]}
result = merge_dicts(self.requirements_copy, result)
return result
def update(self):
self.execute(None)
user = get_current()
is_manager = has_role(user=user, role=('PortalManager', ))
filters = [{'metadata_filter': {'content_types': ['person']}}]
filter_form, filter_data = self._add_filter(user, is_manager)
args = merge_with_filter_view(self, {})
args['request'] = self.request
objects = find_entities(user=user, filters=filters, **args)
objects, sort_body = sort_view_objects(self, objects, ['person'], user)
url = self.request.resource_url(self.context, self.name)
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_users"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = self._get_title(index=index,
len_result=len_result,
user=user)
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(self.request, batch, user)
novaideo_catalog = find_catalog('novaideo')
last_connection_index = novaideo_catalog['last_connection']
current_date = datetime.datetime.combine(
datetime.datetime.now(), datetime.time(0, 0, 0, tzinfo=pytz.UTC))
inactive_users = find_users(last_connection_index, current_date,
(INACTIVITY_DURATION, None))
if filter_form:
result = merge_dicts(
{
'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {
'bodies': result_body,
'batch': batch,
'is_manager': is_manager,
'inactivity_duration': INACTIVITY_DURATION,
'inactive_users': inactive_users.__len__(),
'filter_body': filter_body,
'sort_body': sort_body
}
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)
try:
navbars = generate_navbars(self.request, self.context)
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
user = self.context
current_user = get_current()
details = {}
stats = get_object_stat(self.context, self.request)
stats['nb_other'] = stats.get('nb_other', 0) + len(
user.evaluated_objs_ids())
stas_len = sum(stats.values())
evaluation_chart = render_object_evaluation_stat(
self.context, self.request)
examination_chart = render_object_examination_stat(
self.context, self.request)
values = {
'user':
user,
'proposals':
None,
'state':
get_states_mapping(current_user, user,
getattr(user, 'state_or_none', [None])[0]),
'navbar_body':
navbars['navbar_body'],
'actions_bodies':
navbars['body_actions'],
'footer_body':
navbars['footer_body'],
'is_portal_manager':
has_role(role=('PortalManager', )),
'contributions_len':
stas_len,
'details':
stats,
'evaluation_chart':
evaluation_chart,
'examination_chart':
examination_chart,
}
result = {}
result = merge_dicts(navbars['resources'], result,
('css_links', 'js_links'))
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['coordinates'] = {self.coordinates: [item]}
return result
def get_view_requirements(self):
bindings = self.bind()
bindings.update({
'request': self.request,
'context': self.context,
})
schema = self.schema.bind(**bindings)
reqts = self.form_class(schema).get_widget_resources()
result = {}
result['js_links'] = list(reqts['js'])
result['css_links'] = list(reqts['css'])
result = merge_dicts(self.requirements_copy, result)
return result
def get_view_requirements(self):
bindings = self.bind()
bindings.update({
'request': self.request,
'context': self.context,
})
schema = self.schema.bind(**bindings)
reqts = self.form_class(schema).get_widget_resources()
result = {}
result['js_links'] = list(reqts['js'])
result['css_links'] = list(reqts['css'])
result = merge_dicts(self.requirements_copy, result)
return result
def update(self):
self.execute(None)
result = {}
all_involveds = self._datas(
self.context.execution_context.all_classified_involveds())
involveds = [a for a in all_involveds if a['iscurrent']]
values = {'datas': involveds,
'alldatas':all_involveds,
'tabid':self.__class__.__name__+'AllDatas'}
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)
result = {}
dace_ui_api = get_current_registry().getUtility(IDaceUIAPI,
'dace_ui_api')
values = dace_ui_api.statistic_processes(self, self.context.processes,
self.__class__.__name__)
dates = dace_ui_api.statistic_dates(self, self.context.processes)
values['dates'] = dates
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)
user = get_current()
filter_form, filter_data = self._add_filter(user)
filters = [
{'metadata_filter': {
'content_types': ['challenge']
}}
]
args = {}
args = merge_with_filter_view(self, args)
args['request'] = self.request
objects = find_entities(user=user,
filters=filters,
**args)
objects, sort_body = sort_view_objects(
self, objects, ['challenge'], user,
intersect=getattr(self, 'sorts', None))
url = self.request.resource_url(self.context, self.name)
batch = Batch(
objects, self.request, url=url, default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results-home-challenges"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = self.request.localizer.translate(
_(CONTENTS_MESSAGES[index],
mapping={'number': len_result}))
filter_data['filter_message'] = self.title
filter_body = self.filter_instance.get_body(filter_data)
result_body, result = render_listing_objs(
self.request, batch, user, 'card')
if filter_form:
result = merge_dicts(
{'css_links': filter_form['css_links'],
'js_links': filter_form['js_links']
}, result)
values = {
'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'sort_body': sort_body
}
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):
stepidkey = STEPID+self.viewid
#TODO
#if stepidkey in self.request.POST:
# self.currentsteps = [self.viewsinstances[self.request.POST[stepidkey]]]
if stepidkey in self.request.session:
self.currentsteps = [self.viewsinstances[self.request.session.pop(stepidkey)]]
result = None
finished_successfully = False
viewinstance, finished_successfully, result = self._get_result(
self.currentsteps)
self.isexecutable = viewinstance.isexecutable
if viewinstance is not None and \
finished_successfully and viewinstance._outgoing and \
not(viewinstance._outgoing[0].target == self.endnode):
result = None
while(result is None and \
not(viewinstance._outgoing[0].target == self.endnode)):
viewinstance.after_update()
nextsteps = [transition.target for transition in viewinstance._outgoing \
if (transition.validate() and not transition.isdefault)]
if not nextsteps:
nextsteps = [transition.target for transition in viewinstance._outgoing \
if transition.isdefault]
viewinstance, finished_successfully, result = self._get_result(
nextsteps)
self.isexecutable = viewinstance.isexecutable
if isinstance(result, dict) and self.include_informations:
wizardinfo = self.getwizardinformationsview()
result = merge_dicts(result, wizardinfo, ('js_links', 'css_links'))
for coordinates in result['coordinates']:
item = result['coordinates'][coordinates][0]
body = item['body']
body = wizardinfo['body']+body
item['body'] = body
if finished_successfully and \
(viewinstance._outgoing[0].target == self.endnode):
self.finished_successfully = True
viewinstance.after_update()
self.request.session.__delitem__(stepidkey)
if viewinstance.isexecutable:
return self.success()
return result
def update(self):
self.execute(None)
result = {}
tabid = self.__class__.__name__+'AllProcesses'
page, pages, allprocesses = self._processes(tabid)
values = {'processes': allprocesses,
'p_id': self.context.title,
'tabid':tabid,
'page': page,
'pages': pages,
'url': self.request.resource_url(self.context,
'@@ProcessInst')}
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_processes(self, view, processes, tabid):
result = {}
processes = sorted(processes, key=lambda p: p.created_at)
page, pages, processes = calculatePage(processes, view, tabid)
nb_encours, nb_bloque, nb_termine, allprocesses = self._processes(view, processes)
values = {'processes': allprocesses,
'encours': nb_encours,
'bloque': nb_bloque,
'termine': nb_termine,
'tabid': tabid,
'page': page,
'pages': pages,
'url': view.request.resource_url(view.context, '@@'+view.name)}
body = view.content(args=values, template='daceui:templates/runtime_view.pt')['body']
item = view.adapt_item(body, view.viewid)
result['coordinates'] = {view.coordinates:[item]}
result = merge_dicts(view.requirements, result)
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 update(self):
user = get_current()
formviewinstance = SearchView(self.context, self.request)
formviewinstance.postedform = self.request.POST
appstruct = formviewinstance.get_appstruct()
content_types = appstruct['content_types']
text = appstruct['text_to_search']
objects = search(text, content_types, user)
url = self.request.resource_url(self.context, '',
query={'content_types':content_types,
'text_to_search':appstruct['text_to_search']})
batch = Batch(objects,
self.request,
url=url,
default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(CONTENTS_MESSAGES[index] ,
mapping={'nember': len_result})
result_body = []
for obj in batch:
object_values = {'object':obj,
'current_user': user,
'state': get_states_mapping(user, obj,
getattr(obj, 'state', [None])[0])}
body = self.content(result=object_values,
template=obj.result_template)['body']
result_body.append(body)
result = {}
values = {
'bodies': result_body,
'length': len_result,
'batch': batch
}
body = self.content(result=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 _rendre_comments(self,
comments,
current_user,
origin=False,
batch=None,
unread_comments=[],
filtered=False):
all_comments = []
resources = {'css_links': [], 'js_links': []}
for obj in comments:
try:
navbars = generate_listing_menu(
self.request,
obj,
template='novaideo:views/templates/comment_menu.pt')
except ObjectRemovedException:
continue
resources = merge_dicts(navbars['resources'], resources)
object_values = {
'context': obj,
'menu_body': navbars['menu_body'],
'primary_menu_body': navbars['primary_menu_body'],
'footer_actions_body': navbars['footer_actions_body'],
'footer_body': navbars['footer_body']
}
all_comments.append(object_values)
all_comments = sorted(all_comments,
key=lambda e: e['context'].created_at)
values = {
'comments': all_comments,
'unread_comments': unread_comments,
'filtered': filtered,
'current_user': current_user,
'view': self,
'origin': origin,
'batch': batch,
'level': COMMENT_LEVEL
}
body = self.content(args=values, template=self.template)['body']
return body, resources
def update(self):
vote_actions = self.get_binding('vote_actions')
navbars = self.get_binding('navbars')
root = self.get_binding('root')
if navbars is None:
return HTTPFound(self.request.resource_url(root, ''))
resources = merge_dicts(navbars['resources'],
vote_actions['resources'],
('js_links', 'css_links'))
resources['js_links'] = list(set(resources['js_links']))
resources['css_links'] = list(set(resources['css_links']))
messages = vote_actions['messages']
if not messages:
messages = navbars['messages']
user = self.get_binding('user')
is_censored = self.get_binding('is_censored')
to_hide = self.get_binding('to_hide')
result = {}
values = {
'idea': self.context,
'is_censored': is_censored,
'to_hide': to_hide,
'state': get_states_mapping(user, self.context,
self.context.state[0]),
'current_user': user,
'cant_publish': self._cant_publish_alert(navbars['all_actions'],
user),
'cant_submit': self._cant_submit_alert(navbars['all_actions'],
user),
'navbar_body': navbars['navbar_body'],
'vote_actions_body': vote_actions['body']
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['messages'] = messages
item['isactive'] = vote_actions['isactive'] or navbars['isactive']
result.update(resources)
result['coordinates'] = {self.coordinates: [item]}
return result
def __call__(self):
user = get_current()
guide_tour_data = getattr(user, 'guide_tour_data', {})
guide_state = guide_tour_data.get(
'guide_state', 'first_start')
if guide_state in ('pending', 'first_start'):
page_resources = get_guide_tour_page(
self.request, self.context, user, self.request.view_name)
if page_resources:
page_resources = merge_dicts(
self.resources, page_resources)
page_resources['request'] = self.request
# if user is not an anonymous
if self.request.user:
root = getSite()
page_resources['update_url'] = self.request.resource_url(
root,
'novaideoapi', query={
'op': 'update_guide_tour_data'
})
guide = page_resources.get('guide', None)
page = page_resources.get('page', None)
if guide is not None and page is not None:
guide_data = guide_tour_data.get(
guide+'_'+page, {})
page_state = guide_data.get(
'page_state', 'pending')
if page_state == 'pending':
page_resources['guide'] = guide
page_resources['page'] = page
page_resources['guide_value'] = guide_data.get(
'guide', -1)
page_resources['page_value'] = guide_data.get(
'page', 0)
page_resources['guide_state'] = guide_state
else:
return {}
return page_resources
return {}
def _update_validated_children(self):
result = {}
for view in self.validated_children:
try:
view_result = view.update()
except ViewError as e:
continue
if self.isexecutable and view.isexecutable and \
view.finished_successfully:
self.finished_successfully = True
#for wizards
view.init_stepid()
return self.success(view_result)
if not isinstance(view_result, dict):
return view_result
result = merge_dicts(view_result, result)
return result
def valid_services(request):
site = request.get_site_folder
user = get_current()
context = request.context
allservices = site.get_all_services(context=context,
user=user,
site=site,
validate=True,
delegation=False)
if hasattr(user, 'get_all_services'):
user_services = user.get_all_services(context=context,
user=user,
site=site,
validate=True,
delegation=False)
allservices = merge_dicts(allservices, user_services)
for service in allservices:
allservices[service] = list(set(allservices[service]))
return allservices
def update(self):
self.execute(None)
try:
navbars = generate_navbars(self.request, self.context)
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
user = self.context
current_user = get_current()
details = {}
stats = get_object_stat(self.context, self.request)
stats['nb_other'] = stats.get('nb_other', 0) + len(user.evaluated_objs_ids())
stas_len = sum(stats.values())
evaluation_chart = render_object_evaluation_stat(self.context, self.request)
examination_chart = render_object_examination_stat(self.context, self.request)
values = {
'user': user,
'proposals': None,
'state': get_states_mapping(
current_user, user,
getattr(user, 'state_or_none', [None])[0]),
'navbar_body': navbars['navbar_body'],
'actions_bodies': navbars['body_actions'],
'footer_body': navbars['footer_body'],
'is_portal_manager': has_role(role=('PortalManager',)),
'contributions_len': stas_len,
'details': stats,
'evaluation_chart': evaluation_chart,
'examination_chart': examination_chart,
}
result = {}
result = merge_dicts(navbars['resources'], result, ('css_links', 'js_links'))
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['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
self.execute(None)
navbars = self.get_binding('navbars')
root = self.get_binding('root')
if navbars is None:
return HTTPFound(self.request.resource_url(root, ''))
user = self.get_binding('user')
to_hide = self.get_binding('to_hide')
result = {}
values = {
'idea': self.context,
'to_hide': to_hide,
'text': self.context.text.replace('\n', '<br/>'),
'current_user': user,
'footer_body': navbars['footer_body']
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['isactive'] = True
result['coordinates'] = {self.coordinates: [item]}
result = merge_dicts(self.requirements_copy, result)
return result
def valid_services(request):
site = request.get_site_folder
user = get_current()
context = request.context
allservices = site.get_all_services(
context=context,
user=user,
site=site,
validate=True,
delegation=False)
if hasattr(user, 'get_all_services'):
user_services = user.get_all_services(
context=context,
user=user,
site=site,
validate=True,
delegation=False)
allservices = merge_dicts(allservices, user_services)
for service in allservices:
allservices[service] = list(set(allservices[service]))
return allservices
def _rendre_comments(
self, comments, current_user,
origin=False, batch=None, unread_comments=[],
filtered=False):
all_comments = []
resources = {'css_links': [], 'js_links': []}
for obj in comments:
try:
navbars = generate_listing_menu(
self.request, obj,
template='novaideo:views/templates/comment_menu.pt')
except ObjectRemovedException:
continue
resources = merge_dicts(navbars['resources'], resources)
object_values = {
'context': obj,
'menu_body': navbars['menu_body'],
'primary_menu_body': navbars['primary_menu_body'],
'footer_actions_body': navbars['footer_actions_body'],
'footer_body': navbars['footer_body']}
all_comments.append(object_values)
all_comments = sorted(all_comments,
key=lambda e: e['context'].created_at)
values = {
'comments': all_comments,
'unread_comments': unread_comments,
'filtered': filtered,
'current_user': current_user,
'view': self,
'origin': origin,
'batch': batch,
'level': COMMENT_LEVEL
}
body = self.content(args=values, template=self.template)['body']
return body, resources
def __call__(self):
user = get_current()
guide_tour_data = getattr(user, 'guide_tour_data', {})
guide_state = guide_tour_data.get('guide_state', 'first_start')
if guide_state in ('pending', 'first_start'):
page_resources = get_guide_tour_page(self.request, self.context,
user, self.request.view_name)
if page_resources:
page_resources = merge_dicts(self.resources, page_resources)
page_resources['request'] = self.request
# if user is not an anonymous
if self.request.user:
root = getSite()
page_resources['update_url'] = self.request.resource_url(
root,
'novaideoapi',
query={'op': 'update_guide_tour_data'})
guide = page_resources.get('guide', None)
page = page_resources.get('page', None)
if guide is not None and page is not None:
guide_data = guide_tour_data.get(
guide + '_' + page, {})
page_state = guide_data.get('page_state', 'pending')
if page_state == 'pending':
page_resources['guide'] = guide
page_resources['page'] = page
page_resources['guide_value'] = guide_data.get(
'guide', -1)
page_resources['page_value'] = guide_data.get(
'page', 0)
page_resources['guide_state'] = guide_state
else:
return {}
return page_resources
return {}
def update(self):
self.execute(None)
vote_actions = get_vote_actions_body(self.context,
self.request,
ballot_ids=['vote_moderation'])
try:
navbars = generate_navbars(self.request,
self.context,
process_id='reportsmanagement',
descriminators=['plus-action'],
flatten=True,
text_action=vote_actions['activators'])
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
resources = merge_dicts(navbars['resources'],
vote_actions['resources'],
('js_links', 'css_links'))
resources['js_links'] = list(set(resources['js_links']))
resources['css_links'] = list(set(resources['css_links']))
messages = vote_actions['messages']
if not messages:
messages = navbars['messages']
result = {}
values = {
'navbar_body': navbars['navbar_body'],
'object': self.context,
'vote_actions_body': vote_actions['body']
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['messages'] = messages
item['isactive'] = vote_actions['isactive'] or navbars['isactive']
result.update(resources)
result['coordinates'] = {self.coordinates: [item]}
return result
def _ajax_views(self,
request,
actions,
form_id,
ignor_actionsofactions=True,
include_resources=True):
action_updated = False
resources = {}
resources['js_links'] = []
resources['css_links'] = []
allbodies_actions = []
updated_view = None
valid_form_id = False
for (context, action) in actions:
#get view class
view = DEFAULTMAPPING_ACTIONS_VIEWS[action._class_]
#get view instance
view_instance = view(
context, request,
behaviors=[action])
view_result = {}
view_has_id = view_instance.has_id(form_id)
valid_form_id = valid_form_id or view_has_id
#if the view instance is called then update the view
if not action_updated and form_id and \
view_has_id:
action_updated = True
updated_view = view_instance
view_result = view_instance()
else:
#else get view requirements
view_result = {'js_links': [], 'css_links': []}
if include_resources:
view_result = view_instance.get_view_requirements()
#if the view instance is executable
#and finished successfully return
if updated_view is view_instance and \
view_instance.isexecutable and \
view_instance.finished_successfully:
return True, True, True, None, None
#if the view instance return a result
if isinstance(view_result, dict):
action_infos = {}
#if the view instance is not executable or
#it is finished with an error
if updated_view is view_instance and \
(not view_instance.isexecutable or \
(view_instance.isexecutable and \
not view_instance.finished_successfully)):
action_infos['toreplay'] = True
if not view_instance.isexecutable:
action_infos['finished'] = True
if not ignor_actionsofactions:
actions_as = sorted(
action.actions,
key=lambda call_action: call_action.action.behavior_id)
a_actions = [(action, call_action.action)
for call_action in actions_as]
toreplay, valid_form_id_as, action_updated_as, \
resources_as, allbodies_actions_as = self._ajax_views(
request, a_actions, form_id, include_resources)
if toreplay:
return True, True, True, None, None
if action_updated_as:
action_updated = True
if valid_form_id_as:
valid_form_id = True
resources['js_links'].extend(resources_as['js_links'])
resources['js_links'] = list(set(resources['js_links']))
resources['css_links'].extend(resources_as['css_links'])
resources['css_links'] = list(set(resources['css_links']))
action_infos['actions'] = allbodies_actions_as
body = ''
if 'coordinates' in view_result:
body = view_instance.render_item(
view_result['coordinates'][view_instance.coordinates][0],
view_instance.coordinates, None)
action_infos.update(
self.action_infomrations(action=action,
context=context,
request=request))
action_infos.update({
'body': json.dumps(body),
'context': context,
'assigned_to': sorted(
action.assigned_to,
key=lambda u: getattr(
u, 'title', u.__name__))})
allbodies_actions.append(action_infos)
resources = merge_dicts(view_result, resources,
('js_links', 'css_links'))
resources['js_links'] = list(set(resources['js_links']))
resources['css_links'] = list(set(resources['css_links']))
if 'finished' in action_infos:
view_resources = {}
view_resources['js_links'] = []
view_resources['css_links'] = []
view_resources = merge_dicts(
view_result, view_resources,
('js_links', 'css_links'))
return True, True, True, view_resources, [action_infos]
return False, valid_form_id, action_updated, \
resources, allbodies_actions
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
classifications = [
CLASSIFICATIONS[fid]
for fid in getattr(folder, 'classifications', [])
]
classifications.reverse()
source_class = None
for classification in classifications:
source_class = classification(source_class)
setattr(self, 'filter_instance', None)
filter_body = None
filter_form, filter_data = self._add_filter(folder, user)
# calling self._add_filter will set self.filter_instance or not
template_type = getattr(folder, 'view_type', 'default')
if template_type == 'bloc':
self.container_css_class = 'home folder-bloc'
self.wrapper_template = 'lac:views/admin_process/templates/folder_blocs_view_wrapper.pt'
args = merge_with_filter_view(self, {})
objects = get_folder_content(folder, user, **args)
len_result = len(objects)
self.breadcrumb = self.content(
args={
'lineage': folder.folder_lineage,
'nember': len_result
},
template=self.breadcrumb_template)['body']
self.title = '/'.join([f.title for f in folder.folder_lineage])
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)
if source_class is None:
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:
object_values = {
'object':
obj,
'current_user':
user,
'state':
get_states_mapping(
user, obj,
getattr(obj, 'state_or_none', [None])[0])
}
body = self.content(
args=object_values,
template=obj.templates[template_type])['body']
result_body.append(body)
values = {
'bodies': result_body,
'batch': batch,
'filter_body': filter_body,
'row_len': math.ceil(len_result / 2)
}
template = self.templates.get(template_type, 'default')
body = self.content(args=values, template=template)['body']
else:
body = source_class.render(objects,
self.request,
folder,
filter_body=filter_body,
validated=getattr(
self.filter_instance, 'validated',
{}),
template_type=template_type)
item = self.adapt_item(body, self.viewid)
result['coordinates'] = {self.coordinates: [item]}
result = merge_dicts(self.requirements_copy, result)
if filter_form:
result['css_links'] = filter_form['css_links']
result['js_links'] = filter_form['js_links']
return result
def update(self, ):
self.init_stepid(self.schema)
form, reqts = self._build_form()
form.formid = self.viewid + '_' + form.formid
set_oid(form.children, form.formid)
item = None
result = {}
posted_formid = None
error = False
if '__formid__' in self.request.POST:
posted_formid = self.request.POST['__formid__']
if posted_formid is not None and posted_formid == form.formid:
for button in form.buttons:
if button.name in self.request.POST:
try:
if (button.name in self.behaviors_instances) and \
isinstance(self.behaviors_instances[button.name],
Cancel):
# bypass form validation for Cancel behavior
cancel_beh = self.behaviors_instances[button.name]
behaviors = self.behaviors_instances.values()
self.remove_tmp_stores(form)
cancel_beh.execute(self.context, self.request,
{'behaviors': behaviors})
validated = {}
else:
controls = self.request.POST.items()
validated = form.validate(controls)
except deform.exception.ValidationFailure as e:
fail = getattr(self, '%s_failure' % button.title, None)
if fail is None:
fail = self._failure
item = fail(e, form)
error = True
else:
try:
behavior = self.behaviors_instances[button.name]
item = behavior.execute(self.context, self.request,
validated)
self.finished_successfully = True
self.remove_tmp_stores(form)
except FormError as e:
snippet = '<div class="error">Failed: %s</div>' % e
self.request.sdiapi.flash(snippet,
'danger',
allow_duplicate=True)
item = self.adapt_item(form.render(validated),
form.formid)
error = True
break
if item is None:
if not self.finished_successfully:
item = self.show(form)
if isinstance(item, dict):
if error:
item['isactive'] = True
result['coordinates'] = {self.coordinates: [item]}
result['js_links'] = list(reqts['js'])
result['css_links'] = list(reqts['css'])
result = merge_dicts(self.requirements_copy, result)
else:
result = item
return result
def update(self):
self.execute(None)
vote_actions = self.get_binding('vote_actions')
navbars = self.get_binding('navbars')
root = self.get_binding('root')
if navbars is None:
return HTTPFound(self.request.resource_url(root, ''))
resources = merge_dicts(navbars['resources'],
vote_actions['resources'],
('js_links', 'css_links'))
resources['js_links'] = list(set(resources['js_links']))
resources['css_links'] = list(set(resources['css_links']))
messages = vote_actions['messages']
if not messages:
messages = navbars['messages']
user = self.get_binding('user')
is_participant = self.get_binding('is_participant')
is_censored = self.get_binding('is_censored')
to_hide = self.get_binding('to_hide')
title, description, text, add_filigrane = self.get_binding(
'content_data')
corrections = self.get_binding('corrections')
enable_corrections = self.get_binding('enable_corrections')
tinymce_js = 'deform:static/tinymce/tinymce.min.js'
if enable_corrections and\
tinymce_js not in resources['js_links']:
resources['js_links'].append(tinymce_js)
related_ideas = self.context.related_ideas
not_published_ideas = [
i for i in related_ideas if 'published' not in i.state
]
not_favorable_ideas = []
idea_to_examine = 'idea' in self.request.content_to_examine
if idea_to_examine:
not_favorable_ideas = [
i for i in related_ideas
if 'favorable' not in i.state and 'published' in i.state
]
if not self.request.moderate_ideas:
not_favorable_ideas.extend(not_published_ideas)
result = {}
values = {
'proposal':
self.context,
'is_censored':
is_censored,
'to_hide':
to_hide,
'state':
get_states_mapping(user, self.context, self.context.state[0]),
'title':
title,
'description':
description,
'corrections':
corrections,
'enable_corrections':
enable_corrections,
'current_user':
user,
'is_participant':
is_participant,
'vote_actions_body':
vote_actions['body'],
'cant_publish':
self._cant_publish(navbars['all_actions']),
'idea_to_examine':
idea_to_examine,
'not_published_ideas':
not_published_ideas,
'not_favorable_ideas':
not_favorable_ideas,
'ct_participate':
self._cant_participate(navbars['all_actions'], user, root),
'wg_body':
navbars['wg_body'],
'navbar_body':
navbars['navbar_body'],
'json':
json
}
body = self.content(args=values, template=self.template)['body']
item = self.adapt_item(body, self.viewid)
item['messages'] = messages
item['isactive'] = vote_actions['isactive'] or navbars['isactive']
result.update(resources)
result['coordinates'] = {self.coordinates: [item]}
return result
def update(self):
if self.request.POST and 'login_form.submitted' in self.request.POST:
log_result = self.login()
if not isinstance(log_result, dict):
return log_result
self.execute(None)
site = get_site_folder(True)
self.title = site.title
site_id = get_oid(site)
user = get_current()
folders = find_entities(interfaces=[ISmartFolder],
metadata_filter={'states': ['published']},
force_local_control=True)
my_folders = []
if self.request.user:
my_folders = getattr(user, 'folders', [])
my_folders = [
folder for folder in my_folders
if isinstance(folder, SmartFolder) and not folder.parents
and 'private' in folder.state
]
folders = [
folder for folder in folders
if not folder.parents and getattr(folder, 'add_as_a_block', False)
]
folders.extend(my_folders)
foldersdata = []
old_date = datetime.datetime.now(tz=pytz.UTC) - datetime.timedelta(
days=getattr(site, 'days_visibility', DEFAULT_DAYS_VISIBILITY))
old_date = old_date.replace(tzinfo=pytz.UTC)
lac_catalog = find_catalog('lac')
release_date_index = lac_catalog['release_date']
query = release_date_index.ge(old_date)
content_types = getattr(
site, 'home_content_types',
['review', 'cinema_review', 'brief', 'interview'])
for folder in folders:
all_folders = [folder]
all_folders.extend(folder.all_sub_folders('published'))
contents_oids = set()
for sub_folder in all_folders:
result_set = get_folder_content(sub_folder,
user,
sort_on='release_date',
reverse=True,
limit=MORE_NB,
add_query=query,
metadata_filter={
'content_types':
content_types,
'states': ['published']
})
contents_oids |= set(result_set.ids)
if contents_oids:
contents_oids = release_date_index.sort(contents_oids,
reverse=True,
limit=MORE_NB)
objectmap = find_objectmap(get_current_request().root)
resolver = objectmap.object_for
contents = [resolver(oid) for oid in contents_oids]
foldersdata.append({
'folder': folder,
'contents': contents,
'order': folder.get_order(site_id)
})
foldersdata = sorted(foldersdata, key=lambda e: e['order'])
result = {}
values = {
'folders': foldersdata,
'content_types': content_types,
'row_len': math.ceil(len(foldersdata) / 2)
}
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
