update requirements
[redakcja.git] / apps / forms_builder / forms / models.py
1 from __future__ import unicode_literals
2
3 from django.contrib.sites.models import Site
4 from django.core.exceptions import ValidationError
5 from django.core.urlresolvers import reverse
6 from django.db import models
7 from django.db.models import Q
8 from django.utils.encoding import python_2_unicode_compatible
9 from django.utils.translation import ugettext, ugettext_lazy as _
10 from future.builtins import str
11
12 from forms_builder.forms import fields
13 from forms_builder.forms import settings
14 from forms_builder.forms.utils import now, slugify, unique_slug
15
16
17 STATUS_DRAFT = 1
18 STATUS_PUBLISHED = 2
19 STATUS_CHOICES = (
20     (STATUS_DRAFT, _("Draft")),
21     (STATUS_PUBLISHED, _("Published")),
22 )
23
24
25 class FormManager(models.Manager):
26     """
27     Only show published forms for non-staff users.
28     """
29     def published(self, for_user=None):
30         if for_user is not None and for_user.is_staff:
31             return self.all()
32         filters = [
33             Q(publish_date__lte=now()) | Q(publish_date__isnull=True),
34             Q(expiry_date__gte=now()) | Q(expiry_date__isnull=True),
35             Q(status=STATUS_PUBLISHED),
36         ]
37         if settings.USE_SITES:
38             filters.append(Q(sites=Site.objects.get_current()))
39         return self.filter(*filters)
40
41
42 ######################################################################
43 #                                                                    #
44 #   Each of the models are implemented as abstract to allow for      #
45 #   subclassing. Default concrete implementations are then defined   #
46 #   at the end of this module.                                       #
47 #                                                                    #
48 ######################################################################
49
50 @python_2_unicode_compatible
51 class AbstractForm(models.Model):
52     """
53     A user-built form.
54     """
55
56     sites = models.ManyToManyField(Site,
57         default=[settings.SITE_ID], related_name="%(app_label)s_%(class)s_forms")
58     title = models.CharField(_("Title"), max_length=50)
59     slug = models.SlugField(_("Slug"), editable=settings.EDITABLE_SLUGS,
60         max_length=100, unique=True)
61     intro = models.TextField(_("Intro"), blank=True)
62     button_text = models.CharField(_("Button text"), max_length=50,
63         default=_("Submit"))
64     response = models.TextField(_("Response"), blank=True)
65     redirect_url = models.CharField(_("Redirect url"), max_length=200,
66         null=True, blank=True,
67         help_text=_("An alternate URL to redirect to after form submission"))
68     status = models.IntegerField(_("Status"), choices=STATUS_CHOICES,
69         default=STATUS_PUBLISHED)
70     publish_date = models.DateTimeField(_("Published from"),
71         help_text=_("With published selected, won't be shown until this time"),
72         blank=True, null=True)
73     expiry_date = models.DateTimeField(_("Expires on"),
74         help_text=_("With published selected, won't be shown after this time"),
75         blank=True, null=True)
76     login_required = models.BooleanField(_("Login required"), default=False,
77         help_text=_("If checked, only logged in users can view the form"))
78     send_email = models.BooleanField(_("Send email"), default=True, help_text=
79         _("If checked, the person entering the form will be sent an email"))
80     email_from = models.EmailField(_("From address"), blank=True,
81         help_text=_("The address the email will be sent from"))
82     email_copies = models.CharField(_("Send copies to"), blank=True,
83         help_text=_("One or more email addresses, separated by commas"),
84         max_length=200)
85     email_subject = models.CharField(_("Subject"), max_length=200, blank=True)
86     email_message = models.TextField(_("Message"), blank=True)
87
88     objects = FormManager()
89
90     class Meta:
91         verbose_name = _("Form")
92         verbose_name_plural = _("Forms")
93         abstract = True
94
95     def __str__(self):
96         return str(self.title)
97
98     def save(self, *args, **kwargs):
99         """
100         Create a unique slug from title - append an index and increment if it
101         already exists.
102         """
103         if not self.slug:
104             slug = slugify(self)
105             self.slug = unique_slug(self.__class__.objects, "slug", slug)
106         super(AbstractForm, self).save(*args, **kwargs)
107
108     def published(self, for_user=None):
109         """
110         Mimics the queryset logic in ``FormManager.published``, so we
111         can check a form is published when it wasn't loaded via the
112         queryset's ``published`` method, and is passed to the
113         ``render_built_form`` template tag.
114         """
115         if for_user is not None and for_user.is_staff:
116             return True
117         status = self.status == STATUS_PUBLISHED
118         publish_date = self.publish_date is None or self.publish_date <= now()
119         expiry_date = self.expiry_date is None or self.expiry_date >= now()
120         authenticated = for_user is not None and for_user.is_authenticated()
121         login_required = (not self.login_required or authenticated)
122         return status and publish_date and expiry_date and login_required
123
124     def total_entries(self):
125         """
126         Called by the admin list view where the queryset is annotated
127         with the number of entries.
128         """
129         return self.total_entries
130     total_entries.admin_order_field = "total_entries"
131
132     @models.permalink
133     def get_absolute_url(self):
134         return ("form_detail", (), {"slug": self.slug})
135
136     def admin_links(self):
137         kw = {"args": (self.id,)}
138         links = [
139             (_("View form on site"), self.get_absolute_url()),
140             (_("Filter entries"), reverse("admin:form_entries", **kw)),
141             (_("View all entries"), reverse("admin:form_entries_show", **kw)),
142             (_("Export all entries"), reverse("admin:form_entries_export", **kw)),
143         ]
144         for i, (text, url) in enumerate(links):
145             links[i] = "<a href='%s'>%s</a>" % (url, ugettext(text))
146         return "<br>".join(links)
147     admin_links.allow_tags = True
148     admin_links.short_description = ""
149
150
151 class FieldManager(models.Manager):
152     """
153     Only show visible fields when displaying actual form..
154     """
155     def visible(self):
156         return self.filter(visible=True)
157
158
159 @python_2_unicode_compatible
160 class AbstractField(models.Model):
161     """
162     A field for a user-built form.
163     """
164
165     label = models.CharField(_("Label"), max_length=settings.LABEL_MAX_LENGTH)
166     slug = models.SlugField(_('Slug'), max_length=100, blank=True,
167             default="")
168     field_type = models.IntegerField(_("Type"), choices=fields.NAMES)
169     required = models.BooleanField(_("Required"), default=True)
170     visible = models.BooleanField(_("Visible"), default=True)
171     choices = models.CharField(_("Choices"), max_length=settings.CHOICES_MAX_LENGTH, blank=True,
172         help_text="Comma separated options where applicable. If an option "
173             "itself contains commas, surround the option starting with the %s"
174             "character and ending with the %s character." %
175                 (settings.CHOICES_QUOTE, settings.CHOICES_UNQUOTE))
176     default = models.CharField(_("Default value"), blank=True,
177         max_length=settings.FIELD_MAX_LENGTH)
178     placeholder_text = models.CharField(_("Placeholder Text"), null=True,
179         blank=True, max_length=100, editable=settings.USE_HTML5)
180     help_text = models.CharField(_("Help text"), blank=True, max_length=settings.HELPTEXT_MAX_LENGTH)
181
182     objects = FieldManager()
183
184     class Meta:
185         verbose_name = _("Field")
186         verbose_name_plural = _("Fields")
187         abstract = True
188
189     def __str__(self):
190         return str(self.label)
191
192     def get_choices(self):
193         """
194         Parse a comma separated choice string into a list of choices taking
195         into account quoted choices using the ``settings.CHOICES_QUOTE`` and
196         ``settings.CHOICES_UNQUOTE`` settings.
197         """
198         choice = ""
199         quoted = False
200         for char in self.choices:
201             if not quoted and char == settings.CHOICES_QUOTE:
202                 quoted = True
203             elif quoted and char == settings.CHOICES_UNQUOTE:
204                 quoted = False
205             elif char == "," and not quoted:
206                 choice = choice.strip()
207                 if choice:
208                     yield choice, choice
209                 choice = ""
210             else:
211                 choice += char
212         choice = choice.strip()
213         if choice:
214             yield choice, choice
215
216     def save(self, *args, **kwargs):
217         if not self.slug:
218             slug = slugify(self).replace('-', '_')
219             self.slug = unique_slug(self.form.fields, "slug", slug)
220         return super(AbstractField, self).save(*args, **kwargs)
221
222     def is_a(self, *args):
223         """
224         Helper that returns True if the field's type is given in any arg.
225         """
226         return self.field_type in args
227
228
229 class AbstractFormEntry(models.Model):
230     """
231     An entry submitted via a user-built form.
232     """
233
234     entry_time = models.DateTimeField(_("Date/time"))
235
236     class Meta:
237         verbose_name = _("Form entry")
238         verbose_name_plural = _("Form entries")
239         abstract = True
240
241
242 class AbstractFieldEntry(models.Model):
243     """
244     A single field value for a form entry submitted via a user-built form.
245     """
246
247     field_id = models.IntegerField()
248     value = models.CharField(max_length=settings.FIELD_MAX_LENGTH,
249             null=True)
250
251     class Meta:
252         verbose_name = _("Form field entry")
253         verbose_name_plural = _("Form field entries")
254         abstract = True
255
256
257 ###################################################
258 #                                                 #
259 #   Default concrete implementations are below.   #
260 #                                                 #
261 ###################################################
262
263 class FormEntry(AbstractFormEntry):
264     form = models.ForeignKey("Form", related_name="entries")
265
266
267 class FieldEntry(AbstractFieldEntry):
268     entry = models.ForeignKey("FormEntry", related_name="fields")
269
270
271 class Form(AbstractForm):
272     pass
273
274
275 class Field(AbstractField):
276     """
277     Implements automated field ordering.
278     """
279
280     form = models.ForeignKey("Form", related_name="fields")
281     order = models.IntegerField(_("Order"), null=True, blank=True)
282
283     class Meta(AbstractField.Meta):
284         ordering = ("order",)
285
286     def save(self, *args, **kwargs):
287         if self.order is None:
288             self.order = self.form.fields.count()
289         super(Field, self).save(*args, **kwargs)
290
291     def delete(self, *args, **kwargs):
292         fields_after = self.form.fields.filter(order__gte=self.order)
293         fields_after.update(order=models.F("order") - 1)
294         super(Field, self).delete(*args, **kwargs)