regluit/frontend/forms.py

"""
external library imports
"""
import logging
import re
import zipfile

from datetime import timedelta, datetime, date
from decimal import Decimal as D

"""
django imports
"""
from django import forms
from django.conf import settings
from django.conf.global_settings import LANGUAGES
from django.contrib.auth.models import User
from django.core.validators import validate_email
from django.db import models
from django.forms.widgets import RadioSelect
from django.forms.extras.widgets import SelectDateWidget
from django.utils.translation import ugettext_lazy as _

from ckeditor.widgets import CKEditorWidget

from selectable.forms import (
    AutoCompleteSelectMultipleWidget,
    AutoCompleteSelectMultipleField,
    AutoCompleteSelectWidget,
    AutoCompleteSelectField
)

from PyPDF2 import PdfFileReader


"""
regluit imports
"""
from regluit.core.models import (
    UserProfile,
    RightsHolder,
    Claim,
    Campaign,
    Offer,
    Premium,
    Ebook,
    EbookFile,
    Edition,
    PledgeExtra,
    Work,
    Press,
    Libpref,
    TWITTER,
    FACEBOOK,
    GRAVATAR,
    UNGLUEITAR
)
from regluit.libraryauth.models import Library
from regluit.core.parameters import LIBRARY, REWARDS, BUY2UNGLUE, THANKS
from regluit.core.lookups import (
    OwnerLookup,
    WorkLookup,
    PublisherNameLookup,
    EditionLookup
)
from regluit.utils.localdatetime import now
from regluit.utils.fields import EpubFileField, ISBNField
from regluit.mobi import Mobi
from regluit.pyepub import EPUB

logger = logging.getLogger(__name__)
nulls = [False, 'delete', '']

class EditionForm(forms.ModelForm):
    add_author = forms.CharField(max_length=500, required=False)
    add_subject = forms.CharField(max_length=200, required=False)
    publisher_name = AutoCompleteSelectField(
            PublisherNameLookup,
            label='Publisher Name',
            widget=AutoCompleteSelectWidget(PublisherNameLookup,allow_new=True),
            required=False,
            allow_new=True,
        )

    isbn = ISBNField(
        label=_("ISBN"), 
        max_length=17, 
        required = False,
        help_text = _("13 digits, no dash."),
        error_messages = {
            'invalid': _("This must be a valid ISBN-13."),
        }
    )
    goog = forms.RegexField(
        label=_("Google Books ID"), 
        max_length=12, 
        regex=r'^([a-zA-Z0-9\-_]{12}|delete)$',
        required = False,
        help_text = _("12 alphanumeric characters, dash or underscore, case sensitive."),
        error_messages = {
            'invalid': _("This value must be 12 alphanumeric characters, dash or underscore."),
        }
    )
    gdrd = forms.RegexField(
        label=_("GoodReads ID"), 
        max_length=8, 
        regex=r'^(\d+|delete)$',
        required = False,
        help_text = _("1-8 digits."),
        error_messages = {
            'invalid': _("This value must be 1-8 digits."),
        }
    )
    thng = forms.RegexField(
        label=_("LibraryThing ID"), 
        max_length=8, 
        regex=r'(^\d+|delete)$',
        required = False,
        help_text = _("1-8 digits."),
        error_messages = {
            'invalid': _("This value must be 1-8 digits."),
        }
    )
    oclc = forms.RegexField(
        label=_("OCLCnum"), 
        regex=r'^(\d\d\d\d\d\d\d\d\d*|delete)$',
        required = False,
        help_text = _("8 or more digits."),
        error_messages = {
            'invalid': _("This value must be 8 or more digits."),
        }
    )
    http = forms.RegexField(
        label=_("HTTP URL"),
        # https://mathiasbynens.be/demo/url-regex
        regex=re.compile(r"(https?|ftp)://(-\.)?([^\s/?\.#]+\.?)+(/[^\s]*)?$",
                         flags=re.IGNORECASE|re.S ), 
        required = False,
        help_text = _("no spaces of funny stuff."),
        error_messages = {
            'invalid': _("This value must be a valid http(s) URL."),
        }
    )
    language = forms.ChoiceField(choices=LANGUAGES)
    description = forms.CharField( required=False, widget= forms.Textarea(attrs={'cols': 80, 'rows': 10}))
    coverfile = forms.ImageField(required=False)
    
    def clean(self):
        has_isbn = self.cleaned_data.get("isbn", False) not in nulls
        has_oclc = self.cleaned_data.get("oclc", False) not in nulls
        has_goog = self.cleaned_data.get("goog", False) not in nulls
        has_http = self.cleaned_data.get("http", False) not in nulls
        if not has_isbn and not has_oclc  and not has_goog and not has_http:
            raise forms.ValidationError(_("There must be either an ISBN or an OCLC number."))
        return self.cleaned_data
    
    class Meta:
        model = Edition
        exclude = 'created', 'work'
        widgets = { 
                'title': forms.TextInput(attrs={'size': 40}),
                'add_author': forms.TextInput(attrs={'size': 30}),
                'add_subject': forms.TextInput(attrs={'size': 30}),
                'unglued': forms.CheckboxInput(),
                'cover_image': forms.TextInput(attrs={'size': 60}),
            }
            
