class Widget(AbstractWidget):
""" Widget
"""
widget_type = 'debug'
widget_label = _('Debugger')
view_css = '++resource++eea.facetednavigation.widgets.debug.view.css'
edit_css = '++resource++eea.facetednavigation.widgets.debug.edit.css'
edit_js = '++resource++eea.facetednavigation.widgets.debug.edit.js'
view_js = '++resource++eea.facetednavigation.widgets.debug.view.js'
index = ViewPageTemplateFile('widget.pt')
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema.copy()
edit_schema['title'].default = 'Debug faceted criteria'
def __init__(self, context, request, data=None):
super(Widget, self).__init__(context, request, data)
voc = getUtility(IVocabularyFactory,
'eea.faceted.vocabularies.CurrentUser')
voc = [(term.value, term.title or term.value) for term in voc(context)
if term.value]
self.edit_schema['user'].vocabulary = DisplayList(voc)
class Widget(AbstractWidget, L10nDatepicker):
""" Widget
"""
widget_type = 'daterange'
widget_label = _('Date range')
groups = (DefaultSchemata, LayoutSchemata, DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def default(self):
""" Return default
"""
default = self.data.get('default', '')
if not default:
return '', ''
default = default.split('=>')
if len(default) != 2:
return '', ''
start, end = default
start = start.strip()
end = end.strip()
if not self.use_plone_date_format:
start = start.replace('/', '-')
end = end.replace('/', '-')
try:
start = DateTime(datetime.strptime(start, self.python_date_format))
start = start.strftime(self.python_date_format)
except Exception, err:
logger.exception('%s => Start date: %s', err, start)
start = ''
try:
end = DateTime(datetime.strptime(end, self.python_date_format))
end = end.strftime(self.python_date_format)
except Exception, err:
logger.exception('%s => End date: %s', err, end)
end = ''
class Widget(AbstractWidget):
""" Widget
"""
# Widget properties
widget_type = 'daterange'
widget_label = _('Date range')
view_js = '++resource++eea.facetednavigation.widgets.daterange.view.js'
edit_js = '++resource++eea.facetednavigation.widgets.daterange.edit.js'
view_css = '++resource++eea.facetednavigation.widgets.daterange.view.css'
edit_css = '++resource++eea.facetednavigation.widgets.daterange.edit.css'
index = ViewPageTemplateFile('widget.pt')
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema
@property
def default(self):
""" Return default
"""
default = self.data.get('default', '')
if not default:
return ('', '')
default = default.split('=>')
if len(default) != 2:
return ('', '')
start, end = default
try:
start = DateTime(start.strip())
start = start.strftime('%Y-%m-%d')
except Exception, err:
logger.exception('%s => Start date: %s', err, start)
start = ''
try:
end = DateTime(end.strip())
end = end.strftime('%Y-%m-%d')
except Exception, err:
logger.exception('%s => End date: %s', err, end)
end = ''
class Widget(AbstractWidget):
""" Banner widget
The following contexts can be used within tal expressions:
context -- faceted navigable context
referer -- request.HTTP_REFERER object. Use this if you load
faceted from another place (like: portal_relations)
request -- faceted navigable REQUEST object
widget -- Banner Widget instance
criterion -- Banner Criterion instance
"""
widget_type = 'banner'
widget_label = _('Banner')
view_js = '++resource++brasil.gov.facetada.faceted.widgets.banner.view.js'
index = ViewPageTemplateFile('widget.pt')
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema
edit_schema['title'].default = 'Banner'
def scale(self):
"""Retorna imagem no tamanho selecionado
"""
if self.data.imagem and self.data.scales:
catalog = getToolByName(self.context, 'portal_catalog')
image = None
brain = catalog(path={'query': self.data.imagem, 'depth': 0})
if brain:
image = brain[0].getObject()
scales = image.restrictedTraverse('@@images')
# scales come like u'preview 400:400'
# so I take the scale information from it
thumb = scales.scale('image', self.data.scales.split(' ')[0])
return {
'src': thumb.url,
'alt': image.Description(),
'width': thumb.width,
'height': thumb.height,
}
class Widget(AbstractWidget):
""" Widget
"""
# Widget properties
widget_type = 'resultsperpage'
widget_label = _('Results per page')
view_js = '++resource++eea.facetednavigation.widgets.resultsperpage.view.js'
edit_js = '++resource++eea.facetednavigation.widgets.resultsperpage.edit.js'
index = ViewPageTemplateFile('widget.pt')
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema
edit_schema['title'].default = 'Results per page'
@property
def default(self):
""" Get default values
"""
value = self.data.get('default', 0) or 0
try:
return int(value)
except (TypeError, ValueError), err:
logger.exception(err)
return 0
class Widget(CountableWidget):
""" Widget
"""
widget_type = 'select'
widget_label = _('Select')
groups = (DefaultSchemata, LayoutSchemata, CountableSchemata,
DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def default(self):
""" Get default values
"""
default = super(Widget, self).default or u''
return default.encode('utf-8')
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
query[index] = value
return query
class Widget(CountableWidget):
""" Widget
"""
# Widget properties
widget_type = 'select-nested'
widget_label = _('Select nested')
view_js = '++resource++eea.facetednavigation.widgets.select-nested.view.js'
edit_js = '++resource++eea.facetednavigation.widgets.select-nested.edit.js'
view_css = '++resource++eea.facetednavigation.widgets.select-nested.view.css'
index = ViewPageTemplateFile('widget.pt')
edit_schema = CountableWidget.edit_schema.copy() + EditSchema
def catalog_vocabulary(self):
""" Get vocabulary from catalog
"""
catalog = self.data.get('catalog', 'portal_catalog')
ctool = getToolByName(self.context, catalog)
if not ctool:
return []
index = self.data.get('index', None)
if not index:
return []
index = ctool.Indexes.get(index, None)
if not index:
return []
res = []
for val in index.uniqueValues():
if isinstance(val, (int, float)):
val = unicode(str(val), 'utf-8')
elif not isinstance(val, unicode):
try:
val = unicode(val, 'utf-8')
except Exception:
continue
val = val.strip()
if not val:
continue
res.append(val)
return res
def portal_vocabulary(self):
"""Look up selected vocabulary from portal_vocabulary or from ZTK
zope-vocabulary factory.
"""
vtool = getToolByName(self.context, 'portal_vocabularies', None)
voc_id = self.data.get('vocabulary', None)
if not voc_id:
return []
voc = getattr(vtool, voc_id, None)
if not voc:
voc = queryUtility(IVocabularyFactory, voc_id, None)
if voc:
return [(term.value, (term.title or term.token or term.value))
for term in voc(self.context)]
return []
terms = voc.getDisplayList(self.context)
if hasattr(terms, 'items'):
return terms.items()
return terms
def vocabulary(self, **kwargs):
""" Return data vocabulary
"""
reverse = safeToInt(self.data.get('sortreversed', 0))
mapping = self.portal_vocabulary()
catalog = self.data.get('catalog', None)
if catalog:
mapping = dict(mapping)
values = self.catalog_vocabulary()
res = [(val, mapping.get(val, val)) for val in values]
res.sort(key=operator.itemgetter(1), cmp=compare)
else:
res = mapping
if reverse:
res.reverse()
return res
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
if not isinstance(value, unicode):
value = value.decode('utf-8')
query[index] = value.encode('utf-8')
return query
class Widget(_Widget):
widget_type = 'checkbox_degree_explorer'
index = ViewPageTemplateFile('widget.pt')
class Widget(AbstractWidget):
""" Widget
"""
# Widget properties
widget_type = 'autocomplete'
widget_label = _('Text field with suggestions')
view_js = '++resource++eea.facetednavigation.widgets.autocomplete.view.js'
edit_js = '++resource++eea.facetednavigation.widgets.autocomplete.edit.js'
view_css = '++resource++eea.facetednavigation.widgets.autocomplete.view.css'
index = ViewPageTemplateFile('widget.pt')
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema
def quotestring(self, string):
""" Quote given string
"""
return '"%s"' % string
def quote_bad_chars(self, string):
""" Quote bad chars in query string
"""
bad_chars = ["(", ")"]
for char in bad_chars:
string = string.replace(char, self.quotestring(char))
return string
def normalize_string(self, value):
""" Process string values to be used in catalog query
"""
# Ensure words are string instances as ZCatalog requires strings
if isinstance(value, str):
value = value.decode('utf-8')
if isinstance(value, unicode):
value = value.encode('utf-8')
value = self.quote_bad_chars(value)
return value
def normalize_list(self, value):
""" Process list values to be used in catalog query
"""
return [self.normalize_string(word) for word in value]
def normalize(self, value):
""" Process value to be used in catalog query
"""
# select2 send us selected values separated by a comma
if ',' in value:
value = value.split(',')
if isinstance(value, (tuple, list)):
value = self.normalize_list(value)
elif isinstance(value, (str, unicode)):
value = self.normalize_string(value)
return value
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
value = self.normalize(value)
query[index] = {'query': value, 'operator': 'and'}
return query
def autocomplete_view(self):
""" Get the autocomplete view name
"""
view_name = self.data.get('autocomplete_view', '')
return view_name
class Widget(CountableWidget):
""" Widget
"""
# Widget properties
widget_type = 'userselect'
widget_label = _('User Select')
groups = (DefaultSchemata, LayoutSchemata, CountableSchemata,
DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
def __init__(self, context, request, data=None):
super(Widget, self).__init__(context, request, data)
self.data.index = 'Creator'
self.data.default = 'all'
def vocabulary(self):
return (('user', u'User'), ('admin', u'BCCVL'), ('shared', u'Shared'))
def _get_query(self, value):
portal_state = getMultiAdapter((self.context, self.request),
name="plone_portal_state")
member = portal_state.member()
if value == 'user':
return {'Creator': member.getId()}
elif value == 'admin':
return {'Creator': 'BCCVL'}
elif value == 'shared':
pc = getToolByName(self.context, 'portal_catalog')
vals = filter(lambda x: x not in ('BCCVL', member.getId()),
pc.uniqueValuesFor('Creator'))
return {'Creator': vals}
return {}
def query(self, form):
""" Get value from form and return a catalog dict query
"""
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return {}
value = form.get(self.data.getId(), 'all')
return self._get_query(value)
def count(self, brains, sequence=None):
""" Intersect results
"""
res = {}
# by checking for facet_counts we assume this is a SolrResponse
# from collective.solr
if hasattr(brains, 'facet_counts'):
facet_fields = brains.facet_counts.get('facet_fields')
if facet_fields:
index_id = self.data.get('index')
facet_field = facet_fields.get(index_id, {})
for value, num in facet_field.items():
normalized_value = atdx_normalize(value)
if isinstance(value, unicode):
res[value] = num
elif isinstance(normalized_value, unicode):
res[normalized_value] = num
else:
unicode_value = value.decode('utf-8')
res[unicode_value] = num
else:
# no facet counts were returned. we exit anyway because
# zcatalog methods throw an error on solr responses
return res
res[""] = res['all'] = len(brains)
return res
else:
# this is handled by the zcatalog. see below
pass
if not sequence:
sequence = [key for key, value in self.vocabulary()]
if not sequence:
return res
index_id = self.data.get('index')
if not index_id:
return res
ctool = getToolByName(self.context, 'portal_catalog')
index = ctool._catalog.getIndex(index_id)
ctool = queryUtility(IFacetedCatalog)
if not ctool:
return res
brains = IISet(brain.getRID() for brain in brains)
res[""] = res['all'] = len(brains)
for value in sequence:
if not value:
res[value] = len(brains)
continue
normalized_value = atdx_normalize(value)
query = self._get_query(normalized_value)
rset = ctool.apply_index(self.context, index, query[index_id])[0]
rset = IISet(rset)
rset = weightedIntersection(brains, rset)[1]
if isinstance(value, unicode):
res[value] = len(rset)
elif isinstance(normalized_value, unicode):
res[normalized_value] = len(rset)
else:
unicode_value = value.decode('utf-8')
res[unicode_value] = len(rset)
return res
class Widget(AbstractWidget):
""" Widget
"""
widget_type = "intrange"
widget_label = _("Int range field")
groups = (DefaultSchemata, LayoutSchemata)
index = ViewPageTemplateFile("widget.pt")
# @property
# def css_class(self):
# css = super(Widget, self).css_class
# css += ' col-xs-12 col-sm-6 col-lg-6 users'
# return css
@property
def default(self):
""" Return default
"""
default = self.data.get("default", "")
if not default:
return ("", "")
default = default.split("=>")
if len(default) != 2:
return ("", "")
min, max = default
return (min, max)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
# import ipdb; ipdb.set_trace()
index = self.data.get("index", "")
index = index.encode("utf-8", "replace")
value = None
if not index:
return query
if self.hidden:
min, max = self.default
else:
value = form.get(self.data.getId(), "")
if not value or len(value) != 2:
return query
min, max = [int(x) if x else 0 for x in value]
# import ipdb; ipdb.set_trace()
if not value:
return query
# portal_catalog({'price':{'query':[2,1000],'range':'min:max'}})
if min and not max:
value = min
range = "min"
elif max and not min:
value = max
range = "max"
else:
value = [min, max]
range = "min:max"
query[index] = {"query": value, "range": range}
return query
class Widget(CountableWidget):
""" Widget
"""
widget_type = 'checkbox'
widget_label = _('Checkboxes')
groups = (DefaultSchemata, LayoutSchemata, CountableSchemata,
DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def css_class(self):
""" Widget specific css class
"""
css_type = self.widget_type
css_title = normalizer.normalize(self.data.title)
return ('faceted-checkboxes-widget '
'faceted-{0}-widget section-{1}').format(css_type, css_title)
@property
def default(self):
""" Get default values
"""
default = super(Widget, self).default
if not default:
return []
if isinstance(default, (str, unicode)):
default = [
default,
]
return [x.encode('utf-8') for x in default]
def selected(self, key):
""" Return True if key in self.default
"""
default = self.default
if not default:
return False
for item in default:
if compare(key, item) == 0:
return True
return False
@property
def operator_visible(self):
""" Is operator visible for anonymous users
"""
return self.data.get('operator_visible', False)
@property
def operator(self):
""" Get the default query operator
"""
return self.data.get('operator', 'and')
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not self.operator_visible:
operator = self.operator
else:
operator = form.get(self.data.getId() + '-operator', self.operator)
operator = operator.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
catalog = getToolByName(self.context, 'portal_catalog')
if index in catalog.Indexes:
if catalog.Indexes[index].meta_type == 'BooleanIndex':
if value == 'False':
value = False
elif value == 'True':
value = True
query[index] = {'query': value, 'operator': operator}
return query
class Widget(AbstractWidget):
""" Widget
"""
# Widget properties
widget_type = 'sorting'
widget_label = _('Sorting')
view_js = '++resource++eea.facetednavigation.widgets.sorting.view.js'
edit_js = '++resource++eea.facetednavigation.widgets.sorting.edit.js'
view_css = '++resource++eea.facetednavigation.widgets.sorting.view.css'
index = ViewPageTemplateFile('widget.pt')
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema
edit_schema['title'].default = 'Sort on'
@property
def default(self):
""" Return default sorting values
"""
default = self.data.get('default', '')
if not default:
return ()
reverse = False
if '(reverse)' in default:
default = default.replace('(reverse)', '', 1)
reverse = True
default = default.strip()
return (default, reverse)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
if self.hidden:
default = self.default
sort_on = len(default) > 0 and default[0] or None
reverse = len(default) > 1 and default[1] or False
else:
sort_on = form.get(self.data.getId(), '')
reverse = form.get('reversed', False)
if sort_on:
query['sort_on'] = sort_on
if reverse:
query['sort_order'] = 'descending'
else:
query['sort_order'] = 'ascending'
return query
def criteriaByIndexId(self, indexId):
""" Get criteria by index id
"""
catalog_tool = getToolByName(self.context, 'portal_catalog')
indexObj = catalog_tool.Indexes[indexId]
# allow DateRecurringIndex that is unknown to atct.
# events in plone.app.contenttypes use it for start and end
if indexObj.meta_type == "DateRecurringIndex":
return ('ATFriendlyDateCriteria',
'ATDateRangeCriterion',
'ATSortCriterion')
results = _criterionRegistry.criteriaByIndex(indexObj.meta_type)
return results
def validateAddCriterion(self, indexId, criteriaType):
"""Is criteriaType acceptable criteria for indexId
"""
return criteriaType in self.criteriaByIndexId(indexId)
def listFields(self):
"""Return a list of fields from portal_catalog.
"""
tool = getToolByName(self.context, 'portal_atct')
return tool.getEnabledFields()
def listSortFields(self):
"""Return a list of available fields for sorting."""
fields = [field for field in self.listFields()
if self.validateAddCriterion(field[0], 'ATSortCriterion')]
return fields
def vocabulary(self, **kwargs):
""" Return data vocabulary
"""
vocab = self.portal_vocabulary()
sort_fields = self.listSortFields()
if not vocab:
return sort_fields
vocab_fields = [field[0].replace('term.', '', 1) for field in vocab]
return [f for f in sort_fields if f[0] in vocab_fields]
class Widget(AbstractWidget):
""" Widget
"""
widget_type = 'text'
widget_label = _('Text field')
groups = (DefaultSchemata, LayoutSchemata, DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
def quotestring(self, string):
""" Quote given string
"""
return '"%s"' % string
def quote_bad_chars(self, string):
""" Quote bad chars in query string
"""
bad_chars = ["(", ")"]
for char in bad_chars:
string = string.replace(char, self.quotestring(char))
return string
def normalize_string(self, value):
""" Process string values to be used in catalog query
"""
# Ensure words are string instances as ZCatalog requires strings
if isinstance(value, six.binary_type):
value = value.decode('utf-8')
if six.PY2 and isinstance(value, six.text_type):
value = value.encode('utf-8')
if self.data.get('wildcard', False) and not value.endswith("*"):
value = value + "*"
value = self.quote_bad_chars(value)
return value
def normalize_list(self, value):
""" Process list values to be used in catalog query
"""
return [self.normalize_string(word) for word in value]
def normalize(self, value):
""" Process value to be used in catalog query
"""
if isinstance(value, (tuple, list)):
value = self.normalize_list(value)
elif isinstance(value, (str, six.text_type)):
value = self.normalize_string(value)
return value
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
if six.PY2:
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
query[index] = {}
query[index]['query'] = self.normalize(value)
catalog = getToolByName(self.context, 'portal_catalog')
catalog_index = catalog.Indexes.get(index)
if 'operator' in getattr(catalog_index, 'query_options', []):
query[index]['operator'] = 'and'
return query
class Widget(AbstractWidget):
""" Widget
"""
# Widget properties
widget_type = 'date'
widget_label = _('Date')
groups = (DefaultSchemata, LayoutSchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def default(self):
""" Return default value
"""
default = self.data.get('default', '')
if not default:
return ('now-past', 'now_future')
default = default.split('=>')
if len(default) == 1:
return ('now-past', 'now_future')
elif len(default) == 2:
date_from = default[0].strip()
if not date_from.startswith('now'):
return ('now-past', 'now_future')
date_to = default[1].strip()
if not date_to.startswith('now'):
return ('now-past', 'now_future')
return (date_from, date_to)
return ('now-past', 'now_future')
@property
def select_vocabulary(self):
""" Select vocabulary
"""
# Past
res = [
('now-past', self.translate(_('Past'))),
]
for key, value in PAST:
key = 'now-%d' % key
res.append((key, self.translate(value)))
# Present
res.append(('now-0', self.translate(_('Today'))))
#Future
for key, value in FUTURE:
key = 'now_%d' % key
res.append((key, self.translate(value)))
res.append(('now_future', self.translate(_('Future'))))
return res
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), ())
if len(value) != 2:
return query
from_val, to_val = value
from_val = from_val.replace('now', '', 1)
if from_val.startswith('+') or from_val.startswith('_'):
from_val = from_val[1:]
to_val = to_val.replace('now', '', 1)
if to_val.startswith('+') or to_val.startswith('_'):
to_val = to_val[1:]
# Empty query
if from_val == '-past' and to_val == 'future':
return query
now = DateTime()
from_date = DateTime('1970/01/01')
to_date = DateTime('2030/12/31')
query_range = 'min:max'
if from_val == '-past':
query_range = 'max'
elif from_val == 'future':
from_date = DateTime('2030/12/31')
query_range = 'max'
else:
try:
from_delta = int(from_val)
except (ValueError, TypeError), err:
logger.exception(err)
else:
class Widget(AbstractWidget):
""" Widget
"""
widget_type = "moreorless"
widget_label = _("More or less field")
groups = (DefaultSchemata, LayoutSchemata)
index = ViewPageTemplateFile("widget.pt")
# @property
# def css_class(self):
# css = super(Widget, self).css_class
# css += ' col-xs-12 col-sm-6 col-lg-6 users'
# return css
@property
def default(self):
""" Return default
"""
default = self.data.get("default", "")
if not default:
return ""
return default
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
# import ipdb; ipdb.set_trace()
index = self.data.get("index", "")
moreorless = self.data.get("moreorless", "")
index = index.encode("utf-8", "replace")
value = None
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), "")
if not value:
return query
# check if there are other criteria with same index
second_value = None
second_moreorless = None
criteria = ICriteria(self.context)
for cid, criterion in criteria.items():
if cid in form.keys() and cid != self.data.getId():
if criterion.index == index:
second_value = form.get(cid)
second_moreorless = criterion.moreorless
value = int(value)
# portal_catalog({'price':{'query':[2,1000],'range':'min:max'}})
if moreorless == u"more" and not second_value:
range = "min"
elif moreorless == u"less" and not second_value:
range = "max"
else:
range = "min:max"
if second_moreorless == u"more":
value = [int(second_value), value]
query[index] = {"query": value, "range": range}
return query
class Widget(CountableWidget):
""" Widget
"""
widget_type = 'intselect'
widget_label = _('Int Select')
groups = (
DefaultSchemata,
LayoutSchemata,
CountableSchemata,
DisplaySchemata
)
index = ViewPageTemplateFile('widget.pt')
# @property
# def css_class(self):
# css = super(Widget, self).css_class
# css += ' col-xs-12 col-sm-6 col-lg-6 users'
# return css
@property
def default(self):
""" Get default values
"""
default = super(Widget, self).default or u''
return default.encode('utf-8')
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
query[index] = int(value)
return query
def vocabulary(self, **kwargs):
""" Return data vocabulary
"""
reverse = safeToInt(self.data.get('sortreversed', 0))
# import ipdb; ipdb.set_trace()
self.data.catalog = 'portal_catalog'
values = self.catalog_vocabulary()
mapping = {}
res = [(val, mapping.get(val, val)) for val in values]
res.sort(key=operator.itemgetter(1), cmp=intcompare)
if reverse:
res.reverse()
return res
class Widget(AbstractWidget):
""" Widget
"""
# Widget properties
widget_type = 'ordenar'
widget_label = _('Ordenar')
view_js = '++resource++brasil.gov.facetada.faceted.widgets.ordenar.view.js'
edit_js = '++resource++brasil.gov.facetada.faceted.widgets.ordenar.edit.js'
view_css = '+++resource++brasil.gov.facetada.faceted.widgets.ordenar.view.css'
css_class = 'faceted-ordenar-widget'
index = ViewPageTemplateFile('widget.pt')
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema
edit_schema['title'].default = 'Ordenar por'
@property
def default(self):
""" Return default sorting values
"""
default = self.data.get('default', '')
if not default:
return ()
reverse = False
if '(reverse)' in default:
default = default.replace('(reverse)', '', 1)
reverse = True
default = default.strip()
return (default, reverse)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
sort_on = form.get(self.data.getId(), '')
reverse = form.get('reversed', False)
if sort_on:
query['sort_on'] = sort_on
if reverse:
query['sort_order'] = 'descending'
else:
query['sort_order'] = 'ascending'
return query
def criteriaByIndexId(self, indexId):
""" Get criteria by index id
"""
catalog_tool = getToolByName(self.context, 'portal_catalog')
indexObj = catalog_tool.Indexes[indexId]
# allow DateRecurringIndex that is unknown to atct.
# events in plone.app.contenttypes use it for start and end
if indexObj.meta_type == 'DateRecurringIndex':
return ('ATFriendlyDateCriteria', 'ATDateRangeCriterion',
'ATSortCriterion')
results = _criterionRegistry.criteriaByIndex(indexObj.meta_type)
return results
def validateAddCriterion(self, indexId, criteriaType):
"""Is criteriaType acceptable criteria for indexId
"""
return criteriaType in self.criteriaByIndexId(indexId)
def listFields(self):
"""Return a list of fields from portal_catalog.
"""
tool = getToolByName(self.context, 'portal_atct')
return tool.getEnabledFields()
def listSortFields(self):
"""Return a list of available fields for sorting."""
fields = [
field for field in self.listFields()
if self.validateAddCriterion(field[0], 'ATSortCriterion')
]
return fields
class Widget(AbstractWidget):
""" Results Filter widget
The following contexts can be used within tal expressions:
context -- faceted navigable context
referer -- request.HTTP_REFERER object. Use this if you load
faceted from another place (like: portal_relations)
request -- faceted navigable REQUEST object
widget -- Results Filter Widget instance
criterion -- Results Filter Criterion instance
brain -- Catalog brain
"""
implements(IResultsFilterWidget)
widget_type = 'resultsfilter'
widget_label = _('Results Filter')
edit_css = (
'++resource++eea.facetednavigation.widgets.resultsfilter.edit.css')
edit_js = (
'++resource++eea.facetednavigation.widgets.resultsfilter.edit.js')
css_class = 'faceted-resultsfilter-widget'
index = ViewPageTemplateFile('widget.pt')
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema
edit_schema['title'].default = 'Results Filter'
edit_schema['hidden'].default = True
edit_schema['hidden'].schemata = 'hidden'
def referer(self, path=None):
""" Extract referer from request or return self.context
"""
default = self.context.aq_inner
if path is None:
path = getattr(self.request, 'HTTP_REFERER', None)
if not path:
return default
portal_url = getToolByName(self.context, 'portal_url')
path = path.replace(portal_url(), '', 1)
site = portal_url.getPortalObject().absolute_url(1)
if site and (not path.startswith(site)):
path = site + path
try:
referer = self.context.restrictedTraverse(path)
except Exception:
return default
if path == self.context.absolute_url(1):
return default
if IBaseObject.providedBy(referer):
return referer
path = '/'.join(path.split('/')[:-1])
return self.referer(path)
def talexpr(self, brain=None):
""" Compile tal expression
"""
talexpr = self.default
if talexpr is None:
return ''
engine = TrustedEngine
context = TrustedZopeContext(
engine,
dict(context=self.context.aq_inner,
referer=self.referer(),
request=self.request,
criterion=self.data,
brain=brain,
widget=self))
expression = engine.compile(talexpr)
result = context.evaluate(expression)
if callable(result):
return result()
return result
class Widget(AbstractWidget):
""" TAL Expression widget
The following contexts can be used within tal expressions:
context -- faceted navigable context
referer -- request.HTTP_REFERER object. Use this if you load
faceted from another place (like: portal_relations)
request -- faceted navigable REQUEST object
widget -- Tal Expression Widget instance
criterion -- Tal Expression Criterion instance
"""
widget_type = 'tal'
widget_label = _('TAL Expression')
index = ViewPageTemplateFile('widget.pt')
groups = (DefaultSchemata, LayoutSchemata)
def referer(self, path=None):
""" Extract referer from request or return self.context
"""
default = self.context.aq_inner
if path is None:
path = getattr(self.request, 'HTTP_REFERER', None)
if not path:
return default
portal_url = getToolByName(self.context, 'portal_url')
path = path.replace(portal_url(), '', 1)
site = portal_url.getPortalObject().absolute_url(1)
if site and (not path.startswith(site)):
path = site + path
try:
referer = self.context.restrictedTraverse(path)
except Exception:
return default
if path == self.context.absolute_url(1):
return default
if IBaseObject.providedBy(referer):
return referer
path = '/'.join(path.split('/')[:-1])
return self.referer(path)
def talexpr(self, form=None):
""" Compile tal expression
"""
if form is None:
form = {}
talexpr = self.default
if talexpr is None:
return ''
engine = TrustedEngine
context = TrustedZopeContext(
engine,
dict(context=self.context.aq_inner,
referer=self.referer(),
request=self.request,
criterion=self.data,
widget=self,
form=form))
expression = engine.compile(talexpr)
result = context.evaluate(expression)
if callable(result):
return result()
return result
def query(self, form):
""" Update query.
Use 'FACET-EMPTY' string to send no query to catalog
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
try:
value = self.talexpr(form=form)
except Exception, err:
logger.exception(err)
return query
if value == "FACET-EMPTY":
return query
query[index] = value
logger.debug(query)
return query
class Widget(CountableWidget):
""" Widget
"""
widget_type = 'multiselect'
widget_label = _('Multi Select')
groups = (DefaultSchemata, LayoutSchemata, CountableSchemata,
DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def css_class(self):
""" Widget specific css class
"""
css_type = self.widget_type
css_title = normalizer.normalize(self.data.title)
return ('faceted-multiselect-widget '
'faceted-{0}-widget section-{1}').format(css_type, css_title)
@property
def default(self):
""" Get default values
"""
default = super(Widget, self).default
if not default:
return []
if isinstance(default, (str, six.text_type)):
default = [
default,
]
res = []
for x in default:
if six.PY2 and isinstance(x, six.text_type):
x = x.encode('utf-8')
res.append(x)
return res
def selected(self, key):
""" Return True if key in self.default
"""
default = self.default
if not default:
return False
for item in default:
if key.lower() == item.lower():
return True
return False
@property
def operator_visible(self):
""" Is operator visible for anonymous users
"""
return self.data.get('operator_visible', False)
@property
def operator(self):
""" Get the default query operator
"""
return self.data.get('operator', 'and')
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
if six.PY2:
index = index.encode('utf-8', 'replace')
if not self.operator_visible:
operator = self.operator
else:
operator = form.get(self.data.getId() + '-operator', self.operator)
if six.PY2:
operator = operator.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
catalog = getToolByName(self.context, 'portal_catalog')
catalog_index = catalog.Indexes.get(index)
operator_supported = True
if catalog_index:
if catalog_index.meta_type == 'BooleanIndex':
if value == 'False':
value = False
elif value == 'True':
value = True
operator_supported = 'operator' in getattr(catalog_index,
'query_options', [])
query[index] = {'query': value}
if operator_supported:
query[index]['operator'] = operator
return query
class Widget(AbstractWidget):
""" Widget
"""
widget_type = 'sorting'
widget_label = _('Sorting')
groups = (DefaultSchemata, LayoutSchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def default(self):
""" Return default sorting values
"""
default = self.data.get('default', '')
if not default:
return ()
reverse = False
if '(reverse)' in default:
default = default.replace('(reverse)', '', 1)
reverse = True
default = default.strip()
return (default, reverse)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
if self.hidden:
default = self.default
sort_on = len(default) > 0 and default[0] or None
reverse = len(default) > 1 and default[1] or False
else:
sort_on = form.get(self.data.getId(), '')
reverse = form.get('reversed', False)
if sort_on:
query['sort_on'] = sort_on
if reverse:
query['sort_order'] = 'descending'
else:
query['sort_order'] = 'ascending'
return query
def criteriaByIndexId(self, indexId):
""" Get criteria by index id
"""
catalog_tool = getToolByName(self.context, 'portal_catalog')
try:
indexObj = catalog_tool.Indexes[indexId]
except KeyError:
return []
# allow DateRecurringIndex that is unknown to atct.
# events in plone.app.contenttypes use it for start and end
if indexObj.meta_type == "DateRecurringIndex":
return ('ATFriendlyDateCriteria', 'ATDateRangeCriterion',
'ATSortCriterion')
results = _criterionRegistry.criteriaByIndex(indexObj.meta_type)
return results
def validateAddCriterion(self, indexId, criteriaType):
"""Is criteriaType acceptable criteria for indexId
"""
return criteriaType in self.criteriaByIndexId(indexId)
def listSortFields(self):
"""Return a list of available fields for sorting."""
registry = getUtility(IRegistry)
config = IQuerystringRegistryReader(registry)()
indexes = config.get('sortable_indexes', {})
for name, index in indexes.items():
title = index.get('title', name)
description = index.get('description', title)
yield (name, title, description)
def vocabulary(self, **kwargs):
""" Return data vocabulary
"""
vocab = self.portal_vocabulary()
sort_fields = self.listSortFields()
if not vocab:
return [field for field in sort_fields]
vocab_fields = [field[0].replace('term.', '', 1) for field in vocab]
return [f for f in sort_fields if f[0] in vocab_fields]
class Widget(AbstractWidget, L10nDatepicker):
""" Widget
"""
widget_type = 'daterange'
widget_label = _('Date range')
groups = (DefaultSchemata, LayoutSchemata, DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def default(self):
""" Return default
"""
default = self.data.get('default', '')
if not default:
return '', ''
default = default.split('=>')
if len(default) != 2:
return '', ''
start, end = default
start = start.strip()
end = end.strip()
if not self.use_plone_date_format:
start = start.replace('/', '-')
end = end.replace('/', '-')
try:
start = DateTime(datetime.strptime(start, self.python_date_format))
start = start.strftime(self.python_date_format)
except Exception as err:
logger.exception('%s => Start date: %s', err, start)
start = ''
try:
end = DateTime(datetime.strptime(end, self.python_date_format))
end = end.strftime(self.python_date_format)
except Exception as err:
logger.exception('%s => End date: %s', err, end)
end = ''
return (start, end)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
if six.PY2:
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
start, end = self.default
else:
value = form.get(self.data.getId(), ())
if not value or len(value) != 2:
return query
start, end = value
if not (start and end):
return query
if self.use_plone_date_format:
try:
start = DateTime(
datetime.strptime(start, self.python_date_format))
end = DateTime(datetime.strptime(end, self.python_date_format))
except Exception as err:
logger.exception(err)
return query
else:
start, end = convert_to_padded_digits(start, end)
try:
# give datetime.datetime to allow very old or big years
# not to be transformed in current years (eg: 0001 -> 1901)
start = formated_time(start)
end = formated_time(end)
except Exception as err:
logger.exception(err)
return query
start = start - 1
start = start.latestTime()
end = end.latestTime()
query[index] = {'query': (start, end), 'range': 'min:max'}
return query
@property
def cal_year_range(self):
"""Return the stored value of calYearRange."""
return self.data.get('calYearRange', u"c-10:c+10")
@property
def use_plone_date_format(self):
"""Return the stored value of usePloneDateFormat."""
return self.data.get('usePloneDateFormat', False)
@property
def js_date_format(self):
"""Return the date format to use with JS datepicker"""
if self.use_plone_date_format:
return get_datepicker_date_format(self.request)
return "yy-mm-dd"
@property
def python_date_format(self):
"""Return the date format to use in python"""
if self.use_plone_date_format:
return get_python_date_format(self.request)
return "%Y-%m-%d"
@property
def js_language(self):
"""Return the language to use with JS code"""
if self.use_plone_date_format:
return self.jq_language()
return ""
class Widget(AbstractWidget):
""" Widget
"""
widget_type = 'path'
widget_label = _('Path')
groups = (DefaultSchemata, LayoutSchemata, DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def data_root(self):
""" Get navigation root
"""
site = self.context.portal_url.getPortalObject()
site_url = '/'.join(site.getPhysicalPath())
site_url = site_url.strip('/')
data_root = self.data.get('root', '') or ''
data_root = data_root.strip().strip('/')
if isinstance(data_root, unicode):
data_root = data_root.encode('utf-8')
if data_root.startswith(site_url):
data_root = '/' + data_root
return data_root.split('/')
site_url = site_url.split('/')
if data_root:
data_root = data_root.split('/')
else:
data_root = []
site_url.extend(data_root)
site_url.insert(0, '')
return site_url
@property
def root(self):
""" Get navigation root language dependent
"""
getLanguage = getattr(self.context, 'getLanguage', None)
if not getLanguage:
return self.data_root
lang = getLanguage() or self.request.get('LANGUAGE', '')
if not lang:
return self.data_root
root = '/'.join(self.data_root)
root = self.context.unrestrictedTraverse(root, None)
getTranslation = getattr(root, 'getTranslation', None)
if not getTranslation:
return self.data_root
translation = getTranslation(lang)
if not translation:
return self.data_root
url = translation.getPhysicalPath()
return list(url)
@property
def default(self):
""" Default value
"""
data_default = self.data.get('default', '')
if not data_default:
return ''
if isinstance(data_default, unicode):
data_default = data_default.encode('utf-8')
data_list = [
d for d in data_default.strip().strip('/').split('/') if d
]
root = self.data_root[:]
root.extend(data_list)
url = '/'.join(root)
folder = self.context.unrestrictedTraverse(url, None)
if not folder:
return ''
getTranslation = getattr(folder, 'getTranslation', None)
if not getTranslation:
return data_default
getLanguage = getattr(self.context, 'getLanguage', None)
if not getLanguage:
return data_default
lang = getLanguage() or self.request.get('LANGUAGE', '')
if not lang:
return data_default
translation = getTranslation(lang)
if not translation:
return data_default
url = '/'.join(translation.getPhysicalPath())
root = '/'.join(self.root)
return url.replace(root, '', 1)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
value = value.strip().strip('/')
if not value:
return query
url = self.root[:]
if not url:
return query
url.extend(value.split('/'))
value = '/'.join(url).rstrip('/')
depth = safeToInt(self.data.get('depth', 0))
query[index] = {"query": value, 'level': depth}
logger.debug(query)
return query
class Widget(CountableWidget):
""" Widget
"""
# Widget properties
widget_type = 'tagscloud'
widget_label = _('Tags Cloud')
view_js = '++resource++eea.facetednavigation.widgets.tagscloud.view.js'
edit_js = '++resource++eea.facetednavigation.widgets.tagscloud.edit.js'
view_css = '++resource++eea.facetednavigation.widgets.tagscloud.view.css'
edit_css = '++resource++eea.facetednavigation.widgets.tagscloud.edit.css'
index = ViewPageTemplateFile('widget.pt')
edit_schema = CountableWidget.edit_schema.copy() + EditSchema
@property
def maxitems(self):
""" Maximum items
"""
return safeToInt(self.data.get('maxitems', 0))
def cut_text(self, text='', maxchars=0):
""" Cut long text
"""
maxchars = safeToInt(self.data.get('maxchars', 0))
if not maxchars:
return text
# Allow 20 % more characters in order
# to avoid cutting at the end of the text
if len(text) <= (maxchars + round(0.2 * maxchars)):
return text
return '%s...' % text[0:maxchars]
def vocabulary(self, oll=False, **kwargs):
""" Return a limited number of results
"""
voc = list(super(Widget, self).vocabulary())
if oll:
maxitems = 0
else:
maxitems = self.maxitems
voc.insert(0, ('all', 'All'))
for index, item in enumerate(voc):
if maxitems and (index >= maxitems):
return
res = (item[0], item[1], -1)
yield res
@property
def randint(self):
""" Random integer
"""
maxint = self.maxitems or 100
return random.randint(0, maxint)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
if compare(value, 'all') == 0:
return query
if not isinstance(value, unicode):
value = value.decode('utf-8')
query[index] = value.encode('utf-8')
return query
def __call__(self, **kwargs):
return self.index(kwargs=kwargs)
class Widget(CountableWidget):
""" Widget
"""
# Widget properties
widget_type = 'checkbox'
widget_label = _('Checkboxes')
view_js = '++resource++eea.facetednavigation.widgets.checkbox.view.js'
edit_js = '++resource++eea.facetednavigation.widgets.checkbox.edit.js'
view_css = '++resource++eea.facetednavigation.widgets.checkbox.view.css'
edit_css = '++resource++eea.facetednavigation.widgets.checkbox.edit.css'
index = ViewPageTemplateFile('widget.pt')
edit_schema = CountableWidget.edit_schema.copy() + EditSchema
css_class = "faceted-checkboxes-widget"
@property
def default(self):
""" Get default values
"""
default = super(Widget, self).default
if not default:
return []
if isinstance(default, (str, unicode)):
default = [
default,
]
return default
def selected(self, key):
""" Return True if key in self.default
"""
default = self.default
if not default:
return False
for item in default:
if compare(key, item) == 0:
return True
return False
@property
def operator_visible(self):
""" Is operator visible for anonymous users
"""
return self.data.get('operator_visible', False)
@property
def operator(self):
""" Get the default query operator
"""
return self.data.get('operator', 'and')
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not self.operator_visible:
operator = self.operator
else:
operator = form.get(self.data.getId() + '-operator', self.operator)
operator = operator.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
value = atdx_normalize(value)
if not value:
return query
query[index] = {'query': value, 'operator': operator}
return query
class Widget(CountableWidget):
""" Widget
"""
# Widget properties
widget_type = 'pathselect'
widget_label = _('Path Select')
groups = (DefaultSchemata, LayoutSchemata, CountableSchemata,
DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
# TODO: we could add index and field 'part_of' to associate datasets with collections (similar to related_items? maybe eea.relations would be an option?)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
value = form.get(self.data.getId(), '')
if value:
value = uuidToCatalogBrain(value)
if value:
value = value.getPath()
if not value:
portal_url = getToolByName(self.context, 'portal_url')
root = self.data.get('root', '')
if root.startswith('/'):
root = root[1:]
value = '/'.join([portal_url.getPortalPath(), root])
if not value:
return query
depth = safeToInt(self.data.get('depth', -1))
query[index] = {"query": value, 'level': depth}
return query
def count(self, brains, sequence=None):
""" Intersect results
"""
res = {}
# by checking for facet_counts we assume this is a SolrResponse
# from collective.solr
if hasattr(brains, 'facet_counts'):
facet_fields = brains.facet_counts.get('facet_fields')
if facet_fields:
index_id = self.data.get('index')
facet_field = facet_fields.get(index_id, {})
for value, num in facet_field.items():
if isinstance(value, unicode):
res[value] = num
else:
unicode_value = value.decode('utf-8')
res[unicode_value] = num
else:
# no facet counts were returned. we exit anyway because
# zcatalog methods throw an error on solr responses
return res
res[""] = res['all'] = len(brains)
return res
else:
# this is handled by the zcatalog. see below
pass
if not sequence:
sequence = [key for key, value in self.vocabulary()]
if not sequence:
return res
index_id = self.data.get('index')
if not index_id:
return res
ctool = getToolByName(self.context, 'portal_catalog')
index = ctool._catalog.getIndex(index_id)
ctool = queryUtility(IFacetedCatalog)
if not ctool:
return res
brains = IISet(brain.getRID() for brain in brains)
res[""] = res['all'] = len(brains)
for value in sequence:
item = uuidToCatalogBrain(value)
if not item:
res[value] = len(brains)
continue
rset = ctool.apply_index(self.context, index, item.getPath())[0]
rset = IISet(rset)
rset = weightedIntersection(brains, rset)[1]
if isinstance(value, unicode):
res[value] = len(rset)
else:
unicode_value = value.decode('utf-8')
res[unicode_value] = len(rset)
return res
class Widget(CountableWidget):
""" Widget
"""
# Widget properties
widget_type = 'tagscloud'
widget_label = _('Tags Cloud')
groups = (
DefaultSchemata,
LayoutSchemata,
CountableSchemata,
DisplaySchemata,
GeometrySchemata,
)
index = ViewPageTemplateFile('widget.pt')
@property
def default(self):
""" Get default values
"""
default = super(Widget, self).default or u''
return default.encode('utf-8')
@property
def maxitems(self):
""" Maximum items
"""
return safeToInt(self.data.get('maxitems', 0))
def cut_text(self, text='', maxchars=0):
""" Cut long text
"""
maxchars = safeToInt(self.data.get('maxchars', 0))
if not maxchars:
return text
# Allow 20 % more characters in order
# to avoid cutting at the end of the text
if len(text) <= (maxchars + round(0.2 * maxchars)):
return text
return '%s...' % text[0:maxchars]
def vocabulary(self, oll=False, **kwargs):
""" Return a limited number of results
"""
voc = list(super(Widget, self).vocabulary())
if oll:
maxitems = 0
else:
maxitems = self.maxitems
voc.insert(0, ('all', 'All'))
for index, item in enumerate(voc):
if maxitems and (index >= maxitems):
return
res = (item[0], item[1], -1)
yield res
@property
def randint(self):
""" Random integer
"""
maxint = self.maxitems or 100
return random.randint(0, maxint)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
value = self.default
else:
value = form.get(self.data.getId(), '')
if not value:
return query
if compare(value, 'all') == 0:
return query
query[index] = value
return query
def __call__(self, **kwargs):
return self.index(kwargs=kwargs)
class Widget(AbstractWidget):
""" Widget
"""
widget_type = 'range'
widget_label = _('Range')
groups = (DefaultSchemata, LayoutSchemata, DisplaySchemata)
index = ViewPageTemplateFile('widget.pt')
@property
def default(self):
""" Return default
"""
default = self.data.get('default', '')
if not default:
return ('', '')
default = default.split('=>')
if len(default) != 2:
return ('', '')
start, end = default
return (start, end)
@property
def integer(self):
""" Integer only
"""
return self.data.get("integer", False)
def query(self, form):
""" Get value from form and return a catalog dict query
"""
query = {}
index = self.data.get('index', '')
if six.PY2:
index = index.encode('utf-8', 'replace')
if not index:
return query
if self.hidden:
start, end = self.default
else:
value = form.get(self.data.getId(), ())
if not value or len(value) != 2:
return query
start, end = value
if not (start and end):
return query
# let the field be integer if integer:
try:
_start = int(float(start))
except ValueError:
_start = start
try:
_end = int(float(end))
except ValueError:
_end = end
query[index] = {'query': (_start, _end), 'range': 'min:max'}
return query