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 update(self):
self.execute(None)
try:
navbars = generate_navbars(self.request, self.context)
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
result = {}
user = get_current()
values = {
'object': self.context,
'state': get_states_mapping(
user, self.context, self.context.state[0]),
'is_portalmanager': has_role(user=user, role=('PortalManager',)),
'navbar_body': navbars['navbar_body'],
'actions_bodies': navbars['body_actions'],
'footer_body': navbars['footer_body']
}
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 update(self):
self.execute(None)
try:
navbars = generate_navbars(self.request, self.context)
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
result = {}
user = get_current()
values = {
'object':
self.context,
'current_user':
user,
'state':
get_states_mapping(
user, self.context,
getattr(self.context, 'state_or_none', [None])[0]),
'navbar_body':
navbars['navbar_body']
}
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_subject_state(self, subject, user, last_state=False):
states = getattr(subject, 'state_or_none', [None])
state = states[0]
if last_state:
state = states[-1]
return get_states_mapping(user, subject, state)
def update(self):
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')
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']
}
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 update(self):
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')
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']
}
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 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 get_subject_state(self, subject, user, last_state=False):
states = getattr(subject, 'state_or_none', [None])
state = states[0]
if last_state:
state = states[-1]
return get_states_mapping(
user, subject, state)
def state(self, user, request):
states = getattr(self.context, 'state', [])
result = []
for state in states:
result.append(request.localizer.translate(
get_states_mapping(
None, self.context, state)))
return ', '.join(result)
def state(self, user, request):
states = getattr(self.context, 'state', [])
result = []
for state in states:
result.append(
request.localizer.translate(
get_states_mapping(None, self.context, state)))
return ', '.join(result)
def mysubscriber_object_modified(event):
content = event.object
args = event.args
state_source = args.get('state_source', '')
state_target = args.get('state_target', '')
request = get_current_request()
users = get_users_by_preferences(content)
root = request.root
localizer = request.localizer
subject_data = get_entity_data(content, 'subject', request)
all_users = []
for member in users:
all_users.append(member)
if getattr(member, 'email', ''):
mail_template = root.get_mail_template('alert_content_modified',
member.user_locale)
subject = mail_template['subject'].format(**subject_data)
state_source_translate = state_source
state_target_translate = state_target
if state_source:
state_source_translate = localizer.translate(
get_states_mapping(member, content, state_source))
if state_target:
state_target_translate = localizer.translate(
get_states_mapping(member, content, state_target))
email_data = get_user_data(member, 'recipient', request)
email_data.update(subject_data)
message = mail_template['template'].format(
state_source=state_source_translate,
state_target=state_target_translate,
novaideo_title=root.title,
**email_data)
alert('email', [root.get_site_sender()], [member.email],
subject=subject,
body=message)
alert('internal', [root],
all_users,
internal_kind=InternalAlertKind.content_alert,
subjects=[content],
alert_kind='modified')
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)
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):
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 update(self):
self.execute(None)
user = get_current()
objects = [o for o in getattr(user, 'selections', []) \
if not('archived' in o.state)]
objects = sorted(objects,
key=lambda e: getattr(e, 'modified_at',
datetime.datetime.today()),
reverse=True)
batch = Batch(objects, self.request, default_size=BATCH_DEFAULT_SIZE)
batch.target = "#results_selections"
len_result = batch.seqlen
index = str(len_result)
if len_result > 1:
index = '*'
self.title = _(MY_CONTENTS_MESSAGES[index],
mapping={'nember': len_result})
result_body = []
for obj in batch:
state = None
if getattr(obj, 'state', []):
state = obj.state[0]
object_values = {'object': obj,
'current_user': user,
'state': get_states_mapping(user, obj, state)}
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]}
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 update(self):
self.execute(None)
try:
navbars = generate_navbars(self.request, self.context)
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
result = {}
user = get_current()
values = {
'object': self.context,
'state': get_states_mapping(
user, self.context,
getattr(self.context, 'state_or_none', [None])[0]),
'navbar_body': navbars['navbar_body']
}
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 update(self):
self.execute(None)
try:
navbars = generate_listing_menu(
self.request, self.context,
template=DEFAUL_LISTING_ACTIONS_TEMPLATE)
except ObjectRemovedException:
#Log in if the invitation is accepted
if hasattr(self.context, 'person'):
person = self.context.person
headers = remember(self.request, get_oid(person))
self.request.registry.notify(
LoggedIn(person.email, person,
self.context, self.request))
root = getSite()
return HTTPFound(
location=self.request.resource_url(root),
headers=headers)
return HTTPFound(self.request.resource_url(getSite(), ''))
user = get_current()
values = {
'invitation': self.context,
'menu_body': navbars['menu_body'],
'primary_menu_body': navbars['primary_menu_body'],
'state': get_states_mapping(
user, self.context, self.context.state[0]),}
result = {}
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 update(self):
self.execute(None)
try:
navbars = generate_listing_menu(
self.request,
self.context,
template=DEFAUL_LISTING_ACTIONS_TEMPLATE)
except ObjectRemovedException:
#Log in if the invitation is accepted
if hasattr(self.context, 'person'):
person = self.context.person
headers = remember(self.request, get_oid(person))
self.request.registry.notify(
LoggedIn(person.email, person, self.context, self.request))
root = getSite()
return HTTPFound(location=self.request.resource_url(root),
headers=headers)
return HTTPFound(self.request.resource_url(getSite(), ''))
user = get_current()
values = {
'invitation': self.context,
'menu_body': navbars['menu_body'],
'primary_menu_body': navbars['primary_menu_body'],
'state': get_states_mapping(user, self.context,
self.context.state[0]),
}
result = {}
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 update(self):
self.execute(None)
user = get_current()
files = getattr(self.context, 'attached_files', [])
files_urls = []
for file in files:
files_urls.append({'title':file.title,
'url':file.url(self.request)})
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 = {}
values = {
'idea': self.context,
'state': get_states_mapping(user, self.context,
self.context.state[0]),
'current_user': user,
'files': files_urls,
'cant_publish': self._cant_publish_alert(global_actions),
'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 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 get_state(self, request, user):
return get_states_mapping(user, self,
getattr(self, 'state_or_none', [None])[0])
def update(self):
self.execute(None)
user = get_current()
root = getSite()
wg = self.context.working_group
vote_actions, resources, messages, isactive = self._vote_actions()
def actions_getter():
return [a for a in self.context.actions \
if getattr(a.action, 'style', '') == 'button']
try:
actions_navbar = get_actions_navbar(actions_getter, self.request,
['global-action', 'text-action', 'wg-action'])
except TypeError:
pass
if getattr(self.context, '__parent__', None) is None:
return HTTPFound(self.request.resource_url(root, ''))
if vote_actions:
actions_navbar['text-action'].append({
'title': _('Vote'),
'class_css': 'vote-action',
'style_picto': 'glyphicon glyphicon-stats'})
global_actions = actions_navbar['global-action']
wg_actions = actions_navbar['wg-action']
modal_isactive = actions_navbar['modal-action']['isactive']
modal_messages = actions_navbar['modal-action']['messages']
modal_resources = actions_navbar['modal-action']['resources']
resources = merge_dicts(modal_resources, resources,
('js_links', 'css_links'))
resources['js_links'] = list(set(resources['js_links']))
resources['css_links'] = list(set(resources['css_links']))
if not messages:
messages = modal_messages
ct_participate_max = False
ct_participate_closed = False
ct_participate = False
if wg:
ct_participate_max = len(wg.members) == root.participants_maxi
ct_participate_closed = 'closed' in wg.state
ct_participate = 'archived' not in wg.state and \
not isinstance(user, Anonymous) and \
user not in wg.members and \
(ct_participate_max or ct_participate_closed)
title, description, text, add_filigrane = self._get_adapted_text(user)
result = {}
values = {
'proposal': self.context,
'state': get_states_mapping(user, self.context,
self.context.state[0]),
'title': title,
'description': description,
'text': text,
'current_user': user,
'wg_actions': wg_actions,
'voteactions': vote_actions,
'filigrane': add_filigrane,
'cant_submit': self._cant_submit_alert(global_actions),
'ct_participate': ct_participate,
'ct_participate_closed': ct_participate_closed,
'ct_participate_max': ct_participate_max,
'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 or modal_isactive
result.update(resources)
result['coordinates'] = {self.coordinates:[item]}
return result
def _get_step3_informations(self, context, request):
time_delta = None
working_group = context.working_group
process = working_group.improvement_cycle_proc
is_closed = 'closed' in working_group.state
user = get_current()
working_group_states = [
_(get_states_mapping(user, working_group, s))
for s in working_group.state
]
if 'amendable' in context.state and process:
subprocesses = process['work'].sub_processes
date_iteration = None
if subprocesses:
date_iteration = subprocesses[-1]['timer'].eventKind.time_date
today = datetime.datetime.now()
if date_iteration is not None and date_iteration > today:
time_delta = date_iteration - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(
self.step3_1_template, {
'context': context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration': time_delta,
'process': process
}, request)
elif 'votes for publishing' in context.state:
ballot = working_group.vp_ballot
today = datetime.datetime.now(tz=pytz.UTC)
if ballot.finished_at is not None and ballot.finished_at > today:
time_delta = ballot.finished_at - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(
self.step3_3_template, {
'context': context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration': time_delta,
'process': process,
'ballot_report': ballot.report
}, request)
elif 'votes for amendments' in context.state:
voters = []
[
voters.extend(b.report.voters)
for b in working_group.amendments_ballots
]
voters = list(set(voters))
ballot = working_group.amendments_ballots[-1]
today = datetime.datetime.now(tz=pytz.UTC)
if ballot.finished_at is not None and ballot.finished_at > today:
time_delta = ballot.finished_at - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(
self.step3_2_template, {
'context': context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration': time_delta,
'process': process,
'ballot_report': ballot.report,
'voters': voters
}, request)
elif 'open to a working group' in context.state:
participants_mini = getSite().participants_mini
work_mode = getattr(working_group, 'work_mode', None)
if work_mode:
participants_mini = work_mode.participants_mini
return renderers.render(
self.step3_0_template, {
'context': context,
'process': process,
'min_members': participants_mini
}, request)
return _('Information unvailable.')
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):
self.execute(None)
try:
navbars = generate_navbars(self.request, self.context)
except ObjectRemovedException:
return HTTPFound(self.request.resource_url(getSite(), ''))
user = get_current()
result = {}
textdiff = ''
# descriptiondiff = ''
# keywordsdiff = []
# proposal = self.context.proposal
textdiff = self.context.text_diff
# soup, descriptiondiff = html_diff_wrapper.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]
related_ideas = list(self.context.get_used_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)
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': navbars['navbar_body'],
'actions_bodies': navbars['body_actions'],
'footer_body': navbars['footer_body'],
'to_submit': self._end_explanation(navbars['all_actions']),
'idea_to_examine': idea_to_examine,
'not_published_ideas': not_published_ideas,
'not_favorable_ideas': not_favorable_ideas
}
self._add_requirements(user)
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]}
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()
result = {}
textdiff = ''
# descriptiondiff = ''
# keywordsdiff = []
# proposal = self.context.proposal
textdiff = self.context.text_diff
# soup, descriptiondiff = html_diff_wrapper.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]
related_ideas = list(self.context.get_used_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)
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': navbars['navbar_body'],
'actions_bodies': navbars['body_actions'],
'footer_body': navbars['footer_body'],
'to_submit': self._end_explanation(navbars['all_actions']),
'idea_to_examine': idea_to_examine,
'not_published_ideas': not_published_ideas,
'not_favorable_ideas': not_favorable_ideas
}
self._add_requirements(user)
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]}
result = merge_dicts(self.requirements_copy, result)
return result
def _get_step3_informations(self, context, request):
time_delta = None
working_group = context.working_group
process = working_group.improvement_cycle_proc
is_closed = 'closed' in working_group.state
user = get_current()
working_group_states = [_(get_states_mapping(user, working_group, s))
for s in working_group.state]
if 'amendable' in context.state and process:
subprocesses = process['work'].sub_processes
date_iteration = None
if subprocesses:
date_iteration = subprocesses[-1]['timer'].eventKind.time_date
today = datetime.datetime.now()
if date_iteration is not None and date_iteration > today:
time_delta = date_iteration - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(
self.step3_1_template,
{'context': context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration': time_delta,
'process': process},
request)
elif 'votes for publishing' in context.state:
ballot = working_group.vp_ballot
today = datetime.datetime.now(tz=pytz.UTC)
if ballot.finished_at is not None and ballot.finished_at > today:
time_delta = ballot.finished_at - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(
self.step3_3_template,
{'context': context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration': time_delta,
'process': process,
'ballot_report': ballot.report},
request)
elif 'votes for amendments' in context.state:
voters = []
[voters.extend(b.report.voters)
for b in working_group.amendments_ballots]
voters = list(set(voters))
ballot = working_group.amendments_ballots[-1]
today = datetime.datetime.now(tz=pytz.UTC)
if ballot.finished_at is not None and ballot.finished_at > today:
time_delta = ballot.finished_at - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(
self.step3_2_template,
{'context': context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration': time_delta,
'process': process,
'ballot_report': ballot.report,
'voters': voters},
request)
elif 'open to a working group' in context.state:
participants_mini = getSite().participants_mini
work_mode = getattr(working_group, 'work_mode', None)
if work_mode:
participants_mini = work_mode.participants_mini
return renderers.render(
self.step3_0_template,
{'context': context,
'process': process,
'min_members': participants_mini},
request)
return _('Information unvailable.')
def get_state(self, request, user):
return get_states_mapping(
user, self,
getattr(self, 'state_or_none', [None])[0])
def _get_step3_informations(self, context, request):
time_delta = None
process = context.creator
wg = context.working_group
is_closed = 'closed' in wg.state
user = get_current()
working_group_states = [_(get_states_mapping(user, wg, s)) \
for s in wg.state]
if any(s in context.state for s in ['proofreading','amendable']):
date_iteration = process['timer'].eventKind.time_date
today = datetime.datetime.today()
if date_iteration is not None and date_iteration > today:
time_delta = date_iteration - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(self.step3_1_template,
{'context':context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration':time_delta,
'process': process},
request)
elif 'votes for publishing' in context.state:
ballot = process.vp_ballot
today = datetime.datetime.today()
if ballot.finished_at is not None and ballot.finished_at > today:
time_delta = ballot.finished_at - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(self.step3_3_template,
{'context': context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration': time_delta,
'process': process,
'ballot_report': ballot.report},
request)
elif 'votes for amendments' in context.state:
voters = []
[voters.extend(b.report.voters) \
for b in process.amendments_ballots]
voters = list(set(voters))
ballot = process.amendments_ballots[-1]
today = datetime.datetime.today()
if ballot.finished_at is not None and ballot.finished_at > today:
time_delta = ballot.finished_at - today
time_delta = days_hours_minutes(time_delta)
return renderers.render(self.step3_2_template,
{'context':context,
'working_group_states': working_group_states,
'is_closed': is_closed,
'duration':time_delta,
'process': process,
'ballot_report': ballot.report,
'voters': voters},
request)
elif 'open to a working group' in context.state:
return renderers.render(self.step3_0_template,
{'context':context,
'process': process,
'min_members': getSite().participants_mini},
request)
return _('No more Information.')
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']
user = get_current()
is_censored = 'censored' in self.context.state
dace_catalog = find_catalog('dace')
container_oid = dace_catalog['containers_oids']
answers = find_entities(interfaces=[IAnswer],
user=user,
add_query=container_oid.any(
[get_oid(self.context)]))
len_answers = len(answers.ids)
index = str(len_answers)
if len_answers > 1:
index = '*'
answers_title = _(CONTENTS_MESSAGES[index],
mapping={'number': len_answers})
answer_body = None
if self.context.answer:
answer_body = render_listing_obj(self.request, self.context.answer,
user)
result = {}
values = {
'object':
self.context,
'state':
get_states_mapping(user, self.context, self.context.state[0]),
'current_user':
user,
'answers_title':
answers_title,
'navbar_body':
navbars['navbar_body'],
'actions_bodies':
navbars['body_actions'],
'footer_body':
navbars['footer_body'],
'support_actions_body':
navbars['support_actions_body'],
'vote_actions_body':
vote_actions['body'],
'answer_body':
answer_body,
'is_censored':
is_censored,
'to_hide':
is_censored
and not has_any_roles(user=user,
roles=(('Owner', self.context), 'Moderator'))
}
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