class EbookFileForm(forms.ModelForm):
    file = forms.FileField(max_length=16777216)
    
    def __init__(self, campaign_type=BUY2UNGLUE, *args, **kwargs):
        super(EbookFileForm, self).__init__(*args, **kwargs)
        self.campaign_type = campaign_type
        if campaign_type == BUY2UNGLUE:
            self.fields['format'].widget=forms.HiddenInput()
        if campaign_type == THANKS:
            self.fields['format'].widget=forms.Select(choices=(('pdf','PDF'),( 'epub','EPUB'), ('mobi','MOBI')))
        
    def clean_format(self):
        if self.campaign_type is BUY2UNGLUE:
            return 'epub'
        else:
            logger.info("EbookFileForm "+self.cleaned_data.get('format',''))
            return self.cleaned_data.get('format','')
            
    def clean(self):
        format = self.cleaned_data['format']
        the_file = self.cleaned_data.get('file',None)
        if the_file and the_file.name:
            if format == 'epub':
                try:
                    book = EPUB(the_file.file)
                except Exception as e:
                    raise forms.ValidationError(_('Are you sure this is an EPUB file?: %s' % e) )
            elif format == 'mobi':
                try:
                    book = Mobi(the_file.file)
                    book.parse()
                except Exception as e:
                    raise forms.ValidationError(_('Are you sure this is a MOBI file?: %s' % e) )
            elif format == 'pdf':
                try:
                    doc = PdfFileReader(the_file.file)
                except Exception, e:
                    raise forms.ValidationError(_('%s is not a valid PDF file' % the_file.name) )
        return self.cleaned_data

    class Meta:
        model = EbookFile
        widgets = { 'edition': forms.HiddenInput}
        exclude = { 'created', 'asking' }

class EbookForm(forms.ModelForm):
    class Meta:
        model = Ebook
        exclude =( 'created', 'download_count', 'active')
        widgets = { 
                'edition': forms.HiddenInput, 
                'user': forms.HiddenInput, 
                'provider': forms.HiddenInput, 
                'url': forms.TextInput(attrs={'size' : 60}),
            }
    def clean_provider(self):
        new_provider= Ebook.infer_provider(self.data[self.prefix + '-url'])
        if not new_provider:
            raise forms.ValidationError(_("At this time, ebook URLs must point at Internet Archive, Wikisources, Wikibooks, Hathitrust, Project Gutenberg, raw files at Github, or Google Books."))
        return new_provider
        
    def clean_url(self):
        url = self.data[self.prefix + '-url']
        try:
            Ebook.objects.get(url=url)
        except Ebook.DoesNotExist:
            return url
        raise forms.ValidationError(_("There's already an ebook with that url."))
        
