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
