words/forms.py

   1 # imports # {{{
   2 from django import forms
   3 from django.conf import settings
   4
   5 import re
   6 from datetime import datetime
   7
   8 from iwdb.words.models import Word, ChangeSheet, LanguageChoices
   9 from iwdb.words.models import Pronunciation, POLChoices, Meaning
  10 from iwdb.utils import no_new_lines
  11 # }}}
  12
  13 # BaseAjaxForm # {{{
  14 class BaseAjaxForm(forms.Form):
  15     def __init__(self, request, *args, **kw):
  16         self.request = request
  17         super(BaseAjaxForm, self).__init__(*args, **kw)
  18 # }}}
  19
  20 # BaseWordAjaxForm # {{{
  21 class BaseWordAjaxForm(BaseAjaxForm):
  22     word = forms.CharField(max_length=100)
  23
  24     def clean_word(self):
  25         word = self.cleaned_data["word"]
  26         try:
  27             word = Word.objects.get(word=word)
  28         except Word.DoesNotExist:
  29             try:
  30                 word = Word.objects.get(pk=word)
  31             except Word.DoesNotExist:
  32                 raise forms.ValidationError("word does not exists")
  33             except Word.MultipleObjectsReturned:
  34                 raise forms.ValidationError("MultipleObjectsReturned")
  35         return word
  36 # }}}
  37
  38 # TwoWordAjaxForm # {{{
  39 class TwoWordAjaxForm(BaseWordAjaxForm):
  40     other_word = forms.CharField(max_length=100)
  41
  42     def clean_other_word(self):
  43         word = self.cleaned_data["other_word"]
  44         try:
  45             word = Word.objects.get(word=word)
  46         except Word.DoesNotExist:
  47             try:
  48                 word = Word.objects.get(pk=word)
  49             except Word.DoesNotExist:
  50                 raise forms.ValidationError("word does not exists")
  51             except Word.MultipleObjectsReturned:
  52                 raise forms.ValidationError("MultipleObjectsReturned")
  53         return word
  54 # }}}
  55
  56 # AlterM2MRelationForm # {{{
  57 class AlterM2MRelationForm(TwoWordAjaxForm):
  58     url_re = re.compile("/w/ajax/word/(?P<operation>.*)-(?P<relation>.*)/")
  59     def clean(self):
  60         d = self.cleaned_data.get
  61         if not d("word") or not d("other_word"):
  62             return self.cleaned_data
  63         operation, relation = AlterM2MRelationForm.url_re.match(
  64             self.request.path
  65         ).groups()
  66         relation_name = relation if relation.endswith("s") else relation + "s"
  67         changesheet_type = "%s-added" if operation == "add" else "%s-removed"
  68         self.changesheet_type = changesheet_type % relation
  69         self.operation = operation
  70         self.relation_name = relation_name
  71         # actual validation
  72         if relation == "translation":
  73             if d("word").language == d("other_word").language:
  74                 raise forms.ValidationError(
  75                     "translation in same language not supported"
  76                 )
  77         else:
  78             if d("word").language != d("other_word").language:
  79                 raise forms.ValidationError(
  80                     "both words are not in same language"
  81                 )
  82         return self.cleaned_data
  83
  84     def save(self):
  85         d = self.cleaned_data.get
  86         getattr(
  87             getattr(d("word"), self.relation_name), self.operation
  88         )(d("other_word"))
  89         ChangeSheet.objects.create(
  90             word = d("word"),
  91             user = self.request.user,
  92             id_1 = d("other_word").id,
  93             type = self.changesheet_type,
  94         )
  95         return [
  96             unicode(word) for word in getattr(
  97                 d("word"), self.relation_name
  98             ).all()
  99         ]
 100 # }}}
 101
 102 # ChangeLanguageForm # {{{
 103 class ChangeLanguageForm(BaseWordAjaxForm):
 104     language = forms.ChoiceField(choices=LanguageChoices)
 105     def save(self):
 106         d = self.cleaned_data.get
 107         ChangeSheet.objects.create(
 108             word = d("word"),
 109             user = self.request.user,
 110             data = d("word").language, # old language gets logged.
 111             type = "language-changed",
 112         )
 113         d("word").language = d("language")
 114         d("word").save()
 115         return d("word").language
 116 # }}}
 117
 118 # UpdateEtymologyForm # {{{
 119 class UpdateEtymologyForm(BaseWordAjaxForm):
 120     etymology = forms.CharField()
 121     def save(self):
 122         d = self.cleaned_data.get
 123         ChangeSheet.objects.create(
 124             word = d("word"),
 125             user = self.request.user,
 126             data = d("word").etymology, # old etymology gets logged.
 127             type = "etymology-updated",
 128         )
 129         d("word").etymology = d("etymology")
 130         d("word").save()
 131         return d("word").etymology
 132 # }}}
 133
 134 # AddPronunciation # {{{
 135 class AddPronunciation(BaseWordAjaxForm):
 136     spelling = forms.CharField(max_length=100)
 137     key = forms.CharField(max_length=100)
 138
 139     def clean_spelling(self):
 140         d = self.cleaned_data.get
 141         if d("spelling") not in d("word").forms:
 142             raise forms.ValidationError(
 143                 "this spelling not allowed for this word"
 144             )
 145         return d("spelling")
 146
 147     def save(self):
 148         d = self.cleaned_data.get
 149         p, c = Pronunciation.objects.get_or_create(
 150             spelling=d("spelling"), pronunciation_key=d("key")
 151         )
 152         p.is_deleted = False
 153         p.deleted_on = None
 154         p.save()
 155         ChangeSheet.objects.create(
 156             word = d("word"),
 157             user = self.request.user,
 158             id_1 = p.id,
 159             type = "pronunciation-added",
 160         )
 161 # }}}
 162
 163 # RemovePronunciation # {{{
 164 class RemovePronunciation(BaseWordAjaxForm):
 165     pronunciation = forms.CharField(max_length=100)
 166
 167     def clean_pronunciation(self):
 168         d = self.cleaned_data.get
 169         try:
 170             pronunciation = Pronunciation.objects.get(pk=d("pronunciation"))
 171         except Pronunciation.DoesNotExist:
 172             raise forms.ValidationError("No such pronunciation")
 173         if pronunciation.spelling not in d("word").forms:
 174             raise forms.ValidationError(
 175                 "pronunciation not used for this word"
 176             )
 177         return pronunciation
 178
 179     def save(self):
 180         d = self.cleaned_data.get
 181         p = d("pronunciation")
 182         p.is_deleted = True
 183         p.deleted_on = datetime.now()
 184         p.save()
 185         ChangeSheet.objects.create(
 186             word = d("word"),
 187             user = self.request.user,
 188             id_1 = p.id,
 189             type = "pronunciation-removed",
 190         )
 191 # }}}
 192
 193 # EditPronunciation # {{{
 194 class EditPronunciation(BaseWordAjaxForm):
 195     pronunciation = forms.CharField(max_length=100)
 196     key = forms.CharField(max_length=100)
 197
 198     def clean_pronunciation(self):
 199         d = self.cleaned_data.get
 200         try:
 201             pronunciation = Pronunciation.objects.get(pk=d("pronunciation"))
 202         except Pronunciation.DoesNotExist:
 203             raise forms.ValidationError("No such pronunciation")
 204         if pronunciation.spelling not in d("word").forms:
 205             raise forms.ValidationError(
 206                 "pronunciation not used for this word"
 207             )
 208         return pronunciation
 209
 210     def save(self):
 211         d = self.cleaned_data.get
 212         p = d("pronunciation")
 213         ChangeSheet.objects.create(
 214             word = d("word"),
 215             user = self.request.user,
 216             id_1 = p.id,
 217             data = p.pronunciation_key, # old key
 218             type = "pronunciation-edited",
 219         )
 220         p.pronunciation_key = d("key")
 221         p.save()
 222 # }}}
 223
 224 # AddMeaning # {{{
 225 class AddMeaning(BaseWordAjaxForm):
 226     m = forms.CharField()
 227     usage = forms.CharField(required=False)
 228     pol = forms.ChoiceField(choices=POLChoices)
 229     language = forms.ChoiceField(choices=LanguageChoices)
 230
 231     clean_m = no_new_lines("m")
 232     clean_usage = no_new_lines("usage")
 233
 234     def save(self):
 235         d = self.cleaned_data.get
 236         meaning = Meaning.objects.create(
 237             word = d("word"), meaning = d("m"), usage = d("usage"),
 238             pol = d("pol"), language = d("language"),
 239         )
 240         ChangeSheet.objects.create(
 241             word = d("word"),
 242             user = self.request.user,
 243             id_1 = meaning.id,
 244             type = "meaning-added",
 245         )
 246 # }}}
 247
 248 # RemoveMeaning # {{{
 249 class RemoveMeaning(BaseWordAjaxForm):
 250     meaning = forms.CharField(max_length=100)
 251
 252     def clean_meaning(self):
 253         d = self.cleaned_data.get
 254         try:
 255             meaning = Meaning.objects.get(pk=d("meaning"))
 256         except Meaning.DoesNotExist:
 257             raise forms.ValidationError("No such meaning")
 258         if meaning.word != d("word"):
 259             raise forms.ValidationError(
 260                 "meaning not used for this word"
 261             )
 262         return meaning
 263
 264     def save(self):
 265         d = self.cleaned_data.get
 266         meaning = d("meaning")
 267         meaning.is_deleted = True
 268         meaning.deleted_on = datetime.now()
 269         meaning.save()
 270         ChangeSheet.objects.create(
 271             word = d("word"),
 272             user = self.request.user,
 273             id_1 = meaning.id,
 274             type = "meaning-removed",
 275         )
 276 # }}}
 277
 278 # UpdateMeaning # {{{
 279 class UpdateMeaning(AddMeaning, RemoveMeaning):
 280     def save(self):
 281         d = self.cleaned_data.get
 282         meaning = d("meaning")
 283         data = "\n".join(
 284             (
 285                 "meaning: %s" % meaning.meaning,
 286                 "usage: %s" % meaning.usage,
 287                 "pol: %s" % meaning.pol,
 288                 "language: %s" % meaning.language,
 289             )
 290         )
 291         meaning.meaning = d("m")
 292         meaning.usage = d("usage")
 293         meaning.pol = d("pol")
 294         meaning.language = d("language")
 295         meaning.save()
 296         ChangeSheet.objects.create(
 297             word = d("word"),
 298             user = self.request.user,
 299             id_1 = meaning.id,
 300             data = data,
 301             type = "meaning-updated",
 302         )
 303 # }}}
 304
 305 # AddWordForm # {{{
 306 class AddWordForm(BaseWordAjaxForm):
 307     form = forms.CharField()
 308
 309     def clean_form(self):
 310         # form same as word can not be added/deleted
 311         d = self.cleaned_data.get
 312         if d("form").lower() == d("word").word.lower():
 313             raise forms.ValidationError("not allowed")
 314         return d("form").lower()
 315
 316     def save(self):
 317         d = self.cleaned_data.get
 318         ChangeSheet.objects.create(
 319             word = d("word"),
 320             user = self.request.user,
 321             data = d("word").forms, # old forms
 322             type = "form-added",
 323         )
 324         if "%s%s%s" % (
 325             settings.WORD_FORM_DELIMITER, d("form"),
 326             settings.WORD_FORM_DELIMITER
 327         ) not in d("word").forms:
 328             d("word").forms += d("form")+settings.WORD_FORM_DELIMITER
 329             d("word").save()
 330         return d("word").forms.split(settings.WORD_FORM_DELIMITER)
 331 # }}}
 332
 333 # RemoveWordForm # {{{
 334 class RemoveWordForm(BaseWordAjaxForm):
 335     form = forms.CharField()
 336
 337     def clean_form(self):
 338         # form same as word can not be added/deleted
 339         d = self.cleaned_data.get
 340         if d("form").lower() == d("word").word.lower():
 341             raise forms.ValidationError("not allowed")
 342         if "%s%s%s" % (
 343             settings.WORD_FORM_DELIMITER, d("form"),
 344             settings.WORD_FORM_DELIMITER
 345         ) not in d("word").forms:
 346             raise forms.ValidationError("form is not associated with word")
 347         return d("form").lower()
 348
 349     def save(self):
 350         d = self.cleaned_data.get
 351         ChangeSheet.objects.create(
 352             word = d("word"),
 353             user = self.request.user,
 354             data = d("form"), # form that is being removed
 355             type = "form-removed",
 356         )
 357         forms = d("word").forms.split(settings.WORD_FORM_DELIMITER)
 358         forms.remove(d("form"))
 359         d("word").forms = settings.WORD_FORM_DELIMITER.join(forms)
 360         d("word").save()
 361         return forms
 362 # }}}
 363
 364 # AddWord # {{{
 365 class AddWord(BaseAjaxForm):
 366     word = forms.CharField(max_length=100)
 367
 368     def clean_word(self):
 369         d = self.cleaned_data.get
 370         if settings.WORD_FORM_DELIMITER in d("word"):
 371             raise forms.ValidationError(
 372                 "%s not allowed" % settings.WORD_FORM_DELIMITER
 373             )
 374         # what if someone tries to add a word that is already a form
 375         # of another word? this cant be because they ll go to that forms
 376         # page and they ll be redirected to the original word, they wud just
 377         # not see the add button for that word.
 378         return d("word")
 379
 380     def save(self):
 381         d = self.cleaned_data.get
 382         word = Word.objects.create(
 383             word=d("word"), forms="%s%s%s" % (
 384                 settings.WORD_FORM_DELIMITER, wordname,
 385                 settings.WORD_FORM_DELIMITER
 386             ),
 387         )
 388         ChangeSheet.objects.create(
 389             word = d("word"),
 390             user = self.request.user,
 391             type = "added-word",
 392         )
 393         return word.id
 394 # }}}