1 from django.forms.models import inlineformset_factory

     2 from cm.models import *

     3 from cm.message import *

     4 from django.contrib.auth import authenticate

     5 from django.contrib.auth import login as django_login  

     6 from django.forms import ModelForm

     7 from django.contrib.auth.models import User

     8 from django.forms.formsets import formset_factory

     9 from django.shortcuts import render_to_response

    10 from django.template import RequestContext

    11 from django.utils.translation import ugettext as _, ugettext_lazy, ungettext

    12 from django.http import HttpResponse, HttpResponseRedirect, Http404

    13 from django.forms.util import ErrorList

    14 from django.shortcuts import get_object_or_404

    15 from cm.activity import register_activity

    16 from cm.views import get_text_by_keys_or_404

    17 from cm.message import display_message

    18 from cm.utils import get_among, get_int

    19 from cm.models import ApplicationConfiguration

    20 from django.views.generic.list_detail import object_list

    21 from django.contrib.auth.decorators import login_required

    22 from cm.views import get_keys_from_dict

    23 from cm.security import has_global_perm

    24 from cm.exception import UnauthorizedException

    25 import sys

    26 import re

    27 

    28 USER_PAGINATION = 10

    29 

    30 @has_global_perm('can_manage_workspace')

    31 def user_list(request):    

    32     display_suspended_users = get_int(request.GET, 'display', 0)

    33     paginate_by = get_int(request.GET, 'paginate', USER_PAGINATION)

    34     order_by = get_among(request.GET, 'order', ('user__username',

    35                                               'user__email',

    36                                               '-user__username',

    37                                               '-user__email',

    38                                               'role__name',

    39                                               '-role__name',

    40                                               'user__date_joined',

    41                                               '-user__date_joined',

    42                                               ),

    43                           'user__username')

    44     

    45     UserRole.objects.create_userroles_text(None)

    46     

    47     if request.method == 'POST':

    48         # bulk apply

    49         if 'apply' in request.POST:

    50             action = request.POST.get('action', None)

    51             user_profile_keys = get_keys_from_dict(request.POST, 'check-').keys()

    52             if action == 'disable':

    53                 for user_profile_key in user_profile_keys:

    54                     profile = UserProfile.objects.get(key=user_profile_key)

    55                     if profile != request.user.get_profile():

    56                         profile.is_suspended = True

    57                         profile.save()             

    58                 display_message(request, _(u"%(count)i User's access suspended") % {'count':len(user_profile_keys)})

    59 

    60             if action == 'enable':

    61                 for user_profile_key in user_profile_keys:

    62                     profile = UserProfile.objects.get(key=user_profile_key)

    63                     profile.is_suspended = False

    64                     profile.save()             

    65                 display_message(request, _(u"%(count)i User's access enabled") % {'count':len(user_profile_keys)})

    66             

    67             ROLE_RE = re.compile('role_(\d*)')

    68             match = ROLE_RE.match(action)

    69               

    70             if match:

    71                 role_id = match.group(1)

    72                 for user_profile_key in user_profile_keys:

    73                     user_role = UserRole.objects.get(user__userprofile__key=user_profile_key, text=None)

    74                     user_role.role_id = role_id

    75                     user_role.save()

    76                 display_message(request, _(u"%(count)i user(s) role modified") % {'count':len(user_profile_keys)})

    77                 

    78             return HttpResponseRedirect(reverse('user'))

    79         

    80         if 'save' in request.POST:

    81             user_profile_keys_roles = get_keys_from_dict(request.POST, 'user-role-')

    82             count = 0

    83             for user_profile_key in user_profile_keys_roles:

    84                 role_id = user_profile_keys_roles[user_profile_key]

    85                 if not user_profile_key:

    86                     user_role = UserRole.objects.get(user=None, text=None)

    87                 else:                    

    88                     user_role = UserRole.objects.get(user__userprofile__key=user_profile_key, text=None)

    89                 if (role_id != u'' or user_role.role_id != None) and role_id != unicode(user_role.role_id):

    90                     if role_id:

    91                         user_role.role_id = int(role_id)

    92                     else:

    93                         user_role.role_id = None

    94                     user_role.save()

    95                     count += 1

    96             display_message(request, _(u"%(count)i user(s) role modified") % {'count':count})                

    97             return HttpResponseRedirect(reverse('user'))

    98     try:

    99         anon_role = UserRole.objects.get(user=None, text=None).role

   100     except UserRole.DoesNotExist:

   101         anon_role = None

   102         

   103     context = {

   104                'anon_role' : anon_role,

   105                'all_roles' : Role.objects.all(),

   106                'anon_roles' : Role.objects.filter(anon=True),

   107                'display_suspended_users' : display_suspended_users,

   108                }

   109     

   110     query = UserRole.objects.filter(text=None).filter(~Q(user=None)).order_by(order_by)

   111     if not display_suspended_users:

   112         query = query.exclude(Q(user__userprofile__is_suspended=True) & Q(user__is_active=True))

   113         

   114     return object_list(request, query,

   115                        template_name='site/user_list.html',

   116                        paginate_by=paginate_by,

   117                        extra_context=context,

   118                        )

   119 

   120 class UserForm(ModelForm):

   121     email = forms.EmailField(label=ugettext_lazy(u'E-mail address'), required=True)

   122     

   123     class Meta:

   124         model = User

   125         fields = ('email', 'first_name', 'last_name')

   126         

   127 

   128     def clean_email(self):

   129         """

   130         Validates that the supplied email is new to the site

   131         """

   132         if 'email' in self.cleaned_data:

   133             email = self.cleaned_data['email']

   134             try:

   135                 if self.instance:

   136                     user = User.objects.exclude(email__iexact=self.instance.email).get(email__iexact=email)

   137                 else:

   138                     user = User.objects.get(email__iexact=email)

   139             except User.DoesNotExist:

   140                 return email

   141             raise forms.ValidationError(_(u'This user is already a member.'))

   142         

   143 class MassUserForm(forms.Form):

   144     email = forms.CharField(label=ugettext_lazy(u'Emails'),

   145                            help_text=ugettext_lazy(u'Add multiples emails one per line (or separated by "," or ";")'),

   146                            widget=forms.Textarea,

   147                            required=True)

   148     

   149 class UserRoleForm(ModelForm):

   150     class Meta:

   151         model = UserRole

   152         fields = ('role',)

   153 

   154     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,

   155                  initial=None, error_class=ErrorList, label_suffix=':',

   156                  empty_permitted=False, instance=None):

   157         ModelForm.__init__(self, data, files, auto_id, prefix, initial, error_class, label_suffix, empty_permitted, instance)

   158 

   159         # override manually

   160         role_field = self.fields['role']

   161         #role_field.required = True

   162         role_field.label = _(u'Workspace level role')

   163         role_field.help_text = _(u'This role will apply to every text in the workspace. To share only a (few) texts with this user, you can leave this blank and delegate roles on texts once the user is created.')

   164         self.fields['role'] = role_field

   165         

   166 class UserRoleTextForm(ModelForm):

   167     class Meta:

   168         model = UserRole

   169         fields = ('role',)

   170 

   171     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,

   172                  initial=None, error_class=ErrorList, label_suffix=':',

   173                  empty_permitted=False, instance=None):

   174         ModelForm.__init__(self, data, files, auto_id, prefix, initial, error_class, label_suffix, empty_permitted, instance)

   175 

   176         # override manually

   177         role_field = self.fields['role']

   178         #role_field.required = True

   179         role_field.label = _(u'Text level role')

   180         role_field.help_text = _(u'This role will apply only to this text.')

   181         self.fields['role'] = role_field

   182         

   183 class UserProfileForm(ModelForm):

   184     class Meta:

   185         model = UserProfile

   186         fields = ('allow_contact', 'preferred_language', 'is_suspended')

   187 

   188 class MyUserProfileForm(ModelForm):

   189     class Meta:

   190         model = UserProfile

   191         fields = ('allow_contact', 'preferred_language')

   192 

   193 class UserProfileAddForm(ModelForm):

   194     class Meta:

   195         model = UserProfile

   196         fields = ('preferred_language',)

   197 

   198 class UserAddForm(forms.Form):

   199     note = forms.CharField(label=ugettext_lazy(u'Note'),

   200                            help_text=ugettext_lazy(u'Optional text to add to invitation email'),

   201                            widget=forms.Textarea,

   202                            required=False)

   203 

   204 

   205 SEPARATORS_RE = re.compile('[;,\n]+')

   206 

   207 @has_global_perm('can_manage_workspace')

   208 def user_mass_add(request, key=None):

   209     return user_add(request, key=key, mass=True)

   210 

   211 @has_global_perm('can_manage_workspace')

   212 def user_add(request, key=None, mass=False):

   213     text = get_text_by_keys_or_404(key) if key else None

   214     if request.method == 'POST':

   215         userform = UserForm(request.POST) if not mass else MassUserForm(request.POST)

   216         userroleform = UserRoleForm(request.POST)

   217         noteform = UserAddForm(request.POST)

   218         userprofileform = UserProfileAddForm(request.POST)

   219         localroleform = UserRoleTextForm(request.POST, prefix="local") if key else None

   220         if userform.is_valid() and userroleform.is_valid() and noteform.is_valid() and userprofileform.is_valid() and (not localroleform or localroleform.is_valid()):

   221             data = userform.cleaned_data

   222             data.update(userprofileform.cleaned_data)

   223             data.update(noteform.cleaned_data)

   224             emails = data['email']

   225             del data['email']

   226             email_created = set()

   227             for email in [s.strip() for s in SEPARATORS_RE.split(emails)]:

   228                 if email and not User.objects.filter(email__iexact=email) and email not in email_created:

   229                     user = UserProfile.objects.create_inactive_user(email, True, **data)

   230                     userrole = UserRole.objects.create(user=user, role=userroleform.cleaned_data['role'], text=None)

   231                     if key:

   232                         localuserrole = UserRole.objects.create(user=user, role=localroleform.cleaned_data['role'], text=text)

   233                     email_created.add(email)

   234                 register_activity(request, "user_created", user=user)

   235             display_message(request, ungettext(u'%(nb_users)d user added', u'%(nb_users)d users added', len(email_created)) % {'nb_users': len(email_created)})

   236             if key:

   237                 return HttpResponseRedirect(reverse('text-share', args=[text.key]))

   238             else:

   239                 return HttpResponseRedirect(reverse('user'))

   240     else:

   241         userform = UserForm() if not mass else MassUserForm()

   242         userroleform = UserRoleForm()

   243         userprofileform = UserProfileAddForm()

   244         noteform = UserAddForm()

   245         localroleform = UserRoleTextForm(prefix="local") if key else None

   246     

   247     if key:

   248         template = 'site/user_mass_add_text.html' if mass else 'site/user_add_text.html'

   249     else:

   250         template = 'site/user_mass_add.html' if mass else 'site/user_add.html'

   251 

   252     return render_to_response(template, {'forms' : [userform, userprofileform , userroleform, noteform, localroleform],

   253                                                                'save_name' : ungettext(u'Save user', u'Save users', 2 if mass else 1),

   254                                                                'mass' : mass,

   255                                                                'text' : text,

   256                                                                 }, context_instance=RequestContext(request))

   257 

   258 class UserValidateForm(ModelForm):

   259     email = forms.EmailField(label=ugettext_lazy(u'Email'), required=True)

   260     

   261     class Meta:

   262         model = User

   263         fields = ('email', 'username', 'first_name', 'last_name')

   264 

   265     def clean_username(self):

   266         """

   267         Validates that the supplied username is unique for the site.

   268         """

   269         if 'username' in self.cleaned_data:

   270             username = self.cleaned_data['username']

   271             try:

   272                 user = User.objects.get(username__exact=username)

   273             except User.DoesNotExist:

   274                 return username

   275             raise forms.ValidationError(_(u'This username is already in use. Please supply a different username.'))

   276         

   277 from django.contrib.auth.forms import SetPasswordForm

   278 

   279 def user_activate(request, key):

   280     try:

   281         profile = UserProfile.objects.get(adminkey=key)

   282         user = profile.user

   283         if not user.is_active:

   284             if request.method == 'POST':

   285                 userform = UserValidateForm(request.POST, instance=user)

   286                 pwform = SetPasswordForm(profile.user, request.POST)

   287                 if userform.is_valid() and pwform.is_valid():

   288                     userform.save()

   289                     pwform.save()

   290                     user.is_active = True

   291                     user.save()

   292                     # login

   293                     user.backend = 'django.contrib.auth.backends.ModelBackend'

   294                     django_login(request, user)

   295                     register_activity(request, "user_activated", user=user)

   296                     display_message(request, _(u"Your account has been activated. You're now logged-in."))

   297                     

   298                     return HttpResponseRedirect(reverse('index'))

   299             else:

   300                 user.username = ''

   301                 userform = UserValidateForm(instance=user)

   302                 pwform = SetPasswordForm(user)

   303             

   304             return render_to_response('site/activate.html', {

   305                                                                   'forms' : [userform, pwform],

   306                                                                   'title': _(u'Activate your account'),

   307                                                                   'save_name' : _(u'activate account'),

   308                                                                   }, context_instance=RequestContext(request))

   309         else:

   310             user.backend = 'django.contrib.auth.backends.ModelBackend'

   311             django_login(request, user)

   312             display_message(request, _(u"Your account has been activated. You're now logged-in."))

   313             

   314             return HttpResponseRedirect(reverse('index'))

   315                         

   316     except UserProfile.DoesNotExist:

   317         raise UnauthorizedException('No profile')

   318 

   319 #@has_global_perm('can_manage_workspace')

   320 #def user_delete(request, key):

   321 #    try:

   322 #        if request.method == 'POST':

   323 #            profile = UserProfile.objects.get(key=key)

   324 #            profile.delete()

   325 #            display_message(request, "User %s has been deleted." %(profile.simple_print()))

   326 #            return HttpResponse('') # no redirect because this is called by js

   327 #    except UserProfile.DoesNotExist:

   328 #        raise UnauthorizedException('No profile')

   329 

   330 @has_global_perm('can_manage_workspace')

   331 def user_suspend(request, key):

   332     if request.method == 'POST':

   333         profile = get_object_or_404(UserProfile, key=key)

   334         profile = UserProfile.objects.get(key=key)

   335         profile.is_suspended = True

   336         profile.save()

   337         if profile.user.is_active:            

   338             display_message(request, _(u"User's access %(prof)s has been suspended.") % {'prof':profile.simple_print()})

   339             register_activity(request, "user_suspended", user=profile.user)

   340         else:

   341             # make use active but disabled

   342             profile.user.is_active = True 

   343             profile.user.save()

   344             display_message(request, _(u"User's access %(prof)s has been refused.") % {'prof':profile.simple_print()})

   345             register_activity(request, "user_refused", user=profile.user)                

   346         return HttpResponse('') # no redirect because this is called by js

   347     raise UnauthorizedException('')

   348     

   349 @has_global_perm('can_manage_workspace')

   350 def user_enable(request, key):

   351     if request.method == 'POST':

   352         profile = get_object_or_404(UserProfile, key=key)

   353         profile = UserProfile.objects.get(key=key)

   354         profile.is_suspended = False

   355         profile.save()

   356         if profile.user.is_active:

   357             display_message(request, _(u"User's access %(prof)s has been restored.") % {'prof':profile.simple_print()})

   358             register_activity(request, "user_enabled", user=profile.user)

   359         else: # new member approval

   360             profile.send_activation_email()

   361             display_message(request, _(u"User's access %(prof)s has been approved.") % {'prof':profile.simple_print()})

   362             register_activity(request, "user_approved", user=profile.user)                

   363         return HttpResponse('') # no redirect because this is called by js

   364     raise UnauthorizedException('')

   365     

   366 def user_send_invitation(request, key):

   367     if request.method == 'POST':

   368         profile = get_object_or_404(UserProfile, key=key)

   369         profile.send_invitation_email()

   370         

   371         display_message(request, _(u"A new invitation has been sent to user %(prof)s.") % {'prof':profile.simple_print()})

   372         return HttpResponse('') # no redirect because this is called by js

   373     raise UnauthorizedException('')

   374 

   375 @login_required()

   376 def profile(request):

   377     user = request.user

   378     profile = user.get_profile()

   379     if request.method == 'POST':

   380         userform = UserForm(request.POST, instance=user)

   381         userprofileform = MyUserProfileForm(request.POST, instance=profile)

   382         if userform.is_valid() and userprofileform.is_valid():

   383             userform.save()

   384             userprofileform.save()

   385             display_message(request, _(u'Profile updated'))

   386             return HttpResponseRedirect(reverse('index'))

   387     else:

   388         userform = UserForm(instance=user)

   389         userprofileform = MyUserProfileForm(instance=profile)

   390     

   391     return render_to_response('site/profile.html', {'forms' : [userform, userprofileform],

   392                                                                'title' : 'Profile',

   393                                                                 }, context_instance=RequestContext(request))

   394 

   395 class AnonUserRoleForm(UserRoleForm):

   396     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,

   397                  initial=None, error_class=ErrorList, label_suffix=':',

   398                  empty_permitted=False, instance=None):

   399         ModelForm.__init__(self, data, files, auto_id, prefix, initial, error_class, label_suffix, empty_permitted, instance)

   400 

   401         # override manually

   402         role_field = self.fields['role']

   403         role_field.required = False

   404         role_field.choices = [(u'', u'---------')] + [(r.id, str(r)) for r in Role.objects.filter(anon=True)] # limit anon choices

   405         for c in role_field.choices:

   406             print c

   407         

   408         self.fields['role'] = role_field

   409 

   410 @has_global_perm('can_manage_workspace')    

   411 def user_anon_edit(request):

   412     userrole, created = UserRole.objects.get_or_create(user=None, text=None)

   413     if request.method == 'POST':

   414         userroleform = AnonUserRoleForm(request.POST, instance=userrole)

   415         if userroleform.is_valid():

   416             userroleform.save()

   417             display_message(request, _(u'Anonymous user role modified.'))

   418             return HttpResponseRedirect(reverse('user'))

   419     else:

   420         userroleform = AnonUserRoleForm(instance=userrole)

   421     

   422     return render_to_response('site/user_edit.html', {'form' : userroleform,

   423                                                                'title' : 'Edit anonymous user',

   424                                                                 }, context_instance=RequestContext(request))

   425 

   426 @has_global_perm('can_manage_workspace')    

   427 def user_edit(request, key):

   428     profile = UserProfile.objects.get(key=key)

   429     user = profile.user

   430     userrole = profile.global_userrole()

   431     if request.method == 'POST':

   432         userform = UserForm(request.POST, instance=user)

   433         userprofileform = UserProfileForm(request.POST, instance=profile)

   434         userroleform = UserRoleForm(request.POST, instance=userrole)

   435         if userform.is_valid() and userroleform.is_valid() and userprofileform.is_valid():

   436             userform.save()

   437             userroleform.save()

   438             userprofileform.save()

   439             display_message(request, _(u'User modified'))

   440             return HttpResponseRedirect(reverse('user'))

   441     else:

   442         userform = UserForm(instance=user)

   443         userprofileform = UserProfileForm(instance=profile)

   444         userroleform = UserRoleForm(instance=userrole)

   445     

   446     return render_to_response('site/user_edit.html', {'forms' : [userform , userprofileform, userroleform],

   447                                                                'title' : 'Edit user',

   448                                                                'user_edit' : user,

   449                                                                 }, context_instance=RequestContext(request))

   450 

   451 # user contact form (for logged-in users only

   452 

   453 class UserContactForm(forms.Form):

   454     subject = forms.CharField(label=ugettext_lazy(u'Subject'),

   455                            help_text=ugettext_lazy(u'Subject of the email'),

   456                            required=True)

   457 

   458     body = forms.CharField(label=ugettext_lazy(u'Body'),

   459                            help_text=ugettext_lazy(u'Body of the email'),

   460                            widget=forms.Textarea,

   461                            required=True)

   462 

   463 @login_required

   464 def user_contact(request, key):

   465     recipient_profile = UserProfile.objects.get(key=key)

   466 

   467     if request.method == 'POST':

   468         contact_form = UserContactForm(request.POST)

   469         if contact_form.is_valid():

   470             data = contact_form.cleaned_data

   471             message = render_to_string('email/user_contact_email.txt',

   472                                        { 

   473                                          'body' : data['body'],

   474                                          'CONF': ApplicationConfiguration

   475                                           })

   476         

   477             send_mail(data['subject'], message, request.user.email, [recipient_profile.user.email])

   478             

   479             display_message(request, _(u'Email sent.'))

   480             return HttpResponseRedirect(reverse('index'))

   481     else:

   482         contact_form = UserContactForm()

   483     

   484     return render_to_response('site/user_contact.html', {'form' : contact_form,

   485                                                          'save_name' : 'send',

   486                                                                 }, context_instance=RequestContext(request))

   487 

   488 

   489 from django.contrib.auth.forms import AuthenticationForm

   490 

   491 def cm_login(request, user):

   492     # make sure user has a profile

   493     try:

   494         user.get_profile()

   495     except UserProfile.DoesNotExist :

   496         UserProfile.objects.create(user=user)

   497         

   498     if user.get_profile().is_suspended:

   499         display_message(request, _(u"This account is suspended, contact the workspace administrator."))

   500         return HttpResponseRedirect(reverse('index'))

   501                 

   502     user.backend = 'django.contrib.auth.backends.ModelBackend'

   503     django_login(request, user)

   504     

   505     display_message(request, _(u"You're logged in!"))

   506     next = request.POST.get('next', None)

   507     if next and next.startswith('/'):

   508         return HttpResponseRedirect(next)

   509     else:

   510         return HttpResponseRedirect(reverse('index'))

   511 

   512 def login(request): 

   513     request.session.set_test_cookie()

   514     

   515     if request.method == 'POST':

   516         form = AuthenticationForm(request, request.POST)

   517         if form.is_valid():

   518             user = form.get_user()

   519             

   520             return cm_login(request, user)            

   521     else:    

   522         form = AuthenticationForm()        

   523     

   524     return render_to_response('site/login.html', {'form':form}, context_instance=RequestContext(request))

   525 

   526 from django.contrib.auth import logout as django_logout

   527 

   528 def logout(request):

   529     django_logout(request)

   530     display_message(request, _(u"You've been logged out."))

   531     return HttpResponseRedirect(reverse('index'))

   532 

   533 def register(request):

   534     if request.method == 'POST':

   535         userform = UserForm(request.POST)

   536         userprofileaddform = UserProfileAddForm(request.POST)

   537         

   538         if userform.is_valid() and userprofileaddform.is_valid():

   539             data = userform.cleaned_data

   540             data.update(userprofileaddform.cleaned_data)

   541             user = UserProfile.objects.create_inactive_user(userform.cleaned_data['email'], False, **userprofileaddform.cleaned_data)

   542             profile = user.get_profile()

   543             if ApplicationConfiguration.get_key('workspace_registration_moderation', False): # need moderation

   544                 profile.is_suspended = True

   545                 profile.save()

   546                 display_message(request, _(u"You've been registered, you will receive a confirmation mail once a moderator has approved your membership."))                

   547             else:

   548                 profile.send_activation_email()

   549                 display_message(request, _(u"You've been registered, please check your email for the confirm message."))                

   550             return HttpResponseRedirect(reverse('index'))

   551     else:    

   552         userform = UserForm()

   553         userprofileaddform = UserProfileAddForm()

   554     

   555     return render_to_response('site/register.html', {'forms':[userform, userprofileaddform]}, context_instance=RequestContext(request))