Commits

Kai Diefenbach committed 1a1f06e

Added specific lfs contact form on base of django-contact-form

Comments (0)

Files changed (6)

lfs/contact_form/LICENSE.txt

-Copyright (c) 2007, James Bennett
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-    * Neither the name of the author nor the names of other
-      contributors may be used to endorse or promote products derived
-      from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

lfs/contact_form/forms.py

-"""
-A base contact form for allowing users to send email messages through
-a web interface, and a subclass demonstrating useful functionality.
+# contact_form imports
+from contact_form.forms import ContactForm as BaseContactForm
 
-"""
-from django import forms
-from django.conf import settings
-from django.core.mail import send_mail
-from django.template import loader
-from django.template import RequestContext
-from django.utils.translation import ugettext_lazy as _
-from django.contrib.sites.models import Site
-
-# I put this on all required fields, because it's easier to pick up
-# on them with CSS or JavaScript if they have a class of "required"
-# in the HTML. Your mileage may vary.
-attrs_dict = { 'class': 'required' }
-
+#lfs imports
 import lfs.core.utils
 
-class ContactForm(forms.Form):
-    """
-    Base contact form class from which all contact form classes should
-    inherit.
-
-    If you don't need any custom functionality, you can simply use
-    this form to provide basic contact functionality; it will collect
-    name, email address and message.
-
-    The ``contact_form`` view included in this application knows how
-    to work with this form and can handle many types of subclasses as
-    well (see below for a discussion of the important points), so in
-    many cases it will be all that you need. If you'd like to use this
-    form or a subclass of it from one of your own views, just do the
-    following:
-
-    1. When you instantiate the form, pass the current ``HttpRequest``
-       object to the constructor as the keyword argument ``request``;
-       this is used internally by the base implementation, and also
-       made available so that subclasses can add functionality which
-       relies on inspecting the request.
-
-    2. To send the message, call the form's ``save`` method, which
-       accepts the keyword argument ``fail_silently`` and defaults it
-       to ``False``. This argument is passed directly to
-       ``send_mail``, and allows you to suppress or raise exceptions
-       as needed for debugging. The ``save`` method has no return
-       value.
-
-    Other than that, treat it like any other form; validity checks and
-    validated data are handled normally, through the ``is_valid``
-    method and the ``cleaned_data`` dictionary.
-
-
-    Base implementation
-    -------------------
-
-    Under the hood, this form uses a somewhat abstracted interface in
-    order to make it easier to subclass and add functionality. There
-    are several important attributes subclasses may want to look at
-    overriding, all of which will work (in the base implementation) as
-    either plain attributes or as callable methods:
-
-    * ``from_email`` -- used to get the address to use in the
-      ``From:`` header of the message. The base implementation returns
-      the value of the ``DEFAULT_FROM_EMAIL`` setting.
-
-    * ``message`` -- used to get the message body as a string. The
-      base implementation renders a template using the form's
-      ``cleaned_data`` dictionary as context.
-
-    * ``recipient_list`` -- used to generate the list of recipients
-      for the message. The base implementation returns the email
-      addresses specified in the ``MANAGERS`` setting.
-
-    * ``subject`` -- used to generate the subject line for the
-      message. The base implementation returns the string 'Message
-      sent through the web site', with the name of the current
-      ``Site`` prepended.
-
-    * ``template_name`` -- used by the base ``message`` method to
-      determine which template to use for rendering the
-      message. Default is ``contact_form/contact_form.txt``.
-
-    Internally, the base implementation ``_get_message_dict`` method
-    collects ``from_email``, ``message``, ``recipient_list`` and
-    ``subject`` into a dictionary, which the ``save`` method then
-    passes directly to ``send_mail`` as keyword arguments.
-
-    Particularly important is the ``message`` attribute, with its base
-    implementation as a method which renders a template; because it
-    passes ``cleaned_data`` as the template context, any additional
-    fields added by a subclass will automatically be available in the
-    template. This means that many useful subclasses can get by with
-    just adding a few fields and possibly overriding
-    ``template_name``.
-
-    Much useful functionality can be achieved in subclasses without
-    having to override much of the above; adding additional validation
-    methods works the same as any other form, and typically only a few
-    items -- ``recipient_list`` and ``subject_line``, for example,
-    need to be overridden to achieve customized behavior.
-
-
-    Other notes for subclassing
-    ---------------------------
-
-    Subclasses which want to inspect the current ``HttpRequest`` to
-    add functionality can access it via the attribute ``request``; the
-    base ``message`` takes advantage of this to use ``RequestContext``
-    when rendering its template. See the ``AkismetContactForm``
-    subclass in this file for an example of using the request to
-    perform additional validation.
-
-    Subclasses which override ``__init__`` need to accept ``*args``
-    and ``**kwargs``, and pass them via ``super`` in order to ensure
-    proper behavior.
-
-    Subclasses should be careful if overriding ``_get_message_dict``,
-    since that method **must** return a dictionary suitable for
-    passing directly to ``send_mail`` (unless ``save`` is overridden
-    as well).
-
-    Overriding ``save`` is relatively safe, though remember that code
-    which uses your form will expect ``save`` to accept the
-    ``fail_silently`` keyword argument. In the base implementation,
-    that argument defaults to ``False``, on the assumption that it's
-    far better to notice errors than to silently not send mail from
-    the contact form (see also the Zen of Python: "Errors should never
-    pass silently, unless explicitly silenced").
-
+class ContactForm(BaseContactForm):
+    """Specific ContactForm for LFS.
     """
     def __init__(self, data=None, files=None, request=None, *args, **kwargs):
-        if request is None:
-            raise TypeError("Keyword argument 'request' must be supplied")
-        super(ContactForm, self).__init__(data=data, files=files, *args, **kwargs)
-        self.request = request
+        super(ContactForm, self).__init__(data=data, files=files, request=request, *args, **kwargs)
         self.shop = lfs.core.utils.get_default_shop()
-
-    name = forms.CharField(max_length=100,
-                           widget=forms.TextInput(attrs=attrs_dict),
-                           label=_(u'Your name'))
-    email = forms.EmailField(widget=forms.TextInput(attrs=dict(attrs_dict,
-                                                               maxlength=200)),
-                             label=_(u'Your email address'))
-    body = forms.CharField(widget=forms.Textarea(attrs=attrs_dict),
-                              label=_(u'Your message'))
-
+        
     def from_email(self):
         return self.shop.from_email
 
     def recipient_list(self):
-        return self.shop.get_notification_emails()
-
-    subject_template_name = "contact_form/contact_form_subject.txt"
-
-    template_name = 'contact_form/contact_form.txt'
-
-    def message(self):
-        """
-        Render the body of the message to a string.
-
-        """
-        if callable(self.template_name):
-            template_name = self.template_name()
-        else:
-            template_name = self.template_name
-        return loader.render_to_string(template_name,
-                                       self.get_context())
-
-    def subject(self):
-        """
-        Render the subject of the message to a string.
-
-        """
-        subject = loader.render_to_string(self.subject_template_name,
-                                          self.get_context())
-        return ''.join(subject.splitlines())
-
-    def get_context(self):
-        """
-        Return the context used to render the templates for the email
-        subject and body.
-
-        By default, this context includes:
-
-        * All of the validated values in the form, as variables of the
-          same names as their fields.
-
-        * The current ``Site`` object, as the variable ``site``.
-
-        * Any additional variables added by context processors (this
-          will be a ``RequestContext``).
-
-        """
-        if not self.is_valid():
-            raise ValueError("Cannot generate Context from invalid contact form")
-        return RequestContext(self.request,
-                              dict(self.cleaned_data,
-                                   site=Site.objects.get_current()))
-
-    def get_message_dict(self):
-        """
-        Generate the various parts of the message and return them in a
-        dictionary, suitable for passing directly as keyword arguments
-        to ``django.core.mail.send_mail()``.
-
-        By default, the following values are returned:
-
-        * ``from_email``
-
-        * ``message``
-
-        * ``recipient_list``
-
-        * ``subject``
-
-        """
-        if not self.is_valid():
-            raise ValueError("Message cannot be sent from invalid contact form")
-        message_dict = {}
-        for message_part in ('from_email', 'message', 'recipient_list', 'subject'):
-            attr = getattr(self, message_part)
-            message_dict[message_part] = callable(attr) and attr() or attr
-        return message_dict
-
-    def save(self, fail_silently=False):
-        """
-        Build and send the email message.
-
-        """
-        send_mail(fail_silently=fail_silently, **self.get_message_dict())
-
-
-class AkismetContactForm(ContactForm):
-    """
-    Contact form which doesn't add any extra fields, but does add an
-    Akismet spam check to the validation routine.
-
-    Requires the setting ``AKISMET_API_KEY``, which should be a valid
-    Akismet API key.
-
-    """
-    def clean_body(self):
-        """
-        Perform Akismet validation of the message.
-
-        """
-        if 'body' in self.cleaned_data and getattr(settings, 'AKISMET_API_KEY', ''):
-            from akismet import Akismet
-            from django.utils.encoding import smart_str
-            akismet_api = Akismet(key=settings.AKISMET_API_KEY,
-                                  blog_url='http://%s/' % Site.objects.get_current().domain)
-            if akismet_api.verify_key():
-                akismet_data = { 'comment_type': 'comment',
-                                 'referer': self.request.META.get('HTTP_REFERER', ''),
-                                 'user_ip': self.request.META.get('REMOTE_ADDR', ''),
-                                 'user_agent': self.request.META.get('HTTP_USER_AGENT', '') }
-                if akismet_api.comment_check(smart_str(self.cleaned_data['body']), data=akismet_data, build_data=True):
-                    raise forms.ValidationError(u"Akismet thinks this message is spam")
-        return self.cleaned_data['body']
+        return self.shop.get_notification_emails()

lfs/contact_form/locale/de/LC_MESSAGES/django.mo

Binary file removed.

lfs/contact_form/locale/de/LC_MESSAGES/django.po

-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\n"
-"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2010-05-20 08:03+0200\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-#: forms.py:140
-msgid "Your name"
-msgstr "Ihr Name"
-
-#: forms.py:143
-msgid "Your email address"
-msgstr "Ihre E-Mail Adresse"
-
-#: forms.py:145
-msgid "Your message"
-msgstr "Ihre Nachricht"

lfs/contact_form/views.py

-"""
-View which can render and send email from a contact form.
-
-"""
-
-from django.core.urlresolvers import reverse
-from django.http import HttpResponseRedirect
-from django.shortcuts import render_to_response
-from django.template import RequestContext
-
-from lfs.contact_form.forms import ContactForm
-
-
-def contact_form(request, form_class=ContactForm,
-                 template_name='contact_form/contact_form.html',
-                 success_url=None, extra_context=None,
-                 fail_silently=False):
-    """
-    Render a contact form, validate its input and send an email
-    from it.
-
-    **Optional arguments:**
-
-    ``extra_context``
-        A dictionary of variables to add to the template context. Any
-        callable object in this dictionary will be called to produce
-        the end result which appears in the context.
-
-    ``fail_silently``
-        If ``True``, errors when sending the email will be silently
-        supressed (i.e., with no logging or reporting of any such
-        errors. Default value is ``False``.
-
-    ``form_class``
-        The form to use. If not supplied, this will default to
-        ``contact_form.forms.ContactForm``. If supplied, the form
-        class must implement a method named ``save()`` which sends the
-        email from the form; the form class must accept an
-        ``HttpRequest`` as the keyword argument ``request`` to its
-        constructor, and it must implement a method named ``save()``
-        which sends the email and which accepts the keyword argument
-        ``fail_silently``.
-
-    ``success_url``
-        The URL to redirect to after a successful submission. If not
-        supplied, this will default to the URL pointed to by the named
-        URL pattern ``contact_form_sent``.
-
-    ``template_name``
-        The template to use for rendering the contact form. If not
-        supplied, defaults to
-        :template:`contact_form/contact_form.html`.
-
-    **Context:**
-
-    ``form``
-        The form instance.
-    
-    **Template:**
-
-    The value of the ``template_name`` keyword argument, or
-    :template:`contact_form/contact_form.html`.
-
-    """
-    #
-    # We set up success_url here, rather than as the default value for
-    # the argument. Trying to do it as the argument's default would
-    # mean evaluating the call to reverse() at the time this module is
-    # first imported, which introduces a circular dependency: to
-    # perform the reverse lookup we need access to contact_form/urls.py,
-    # but contact_form/urls.py in turn imports from this module.
-    #
-    
-    if success_url is None:
-        success_url = reverse('contact_form_sent')
-    if request.method == 'POST':
-        form = form_class(data=request.POST, files=request.FILES, request=request)
-        if form.is_valid():
-            form.save(fail_silently=fail_silently)
-            return HttpResponseRedirect(success_url)
-    else:
-        form = form_class(request=request)
-
-    if extra_context is None:
-        extra_context = {}
-    context = RequestContext(request)
-    for key, value in extra_context.items():
-        context[key] = callable(value) and value() or value
-    
-    return render_to_response(template_name,
-                              { 'form': form },
-                              context_instance=context)
 # lfs imports
 from lfs.core.sitemap import ProductSitemap
 from lfs.core.sitemap import CategorySitemap
+from lfs.contact_form.forms import ContactForm
 
 # Robots
 urlpatterns = patterns('django.views.generic.simple',
     url(r'^check-voucher/$', "check_voucher", name="lfs_check_voucher"),    
 )
 
-urlpatterns += patterns('lfs.contact_form.views',
-    url(r'^contact/$', "contact_form", name='contact_form'),
+urlpatterns += patterns('contact_form.views',
+    url(r'^contact/$', "contact_form", { "form_class" : ContactForm }, name='contact_form'),
     url(r'^sent/$', direct_to_template, { 'template': 'contact_form/contact_form_sent.html' }, name='contact_form_sent'),
 )