def UserClaimForm ( user_instance, *args, **kwargs ):
    class ClaimForm(forms.ModelForm):
        i_agree=forms.BooleanField(error_messages={'required': 'You must agree to the Terms in order to claim a work.'})
        rights_holder=forms.ModelChoiceField(queryset=user_instance.rights_holder.all(), empty_label=None)
        
        class Meta:
            model = Claim
            exclude = 'status'
            widgets = { 
                    'user': forms.HiddenInput, 
                    'work': forms.HiddenInput, 
                }

        def __init__(self):
            super(ClaimForm, self).__init__(*args, **kwargs)

    return ClaimForm()
            
class RightsHolderForm(forms.ModelForm):
    owner = AutoCompleteSelectField(
            OwnerLookup,
            label='Owner',
            widget=AutoCompleteSelectWidget(OwnerLookup),
            required=True,
            error_messages={'required': 'Please ensure the owner is a valid Unglue.it account.'},
        )
    email = forms.EmailField(
        label=_("notification email address for rights holder"), 
        max_length=100,
        error_messages={'required': 'Please enter an email address for the rights holder.'},
        )
    class Meta:
        model = RightsHolder

    def clean_rights_holder_name(self):
        rights_holder_name = self.data["rights_holder_name"]
        try:
            RightsHolder.objects.get(rights_holder_name__iexact=rights_holder_name)
        except RightsHolder.DoesNotExist:
            return rights_holder_name
        raise forms.ValidationError(_("Another rights holder with that name already exists."))

    
class ProfileForm(forms.ModelForm):
    clear_facebook=forms.BooleanField(required=False)
    clear_twitter=forms.BooleanField(required=False)
    clear_goodreads=forms.BooleanField(required=False)
    
    class Meta:
        model = UserProfile
        fields = 'tagline', 'librarything_id', 'home_url', 'clear_facebook', 'clear_twitter', 'clear_goodreads', 'avatar_source'
        widgets = {
            'tagline': forms.Textarea(attrs={'rows': 5, 'onKeyUp': "counter(this, 140)", 'onBlur': "counter(this, 140)"}),
        }

    def __init__(self, *args, **kwargs):
        profile = kwargs.get('instance')
        super(ProfileForm, self).__init__(*args, **kwargs)
        choices = []
        for choice in self.fields['avatar_source'].choices :
            if choice[0] == FACEBOOK and not profile.facebook_id:
                pass
            elif choice[0] == TWITTER and not profile.twitter_id:
                pass
            else:
                choices.append(choice)
        self.fields['avatar_source'].choices = choices

    def clean(self):
        # check that if a social net is cleared, we're not using it a avatar source
        if self.cleaned_data.get("clear_facebook", False) and self.cleaned_data.get("avatar_source", None)==FACEBOOK:
            self.cleaned_data["avatar_source"]==UNGLUEITAR
        if self.cleaned_data.get("clear_twitter", False) and self.cleaned_data.get("avatar_source", None)==TWITTER:
            self.cleaned_data["avatar_source"]==UNGLUEITAR
        return self.cleaned_data
 
class UserData(forms.Form):
    username = forms.RegexField(
        label=_("New Username"), 
        max_length=30, 
        regex=r'^[\w.@+-]+$',
        help_text = _("30 characters or fewer."),
        error_messages = {
            'invalid': _("This value may contain only letters, numbers and @/./+/-/_ characters.")
        }
    )
    oldusername = None


    def clean_username(self):
        username = self.data["username"]
        if username != self.oldusername:
            users = User.objects.filter(username__iexact=username)
            for user in users:
                raise forms.ValidationError(_("Another user with that username already exists."))
            return username
        raise forms.ValidationError(_("Your username is already "+username))

class CloneCampaignForm(forms.Form):
    campaign_id = forms.IntegerField(required = True, widget = forms.HiddenInput)

