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)