def clean(self, value):
""" We organize the ids gotten back from the recipient select2 field.
This is a list of mixed ids which could either be groups or users.
See cosinnus_messages.views.UserSelect2View for how these ids are built.
Example for <value>: [u'user:1', u'group:4']
"""
if self.required and not value:
raise ValidationError(self.error_messages['required'])
user_ids, group_ids = self.get_user_and_group_ids_for_value(value)
# add group members to the list
groups = CosinnusGroup.objects.get_cached(pks=group_ids)
recipients = set()
for group in groups:
group_members = get_user_model().objects.filter(
id__in=group.members)
recipients.update(filter_active_users(group_members))
# combine the groups users with the directly selected users
recipients.update(
filter_active_users(User.objects.filter(id__in=user_ids)))
return list(recipients)
def get_statistics(self, from_date, to_date):
""" Actual collection of data """
created_users = filter_active_users(get_user_model().objects.filter(id__in=CosinnusPortal.get_current().members))\
.filter(date_joined__gte=from_date, date_joined__lte=to_date).count()
active_users = filter_active_users(get_user_model().objects.filter(id__in=CosinnusPortal.get_current().members))\
.filter(date_joined__lte=to_date).count()
created_projects = CosinnusProject.objects.filter(
portal=CosinnusPortal.get_current(),
is_active=True,
created__gte=from_date,
created__lte=to_date).count()
created_groups = CosinnusSociety.objects.filter(
portal=CosinnusPortal.get_current(),
is_active=True,
created__gte=from_date,
created__lte=to_date).count()
active_projects = CosinnusProject.objects.filter(
portal=CosinnusPortal.get_current(),
is_active=True,
created__lte=to_date).count()
active_groups = CosinnusSociety.objects.filter(
portal=CosinnusPortal.get_current(),
is_active=True,
created__lte=to_date).count()
statistics = {
'1. New Registered Users': created_users,
'2. Active Users': active_users,
'3. New Created Projects': created_projects,
'4. Active Projects': active_projects,
'5. New Created Groups': created_groups,
'6. Active Groups': active_groups,
}
try:
from cosinnus_event.models import Event
created_event_count = Event.objects.filter(
group__portal=CosinnusPortal.get_current(),
created__gte=from_date,
created__lte=to_date).count()
statistics.update({
'7. Created Events': created_event_count,
})
except:
pass
try:
from cosinnus_note.models import Note
created_note_count = Note.objects.filter(
group__portal=CosinnusPortal.get_current(),
created__gte=from_date,
created__lte=to_date).count()
statistics.update({
'8. Created News': created_note_count,
})
except:
pass
statistics = sorted(statistics.items())
return statistics
def general(request):
""" Returns a JSON dict of common statistics for this portal """
all_users_qs = get_user_model().objects.filter(id__in=CosinnusPortal.get_current().members)
data = {
'groups': CosinnusSociety.objects.all_in_portal().count(),
'projects': CosinnusProject.objects.all_in_portal().count(),
'users_registered': all_users_qs.count(),
'users_active': filter_active_users(all_users_qs).count(),
}
try:
from cosinnus_event.models import Event
upcoming_event_count = Event.get_current_for_portal().count()
data.update({
'events_upcoming': upcoming_event_count,
})
except:
pass
try:
from cosinnus_note.models import Note
note_count = Note.get_current_for_portal().count()
data.update({
'notes': note_count,
})
except:
pass
return JsonResponse(data)
def get_results(self, request, term, page, context):
term = term.lower()
start = (page - 1) * 10
end = page * 10
User = get_user_model()
uids = self.group.members
# if this is a Project, add all users of its parent Group as well
# (disabled for now as it leads to a lot of confusion)
# if self.group.parent:
# uids = list(set(uids + self.group.parent.members))
terms = term.strip().lower().split(' ')
q = get_user_query_filter_for_search_terms(terms)
user_qs = filter_active_users(
User.objects.filter(id__in=uids).filter(q))
count = user_qs.count()
if count < start:
raise Http404
has_more = count > end
users = user_qs.all()[start:end]
#results = get_user_choices(users)
results = get_user_select2_pills(users)
return (NO_ERR_RESP, has_more, results)
def reset_user_tos_flags(request=None):
if request and not request.user.is_superuser:
return HttpResponseForbidden('Not authenticated')
if not request.GET.get('confirm', False) == '1':
active_users = filter_active_users(get_user_model().objects.all())
ret = '********** This will reset all %d active users\' ToS accepted flag! Use param ?confirm=1 to delete the flags! ***********' % active_users.count()
else:
count = 0
active_users = filter_active_users(get_user_model().objects.all())
for profile in get_user_profile_model().objects.all().filter(user__in=active_users):
del profile.settings['tos_accepted']
profile.save(update_fields=['settings'])
count += 1
ret = 'Successfully reset the ToS flag for %d users.' % count
return HttpResponse(ret)
def get_data(self, offset=0):
""" Returns a tuple (data, rows_returned, has_more) of the rendered data and how many items were returned.
if has_more == False, the receiving widget will assume no further data can be loaded.
"""
group = self.config.group
if group is None:
return ''
# how many members display. it's -1 because the last tile is always the "+72 members"
count = getattr(settings, 'COSINNUS_GROUP_MEMBER_WIDGET_USER_COUNT',
19)
admin_ids = CosinnusGroupMembership.objects.get_admins(group=group)
member_ids = CosinnusGroupMembership.objects.get_members(group=group)
all_ids = set(admin_ids + member_ids)
userprofile_table = get_user_profile_model()._meta.db_table
qs = filter_active_users(get_user_model().objects.all()) \
.select_related('cosinnus_profile') \
.extra(select={
'has_avatar': 'LENGTH(%s.avatar) > 0' % userprofile_table
}) \
.order_by('-has_avatar', 'first_name', 'last_name')
qs = qs.filter(id__in=all_ids)
self.member_count = qs.count()
hidden_member_count = 0
is_member_of_this_group = self.request.user.pk in all_ids
if not self.request.user.is_authenticated:
visibility_level = BaseTagObject.VISIBILITY_ALL
elif not is_member_of_this_group:
visibility_level = BaseTagObject.VISIBILITY_GROUP
else:
visibility_level = -1
# show VISIBILITY_ALL users to anonymous users, VISIBILITY_GROUP to logged in users,
# and all members to group-members
if visibility_level != -1:
qs = qs.filter(
cosinnus_profile__media_tag__visibility__gte=visibility_level)
hidden_member_count = self.member_count - len(qs)
has_more = len(qs) > offset + count or hidden_member_count > 0
more_count = max(0, len(qs) - (offset + count)) + hidden_member_count
if count != 0:
qs = qs[offset:offset + count]
data = {
'group': group,
'members': qs,
'has_more': has_more,
'more_count': more_count,
}
return (render_to_string('cosinnus/widgets/group_members.html',
data), len(qs), has_more)
def get_context_data(self, **kwargs):
context = super(InteractiveTodoEntryMixin,
self).get_context_data(**kwargs)
context.update({
'group_users':
filter_active_users(get_user_model().objects.filter(
id__in=self.group.members).prefetch_related(
'cosinnus_profile'))
})
return context
def get_queryset(self):
# get all users from this portal only
# we also exclude users who have never logged in
all_users = filter_active_users(super(UserListView, self).get_queryset().filter(id__in=CosinnusPortal.get_current().members))
if self.request.user.is_authenticated():
visibility_level = BaseTagObject.VISIBILITY_GROUP
else:
visibility_level = BaseTagObject.VISIBILITY_ALL
# only show users with the visibility level
qs = all_users.filter(cosinnus_profile__media_tag__visibility__gte=visibility_level)
self.hidden_users = all_users.exclude(cosinnus_profile__media_tag__visibility__gte=visibility_level)
qs = qs.order_by('first_name', 'last_name')
qs = qs.select_related('cosinnus_profile')
return qs
def handle(self, *args, **options):
try:
initialize_cosinnus_after_startup()
self.stdout.write(
"Checking active users and creating any missing nextcloud user accounts."
)
counter = 0
created = 0
errors = 0
all_users = filter_active_users(filter_portal_users(get_user_model().objects.all()))
# retrieve all existing users so we don't create them anew
existing_nc_users = list_all_users()
total_users = len(all_users)
for user in all_users:
counter += 1
# only add user if not already in NC user DB with their id
if not get_nc_user_id(user) in existing_nc_users:
try:
create_user_from_obj(user)
created += 1
except OCSException as e:
if not e.statuscode == 102: # 102: user already exists
errors += 1
self.stdout.write(
f"Error: OCSException: '{e.message}' ({e.statuscode})"
)
except Exception as e:
if settings.DEBUG:
raise
errors += 1
self.stdout.write("Error: Exception: " + str(e))
self.stdout.write(
f"{counter}/{total_users} users checked, {created} nextcloud users created ({errors} Errors)",
ending="\r",
)
self.stdout.flush()
self.stdout.write(
f"Done! {counter}/{total_users} users checked, {created} nextcloud users created ({errors} Errors)."
)
except Exception as e:
if settings.DEBUG:
raise
def get(self, request, *args, **kwargs):
all_users_qs = self.get_user_qs()
data = {
'groups': self.get_society_qs().count(),
'projects': self.get_project_qs().count(),
'users_registered': all_users_qs.count(),
'users_active': filter_active_users(all_users_qs).count(),
}
try:
data.update({
'events_upcoming': self.get_event_qs().count(),
})
except:
pass
try:
data.update({
'notes': self.get_note_qs().count(),
})
except:
pass
return Response(data)
def get_results(self, request, term, page, context):
start = (page - 1) * 10
end = page * 10
User = get_user_model()
terms = term.strip().lower().split(' ')
q = get_user_query_filter_for_search_terms(terms)
user_qs = filter_active_users(
User.objects.filter(
id__in=CosinnusPortal.get_current().members).filter(q))
count = user_qs.count()
if count < start:
raise Http404
has_more = count > end
users = user_qs.all()[start:end]
#results = get_user_choices(users)
results = get_user_select2_pills(users)
return (NO_ERR_RESP, has_more, results)
def qs_func():
return filter_portal_users(
filter_active_users(get_user_model().objects.all()))
def index_queryset(self, using=None):
qs = self.get_model().objects.all()
qs = filter_active_users(qs, filter_on_user_profile_model=True)
qs = qs.select_related('user').all()
return qs
def filter_user_qs(self, user_qs, terms):
q = get_user_query_filter_for_search_terms(terms)
user_qs = filter_active_users(
user_qs.filter(
id__in=CosinnusPortal.get_current().members).filter(q))
return user_qs
def get_queryset(self):
include_uids = CosinnusPortal.get_current().members
exclude_uids = self.group.members
return filter_active_users(get_user_model().objects.filter(id__in=include_uids).exclude(id__in=exclude_uids))