class OpenCampaignForm(forms.ModelForm):
    managers = AutoCompleteSelectMultipleField(
            OwnerLookup,
            label='Campaign Managers',
            widget=AutoCompleteSelectMultipleWidget(OwnerLookup),
            required=True,
            error_messages = {'required': "You must have at least one manager for a campaign."},
        )
    userid = forms.IntegerField( required = True, widget = forms.HiddenInput )
    class Meta:
        model = Campaign
        fields = 'name', 'work',  'managers', 'type'
        widgets = { 'work': forms.HiddenInput, "name": forms.HiddenInput, }

def getTransferCreditForm(maximum, data=None, *args, **kwargs ):
    class TransferCreditForm(forms.Form):
        recipient = AutoCompleteSelectField(
                OwnerLookup,
                label='Recipient',
                widget=AutoCompleteSelectWidget(OwnerLookup),
                required=True,
                error_messages={'required': 'Please ensure the recipient is a valid Unglue.it account.'},
            )
        amount = forms.IntegerField(
                required=True,
                min_value=1, 
                max_value=maximum,
                label="Transfer Amount",
                error_messages={'min_value': 'Transfer amount must be positive', 'max_value': 'You only have %(limit_value)s available for transfer'},
            )
    return TransferCreditForm( data=data )


class WorkForm(forms.Form):
    other_work = forms.ModelChoiceField(queryset=Work.objects.all(), 
            widget=forms.HiddenInput(), 
            required=True, 
            error_messages={'required': 'Missing work to merge with.'},
            )
    work=None

    def clean_other_work(self):
        if self.cleaned_data["other_work"].id== self.work.id:
            raise forms.ValidationError(_("You can't merge a work into itself"))
        return self.cleaned_data["other_work"]

    def __init__(self, work=None, *args, **kwargs):
        super(WorkForm, self).__init__(*args, **kwargs)
        self.work=work

class OtherWorkForm(WorkForm):
    other_work = AutoCompleteSelectField(
            WorkLookup,
            label='Other Work (title)',
            widget=AutoCompleteSelectWidget(WorkLookup),
            required=True,
            error_messages={'required': 'Missing work to merge with.'},
        )    

    def __init__(self,  *args, **kwargs):
        super(OtherWorkForm, self).__init__(*args, **kwargs)
        self.fields['other_work'].widget.update_query_parameters({'language':self.work.language})
    
class EditManagersForm(forms.ModelForm):
    managers = AutoCompleteSelectMultipleField(
            OwnerLookup,
            label='Campaign Managers',
            widget=AutoCompleteSelectMultipleWidget(OwnerLookup),
            required=True,
            error_messages = {'required': "You must have at least one manager for a campaign."},
        )
    class Meta:
        model = Campaign
        fields = ('id', 'managers')
        widgets = { 'id': forms.HiddenInput }

class CustomPremiumForm(forms.ModelForm):

    class Meta:
        model = Premium
        fields = 'campaign', 'amount', 'description', 'type', 'limit'
        widgets = { 
                'description': forms.Textarea(attrs={'cols': 80, 'rows': 4}),
                'campaign': forms.HiddenInput,
                'type': forms.HiddenInput(attrs={'value':'XX'}),
                'limit': forms.TextInput(attrs={'value':'0'}),
            }
class OfferForm(forms.ModelForm):

    class Meta:
        model = Offer
        fields = 'work', 'price', 'license'
        widgets = { 
                'work': forms.HiddenInput,
                'license': forms.HiddenInput,
            }
            
date_selector=range(date.today().year, settings.MAX_CC_DATE.year+1)

