class View(core.View):
"""A numer of macros for use with seantis.dir.base"""
grok.context(Interface)
grok.require('zope2.View')
grok.name('seantis-dir-macros')
template = grok.PageTemplateFile('templates/macros.pt')
directory_template = grok.PageTemplateFile('templates/directory.pt')
def __getitem__(self, key):
if key == 'directory':
return self.directory_template._template.macros['directory']
return self.template._template.macros[key]
class ReservationList(BaseView, ReservationListView, ReservationUrls):
permission = "seantis.reservation.ViewReservations"
grok.name('reservations')
grok.require(permission)
grok.context(IResourceBase)
template = grok.PageTemplateFile('templates/reservations.pt')
@property
def group(self):
if 'group' in self.request:
return six.text_type(self.request['group'].decode('utf-8'))
else:
return u''
@property
def token(self):
""" Limits the list to the given reservation. """
return self.request.get('token', None)
@property
def print_site(self):
""" Returns true if the document should be printed when opening it. """
return self.request.get('print', None) is not None
@property
def body_classes(self):
if utils.is_uuid(self.reservation):
return ['single-reservation-view']
class YourReservations(ResourceBaseForm, YourReservationsData):
permission = "seantis.reservation.SubmitReservation"
grok.name('your-reservations')
grok.require(permission)
context_buttons = ('finish', )
grok.context(Interface)
css_class = 'seantis-reservation-form'
template = grok.PageTemplateFile('templates/your_reservations.pt')
@button.buttonAndHandler(_(u'Submit Reservations'), name="finish")
def finish(self, data):
def on_success():
self.request.response.redirect(self.context.absolute_url())
self.flash(_(u'Reservations Successfully Submitted'))
utils.handle_action(self.confirm_reservations, success=on_success)
@button.buttonAndHandler(_(u'Reserve More'), name="proceed")
def proceed(self, data):
# Don't do anything, reservations stay in the session.
self.request.response.redirect(self.context.absolute_url())
def update(self):
if 'remove' in self.request and utils.is_uuid(self.request['remove']):
self.remove_reservation(self.request['remove'])
self.request.response.redirect(self.context.absolute_url())
super(YourReservations, self).update()
class GroupView(grok.View, AllocationGroupView):
permission = 'zope2.View'
grok.context(IResourceBase)
grok.require(permission)
grok.name('group')
group = None
template = grok.PageTemplateFile('templates/group.pt')
def update(self, **kwargs):
self.group = self.request.get('name', u'').decode('utf-8')
self.recurrence_id = utils.request_id_as_int(
self.request.get('recurrence_id'))
def title(self):
return self.group
@property
def timespan_start(self):
return None
@property
def timespan_end(self):
return None
def render(self):
self.subject = 'Application to the Healthy Workplaces campaign'
self.template = grok.PageTemplateFile(
'templates/mail_organisation_created_siteowner.pt')
if not self.from_addr:
raise KeyError('email_from_address')
return self.template.render(self)
def render(self):
self.subject = 'Profile submitted'
self.template = grok.PageTemplateFile(
'templates/mail_organisation_submitted_siteowner.pt')
if not self.from_addr:
raise KeyError('email_from_address')
return self.template.render(self)
def render(self):
self.subject = 'Profile rejected'
self.template = grok.PageTemplateFile(
'templates/mail_mediapartner_rejected.pt')
if not self.from_addr:
raise KeyError('email_from_address')
return self.template.render(self)
class Utilsviewlet(BaseViewlet):
grok.context(Interface)
grok.name('seantis.reservation.utilslet')
grok.require('zope2.View')
grok.viewletmanager(OverviewletManager)
grok.order(10)
template = grok.PageTemplateFile('templates/utils.pt')
@property
def compare_link(self):
return utils.compare_link(self.manager.resource_uuids)
@property
def monthly_report_link(self):
return utils.monthly_report_link(self.context, self.request,
self.manager.resource_uuids)
@property
def latest_reservations_link(self):
return utils.latest_reservations_link(self.context, self.request,
self.manager.resource_uuids)
@property
def export_link(self):
return utils.export_link(self.context, self.request,
self.manager.resource_uuids)
class OrganizationView(BaseView):
grok.require('zope2.View')
grok.context(IOrganization)
grok.name('view')
template = grok.PageTemplateFile('templates/organization.pt')
event_fired = False
def suborganizations(self):
return [
(brain["Title"] if "Title" in brain else "", brain.getURL())
for brain in self.context.suborganizations()
]
def memberships(self):
memberships = []
for brain in self.context.memberships():
obj = brain.getObject()
person = obj.person.to_object
name = person.title if person else u''
memberships.append((obj.role, name, obj.prefix, brain.getURL()))
if self.context.display_alphabetically:
sortkey = lambda m: tools.unicode_collate_sortkey()(m[1])
memberships = sorted(memberships, key=sortkey)
return memberships
def update(self, **kwargs):
super(OrganizationView, self).update(**kwargs)
if not self.event_fired:
notify(ResourceViewedEvent())
self.event_fired = True
class TermsView(grok.View):
grok.name('terms')
grok.context(IEventsDirectory)
grok.require('zope2.View')
label = _(u'Terms and Conditions')
template = grok.PageTemplateFile('templates/terms.pt')
def render(self, parent):
self.subject = 'Content submitted'
self.content_type = self.context.Type()
self.parent_type = parent.Type()
self.parent_name = parent.Title()
self.template = grok.PageTemplateFile(
'templates/mail_content_submitted.pt')
return self.template.render(self)
class View(core.View):
"""A numer of macros for use with seantis.dir.base"""
grok.context(Interface)
grok.require('zope2.View')
grok.name('seantis-dir-macros')
template = grok.PageTemplateFile('templates/macros.pt')
class View(grok.View):
grok.context(Interface)
grok.require('zope2.View')
grok.name('meeting-macros')
template = grok.PageTemplateFile('templates/macros.pt')
def __getitem__(self, key):
return self.template._template.macros[key]
class ExtendedDirectoryViewlet(grok.Viewlet):
grok.context(IEventsDirectory)
grok.name('seantis.dir.events.directory.detail')
grok.require('zope2.View')
grok.viewletmanager(directory.DirectoryViewletManager)
template = grok.PageTemplateFile('templates/directorydetail.pt')
def __init__(self, *args, **kwargs):
super(ExtendedDirectoryViewlet, self).__init__(*args, **kwargs)
def render(self, username, created):
self.username = username
self.subject = 'Profile approved'
self.template = grok.PageTemplateFile(
'templates/mail_approve_media_partner.pt')
self.created = created
reset_tool = getToolByName(self, 'portal_password_reset')
membership = getToolByName(self, 'portal_membership')
member = membership.getMemberById(username)
self.reset = reset_tool.requestReset(member.getId())
return self.template.render(self)
class XlsExportsView(grok.View):
"""Shows a list of possible exports."""
grok.context(IDirectoryBase)
grok.require('cmf.ModifyPortalContent')
grok.name('exports')
_template = grok.PageTemplateFile('templates/exports.pt')
def title(self):
return ' '.join((_(u'Exports for'), self.context.title))
@cached_property
def providers(self):
providers = []
for provider in subscribers([self.context], IExportProvider):
if provider.layer:
if not provider.layer.providedBy(self.request):
continue
providers.append(provider)
return providers
def exports(self):
ExportDefinition = namedtuple('ExportDefinition',
('url', 'title', 'description'))
exports = []
for provider in self.providers:
url = provider.url or ''.join(
(self.url(), '?export-id=', provider.id))
exports.append(
ExportDefinition(
url=url,
title=utils.translate(self.context, self.request,
provider.title),
description=utils.translate(self.context, self.request,
provider.description)))
return exports
def render(self):
id = self.request.get('export-id', None)
for provider in self.providers:
if provider.id == id:
return provider.export(self.request)
return self._template.render(self)
class OrganizationView(BaseView):
grok.require('zope2.View')
grok.context(IMembership)
grok.name('view')
template = grok.PageTemplateFile('templates/membership.pt')
def person(self):
person = self.context.person.to_object
if person:
return [person.title, person.absolute_url()]
return [u'', u'']
class ExportListView(grok.View, form.ResourceParameterView):
"""Shows the available exports for the resource. """
permission = 'seantis.reservation.ViewReservations'
grok.require(permission)
grok.context(Interface)
grok.name('reservation-exports')
template = grok.PageTemplateFile('templates/reservation_exports.pt')
title = _(u'Export Reservations')
def exports(self):
return get_exports(self.context, self.request, self.uuids)
class GroupView(BaseView, AllocationGroupView):
permission = 'zope2.View'
grok.context(IResourceBase)
grok.require(permission)
grok.name('group')
group = None
template = grok.PageTemplateFile('templates/group.pt')
def update(self, **kwargs):
self.group = self.request.get('name', u'').decode('utf-8')
def title(self):
return self.group
class View(grok.View, ReservationUrls, ReservationDataView):
"""A numer of macros for use with seantis.dir.base"""
grok.context(Interface)
grok.require('zope2.View')
grok.name('seantis-reservation-macros')
template = grok.PageTemplateFile('templates/macros.pt')
def __getitem__(self, key):
return self.template._template.macros[key]
@property
def utils(self):
return utils
class YourReservationsViewlet(grok.Viewlet, YourReservationsData):
grok.context(Interface)
grok.name('seantis.reservation.YourReservationsviewlet')
grok.require('zope2.View')
grok.viewletmanager(OverviewletManager)
grok.order(0)
template = grok.PageTemplateFile('templates/your_reservations_viewlet.pt')
def available(self):
return self.has_reservations
def finish_url(self):
return self.context.absolute_url() + '/your-reservations'
class Listing(BaseView):
permission = 'zope2.View'
implements(IOverview)
grok.context(IATFolder)
grok.require(permission)
grok.name('resource_listing')
template = grok.PageTemplateFile('templates/listing.pt')
def list_item(self, item):
return item.portal_type == 'seantis.reservation.resource'
def resource_map(self):
return (r.UID for r in utils.portal_type_in_context(
self.context, 'seantis.reservation.resource'))
class YourReservations(ResourceBaseForm, YourReservationsData):
permission = "seantis.reservation.SubmitReservation"
grok.name('your-reservations')
grok.require(permission)
context_buttons = ('finish', )
standalone_buttons = ('cancel', )
grok.context(Interface)
css_class = 'seantis-reservation-form'
template = grok.PageTemplateFile('templates/your_reservations.pt')
@button.buttonAndHandler(_(u'Submit Reservations'), name="finish")
def finish(self, data):
resources = self.resources()
def on_success():
self.request.response.redirect(
'{context}/thank-you-for-reserving?uuid={uuids}'.format(
context=self.context.absolute_url(),
uuids='&uuid='.join(resources)))
utils.handle_action(self.confirm_reservations, success=on_success)
# the button's name is 'cancel' because it should behave like a cancel
# button in the browser (namely, it should not refetch the events)
@button.buttonAndHandler(_(u'Reserve More'), name="cancel")
def proceed(self, data):
# Don't do anything, reservations stay in the session.
self.request.response.redirect(self.context.absolute_url())
def update(self):
if 'remove' in self.request and utils.is_uuid(self.request['remove']):
self.remove_reservation(self.request['remove'])
self.request.response.redirect(self.context.absolute_url())
super(YourReservations, self).update()
class TemplatesViewlet(BaseViewlet):
permission = 'cmf.ModifyPortalContent'
grok.context(IFolderish)
grok.require(permission)
grok.name('seantis.reservation.mailviewlet')
grok.viewletmanager(OverviewletManager)
grok.order(4)
_template = grok.PageTemplateFile('templates/email_templates.pt')
@view.memoize
def templates(self):
templates = [
t.getObject() for t in utils.portal_type_in_context(
self.context, portal_type='seantis.reservation.emailtemplate')
]
return sorted(templates, key=lambda t: t.title)
def links(self, template=None):
# global links
if not template:
baseurl = self.context.absolute_url()
return [(_(u'Add email template'),
baseurl + '/++add++seantis.reservation.emailtemplate')]
# template specific links
links = []
baseurl = template.absolute_url()
links.append((_(u'Edit'), baseurl + '/edit'))
links.append((_(u'Delete'), baseurl + '/delete_confirmation'))
return links
def render(self, **kwargs):
return self._template.render(self)
class ThankYouPage(BaseView, ResourceParameterView):
grok.context(Interface)
grok.require('zope2.View')
grok.name('thank-you-for-reserving')
template = grok.PageTemplateFile('templates/thankyoupage.pt')
@property
def current_url(self):
return self.request.ACTUAL_URL + "?" + self.request.QUERY_STRING
def infoblocks(self):
blocks = []
for resource in self.resources.values():
text = (getattr(resource, 'thank_you_text', None) or u'').strip()
if text:
blocks.append((utils.get_resource_title(resource), text))
return blocks
class LatestReservationsReportView(grok.View, GeneralReportParametersMixin):
permission = 'seantis.reservation.ViewReservations'
grok.require(permission)
grok.context(Interface)
grok.name('latest_reservations')
template = grok.PageTemplateFile('../templates/latest_reservations.pt')
@property
def title(self):
return _(u'Reservations in the last 30 days')
@property
def results(self):
return latest_reservations(self.resources, self.reservations or '*')
def reservation_title(self, reservation):
human_date_text = utils.translate(self.context, self.request,
human_date(reservation.created))
return '{} - {}'.format(human_date_text, reservation.title)
class ReservationList(grok.View, ReservationListView, ReservationUrls):
permission = "seantis.reservation.ViewReservations"
grok.name('reservations')
grok.require(permission)
grok.context(IResourceBase)
template = grok.PageTemplateFile('templates/reservations.pt')
#XXX maybe move to ReservationList
def all_reservations(self):
query = super(ReservationList, self).all_reservations()
if query:
return query
if self.recurring_allocation_id:
scheduler = self.context.scheduler()
return scheduler.reservations_by_recurring_allocation(
self.recurring_allocation_id)
return None
def all_allocations(self):
query = super(ReservationList, self).all_allocations()
if query:
return query
if self.recurring_allocation_id:
return Session.query(Allocation).filter_by(
id=self.recurring_allocation_id)
return None
def reservations_by_recurring_allocation(self):
"""Find reservations that target a recurring allocation
"""
allocation_id = self.recurring_allocation_id
allocation = Session.query(Allocation).get(allocation_id)
if not allocation:
return None
reservation_tokens = [each.reservation_token for each
in allocation.reserved_slots]
return Session.query(Reservation).filter(
Reservation.token.in_(reservation_tokens))
@property
def recurring_allocation_id(self):
allocation_id = self.request.get('recurring_allocation_id')
return utils.request_id_as_int(allocation_id)
@property
def id(self):
return utils.request_id_as_int(self.request.get('id'))
@property
def group(self):
if 'group' in self.request:
return unicode(self.request['group'].decode('utf-8'))
else:
return u''
@property
def reservation(self):
""" Limits the list to the given reservation. """
return self.request.get('reservation', None)
@property
def print_site(self):
""" Returns true if the document should be printed when opening it. """
return self.request.get('print', None) is not None
class TimeframeViewlet(BaseViewlet):
permission = 'cmf.ModifyPortalContent'
grok.context(IFolderish)
grok.require(permission)
grok.name('seantis.reservation.timeframeviewlet')
grok.viewletmanager(OverviewletManager)
grok.order(3)
_template = grok.PageTemplateFile('templates/timeframes.pt')
@property
def workflowTool(self):
return getToolByName(self.context, "portal_workflow")
@view.memoize
def timeframes(self):
frames = [t.getObject() for t in timeframes_in_context(self.context)]
return sorted(frames, key=lambda f: f.start)
@property
@view.memoize
def titles(self):
"""Returns a dict with titles keyed by review_state. The workflow-tool
has a getTitleForStateOnType function which should do that but
it does not return updated values for me, just some old ones.
The listWFStatesByTitle function on the other hand contains
the right information and I will just use that instead.
Once this breaks I'll read the source of the workflow tool, until this
happens I'm off to do useful things.
"""
titles = self.workflowTool.listWFStatesByTitle()
return dict(((t[1], t[0]) for t in titles))
def state(self, timeframe):
state = self.workflowTool.getStatusOf(
"timeframe_workflow", timeframe
)['review_state']
title = self.titles[state]
return state, utils.translate_workflow(
self.context, self.request, title
)
def render(self, **kwargs):
if self.context is None:
return u''
return self._template.render(self)
def visible(self, frame):
state = self.state(frame)[0]
return state == 'visible'
def links(self, frame=None):
# global links
if not frame:
baseurl = self.context.absolute_url()
return [(_(u'Add timeframe'),
baseurl + '/++add++seantis.reservation.timeframe')]
# frame specific links
links = []
action_tool = getToolByName(frame, 'portal_actions')
actions = action_tool.listFilteredActionsFor(frame)['workflow']
for action in actions:
if action['visible'] and action['available']:
action['title'] = utils.translate_workflow(
self.context, self.request, action['title']
)
links.append((action['title'], action['url']))
baseurl = frame.absolute_url()
links.append((_(u'Edit'), baseurl + '/edit'))
links.append((_(u'Delete'), baseurl + '/delete_confirmation'))
return links
def render(self):
self.subject = 'Profile finalised'
self.template = grok.PageTemplateFile(
'templates/mail_organisation_submitted_creator.pt')
return self.template.render(self)
def render(self):
self.subject = 'Application to the Healthy Workplaces campaign'
self.template = grok.PageTemplateFile(
'templates/mail_organisation_created_creator.pt')
return self.template.render(self)
