def date(self):
dt = None
if self._date:
try:
dt = guess_date_from(self._date)
except TypeError:
pass
return dt
def date(self):
dt = None
if self._date:
try:
dt = guess_date_from(self._date)
except TypeError:
pass
return dt
def publishTraverse(self, request, name):
context = self.context
dateobj = guess_date_from(name, context)
if dateobj:
occurrence = IRecurrenceSupport(context).occurrences(
range_start=dateobj)[0]
occ_acc = IEventAccessor(occurrence)
if is_same_day(dateobj, occ_acc.start):
return occurrence
return self.fallbackTraverse(request, name)
def publishTraverse(self, request, name):
context = self.context
dateobj = guess_date_from(name, context)
if dateobj:
occurrence = IRecurrenceSupport(context).occurrences(
range_start=dateobj)[0]
occ_acc = IEventAccessor(occurrence)
if is_same_day(dateobj, occ_acc.start):
return occurrence
return self.fallbackTraverse(request, name)
def publishTraverse(self, request, name):
dateobj = guess_date_from(name, self.context)
if dateobj:
occurrence = IRecurrenceSupport(self.context).occurrences(
range_start=dateobj)[0]
occ_acc = IEventAccessor(occurrence)
if is_same_day(dateobj, occ_acc.start):
return occurrence
# No self.fallback to avoid circular call from ImageTraverser
return super(OccurrenceTraverser, self).publishTraverse(request, name)
def publishTraverse(self, request, name):
# TODO: here is something odd....
# called every time, when an attribute is traversed/accessed?
dateobj = guess_date_from(name, self.context)
if dateobj:
occurrence = IRecurrenceSupport(self.context).occurrences(
range_start=dateobj)[0]
occ_acc = IEventAccessor(occurrence)
if is_same_day(dateobj, occ_acc.start):
return occurrence
return self.fallback(name)
def publishTraverse(self, request, name):
context = self.context
dateobj = guess_date_from(name, context)
if dateobj:
occs = IRecurrenceSupport(context).occurrences(range_start=dateobj)
try:
occurrence = occs.next()
occ_acc = IEventAccessor(occurrence)
if is_same_day(dateobj, occ_acc.start):
return occurrence
except StopIteration:
pass
return self.fallbackTraverse(request, name)
def publishTraverse(self, request, name):
context = self.context
dateobj = guess_date_from(name, context)
if dateobj:
occs = IRecurrenceSupport(context).occurrences(range_start=dateobj)
try:
occurrence = occs.next()
occ_acc = IEventAccessor(occurrence)
if is_same_day(dateobj, occ_acc.start):
return occurrence
except StopIteration:
pass
return self.fallbackTraverse(request, name)
def get_data(self):
start = guess_date_from(self.request.form.get('start', ''))
limit = self.request.form.get('limit', None)
b_size = self.request.form.get('b_size', 20)
b_start = self.request.form.get('b_start', 0)
result = get_portal_events(self.context, range_start=start)
# TODO: performance issue! the batch is somehow useless, if we
# calculate every result item anyways.
occ = [IEventAccessor(occ) for occ in\
get_occurrences(self.context,
result,
range_start=start,
limit=limit)]
return Batch(occ, b_size, b_start)
def results(self, custom_query, request_params):
# Support for the Event Listing view from plone.app.event
collection_layout = self.context.getLayout()
default_view = self.context.restrictedTraverse(collection_layout)
if isinstance(default_view, EventListing):
mode = request_params.get("mode", "future")
date = request_params.get("date", None)
date = guess_date_from(date) if date else None
start, end = start_end_from_mode(mode, date, self.collection)
start, end = _prepare_range(self.collection, start, end)
custom_query.update(start_end_query(start, end))
# TODO: expand events. better yet, let collection.results
# do that
return self.collection.results(
batch=False, brains=True, custom_query=custom_query
)
def get_events(self, start=None, end=None, batch=True, mode=None):
context = self.context
mode = mode or self.mode
if not mode and not start and not end:
mode = "future"
if mode:
dt = None
if self.date:
try:
dt = guess_date_from(self.date)
except TypeError:
pass
start, end = start_end_from_mode(mode, dt, context)
b_start = b_size = None
if batch:
b_start = self.b_start
b_size = self.b_size
occs = get_occurrences_from_brains(
context,
get_portal_events(
context,
start,
end,
# b_start=b_start, b_size=b_size,
path=context.getPhysicalPath(),
),
start,
end,
)
if batch:
ret = Batch(occs, size=b_size, start=b_start, orphan=self.orphan)
else:
ret = occs
return ret
def _get_occs(self):
date = guess_date_from(self.date)
if date:
start, end = start_end_from_mode('day', date, self.context)
query = {}
query['review_state'] = self.data.state
search_base_path = self.search_base_path
if search_base_path:
query['path'] = {'query': search_base_path}
list_events = []
events = get_events(self.context, start=start, end=end, sort='start', sort_reverse=False, ret_mode=RET_MODE_OBJECTS, expand=True, **query)
today = datetime.datetime.today().date()
for occ in events:
if IOccurrence.providedBy(occ):
occurrence_id = occ.id
event = aq_parent(occ)
occ_data = ITicketOccurrenceData(event)
occs = occ_data.ticket_occurrences(occurrence_id)
if occs:
occurrence_ticket = occs[0]
item_stock = get_item_stock(occurrence_ticket)
if item_stock:
stock = item_stock.available
else:
stock = 0
is_today = occ.start.date() == today
new_event = {
"start": occ.start,
"uid": occurrence_ticket.UID(),
"stock": stock,
"is_today": is_today
}
list_events.append(new_event)
elif IBuyableEvent.providedBy(occ):
occ_data = ITicketOccurrenceData(occ)
occs = occ_data.tickets
if occs:
occurrence_ticket = occs[0]
item_stock = get_item_stock(occurrence_ticket)
if item_stock:
stock = item_stock.available
else:
stock = 0
is_today = occ.start.date() == today
new_event = {
"start": occ.start,
"uid": occurrence_ticket.UID(),
"stock": stock,
"is_today": is_today
}
list_events.append(new_event)
else:
print 'NOT AVAILABLE'
return list_events
else:
return []
def get_filter_items(target_collection,
group_by,
filter_type=DEFAULT_FILTER_TYPE,
narrow_down=False,
show_count=False,
view_name='',
cache_enabled=True,
request_params=None):
request_params = request_params or {}
custom_query = {} # Additional query to filter the collection
collection = uuidToObject(target_collection)
if not collection or not group_by:
return None
collection_url = collection.absolute_url()
# Recursively transform all to unicode
request_params = safe_decode(request_params)
# Support for the Event Listing view from plone.app.event
collection_layout = collection.getLayout()
default_view = collection.restrictedTraverse(collection_layout)
if isinstance(default_view, EventListing):
mode = request_params.get('mode', 'future')
date = request_params.get('date', None)
date = guess_date_from(date) if date else None
start, end = start_end_from_mode(mode, date, collection)
start, end = _prepare_range(collection, start, end)
custom_query.update(start_end_query(start, end))
# TODO: expand events. better yet, let collection.results
# do that
# Get index in question and the current filter value of this index, if set.
groupby_criteria = getUtility(IGroupByCriteria).groupby
idx = groupby_criteria[group_by]['index']
current_idx_value = safe_iterable(request_params.get(idx))
extra_ignores = []
if not narrow_down:
# Additive filtering is about adding other filter values of the same
# index.
extra_ignores = [idx, idx + '_op']
urlquery = base_query(request_params, extra_ignores)
# Get all collection results with additional filter defined by urlquery
custom_query.update(urlquery)
custom_query = make_query(custom_query)
catalog_results = ICollection(collection).results(
batch=False, brains=True, custom_query=custom_query)
if narrow_down and show_count:
# we need the extra_ignores to get a true count
# even when narrow_down filters the display of indexed values
# count_query allows us to do that true count
count_query = {}
count_urlquery = base_query(request_params, [idx, idx + '_op'])
count_query.update(count_urlquery)
catalog_results_fullcount = ICollection(collection).results(
batch=False, brains=True, custom_query=count_query)
if not catalog_results:
return None
# Attribute name for getting filter value from brain
metadata_attr = groupby_criteria[group_by]['metadata']
# Optional modifier to set title from filter value
display_modifier = groupby_criteria[group_by].get('display_modifier', None)
# CSS modifier to set class on filter item
css_modifier = groupby_criteria[group_by].get('css_modifier', None)
# Value blacklist
value_blacklist = groupby_criteria[group_by].get('value_blacklist', None)
# Allow value_blacklist to be callables for runtime-evaluation
value_blacklist = value_blacklist() if callable(
value_blacklist) else value_blacklist # noqa
# fallback to title sorted values
sort_key_function = groupby_criteria[group_by].get(
'sort_key_function', lambda it: it['title'].lower())
grouped_results = {}
for brain in catalog_results:
# Get filter value
val = getattr(brain, metadata_attr, None)
if callable(val):
val = val()
# decode it to unicode
val = safe_decode(val)
# Make sure it's iterable, as it's the case for e.g. the subject index.
val = safe_iterable(val)
for filter_value in val:
if filter_value is None or isinstance(filter_value, Missing):
continue
if value_blacklist and filter_value in value_blacklist:
# Do not include blacklisted
continue
if filter_value in grouped_results:
# Add counter, if filter value is already present
grouped_results[filter_value]['count'] += 1
continue
# Set title from filter value with modifications,
# e.g. uuid to title
title = filter_value
if filter_value is not EMPTY_MARKER and callable(display_modifier):
title = safe_decode(display_modifier(filter_value))
# Build filter url query
_urlquery = urlquery.copy()
# Allow deselection
if filter_value in current_idx_value:
_urlquery[idx] = [
it for it in current_idx_value if it != filter_value
]
elif filter_type != 'single':
# additive filter behavior
_urlquery[idx] = current_idx_value + [filter_value]
_urlquery[idx + '_op'] = filter_type # additive operator
else:
_urlquery[idx] = filter_value
query_param = urlencode(safe_encode(_urlquery), doseq=True)
url = '/'.join([
it for it in [
collection_url, view_name, '?' +
query_param if query_param else None
] if it
])
# Set selected state
selected = filter_value in current_idx_value
css_class = 'filterItem {0}{1} {2}'.format(
'filter-' + idnormalizer.normalize(filter_value),
' selected' if selected else '',
css_modifier(filter_value) if css_modifier else '',
)
grouped_results[filter_value] = {
'title': title,
'url': url,
'value': filter_value,
'css_class': css_class,
'count': 1,
'selected': selected
}
# Entry to clear all filters
urlquery_all = {
k: v
for k, v in list(urlquery.items()) if k not in (idx, idx + '_op')
}
if narrow_down and show_count:
catalog_results = catalog_results_fullcount
ret = [{
'title':
translate(_('subject_all', default=u'All'), context=getRequest()),
'url':
u'{0}/?{1}'.format(collection_url,
urlencode(safe_encode(urlquery_all), doseq=True)),
'value':
'all',
'css_class':
'filterItem filter-all',
'count':
len(catalog_results),
'selected':
idx not in request_params
}]
grouped_results = list(grouped_results.values())
if callable(sort_key_function):
grouped_results = sorted(grouped_results, key=sort_key_function)
ret += grouped_results
return ret
def _results(self, collection, request_params):
ret = []
if collection:
collection_layout = collection.getLayout()
default_view = collection.restrictedTraverse(collection_layout)
results = []
custom_query = {}
if isinstance(default_view, EventListing):
mode = request_params.get('mode', 'future')
date = request_params.get('date', None)
date = guess_date_from(date) if date else None
start, end = start_end_from_mode(mode, date, collection)
start, end = _prepare_range(collection, start, end)
custom_query.update(start_end_query(start, end))
# TODO: expand events. better yet, let collection.results
# do that
idx = GROUPBY_CRITERIA[self.data.group_by]['index']
urlquery = {}
urlquery.update(request_params)
for it in (idx, 'b_start', 'b_size', 'batch', 'sort_on', 'limit'):
# Remove problematic url parameters
# And make sure to not filter by previously selected terms from
# this index. This narrows down too much (except for dedicated
# facetted searches - TODO)
if it in urlquery:
del urlquery[it]
custom_query.update(urlquery)
results = collection.results(
batch=False, custom_query=custom_query
)
if results:
ret.append(dict(
title=_('subject_all', default=u'All'),
url=u'{0}/?{1}'.format(
self.collection.absolute_url(),
urlencode(urlquery)
),
count=len(results),
selected=idx not in request_params
))
attr = GROUPBY_CRITERIA[self.data.group_by]['metadata']
mod = GROUPBY_CRITERIA[self.data.group_by]['display_modifier']
grouped_results = {}
for item in results:
val = getattr(item, attr, None)
if callable(val):
val = val()
if not getattr(val, '__iter__', False):
val = [val]
for crit in val:
if crit not in grouped_results:
urlquery[idx] = crit
title = _(safe_decode(
mod(crit)
if mod and crit is not EMPTY_MARKER
else crit
)) # mod modifies for displaying (e.g. uuid to title) # noqa
url = u'{0}/?{1}'.format(
self.collection.absolute_url(),
urlencode(safe_encode(urlquery)) # need to be utf-8 encoded # noqa
)
selected = safe_decode(request_params.get(idx)) == safe_decode(crit) # noqa
sort_key = crit if crit else 'zzzzzz'
crit_dict = {
'sort_key': sort_key.lower(),
'count': 1,
'title': title,
'url': url,
'selected': selected
}
grouped_results[crit] = crit_dict
else:
grouped_results[crit]['count'] += 1
ret += sorted(
grouped_results.values(),
key=lambda it: it['sort_key']
)
return ret