class CCDateForm(object):
    target = forms.DecimalField( min_value= D(settings.UNGLUEIT_MINIMUM_TARGET), error_messages={'required': 'Please specify a Revenue Target.'} )
    minimum_target = settings.UNGLUEIT_MINIMUM_TARGET
    maximum_target = settings.UNGLUEIT_MAXIMUM_TARGET
    max_cc_date = settings.MAX_CC_DATE

    def clean_target(self):
        new_target = self.cleaned_data['target']
        if new_target < D(settings.UNGLUEIT_MINIMUM_TARGET):
            raise forms.ValidationError(_('A campaign may not be launched with a target less than $%s' % settings.UNGLUEIT_MINIMUM_TARGET))
        if new_target > D(settings.UNGLUEIT_MAXIMUM_TARGET):
            raise forms.ValidationError(_('A campaign may not be launched with a target more than $%s' % settings.UNGLUEIT_MAXIMUM_TARGET))
        return new_target

    def clean_cc_date_initial(self):
        new_cc_date_initial = self.cleaned_data['cc_date_initial']
        if new_cc_date_initial.date() > settings.MAX_CC_DATE:
            raise forms.ValidationError('The initial Ungluing Date cannot be after %s'%settings.MAX_CC_DATE)
        elif new_cc_date_initial - now() < timedelta(days=0):         
            raise forms.ValidationError('The initial Ungluing date must be in the future!')
        return new_cc_date_initial

class DateCalculatorForm(CCDateForm, forms.ModelForm):
    revenue = forms.DecimalField()
    cc_date_initial = forms.DateTimeField(
            widget = SelectDateWidget(years=date_selector) 
        )
    class Meta:
        model = Campaign
        fields = 'target',  'cc_date_initial', 'revenue',

