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