def view(self):
session = DBSession()
query = (session.query(TodoItem)
.filter(TodoItem.parent_id == self.context.id)
.order_by(TodoItem.todostate)
.order_by(TodoItem.modification_date.desc())
)
items = query.all()
page = self.request.params.get('page', 1)
settings = todos_settings()
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'items': items,
'settings': settings,
}
def view(self):
session = DBSession()
query = session.query(SoftwareProject).filter(
SoftwareProject.parent_id == self.context.id)
items = query.all()
# [TODO] Are these calls too expensive?
[item.refresh_pypi() for item in items]
[item.refresh_github() for item in items]
[item.refresh_bitbucket() for item in items]
if self.context.sort_order_is_ascending:
items = sorted(items, key=lambda x: x.date)
else:
items = sorted(items, key=lambda x: x.date, reverse=True)
page = self.request.params.get('page', 1)
settings = collection_settings()
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'items': items,
'settings': settings,
}
def search(self, query=None, page=None, b_size=None, uids=None):
catalog = getToolByName(self.context, 'portal_catalog')
registry = getUtility(IRegistry)
settings = registry.forInterface(ICoverSettings)
searchable_types = settings.searchable_content_types
#temporary we'll only list published elements
catalog_query = {'sort_on': 'effective', 'sort_order': 'descending'}
catalog_query['portal_type'] = searchable_types
if query:
catalog_query = {'SearchableText': '%s*' % query}
# XXX: not implemented, this is needed?
# if uids:
# catalog_query['UID'] = uids
results = catalog(**catalog_query)
results = Batch.fromPagenumber(items=results,
pagesize=b_size,
pagenumber=page)
return results
def batch(self):
pagesize = self.pagesize
if self.show_all:
pagesize = len(self.items)
b = Batch.fromPagenumber(self.items, pagesize=pagesize, pagenumber=self.pagenumber)
map(self.set_checked, b)
return b
def extend_with_batching(widget, results):
page = 1
if widget.request.get('page'):
page = int(widget.request.get('page'))
batch = Batch.fromPagenumber(results, pagenumber=page)
batch_view = RefBrowserBatchView(widget, widget.request)
return (batch, batch_view(batch, minimal_navigation=True))
def view(self):
session = DBSession()
query = session.query(Category).filter(
Category.parent_id == self.context.id)
items = query.all()
todos_data = {}
for state in todo_states:
todos_data[state] = 0
todos_data['total'] = 0
modification_dates_and_items = []
for item in items:
if item.children:
done_count = 0
for todo in item.children:
todos_data[todo.todostate] += 1
if todo.todostate == 'done':
done_count += 1
todos_data['total'] += len(item.children)
sorted_todoitems = sorted(item.children,
key=lambda x: x.modification_date,
reverse=True)
modification_dates_and_items.append(
(sorted_todoitems[0].modification_date,
sorted_todoitems[0],
done_count,
item))
else:
modification_dates_and_items.append(
(item.modification_date, item, 0, item))
items = sorted(modification_dates_and_items)
page = self.request.params.get('page', 1)
settings = todos_settings()
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'items': items,
'todos_data': todos_data,
'data_keys': todo_states + ['total'],
'settings': settings,
}
def batched_news(self):
query = {"portal_type": "News Item",
"sort_on": "effective",
"sort_order": "descending", }
news = api.content.find(**query)
pagenumber = int(self.request.get("p", "1"))
batch = Batch.fromPagenumber(items=news, pagesize=6,
pagenumber=pagenumber, navlistsize=0)
return batch
def batch(self):
pagesize = self.pagesize
if self.show_all:
pagesize = len(self.items)
b = Batch.fromPagenumber(self.items,
pagesize=pagesize,
pagenumber=self.pagenumber)
map(self.set_checked, b)
return b
def test_custom_batching_is_available(self):
batch = Batch.fromPagenumber([item for item in range(1, 100)],
pagesize=10,
pagenumber=1)
batching = self.portal.restrictedTraverse('@@batchnavigation')
doc = PyQuery(batching(batch))
self.assertTrue(doc('.onegovBatching.listingBar'),
'Did not found the onegov batching')
def test_custom_batching_is_available(self):
batch = Batch.fromPagenumber([item for item in range(1, 100)],
pagesize=10,
pagenumber=1)
batching = self.portal.restrictedTraverse('@@batchnavigation')
doc = PyQuery(batching(batch))
self.assertTrue(doc('.onegovBatching.listingBar'),
'Did not found the onegov batching')
def batch(self):
"""Batch of Products (brains)."""
context = aq_inner(self.context)
search_filter = dict(
path='/'.join(context.getPhysicalPath()),
review_state='published',
portal_type='Place'
)
catalog = getToolByName(context, 'portal_catalog')
brains = catalog.searchResults(search_filter)
batch = Batch.fromPagenumber(
items=brains, pagesize=2000,
pagenumber=self.pagenum, navlistsize=5)
return batch
def view_blog(self):
settings = blog_settings()
macros = get_renderer('templates/macros.pt').implementation()
session = DBSession()
query = session.query(BlogEntry).filter(\
BlogEntry.parent_id == self.context.id).order_by(BlogEntry.date.desc())
items = query.all()
items = [item for item in items if has_permission('view', item, self.request)]
page = self.request.params.get('page', 1)
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': macros,
'items': items,
'settings': settings,
}
def view(self):
session = DBSession()
query = session.query(Topic).filter(
Topic.parent_id == self.context.id)
items = query.all()
modification_dates_and_items = []
for item in items:
if item.children:
sorted_posts = sorted(item.children,
key=lambda x: x.modification_date,
reverse=True)
modification_dates_and_items.append(
(sorted_posts[0].modification_date, sorted_posts[0], item))
else:
modification_dates_and_items.append(
(item.modification_date, item, item))
if self.context.sort_order_is_ascending:
items = sorted(modification_dates_and_items)
else:
items = sorted(modification_dates_and_items, reverse=True)
page = self.request.params.get('page', 1)
settings = forum_settings()
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'items': items,
'settings': settings,
}
def search(self, query=None, page=None, b_size=None, uids=None):
catalog = getToolByName(self.context, "portal_catalog")
registry = getUtility(IRegistry)
settings = registry.forInterface(ICoverSettings)
searchable_types = settings.searchable_content_types
# temporary we'll only list published elements
catalog_query = {"sort_on": "effective", "sort_order": "descending"}
catalog_query["portal_type"] = searchable_types
if query:
catalog_query = {"SearchableText": "%s*" % query}
# XXX: not implemented, this is needed?
# if uids:
# catalog_query['UID'] = uids
results = catalog(**catalog_query)
results = Batch.fromPagenumber(items=results, pagesize=b_size, pagenumber=page)
return results
def view_blog(context, request):
settings = blog_settings()
macros = get_renderer('templates/macros.pt').implementation()
session = DBSession()
query = session.query(BlogEntry).filter(\
BlogEntry.parent_id == context.id).order_by(BlogEntry.date)
items = query.all()
page = request.params.get('page', 1)
if settings['use_batching']:
items = Batch.fromPagenumber(items,
pagesize=settings['pagesize'],
pagenumber=int(page))
for item in items:
item.formatted_date = format_date(item.date)
return {
'api': template_api(context, request),
'macros': macros,
'items': items,
'settings': settings,
}
def articles(self, limit, genre='Current', all_articles=False,
outstanding_optional=False, section='', batched=False, b_start=0):
elements = {'outstanding': [], 'secondary': [], 'articles': []}
catalog = getToolByName(self.context, 'portal_catalog')
section = self.section(section)
#query build getting all the section news
query = {}
query['object_provides'] = {'query': [INITF.__identifier__]}
query['sort_on'] = 'effective'
query['sort_order'] = 'reverse'
query['genre'] = genre
query['review_state'] = 'published'
#query build for outstanding news
outstanding = {}
outstanding['object_provides'] = {
'query': [ISectionArticle.__identifier__]}
outstanding['genre'] = genre
outstanding['sort_on'] = 'effective'
outstanding['sort_order'] = 'reverse'
outstanding['sort_limit'] = 1
outstanding['review_state'] = 'published'
if section:
query['section'] = section
outstanding['section'] = section
existing = catalog.searchResults(query)
if all_articles:
if batched:
if(len(existing) > (b_start-1)*limit):
elements['articles'] = Batch.fromPagenumber(items=existing, pagesize=limit, pagenumber=b_start)
else:
elements['articles'] = []
else:
elements['articles'] = existing[:limit]
else:
#queremos dividir los objetos en outstanding y otros
if (existing and section) or (existing and outstanding_optional):
outstanding_UID = 0
outstanding_results = catalog.searchResults(outstanding)
move = 0
if outstanding_results:
elements['outstanding'].append(
outstanding_results[0].getObject())
outstanding_UID = outstanding_results[0].UID
else:
elements['outstanding'].append(existing[0].getObject())
move = 1
#batcheamos los objetos para paginacion
if batched:
if b_start > limit:
move = 0
tmp_elements = filter(lambda nota: nota.UID != outstanding_UID,
existing)[move:]
if(len(existing) > (b_start-1)*limit):
elements['secondary'] = Batch.fromPagenumber(items=tmp_elements, pagesize=limit, pagenumber=b_start)
else:
elements['secondary'] = []
else:
elements['secondary'] = \
filter(lambda nota: nota.UID != outstanding_UID,
existing)[move: limit + move]
elif existing:
#no es una seccion, sino una vista global
elements['outstanding'] = [existing[0].getObject()]
elements['secondary'] = existing[1: limit + 1]
return elements
def batch(self):
items = self.context.get_items()
batch_size = self.context.batch_size or sys.maxsize
page = int(self.request.get('%spage' % self.prefix, 0))
return Batch.fromPagenumber(items, batch_size, page + 1)
def view(self):
session = DBSession()
# Posts, if we have them.
order_by = Post.modification_date
if not self.context.sort_order_is_ascending:
order_by = Post.modification_date.desc()
query = (session.query(Post)
.filter(Post.parent_id == self.context.id)
.order_by(order_by)
)
top_level_posts = query.all()
post_counts_and_trees = []
for post in top_level_posts:
if post.children:
tree = nodes_tree(self.request, post)
post_count = len(tree.tolist())
else:
tree = (post)
post_count = 1
post_tree = {
'tree': {
'children': [tree],
},
}
post_counts_and_trees.append((post_count, post, post_tree))
# Votes, if we have them.
votes = None
vote_data = {}
vote_data['Sum'] = 0
vote_data['Count'] = 0
vote_data['Plus'] = 0
vote_data['Zero'] = 0
vote_data['Minus'] = 0
votes_and_vote_objs = []
if self.context.votable:
query = session.query(Vote).filter(
Vote.parent_id == self.context.id)
votes = query.all()
for vote in votes:
vote_data['Sum'] += vote.vote
vote_data['Count'] += 1
if vote.vote > 0:
vote_data['Plus'] += 1
elif vote.vote == 0:
vote_data['Zero'] += 1
else:
vote_data['Minus'] += 1
votes_and_vote_objs.append((vote.vote, vote, 'vote'))
if votes_and_vote_objs:
if self.context.sort_order_is_ascending:
votes_and_vote_objs = sorted(votes_and_vote_objs)
else:
votes_and_vote_objs = sorted(votes_and_vote_objs, reverse=True)
page = self.request.params.get('page', 1)
settings = forum_settings()
if settings['use_batching']:
post_items = Batch.fromPagenumber(post_counts_and_trees,
pagesize=settings['pagesize'],
pagenumber=int(page))
return {
'api': template_api(self.context, self.request),
'macros': get_renderer('templates/macros.pt').implementation(),
'vote_items': votes_and_vote_objs,
'vote_data': vote_data,
'items': post_items,
'settings': settings,
}
def batch(self):
items = self.context.get_items()
batch_size = self.context.batch_size or sys.maxint
page = int(self.request.get('%spage' % self.prefix, 0))
return Batch.fromPagenumber(items, batch_size, page + 1)
