class UserPasswordDataManager(grok.MultiAdapter): grok.adapts(IPropertiedUser, IPassword) grok.implements(IDataManager) def __init__(self, user, field): self.user=user self.field=field def get(self): raise AttributeError(self.field.__name__) def query(self, default=NO_VALUE): return default def set(self, value): if value is None: return IStatusMessage(getRequest()).add( _('Password not updated, none was specified.'), type='error') try: mt = getToolByName(self.user, "portal_membership") except AttributeError: return IStatusMessage(getRequest()).add( _('Cannot change password for Zope users, only Plone'), type='error') else: mt.setPassword(value) def canAccess(self): return False def canWrite(self): return True
class FilteredPostFactoryMenu(grok.MultiAdapter): """Build a customized factory menu by allowing factories to be filtered and renamed. Concrete filtering / renaming can be implemented by subclasses. """ grok.adapts(Interface, Interface) grok.implements(IContentmenuPostFactoryMenu) def __init__(self, context, request): self.context = context self.request = request def is_filtered(self, factory): """Allows a subclass to determine whether a factory should be filtered (omitted) or not. """ return False def rename(self, factory): """Lets a subclass rename a factory entry if necessary, and return the modified factory. """ return factory def __call__(self, factories): filtered_factories = [] for factory in factories: factory = self.rename(factory) if not self.is_filtered(factory): filtered_factories.append(factory) return order_factories(self.context, filtered_factories)
class DocumentsLaTeXListing(DossiersLaTeXListing): grok.provides(ILaTexListing) grok.adapts(Interface, Interface, Interface) grok.name('documents') def get_columns(self): return [ Column('sequence_number', _('short_label_sequence_number', default='No.'), '6%'), Column('title', _('label_title', default='Title'), '35%', 'Title'), Column( 'document_date', _('label_document_date', default='Document date'), '13%', lambda brain: helper.readable_date( brain, brain.document_date)), Column( 'receipt_date', _('label_receipt_date', default='Receipt date'), '13%', lambda brain: helper.readable_date(brain, brain.receipt_date)), Column( 'delivery_date', _('label_delivery_date', default='Delivery date'), '13%', lambda brain: helper.readable_date( brain, brain.delivery_date)), Column('document_author', _('label_document_author', default='Document author'), '20%') ]
class TabBlockController(BlockController): grok.adapts(TabBlock, Interface, IHTTPRequest) def __init__(self, block, context, request): super(TabBlockController, self).__init__(block, context, request) self._references = ReferenceSet(self.context, block.identifier) def editable(self): return True @apply def content(): def getter(self): return self._references.get() def setter(self, value): self._references.set(value) return property(getter, setter) def remove(self): self._references.clear() def render(self, view=None): return TabRenderer(self.content, self.request)()
class DocumentCollection(AdapterContext): # http://site/api/1.0/documents grok.adapts(V10, IRequest) grok.name('documents') def query(self): params = { 'object_provides': IDocument.__identifier__, 'sort_on': 'Date', 'sort_order': 'descending', 'Language': 'all' } objs = [brain.getObject() for brain in self.portal_catalog(**params)] result = [] limit = int(self.request.get('limit', 20)) for obj in objs[:limit]: item = IJsonProvider(obj).to_dict() result.append(item) return result def __getattr__(self, uuid): site = getSite() brains = site.portal_catalog(UID=uuid, portal_type='wcc.activity.document', Language='all') if not brains: raise AttributeError(uuid) return Activity(brains[0].getObject())
class ConfigureExisting(ExistingCodeSourcesMixin, rest.FormWithTemplateREST): grok.adapts(rest.Screen, CodeSourceService) grok.name('admin-existing') grok.require('zope2.ViewManagementScreens') def get_menu_title(self): return _('Available code sources') def get_menu_parent(self): parent = super(ConfigureExisting, self).get_menu_parent() parent['screen'] = 'admin' return parent def _get_source_name(self, source): return source.get_title() def update(self): sources = self.request.form.get('sources') if sources is not None and not isinstance(sources, list): sources = [sources] super(ConfigureExisting, self).update(find='find' in self.request.form, update='update' in self.request.form, sources=sources) if self.success or self.errors: service = getUtility(IMessageService) for status in self.success: service.send(status, self.request, namespace='feedback') for status in self.errors: service.send(status, self.request, namespace='error')
class Count(REST, CommunityMixin): """ /api/communities/count/{community_type} /api/communities/count?community_type=Closed """ grok.adapts(Communities, IPloneSiteRoot) grok.require('genweb.authenticated') def __init__(self, context, request): super(Count, self).__init__(context, request) @api_resource() def GET(self): """ Return the number of communities. """ pc = api.portal.get_tool('portal_catalog') community_type = self.params.pop('community_type', None) if community_type is not None: results = pc.unrestrictedSearchResults( portal_type='ulearn.community', community_type=community_type) else: results = pc.unrestrictedSearchResults( portal_type='ulearn.community') return ApiResponse(len(results))
class Templating(object): """Store a template in a content object. """ grok.implements(ITemplating) grok.adapts(IAttributeAnnotatable) def __init__(self, context): self.context = context @property def template(self): return self.annotations().get('template') @template.setter def template(self, value): if value: zope.interface.alsoProvides(self.context, IHasTemplate) else: zope.interface.noLongerProvides(self.context, IHasTemplate) self.annotations()['template'] = value @property def template_object(self): possible_template = self.template if possible_template is not None: return possible_template.to_object return NullTemplate(self.context) def annotations(self): annotations = IAnnotations(self.context) if templating_key not in annotations: annotations[templating_key] = PersistentDict() return annotations[templating_key]
class LocationShapeMapDisplayWidget(grok.MultiAdapter, ShapeMapDisplayWidget): grok.adapts(IMapWidget, Interface, ILocation) grok.provides(IMapWidget_geo) grok.implements(IMapWidget_geo) grok.name('geoshapedisplaymap') _layers = ['shapedisplay', 'all_locations']
class MetadataResultView(ResultView): grok.adapts(schema.MetadataResultField, IQuery, Interface) def update(self, view): self.set_name, self.element_name = self.result.getId().split(':') service = getUtility(IMetadataService) metadata_set = service.getMetadataSet(self.set_name) metadata_element = metadata_set.getElement(self.element_name) assert IMetadataElement.providedBy(metadata_element),\ "Unknow metadata element %s" % self.result.getId() self.renderValue = metadata_element.renderView if metadata_element.metadata_in_catalog_p: # If the metadata is available on the brain, directly use it metadata_key = createIndexId(metadata_element) self.getValue = lambda item: getattr(item, metadata_key) else: self.getValue = lambda item: service.getMetadataValue( item.getObject(), self.set_name, self.element_name) def render(self, item): # self.context should item.getObject() result = self.renderValue(self.context, self.getValue(item)) if not result: return css_class = "metadata-%s-%s" % (self.set_name, self.element_name) return ''.join([ '<span class="searchresult-field %s">' % css_class, '<span class="searchresult-field-title">', self.result.getTitle(), '</span>', '<span class="searchresult-field-value">', result, '</span>', '</span>' ])
class RankingResultView(ResultView): grok.adapts(schema.RankingResultField, IQuery, Interface) def __init__(self, *args): super(RankingResultView, self).__init__(*args) self.rankings = {} self.highest = 1.0 def update(self, view): query = self.request.form.get('fulltext') self.highest = 1.0 self.rankings = {} if query: query = str(query, 'utf8') # XXX should use getUtility catalog = self.context.service_catalog index = catalog.Indexes['fulltext'] try: max_index = view.results.start + len(view.results) + 1 rankings = index.query(query, max_index)[0] if rankings: self.highest = rankings[0][1] / 100.0 self.rankings = dict(rankings) except ParseError: pass self.img = '<img alt="Rank" src="%s"/>' % view.static['ranking.gif']() def render(self, item): rid = item.getRID() if rid in self.rankings: return '<span class="searchresult-ranking">%s %.1f%%</span>' % ( self.img, (self.rankings[rid] / self.highest)) return None
class ResultView(grok.MultiAdapter): grok.implements(IResultView) grok.adapts(IResultField, IQuery, Interface) grok.provides(IResultView) def __init__(self, result, context, request): self.context = context self.result = result self.request = request def update(self, view): pass def render(self, item): value = getattr(item.getObject(), self.result.getName())() if not value: return if hasattr(value, 'strftime'): # what the hell are these things?, # they don't have a decent type value = value.strftime('%d %b %Y %H:%M') value = '<span class="searchresult-field-value">%s</span>' % value title = '<span class="searchresult-field-title">%s</span>' % ( self.title) return '<span class="searchresult-field">%s%s</span>' % (title, value)
class ActionWidget(ActionWidget): grok.adapts(interfaces.IAction, interfaces.IFieldExtractionValueSetting, IThemeSpecific) def htmlClass(self): return 'btn btn-primary'
class TaskPostFactoryMenu(grok.MultiAdapter): """If a task is added to another task, it is called subtask. So we need to change the name of the task in the add-menu if we are on a task. """ grok.adapts(ITask, Interface) grok.implements(IContentmenuPostFactoryMenu) def __init__(self, context, request): self.context = context self.request = request def __call__(self, factories): cleaned_factories = [] for factory in factories: # drop mail factory if factory['extra']['id'] != u'ftw-mail-mail': if factory['title'] == u'Task': factory['title'] = _(u'Subtask') factory['extra']['class'] = 'icon-task-subtask' cleaned_factories.append(factory) return cleaned_factories
class MetadataCriterionView(CriterionView): grok.adapts(IMetadataCriterionField, IQuery, Interface) def renderPublicWidget(self): # we don't want to show widgets for stored values. # BBB convertValue is here for previously stored (wrong) values value = convertValue(self.data.getValue()) if value: return self.renderValue(value) return self.renderWidget(self.extractWidgetValue()) def renderValue(self, value): if isinstance(value, list): value = u", ".join(value) return u"<strong>%s</strong>" % value def renderWidget(self, value): # XXX does None values work ? element = self.criterion.getMetadataElement() return element.field.render(value) def extractWidgetValue(self): set_name = self.criterion.getSetName() set_values = self.request.get(set_name, None) if set_values is None: return None element_name = self.criterion.getElementName() value = set_values.get(element_name, None) return convertValue(value)
class AddViewTraverser(SimpleHandler, grok.MultiAdapter): grok.name('add') grok.adapts(SQLContainer, Interface) grok.provides(ITraversable) def __init__(self, context, request): self.context = context self.request = request def traverse(self, name, ignored): ti = queryUtility(IDexterityFTI, name=name) if ti is not None: add_view = queryMultiAdapter((self.context, self.request, ti), name=name) if add_view is None: add_view = queryMultiAdapter((self.context, self.request, ti)) if add_view is not None: #add_view.__name__ = name #view = ImplicitAcquisitionWrapper(add_view, self.context) view = add_view.__of__(self.context) return view raise TraversalError(self.context, name)
class CriterionData(grok.MultiAdapter): grok.adapts(ICriterionField, IQuery) grok.provides(ICriterionData) grok.implements(ICriterionData) def __init__(self, criterion, query): self.criterion = criterion self.query = query self.name = str(criterion.getName()) def getValue(self): return self.query.getCriterionValue(self.name) def setValue(self, value): if value: self.query.setCriterionValue(self.name, value) else: self.query.deleteCriterionValue(self.name) def serializeXML(self, handler): value = self.getValue() if value is None: return [] elif isinstance(value, list) or isinstance(value, tuple): return [item if item is not None else '' for item in value] return [value] def setXMLValue(self, handler, value): if len(value) == 1: value = value[0] self.setValue(value)
class PortalRoleManagerMigration(REST): """ /api/portalrolemanagermigration """ placeholder_type = 'person' placeholder_id = 'username' grok.adapts(APIRoot, IPloneSiteRoot) grok.require('genweb.authenticated') def GET(self): """ Returns all permision assigned to portal_role_manager """ portal = api.portal.get() role_manager = portal.acl_users.portal_role_manager roles = role_manager.enumerateRoles() result = [] for role in roles: users_assigned = role_manager.listAssignedPrincipals(role['id']) try: info_role_manager = dict(role_id=role['id'], users_assigned=users_assigned) result.append(info_role_manager) except: logger.info('HA FALLAT LA INFO DE {}'.format(role['id'])) return json.dumps(result)
class ConfigureInstall(InstallCodeSourcesMixin, rest.FormWithTemplateREST): grok.adapts(rest.Screen, CodeSourceService) grok.name('admin') grok.require('zope2.ViewManagementScreens') only_uninstalled = True def get_menu_title(self): return _('Install code sources') def get_menu_parent(self): parent = super(ConfigureInstall, self).get_menu_parent() parent['screen'] = 'admin' return parent def _get_source_name(self, installable): return installable.title def update(self, install=False, refresh=False, locations=[]): super(ConfigureInstall, self).update(install='install' in self.request.form, refresh='refresh' in self.request.form, locations=self.request.form.get('locations', [])) if self.success or self.errors: service = getUtility(IMessageService) for status in self.success: service.send(status, self.request, namespace='feedback') for status in self.errors: service.send(status, self.request, namespace='error')
class ProposalTableSource(SqlTableSource): grok.implements(ITableSource) grok.adapts(ProposalListingTab, Interface) searchable_columns = [ Proposal.title, ]
class PathCriterionView(CriterionTemplateView): grok.adapts(IPathCriterionField, IQuery, Interface) template = ChameleonPageTemplate(filename="templates/pathcriterion.cpt") interface = 'silva.core.interfaces.content.IContainer' def renderPublicWidget(self): raise ValueError(u"Cannot render path widgets for the public") def updateWidget(self, value): resolver = ReferenceInfoResolver(self.request, self.query, self) resolver.update(interface=self.interface) resolver.add(value=value) def extractWidgetValue(self): value = self.request.form.get(self.name, None) try: return int(value) except (ValueError, TypeError): return 0 def getIndexValue(self): content = self.data.getValue() if content is None: return None return "/".join(content.getPhysicalPath())
class QuestionResponseHeaders(HTTPResponseHeaders): """Disable cache on poll questions. """ grok.adapts(IBrowserRequest, IPollQuestion) def cachable(self): return False
class NewsCollection(AdapterContext): # http://site/api/1.0/news grok.adapts(V10, IRequest) grok.name('news') def query(self): activity_uuid = self.request.get('activity', '') params = { 'object_provides': IATNewsItem.__identifier__, 'sort_on': 'Date', 'sort_order': 'descending', 'Language': 'all', } category = self.request.get('category', '') if category: params['Subject'] = category.strip() params['Language'] = self.request.get('language', 'all') objs = [brain.getObject() for brain in self.portal_catalog(**params)] result = [] limit = int(self.request.get('limit', 20)) for obj in objs[:limit]: item = IJsonProvider(obj).to_dict() result.append(item) return result
class DossierGridStateStorageKeyGenerator(grok.MultiAdapter): """This storage key generator creates a shared key for all dossier types, since we need to share the configuration between different dossier types. """ grok.implements(IGridStateStorageKeyGenerator) grok.adapts(IDossierMarker, IBrowserView, IBrowserRequest) def __init__(self, context, tabview, request): self.context = context self.tabview = tabview self.request = request def get_key(self): key = [] key.append('ftw.tabbedview') # replace the portal type with static 'opengever.dossier' key.append('openever.dossier') # add the name of the tab key.append(self.tabview.__name__) # add the userid mtool = getToolByName(self.context, 'portal_membership') member = mtool.getAuthenticatedMember() key.append(member.getId()) # concatenate with "-" return '-'.join(key)
class ActivityCollection(AdapterContext): # http://site/api/1.0/activities grok.adapts(V10, IRequest) grok.name('activities') def query(self): language = self.request.get('language', 'all') brains = self.portal_catalog(portal_type='wcc.activity.activity', Language=language) result = [] for brain in brains: obj = brain.getObject() item = IJsonProvider(obj).to_dict() result.append(item) return result def __getattr__(self, uuid): site = getSite() brains = site.portal_catalog(UID=uuid, portal_type='wcc.activity.activity', Language='all') if not brains: raise AttributeError(uuid) return Activity(brains[0].getObject())
class DossierPostFactoryMenu(grok.MultiAdapter): """If a task is added to another task, it is called subtask. So we need to change the name of the task in the add-menu if we are in a task. """ grok.adapts(IDossierMarker, Interface) grok.implements(IContentmenuPostFactoryMenu) def __init__(self, context, request): self.context = context self.request = request def __call__(self, factories): if not IDossierMarker.providedBy(self.context): # use default return factories for factory in factories: if factory['extra']['id'] == \ u'opengever-dossier-businesscasedossier': factory['title'] = _(u'Subdossier') elif factory['extra']['id'] == u'ftw-mail-mail': factories.remove(factory) # Order the factory-menu factories = order_factories(self.context, factories) return factories
class DossiersLaTeXListing(LaTexListing): grok.provides(ILaTexListing) grok.adapts(Interface, Interface, Interface) grok.name('dossiers') template = ViewPageTemplateFile('templates/listing.pt') def get_responsible(self, brain): return Actor.lookup(brain.responsible).get_label_with_admin_unit() def get_columns(self): return [ Column('reference', _('label_reference_number', default='Reference number'), '10%'), Column('sequence_number', _('short_label_sequence_number', default='No.'), '5%'), Column('repository_title', _('label_repository_title', default='Repositoryfolder'), '20%', self.get_repository_title), Column('title', _('label_title', default='Title'), '25%', 'Title'), Column('responsible', _('label_responsible', default='Responsible'), '20%', self.get_responsible), Column('review_state', _('label_review_state', default='State'), '10%', lambda brain: workflow_state(brain, brain.review_state)), Column('start', _('label_start', default='Start'), '5%', lambda brain: helper.readable_date(brain, brain.start)), Column('end', _('label_end', default='End'), '5%', lambda brain: helper.readable_date(brain, brain.end)) ]
class GridDataConverter(grok.MultiAdapter, BaseDataConverter): """ Convert between the PriceList object and a data structure expected by the widget. """ grok.adapts(PriceListField, IDataGridField) grok.implements(IDataConverter) def toWidgetValue(self, value): rv = list() if value is not NO_PRICELIST: for row in value: d = dict() for name, field in schema.getFieldsInOrder(INamedPriceSchema): d[name] = getattr(row, name) rv.append(d) return rv def toFieldValue(self, value): rv = PriceList() for row in value: d = dict() for name, field in schema.getFieldsInOrder(INamedPriceSchema): if row.get(name, NO_VALUE) != NO_VALUE: d[name] = row.get(name) rv.append(NamedPrice(**d)) return rv
class JournalLaTeXListing(LaTexListing): grok.provides(ILaTexListing) grok.adapts(Interface, Interface, Interface) grok.name('journal') template = ViewPageTemplateFile('templates/listing.pt') def get_actor_label(self, item): return Actor.lookup(item.get('actor')).get_label() def get_journal_comment(self, item): """Skip comment for document sent entries. """ if item.get('action', {}).get('type') == DOCUMENT_SENT: return return item.get('comments') def get_columns(self): return [ Column( 'time', journal_mf('label_time', default=u'Time'), '10%', lambda item: helper.readable_date_time( item, item.get('time'))), Column( 'title', journal_mf('label_title', default=u'Title'), '45%', lambda item: title_helper(item, item['action'].get('title'))), Column('actor', journal_mf('label_actor', default=u'Changed by'), '15%', self.get_actor_label), Column('comments', journal_mf('label_comments', default='Comments'), '30%', self.get_journal_comment) ]
class UserPropertyDataManager(grok.MultiAdapter): grok.adapts(IPropertiedUser, IField) grok.implements(IDataManager) def __init__(self, user, field): self.user=user self.field=field self.propname=field.__name__ for sheet_id in user.listPropertysheets(): sheet=user.getPropertysheet(sheet_id) if sheet.hasProperty(self.propname): self.propertysheet=sheet break else: self.propname=None def get(self): return self.propertysheet.getProperty(self.propname) def query(self, default=NO_VALUE): if self.propname is None: return default return self.propertysheet.getProperty(self.propname, NO_VALUE) def set(self, value): self.propertysheet.setProperty(self.user, self.propname, value) def canAccess(self): return self.propname is not None def canWrite(self): return self.propname is not None