def getManageCampaignForm ( instance, data=None, initial=None, *args, **kwargs ):
    
    def get_queryset():
        work=instance.work
        return Edition.objects.filter(work = work)
            
    class ManageCampaignForm(CCDateForm,forms.ModelForm):
        target = forms.DecimalField( required= (instance.type in {REWARDS, BUY2UNGLUE}))
        deadline = forms.DateTimeField(
                required = (instance.type==REWARDS),
                widget = SelectDateWidget(years=date_selector) if instance.status=='INITIALIZED' else forms.HiddenInput
            )
        cc_date_initial = forms.DateTimeField(
                required = (instance.type==BUY2UNGLUE) and instance.status=='INITIALIZED',
                widget = SelectDateWidget(years=date_selector) if instance.status=='INITIALIZED' else forms.HiddenInput
            )
        paypal_receiver = forms.EmailField(
            label=_("contact email address for this campaign"), 
            max_length=100, 
            error_messages={'required': 'You must enter the email we should contact you at for this campaign.'},
            )
        edition =  forms.ModelChoiceField(get_queryset(), widget=RadioSelect(),empty_label='no edition selected',required = False,)
        publisher = forms.ModelChoiceField(instance.work.publishers(), empty_label='no publisher selected', required = False,)
        work_description =  forms.CharField( required=False , widget=CKEditorWidget())
        
        class Meta:
            model = Campaign
            fields = 'description', 'details', 'license', 'target', 'deadline', 'paypal_receiver', 'edition', 'email', 'publisher',  'cc_date_initial', "do_watermark", "use_add_ask",
            widgets = { 'deadline': SelectDateWidget }
    
        def clean_target(self):
            if self.instance.type == THANKS:
                return None
            new_target = super(ManageCampaignForm,self).clean_target()
            if self.instance:
                if self.instance.status == 'ACTIVE' and self.instance.target < new_target:
                    raise forms.ValidationError(_('The fundraising target for an ACTIVE campaign cannot be increased.'))
            return new_target

        def clean_cc_date_initial(self):
            if self.instance.type in {REWARDS,THANKS} :
                return None
            if self.instance:
                if self.instance.status != 'INITIALIZED':
                    # can't change this once launched
                    return self.instance.cc_date_initial
            return super(ManageCampaignForm,self).clean_cc_date_initial()            
        
        def clean_deadline(self):
            if self.instance.type in {BUY2UNGLUE, THANKS} :
                return None
            new_deadline_date = self.cleaned_data['deadline']
            new_deadline= new_deadline_date + timedelta(hours=23,minutes=59)
            if self.instance:
                if self.instance.status == 'ACTIVE':
                    return self.instance.deadline
            if new_deadline_date - now() > timedelta(days=int(settings.UNGLUEIT_LONGEST_DEADLINE)):
                raise forms.ValidationError(_('The chosen closing date is more than %s days from now' % settings.UNGLUEIT_LONGEST_DEADLINE))
            elif new_deadline - now() < timedelta(days=0):         
                raise forms.ValidationError(_('The chosen closing date is in the past'))
            return new_deadline
            
        def clean_license(self):
            new_license = self.cleaned_data['license']
            if self.instance:
                if self.instance.status == 'ACTIVE' and self.instance.license != new_license:
                    # should only allow change to a less restrictive license
                    if self.instance.license == 'CC BY-ND' and new_license in ['CC BY-NC-ND','CC BY-NC-SA','CC BY-NC']:
                        raise forms.ValidationError(_('The proposed license for an ACTIVE campaign may not add restrictions.'))
                    elif self.instance.license == 'CC BY' and new_license != 'CC0':
                        raise forms.ValidationError(_('The proposed license for an ACTIVE campaign may not add restrictions.'))
                    elif self.instance.license == 'CC BY-NC' and new_license in ['CC BY-NC-ND','CC BY-NC-SA','CC BY-SA','CC BY-ND']:
                        raise forms.ValidationError(_('The proposed license for an ACTIVE campaign may not add restrictions.'))
                    elif self.instance.license == 'CC BY-ND' and new_license in ['CC BY-NC-ND','CC BY-NC-SA','CC BY-SA','CC BY-NC']:
                        raise forms.ValidationError(_('The proposed license for an ACTIVE campaign may not add restrictions.'))
                    elif self.instance.license == 'CC BY-SA' and new_license in ['CC BY-NC-ND','CC BY-NC-SA','CC BY-ND','CC BY-NC']:
                        raise forms.ValidationError(_('The proposed license for an ACTIVE campaign may not add restrictions.'))
                    elif self.instance.license == 'CC BY-NC-SA' and new_license in ['CC BY-NC-ND','CC BY-ND']:
                        raise forms.ValidationError(_('The proposed license for an ACTIVE campaign may not add restrictions.'))
                    elif self.instance.license == 'CC0' :
                        raise forms.ValidationError(_('The proposed license for an ACTIVE campaign may not add restrictions.'))
                    elif self.instance.license in ['GDFL' , 'LAL']:
                        raise forms.ValidationError(_('Once you start a campaign with GDFL or LAL, you can\'t use any other license.'))
            return new_license
    return ManageCampaignForm(instance = instance, data=data, initial=initial)

class CampaignPurchaseForm(forms.Form):
    anonymous = forms.BooleanField(required=False, label=_("Make this purchase anonymous, please"))
    offer_id = forms.IntegerField(required=False)
    offer=None
    library_id = forms.IntegerField(required=False)
    library = None
    copies = forms.IntegerField(required=False,min_value=1)
    
    def clean_offer_id(self):
        offer_id = self.cleaned_data['offer_id']
        try:
            self.offer= Offer.objects.get(id=offer_id)
        except  Offer.DoesNotExist:
            raise forms.ValidationError(_("Sorry, that offer is not valid."))

    def clean_library_id(self):
        library_id = self.cleaned_data['library_id']
        if library_id:
            try:
                self.library = Library.objects.get(id=library_id)
            except  Library.DoesNotExist:
                raise forms.ValidationError(_("Sorry, that Library is not valid."))
 
    def clean(self):
        if self.offer.license == LIBRARY:
            if not self.library:
                raise forms.ValidationError(_("No library specified." ))
        return self.cleaned_data

    def amount(self):
        
        return self.offer.price * self.cleaned_data.get('copies',1) if self.offer else None
        
    @property
    def trans_extra(self):
        pe = PledgeExtra( anonymous=self.cleaned_data['anonymous'],
                            offer = self.offer )
        if self.library:
            pe.extra['library_id']=self.library.id
        pe.extra['copies']=self.cleaned_data.get('copies',1)
        return pe

