forum/forms.py

   1 import re
   2 from datetime import date
   3 from django import forms
   4 from models import *
   5 from const import *
   6 from django.utils.translation import ugettext as _
   7 from django.contrib.auth.models import User
   8 from django.contrib.contenttypes.models import ContentType
   9 from django.utils.safestring import mark_safe
  10 from forum.utils.forms import NextUrlField, UserNameField, SetPasswordForm
  11 from recaptcha_django import ReCaptchaField
  12 from django.conf import settings
  13 import logging
  14
  15 class TitleField(forms.CharField):
  16     def __init__(self, *args, **kwargs):
  17         super(TitleField, self).__init__(*args, **kwargs)
  18         self.required = True
  19         self.widget = forms.TextInput(attrs={'size' : 70, 'autocomplete' : 'off'})
  20         self.max_length = 255
  21         self.label  = _('title')
  22         self.help_text = _('please enter a descriptive title for your question')
  23         self.initial = ''
  24
  25     def clean(self, value):
  26         if len(value) < 10:
  27             raise forms.ValidationError(_('title must be > 10 characters'))
  28
  29         return value
  30
  31 class EditorField(forms.CharField):
  32     def __init__(self, *args, **kwargs):
  33         super(EditorField, self).__init__(*args, **kwargs)
  34         self.required = True
  35         self.widget = forms.Textarea(attrs={'id':'editor'})
  36         self.label  = _('content')
  37         self.help_text = u''
  38         self.initial = ''
  39
  40     def clean(self, value):
  41         if len(value) < 10:
  42             raise forms.ValidationError(_('question content must be > 10 characters'))
  43
  44         return value
  45
  46 class TagNamesField(forms.CharField):
  47     def __init__(self, *args, **kwargs):
  48         super(TagNamesField, self).__init__(*args, **kwargs)
  49         self.required = True
  50         self.widget = forms.TextInput(attrs={'size' : 50, 'autocomplete' : 'off'})
  51         self.max_length = 255
  52         self.label  = _('tags')
  53         #self.help_text = _('please use space to separate tags (this enables autocomplete feature)')
  54         self.help_text = _('Tags are short keywords, with no spaces within. Up to five tags can be used.')
  55         self.initial = ''
  56
  57     def clean(self, value):
  58         value = super(TagNamesField, self).clean(value)
  59         data = value.strip()
  60         if len(data) < 1:
  61             raise forms.ValidationError(_('tags are required'))
  62
  63         split_re = re.compile(r'[ ,]+')
  64         list = split_re.split(data)
  65         list_temp = []
  66         if len(list) > 5:
  67             raise forms.ValidationError(_('please use 5 tags or less'))
  68         for tag in list:
  69             if len(tag) > 20:
  70                 raise forms.ValidationError(_('tags must be shorter than 20 characters'))
  71             #take tag regex from settings
  72             tagname_re = re.compile(r'[a-z0-9]+')
  73             if not tagname_re.match(tag):
  74                 raise forms.ValidationError(_('please use following characters in tags: letters \'a-z\', numbers, and characters \'.-_#\''))
  75             # only keep one same tag
  76             if tag not in list_temp and len(tag.strip()) > 0:
  77                 list_temp.append(tag)
  78         return u' '.join(list_temp)
  79
  80 class WikiField(forms.BooleanField):
  81     def __init__(self, *args, **kwargs):
  82         super(WikiField, self).__init__(*args, **kwargs)
  83         self.required = False
  84         self.label  = _('community wiki')
  85         self.help_text = _('if you choose community wiki option, the question and answer do not generate points and name of author will not be shown')
  86     def clean(self,value):
  87         return value and settings.WIKI_ON
  88
  89 class EmailNotifyField(forms.BooleanField):
  90     def __init__(self, *args, **kwargs):
  91         super(EmailNotifyField, self).__init__(*args, **kwargs)
  92         self.required = False
  93         self.widget.attrs['class'] = 'nomargin'
  94
  95 class SummaryField(forms.CharField):
  96     def __init__(self, *args, **kwargs):
  97         super(SummaryField, self).__init__(*args, **kwargs)
  98         self.required = False
  99         self.widget = forms.TextInput(attrs={'size' : 50, 'autocomplete' : 'off'})
 100         self.max_length = 300
 101         self.label  = _('update summary:')
 102         self.help_text = _('enter a brief summary of your revision (e.g. fixed spelling, grammar, improved style, this field is optional)')
 103
 104 class ModerateUserForm(forms.ModelForm):
 105     is_approved = forms.BooleanField(label=_("Automatically accept user's contributions for the email updates"),
 106                                      required=False)
 107
 108     def clean_is_approved(self):
 109         if 'is_approved' not in self.cleaned_data:
 110             self.cleaned_data['is_approved'] = False
 111         return self.cleaned_data['is_approved']
 112
 113     class Meta:
 114         model = User
 115         fields = ('is_approved',)
 116
 117 class NotARobotForm(forms.Form):
 118     recaptcha = ReCaptchaField()
 119
 120 class FeedbackForm(forms.Form):
 121     name = forms.CharField(label=_('Your name:'), required=False)
 122     email = forms.EmailField(label=_('Email (not shared with anyone):'), required=False)
 123     message = forms.CharField(label=_('Your message:'), max_length=800,widget=forms.Textarea(attrs={'cols':60}))
 124     next = NextUrlField()
 125
 126 class AskForm(forms.Form):
 127     title  = TitleField()
 128     text   = EditorField()
 129     tags   = TagNamesField()
 130     wiki = WikiField()
 131
 132     openid = forms.CharField(required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 40, 'class':'openid-input'}))
 133     user   = forms.CharField(required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 35}))
 134     email  = forms.CharField(required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 35}))
 135
 136 class AnswerForm(forms.Form):
 137     text   = EditorField()
 138     wiki   = WikiField()
 139     openid = forms.CharField(required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 40, 'class':'openid-input'}))
 140     user   = forms.CharField(required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 35}))
 141     email  = forms.CharField(required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 35}))
 142     email_notify = EmailNotifyField()
 143     def __init__(self, question, user, *args, **kwargs):
 144         super(AnswerForm, self).__init__(*args, **kwargs)
 145         self.fields['email_notify'].widget.attrs['id'] = 'question-subscribe-updates';
 146         if question.wiki and settings.WIKI_ON:
 147             self.fields['wiki'].initial = True
 148         if user.is_authenticated():
 149             if user in question.followed_by.all():
 150                 self.fields['email_notify'].initial = True
 151                 return
 152         self.fields['email_notify'].initial = False
 153
 154
 155 class CloseForm(forms.Form):
 156     reason = forms.ChoiceField(choices=CLOSE_REASONS)
 157
 158 class RetagQuestionForm(forms.Form):
 159     tags   = TagNamesField()
 160     # initialize the default values
 161     def __init__(self, question, *args, **kwargs):
 162         super(RetagQuestionForm, self).__init__(*args, **kwargs)
 163         self.fields['tags'].initial = question.tagnames
 164
 165 class RevisionForm(forms.Form):
 166     """
 167     Lists revisions of a Question or Answer
 168     """
 169     revision = forms.ChoiceField(widget=forms.Select(attrs={'style' : 'width:520px'}))
 170
 171     def __init__(self, post, latest_revision, *args, **kwargs):
 172         super(RevisionForm, self).__init__(*args, **kwargs)
 173         revisions = post.revisions.all().values_list(
 174             'revision', 'author__username', 'revised_at', 'summary')
 175         date_format = '%c'
 176         self.fields['revision'].choices = [
 177             (r[0], u'%s - %s (%s) %s' % (r[0], r[1], r[2].strftime(date_format), r[3]))
 178             for r in revisions]
 179         self.fields['revision'].initial = latest_revision.revision
 180
 181 class EditQuestionForm(forms.Form):
 182     title  = TitleField()
 183     text   = EditorField()
 184     tags   = TagNamesField()
 185     summary = SummaryField()
 186
 187     def __init__(self, question, revision, *args, **kwargs):
 188         super(EditQuestionForm, self).__init__(*args, **kwargs)
 189         self.fields['title'].initial = revision.title
 190         self.fields['text'].initial = revision.text
 191         self.fields['tags'].initial = revision.tagnames
 192         # Once wiki mode is enabled, it can't be disabled
 193         if not question.wiki:
 194             self.fields['wiki'] = WikiField()
 195
 196 class EditAnswerForm(forms.Form):
 197     text = EditorField()
 198     summary = SummaryField()
 199
 200     def __init__(self, answer, revision, *args, **kwargs):
 201         super(EditAnswerForm, self).__init__(*args, **kwargs)
 202         self.fields['text'].initial = revision.text
 203
 204 class EditUserForm(forms.Form):
 205     email = forms.EmailField(label=u'Email', help_text=_('this email does not have to be linked to gravatar'), required=True, max_length=255, widget=forms.TextInput(attrs={'size' : 35}))
 206     if settings.EDITABLE_SCREEN_NAME:
 207         username = UserNameField(label=_('Screen name'))
 208     realname = forms.CharField(label=_('Real name'), required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 35}))
 209     website = forms.URLField(label=_('Website'), required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 35}))
 210     city = forms.CharField(label=_('Location'), required=False, max_length=255, widget=forms.TextInput(attrs={'size' : 35}))
 211     birthday = forms.DateField(label=_('Date of birth'), help_text=_('will not be shown, used to calculate age, format: YYYY-MM-DD'), required=False, widget=forms.TextInput(attrs={'size' : 35}))
 212     about = forms.CharField(label=_('Profile'), required=False, widget=forms.Textarea(attrs={'cols' : 60}))
 213
 214     def __init__(self, user, *args, **kwargs):
 215         super(EditUserForm, self).__init__(*args, **kwargs)
 216         logging.debug('initializing the form')
 217         if settings.EDITABLE_SCREEN_NAME:
 218             self.fields['username'].initial = user.username
 219             self.fields['username'].user_instance = user
 220         self.fields['email'].initial = user.email
 221         self.fields['realname'].initial = user.real_name
 222         self.fields['website'].initial = user.website
 223         self.fields['city'].initial = user.location
 224
 225         if user.date_of_birth is not None:
 226             self.fields['birthday'].initial = user.date_of_birth
 227         else:
 228             self.fields['birthday'].initial = '1990-01-01'
 229         self.fields['about'].initial = user.about
 230         self.user = user
 231
 232     def clean_email(self):
 233         """For security reason one unique email in database"""
 234         if self.user.email != self.cleaned_data['email']:
 235             #todo dry it, there is a similar thing in openidauth
 236             if settings.EMAIL_UNIQUE == True:
 237                 if 'email' in self.cleaned_data:
 238                     try:
 239                         user = User.objects.get(email = self.cleaned_data['email'])
 240                     except User.DoesNotExist:
 241                         return self.cleaned_data['email']
 242                     except User.MultipleObjectsReturned:
 243                         raise forms.ValidationError(_('this email has already been registered, please use another one'))
 244                     raise forms.ValidationError(_('this email has already been registered, please use another one'))
 245         return self.cleaned_data['email']
 246
 247 class TagFilterSelectionForm(forms.ModelForm):
 248     tag_filter_setting = forms.ChoiceField(choices=TAG_EMAIL_FILTER_CHOICES, #imported from forum/const.py
 249                                             initial='ignored',
 250                                             label=_('Choose email tag filter'),
 251                                             widget=forms.RadioSelect)
 252     class Meta:
 253         model = User
 254         fields = ('tag_filter_setting',)
 255
 256     def save(self):
 257         before = self.instance.tag_filter_setting
 258         super(TagFilterSelectionForm, self).save()
 259         after = self.instance.tag_filter_setting #User.objects.get(pk=self.instance.id).tag_filter_setting
 260         if before != after:
 261             return True
 262         return False
 263
 264
 265 class ChangePasswordForm(SetPasswordForm):
 266     """ change password form """
 267     oldpw = forms.CharField(widget=forms.PasswordInput(attrs={'class':'required'}),
 268                 label=mark_safe(_('Current password')))
 269
 270     def __init__(self, data=None, user=None, *args, **kwargs):
 271         if user is None:
 272             raise TypeError("Keyword argument 'user' must be supplied")
 273         super(ChangePasswordForm, self).__init__(data, *args, **kwargs)
 274         self.user = user
 275
 276     def clean_oldpw(self):
 277         """ test old password """
 278         if not self.user.check_password(self.cleaned_data['oldpw']):
 279             raise forms.ValidationError(_("Old password is incorrect. \
 280                     Please enter the correct password."))
 281         return self.cleaned_data['oldpw']
 282
 283 class EditUserEmailFeedsForm(forms.Form):
 284     WN = (('w',_('weekly')),('n',_('no email')))
 285     DWN = (('d',_('daily')),('w',_('weekly')),('n',_('no email')))
 286     FORM_TO_MODEL_MAP = {
 287                 'all_questions':'q_all',
 288                 'asked_by_me':'q_ask',
 289                 'answered_by_me':'q_ans',
 290                 'individually_selected':'q_sel',
 291                 }
 292     NO_EMAIL_INITIAL = {
 293                 'all_questions':'n',
 294                 'asked_by_me':'n',
 295                 'answered_by_me':'n',
 296                 'individually_selected':'n',
 297                 }
 298     asked_by_me = forms.ChoiceField(choices=DWN,initial='w',
 299                             widget=forms.RadioSelect,
 300                             label=_('Asked by me'))
 301     answered_by_me = forms.ChoiceField(choices=DWN,initial='w',
 302                             widget=forms.RadioSelect,
 303                             label=_('Answered by me'))
 304     individually_selected = forms.ChoiceField(choices=DWN,initial='w',
 305                             widget=forms.RadioSelect,
 306                             label=_('Individually selected'))
 307     all_questions = forms.ChoiceField(choices=DWN,initial='w',
 308                             widget=forms.RadioSelect,
 309                             label=_('Entire forum (tag filtered)'),)
 310
 311     def set_initial_values(self,user=None):
 312         KEY_MAP = dict([(v,k) for k,v in self.FORM_TO_MODEL_MAP.iteritems()])
 313         if user != None:
 314             settings = EmailFeedSetting.objects.filter(subscriber=user)
 315             initial_values = {}
 316             for setting in settings:
 317                 feed_type = setting.feed_type
 318                 form_field = KEY_MAP[feed_type]
 319                 frequency = setting.frequency
 320                 initial_values[form_field] = frequency
 321             self.initial = initial_values
 322         return self
 323
 324     def reset(self):
 325         self.cleaned_data['all_questions'] = 'n'
 326         self.cleaned_data['asked_by_me'] = 'n'
 327         self.cleaned_data['answered_by_me'] = 'n'
 328         self.cleaned_data['individually_selected'] = 'n'
 329         self.initial = self.NO_EMAIL_INITIAL
 330         return self
 331
 332     def save(self,user,save_unbound=False):
 333         """
 334             with save_unbound==True will bypass form validation and save initial values
 335         """
 336         changed = False
 337         for form_field, feed_type in self.FORM_TO_MODEL_MAP.items():
 338             s, created = EmailFeedSetting.objects.get_or_create(subscriber=user,\
 339                                                     feed_type=feed_type)
 340             if save_unbound:
 341                 #just save initial values instead
 342                 if form_field in self.initial:
 343                     new_value = self.initial[form_field]
 344                 else:
 345                     new_value = self.fields[form_field].initial
 346             else:
 347                 new_value = self.cleaned_data[form_field]
 348             if s.frequency != new_value:
 349                 s.frequency = new_value
 350                 s.save()
 351                 changed = True
 352             else:
 353                 if created:
 354                     s.save()
 355             if form_field == 'individually_selected':
 356                 feed_type = ContentType.objects.get_for_model(Question)
 357                 user.followed_questions.clear()
 358         return changed
 359