def __init__(self, context, request, page_title=None):
self.context = context
self.request = request
self.snippets = get_template("templates/snippets.pt")
self.snippets.doctype = xhtml
self.userid = authenticated_userid(request)
self.app_url = app_url = request.application_url
self.profile_url = app_url + "/profiles/%s" % self.userid
self.here_url = self.context_url = model_url(context, request)
self.view_url = model_url(context, request, request.view_name)
settings = queryUtility(ISettings)
self.js_devel_mode = settings and getattr(settings, "js_devel_mode", None)
self.static_url = "%s/static/%s" % (app_url, _get_static_rev())
# Provide a setting in the INI to fully control the entire URL
# to the static. This is when the proxy runs a different port
# number, or to "pipeline" resources on a different URL path.
full_static_path = getattr(settings, "full_static_path", False)
if full_static_path:
if "%d" in full_static_path:
full_static_path = full_static_path % _start_time
self.static_url = full_static_path
self.page_title = page_title
self.system_name = get_setting(context, "system_name", "KARL")
self.user_is_admin = "group.KarlAdmin" in effective_principals(request)
site = find_site(context)
self.admin_url = model_url(site, request, "admin.html")
self.site_announcement = getattr(site, "site_announcement", "")
def _get_criteria(request):
principals = effective_principals(request)
principals = [x for x in principals if not x.startswith('system.')]
# Check to see if we're asking for only "my" communities.
filterby = request.params.get('filter', '')
# cookie must be set even if param is empty or non-existent, to make
# the no-filter button sticky.
header = ('Set-Cookie', '%s=%s; Path=/' % (_FILTER_COOKIE, str(filterby)))
request.cookies[_FILTER_COOKIE] = filterby
request.response_headerlist = [header]
if filterby == 'mycommunities':
principals = [x for x in principals if not x.startswith('group.Karl')]
if filterby == 'mycontent':
created_by = authenticated_userid(request)
elif filterby.startswith('profile:'):
created_by = filterby[len('profile:'):]
elif filterby.startswith('community:'):
created_by = None
community = filterby[len('community:'):]
prefix = 'group.community:%s' % community
principals = [x for x in principals if x.startswith(prefix)]
else:
created_by = None
return principals, created_by
def get_my_communities(communities_folder, request, ignore_preferred=False):
# sorted by title
principals = effective_principals(request)
communities = {}
for name, role in get_community_groups(principals):
if name in communities:
continue
try:
community = communities_folder[name]
except KeyError:
continue
communities[name] = (community.title, community)
communities = communities.values()
communities.sort()
communities = [ x[1] for x in communities ]
preferred = get_preferred_communities(communities_folder, request)
# if preferred list is empty show all instead of nothing
if preferred == []:
ignore_preferred = True
my_communities = []
for community in communities:
adapted = getMultiAdapter((community, request), ICommunityInfo)
if not ignore_preferred and preferred is not None \
and adapted.title in preferred:
my_communities.append(adapted)
if preferred is None or ignore_preferred:
my_communities.append(adapted)
return my_communities
def _show_communities_view_helper(context,
request,
prefix='',
**kw
):
# Grab the data for the two listings, main communities and portlet
communities_path = model_path(context)
query = dict(
sort_index='title',
interfaces=[ICommunity],
path={'query': communities_path, 'depth': 1},
allowed={'query': effective_principals(request), 'operator': 'or'},
**kw
)
qualifiers = []
titlestartswith = request.params.get('titlestartswith')
if titlestartswith:
query['titlestartswith'] = (titlestartswith, titlestartswith)
qualifiers.append("Communities that begin with '%s'" % titlestartswith)
body = request.params.get('body')
if body:
query['texts'] = body
qualifiers.append('Search for "%s"' % body)
error = None
try:
batch_info = get_catalog_batch_grid(context, request, **query)
except ParseError, e:
batch_info = { 'entries': [], 'batching_required': False }
error = 'Error: %s' % e
def get_members_batch(community, request, size=10):
mods = list(community.moderator_names)
members = list(community.member_names - community.moderator_names)
any = list(community.member_names | community.moderator_names)
principals = effective_principals(request)
searcher = ICatalogSearch(community)
total, docids, resolver = searcher(interfaces=[IProfile],
limit=size,
name={'query': any,
'operator': 'or'},
allowed={'query': principals,
'operator': 'or'},
)
mod_entries = []
other_entries = []
for docid in docids:
model = resolver(docid)
if model is not None:
if model.__name__ in mods:
mod_entries.append(model)
else:
other_entries.append(model)
return (mod_entries + other_entries)[:size]
def get_batch(context, request):
"""Return a batch of results and term sequence for a search request.
If the user provided no terms, the returned batch will be None and the
term sequence will be empty.
"""
batch = None
terms = ()
kind = request.params.get("kind")
if not kind:
# Search form
query, terms = make_query(context, request)
if terms:
context_path = model_path(context)
if context_path and context_path != "/":
query["path"] = {"query": context_path}
principals = effective_principals(request)
query["allowed"] = {"query": principals, "operator": "or"}
batch = get_catalog_batch_grid(context, request, **query)
else:
# LiveSearch
text_term = request.params.get("body")
if text_term:
searcher = queryUtility(IGroupSearchFactory, kind)
if searcher is None:
# If the 'kind' we got is not known, return an error
fmt = "The LiveSearch group %s is not known"
raise HTTPBadRequest(fmt % kind)
batch = searcher(context, request, text_term).get_batch()
terms = [text_term, kind]
return batch, terms
def get_recent_items_batch(community, request, size=10):
batch = get_catalog_batch_grid(
community, request, interfaces=[ICommunityContent],
sort_index="modified_date", reverse=True, batch_size=size,
path={'query': model_path(community)},
allowed={'query': effective_principals(request), 'operator': 'or'},
)
return batch
def number_of_comments(forum, request):
searcher = ICatalogSearch(forum)
total, docids, resolver = searcher(
interfaces=[IComment],
path={'query': model_path(forum)},
allowed={'query': effective_principals(request), 'operator': 'or'},
)
return total
def jquery_livesearch_view(context, request):
# Prefix search is with a wildcard at the end
searchterm = request.params.get("val", None)
if searchterm is None:
# The request forgot to send the key we use to do a search, so
# make a friendly error message. Important for the unit test.
msg = "Client failed to send a 'val' parameter as the searchterm"
return HTTPBadRequest(msg)
else:
searchterm = searchterm + "*"
records = LivesearchResults()
principals = effective_principals(request)
site_path = model_path(context)
records.set_header("", pre='<div class="header"></div>')
records.append_to(
rowclass="showall",
title="Show All",
href=model_url(context, request, "searchresults.html", query={"body": searchterm}),
)
for listitem in get_listitems(IGroupSearchFactory):
utility = listitem["component"]
factory = utility(context, request, searchterm)
if factory is None:
continue
try:
num, docids, resolver = factory()
except ParseError:
continue
groupname = listitem["title"]
records.set_header(groupname, pre='<div class="header">%s</div>' % (groupname,))
results = filter(None, map(resolver, docids))
qs = {"body": searchterm, "kind": groupname}
sr_href = model_url(context, request, "searchresults.html", query=qs)
for result in results:
records.append_to(
rowclass="result", title=getattr(result, "title", "<No Title>"), href=model_url(result, request)
)
if results:
records.append_to(rowclass="showall", title="Show All", href=sr_href)
else:
records.append_to(rowclass="noresult", title="No Result", href=sr_href)
result = JSONEncoder().encode(list(records))
return Response(result, content_type="application/x-json")
def _makeCriteria(self):
principals = effective_principals(self.request)
# this is always assumed to be a global search; it does no
# path filtering
criteria = {}
criteria['sort_index'] = 'texts'
criteria['texts'] = self.term
criteria['interfaces'] = {'query':self.interfaces, 'operator':'or'}
criteria['allowed'] = {'query':principals, 'operator':'or'}
return criteria
def get_catalog_events(context, request,
searchterm=None, year=None, month=None,
past_events=None):
# Build up a query
query = dict(
path={'query': model_path(context)},
allowed={'query': effective_principals(request), 'operator': 'or'},
interfaces=[ICalendarEvent],
sort_index="start_date",
reverse=True,
use_cache=False,
)
if searchterm is not None:
query['texts'] = searchterm
if year is not None or month is not None:
if year is not None:
year = int(year)
else:
# No year given, assume this year
year = datetime.datetime.now().year
if month is not None:
month = int(month)
last_day = calendar.monthrange(year, month)[1]
first_moment = coarse_datetime_repr(
datetime.datetime(year, month, 1))
last_moment = coarse_datetime_repr(
datetime.datetime(year, month, last_day, 23, 59, 59))
else:
# No month given, search entire year
first_moment = coarse_datetime_repr(datetime.datetime(year, 1, 1))
last_moment = coarse_datetime_repr(datetime.datetime(year+1, 1, 1))
query['start_date'] = (None, last_moment)
query['end_date'] = (first_moment, None)
else:
# Show either all future or all past events
now = coarse_datetime_repr(datetime.datetime.now())
if past_events:
# Past; show the most recent first
query['end_date'] = (None, now)
query['reverse'] = True
else:
# Future; show the soonest first
query['end_date'] = (now, None)
query['reverse'] = False
batch = get_catalog_batch_grid(context, request, **query)
return batch
def get_report_query(report, request):
"""Produce query parameters for a catalog search
"""
kw = report.getQuery()
principals = effective_principals(request)
kw['allowed'] = {'query': principals, 'operator': 'or'}
letter = request.params.get('lastnamestartswith')
if letter:
kw['lastnamestartswith'] = letter.upper()
body = request.params.get('body')
if body:
kw['texts'] = body.strip() + '*'
return kw
def _member_profile_batch(context, request):
community = find_interface(context, ICommunity)
member_names = community.member_names
profiles_path = model_path(find_profiles(context))
batch = get_catalog_batch(
context, request,
batch_size = 12,
interfaces = [IProfile],
path={'query': profiles_path, 'depth': 1},
allowed={'query': effective_principals(request), 'operator': 'or'},
name = list(member_names),
sort_index='lastfirst',
)
return batch
def latest_object(forum, request):
searcher = ICatalogSearch(forum)
total, docids, resolver = searcher(
sort_index='modified_date',
interfaces={'query': [IForumTopic, IComment], 'operator':'or'},
path={'query': model_path(forum)},
allowed={'query': effective_principals(request), 'operator': 'or'},
reverse=True)
docids = list(docids)
if docids:
return resolver(docids[0])
else:
return None
def get_catalog_news(context, request,
searchterm=None, year=None, month=None):
# Build up a query
query = dict(
path={'query': model_path(context)},
allowed={'query': effective_principals(request), 'operator': 'or'},
interfaces=[INewsItem],
sort_index="publication_date",
reverse=True,
)
if searchterm is not None:
query['texts'] = searchterm
now = coarse_datetime_repr(datetime.datetime.now())
if year is not None or month is not None:
if year is not None:
year = int(year)
else:
# No year given, assume this year
year = datetime.datetime.now().year
if month is not None:
month = int(month)
last_day = calendar.monthrange(year, month)[1]
first_moment = coarse_datetime_repr(
datetime.datetime(year, month, 1))
last_moment = coarse_datetime_repr(
datetime.datetime(year, month, last_day, 23, 59, 59))
else:
# No month given, search entire year
first_moment = coarse_datetime_repr(datetime.datetime(year, 1, 1))
last_moment = coarse_datetime_repr(datetime.datetime(year+1, 1, 1))
# Never show news items that aren't published yet
last_moment = min(last_moment, now)
query['publication_date'] = (first_moment, last_moment)
else:
# Don't show news from future
query['publication_date'] = (None, now)
batch = get_catalog_batch_grid(context, request, **query)
return batch
def get_report_query(report, request):
"""Produce query parameters for a catalog search"""
kw = {}
if report.query:
kw.update(report.query)
for catid, values in report.filters.items():
kw['category_%s' % catid] = {'query': values, 'operator': 'or'}
principals = effective_principals(request)
kw['allowed'] = {'query': principals, 'operator': 'or'}
letter = request.params.get('lastnamestartswith')
if letter:
kw['lastnamestartswith'] = letter.upper()
body = request.params.get('body')
if body:
kw['texts'] = body.strip() + '*'
return kw
def show_communities_view(context, request):
system_name = get_setting(context, 'system_name', 'KARL')
page_title = '%s Communities' % system_name
actions = []
if has_permission('create', context, request):
actions.append(('Add Community', 'add_community.html'))
api = TemplateAPI(context, request, page_title)
# Grab the data for the two listings, main communities and portlet
communities_path = model_path(context)
query = dict(
sort_index='title',
interfaces=[ICommunity],
path={'query': communities_path, 'depth': 1},
allowed={'query': effective_principals(request), 'operator': 'or'},
)
titlestartswith = request.params.get('titlestartswith')
if titlestartswith:
query['titlestartswith'] = (titlestartswith, titlestartswith)
batch_info = get_catalog_batch_grid(context, request, **query)
communities = []
for community in batch_info['entries']:
adapted = getMultiAdapter((community, request), ICommunityInfo)
communities.append(adapted)
mgr = ILetterManager(context)
letter_info = mgr.get_info(request)
my_communities = get_my_communities(context, request)
return render_template_to_response(
'templates/communities.pt',
api=api,
actions=actions,
communities=communities,
my_communities=my_communities,
batch_info=batch_info,
letters=letter_info,
)
def _get_catalog_events(calendar, request,
first_moment, last_moment, layer_name=None):
searcher = ICatalogSearch(calendar)
search_params = dict(
allowed={'query': effective_principals(request), 'operator': 'or'},
interfaces=[ICalendarEvent],
sort_index='start_date',
reverse=False,
)
if first_moment:
end_date = (coarse_datetime_repr(first_moment), None)
search_params['end_date'] = end_date
if last_moment:
start_date = (None, coarse_datetime_repr(last_moment))
search_params['start_date'] = start_date
docids_seen = set()
events = []
for layer in _get_calendar_layers(calendar):
if layer_name and layer.__name__ != layer_name:
continue
total, docids, resolver = searcher(
virtual={'query':layer.paths, 'operator':'or'},
**search_params)
for docid in docids:
if docid not in docids_seen:
docids_seen.add(docid)
event = resolver(docid)
event._v_layer_color = layer.color.strip()
event._v_layer_title = layer.title
events.append(event)
return events
def _makeCriteria(self):
principals = effective_principals(self.request)
# this is always assumed to be a global search; it does no
# path filtering
criteria = {}
if self.term:
criteria['sort_index'] = 'texts'
q = WeightedQuery(self.term)
if len(self.interfaces) == 1:
q.marker = self.interfaces[0].queryTaggedValue('marker')
criteria['texts'] = q
interfaces = self.interfaces
if not interfaces:
interfaces = [IContent]
criteria['interfaces'] = {'query':interfaces, 'operator':'or'}
criteria['allowed'] = {'query':principals, 'operator':'or'}
containment = self.containment
if containment:
criteria['containment'] = {'query': containment, 'operator': 'or'}
return criteria
def recent_content_view(context, request):
batch = get_catalog_batch(context, request,
sort_index='creation_date', reverse=True,
interfaces=[IContent], creator=context.__name__,
allowed={'query': effective_principals(request), 'operator': 'or'},
)
recent_items = []
for item in batch['entries']:
adapted = getMultiAdapter((item, request), IGridEntryInfo)
recent_items.append(adapted)
page_title = "Content Added Recently by %s" % context.title
api = TemplateAPI(context, request, page_title)
return render_template_to_response(
'templates/profile_recent_content.pt',
api=api,
batch_info=batch,
recent_items=recent_items,
)
def _get_all_calendar_categories(context, request):
calendar_categories = []
searcher = queryAdapter(context, ICatalogSearch)
if searcher is not None:
total, docids, resolver = searcher(
allowed={'query': effective_principals(request), 'operator': 'or'},
interfaces={'query':[ICalendarCategory],'operator':'or'},
reverse=False,
)
for docid in docids:
ob = resolver(docid)
path = model_path(ob)
folder = path.rsplit('/', 1)[0]
title = _calendar_category_title(ob)
calendar_categories.append({'title':title, 'path':path,
'folder':folder})
calendar_categories.sort(key=lambda x: (x['folder'], x['title']))
return calendar_categories
def recent_items(self):
if self._recent_items is None:
community = find_interface(self.context, ICommunity)
if community is not None:
community_path = model_path(community)
search = getAdapter(self.context, ICatalogSearch)
principals = effective_principals(self.request)
self._recent_items = []
num, docids, resolver = search(
limit=10,
path={"query": community_path},
allowed={"query": principals, "operator": "or"},
sort_index="modified_date",
reverse=True,
interfaces=[ICommunityContent],
)
models = filter(None, map(resolver, docids))
for model in models:
adapted = getMultiAdapter((model, self.request), IGridEntryInfo)
self._recent_items.append(adapted)
return self._recent_items
def get_my_communities(communities_folder, request):
# sorted by title
principals = effective_principals(request)
communities = {}
for name, role in get_community_groups(principals):
if name in communities:
continue
try:
community = communities_folder[name]
except KeyError:
continue
communities[name] = (community.title, community)
communities = communities.values()
communities.sort()
communities = [ x[1] for x in communities ]
my_communities = []
for community in communities:
adapted = getMultiAdapter((community, request), ICommunityInfo)
my_communities.append(adapted)
return my_communities
def related_communities_ajax_view(context, request):
assert ICommunity.providedBy(context), str(type(context))
related = []
principals = effective_principals(request)
searcher = ICatalogSearch(context)
search = ' OR '.join(context.title.lower().split())
total, docids, resolver = searcher(interfaces=[ICommunity],
limit=5,
reverse=True,
sort_index="modified_date",
texts=search,
allowed={'query': principals,
'operator': 'or'},
)
for docid in docids:
model = resolver(docid)
if model is not None:
if model is not context:
adapted = getMultiAdapter((model, request), IGridEntryInfo)
related.append(adapted)
return {'items': related}
def get_images_batch(context,
request,
creator=None, # 'My Recent' in imagedrawer
community=None, # 'This Community' in imagedrawer
batch_start=0,
batch_size=12,
sort_index='creation_date',
reverse=True,
batcher=get_catalog_batch): # For unit testing
search_params = dict(
interfaces=[IImage,],
allowed={'query': effective_principals(request), 'operator': 'or'},
sort_index=sort_index,
reverse=reverse,
batch_start=batch_start,
batch_size=batch_size,
)
if creator is not None:
search_params['creator'] = creator
if community is not None:
search_params['path'] = community
return batcher(context, request, **search_params)
def __init__(self, context, request, page_title=None):
site = find_site(context)
self.context = context
self.request = request
self.userid = authenticated_userid(request)
self.app_url = app_url = request.application_url
self.profile_url = app_url + "/profiles/%s" % self.userid
self.here_url = self.context_url = model_url(context, request)
self.view_url = model_url(context, request, request.view_name)
settings = queryUtility(ISettings)
self.js_devel_mode = settings and getattr(settings, "js_devel_mode", None)
self.read_only = settings and getattr(settings, "read_only", False)
self.static_url = "%s/static/%s" % (app_url, _get_static_rev())
# this data will be provided for the client javascript
self.karl_client_data = {}
# Provide a setting in the INI to fully control the entire URL
# to the static. This is when the proxy runs a different port
# number, or to "pipeline" resources on a different URL path.
full_static_path = getattr(settings, "full_static_path", False)
if full_static_path:
if "%d" in full_static_path:
# XXX XXX note self._start_time is needed... and not _start_time
# XXX XXX since this was a trivial bug, there is chance that
# XXX XXX this actually never runs! TODO testing???
full_static_path = full_static_path % self._start_time
self.static_url = full_static_path
self.page_title = page_title
self.system_name = get_setting(context, "system_name", "KARL")
self.user_is_admin = "group.KarlAdmin" in effective_principals(request)
self.can_administer = has_permission("administer", site, request)
self.can_email = has_permission("email", site, request)
self.admin_url = model_url(site, request, "admin.html")
self.site_announcement = getattr(site, "site_announcement", "")
# XXX XXX XXX This will never work from peoples formish templates
# XXX XXX XXX (edit_profile and derivates) because, in those form
# XXX XXX XXX controllers, the api is instantiated from __init__,
# XXX XXX XXX where request.form is still unset!!! (From all other
# XXX XXX XXX formcontrollers the api is instantiated from __call__,
# XXX XXX XXX which is why this works. A chicken-and-egg problem, really.
if hasattr(request, "form") and getattr(request.form, "errors", False):
# This is a failed form submission request, specify an error message
self.error_message = u"Please correct the indicated errors."
if settings:
self.kaltura_info = dict(
enabled=getattr(settings, "kaltura_enabled", False) in ("true", "True"),
partner_id=getattr(settings, "kaltura_partner_id", ""),
sub_partner_id=getattr(settings, "kaltura_sub_partner_id", ""),
admin_secret=getattr(settings, "kaltura_admin_secret", ""),
user_secret=getattr(settings, "kaltura_user_secret", ""),
kcw_uiconf_id=getattr(settings, "kaltura_kcw_uiconf_id", "1000741"),
player_uiconf_id=getattr(settings, "kaltura_player_uiconf_id", ""),
player_cache_st=getattr(settings, "kaltura_player_cache_st", ""),
local_user=self.userid,
)
if not getattr(settings, "kaltura_client_session", False) in ("true", "True"):
# Secrets will not be sent to client, instead session is handled on the server.
self.kaltura_info["session_url"] = app_url + "/" + "kaltura_create_session.json"
else:
self.kaltura_info = dict(enabled=False)
# propagate the head data to the client
d = self.karl_client_data["kaltura"] = dict(self.kaltura_info)
# remove secrets if needed
if "session_url" in d:
# server side session management, do not send secrets to client
del d["user_secret"]
del d["admin_secret"]
def show_profile_view(context, request):
"""Show a profile with actions if the current user"""
page_title = "View Profile"
api = TemplateAPI(context, request, page_title)
# Create display values from model object
profile = {}
for name in [name for name in context.__dict__.keys() if not name.startswith("_")]:
profile_value = getattr(context, name)
if profile_value is not None:
# Don't produce u'None'
profile[name] = unicode(profile_value)
else:
profile[name] = None
if "fax" not in profile:
profile["fax"] = "" # BBB
# 'websites' is a property, so the loop above misses it
profile["websites"] = context.websites
# ditto for 'title'
profile["title"] = context.title
if profile.has_key("languages"):
profile["languages"] = context.languages
if profile.has_key("department"):
profile["department"] = context.department
if profile.get("last_login_time"):
stamp = context.last_login_time.strftime("%Y-%m-%dT%H:%M:%SZ")
profile["last_login_time"] = stamp
if profile.has_key("country"):
# translate from country code to country name
country_code = profile["country"]
country = countries.as_dict.get(country_code, u"")
profile["country"] = country
# Display portrait
photo = context.get("photo")
display_photo = {}
if photo is not None:
display_photo["url"] = thumb_url(photo, request, PROFILE_THUMB_SIZE)
else:
display_photo["url"] = api.static_url + "/images/defaultUser.gif"
profile["photo"] = display_photo
# provide client data for rendering current tags in the tagbox
client_json_data = dict(tagbox=get_tags_client_data(context, request))
# Get communities this user is a member of, along with moderator info
#
communities = {}
communities_folder = find_communities(context)
user_info = find_users(context).get_by_id(context.__name__)
if user_info is not None:
for group in user_info["groups"]:
if group.startswith("group.community:"):
unused, community_name, role = group.split(":")
if communities.has_key(community_name) and role != "moderators":
continue
community = communities_folder.get(community_name, None)
if community is None:
continue
if has_permission("view", community, request):
communities[community_name] = {
"title": community.title,
"moderator": role == "moderators",
"url": model_url(community, request),
}
communities = communities.values()
communities.sort(key=lambda x: x["title"])
preferred_communities = []
my_communities = None
name = context.__name__
# is this the current user's profile?
if authenticated_userid(request) == name:
preferred_communities = get_preferred_communities(communities_folder, request)
my_communities = get_my_communities(communities_folder, request)
tagger = find_tags(context)
if tagger is None:
tags = ()
else:
tags = []
names = tagger.getTags(users=[context.__name__])
for name, count in sorted(tagger.getFrequency(names, user=context.__name__), key=lambda x: x[1], reverse=True)[
:10
]:
tags.append({"name": name, "count": count})
# List recently added content
num, docids, resolver = ICatalogSearch(context)(
sort_index="creation_date",
reverse=True,
interfaces=[IContent],
limit=5,
creator=context.__name__,
allowed={"query": effective_principals(request), "operator": "or"},
)
recent_items = []
for docid in docids:
item = resolver(docid)
if item is None:
continue
adapted = getMultiAdapter((item, request), IGridEntryInfo)
recent_items.append(adapted)
return render_template_to_response(
"templates/profile.pt",
api=api,
profile=profile,
actions=get_profile_actions(context, request),
photo=photo,
head_data=convert_to_script(client_json_data),
communities=communities,
my_communities=my_communities,
preferred_communities=preferred_communities,
tags=tags,
recent_items=recent_items,
)
def get_topic_batch(forum, request):
return get_catalog_batch_grid(
forum, request, interfaces=[IForumTopic], reverse=True,
path={'query': model_path(forum)},
allowed={'query': effective_principals(request), 'operator': 'or'},
)
def member(self):
principals = set(effective_principals(self.request))
members = set(self.context.member_names)
return bool(principals & members)
def groups(self):
groups = [ principal for principal in effective_principals(self.request) if 'group:' in principal]
return groups
def groups(self):
groups = [
principal for principal in effective_principals(self.request)
if 'group:' in principal
]
return groups
