class BaseView(grok.View):
grok.baseclass()
grok.layer(ISeantisReservationSpecific)
def translate(self, text):
return tools.translator(self.request, 'seantis.reservation')(text)
class DocPropertyProvider(grok.Adapter):
"""Baseclass for DocPropertyProviders.
Contains utility methods to create a dict of doc-properties. Set the NS
class attribute to define a namespace. All your property-values written
with _add_property will be prefixed with that namespace.
"""
grok.baseclass()
grok.provides(IDocPropertyProvider)
NS = tuple()
def _add_property(self, properties, name, value):
"""Add single property to collection of properties.
If a namespace (NS) has been configured prefixes keys with that
namespace.
"""
if not value:
return
key = '.'.join(self.NS + (name, ))
properties[key] = value
def get_properties(self):
return {}
def get_title(self):
return self.context.title
def get_reference_number(self):
return getAdapter(self.context, IReferenceNumber).get_number()
def get_sequence_number(self):
return str(getUtility(ISequenceNumber).get_number(self.context))
class CalendarListing(grok.View):
grok.context(ISolgemaFullcalendarMarker)
grok.baseclass()
grok.name('calendarlisting')
grok.require('zope2.View')
grok.template('calendarlisting')
def months(self):
items = self._items()
b_start = self.request.get('b_start', 0)
result = self._group_by_month(items)
return Batch(result, 2, int(b_start), orphan=0)
def _group_by_month(self, events):
months = []
month_info = []
old_month_year = None
for event in events:
# ignore if content does not have start/end
if not event.start:
continue
start = event.start
end = event.end
month = str(start.month())
year = str(start.year())
month_year = year + month
if month_year != old_month_year:
old_month_year = month_year
if month_info:
months.append(month_info)
month_info = {
'month': start.month(),
'year': start.year(),
'month_name': start.strftime("%B"),
'events': []
}
event_dict = {
'event': event,
'day': start.day(),
'month': start.month(),
'month_name': start.strftime('%b'),
'year': start.year(),
'day_end': end.day(),
'month_end': end.month(),
'month_end_name': end.strftime('%b'),
'year_end': end.year(),
'title': event.Title,
'description': event.Description,
'location': event.location,
'url': event.getURL(),
}
month_info['events'].append(event_dict)
if month_info:
months.append(month_info)
return months
class PloneFieldWidget(FieldWidget, Acquisition.Explicit):
grok.baseclass()
@property
def context(self):
# Plone Zope 2 template need a context.
return self.form.context
class LocationTagsExtender(grok.Adapter):
grok.implements(IOrderableSchemaExtender, IBrowserLayerAwareExtender)
grok.provides(IOrderableSchemaExtender)
grok.baseclass()
grok.name('wcc.location.locationtags')
fields = [
ExtensionLinesField(
'countries',
vocabulary_factory='wcc.vocabulary.country',
storage=AttributeStorage(),
widget=InAndOutWidget(title=_(u'Related Countries'))),
]
layer = IProductSpecific
def __init__(self, context):
self.context = context
def getFields(self):
return self.fields
def getOrder(self, schematas):
# you may reorder the fields in the schemata here
return schematas
class BaseViewlet(grok.Viewlet):
"""Base Viewlet Class."""
grok.baseclass()
grok.context(IItem)
grok.layer(ISantaTemplatesLayer)
grok.require('zope2.View')
grok.viewletmanager(SantaTopViewletManager)
class Publishable(SilvaObject, ViewableObject):
"""Base content that can be published and ordered in Silva.
"""
grok.baseclass()
grok.implements(IPublishable)
security = ClassSecurityInfo()
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'is_default')
def is_default(self):
"""returns True if the SilvaObject is a default document
"""
return False
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'is_published')
def is_published(self):
return True
security.declareProtected(SilvaPermissions.AccessContentsInformation,
'is_approved')
def is_approved(self):
return False
class SourceAPI(UIREST):
grok.context(ISilvaObject)
grok.baseclass()
def get_document(self):
"""Return the document version to which the External source is
associated.
"""
if IVersionedContent.providedBy(self.context):
version = self.context.get_editable()
if version is not None:
return version
version = self.context.get_viewable()
if version is not None:
return version
return self.context
def get_source(self):
"""Return the External Source and form associated with the
given request.
"""
document = self.get_document()
source = getComponent(document, IExternalSourceManager)(document)(
self.request,
instance=self.request.get('source_instance'),
name=self.request.get('source_name'))
source.ignoreContent = 'source_name' in self.request.form
source.ignoreRequest = 'source_inline' not in self.request.form
return source
class EventSubmissionForm(extensible.ExtensibleForm):
grok.baseclass()
grok.require('zope2.View')
coordinates = None
def directory(self):
return self.context
def prepare_coordinates(self, data):
if data.get('wkt'):
self.coordinates = utils.verify_wkt(data['wkt']).__geo_interface__
else:
self.coordinates = None
del data['wkt']
def apply_coordinates(self, content):
c = self.coordinates
if c:
IGeoManager(content).setCoordinates(c['type'], c['coordinates'])
else:
IGeoManager(content).removeCoordinates()
def handle_cancel(self):
try:
clear_token(self.context)
except ComponentLookupError:
pass
IStatusMessage(self.request).add(_(u"Event submission cancelled"),
"info")
self.request.response.redirect(self.directory.absolute_url())
class CriterionTemplateView(CriterionView):
"""Base class for criterion which wish to use a template in order
to render themselves.
"""
grok.baseclass()
template = None
def updateWidget(self, value):
"""Implement this method to prepare value that would be used
by the template.
"""
raise NotImplementedError
def renderWidget(self, value):
assert self.template is not None
self.updateWidget(value)
return self.template.render(self)
# Define namespace that would be used by the Grok template
def default_namespace(self):
return {
'criterion': self.criterion,
'query': self.query,
'request': self.request,
'view': self
}
def namespace(self):
return {}
class gwLanguageSelectorBase(LanguageSelector, grok.Viewlet):
grok.baseclass()
render = ViewPageTemplateFile('viewlets_templates/language_selector.pt')
def get_selected_lang(self, languages):
# Show all languages in language selector
all_languages = super(gwLanguageSelectorBase, self).languages()
if self.context.REQUEST.form.get('set_language'):
idiomes_publicats = genweb_config().idiomes_publicats # noqa
return [lang for lang in all_languages if lang['selected']][0]
def lang_published(self):
# show if the selected lang is published or not in language selector
lang = dict(getToolByName(self, 'portal_languages').listAvailableLanguages())
published_lang = genweb_config().idiomes_publicats
params_lang = self.context.REQUEST.form.get('set_language')
cookie_lang = getToolByName(self, 'portal_languages').getPreferredLanguage()
if params_lang:
if params_lang not in lang:
return _(u'not a valid language', default=u'${results} not a valid language', mapping={u'results': params_lang})
if params_lang not in published_lang:
return _(u'Not published')
else:
if cookie_lang not in published_lang:
return _(u'Not published')
def get_google_translated_langs(self):
# return dict(ca=genweb_config().idiomes_google_translate_link_ca,
# en=genweb_config().idiomes_google_translate_link_en,
# es=genweb_config().idiomes_google_translate_link_es)
return False
class CriterionView(grok.MultiAdapter):
grok.implements(ICriterionView)
grok.provides(ICriterionView)
grok.baseclass()
def __init__(self, criterion, query, request):
self.criterion = criterion
self.query = query
self.request = request
self.data = getMultiAdapter((criterion, query), ICriterionData)
self.name = str(criterion.getName())
def renderEditWidget(self):
return self.renderWidget(self.data.getValue())
def renderPublicWidget(self):
return self.renderWidget(self.getWidgetValue())
def renderWidget(self, value):
"""Implement this method to render a widget with the given
value. By default renderEditWidget and renderPublicWidget are
the same, just the default used value changes.
"""
raise NotImplementedError
def extractWidgetValue(self):
"""Implement this method to extract a value from the request
created by the edit/public widget.
"""
raise NotImplementedError
def saveWidgetValue(self):
self.data.setValue(self.extractWidgetValue())
def getWidgetValue(self):
value = self.extractWidgetValue()
if value is not None:
return value
return self.data.getValue()
# IQueryPart default implementation
def getIndexId(self):
return self.criterion.getIndexId()
getIndexValue = getWidgetValue
# Proxy criterion information mainly for BBB in edit view
def canBeShown(self):
return self.criterion.publicField
def getTitle(self):
return self.criterion.getTitle()
def getDescription(self):
return self.criterion.getDescription()
def getName(self):
return self.name
class ReservationTargetForm(ResourceBaseForm):
""" Describes a form with a hidden reservation field and the ability to
set the reservation using a query parameter:
example-form?token=298c6de470f94c64928c14246f3ee9e5
Optionally, an id can be given to select a specific reservation out
of many possible reservations belonging to one token:
example-form?token=298c6de470f94c64928c14246f3ee9e5&id=123
"""
grok.baseclass()
fields = field.Fields(IReservationTargetForm)
hidden_fields = ('token', 'id')
extracted_data = {}
@property
def token(self):
return self.request.get('token', self.extracted_data.get('token'))
@property
def id(self):
id = self.request.get('id', self.extracted_data.get('id'))
return int(id) if id else None
def defaults(self):
return dict(token=self.token, id=self.id)
class BaseRedirector(grok.Adapter):
grok.baseclass()
grok.implements(IRedirector)
container_iface = None
direct_parent = False
def __init__(self, context):
self.context = context
def _get_parent(self):
if self.direct_parent:
parent = aq_parent(self.context)
if self.container_iface.providedBy(parent):
return parent
else:
for parent in aq_chain(self.context):
if self.container_iface.providedBy(parent):
return parent
return None
def can_handle(self):
return bool(self._get_parent())
def get_url(self):
return self._get_parent().absolute_url()
class RangeMetadataCriterionTemplateView(CriterionTemplateView):
grok.baseclass()
def updateWidget(self, value):
self.begining = None
self.end = None
if value:
self.begining, self.end = value
def renderPublicWidget(self):
# we don't want to show data input widgets for stored values
value = self.data.getValue()
if value:
return self.renderValue(value)
return self.renderWidget(self.extractWidgetValue())
def renderValue(self, value):
return "<strong>%s - %s</strong>" % value
def extractWidgetValue(self):
def extractValue(key):
try:
value = self.request.get(key, None)
if self.convertValue(value) is None:
raise ValueError(value)
return value
except:
pass
return None
value_begin = extractValue(self.name + '-begin')
value_end = extractValue(self.name + '-end')
if value_begin is None and value_end is None:
return None
# XXX It will be better to store directly converted objects
return (value_begin, value_end)
def getIndexValue(self):
return self.constructQuery(self.getWidgetValue())
def constructQuery(self, value):
if value is None:
return None
begin, end = list(map(self.convertValue, value))
if begin is None:
if end is None:
return None
else:
return {'query': end, 'range': 'max'}
else:
if end is None:
return {'query': begin, 'range': 'min'}
else:
return {'query': [begin, end], 'range': 'min:max'}
def convertValue(self, value):
raise NotImplementedError
class BaseJobSearchResults(grok.View):
grok.baseclass()
grok.name('jobsearch_results')
grok.require('zope2.View')
grok.template('jobsearch_results')
grok.layer(IProductSpecific)
def results(self):
query = self.context.buildQuery()
query.update(self.buildFilterQuery())
catalog = self.context.portal_catalog
results = []
for brain in catalog(query):
results.append(self._extract(brain))
# redirect if theres only 1 result
if len(results) == 1:
self.request.response.redirect(results[0]['url'])
return results
def buildFilterQuery(self):
result = {}
if self.request.get('industry_cluster', None):
result['industry_cluster'] = self.request.get('industry_cluster')
if self.request.get('experience', None):
result['exp_levels'] = self.request.get('experience')
if self.request.get('searchtext', None):
result['SearchableText'] = self.request.get('searchtext')
return result
def _extract(self, brain):
obj = brain.getObject()
clustervocab = getUtility(IVocabularyFactory,
name='dkiscm.jobmatrix.industrycluster')(
self.context)
expvocab = getUtility(IVocabularyFactory,
name='dkiscm.jobmatrix.experience')(self.context)
data = {
'title':
brain.Title,
'url':
brain.getURL(),
'exp_levels':
','.join(
[expvocab.getTerm(i).title for i in (obj.exp_levels or [])]),
'industry_cluster':
''
}
if brain.industry_cluster and (brain.industry_cluster !=
'no-industry-cluster'):
data['industry_cluster'] = clustervocab.getTerm(
brain.industry_cluster).title
return data
class ReservationDecisionForm(ReservationIdForm, ReservationListView,
ReservationUrls):
""" Base class for admin's approval / denial forms. """
grok.baseclass()
template = ViewPageTemplateFile('templates/decide_reservation.pt')
show_links = False
class SilvaSoftwareContent(Folder):
grok.baseclass()
def fulltext(self):
text = super(SilvaSoftwareContent, self).fulltext()
default = self.get_default()
if default is not None and hasattr(aq_base(default), 'fulltext'):
text.extend(default.fulltext())
return text
class ZODBFile(File):
"""Silva File object, storage in Filesystem. Contains the
OFS.Image.File.
"""
grok.implements(interfaces.IZODBFile)
grok.baseclass()
security = ClassSecurityInfo()
def __init__(self, id):
super(ZODBFile, self).__init__(id)
# Actual container of file data
self._file = Image.File(id, id, '')
security.declareProtected(SilvaPermissions.ChangeSilvaContent, 'set_file')
def set_file(self, stream, content_type=None, content_encoding=None):
"""Set data in _file object
"""
data, size = self._file._read_data(stream)
if content_type is None:
# Detect content-type
identifier = get_file_name(stream, default=self.id)
content_type, content_encoding = getUtility(
IMimeTypeClassifier).guess_type(
id=identifier,
buffer=hasattr(data, 'data') and data.data or data,
default=DEFAULT_MIMETYPE)
# Update file data.
self._file.update_data(data, content_type, size)
if self._file.content_type == 'text/plain':
self._file.content_type = 'text/plain; charset=utf-8'
self._content_encoding = content_encoding
if not interfaces.IImage.providedBy(aq_parent(self)):
# # If we are not a storage of an image, trigger an event.
notify(ObjectModifiedEvent(self))
security.declareProtected(SilvaPermissions.ChangeSilvaContent, 'set_text')
def set_text(self, text):
stream = StringIO()
stream.write(text)
self.set_file(stream, content_type=self._file.content_type)
stream.close()
security.declareProtected(SilvaPermissions.View, 'get_file')
def get_file(self):
data = self._file.data
if isinstance(data, StringTypes):
return data
return str(data)
security.declareProtected(SilvaPermissions.View, 'get_file_fd')
def get_file_fd(self):
return StringIO(self.get_file())
class ReservationDecisionForm(ReservationTargetForm, ReservationListView,
ReservationUrls):
""" Base class for admin's approval / denial forms. """
grok.baseclass()
grok.layer(ISeantisReservationSpecific)
template = ViewPageTemplateFile('templates/decide_reservation.pt')
show_links = False
class EditForm(Form):
"""Generic Plone Edit Form
"""
grok.baseclass()
grok.name('edit')
grok.require('cmf.ModifyPortalContent')
label = _(u"Edit")
ignoreContent = False
actions = base.Actions(EditAction(_(u"Save")), CancelAction(_(u"Cancel")))
class BaseVocabularyFactory(grok.GlobalUtility):
grok.baseclass()
grok.implements(IVocabularyFactory)
terms = []
def __call__(self, context):
terms = []
for item in self.terms:
terms.append(SimpleTerm(**item))
return SimpleVocabulary(terms)
class BaseForm(SharedBaseForm):
""" Baseform provided by senatis.plonetools. Currently incompatible with
ResourceBaseForm - this should change, but for now it's technical debt.
Should be used by forms independent of resources.
"""
grok.baseclass()
grok.layer(ISeantisReservationSpecific)
domain = 'seantis.reservation'
class GeverTableSource(grok.MultiAdapter,
FilteredTableSourceMixin,
BaseTableSource):
"""Base table source used for some tables.
Add support for gever-specific filterlist configuration option, also
adds support for grok-style directives. It should always be used whenever
a table-source is required.
"""
grok.baseclass()
class MobileViewletBase(grok.Viewlet):
"""
Superclass for all mobile viewlets. Provides some helper methods.
It is not strictly necessary to inherit other viewlets from this.
"""
grok.baseclass()
def is_plone4(self):
""" Allow major viewlet change compatiblity between Plone versions from tempalte """
return PLONE_VERSION > 3
class FileDownloadView(silvaviews.View):
grok.baseclass()
grok.require('zope2.View')
grok.name('index.html')
@Lazy
def _modification_datetime(self):
date = self.context.get_modification_datetime()
if date is None:
return 0
return long(date)
def is_not_modified(self):
"""Return true if the file was not modified since the date
given in the request headers.
"""
header = self.request.environ.get('HTTP_IF_MODIFIED_SINCE', None)
if header is not None:
modified_since = parse_datetime(header.split(';')[0])
if modified_since and self._modification_datetime:
return self._modification_datetime <= modified_since
return False
def have_ranges(self):
"""Return range information if partial content was requested.
"""
range_header = self.request.environ.get('HTTP_RANGE', None)
if range_header is not None:
range_if_header = self.request.environ.get('HTTP_IF_RANGE', None)
if range_if_header:
# If there is an If-Range header, with a date
# prior to the modification, return all the file.
if_date = parse_datetime(range_if_header)
if (if_date and self._modification_datetime
and self._modification_datetime > if_date):
return (None, None, None)
ranges = parseRange(range_header)
if len(ranges) == 1:
size = self.context.get_file_size()
satisfiable = expandRanges(ranges, size)
if len(satisfiable) == 1:
return (satisfiable[0][0], satisfiable[0][1] - 1, size)
return (None, None, size)
return (None, None, None)
def payload(self):
raise NotImplementedError
def render(self):
if self.is_not_modified():
self.response.setStatus(304)
return u''
return self.payload()
class TileEditForm(form.SchemaForm):
""" From to edit the role of a member in an organization. """
grok.baseclass()
grok.require('cmf.ModifyPortalContent')
grok.context(ICover)
schema = ITileEditForm
ignoreContext = True
@property
def redirect_url(self):
return '/'.join((self.context.absolute_url(), 'compose'))
def parameter(self, name):
if self.request.get(name) is not None:
return self.request.get(name)
if self.request.get('form.widgets.{}'.format(name)) is not None:
return self.request.get('form.widgets.{}'.format(name))
return None
@property
def tile(self):
return self.parameter('tile')
@property
def tile_data_key(self):
return 'plone.tiles.data.{}'.format(self.tile)
def get_tile_data(self):
return IAnnotations(self.context).get(self.tile_data_key) or {}
def set_tile_data(self, data):
IAnnotations(self.context)[self.tile_data_key] = data
def update(self, **kwargs):
super(TileEditForm, self).update()
# update the widgets with the values from the request
for param in getFieldNames(self.schema):
self.widgets[param].value = getattr(self, param)
def updateActions(self):
super(TileEditForm, self).updateActions()
if 'save' in self.actions:
self.actions['save'].addClass('context')
if 'cancel' in self.actions:
self.actions['cancel'].addClass('standalone')
class viewletBase(grok.Viewlet):
grok.baseclass()
@memoize_contextless
def portal_url(self):
return self.portal().absolute_url()
@memoize_contextless
def portal(self):
return getSite()
def genweb_config(self):
return genweb_config()
class BaseJobSearchAutocomplete(grok.View):
grok.baseclass()
grok.name('jobtitle_autocomplete')
grok.layer(IProductSpecific)
def render(self):
cluster = self.request.get('industry_cluster', '')
query = self.request.get('q', '')
results = []
for job in self.context.portal_catalog(
industry_cluster=cluster, portal_type='dkiscm.jobmatrix.job'):
if job.Title.lower().startswith(query):
results.append('|'.join((job.Title, job.Title)))
return '\n'.join(results)
class ViewBase(silvaviews.View):
grok.baseclass()
def update(self):
need(IForumResources)
self.emoticons_directory = self.static['emoticons']()
def format_datetime(self, dt):
return dtformat(self.request, dt, DateTime())
def format_text(self, text):
if not isinstance(text, str):
text = str(text, 'utf-8')
text = emoticons(replace_links(cgi.escape(text, 1)),
self.emoticons_directory)
return text.replace('\n', '<br />')
