class FileListingView(FileListingMixin, browser.BungeniBrowserView):
__call__ = ViewPageTemplateFile("templates/listing-view.pt")
_page_title = "Attachments"
def __init__(self, context, request):
browser.BungeniBrowserView.__init__(self, context.__parent__, request)
FileListingMixin.__init__(self)
self._page_title = _(self.__class__._page_title)
class BungeniRSSEventView(BrowserView):
__call__ = ViewPageTemplateFile('templates/rss-event-view.pt')
form_name = None
# Required channel elements:
def rssTitle(self):
"""title The name of the channel.
It's how people refer to your service.
If you have an HTML website that contains the same information as your RSS file,
the title of your channel should be the same as the title of your website.
"""
return self.context.short_name
def rssDescription(self):
"""description
Phrase or sentence describing the channel.
"""
return self.context.summary
def rssLink(self):
"""link
The URL to the HTML website corresponding to the channel.
"""
return url.absoluteURL(self.context, self.request)
# items of a channel:
def rssItems(self):
"""Elements of <item>
A channel may contain any number of <item>s.
An item may represent a "story" -- much like a story in a newspaper or magazine;
if so its description is a synopsis of the story, and the link points to the full story.
An item may also be complete in itself, if so, the description contains the text (entity-encoded HTML is allowed;
see examples), and the link and title may be omitted.
All elements of an item are optional,
however at least one of title or description must be present.
title The title of the item.
link The URL of the item.
description The item synopsis.
pubDate Indicates when the item was published.
"""
bill_id = self.context.bill_id
results = queries.execute_sql(statements.sql_bill_timeline,
item_id=bill_id)
path = url.absoluteURL(self.context, self.request)
rlist = []
for result in results:
rlist.append({
'title': result.atype,
'description': result.title,
'date': result.adate.isoformat()
})
return rlist
class GroupSittingsViewlet(browser.BungeniItemsViewlet):
"""Display the sittings of a group.
Note 1: to be able to customize the URL for each sitting, this custom
viewlet replaces the previous model-introspected container listing:
class GroupSittingsViewlet(SubformViewlet):
sub_attr_name = "sittings"
so replacing a url of the form:
.../committees/obj-59/sittings/obj-17/
with: /business/sittings/obj-17
Note 2: this viewlet should probably be merged or better share the
implementation at: ui.workspace.DraftSittingsViewlet
!+CustomListingURL(mr, oct-2010) an alternative way to do this is to
essentially stuff all the logic below into a custom column_listing to be
used when listing the column -- for an example of this see how the
listing of the column "owner_id" (moved by) is configured in:
descriptor.ParliamentaryItemDescriptor
!+ManagedContainer(mr, oct-2010) this would have been a lot simpler if
the Group.sittings attribute was simply returning the list of sitting
objects.
"""
render = ViewPageTemplateFile("templates/group-sittings-viewlet.pt")
def _get_items(self):
def _format_from_to(item):
start = item.start_date
if start:
start = dt_formatter.format(start)
end = item.end_date
if end:
end = t_formatter.format(end)
return u"%s - %s" % (start, end)
dt_formatter = self.get_date_formatter("dateTime", "medium")
t_formatter = self.get_date_formatter("time", "medium")
def _format_venue(item):
return item.venue and _(item.venue.short_name) or ""
#
trusted_context = removeSecurityProxy(self.context)
sittings = Session().query(domain.GroupSitting).filter(
domain.GroupSitting.group == trusted_context).order_by(
domain.GroupSitting.start_date.desc())
return [{
"url": "/business/sittings/obj-%s" % (item.group_sitting_id),
"date_from_to": _format_from_to(item),
"venue": _format_venue(item)
} for item in sittings]
def update(self):
self.items = self._get_items()
class DefaultReportView(BrowserView):
template = ViewPageTemplateFile("templates/default-report.pt")
def __init__(self, context, request):
self.context = context
self.request = request
def __call__(self):
return self.template()
class HansardView(BrowserView):
template = ViewPageTemplateFile("templates/hansard.pt")
def __call__(self):
self.context = removeSecurityProxy(self.context)
return self.render()
def render(self):
need("hansard-css")
return self.template()
class BungeniContentPDF(DownloadDocument):
oo_template_file = os.path.dirname(__file__) + "/templates/bungenicontent.odt"
template = ViewPageTemplateFile("templates/bungeni-content.pt")
document_type = "pdf"
def bodyText(self):
if not hasattr(self.document,"group"):
session = Session()
self.document.group = session.query(domain.Group).get(self.document.parliament_id)
return self.template()
class DisplayForm(browser.BungeniBrowserView):
"""Content Display
"""
#template = z3evoque.PageViewTemplateFile("content.html#view")
template = ViewPageTemplateFile("templates/content-view.pt")
form_name = _("View")
def __call__(self):
return self.template()
def __init__(self,
filename,
contentType='text/html',
form=None,
request=None):
self.template = ViewPageTemplateFile(filename,
content_type=contentType)
zope.component.adapter(util.getSpecification(form),
util.getSpecification(request))(self)
zope.interface.implementer(IPageTemplate)(self)
class SearchViewlet(object):
render = ViewPageTemplateFile("templates/search.pt")
def update(self):
section = get_section_name()
base_url = abs_url(getSite(), self.request)
if not section:
section = 'business'
self.action = urljoin(base_url, section) + '/search'
class GroupSittingScheduleView(BrowserView):
template = ViewPageTemplateFile("templates/scheduler.pt")
def __init__(self, context, request):
super(GroupSittingScheduleView, self).__init__(context, request)
def sitting_dates(self):
date_formatter = date.getLocaleFormatter(self.request)
time_formatter = date.getLocaleFormatter(self.request, "time", "short")
delta = self.context.end_date - self.context.start_date
if delta.days == 0:
localized_start_date = "%s - %s" %(
date_formatter.format(self.context.start_date),
time_formatter.format(self.context.start_date)
)
localized_end_date = time_formatter.format(self.context.end_date)
else:
localized_start_date = "%s, %s" %(
date_formatter.format(self.context.start_date),
time_formatter.format(self.context.start_date)
)
localized_end_date = "%s, %s" %(
date_formatter.format(self.context.end_date),
time_formatter.format(self.context.end_date)
)
return _("${localized_start_date} to ${localized_end_date}",
mapping = {
"localized_start_date" : localized_start_date,
"localized_end_date" : localized_end_date,
}
)
def __call__(self):
return self.render()
def needed_resources(self):
"""Permission aware resource dependency generation.
Determines what user interface is rendered for the sitting.
See resource definitions in `bungeni.ui.resources` inside
`configure.zcml`.
"""
needed = None
for resource, permission in RESOURCE_PERMISSION_MAP:
if checkPermission(permission, self.context):
needed = resource
break
return needed
def render(self):
_needed = self.needed_resources()
if len(_needed):
map(need, _needed)
return self.template()
class DhtmlxCalendarSittings(BrowserView):
"""This view returns xml of the sittings for the week and group
requested in a format acceptable by DHTMLX scheduler"""
interface.implements(IStructuralView)
content_mimetype = "text/xml"
template = ViewPageTemplateFile('templates/dhtmlxcalendarxml.pt')
def __init__(self, context, request):
super(DhtmlxCalendarSittings,
self).__init__(ISchedulingContext(context), request)
self.context.__name__ = self.__name__
interface.alsoProvides(self.context, ILocation)
interface.alsoProvides(self.context, IDCDescriptiveProperties)
self.__parent__ = context
def __call__(self):
try:
date = self.request.get('from')
dateobj = datetime.datetime(*time.strptime(date, "%Y-%m-%d")[0:5])
start_date = utils.datetimedict.fromdate(dateobj)
except:
start_date = None
try:
date = self.request.get('to')
dateobj = datetime.datetime(*time.strptime(date, "%Y-%m-%d")[0:5])
end_date = utils.datetimedict.fromdate(dateobj)
except:
end_date = None
if start_date is None:
start_date = utils.datetimedict.fromdate(datetime.date.today())
days = tuple(start_date + timedelta(days=d) for d in range(7))
end_date = days[-1]
elif end_date is None:
start_date = utils.datetimedict.fromdate(datetime.date.today())
days = tuple(start_date + timedelta(days=d) for d in range(7))
end_date = days[-1]
sittings = self.context.get_sittings(
start_date,
end_date,
)
self.sittings = []
for sitting in sittings.values():
if checkPermission("zope.View", sitting):
trusted = removeSecurityProxy(sitting)
trusted.text = dict(sitting_status=_(
misc.get_wf_state(trusted, trusted.status)))
self.sittings.append(trusted)
self.request.response.setHeader('Content-type', self.content_mimetype)
return self.render()
def render(self, template=None):
return self.template()
class SignOpenDocumentForm(PageForm):
"""Provides a form to allow signing of a document open for signatures
"""
form_template = NamedTemplate("alchemist.form")
template = ViewPageTemplateFile("templates/sign-open-document.pt")
form_fields = formlib.form.Fields()
@property
def action_message(self):
if self._can_sign_document(None):
return _("Please confirm that you wish to sign" " this document")
elif self._can_review_signature(None):
return _(u"You have already signed this document")
else:
return _(u"You may not sign this document")
def _can_sign_document(self, action):
manager = ISignatoryManager(self.context)
return manager.can_sign()
def _can_review_signature(self, action):
manager = ISignatoryManager(self.context)
return manager.is_signatory(get_db_user_id())
def redirect_to_review(self):
self.request.response.redirect("./signatory-review")
def nextURL(self):
return url.absoluteURL(self.context, self.request)
@formlib.form.action(_(u"Sign Document"),
name="sign_document",
condition=_can_sign_document)
def handle_sign_document(self, action, data):
user_id = get_db_user_id()
manager = ISignatoryManager(self.context)
manager.sign_document(user_id)
self.request.response.redirect(self.nextURL())
@formlib.form.action(_(u"Review Signature"),
name="review_signature",
condition=_can_review_signature)
def handle_review_signature(self, action, data):
self.redirect_to_review()
@formlib.form.action(_(u"Cancel"),
name="cancel",
validator=ui.null_validator)
def handle_cancel(self, action, data):
self.request.response.redirect(self.nextURL())
def __call__(self):
if self._can_review_signature(None):
self.redirect_to_review()
return super(SignOpenDocumentForm, self).__call__()
class VersionLibraryViewlet(LibraryViewlet):
render = ViewPageTemplateFile('templates/version-attached-files.pt')
def __init__(self, context, request, view, manager):
super(VersionLibraryViewlet, self).__init__(context, request, view,
manager)
self.base_url = ui_utils.url.absoluteURL(
self.__parent__.__parent__.__parent__, self.request)
def results(self):
session = Session()
for data in self.context:
file_type = session.query(AttachedFileType)\
.filter(AttachedFileType.attached_file_type_id == data.attached_file_type_id)\
.first()
if file_type is None:
file_type_name = ' - '
else:
file_type_name = translate_obj(
file_type).attached_file_type_name
if file_type_name == "system":
continue
yield {'title': data.file_title,
'url': self.base_url + '/files/obj-%i/versions/obj-%i' \
% (data.content_id, data.version_id),
'name': data.file_name,
'type': file_type_name,
'status_date': self.formatter.format(data.status_date),
'menu': self.generate_file_manipulation_menu(data)}
def create_view_menu_item(self, context):
permission_name = 'bungeni.fileattachment.View'
if self.interaction.checkPermission(permission_name, self.__parent__):
return {'title': _(u'VIEW'),
'url': '%s/files/obj-%i/versions/obj-%i' % \
(self.base_url, context.content_id, context.version_id)}
return None
def create_edit_menu_item(self, context):
# Edit menu item should not be provided for versions
return None
def create_delete_menu_item(self, context):
# Delete menu item should not be provided for versions
return None
def create_download_menu_item(self, context):
permission_name = 'bungeni.fileattachment.View'
if self.interaction.checkPermission(permission_name, self.__parent__):
return {'title': _(u'DOWNLOAD'),
'url': '%s/files/obj-%i/versions/obj-%i/download' % \
(self.base_url, context.content_id, context.version_id)}
return None
class TimeLineViewlet(AuditLogMixin, browser.BungeniItemsViewlet):
view_title = "Timeline"
view_id = "timeline"
weight = 200
render = ViewPageTemplateFile("templates/listing-viewlet.pt")
def __init__(self, context, request, view, manager):
browser.BungeniItemsViewlet.__init__(self, context, request, view, manager)
AuditLogMixin.__init__(self)
self.view_title = _(self.__class__.view_title)
class ErrorPage(BungeniBrowserView):
template = ViewPageTemplateFile("templates/error-page.pt")
def __init__(self, context, request, error):
self.error = error
super(ErrorPage, self).__init__(context, request)
def __call__(self):
self.error_message = self.error.error_description
return self.template()
class ReportPreview(object):
"""Blocked UI processing message."""
render = ViewPageTemplateFile("templates/report_preview.pt")
def update(self):
self.report_preview = self._parent.generated_content
@property
def available(self):
return self._parent.show_preview
def handle_restore(self, action, data):
site_url = ui_utils.url.absoluteURL(getSite(), self.request)
login = data.get("login", "")
email = data.get("email", "")
user = None
app = BungeniApp()
settings = EmailSettings(app)
session = Session()
if email:
user = session.query(User).filter(
User.email==email).first()
elif login:
user = session.query(User).filter(
User.login==login).first()
if user:
email = user.email
link = session.query(PasswordRestoreLink).filter(
PasswordRestoreLink.user_id==user.user_id).first()
if link:
if not link.expired():
self.status = _(u"This user's link is still active!")
return
else:
link = PasswordRestoreLink()
link.hash = hashlib.sha224(user.login +
SECRET_KEY +
str(datetime.datetime.now())).hexdigest()
link.expiration_date = datetime.datetime.now() + datetime.timedelta(1)
link.user_id = user.user_id
session.add(link)
mailer = getUtility(ISMTPMailer, name="bungeni.smtp")
self.message = _(u"Restore password link: ")\
+ "%s/reset_password?key=%s" % (site_url, link.hash)
self.message += u"\n\n"
self.message += _(u"This link will expire in 24 hours.")
text = ViewPageTemplateFile("templates/mail.pt")(self)
message = MIMEText(text)
message.set_charset("utf-8")
message["Subject"] = _(u"Bungeni password restoration")
message["From"] = settings.default_sender
mailer.send(settings.default_sender, email, str(message))
self.status = _(u"Email was sent!")
else:
self.status = _(u"User not found!")
class GenerateTakesViewlet(object):
available = True
render = ViewPageTemplateFile("templates/debate-takes.pt")
def __init__(self, context, request, view, manager):
self.context = context
self.request = request
trusted = removeSecurityProxy(self.context)
if len(trusted.__parent__.debate_takes) > 0:
self.available = False
def update(self):
self.form = GenerateDebateRecordTakes(self.context, self.request)
def cook_template(self, fname):
if fname in self.cookedTemplates:
return self.cookedTemplates[fname]
cooked = ViewPageTemplateFile(fname)
try:
# don't block, we'll just cache it later
if self.__thread_lock.acquire(False):
self.cookedTemplates[fname] = cooked
finally:
self.__thread_lock.release()
return cooked
class WorkspaceContextNavigation(StructureAwareViewlet):
render = ViewPageTemplateFile("templates/workspace.pt")
def update(self):
self.tabs = []
app = getSite()
keys = app["workspace"]["documents"].keys()
for key in keys:
tab = {}
tab["title"] = key
tab["url"] = url.absoluteURL(app["workspace"]["documents"][key], self.request)
self.tabs.append(tab)
class SearchResults(browser.BungeniViewlet):
"""Report preview."""
render = ViewPageTemplateFile("results.pt")
def update(self):
if self.available:
self.search_results = self._parent.search_results
@property
def available(self):
return (isinstance(self._parent, Search) and
self._parent.show_results)
class JournalTab(grok.View, OpengeverTab, ListingView):
"""Journal tab implementing IJorunalConfig.
"""
implements(IJournalSourceConfig)
grok.name('tabbedview_view-journal')
grok.require('zope2.View')
grok.context(IJournalizable)
# do not select
select_all_template = lambda *a, **kw: ''
sort_on = 'time'
sort_reverse = True
# do not show the selects, because no action is enabled
show_selects = False
enabled_actions = []
major_actions = []
selection = ViewPageTemplateFile("no_selection_amount.pt")
columns = (
{
'column': 'title',
'column_title': _(u'label_title', 'Title'),
'transform': title_helper
},
{
'column': 'actor',
'column_title': _(u'label_actor', default=u'Actor'),
'transform': linked_ogds_author
},
{
'column': 'time',
'column_title': _(u'label_time', default=u'Time'),
'transform': helper.readable_date_time
},
{
'column': 'comments',
'column_title': _(u'label_comments', default=u'Comments'),
'transform': tooltip_helper
},
)
def get_base_query(self):
return None
__call__ = ListingView.__call__
update = ListingView.update
render = __call__
class TakesXML(BrowserView):
template = ViewPageTemplateFile("templates/takesxml.pt")
def __call__(self):
rendered = self.render()
return rendered
def render(self):
self.sittings = self.get_sittings()
self.request.response.setHeader('Content-type', 'text/xml')
return self.template()
def get_sittings(self):
session = Session()
logged_in_user = get_db_user()
title = get_title_of_user(logged_in_user.user_id)
sittings = session.query(domain.GroupSitting).join((domain.Assignment,
domain.GroupSitting.sitting_id
== domain.Assignment.sitting_id)) \
.filter(sql.and_(domain.GroupSitting.status == 'draft_minutes',
domain.Assignment.staff_id == logged_in_user.user_id)) \
.options( eagerload("hansard"),
eagerload("hansard.media_paths")).all()
for sitting in sittings:
if title == "Editor":
takes = session.query(domain.Take)\
.filter(sql.and_(domain.Take.editor_id == logged_in_user.user_id,
domain.Take.sitting_id == sitting.sitting_id)) \
.order_by(domain.Take.start_date).all()
elif title == "Reader":
takes = session.query(domain.Take)\
.filter(sql.and_(domain.Take.reader_id == logged_in_user.user_id,
domain.Take.sitting_id == sitting.sitting_id)) \
.order_by(domain.Take.start_date).all()
elif title == "Reporter":
takes = session.query(domain.Take)\
.filter(sql.and_(domain.Take.reporter_id == logged_in_user.user_id,
domain.Take.sitting_id == sitting.sitting_id)) \
.order_by(domain.Take.start_date).all()
for take in takes:
take.start_time = take.start_date - sitting.start_date
take.end_time = take.end_date - sitting.start_date
sitting.takes = takes
if sitting.hansard.media_paths:
sitting.file = sitting.hansard.media_paths.web_optimised_video_path
else:
sitting.file = ""
sitting.name = sitting.group.short_name + str(
sitting.start_date.strftime('%d-%B-%Y %H:%M'))
return sittings
class AgendaReportingView(ReportingView):
"""Agenda report"""
form_name = _(u"Agenda")
report_name = _(u"ORDER OF THE DAY")
form_description = _(u"This form generates the agenda report")
odf_filename = "agenda.odt"
display_minutes = False
main_result_template = ViewPageTemplateFile('main_reports.pt')
result_template = ViewPageTemplateFile('reports.pt')
def get_sittings_items(self, start, end):
""" return the sittings with scheduled items for
the given daterange"""
session = Session()
query = session.query(domain.GroupSitting).filter(
sql.and_(domain.GroupSitting.start_date.between(start, end),
domain.GroupSitting.group_id ==
self.context.group_id)).order_by(
domain.GroupSitting.start_date).options(
eagerload('sitting_type'),
eagerload('item_schedule'),
eagerload('item_schedule.item'),
eagerload('item_schedule.discussion'),
eagerload('item_schedule.category'))
items = query.all()
#items.sort(key=operator.attrgetter('start_date'))
for item in items:
if self.display_minutes:
item.item_schedule.sort(key=operator.attrgetter('real_order'))
else:
item.item_schedule.sort(
key=operator.attrgetter('planned_order'))
item.sitting_type.sitting_type = item.sitting_type.sitting_type.capitalize(
)
#s = queries.get_session_by_date_range(self, item.start_date, item.end_date)
return items
class Contacts(OpengeverCatalogListingTab):
""" Listing of all Task of the authenticated Member """
grok.name('tabbedview_view-local')
grok.context(IDexterityContainer)
types = [
'opengever.contact.contact',
]
columns = (
{
'column': 'lastname',
'column_title': _(u'label_lastname', default=u'Lastname'),
'transform': linked
},
{
'column': 'firstname',
'column_title': _(u'label_firstname', default=u'Firstname'),
'transform': linked_no_icon
},
{
'column': 'email',
'column_title': _(u'label_email', default=u'email'),
'transform': email_helper
},
{
'column': 'phone_office',
'column_title': _(u'label_phone_office', default=u'Phone office')
},
)
sort_on = 'lastname'
sort_order = ''
show_selects = False
enabled_actions = []
major_actions = []
selection = ViewPageTemplateFile("no_selection_amount.pt")
def update_config(self):
OpengeverCatalogListingTab.update_config(self)
# configuration for the extjs grid
extjs_conf = {'auto_expand_column': 'lastname'}
if isinstance(self.table_options, dict):
self.table_options.update(extjs_conf)
elif self.table_options is None:
self.table_options = extjs_conf.copy()
class SchedulablesViewlet(viewlet.ViewletBase):
"""Renders a portlet which calls upon the scheduling viewlet
manager to render a list of schedulable items."""
for_display = True
render = ViewPageTemplateFile('templates/scheduling.pt')
title = _(u"Scheduling")
def __init__(self, context, request, view, manager):
while not ISchedulingContext.providedBy(context):
context = ISchedulingContext(context, context.__parent__)
if context is None:
raise RuntimeError("Unable to locate a scheduling context.")
super(SchedulablesViewlet, self).__init__(context, request, view,
manager)
class LibraryViewlet (viewlet.ViewletBase):
render = ViewPageTemplateFile ('templates/attached-files.pt')
form_name = _(u"attached files")
for_display = True
def __init__( self, context, request, view, manager ):
trusted = removeSecurityProxy(context)
self.context = trusted.attached_files
self.request = request
self.__parent__= context
self.manager = manager
self.query = None
self.for_display = len(self.context) > 0
def results(self):
return self.context
class FileListingViewlet(FileListingMixin, browser.BungeniItemsViewlet):
"""Viewlet to list attachments of a given document (head).
"""
# An Attachment is a record in the attachment table.
render = ViewPageTemplateFile("templates/listing-viewlet.pt")
view_title = "Attachments"
view_id = "attachments"
weight = 50
def __init__(self, context, request, view, manager):
browser.BungeniItemsViewlet.__init__(self, context, request, view, manager)
FileListingMixin.__init__(self)
self.view_title = _(self.__class__.view_title)
self.for_display = True # bool(self.file_data_items)
class TimeLineViewlet(AuditLogMixin, browser.BungeniItemsViewlet):
view_title = "Timeline"
view_id = "timeline"
weight = 20
render = ViewPageTemplateFile("templates/listing-viewlet.pt")
visible_column_names = ["action date", "description", "user"]
include_change_types = [ t for t in CHANGE_TYPES ]
include_change_actions = [ a for a in CHANGE_ACTIONS if not a == "modify" ]
def __init__(self, context, request, view, manager):
browser.BungeniItemsViewlet.__init__(self, context, request, view, manager)
AuditLogMixin.__init__(self)
self.view_title = _(self.__class__.view_title)
class OfficesHeldViewlet( viewlet.ViewletBase ):
for_display = True
def __init__( self, context, request, view, manager ):
self.context = context
self.request = request
self.__parent__= view
self.manager = manager
self.query = None
def get_offices_held(self):
office_list=[]
for oh in self.offices_held:
title = {}
title['group'] = oh[0] + ' - ' + (oh[1] or'')
title['group_type'] = oh[2].capitalize()
if oh[3]:
title['member_title'] = oh[3]
else:
title['member_title'] = _(u"Member")
if oh[4]:
title['start_date'] = oh[4]
else:
title['start_date'] = oh[6]
if oh[5]:
title['end_date'] = oh[5]
else:
title['end_date'] = oh[7]
office_list.append(title)
return office_list
def update(self):
"""
refresh the query
"""
trusted = removeSecurityProxy(self.context)
user_id = trusted.user_id
if interfaces.IMemberOfParliament.providedBy(self.context):
parliament_id = trusted.group_id
else:
parliament = get_parliament_for_group_id(trusted.group_id)
if parliament:
parliament_id = parliament.parliament_id
self.offices_held = get_offices_held_for_user_in_parliament(
user_id, parliament_id)
render = ViewPageTemplateFile ('templates/offices_held_viewlet.pt')