class CampaignThanksForm(forms.Form):
    anonymous = forms.BooleanField(required=False, label=_("Make this contribution anonymous, please"))
    preapproval_amount = forms.DecimalField(
        required = True,
        min_value=D('1.00'),
        max_value=D('2000.00'), 
        decimal_places=2, 
        label="Pledge Amount",
    )
    @property
    def trans_extra(self):
        pe = PledgeExtra( anonymous=self.cleaned_data['anonymous'] )


class CampaignPledgeForm(forms.Form):
    preapproval_amount = forms.DecimalField(
        required = False,
        min_value=D('1.00'),
        max_value=D('2000.00'), 
        decimal_places=2, 
        label="Pledge Amount",
    )
    def amount(self):
        return self.cleaned_data["preapproval_amount"] if self.cleaned_data else None
        
    anonymous = forms.BooleanField(required=False, label=_("Make this pledge anonymous, please"))
    ack_name = forms.CharField(required=False, max_length=64, label=_("What name should we display?"))
    ack_dedication = forms.CharField(required=False, max_length=140, label=_("Your dedication:"))

    premium_id = forms.IntegerField(required=False)
    premium=None
    
    @property
    def trans_extra(self):
        return PledgeExtra( anonymous=self.cleaned_data['anonymous'],
                            ack_name=self.cleaned_data['ack_name'],
                            ack_dedication=self.cleaned_data['ack_dedication'],
                            premium=self.premium)
        
    def clean_preapproval_amount(self):
        preapproval_amount = self.cleaned_data['preapproval_amount']
        if preapproval_amount is None:
            raise forms.ValidationError(_("Please enter a pledge amount."))
        return preapproval_amount
    
    def clean_premium_id(self):
        premium_id = self.cleaned_data['premium_id']
        try:
            self.premium= Premium.objects.get(id=premium_id)
            if self.premium.limit>0:
                if self.premium.limit<=self.premium.premium_count:
                    raise forms.ValidationError(_("Sorry, that premium is fully subscribed."))
        except  Premium.DoesNotExist:
            raise forms.ValidationError(_("Sorry, that premium is not valid."))
        
    def clean(self):
        # check on whether the preapproval amount is < amount for premium tier. If so, put an error message
        preapproval_amount = self.cleaned_data.get("preapproval_amount")
        if preapproval_amount is None:
            # preapproval_amount failed validation, that error is the relevant one
            return self.cleaned_data
        elif self.premium is None:
            raise forms.ValidationError(_("Please select a premium." ))            
        elif preapproval_amount < self.premium.amount:
            logger.info("raising form validating error")
            raise forms.ValidationError(_("Sorry, you must pledge at least $%s to select that premium." % (self.premium.amount)))
        return self.cleaned_data

class TokenCCMixin(forms.Form):
    stripe_token = forms.CharField(required=True, widget=forms.HiddenInput())

class BaseCCMixin(forms.Form):
    work_id = forms.IntegerField(required=False, widget=forms.HiddenInput())
    preapproval_amount= forms.DecimalField(
        required=False,
        min_value=D('1.00'), 
        max_value=D('100000.00'), 
        decimal_places=2, 
        label="Amount",
    )
class UserCCMixin(forms.Form):
    username = forms.CharField(max_length=30, required=True, widget=forms.HiddenInput())

class PlainCCForm(TokenCCMixin, forms.Form):
    pass

class BaseCCForm(BaseCCMixin, TokenCCMixin, forms.Form):
    pass

class AnonCCForm(BaseCCForm):
    email = forms.CharField(max_length=30, required=False, widget=forms.TextInput())

