apps/catalogue/forms.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # This file is part of FNP-Redakcja, licensed under GNU Affero GPLv3 or later.
   4 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
   5 #
   6 from django.utils.encoding import force_text
   7 from django.utils.html import format_html
   8 from django.utils.safestring import mark_safe
   9
  10 from catalogue.models import Category
  11 from catalogue.models import Tag
  12 from django import forms
  13 from django.utils.translation import ugettext_lazy as _
  14
  15 from catalogue.constants import MASTERS
  16
  17
  18 def tag_field(category_tag, required=True):
  19     category = Category.objects.get(dc_tag=category_tag)
  20     return forms.ModelMultipleChoiceField(queryset=category.tag_set.all(), required=required)
  21
  22
  23 class DocumentCreateForm(forms.Form):
  24     """
  25         Form used for creating new documents.
  26     """
  27     owner_organization = forms.CharField(required=False)
  28     title = forms.CharField()
  29     publisher = forms.CharField(required=False)
  30     description = forms.CharField(required=False)
  31     cover = forms.FileField(required=False)
  32
  33     def clean_cover(self):
  34         cover = self.cleaned_data['cover']
  35         if cover and cover.name.rsplit('.', 1)[-1].lower() not in ('jpg', 'jpeg', 'png', 'gif', 'svg'):
  36             raise forms.ValidationError(_('The cover should be an image file (jpg/png/gif)'))
  37         return file
  38
  39
  40 class TagForm(forms.Form):
  41     def __init__(self, category, instance=None, tutorial_no=None, *args, **kwargs):
  42         super(TagForm, self).__init__(*args, **kwargs)
  43         self.category = category
  44         self.instance = instance
  45         self.field().queryset = Tag.objects.filter(category=self.category)
  46         self.field().label = self.category.label.capitalize()
  47         if tutorial_no and category.tutorial:
  48             self.field().widget.attrs.update({
  49                 'data-toggle': 'tutorial',
  50                 'data-tutorial': str(tutorial_no),
  51                 'data-placement': 'bottom',
  52                 'data-content': category.tutorial,
  53             })
  54         if self.instance:
  55             self.field().initial = self.get_initial()
  56
  57     def save(self, instance=None):
  58         instance = instance or self.instance
  59         assert instance, 'No instance provided'
  60         self.category.set_tags_for(instance, self.cleaned_tags())
  61
  62     def field(self):
  63         raise NotImplementedError
  64
  65     def get_initial(self):
  66         raise NotImplementedError
  67
  68     def cleaned_tags(self):
  69         raise NotImplementedError
  70
  71     def metadata_rows(self):
  72         return '\n'.join(
  73             '<dc:%(name)s>%(value)s</dc:%(name)s>' % {'name': tag.category.dc_tag, 'value': tag.dc_value}
  74             for tag in self.cleaned_tags())
  75
  76
  77 class TagSelect(forms.Select):
  78     def render_option(self, selected_choices, option_value, option_label):
  79         if option_value is None:
  80             option_value = ''
  81         help_html = ''
  82         if option_value:
  83             tag = Tag.objects.get(id=int(option_value))
  84             if tag.help_text:
  85                 help_html = mark_safe(' data-help="%s"' % tag.help_text)
  86         option_value = force_text(option_value)
  87         if option_value in selected_choices:
  88             selected_html = mark_safe(' selected="selected"')
  89             if not self.allow_multiple_selected:
  90                 # Only allow for a single selection.
  91                 selected_choices.remove(option_value)
  92         else:
  93             selected_html = ''
  94         return format_html(
  95             u'<option value="{}"{}{}>{}</option>',
  96             option_value, selected_html, help_html, force_text(option_label))
  97
  98
  99 class TagSingleForm(TagForm):
 100     tag = forms.ModelChoiceField(
 101         Tag.objects.none(),
 102         widget=TagSelect(attrs={
 103             'class': 'form-control',
 104         })
 105     )
 106
 107     def field(self):
 108         return self.fields['tag']
 109
 110     def get_initial(self):
 111         return self.instance.tags.get(category=self.category)
 112
 113     def cleaned_tags(self):
 114         return [self.cleaned_data['tag']]
 115
 116
 117 class TagMultipleForm(TagForm):
 118     tags = forms.ModelMultipleChoiceField(
 119         Tag.objects.none(), required=False,
 120         widget=forms.SelectMultiple(attrs={
 121             'class': 'chosen-select',
 122             'data-placeholder': _('Choose'),
 123         }))
 124
 125     def field(self):
 126         return self.fields['tags']
 127
 128     def get_initial(self):
 129         return self.instance.tags.filter(category=self.category)
 130
 131     def cleaned_tags(self):
 132         return self.cleaned_data['tags']
 133
 134
 135 class DocumentsUploadForm(forms.Form):
 136     """
 137         Form used for uploading new documents.
 138     """
 139     file = forms.FileField(required=True, label=_('ZIP file'))
 140     dirs = forms.BooleanField(
 141         label=_('Directories are documents in chunks'),
 142         widget=forms.CheckboxInput(attrs={'disabled': 'disabled'}))
 143
 144     def clean(self):
 145         file = self.cleaned_data['file']
 146
 147         import zipfile
 148         try:
 149             z = self.cleaned_data['zip'] = zipfile.ZipFile(file)
 150         except zipfile.BadZipfile:
 151             raise forms.ValidationError("Should be a ZIP file.")
 152         if z.testzip():
 153             raise forms.ValidationError("ZIP file corrupt.")
 154
 155         return self.cleaned_data
 156
 157
 158 class ChooseMasterForm(forms.Form):
 159     """
 160         Form used for fixing the chunks in a book.
 161     """
 162
 163     master = forms.ChoiceField(choices=((m, m) for m in MASTERS))
 164
 165
 166 class DocumentForkForm(forms.Form):
 167     """
 168         Form used for forking documents.
 169     """
 170     owner_organization = forms.CharField(required=False)