Switch branches/tags
Nothing to show
Find file
Fetching contributors…
Cannot retrieve contributors at this time
188 lines (155 sloc) 6.7 KB
import urllib
from import IQuerystringRegistryReader
from plone.tiles.absoluteurl import BaseTileAbsoluteURL
from import TransientTileDataManager, decode
from import PloneMessageFactory as _
from import IContentListingTileSettings
from plone.directives import form as directivesform
from plone.formwidget.querystring.widget import QueryStringFieldWidget
from plone.registry.interfaces import IRegistry
from plone.tiles import PersistentTile
from plone.tiles import Tile
from zope import schema
from zope.component import getMultiAdapter, adapts
from zope.component import getUtility
from zope.interface import directlyProvides, implements
from zope.schema.interfaces import IVocabularyFactory
from zope.schema.vocabulary import SimpleVocabulary
from plone.tiles.interfaces import ITileDataManager, ITile
class IContentListingTile(directivesform.Schema):
"""A tile that displays a listing of content items"""
view_template = schema.Choice(title=_(u"Display mode"),
source=_(u"Available Listing Views"),
query = schema.List(title=_(u'Search terms'),
description=_(u'Define the search terms for the items '
u'you want to list by choosing what to '
u'match on. The list of results will '
u'be dynamically updated'),
class ContentListingTile(Tile):
"""A tile that displays a listing of content items"""
def __call__(self):
return self.contents()
def update(self):
self.query ='query')
self.view_template ='view_template')
def contents(self):
"""Search results"""
accessor = getMultiAdapter((self.context, self.request),
view = self.view_template
view = view.encode('utf-8')
options = dict(original_context=self.context)
return getMultiAdapter((accessor, self.request), name=view)(**options)
def shortOperators(self):
""" return a new string for operator which is shorter.
Finds unique right substring
registry = getUtility(IRegistry)
registryreader = IQuerystringRegistryReader(registry)
config = registryreader()
op_converters = {}
splitname = lambda n: list(reversed(n.split('.')))
joinname = lambda p: '.'.join(reversed(p))
for indexName, index in config['indexes'].items():
operators = index['operators'].keys()
parts = []
for op in operators:
short2long = {}
long2short = {}
touse = 1
while len(short2long) < len(operators):
# The first is default. We can shorten to ''
short2long = {'': joinname(parts[0])}
long2short = {joinname(parts[0]): ''}
for part in parts[1:]:
short = joinname(part[:touse])
if short in short2long:
short2long[short] = joinname(part)
long2short[short2long[short]] = short
op_converters[indexName] = (short2long, long2short)
return op_converters
class ListingTileAbsoluteURL(BaseTileAbsoluteURL):
"""Override to simplify urls
def __str__(self):
url = super(ListingTileAbsoluteURL, self).__str__()
#we don't need the id
url = '/'.join(url.split('/')[:-1])
data = ITileDataManager(self.context).get()
if data:
url += '?' + query_encode(data, self.context.shortOperators())
return url
class ListingTileDataManager(TransientTileDataManager):
"""Override to decode simpler urls
def get(self):
# If we don't have a schema, just take the request
if self.tileType is None or self.tileType.schema is None:
return = query_decode(, self.tile.shortOperators())
# Try to decode the form data properly if we can
return decode(, self.tileType.schema, missing=True)
except (ValueError, UnicodeDecodeError,):
#LOGGER.exception(u"Could not convert form data to schema")
# turn query into simple data structure
def query_encode(data, short_operators):
query = data['query']
new_data = dict(view_template=data['view_template'])
for criteria in query:
i = criteria['i']
o = criteria['o']
v = criteria['v']
short_op = short_operators[i][1][o]
if short_op:
i = "%s:%s" % (i,short_op)
# HACK can we assume ',' as a delimter for all operators?
if isinstance(v, list):
v = ', '.join(v)
new_data[i] = v
return urllib.urlencode(new_data)
def query_decode(data, short_operators):
# we are also used on forms that include query
query = data.get('query',[])
for i,v in data.items():
if i in ['view_template', 'query']:
if i not in short_operators:
short2long = short_operators[i][0]
if ':' in i:
i, o = i.split(':')
o = short2long.get(o,o)
o = short2long.get('')
if ',' in v:
v = [s.strip() for s in v.split(',')]
criteria = dict(i=i,o=o,v=v)
data['query'] = query
return data
def availableListingViewsVocabulary(context):
"""Get available views for listing content as vocabulary"""
registry = getUtility(IRegistry)
proxy = registry.forInterface(IContentListingTileSettings)
sorted = proxy.listing_views.items()
sorted.sort(lambda a, b: cmp(a[1], b[1]))
voc = []
for key, label in sorted:
voc.append(SimpleVocabulary.createTerm(key, key, label))
return SimpleVocabulary(voc)
directlyProvides(availableListingViewsVocabulary, IVocabularyFactory)