class CCForm(UserCCMixin, BaseCCForm):
    pass

class AccountCCForm( BaseCCMixin, UserCCMixin, forms.Form):
    pass

class DonateForm(forms.Form):
    preapproval_amount = forms.DecimalField( widget=forms.HiddenInput() )
    username = forms.CharField(max_length=30, required=True, widget=forms.HiddenInput() )
    work_id = forms.IntegerField(required=False,  widget=forms.HiddenInput() )
    title = forms.CharField(max_length=200, required=False, widget=forms.HiddenInput() )
    
    
class GoodreadsShelfLoadingForm(forms.Form):
    goodreads_shelf_name_number = forms.CharField(widget=forms.Select(choices=(
                ('all','all'),
                )))

class LibraryThingForm(forms.Form):
    lt_username = forms.CharField(max_length=30, required=True)

class PledgeCancelForm(forms.Form):
    # which campaign whose active transaction to cancel?
    campaign_id = forms.IntegerField(required=True, widget=forms.HiddenInput())


class CampaignAdminForm(forms.Form):
    campaign_id = forms.IntegerField()
    
class EmailShareForm(forms.Form):
    recipient = forms.EmailField(error_messages={'required': 'Please specify a recipient.'})
    subject = forms.CharField(max_length=100, error_messages={'required': 'Please specify a subject.'})
    message = forms.CharField(widget=forms.Textarea(), error_messages={'required': 'Please include a message.'})
    # allows us to return user to original page by passing it as hidden form input
    # we can't rely on POST or GET since the emailshare view handles both
    # and may iterate several times as it catches user errors, losing URL info
    next = forms.CharField(widget=forms.HiddenInput())
    
class FeedbackForm(forms.Form):
    sender = forms.EmailField(widget=forms.TextInput(attrs={'size':50}), label="Your email", error_messages={'required': 'Please specify your email address.'})
    subject = forms.CharField(max_length=500, widget=forms.TextInput(attrs={'size':50}), error_messages={'required': 'Please specify a subject.'})
    message = forms.CharField(widget=forms.Textarea(), error_messages={'required': 'Please specify a message.'})
    page = forms.CharField(widget=forms.HiddenInput())
    notarobot = forms.IntegerField(label="Please prove you're not a robot", error_messages={'required': "You must do the sum to prove you're not a robot."})
    answer = forms.IntegerField(widget=forms.HiddenInput())
    num1 = forms.IntegerField(widget=forms.HiddenInput())
    num2 = forms.IntegerField(widget=forms.HiddenInput())
    
    def clean(self):
        cleaned_data = self.cleaned_data
        notarobot = str(cleaned_data.get("notarobot"))
        answer = str(cleaned_data.get("answer"))
        if notarobot != answer:
            raise forms.ValidationError(_("Whoops, try that sum again."))
            
        return cleaned_data

class MsgForm(forms.Form):
    msg = forms.CharField(widget=forms.Textarea(), error_messages={'required': 'Please specify a message.'})

    def full_clean(self):
        super(MsgForm,self).full_clean()
        if self.data.has_key("supporter"):
            try:
                self.cleaned_data['supporter'] = User.objects.get(id=self.data["supporter"])
            except User.DoesNotExist:
                raise ValidationError("Supporter does not exist")
        else:
            raise ValidationError("Supporter is not specified")
        if self.data.has_key("work"):
            try:
                self.cleaned_data['work'] = Work.objects.get(id=self.data["work"])
            except Work.DoesNotExist:
                raise ValidationError("Work does not exist")
        else:
            raise ValidationError("Work is not specified")
            
class PressForm(forms.ModelForm):
    class Meta:
        model = Press

        widgets = { 
                'date': SelectDateWidget(years=range(2010,2025)),
            }
            
class KindleEmailForm(forms.Form):
    kindle_email = forms.EmailField()
    
        
class LibModeForm(forms.ModelForm):
    class Meta:
        model = Libpref
        fields = ()