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 />')