def get_current(self, group, user):
""" Returns a queryset of the current upcoming events """
qs = Event.objects.filter(group=group).filter(
state__in=[Event.STATE_SCHEDULED, Event.STATE_VOTING_OPEN])
if user:
qs = filter_tagged_object_queryset_for_user(qs, user)
return upcoming_event_filter(qs)
def get_current(self, group, user):
""" Returns a queryset of the current (non-attachment) files """
qs = FileEntry.objects.filter(group=group)
qs = exclude_special_folders(qs)
if user:
qs = filter_tagged_object_queryset_for_user(qs, user)
return qs.filter(is_container=False)
def get_queryset(self, skipFilter=False):
""" @param skipFilter: If true, the filtering for user will be skipped, so it can be done at a later (MRO) time. """
if not self.model:
raise ImproperlyConfigured('%s must define a model',
self.__class__.__name__)
qs = self.model._default_manager.filter(**self.get_queryset_filter())
if not skipFilter:
qs = filter_tagged_object_queryset_for_user(qs, self.request.user)
return qs
def get_current(self, group, user):
""" Returns a queryset of the current upcoming events """
qs = Note.objects.filter(group=group)
# mix in reflected objects
if "%s.%s" % (self._meta.app_label, self._meta.model_name
) in settings.COSINNUS_REFLECTABLE_OBJECTS:
mixin = MixReflectedObjectsMixin()
qs = mixin.mix_queryset(qs, self._meta.model, group)
if user:
qs = filter_tagged_object_queryset_for_user(qs, user)
return qs
def get_queryset(self, **kwargs):
""" Filter queryset for items which can be accessed by the user given their
visibility tags
"""
qs = super(RequireReadMixin, self).get_queryset(**kwargs)
# only use this filter on querysets of media_tagged models
# alternatively, we could check if qs.model is CosinnusGroup or BaseTaggableObjectModel subclass,
# or BaseUserProfileModel subclass, but this is more elegant:
if hasattr(qs.model, 'media_tag'):
self.unfiltered_qs = qs
qs = filter_tagged_object_queryset_for_user(qs, self.request.user)
# very important to set self.queryset to avoid redundant re-filters
self.queryset = qs
return qs
def _get_querysets_for_stream(self, stream, user, include_public=False):
""" Returns all (still-lazy) querysets for models that will appear
in the current stream. Only works for classes inheriting BaseTaggableObjectModel. """
querysets = []
# [u'cosinnus_etherpad.Etherpad', u'cosinnus_event.Event', u'cosinnus_file.FileEntry', 'cosinnus_todo.TodoEntry']
for registered_model in aor:
Renderer = aor[registered_model]
# filter out unwanted model types if set in the Stream
if stream and stream.models and registered_model not in stream.models.split(
','):
continue
app_label, model_name = registered_model.split('.')
model_class = apps.get_model(app_label, model_name)
# get base collection of models for that type
if BaseHierarchicalTaggableObjectModel in inspect.getmro(
model_class):
queryset = model_class._default_manager.filter(
is_container=False)
queryset = exclude_special_folders(queryset)
elif BaseTaggableObjectModel in inspect.getmro(model_class):
queryset = model_class._default_manager.all()
else:
continue
# filter for stream
queryset = self._filter_queryset_for_stream(
queryset, stream, user, include_public=include_public)
# mix in reflected objects
if registered_model.lower() in settings.COSINNUS_REFLECTABLE_OBJECTS and \
BaseTaggableObjectModel in inspect.getmro(model_class):
mixin = MixReflectedObjectsMixin()
queryset = mixin.mix_queryset(queryset, model_class, None,
user)
# filter for read permissions for user
queryset = filter_tagged_object_queryset_for_user(queryset, user)
# sorting
queryset = self._sort_queryset(queryset, stream)
querysets.append(queryset)
return querysets
def get_object_querysets(self, group, cosinnus_apps=None, user=None):
""" Returns all (still-lazy) querysets for BaseTaggableObjects in cosinnus apps.
Can be filtered to be viewable by a certain user, or only publicly viewable,
and can be filtered for a certain group only.
@param cosinnus_apps: Returns objects for these models, or for all registered models if None
- example: ['cosinnus_etherpad.Etherpad', 'cosinnus_event.Event', 'cosinnus_file.FileEntry']
@param group: Filter the objects to belong to this group, or any group if None
@param user: Filter the objects to be viewable by this user, or an anonymous user if None """
if user is None:
user = AnonymousUser()
querysets = []
for registered_model in aor:
app_label, model_name = registered_model.split('.')
app_is_active = app_label not in group.get_deactivated_apps()
# filter out unwanted model types if set in the Stream
if not app_is_active or cosinnus_apps is not None and app_label not in cosinnus_apps:
continue
model_class = apps.get_model(app_label, model_name)
# only use basic tagged models, not extending ones (to avoid duplicates)
bases_modules = [base.__module__ for base in model_class.__bases__]
if not 'cosinnus.models.tagged' in bases_modules:
continue
if hasattr(model_class, 'get_current'):
# get a pre-filtered user-specific recent set for this model
queryset = model_class.get_current(group, user)
else:
# get base collection of models for that type
queryset = model_class._default_manager.all()
# filter for read permissions for user
queryset = filter_tagged_object_queryset_for_user(
queryset, user)
# filter folders
if BaseHierarchicalTaggableObjectModel in model_class.__bases__:
queryset = model_class._default_manager.filter(
is_container=False)
querysets.append(queryset)
return querysets
def get_results(self, request, term, page, context):
tokens = term.lower().split()
aliases_dict = settings.COSINNUS_ATTACHABLE_OBJECTS_SUGGEST_ALIASES
results = []
attach_models = []
if 'model_as_target' in self.request.GET:
attach_models = self.kwargs.get('model', '').split(',')
else:
attach_models = attached_object_registry.get_attachable_to(
self.kwargs.get('model', None))
for attach_model_id in attach_models:
aliases = aliases_dict.get(attach_model_id, [])
aliases = '||'.join(aliases)
app_label, model_name = attach_model_id.split('.')
attach_model_class = get_model(app_label, model_name)
if BaseHierarchicalTaggableObjectModel in attach_model_class.__bases__:
queryset = attach_model_class._default_manager.filter(
group__slug=self.kwargs.get('group', None),
is_container=False)
else:
queryset = attach_model_class._default_manager.filter(
group__slug=self.kwargs.get('group', None))
queryset = filter_tagged_object_queryset_for_user(
queryset, self.request.user)
""" For each token in the search query, filter the full object queryset further down,
comparing the titles of these objects, unless: the query is in the special aliases list
for that model type (for example 'eve' matches 'events', which is a special alias of
cosinnus_event.Event, and thus only further restrict-filters objects that are not events. """
for token in tokens:
if not token in aliases:
queryset = queryset.filter(Q(title__icontains=token))
# these result sets are what select2 uses to build the choice list
for result in queryset:
results.append(
build_attachment_field_result(attach_model_id, result))
return (NO_ERR_RESP, False, results
) # Any error response, Has more results, options list
def get_current(self, group, user, include_sub_projects=False):
""" Returns a queryset of the current upcoming events """
groups = [group]
if include_sub_projects:
groups = groups + list(group.get_children())
qs = Event.objects.filter(group__in=groups).filter(state__in=[
Event.STATE_SCHEDULED,
Event.STATE_VOTING_OPEN,
])
if not include_sub_projects:
# mix in reflected objects, not needed if we are sub-grouping anyways
for onegroup in groups:
if "%s.%s" % (self._meta.app_label, self._meta.model_name
) in settings.COSINNUS_REFLECTABLE_OBJECTS:
mixin = MixReflectedObjectsMixin()
qs = mixin.mix_queryset(qs, self._meta.model, onegroup)
if user:
qs = filter_tagged_object_queryset_for_user(qs, user)
return upcoming_event_filter(qs).distinct()
def get_current(self, group, user):
""" Returns a queryset of the current polls """
qs = Poll.objects.filter(group=group)
if user:
qs = filter_tagged_object_queryset_for_user(qs, user)
return current_poll_filter(qs)
def get_object_list_for_user(cls, user, qs_filter, limit=30):
qs = cls.get_model()._default_manager.filter(**qs_filter)
qs = filter_tagged_object_queryset_for_user(qs, user)
if limit > 0:
qs = qs[:limit]
return qs
def fetch_queryset_for_user(self,
model,
user,
sort_key=None,
only_mine=True,
only_mine_strict=True,
current_only=True):
""" Retrieves a queryset of sorted content items for a user, for a given model.
@param model: An actual model class. Supported are all `BaseTaggableObjectModel`s,
`CosinnusIdea`, and `postman.Message`
@param user: Querysets are filtered by view permission for this user
@param sort_key: (optional) the key for the `order_by` clause for the queryset
@param only_mine: if True, will only show objects that belong to groups or projects
the `user` is a member of, including the Forum, and including Ideas.
If False, will include all visible items in this portal for the user.
@param only_mine_strict: If set to True along with `only_mine`, really only objects
from the user's groups and projects will be returned, *excluding* the Forum and
Ideas.
@param current_only: if True, will only retrieve current items (ie, upcoming events)
TODO: is this correct?
"""
ct = ContentType.objects.get_for_model(model)
model_name = '%s.%s' % (ct.app_label, ct.model_class().__name__)
# ideas are excluded in strict mode
if model is CosinnusIdea and only_mine and only_mine_strict:
return model.objects.none()
queryset = None
skip_filters = False
if BaseHierarchicalTaggableObjectModel in inspect.getmro(model):
queryset = model._default_manager.filter(is_container=False)
queryset = exclude_special_folders(queryset)
elif model_name == 'cosinnus_event.Event':
if current_only:
queryset = model.objects.all_upcoming()
else:
queryset = model.objects.get_queryset()
queryset = queryset.exclude(is_hidden_group_proxy=True)
elif model_name == 'cosinnus_marketplace.Offer':
queryset = model.objects.all_active()
elif model is CosinnusIdea or BaseTaggableObjectModel in inspect.getmro(
model):
queryset = model._default_manager.all()
elif model_name == "postman.Message":
queryset = model.objects.inbox(user)
skip_filters = True
elif model is get_cosinnus_group_model() or issubclass(
model, get_cosinnus_group_model()):
queryset = model.objects.get_queryset()
else:
return None
assert queryset is not None
if not skip_filters:
# mix in reflected objects
if model_name.lower() in settings.COSINNUS_REFLECTABLE_OBJECTS and \
BaseTaggableObjectModel in inspect.getmro(model):
mixin = MixReflectedObjectsMixin()
queryset = mixin.mix_queryset(queryset, model, None, user)
portal_id = CosinnusPortal.get_current().id
portal_list = [portal_id]
if False:
# include all other portals in pool
portal_list += getattr(
settings, 'COSINNUS_SEARCH_DISPLAY_FOREIGN_PORTALS', [])
if model is CosinnusIdea or model is get_cosinnus_group_model(
) or issubclass(model, get_cosinnus_group_model()):
queryset = queryset.filter(portal__id__in=portal_list)
else:
queryset = queryset.filter(group__portal__id__in=portal_list)
user_group_ids = get_cosinnus_group_model(
).objects.get_for_user_pks(user)
# in strict mode, filter any content from the default groups as well
if only_mine and only_mine_strict:
exclude_slugs = get_default_user_group_slugs()
if exclude_slugs:
exclude_groups = get_cosinnus_group_model(
).objects.get_cached(slugs=exclude_slugs,
portal_id=portal_id)
exclude_group_ids = [
group.id for group in exclude_groups
]
user_group_ids = [
group_id for group_id in user_group_ids
if group_id not in exclude_group_ids
]
filter_q = Q(group__pk__in=user_group_ids)
# if the switch is on, also include public posts from all portals
if not only_mine:
filter_q = filter_q | Q(
media_tag__visibility=BaseTagObject.VISIBILITY_ALL)
queryset = queryset.filter(filter_q)
# filter for read permissions for user
queryset = filter_tagged_object_queryset_for_user(
queryset, user)
if sort_key:
queryset = queryset.order_by(sort_key)
else:
queryset = queryset.order_by('-created')
return queryset
def get_queryset(self):
qs = super(UpcomingEvents, self).get_queryset()
qs = filter_tagged_object_queryset_for_user(qs, self.request.user)
return qs
def cosinnus_menu_v2(context, template="cosinnus/v2/navbar/navbar.html"):
""" Renders the new style navbar """
if 'request' not in context:
raise ImproperlyConfigured("Current request missing in rendering "
"context. Include 'django.core.context_processors.request' in the "
"TEMPLATE_CONTEXT_PROCESSORS.")
request = context['request']
user = request.user
if user.is_authenticated:
from cosinnus.views.user_dashboard import MyGroupsClusteredMixin
from cosinnus.models.user_dashboard import DashboardItem
def _escape_quotes(text):
return text.replace('\\', '\\\\').replace('"', '\\"').replace("'", "\\'")
if settings.COSINNUS_IDEAS_ENABLED:
# "My Ideas"
my_ideas = CosinnusIdea.objects.all_in_portal().filter(creator=user).order_by(Lower('title'))
context['my_ideas_json_encoded'] = _escape_quotes(_json.dumps([DashboardItem(idea) for idea in my_ideas]))
# "Followed Ideas"
idea_content_type = ContentType.objects.get_for_model(CosinnusIdea)
my_followed_ids = LikeObject.objects.filter(content_type=idea_content_type, user=user, followed=True).values_list('object_id', flat=True)
my_followed_ideas = CosinnusIdea.objects.all_in_portal().filter(id__in=my_followed_ids).order_by(Lower('title'))
my_followed_ideas = my_followed_ideas.exclude(creator=user)
context['followed_ideas_json_encoded'] = _escape_quotes(_json.dumps([DashboardItem(idea) for idea in my_followed_ideas]))
# "My Groups and Projects"
context['group_clusters_json_encoded'] = _escape_quotes(_json.dumps(MyGroupsClusteredMixin().get_group_clusters(user)))
# "Invitations"
societies_invited = CosinnusSociety.objects.get_for_user_invited(request.user)
projects_invited = CosinnusProject.objects.get_for_user_invited(request.user)
groups_invited = [DashboardItem(group) for group in societies_invited]
groups_invited += [DashboardItem(group) for group in projects_invited]
context['groups_invited_json_encoded'] = _escape_quotes(_json.dumps(groups_invited))
context['groups_invited_count'] = len(groups_invited)
membership_requests = []
membership_requests_count = 0
admined_group_ids = CosinnusGroup.objects.get_for_user_group_admin_pks(request.user)
admined_groups = CosinnusGroup.objects.get_cached(pks=admined_group_ids)
for admined_group in admined_groups:
pending_ids = CosinnusGroupMembership.objects.get_pendings(group=admined_group)
if len(pending_ids) > 0:
membership_request_item = DashboardItem()
membership_request_item['icon'] = 'fa-sitemap' if admined_group.type == CosinnusGroup.TYPE_SOCIETY else 'fa-group'
membership_request_item['text'] = escape('%s (%d)' % (admined_group.name, len(pending_ids)))
membership_request_item['url'] = group_aware_reverse('cosinnus:group-detail', kwargs={'group': admined_group}) + '#requests'
membership_requests.append(membership_request_item)
membership_requests_count += len(pending_ids)
context['group_requests_json_encoded'] = _escape_quotes(_json.dumps(membership_requests))
context['group_requests_count'] = membership_requests_count
attending_events = []
try:
from cosinnus_event.models import Event, EventAttendance # noqa
my_attendances_ids = EventAttendance.objects.filter(user=user, state__gt=EventAttendance.ATTENDANCE_NOT_GOING).values_list('event_id', flat=True)
attending_events = Event.get_current_for_portal().filter(id__in=my_attendances_ids)
attending_events = filter_tagged_object_queryset_for_user(attending_events, user)
except:
if settings.DEBUG:
raise
context['attending_events_json_encoded'] = _escape_quotes(_json.dumps([DashboardItem(event) for event in attending_events]))
# TODO cache the dumped JSON strings?
return render_to_string(template, context.flatten())
def public(self):
from cosinnus.utils.permissions import filter_tagged_object_queryset_for_user
return filter_tagged_object_queryset_for_user(self, AnonymousUser())
def get_current(self, group, user):
""" Returns a queryset of the current calcs """
qs = Ethercalc.objects.filter(group=group)
if user:
qs = filter_tagged_object_queryset_for_user(qs, user)
return qs.filter(is_container=False)
def get_current(self, group, user):
""" Returns a queryset of the current upcoming events """
qs = TodoEntry.objects.filter(group=group)
if user:
qs = filter_tagged_object_queryset_for_user(qs, user)
return qs.filter(is_completed=False)
