regluit/frontend/views.py

'''
external library imports
'''
import re
import sys
import json
import logging
import urllib
import requests
import random
import oauth2 as oauth

from datetime import timedelta, date
from decimal import Decimal as D
from itertools import islice, chain
from notification import models as notification
from random import randint
from re import sub
from xml.etree import ElementTree as ET
from xml.sax import SAXParseException
from tastypie.models import ApiKey

'''
django imports
'''
from django import forms
from django.conf import settings
from django.contrib import messages
from django.contrib.admin.views.decorators import staff_member_required
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.contrib.auth.views import login,password_reset, redirect_to_login
from django.contrib.comments import Comment
from django.contrib.sites.models import Site
from django.core import signing
from django.core.exceptions import ObjectDoesNotExist, ValidationError
from django.core.files.storage import default_storage
from django.core.files.temp import NamedTemporaryFile
from django.core.mail import EmailMessage
from django.core.urlresolvers import reverse, reverse_lazy
from django.core.validators import validate_email
from django.db.models import Q, Count, Sum
from django.forms import Select
from django.forms.models import modelformset_factory, inlineformset_factory
from django.http import (
    HttpResponseRedirect,
    Http404,
    HttpResponse,
    HttpResponseNotFound
)
from django.shortcuts import render, render_to_response, get_object_or_404
from django.template import TemplateDoesNotExist
from django.template.loader import render_to_string
from django.utils.http import urlencode
from django.utils.translation import ugettext_lazy as _
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from django.views.generic.edit import FormView
from django.views.generic.list import ListView
from django.views.generic.base import TemplateView

'''
regluit imports
'''
from regluit.core import (
    tasks,
    models,
    bookloader,
    librarything,
    userlists,
    goodreads,
    ungluify_record
)
import regluit.core.cc as cc
from regluit.core.bookloader import merge_works, detach_edition
from regluit.core.goodreads import GoodreadsClient
from regluit.core.search import gluejar_search
from regluit.core.signals import supporter_message
from regluit.core.tasks import send_mail_task, emit_notifications, watermark_acq
from regluit.core.parameters import *

from regluit.frontend.forms import (
    UserData,
    ProfileForm,
    CampaignPledgeForm,
    CampaignPurchaseForm,
    CampaignThanksForm,
    GoodreadsShelfLoadingForm,
    RightsHolderForm,
    UserClaimForm,
    LibraryThingForm,
    OpenCampaignForm,
    getManageCampaignForm,
    DonateForm,
    CampaignAdminForm,
    EmailShareForm,
    FeedbackForm,
    EbookForm,
    EbookFileForm,
    CustomPremiumForm,
    OfferForm,
    EditManagersForm,
    EditionForm,
    PledgeCancelForm,
    getTransferCreditForm,
    CCForm,
    AnonCCForm,
    CloneCampaignForm,
    PlainCCForm,
    WorkForm,
    OtherWorkForm,
    MsgForm,
    PressForm,
    KindleEmailForm,
    MARCUngluifyForm,
    MARCFormatForm,
    DateCalculatorForm
)

from regluit.payment import baseprocessor, stripelib
from regluit.payment.credit import credit_transaction
from regluit.payment.manager import PaymentManager
from regluit.payment.models import Transaction, Account, Sent, CreditLog
from regluit.payment.parameters import (
    TRANSACTION_STATUS_ACTIVE,
    TRANSACTION_STATUS_COMPLETE,
    TRANSACTION_STATUS_CANCELED,
    TRANSACTION_STATUS_ERROR,
    TRANSACTION_STATUS_FAILED,
    TRANSACTION_STATUS_INCOMPLETE,
    TRANSACTION_STATUS_NONE,
    TRANSACTION_STATUS_MODIFIED,
    PAYMENT_TYPE_AUTHORIZATION,
    PAYMENT_TYPE_INSTANT,
    PAYMENT_HOST_STRIPE,
    PAYMENT_HOST_NONE
)

from regluit.utils.localdatetime import now, date_today
from regluit.booxtream.exceptions import BooXtreamError
from regluit.pyepub import InvalidEpub
from regluit.libraryauth.views import Authenticator
from regluit.libraryauth.models import Library

logger = logging.getLogger(__name__)

def static_redirect_view(request, file_name, dir=""):
    return HttpResponseRedirect('/static/'+dir+"/"+file_name)

def slideshow():
    max = 8
    ending = models.Campaign.objects.filter(status='ACTIVE').order_by('deadline')
    count = ending.count()
    j = 0
        
    worklist = []
    if max > count:
        # add all the works with active campaigns
        for campaign in ending:
            worklist.append(campaign.work)

        # then fill out the rest of the list with slide works
        remainder = max - count
        remainder_works = models.Work.objects.filter(campaigns__status="SUCCESSFUL").order_by('-campaigns__deadline')[:remainder]
        worklist.extend(remainder_works)
    else:
        # if the active campaign list has more works than we can fit 
        # in our slideshow, it's the only source we need to draw from
        while j < max:
            worklist.append(ending[j].work)
            j +=1
                
    return (worklist[:4],worklist[4:8])

def process_kindle_email(request):
    """
    check for kindle_email in session in case this is a redirect after
    download + login/account creation; add kindle email to profile
    """
    user = request.user
    if user.is_authenticated() and request.session.has_key('kindle_email'):
        user.profile.kindle_email = request.session['kindle_email']
        user.profile.save()
        request.session.pop('kindle_email')

def next(request):
    if request.COOKIES.has_key('next'):
        response = HttpResponseRedirect(urllib.unquote(urllib.unquote(request.COOKIES['next'])))
        response.delete_cookie('next')
        return response
    else:
        return HttpResponseRedirect('/')
        
def safe_get_work(work_id):
    """
    use this rather than querying the db directly for a work by id
    """
    try:
        work = models.Work.objects.get(id = work_id)
    except models.Work.DoesNotExist:
        try:
            work = models.WasWork.objects.get(was = work_id).work
        except models.WasWork.DoesNotExist:
            raise Http404
    return work
    
def cover_width(work):
    if work.percent_of_goal() < 100:
        cover_width = 100 - work.percent_of_goal()
    else:
        cover_width = 0
        
    return cover_width

def home(request, landing=False):
    if request.user.is_authenticated() and landing == False:
        return HttpResponseRedirect(reverse('supporter',
            args=[request.user.username]))
            
    """
    use campaigns instead of works so that we can order by amount left,
    drive interest toward most-nearly-successful
    """
    top_campaigns = models.Campaign.objects.filter(status="ACTIVE").order_by('left')[:4]
    coming_soon = []
    if not top_campaigns:
        coming_soon = models.Campaign.objects.filter(status="INITIALIZED").order_by('-work__num_wishes')[:4]
    
    most_wished = models.Work.objects.order_by('-num_wishes')[:4]
    
    unglued_books = models.Work.objects.filter(campaigns__status="SUCCESSFUL").order_by('-campaigns__deadline')[:4]
    
    cc_books = models.Work.objects.filter(
                                          editions__ebooks__isnull=False,
                                          editions__ebooks__rights__in=cc.LICENSE_LIST
                                         ).distinct().order_by('-created')[:4]

    """
    get various recent types of site activity
    """
    latest_comments = Comment.objects.order_by(
            '-submit_date'
        )[:10]
    latest_pledges = Transaction.objects.filter(
            anonymous=False
        ).exclude(
            type=0  #incomplete
        ).only(
            'date_created', 'user', 'campaign'
        ).order_by(
            '-date_created'
        )[:10]
    latest_wishes = models.Wishes.objects.order_by(
            '-created'
        )[:10]

    """
    for each event, we'll be passing its object and type to the template
    (and preserving its date for sorting purposes)
    """
    latest_comments_tuple = map(
        lambda x: (x.submit_date, x, 'comment'),
        latest_comments
    )
    
    latest_pledges_tuple = map(
        lambda x: (x.date_created, x, 'pledge'),
        latest_pledges
    )
    
    latest_wishes_tuple = map(
        lambda x: (x.created, x, 'wish'),
        latest_wishes
    )
    
    """
    merge latest actions into a single list, sorted by date, to loop through in template
    """
    latest_actions = sorted(
        chain(latest_comments_tuple, latest_pledges_tuple, latest_wishes_tuple), 
        key=lambda instance: instance[0],
        reverse=True
    )
    
    if request.user.is_authenticated():
        events = latest_actions[:12]
    else:
        events = latest_actions[:6]
    
    return render(
        request,
        'home.html', 
        {
            'events': events, 
            'top_campaigns': top_campaigns, 
            'coming_soon': coming_soon,
            'unglued_books': unglued_books, 
            'cc_books': cc_books,
            'most_wished': most_wished,
        }
    )

def stub(request):
    path = request.path[6:] # get rid of /stub/
    return render(request,'stub.html', {'path': path})

def acks(request, work):
    return render(request,'front_matter.html', {'campaign': work.last_campaign()})
    

@login_required
def social_auth_reset_password(request):
    if not request.user.has_usable_password():
        request.user.set_password('%010x' % random.randrange(16**10))
        request.user.save()
    return password_reset(request)
    
def work(request, work_id, action='display'):
    work = safe_get_work(work_id)
    alert=''

    formset = None
    if action == "acks":
        return acks( request, work)
    elif action == "editions":
        EditionFormSet = inlineformset_factory(models.Work, models.Edition, fields=(), extra=0 )    
        if request.method == "POST" and (request.user.is_staff or user in work.last_campaign().managers.all()):
            formset = EditionFormSet(data=request.POST, instance=work)
            if formset.is_valid():
                for form in formset.deleted_forms:
                    detach_edition(form.instance)
                    alert = 'editions have been split'
            if request.POST.has_key('select_edition'):
                selected_id=request.POST['select_edition']
                try:
                    work.selected_edition= work.editions.get(id=selected_id)
                    work.save()
                    alert = alert + 'edition selected'
                except models.Edition.DoesNotExist:
                    pass
        formset = EditionFormSet(instance=work)

    # process waiting add request
    if not request.user.is_anonymous() and request.session.has_key("add_wishlist"):
        add_url = request.session["add_wishlist"]
        if add_url == request.path:
            request.user.wishlist.add_work(work, "login", notify=True)
            request.session.pop("add_wishlist")
            
    process_kindle_email(request)
                
    if request.method == 'POST' and not request.user.is_anonymous():
        activetab = '4'
    elif action == 'editions':
        activetab = '4'
    else:
        try:
            activetab = request.GET['tab']
            if activetab not in ['1', '2', '3', '4']:
                activetab = '1';
        except:
            activetab = '1';
            
    campaign = work.last_campaign()
    editions = work.editions.all().order_by('-publication_date')[:10]
    try:
        pledged = campaign.transactions().filter(user=request.user, status="ACTIVE")
    except:
        pledged = None
        
    cover_width_number = 0
    
    if work.last_campaign_status() == 'ACTIVE':
        cover_width_number = cover_width(work)
    
    if action == 'preview':
        work.last_campaign_status = 'ACTIVE'
        
    if not request.user.is_anonymous():
        claimform = UserClaimForm( request.user, data={'claim-work':work.pk, 'claim-user': request.user.id}, prefix = 'claim')
    else:
        claimform = None
        
    if campaign:
        # pull up premiums explicitly tied to the campaign
        # mandatory premiums are only displayed in pledge process
        premiums = campaign.custom_premiums()
    else:
        premiums = None
        
    wishers = work.num_wishes
    base_url = request.build_absolute_uri("/")[:-1]
    
    active_claims = work.claim.all().filter(status='active')
    if active_claims.count() == 1:
        claimstatus = 'one_active'
        rights_holder_name = active_claims[0].rights_holder.rights_holder_name
    else:
        rights_holder_name = None
        pending_claims = work.claim.all().filter(status='pending')
        pending_claims_count = pending_claims.count()
        if pending_claims_count > 1:
          claimstatus = 'disputed'
        elif pending_claims_count == 1:
          claimstatus = 'one_pending'
          rights_holder_name = pending_claims[0].rights_holder.rights_holder_name
        else:
          claimstatus = 'open'
    
    return render(request, 'work.html', {
        'work': work, 
        'premiums': premiums, 
        'ungluers': userlists.supporting_users(work, 5), 
        'claimform': claimform,
        'wishers': wishers,
        'base_url': base_url,
        'editions': editions,
        'pledged': pledged,
        'activetab': activetab,
        'alert': alert,
        'claimstatus': claimstatus,
        'rights_holder_name': rights_holder_name,
        'cover_width': cover_width_number,
        'action': action,
        'formset': formset,
    })    

def edition_uploads(request, edition_id):
    context = {}
    if not request.user.is_authenticated() :
        return render(request, "admins_only.html")
    try:
        edition = models.Edition.objects.get(id = edition_id)
    except models.Edition.DoesNotExist:
        raise Http404
    campaign_type = edition.work.last_campaign().type
    if not request.user.is_staff :
        if not request.user in edition.work.last_campaign().managers.all():
            return render(request, "admins_only.html")
    if request.method == 'POST' :
        form = EbookFileForm(data=request.POST, files=request.FILES, campaign_type=campaign_type)
        if form.is_valid() :
            logger.info("EbookFileForm is_valid")
            form.save()
            edition.work.last_campaign().save()
            context['uploaded']=True
            if campaign_type == BUY2UNGLUE:
                if edition.work.last_campaign().status == 'SUCCESSFUL':
                    try:
                        edition.work.last_campaign().watermark_success()
                    except Exception as e:
                        context['upload_error']= e
                        form.instance.delete()
                else:
                    # campaign mangager gets a copy
                    test_acq = models.Acq.objects.create(user=request.user,work=edition.work,license= TESTING)
                    try:
                        test_acq.get_watermarked()
                        context['watermarked']= test_acq.watermarked
                    except Exception as e:
                        context['upload_error']= e
                        form.instance.delete()
            if campaign_type == THANKS:
                e = form.instance.check_file()
                if e != None:
                    logger.error(e)
                    context['upload_error']= e
                    form.instance.delete()
        else:
            context['upload_error']= form.errors
    form = EbookFileForm(initial={'edition':edition,'format':'epub'}, campaign_type=campaign_type)
    context.update({
            'form': form, 'edition': edition, 
            'ebook_files': models.EbookFile.objects.filter(edition = edition)
        })
    return render(request, 'edition_uploads.html', context )

@login_required
def new_edition(request, work_id, edition_id, by=None):
    if not request.user.is_authenticated() :
        return render(request, "admins_only.html")
    # if the work and edition are set, we save the edition and set the work    
    language='en'
    description=''
    title=''
    if work_id:
        work = safe_get_work(work_id)
        language=work.language
        description=work.description
        title=work.title
    else:
        work=None
    
    alert = ''  
    admin = False
    if request.user.is_staff :
        admin = True
    elif work and work.last_campaign():
        if request.user in work.last_campaign().managers.all():
            admin = True
    elif work==None and request.user.rights_holder.count():
        admin = True
    if edition_id:
        try:
            edition = models.Edition.objects.get(id = edition_id)
        except models.Edition.DoesNotExist:
            raise Http404
        if work:
            edition.work = work 
        language=edition.work.language
        description=edition.work.description
    else:
        edition = models.Edition()
        if work:
            edition.work = work 

    initial={
            'language':language,
            'publisher_name':edition.publisher_name,
            'isbn':edition.isbn_13, 
            'oclc':edition.oclc,
            'description':description,
            'title': title,
            'goog': edition.googlebooks_id,
            'gdrd': edition.goodreads_id,
            'thng': edition.librarything_id,
            }
    if request.method == 'POST' :
        form = None
        edition.new_author_names=request.POST.getlist('new_author')
        edition.new_subjects=request.POST.getlist('new_subject')
        if edition.id and admin:
            for author in edition.authors.all():
                if request.POST.has_key('delete_author_%s' % author.id):
                    edition.authors.remove(author)
                    form = EditionForm(instance=edition, data=request.POST, files=request.FILES)
                    break
        if request.POST.has_key('add_author_submit') and admin:
            new_author_name = request.POST['add_author'].strip()
            try:
                author= models.Author.objects.get(name=new_author_name)
            except models.Author.DoesNotExist:
                author=models.Author.objects.create(name=new_author_name)
            edition.new_author_names.append(new_author_name)
            form = EditionForm(instance=edition, data=request.POST, files=request.FILES)
        elif request.POST.has_key('add_subject_submit') and admin:
            new_subject = request.POST['add_subject'].strip()
            try:
                author= models.Subject.objects.get(name=new_subject)
            except models.Subject.DoesNotExist:
                author=models.Subject.objects.create(name=new_subject)
            edition.new_subjects.append(new_subject)
            form = EditionForm(instance=edition, data=request.POST, files=request.FILES)
            edition.ebook_form = EbookForm( instance= models.Ebook(user = request.user, edition = edition, provider = 'x' ), prefix = 'ebook_%d'%edition.id)

        elif edition.id and request.POST.has_key('ebook_%d-edition' % edition.id):
            edition.ebook_form= EbookForm( data = request.POST, prefix = 'ebook_%d'%edition.id)
            if edition.ebook_form.is_valid():
                edition.ebook_form.save()
                alert = 'Thanks for adding an ebook to unglue.it!'
            else: 
                alert = 'your submitted ebook had errors'
            form = EditionForm(instance=edition, initial=initial)
        elif not form  and admin:
            form = EditionForm(instance=edition, data=request.POST, files=request.FILES)
            if form.is_valid():
                form.save()
                if not work:
                    work= models.Work(title=form.cleaned_data['title'],language=form.cleaned_data['language'],description=form.cleaned_data['description'])
                    work.save()
                    edition.work=work
                    edition.save()
                else:
                    work.description=form.cleaned_data['description']
                    work.title=form.cleaned_data['title']
                    work.earliest_publication = None  # will reset on next access
                    work.save()
                
                id_msg=""
                for id_type in ('isbn', 'oclc', 'goog', 'thng', 'gdrd'):
                    id_val = form.cleaned_data[id_type]
                    if id_val=='delete':
                        edition.identifiers.filter(type=id_type).delete()
                    elif id_val:
                        existing= models.Identifier.objects.filter(type=id_type, value=form.cleaned_data[id_type])
                        if existing.count() and existing[0].edition != edition:
                                return render(request, 'new_edition.html', {
                                        'form': form,  'edition': edition, 
                                        'id_msg': "%s = %s already exists"%( id_type, id_val ),
                                        })
                        else:
                            models.Identifier.set(type=id_type, value=id_val, edition=edition, work=work)
                for author_name in edition.new_author_names:
                    try:
                        author= models.Author.objects.get(name=author_name)
                    except models.Author.DoesNotExist:
                        author=models.Author.objects.create(name=author_name)
                    author.editions.add(edition)
                for subject_name in edition.new_subjects:
                    try:
                        subject= models.Subject.objects.get(name=subject_name)
                    except models.Subject.DoesNotExist:
                        subject=models.Subject.objects.create(name=subject_name)
                    subject.works.add(work)
                work_url = reverse('work', kwargs={'work_id': edition.work.id})
                cover_file=form.cleaned_data.get("coverfile",None)
                if cover_file:
                    # save it 
                    cover_file_name= '/Users/%s/covers/%s/%s' % ( request.user.username, edition.pk, cover_file.name)
                    file = default_storage.open(cover_file_name, 'w')
                    file.write(cover_file.read())
                    file.close()
                    #and put its url into cover_image
                    edition.cover_image = default_storage.url(cover_file_name)
                    edition.save()
                return HttpResponseRedirect(work_url)
    else:
        if edition.pk:
            edition.ebook_form = EbookForm( instance= models.Ebook(user = request.user, edition = edition, provider = 'x' ), prefix = 'ebook_%d'%edition.id)
        form = EditionForm(instance=edition, initial=initial)
    try:
        show_ebook_form = edition.work.last_campaign().status not in ['ACTIVE','INITIALIZED']
    except:
        show_ebook_form = True
    return render(request, 'new_edition.html', {
            'form': form, 'edition': edition, 'admin':admin, 'alert':alert,
                'show_ebook_form':show_ebook_form, 
        })

def campaign_results(request, campaign):
    return render(request, 'campaign_results.html', {
            'campaign': campaign, 
        })
    

def manage_campaign(request, id, action='manage'):
    campaign = get_object_or_404(models.Campaign, id=id)
    campaign.not_manager=False
    campaign.problems=[]
    if (not request.user.is_authenticated) or (not request.user in campaign.managers.all() and not request.user.is_staff):
        campaign.not_manager=True
        return render(request, 'manage_campaign.html', {'campaign': campaign})
    if action == 'results':
        return campaign_results(request, campaign)
    alerts = []
    activetab = '#1'
    offers = campaign.work.offers.all()
    for offer in offers:
        offer.offer_form=OfferForm(instance=offer,prefix='offer_%d'%offer.id)

    if request.method == 'POST' :
        if request.POST.has_key('add_premium') :
            postcopy=request.POST.copy()
            postcopy['type']='CU'
            new_premium_form = CustomPremiumForm(data=postcopy)
            if new_premium_form.is_valid():
                new_premium_form.save()
                alerts.append(_('New premium has been added'))
                new_premium_form = CustomPremiumForm(data={'campaign': campaign})
            else:
                alerts.append(_('New premium has not been added'))              
            form = getManageCampaignForm(instance=campaign)
            activetab = '#2'
        elif request.POST.has_key('save') or request.POST.has_key('launch') :
            form= getManageCampaignForm(instance=campaign, data=request.POST)  
            if form.is_valid():     
                form.save() 
                campaign.dollar_per_day = None
                campaign.set_dollar_per_day()
                campaign.work.selected_edition=campaign.edition
                if campaign.type in {BUY2UNGLUE,THANKS} :
                    offers= campaign.work.create_offers()
                    for offer in offers:
                        offer.offer_form=OfferForm(instance=offer,prefix='offer_%d'%offer.id)
                campaign.update_left()
                if campaign.type is THANKS :
                    campaign.work.description = form.cleaned_data['work_description']
                campaign.work.save()
                alerts.append(_('Campaign data has been saved'))
                activetab = '#2'
            else:
                alerts.append(_('Campaign data has NOT been saved'))
            if 'launch' in request.POST.keys():
                activetab = '#3'
                if (campaign.launchable and form.is_valid()) and (not settings.IS_PREVIEW or request.user.is_staff):
                    campaign.activate()
                    alerts.append(_('Campaign has been launched'))
                else:
                    alerts.append(_('Campaign has NOT been launched'))
            new_premium_form = CustomPremiumForm(data={'campaign': campaign})
        elif request.POST.has_key('inactivate') :
            activetab = '#2'
            if request.POST.has_key('premium_id'):
                premiums_to_stop = request.POST.getlist('premium_id')
                for premium_to_stop in premiums_to_stop:
                    selected_premium = models.Premium.objects.get(id=premium_to_stop)
                    if selected_premium.type == 'CU':
                        selected_premium.type = 'XX'
                        selected_premium.save()
                        alerts.append(_('Premium %s has been inactivated'% premium_to_stop))   
            form = getManageCampaignForm(instance=campaign)
            new_premium_form = CustomPremiumForm(data={'campaign': campaign})
        elif request.POST.has_key('change_offer'):
            for offer in offers :
                if request.POST.has_key('offer_%d-work' % offer.id) :
                    offer.offer_form=OfferForm(instance=offer, data = request.POST, prefix='offer_%d'%offer.id)
                    if offer.offer_form.is_valid():
                        offer.offer_form.save()
                        offer.active =  True
                        offer.save()
                        alerts.append(_('Offer has been changed'))
                    else:
                        alerts.append(_('Offer has not been changed'))              
            form = getManageCampaignForm(instance=campaign)
            new_premium_form = CustomPremiumForm(data={'campaign': campaign})
            activetab = '#2'
    else:
        form = getManageCampaignForm(instance=campaign, initial={'work_description':campaign.work.description})
        new_premium_form = CustomPremiumForm(data={'campaign': campaign})
        
    return render(request, 'manage_campaign.html', {
        'campaign': campaign, 
        'form':form, 
        'problems': campaign.problems, 
        'alerts': alerts, 
        'premiums' : campaign.custom_premiums(),
        'premium_form' : new_premium_form,
        'work': campaign.work,
        'activetab': activetab,
        'offers':offers
    })
        
def googlebooks(request, googlebooks_id):
    try: 
        edition = models.Identifier.objects.get(type='goog',value=googlebooks_id).edition
    except models.Identifier.DoesNotExist:
        try:
            edition = bookloader.add_by_googlebooks_id(googlebooks_id)
            if edition.new:
                # add related editions asynchronously
                tasks.populate_edition.delay(edition.isbn_13)
        except bookloader.LookupFailure:
            logger.warning("failed to load googlebooks_id %s" % googlebooks_id)
            return HttpResponseNotFound("failed looking up googlebooks id %s" % googlebooks_id)
    if not edition:
        return HttpResponseNotFound("invalid googlebooks id")
    work_url = reverse('work', kwargs={'work_id': edition.work.id})

    # process waiting add request
    if not request.user.is_anonymous() and request.session.has_key("add_wishlist"):
        add_url = request.session["add_wishlist"]
        if add_url == request.path:
            request.user.wishlist.add_work(edition.work, "login", notify=True)
            request.session.pop("add_wishlist")

    return HttpResponseRedirect(work_url)

def subjects(request):
    order = request.GET.get('order')
    subjects = models.Subject.objects.all()
    subjects = subjects.annotate(Count('works'))

    if request.GET.get('order') == 'count':
        subjects = subjects.order_by('-works__count')
    else:
        subjects = subjects.order_by('name')

    return render(request, 'subjects.html', {'subjects': subjects})

class FilterableListView(ListView):
    def get_queryset(self):
        if self.request.GET.has_key('pub_lang'):
            if self.model is models.Campaign:
                return self.get_queryset_all().filter(work__language=self.request.GET['pub_lang'])
            else:
                return self.get_queryset_all().filter(language=self.request.GET['pub_lang'])
        else:
            return self.get_queryset_all()
            
    def get_context_data(self, **kwargs):
        context = super(FilterableListView, self).get_context_data(**kwargs)
        if self.request.GET.has_key('pub_lang'):
            context['pub_lang']=self.request.GET['pub_lang']
        else:
            context['pub_lang']=''
        context['show_langs']=True
        context['WISHED_LANGS']=settings.WISHED_LANGS
        return context

recommended_user = User.objects.filter( username=settings.UNGLUEIT_RECOMMENDED_USERNAME)

class WorkListView(FilterableListView):
    template_name = "work_list.html"
    context_object_name = "work_list"
    max_works=100000
    
    def get_queryset_all(self):
        facet = self.kwargs['facet']
        if (facet == 'popular'):
            return models.Work.objects.exclude(num_wishes=0).order_by('-num_wishes', 'id')
        elif (facet == 'recommended'):
            self.template_name = "recommended.html"
            return models.Work.objects.filter(wishlists__user=recommended_user).order_by('-num_wishes')
        elif (facet == 'new'):
            return models.Work.objects.exclude(num_wishes=0).order_by('-created', '-num_wishes' ,'id')
        else:
            return models.Work.objects.all().order_by('-created', 'id')
            
    def get_context_data(self, **kwargs):
            context = super(WorkListView, self).get_context_data(**kwargs)
            qs=self.get_queryset()
            context['ungluers'] = userlists.work_list_users(qs,5)
            context['facet'] = self.kwargs.get('facet','')
            works_unglued = qs.exclude(editions__ebooks__isnull=True).distinct() | qs.filter(campaigns__status='SUCCESSFUL').distinct()
            context['works_unglued'] = works_unglued[:self.max_works]
            context['works_active'] = qs.filter(campaigns__status='ACTIVE').distinct()[:self.max_works]
            context['works_wished'] = qs.exclude(editions__ebooks__isnull=False).exclude(campaigns__status='ACTIVE').exclude(campaigns__status='SUCCESSFUL').distinct()[:self.max_works]
                        
            counts={}
            counts['unglued'] = context['works_unglued'].count()
            counts['unglueing'] = context['works_active'].count()
            counts['wished'] = context['works_wished'].count()
            context['counts'] = counts
            
            if counts['unglueing']:
                context['activetab'] = "#2"
            elif counts['unglued']:
                context['activetab'] = "#1"
            else:
                context['activetab'] = "#3"
            
            return context

class ByPubView(WorkListView):
    template_name = "bypub_list.html"
    context_object_name = "work_list"
    max_works = 100000
    publisher_name = None
    publisher = None
    
    def get_publisher_name(self):
        self.publisher_name = get_object_or_404(models.PublisherName, id=self.kwargs['pubname'])
        self.set_publisher()
    
    def set_publisher(self):
        if self.publisher_name.key_publisher.count():
            self.publisher = self.publisher_name.key_publisher.all()[0]
        elif self.publisher_name.publisher:
            self.publisher = self.publisher_name.publisher
            self.publisher_name = self.publisher.name
        
    def get_queryset_all(self):
        facet = self.kwargs.get('facet','')
        self.get_publisher_name()
        objects = models.Work.objects.filter(editions__publisher_name__id=self.publisher_name.id).distinct()
        if (facet == 'popular'):
            return objects.order_by('-num_wishes', 'id')
        elif (facet == 'pubdate'):
            return objects.order_by('-editions__publication_date') # turns out this messes up distinct, and MySQL doesn't support DISTINCT ON
        elif (facet == 'new'):
            return objects.filter(num_wishes__gt=0).order_by('-created', '-num_wishes' ,'id')
        else:
            return objects.order_by('title', 'id')

    def get_context_data(self, **kwargs):
            context = super(ByPubView, self).get_context_data(**kwargs)
            context['pubname'] = self.publisher_name
            context['publisher'] = self.publisher
            return context

class ByPubListView(ByPubView):
    def get_publisher_name(self):
        self.publisher_name = get_object_or_404(models.PublisherName, name=self.kwargs['pubname'])
        self.set_publisher()

class CCListView(FilterableListView):
    template_name = "cc_list.html"
    context_object_name = "work_list"
    licenses = cc.LICENSE_LIST
    facets = cc.FACET_LIST

    def get_queryset_all(self):
        facet = self.kwargs.get('facet','')
        if facet in self.facets:
            ccworks = models.Work.objects.filter(
                                          editions__ebooks__isnull=False,
                                          editions__ebooks__rights=self.licenses[self.facets.index(facet)]
                                         )
            notyet = models.Work.objects.filter(
                                          campaigns__status="ACTIVE",
                                          campaigns__license=self.licenses[self.facets.index(facet)]
                                         )
            return (notyet | ccworks).distinct().order_by('-created')
        else:
            return models.Work.objects.filter( editions__ebooks__isnull=False, 
                                                editions__ebooks__rights__in=self.licenses
                                                ).distinct().order_by('-created')

    def get_context_data(self, **kwargs):
        context = super(CCListView, self).get_context_data(**kwargs)
        facet = self.kwargs.get('facet','')
        qs=self.get_queryset()
        context['ungluers'] = userlists.work_list_users(qs,5)
        context['activetab'] = "#1"
        context['tab_override'] = 'tabs-1'
        context['facet'] = facet
        context['aspect'] = 'cc'
        context['license'] = self.licenses[self.facets.index(facet)] if facet in self.facets else ''
        context['cc'] = cc.ccinfo(context['license'])
        return context

class UngluedListView(FilterableListView):
    template_name = "unglued_list.html"
    context_object_name = "work_list"
    
    def get_queryset_all(self):
        facet = self.kwargs['facet']
        if (facet == 'popular'):
            return models.Work.objects.filter(editions__ebooks__isnull=False).distinct().order_by('-num_wishes')
        elif (facet == 'cc' or facet == 'creativecommons'):
            # assumes all ebooks have a PD or CC license. compare rights_badge property
            return models.Work.objects.filter(
                                              editions__ebooks__isnull=False,
                                              editions__ebooks__rights__in=cc.LICENSE_LIST
                                             ).exclude(campaigns__status="SUCCESSFUL").distinct().order_by('-num_wishes')
        elif (facet == 'pd' or facet == 'publicdomain'):
            return models.Work.objects.filter(
                                              editions__ebooks__isnull=False,
                                              editions__ebooks__rights__in=['PD-US', 'CC0', '']
                                             ).distinct().order_by('-num_wishes')
        else :
            #(facet == '' or facet == 'unglued' or facet is other)
            return models.Work.objects.filter(campaigns__status="SUCCESSFUL").distinct().order_by('-campaigns__deadline')

    def get_context_data(self, **kwargs):
        context = super(UngluedListView, self).get_context_data(**kwargs)
        qs=self.get_queryset()
        context['ungluers'] = userlists.work_list_users(qs,5)
        facet = self.kwargs['facet']
        context['facet'] = facet
        if facet == 'cc' or facet == 'creativecommons':
            context['activetab'] = "#2"
        elif facet == 'pd' or facet == 'publicdomain':
            context['activetab'] = "#3"
        else:
            context['activetab'] = "#1"
        return context

class CampaignListView(FilterableListView):
    template_name = "campaign_list.html"
    context_object_name = "campaign_list"
    model = models.Campaign
    
    def get_queryset_all(self):
        facet = self.kwargs['facet']
        if (facet == 'newest'):
            return models.Campaign.objects.filter(status='ACTIVE').order_by('-activated')
        elif (facet == 'pledged'):
            return models.Campaign.objects.filter(status='ACTIVE').annotate(total_pledge=Sum('transaction__amount')).order_by('-total_pledge')
        elif (facet == 'pledges'):
            return models.Campaign.objects.filter(status='ACTIVE').annotate(pledges=Count('transaction')).order_by('-pledges')
        elif (facet == 'almost'):
            return models.Campaign.objects.filter(status='ACTIVE').all() # STUB: will need to make db changes to make this work 
        elif (facet == 'ending'):
            return models.Campaign.objects.filter(status='ACTIVE').order_by('deadline')
        elif (facet == 'soon'):
            return models.Campaign.objects.filter(status='INITIALIZED').order_by('-work__num_wishes')
        elif (facet == 'b2u'):
            return models.Campaign.objects.filter(status='ACTIVE', type=BUY2UNGLUE).annotate(pledges=Count('transaction')).order_by('-pledges')
        elif (facet == 't4u'):
            return models.Campaign.objects.filter(status='ACTIVE', type=THANKS).annotate(pledges=Count('transaction')).order_by('-pledges')
        elif (facet == 'pledge'):
            return models.Campaign.objects.filter(status='ACTIVE', type=REWARDS).annotate(pledges=Count('transaction')).order_by('-pledges')
        else:
            return models.Campaign.objects.all()

    def get_context_data(self, **kwargs):
            context = super(CampaignListView, self).get_context_data(**kwargs)
            qs=self.get_queryset()
            context['ungluers'] = userlists.campaign_list_users(qs,5)
            facet = self.kwargs['facet']
            context['facet'] =facet
            if facet == 'b2u':
                context['facet_label'] = "Buy to Unglue"
            elif facet == 't4u':
                context['facet_label'] = "Thanks for Ungluing"
            elif facet == 'pledge':
                context['facet_label'] = "Pledge to Unglue"
            else:
                context['facet_label'] = "Active"
            return context

class MergeView(FormView):
    template_name="merge.html"
    work=None
    
    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_staff:
            return render(request, "admins_only.html")
        else:
            return super(MergeView, self).dispatch(request, *args, **kwargs)
            
    def get_context_data(self, **kwargs):
        context = super(MergeView, self).get_context_data(**kwargs)
        context['work']=self.work
        return context

    def get_form_class(self):
        if self.request.method == 'POST' and self.request.POST.has_key('confirm_merge_works'):
            return WorkForm
        else:
            return OtherWorkForm
                    
    def get_form_kwargs(self):
        self.work = safe_get_work(self.kwargs["work_id"])
        form_kwargs= {'work':self.work}
        if self.request.method == 'POST':
            form_kwargs.update({'data':self.request.POST})
        return form_kwargs

    def form_valid(self, form):
        other_work=form.cleaned_data['other_work']
        context=self.get_context_data()
        if self.request.POST.has_key('confirm_merge_works'):
            context['old_work_id']=other_work.id
            merge_works(self.work,other_work,self.request.user)
            context['merge_complete']=True
        else:
            context['form']=WorkForm(initial={'other_work':other_work})
            context['other_work']=other_work
        return render(self.request, self.template_name, context)

class GiftView(TemplateView):
    template_name = "gift.html"
    
    def get(self, request, *args, **kwargs): 
        context = self.get_context_data()
        context['transfer_form']=getTransferCreditForm(self.request.user.credit.available)
        return self.render_to_response(context)
        
    def post(self, request, *args, **kwargs): 
        context = self.get_context_data()
        transfer_form=getTransferCreditForm(self.request.user.credit.available, data=self.request.POST)
        if transfer_form.is_valid():
            if self.request.user.credit.transfer_to(transfer_form.cleaned_data['recipient'], transfer_form.cleaned_data['amount']):
                #successful transfer
                context['transfer_message'] = 'Your transfer has been successfully executed.'
                context['recipient']= transfer_form.cleaned_data['recipient']
                context['transfer_amount'] = transfer_form.cleaned_data['amount']
                context['transfer_form']=getTransferCreditForm(self.request.user.credit.available)
            else:
                #unsuccessful transfer
                context['transfer_message'] = 'Your transfer was not successful.'
                context['transfer_form']=transfer_form
        else:
            #not valid
            context['transfer_form']=transfer_form
        return self.render_to_response(context)
        
    def get_context_data(self, *args, **kwargs):
        context = {'user' : self.request.user,'nonprofit': settings.NONPROFIT}
        context['donate_form'] = DonateForm(initial={'username':self.request.user.username})
        return context
        
class PledgeView(FormView):
    action = "pledge"
    template_name="pledge.html"
    form_class = CampaignPledgeForm
    transaction = None
    campaign = None
    work = None
    premiums = None
    data = {}
    
    def get_preapproval_amount(self):
        preapproval_amount = self.request.REQUEST.get('preapproval_amount', None)
        if preapproval_amount:
            return preapproval_amount
        premium_id = self.request.REQUEST.get('premium_id', None)
        if premium_id != None:
            try:
                preapproval_amount = D(models.Premium.objects.get(id=premium_id).amount)
            except:
                preapproval_amount = None
        if self.transaction:
            if preapproval_amount: 
                preapproval_amount = preapproval_amount if preapproval_amount>self.transaction.amount else self.transaction.amount
            else:
                preapproval_amount = self.transaction.amount
        return preapproval_amount
    
    def get_form_kwargs(self):
        
        assert self.request.user.is_authenticated()
        self.work = safe_get_work(self.kwargs["work_id"])
        
        # if there is no campaign or if campaign is not active, we should raise an error
        try:
            self.campaign = self.work.last_campaign()
             # TODO need to sort the premiums
            self.premiums = self.campaign.custom_premiums() | models.Premium.objects.filter(id=150)
            # Campaign must be ACTIVE
            assert self.campaign.status == 'ACTIVE'           
        except Exception, e:
            # this used to raise an exception, but that seemed pointless. This now has the effect of preventing any pledges.
            return {}

        transactions = self.campaign.transactions().filter(user=self.request.user, status=TRANSACTION_STATUS_ACTIVE, type=PAYMENT_TYPE_AUTHORIZATION)
        premium_id = self.request.REQUEST.get('premium_id', 150)
        if transactions.count() == 0:
            ack_name=self.request.user.profile.ack_name
            ack_dedication=''
            anonymous=self.request.user.profile.anon_pref
        else:
            self.transaction = transactions[0]   
            if premium_id == 150 and self.transaction.premium is not None:
                premium_id = self.transaction.premium.id
            if self.transaction.extra :
                ack_name = self.transaction.extra.get('ack_name', self.request.user.profile.ack_name)
                ack_dedication = self.transaction.extra.get('ack_dedication','')
            else:
                ack_name = self.request.user.profile.ack_name
                ack_dedication = ''
            anonymous=self.transaction.anonymous

        self.data = {'preapproval_amount':self.get_preapproval_amount(), 'premium_id':premium_id, 
                    'ack_name':ack_name, 'ack_dedication':ack_dedication, 'anonymous':anonymous}
        if self.request.method  == 'POST':
            self.data.update(self.request.POST.dict())
            if not self.request.POST.has_key('anonymous'):
                del self.data['anonymous']
            if not self.request.POST.has_key('ack_name'):
                del self.data['ack_name']
            if not self.request.POST.has_key('ack_dedication'):
                del self.data['ack_dedication']
            return {'data':self.data}
        else:
            return {'initial':self.data}
        
    def get_context_data(self, **kwargs):
        """set up the pledge page"""
        
        context = super(PledgeView, self).get_context_data(**kwargs)
        context['nonprofit'] = settings.NONPROFIT
              
        context.update({
                'work':self.work,
                'campaign':self.campaign, 
                'premiums':self.premiums, 
                'premium_id':self.data.get('premium_id',None), 
                'faqmenu': 'modify' if self.transaction else 'pledge', 
                'transaction': self.transaction,
                'tid': self.transaction.id if self.transaction else None,
                'cover_width': cover_width(self.work)
           })
            
        return context
    
    def form_valid(self, form):
        # right now, if there is a non-zero pledge amount, go with that. otherwise, do the pre_approval
        
        p = PaymentManager()
        if self.transaction:
            # modifying the transaction...
            assert self.transaction.type == PAYMENT_TYPE_AUTHORIZATION and self.transaction.status == TRANSACTION_STATUS_ACTIVE        
            status,  url = p.modify_transaction(self.transaction, form.cleaned_data["preapproval_amount"],  
                    paymentReason="Unglue.it %s for %s"% (self.action,self.campaign.name) , 
                    pledge_extra=form.trans_extra
                    )
            logger.info("status: {0}, url:{1}".format(status, url))
            
            if status and url is not None:
                logger.info("PledgeView (Modify): " + url)
                return HttpResponseRedirect(url)
            elif status and url is None:
                return HttpResponseRedirect("{0}?tid={1}".format(reverse('pledge_modified'), self.transaction.id))
            else:
                return HttpResponse("No modification made")
        else:
            t, url = p.process_transaction('USD',  form.amount(),  
                    host = PAYMENT_HOST_NONE, 
                    campaign=self.campaign, 
                    user=self.request.user,
                    paymentReason="Unglue.it Pledge for {0}".format(self.campaign.name), 
                    pledge_extra=form.trans_extra
                    )    
            if url:
                logger.info("PledgeView url: " + url)
                return HttpResponseRedirect(url)
            else:
                logger.error("Attempt to produce transaction id {0} failed".format(t.id))
                return HttpResponse("Our attempt to enable your transaction failed. We have logged this error.")

class PurchaseView(PledgeView): 
    template_name="purchase.html"
    form_class = CampaignPurchaseForm
    action = "purchase"
    offer_id = None

    def get_context_data(self, **kwargs):
        context = super(PledgeView, self).get_context_data(**kwargs)
        context.update({
                'work':self.work,
                'campaign':self.campaign, 
                'faqmenu': 'purchase' , 
                'transaction': self.transaction,
                'tid': self.transaction.id if self.transaction else None,
                'cover_width': cover_width(self.work),
                'offer_id':self.offer_id,
                'user_license': self.work.get_user_license(self.request.user),
           })
            
        return context

    def get_form_kwargs(self):
        assert self.request.user.is_authenticated()
        self.work = safe_get_work(self.kwargs["work_id"])
        
        # if there is no campaign or if campaign is not active, we should raise an error
        try:
            self.campaign = self.work.last_campaign()
            # Campaign must be ACTIVE
            assert self.campaign.status == 'ACTIVE'           
        except Exception, e:
            # this used to raise an exception, but that seemed pointless. This now has the effect of preventing any pledges.
            return {}
        self.data = {
            'preapproval_amount':self.get_preapproval_amount(),
            'anonymous':self.request.user.profile.anon_pref,
            }
        if self.request.method  == 'POST':
            self.data.update(self.request.POST.dict())
            if not self.request.POST.has_key('anonymous'):
                del self.data['anonymous']
            return {'data':self.data}
        else:
            return {'initial':self.data}

    def get_preapproval_amount(self):
        
        self.offer_id = self.request.REQUEST.get('offer_id', None)
        if not self.offer_id and self.work.last_campaign() and self.work.last_campaign().individual_offer:
            self.offer_id = self.work.last_campaign().individual_offer.id
        preapproval_amount = None
        if self.offer_id != None:
            try:
                preapproval_amount = D(models.Offer.objects.get(id=self.offer_id).price)
            except:
                preapproval_amount = None
        return preapproval_amount

    def form_valid(self, form):
        p = PaymentManager()
        t, url = p.process_transaction('USD',  form.amount(),  
                host = PAYMENT_HOST_NONE, 
                campaign=self.campaign, 
                user=self.request.user,
                paymentReason="Unglue.it Purchase for {0}".format(self.campaign.name), 
                pledge_extra=form.trans_extra
                )    
        if url:
            return HttpResponseRedirect(url)
        else:
            logger.error("Attempt to produce transaction id {0} failed".format(t.id))
            return HttpResponse("Our attempt to enable your transaction failed. We have logged this error.")
    
class FundView(FormView):
    template_name="fund_the_pledge.html"
    transaction = None
    action = None
    
    def get_form_class(self):
        if self.request.user.is_anonymous():
            return AnonCCForm
        else:
            return CCForm

    def get_form_kwargs(self):
        kwargs = super(FundView, self).get_form_kwargs()
        
        #assert self.request.user.is_authenticated()
        if self.transaction is None:
            self.transaction = get_object_or_404(Transaction, id=self.kwargs["t_id"])

        if self.transaction.campaign.type == REWARDS:
            self.action = 'pledge'
        elif self.transaction.campaign.type == THANKS:
            self.action = 'contribution'
        else:
            self.action = 'purchase'

        if kwargs.has_key('data'):
            data = kwargs['data'].copy()
        else:
            data = {}
        
        data.update(
            {'preapproval_amount':self.transaction.needed_amount,
                'username':self.request.user.username if self.request.user.is_authenticated else None,
                'work_id':self.transaction.campaign.work.id,
                'title':self.transaction.campaign.work.title}
            )
        
        kwargs['data'] = data
        
        return kwargs

    def get_context_data(self, **kwargs):
        context = super(FundView, self).get_context_data(**kwargs)
        context['modified'] = self.transaction.status==TRANSACTION_STATUS_MODIFIED
        context['preapproval_amount']=self.transaction.max_amount
        context['needed'] = self.transaction.needed_amount
        context['transaction']=self.transaction
        context['nonprofit'] = settings.NONPROFIT
        context['STRIPE_PK'] = stripelib.STRIPE_PK
        context['action'] = self.action
        if settings.NONPROFIT.is_on:
            # note that get_form_kwargs() will already have been called once
            donate_args=self.get_form_kwargs()
            donate_args['data']['preapproval_amount']=self.transaction.needed_amount
            context['donate_form'] = DonateForm(**donate_args)
        return context
        
    def form_valid(self, form):
        p = PaymentManager()
        stripe_token = form.cleaned_data["stripe_token"]
        self.transaction.host = settings.PAYMENT_PROCESSOR
        return_url = "%s?tid=%s" % (reverse('pledge_complete'),self.transaction.id)

        if self.transaction.campaign.type == THANKS and self.transaction.user == None:
            #anonymous user, just charge the card!
            if self.request.user.is_authenticated():
                self.transaction.user = self.request.user
            # if there's an email address, put it in the receipt column, so far unused.
            self.transaction.receipt = form.cleaned_data.get("email",None)
            t, url = p.charge(self.transaction, return_url = return_url, token=stripe_token )
        elif self.request.user.is_anonymous():
            #somehow the user lost their login
            return HttpResponseRedirect(reverse('superlogin'))
        elif self.transaction.user.id != self.request.user.id:
            # other sort of strange trouble!
            return render(self.request, "pledge_user_error.html", {'transaction': self.transaction, 'action': self.action }) 
        else:
            # if the user has  active account, use it. Otherwise...
            if not self.request.user.profile.account:
            
                # if we get a stripe_token, create a new stripe account for the user
                if stripe_token:
                    try:
                        p.make_account(user=self.request.user, host=settings.PAYMENT_PROCESSOR, token=stripe_token)
                    except baseprocessor.ProcessorError as e:
                        return render(self.request, "pledge_card_error.html", {'transaction': self.transaction, 'exception':e })
                else: # empty token
                    e = baseprocessor.ProcessorError("Empty token")
                    return render(self.request, "pledge_card_error.html", {'transaction': self.transaction, 'exception':e })
            # with the Account in hand, now do the transaction
            if self.action == 'pledge':
                t, url = p.authorize(self.transaction, return_url =  return_url )
            else:
                t, url = p.charge(self.transaction, return_url = return_url )
        
        # redirecting user to pledge_complete/payment_complete on successful preapproval (in the case of stripe)
        if url is not None:
            return HttpResponseRedirect(url)
        else:
            return render(self.request, "pledge_card_error.html", {'transaction': self.transaction }) 
        
class NonprofitCampaign(FormView):
    template_name="nonprofit.html"
    form_class = CCForm
    
    def get_context_data(self, **kwargs):
        context = super(NonprofitCampaign, self).get_context_data(**kwargs)
        context['nonprofit'] = settings.NONPROFIT
        context['get'] = self.request.GET
        return context

    def get_form_kwargs(self):
        if self.request.method == 'POST':
            return {'data':self.request.POST}
        else:
            return {'initial':self.request.GET }

        

    def form_valid(self, form):
        username=form.cleaned_data['username']
        forward={'username':username}
        forward['work_id']= form.cleaned_data['work_id']
        amount=form.cleaned_data['preapproval_amount']
        forward['cents']=int(100*(amount-int(amount)))
        forward['amount']= int(amount)
        forward['sent']= Sent.objects.create(user=username,amount=form.cleaned_data['preapproval_amount']).pk
        token=signing.dumps(forward)
        return HttpResponseRedirect(settings.BASE_URL_SECURE + reverse('gift_credit',kwargs={'token':token}))

class GiftCredit(TemplateView):
    template_name="gift_credit.html"

    def get_context_data(self, **kwargs):
        context = super(GiftCredit, self).get_context_data(**kwargs)
        context['faqmenu']="gift"
        context['nonprofit'] = settings.NONPROFIT
        try:
            envelope=signing.loads(kwargs['token'])
            context['envelope']=envelope
        except signing.BadSignature:
            self.template_name="gift_error.html"
            return context
        try:
            work = models.Work.objects.get(id=envelope['work_id'])
            campaign=work.last_campaign()
        except models.Work.DoesNotExist:
            campaign = None
        context['work']=work
        try:
            user = User.objects.get(username=envelope['username'])
        except User.DoesNotExist:
            self.template_name="gift_user_error.html"
            context['error']='user does not exist'
            return context
        if user != self.request.user:
            self.template_name="gift_user_error.html"
            context['error']='wrong user logged in'
            return context
        try:
            # check token not used
            CreditLog.objects.get(sent=envelope['sent'])
            context['error']='credit already registered'
            return context
        except CreditLog.DoesNotExist:
            #not used yet!
            amount=envelope['amount']+envelope['cents']/D(100)
            CreditLog.objects.create(user=user,amount=amount,action='deposit',sent=envelope['sent'])
            ts=Transaction.objects.filter(user=user,campaign=campaign,status=TRANSACTION_STATUS_NONE).order_by('-pk')
            if ts.count()==0:
                ts=Transaction.objects.filter(user=user,campaign=campaign,status=TRANSACTION_STATUS_MODIFIED).order_by('-pk')
            if ts.count()>0:
                t=ts[0]
                credit_transaction(t,user, amount)
                for t in ts[1:]:
                    t.status=TRANSACTION_STATUS_CANCELED
                    t.save()
                context['transaction']=t
                return context
            else:
                user.credit.add_to_balance(amount)
                return context
                
            
class PledgeRechargeView(TemplateView):
    """
    a view to allow for recharge of a transaction for failed transactions or ones with errors
    """
    template_name="pledge_recharge.html"

    def get_context_data(self, **kwargs):
        
        context = super(PledgeRechargeView, self).get_context_data(**kwargs)
        
        # the following should be true since PledgeView.as_view is wrapped in login_required
        assert self.request.user.is_authenticated()
        user = self.request.user
        
        work = safe_get_work(self.kwargs["work_id"])
        campaign = work.last_campaign()
        
        if campaign is None:
            return Http404
        
        transaction = campaign.transaction_to_recharge(user)
        
        # calculate a URL to do a preapproval -- in the future, we may want to do a straight up payment
            
        return_url = None
        nevermind_url = None
        
        if transaction is not None:
            # the recipients of this authorization is not specified here but rather by the PaymentManager.    
            paymentReason = "Unglue.it Recharge for {0}".format(campaign.name)
            
            p = PaymentManager()
            t, url = p.authorize(transaction, return_url=return_url, paymentReason=paymentReason)
            logger.info("Recharge url: {0}".format(url))
        else:
            url = None
        
        context.update({
                'work':work,
                'transaction':transaction,
                'payment_processor':transaction.host if transaction is not None else None,
                'recharge_url': url
                })
        return context
    

class FundCompleteView(TemplateView):
    """A callback for Payment to tell unglue.it that a payment transaction has completed successfully.
    
    Possible things to implement:
    
        after pledging, supporter receives email including thanks, work pledged, amount, expiry date, any next steps they should expect; others?
    study other confirmation emails for their contents
    should note that a confirmation email has been sent to $email from $sender
    should briefly note next steps (e.g. if this campaign succeeds you will be emailed on date X)    
        
    """
    
    template_name="pledge_complete.html"
    
    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        if context['campaign'].type == THANKS:
            return DownloadView.as_view()(request, work=context['work'])
        else:
            if request.user.is_authenticated:
                return self.render_to_response(context)
            else:
                return redirect_to_login(request.get_full_path())
        
            

    def get_context_data(self):
        # pick up all get and post parameters and display
        context = super(FundCompleteView, self).get_context_data()

        # pull out the transaction id and try to get the corresponding Transaction
        transaction_id = self.request.REQUEST.get("tid")
        transaction = Transaction.objects.get(id=transaction_id)
        
        # work and campaign in question
        try:
            campaign = transaction.campaign
            work = campaign.work
        except Exception, e:
            campaign = None
            work = None
        
        # we need to check whether the user tied to the transaction is indeed the authenticated user.
        if transaction.campaign.type == THANKS and transaction.user == None:
            pass
        elif self.request.user.id != transaction.user.id:
            # should be 403 -- but let's try 404 for now -- 403 exception coming in Django 1.4
            raise Http404
            
        
        # add the work corresponding to the Transaction on the user's wishlist if it's not already on the wishlist
        if transaction.user is not None and (campaign is not None) and (work is not None):
            transaction.user.wishlist.add_work(work, 'pledging', notify=True)

        #put info into session for download page to pick up.
        self.request.session['amount']= transaction.amount
        if transaction.receipt:
            self.request.session['receipt']= transaction.receipt
                
            
        context["transaction"] = transaction
        context["work"] = work
        context["campaign"] = campaign
        context["faqmenu"] = "complete"
        context["slidelist"] = slideshow()
        context["site"] = Site.objects.get_current()
        
        return context        

class PledgeModifiedView(FundCompleteView):
    def get_context_data(self):
        context = super(PledgeModifiedView, self).get_context_data()
        context['modified']=True
        return context
    
class PledgeCancelView(FormView):
    """A view for allowing a user to cancel the active transaction for specified campaign"""
    template_name="pledge_cancel.html"
    form_class = PledgeCancelForm
    
    def get_context_data(self, **kwargs):
        context = super(PledgeCancelView, self).get_context_data(**kwargs)
        
        # initialize error to be None
        context["error"] = None
        
        # the following should be true since PledgeCancelView.as_view is wrapped in login_required
        
        if self.request.user.is_authenticated():
            user = self.request.user
        else:
            context["error"] = "You are not logged in."
            return context
        
        campaign = get_object_or_404(models.Campaign, id=self.kwargs["campaign_id"])
        if campaign.status != 'ACTIVE':
            context["error"] = "{0} is not an active campaign".format(campaign)
            return context
        
        work = campaign.work
        transactions = campaign.transactions().filter(user=user, status=TRANSACTION_STATUS_ACTIVE)
        
        if transactions.count() < 1:
            context["error"] = "You don't have an active transaction for this campaign."
            return context
        elif transactions.count() > 1:
            logger.error("User {0} has {1} active transactions for campaign id {2}".format(user, transactions.count(), campaign.id))
            context["error"] = "You have {0} active transactions for this campaign".format(transactions.count())
            return context

        transaction = transactions[0]
        if transaction.type != PAYMENT_TYPE_AUTHORIZATION:
            logger.error("Transaction id {0} transaction type, which should be {1}, is actually {2}".format(transaction.id, PAYMENT_TYPE_AUTHORIZATION, transaction.type))
            context["error"] = "Your transaction type, which should be {0}, is actually {1}".format(PAYMENT_TYPE_AUTHORIZATION, transaction.type)
            return context
        
        # we've located the transaction, work, and campaign referenced in the view
        
        context["transaction"] = transaction
        context["work"] = work
        context["campaign"] = campaign
        context["faqmenu"] = "cancel"
        
        return context
    
    def form_valid(self, form):
        # check that user does, in fact, have an active transaction for specified campaign
    
        logger.info("arrived at pledge_cancel form_valid")
        # pull campaign_id from form, not from URI as we do from GET
        campaign_id = self.request.REQUEST.get('campaign_id')
        
        # this following logic should be extraneous.
        if self.request.user.is_authenticated():
            user = self.request.user
        else:
            return HttpResponse("You need to be logged in.")
        
        try:
            # look up the specified campaign and attempt to pull up the appropriate transaction
            # i.e., the transaction actually belongs to user, that the transaction is active
            campaign = get_object_or_404(models.Campaign, id=self.kwargs["campaign_id"], status='ACTIVE')
            transaction = campaign.transaction_set.get(user=user, status=TRANSACTION_STATUS_ACTIVE,
                                                          type=PAYMENT_TYPE_AUTHORIZATION)
            # attempt to cancel the transaction and redirect to the Work page if cancel is successful
            # here's a place that would be nice to use https://docs.djangoproject.com/en/dev/ref/contrib/messages/
            # to display the success or failure of the cancel operation as a popup in the context of the work page
            p = PaymentManager()
            result = p.cancel_transaction(transaction)
            # put a notification here for pledge cancellation?
            if result:
                # Now if we redirect the user to the Work page and the IPN hasn't arrived, the status of the
                # transaction might be out of date.  Let's try an explicit polling of the transaction result before redirecting
                # We might want to remove this in a production system
                if settings.DEBUG:
                    update_status = p.update_preapproval(transaction)
                # send a notice out that the transaction has been canceled -- leverage the pledge_modify notice for now
                # BUGBUG:  should have a pledge cancel notice actually since I think it's different
                from regluit.payment.signals import pledge_modified
                pledge_modified.send(sender=self, transaction=transaction, up_or_down="canceled")
                logger.info("pledge_modified notice for cancellation: sender {0}, transaction {1}".format(self, transaction))
                return HttpResponseRedirect(reverse('work', kwargs={'work_id': campaign.work.id}))
            else:
                logger.error("Attempt to cancel transaction id {0} failed".format(transaction.id))
                return HttpResponse("Our attempt to cancel your transaction failed. We have logged this error.")
        except Exception, e:
            logger.error("Exception from attempt to cancel pledge for campaign id {0} for username {1}: {2}".format(campaign_id, user.username, e))
            return HttpResponse("Sorry, something went wrong in canceling your campaign pledge. We have logged this error.")    
    
def claim(request):
    if  request.method == 'GET': 
        data = request.GET
    else:
        data =  request.POST
    form =  UserClaimForm(request.user, data=data, prefix='claim')
    if form.is_valid():
        # make sure we're not creating a duplicate claim
        if not models.Claim.objects.filter(work=form.cleaned_data['work'], rights_holder=form.cleaned_data['rights_holder']).exclude(status='release').count():
            form.save()
        return HttpResponseRedirect(reverse('work', kwargs={'work_id': form.cleaned_data['work'].id}))
    else:
        try:
            work = models.Work.objects.get(id=data['claim-work'])
        except models.Work.DoesNotExist:
            try:
                work = models.WasWork.objects.get(was = data['claim-work']).work
            except models.WasWork.DoesNotExist:
                raise Http404
        rights_holder = models.RightsHolder.objects.get(id=data['claim-rights_holder'])
        active_claims = work.claim.exclude(status = 'release')
        context = {'form': form, 'work': work, 'rights_holder':rights_holder , 'active_claims':active_claims}
        return render(request, "claim.html", context)
            

def rh_tools(request):
    if not request.user.is_authenticated() :
        return render(request, "rh_tools.html")
    claims = request.user.claim.filter(user=request.user)
    campaign_form = "xxx"
    if not claims:
        return render(request, "rh_tools.html")
    for claim in claims:
        if claim.can_open_new:
            if request.method == 'POST' and  request.POST.has_key('cl_%s-work' % claim.id) and int(request.POST['cl_%s-work' % claim.id]) == claim.work.id :
                claim.campaign_form = OpenCampaignForm(data = request.POST, prefix = 'cl_'+str(claim.id),)
                if claim.campaign_form.is_valid():                    
                    new_campaign = claim.campaign_form.save(commit=False)
                    if new_campaign.type==BUY2UNGLUE:
                        new_campaign.target = D(settings.UNGLUEIT_MAXIMUM_TARGET)
                        new_campaign.set_cc_date_initial()
                    elif new_campaign.type==REWARDS:
                        new_campaign.deadline = date_today() + timedelta(days=int(settings.UNGLUEIT_LONGEST_DEADLINE))
                        new_campaign.target = D(settings.UNGLUEIT_MINIMUM_TARGET)
                    elif new_campaign.type==THANKS:
                        new_campaign.target = D(settings.UNGLUEIT_MINIMUM_TARGET)
                    new_campaign.save()
                    claim.campaign_form.save_m2m()
                    claim.campaign_form = None
            else:
                c_type = 2 if claim.rights_holder.can_sell else 1
                claim.campaign_form = OpenCampaignForm(
                    initial={'work': claim.work, 'name': claim.work.title,  'userid': request.user.id, 'managers': [request.user.id], 'type': c_type},
                    prefix = 'cl_'+str(claim.id),
                    )
        if claim.campaign:
            if claim.campaign.status in ['ACTIVE','INITIALIZED']:
                if request.method == 'POST' and request.POST.has_key('edit_managers_%s'% claim.campaign.id) :
                    claim.campaign.edit_managers_form=EditManagersForm( instance=claim.campaign, data=request.POST, prefix=claim.campaign.id)
                    if claim.campaign.edit_managers_form.is_valid():
                        claim.campaign.edit_managers_form.save()
                        claim.campaign.edit_managers_form = EditManagersForm(instance=claim.campaign, prefix=claim.campaign.id)
                else:
                    claim.campaign.edit_managers_form=EditManagersForm(instance=claim.campaign, prefix=claim.campaign.id)
    campaigns = request.user.campaigns.all()
    new_campaign = None
    for campaign in campaigns:
        if campaign.clonable():
            if request.method == 'POST' and  request.POST.has_key('c%s-campaign_id'% campaign.id):
                clone_form= CloneCampaignForm(data=request.POST, prefix = 'c%s' % campaign.id)
                if clone_form.is_valid():
                    campaign.clone()
            else:
                campaign.clone_form= CloneCampaignForm(initial={'campaign_id':campaign.id}, prefix = 'c%s' % campaign.id)
    return render(request, "rh_tools.html", {'claims': claims ,'campaigns': campaigns}) 

def rh_admin(request, facet='top'):
    if not request.user.is_authenticated() :
        return render(request, "admins_only.html")
    if not request.user.is_staff :
        return render(request, "admins_only.html")
    PendingFormSet = modelformset_factory(models.Claim, fields=['status'], extra=0)
    pending_data = models.Claim.objects.filter(status = 'pending')
    active_data = models.Claim.objects.filter(status = 'active')
    if  request.method == 'POST': 
        if 'create_rights_holder' in request.POST.keys():
            form = RightsHolderForm(data=request.POST)
            pending_formset = PendingFormSet (queryset=pending_data)
            if form.is_valid():
                form.save()
                form = RightsHolderForm()
        if 'set_claim_status' in request.POST.keys():
            pending_formset = PendingFormSet (request.POST, request.FILES, queryset=pending_data)
            form = RightsHolderForm()
            if pending_formset.is_valid():
                pending_formset.save()
                pending_formset = PendingFormSet(queryset=pending_data)
    else:
        form = RightsHolderForm()
        pending_formset = PendingFormSet(queryset=pending_data)
    rights_holders = models.RightsHolder.objects.all()
    
    context = { 
        'request': request, 
        'rights_holders': rights_holders, 
        'form': form,
        'pending': zip(pending_data,pending_formset),
        'pending_formset': pending_formset,
        'active_data': active_data,
        'facet': facet,
    }
    return render(request, "rights_holders.html", context)

def campaign_admin(request):
    if not request.user.is_authenticated() :
        return render(request, "admins_only.html")    
    if not request.user.is_staff :
        return render(request, "admins_only.html")
        
    context = {}
    
    def campaigns_types():
        # pull out Campaigns with Transactions that are ACTIVE -- and hence can be executed
        # Campaign.objects.filter(transaction__status='ACTIVE')
        
        campaigns_with_active_transactions = models.Campaign.objects.filter(transaction__status=TRANSACTION_STATUS_ACTIVE)
            
        # pull out Campaigns with Transactions that are INCOMPLETE
    
        campaigns_with_incomplete_transactions = models.Campaign.objects.filter(transaction__status=TRANSACTION_STATUS_INCOMPLETE)
        
        # show all Campaigns with Transactions that are COMPLETED
    
        campaigns_with_completed_transactions = models.Campaign.objects.filter(transaction__status=TRANSACTION_STATUS_COMPLETE)
        
        # show Campaigns with Transactions that are CANCELED
        
        campaigns_with_canceled_transactions = models.Campaign.objects.filter(transaction__status=TRANSACTION_STATUS_CANCELED)
        
        return (campaigns_with_active_transactions, campaigns_with_incomplete_transactions, campaigns_with_completed_transactions, campaigns_with_canceled_transactions)
        
    form = CampaignAdminForm()
    pm = PaymentManager()
    check_status_results = None
    command_status = None
    
    if request.method == 'GET':
        pass
    elif request.method == 'POST':
        if 'campaign_checkstatus' in request.POST.keys():
            # campaign_checkstatus
            try:
                status = pm.checkStatus()
                check_status_results = ""
                # parse the output to display chat transaction statuses have been updated
                if len(status["preapprovals"]):
                    for t in status["preapprovals"]:
                        check_status_results += "<p>Preapproval key: %s updated</p>" % (t["key"])
                else:
                    check_status_results += "<p>No preapprovals needed updating</p>"
                if len(status["payments"]):
                    for t in status["payments"]:
                        info = ", ".join(["%s:%s" % (k,v) for (k,v) in t.items()])
                        check_status_results += "<p>Payment updated: %s </p>" % (info)
                        
                else:
                    check_status_results += "<p>No payments needed updating</p>"                    
                command_status = _("Transactions updated based on PaymentDetails and PreapprovalDetails")
            except Exception, e:
                check_status_results = e
        elif 'execute_campaigns' in request.POST.keys():            
            c_id = request.POST.get('active_campaign', None)
            if c_id is not None:
                try:
                    campaign = models.Campaign.objects.get(id=c_id)
                    results = pm.execute_campaign(campaign)
                    command_status = str(results)
                except Exception, e:
                    command_status = "Error in executing transactions for campaign %s " % (str(e))
        elif 'finish_campaigns' in request.POST.keys():
            c_id = request.POST.get('incomplete_campaign', None)
            if c_id is not None:
                try:
                    campaign = models.Campaign.objects.get(id=c_id)
                    results = pm.finish_campaign(campaign)
                    command_status = str(results)
                except Exception, e:
                    command_status = "Error in finishing transactions for campaign %s " % (str(e))            
            
        elif 'cancel_campaigns' in request.POST.keys():
            c_id = request.POST.get('active_campaign', None)
            if c_id is not None:
                try:
                    campaign = models.Campaign.objects.get(id=c_id)
                    results = pm.cancel_campaign(campaign)
                    command_status = str(results)
                except Exception, e:
                    command_status = "Error in canceling transactions for campaign %s " % (str(e))        
            
    (campaigns_with_active_transactions, campaigns_with_incomplete_transactions, campaigns_with_completed_transactions,
                campaigns_with_canceled_transactions) = campaigns_types()
    
    context.update({
        'form': form,
        'check_status_results':check_status_results,
        'campaigns_with_active_transactions': campaigns_with_active_transactions,
        'campaigns_with_incomplete_transactions': campaigns_with_incomplete_transactions,
        'campaigns_with_completed_transactions': campaigns_with_completed_transactions,
        'campaigns_with_canceled_transactions': campaigns_with_canceled_transactions,
        'command_status': command_status
    })

    return render(request, "campaign_admin.html", context)

def supporter(request, supporter_username, template_name, extra_context={}):
    supporter = get_object_or_404(User, username=supporter_username)
    wishlist = supporter.wishlist
    works_unglued = []
    works_active = []
    works_wished = []
    works_on_wishlist = wishlist.works.all()
    
    if (works_on_wishlist):
        # querysets for tabs
        # unglued tab is anything with an existing ebook or successful campaign
        ## .order_by() may clash with .distinct() and this should be fixed
        unglueit_works = works_on_wishlist.filter(campaigns__status="SUCCESSFUL").distinct()
        works_otherwise_available = works_on_wishlist.filter(editions__ebooks__isnull=False).distinct()
        works_unglued = unglueit_works | works_otherwise_available
        works_unglued = works_unglued.order_by('-campaigns__status', 'campaigns__deadline', '-num_wishes')

        works_active = works_on_wishlist.filter(campaigns__status='ACTIVE').order_by('campaigns__deadline').distinct()
        
        # everything else goes in tab 3
        works_wished = works_on_wishlist.exclude(pk__in=works_active.values_list('pk', flat=True)).exclude(pk__in=works_unglued.values_list('pk', flat=True)).order_by('-num_wishes')
        
        slidelist = []
        # badge counts
        backed = works_unglued.count()
        backing = works_active.count()
        wished = works_wished.count()
    
    else:           
        backed = 0
        backing = 0
        wished = 0
        slidelist = slideshow()
    # default to showing the Active tab if there are active campaigns, else show Wishlist
    if backing > 0:
        activetab = "#2"
    elif wished == 0:
        activetab = "#1"
    else:
        activetab = "#3"
    
    # following block to support profile admin form in supporter page
    if request.user.is_authenticated() and request.user.username == supporter_username:

        try:
            profile_obj=request.user.get_profile()
        except ObjectDoesNotExist:
            profile_obj= models.UserProfile()
            profile_obj.user=request.user

        if  request.method == 'POST': 
            profile_form = ProfileForm(data=request.POST,instance=profile_obj)
            if profile_form.is_valid():
                if profile_form.cleaned_data['clear_facebook'] or profile_form.cleaned_data['clear_twitter'] or  profile_form.cleaned_data['clear_goodreads'] :
                    if profile_form.cleaned_data['clear_facebook']:
                        profile_obj.facebook_id=0
                        if profile_obj.avatar_source == models.FACEBOOK:
                            profile_obj.avatar_source = models.GRAVATAR
                    if profile_form.cleaned_data['clear_twitter']:
                        profile_obj.twitter_id=""
                        if profile_obj.avatar_source == models.TWITTER:
                            profile_obj.avatar_source = models.GRAVATAR
                    if profile_form.cleaned_data['clear_goodreads']:
                        profile_obj.goodreads_user_id = None
                        profile_obj.goodreads_user_name = None
                        profile_obj.goodreads_user_link = None
                        profile_obj.goodreads_auth_token = None
                        profile_obj.goodreads_auth_secret = None

                    profile_obj.save()
                profile_form.save()

        else:
            profile_form= ProfileForm(instance=profile_obj)
        
    else:
        profile_form = ''

    process_kindle_email(request)
    context = {
            "supporter": supporter,
            "wishlist": wishlist,
            "works_unglued": works_unglued,
            "works_active": works_active,
            "works_wished": works_wished,
            "slidelist": slidelist,
            "backed": backed,
            "backing": backing,
            "wished": wished,
            "profile_form": profile_form,
            "ungluers": userlists.other_users(supporter, 5 ),
            "activetab": activetab,
    }
    context.update(extra_context)
    return render(request, template_name, context)

def library(request,library_name):
    context={}
    try:
        # determine if the supporter is a library
        authenticator = Authenticator(request,library_name)
        context['authenticator'] = authenticator
        context['library'] = library = authenticator.library
    except Library.DoesNotExist:
        raise Http404
    works_active= models.Work.objects.filter(acqs__user=library.user,acqs__license=LIBRARY).distinct()
    if works_active.count()>0:
        context['works_active'] = works_active
        context['activetab'] = "#2"
    context['ungluers'] = userlists.library_users(library, 5 )
    return supporter(request,library_name,template_name='libraryauth/library.html', extra_context=context)
                
    

def edit_user(request):
    if not request.user.is_authenticated():
        return HttpResponseRedirect(reverse('superlogin'))    
    form=UserData()
    if request.method == 'POST': 
        if 'change_username' in request.POST.keys():
            form = UserData(request.POST)
            form.oldusername = request.user.username
            if form.is_valid(): # All validation rules pass, go and change the username
                request.user.username=form.cleaned_data['username']
                request.user.save()
                return HttpResponseRedirect(reverse('home')) # Redirect after POST
    return render(request,'registration/user_change_form.html', {'form': form})  

class ManageAccount(FormView):
    template_name="manage_account.html"
    form_class = PlainCCForm

    def get_context_data(self, **kwargs):
        context = super(ManageAccount, self).get_context_data(**kwargs)
        context['STRIPE_PK'] = stripelib.STRIPE_PK
        return context
    
    def form_valid(self, form):
        """ save the token, make an account"""

        p = PaymentManager()
        stripe_token = form.cleaned_data["stripe_token"]
        # if we get a stripe_token, create a new stripe account for the user
        if stripe_token:
            try:
                p.make_account(user=self.request.user, host=settings.PAYMENT_PROCESSOR, token=stripe_token)
            except baseprocessor.ProcessorError as e:
                return render(self.request, "pledge_card_error.html", {'exception':e})
        next = self.request.REQUEST.get('next', None)
        if next :
            return HttpResponseRedirect(next)
        else:
            return render(self.request, self.template_name, self.get_context_data())

def search(request):
    q = request.GET.get('q', '')
    request.session['q']=q
    page = int(request.GET.get('page', 1))
    results = gluejar_search(q, user_ip=request.META['REMOTE_ADDR'], page=page)
    
    if q != '' and page==1:
        work_query = Q(title__icontains=q) | Q(editions__authors__name__icontains=q) | Q(subjects__name__iexact=q)
        campaign_works = models.Work.objects.exclude(campaigns = None).filter(work_query).distinct()
    else:
        campaign_works = None

    # flag search result as on wishlist as appropriate
    if not request.user.is_anonymous():
        ungluers = userlists.other_users(request.user, 5)
    else:
        ungluers = userlists.other_users(None, 5)

    works=[]
    for result in results:
        try:
            work = models.Identifier.objects.get(type='goog',value=result['googlebooks_id']).work
            works.append(work)
        except models.Identifier.DoesNotExist: 
            works.append(result)
    context = {
        "q": q,
        "results": works,
        "ungluers": ungluers,
        "campaign_works": campaign_works
    }
    return render(request, 'search.html', context)

# TODO: perhaps this functionality belongs in the API?
@require_POST
@login_required
@csrf_exempt
def wishlist(request):
    googlebooks_id = request.POST.get('googlebooks_id', None)
    remove_work_id = request.POST.get('remove_work_id', None)
    add_work_id = request.POST.get('add_work_id', None)

    if googlebooks_id:
        try:
            edition = bookloader.add_by_googlebooks_id(googlebooks_id)
            if edition.new:
                # add related editions asynchronously
                tasks.populate_edition.delay(edition.isbn_13)
            request.user.wishlist.add_work(edition.work,'user', notify=True)
            return HttpResponse('added googlebooks id')
        except bookloader.LookupFailure:
            logger.warning("failed to load googlebooks_id %s" % googlebooks_id)
            return HttpResponse('error adding googlebooks id')
        except Exception, e:
            logger.warning("Error in wishlist adding %s" % (e))          
            return HttpResponse('error adding googlebooks id')
        # TODO: redirect to work page, when it exists
    elif remove_work_id:
        work = safe_get_work(int(remove_work_id))
        request.user.wishlist.remove_work(work)
        return HttpResponse('removed work from wishlist')
    elif add_work_id:
        # if adding from work page, we have may work.id, not googlebooks_id
        work =safe_get_work(add_work_id)
        request.user.wishlist.add_work(work,'user', notify=True)
        return HttpResponse('added work to wishlist')
  
class InfoPageView(TemplateView):
    
    def get_template_names(self, **kwargs):
        if self.kwargs['template_name']:
            return (self.kwargs['template_name'])
        else:
            return ('metrics.html')
            
    def get_context_data(self, **kwargs):
        users = User.objects
        users.today = users.filter(date_joined__range = (date_today(), now()))
        users.days7 = users.filter(date_joined__range = (date_today()-timedelta(days=7), now()))
        users.year = users.filter(date_joined__year = date_today().year)
        users.month = users.year.filter(date_joined__month = date_today().month)
        users.yesterday = users.filter(date_joined__range = (date_today()-timedelta(days=1), date_today()))
        users.gr = users.filter(profile__goodreads_user_id__isnull = False)
        users.lt = users.exclude(profile__librarything_id = '')
        users.fb = users.filter(profile__facebook_id__isnull = False)
        users.tw = users.exclude(profile__twitter_id = '')
        works = models.Work.objects
        works.today = works.filter(created__range = (date_today(), now()))
        works.days7 = works.filter(created__range = (date_today()-timedelta(days=7), now()))
        works.year = works.filter(created__year = date_today().year)
        works.month = works.year.filter(created__month = date_today().month)
        works.yesterday = works.filter(created__range = (date_today()-timedelta(days=1), date_today()))
        works.wishedby2 = works.filter(num_wishes__gte = 2)
        works.wishedby20 = works.filter(num_wishes__gte = 20)
        works.wishedby5 = works.filter(num_wishes__gte = 5)
        works.wishedby50 = works.filter(num_wishes__gte = 50)
        works.wishedby10 = works.filter(num_wishes__gte = 10)
        works.wishedby100 = works.filter(num_wishes__gte = 100)
        ebooks = models.Ebook.objects
        ebooks.today = ebooks.filter(created__range = (date_today(), now()))
        ebooks.days7 = ebooks.filter(created__range = (date_today()-timedelta(days=7), now()))
        ebooks.year = ebooks.filter(created__year = date_today().year)
        ebooks.month = ebooks.year.filter(created__month = date_today().month)
        ebooks.yesterday = ebooks.filter(created__range = (date_today()-timedelta(days=1), date_today()))
        ebookfiles = models.EbookFile.objects
        ebookfiles.today = ebookfiles.filter(created__range = (date_today(), now()))
        ebookfiles.days7 = ebookfiles.filter(created__range = (date_today()-timedelta(days=7), now()))
        ebookfiles.year = ebookfiles.filter(created__year = date_today().year)
        ebookfiles.month = ebookfiles.year.filter(created__month = date_today().month)
        ebookfiles.yesterday = ebookfiles.filter(created__range = (date_today()-timedelta(days=1), date_today()))
        wishlists= models.Wishlist.objects.exclude(wishes__isnull=True)
        wishlists.today = wishlists.filter(created__range = (date_today(), now()))
        wishlists.days7 = wishlists.filter(created__range = (date_today()-timedelta(days=7), now()))
        wishlists.year = wishlists.filter(created__year = date_today().year)
        wishlists.month = wishlists.year.filter(created__month = date_today().month)
        if date_today().day==1:
            wishlists.yesterday = wishlists.filter(created__range = (date_today()-timedelta(days=1), date_today()))
        else:
            wishlists.yesterday = wishlists.month.filter(created__day = date_today().day-1)
            
        transactions = Transaction.objects.filter(status__in = [TRANSACTION_STATUS_ACTIVE, TRANSACTION_STATUS_COMPLETE])
        transactions.sum = transactions.aggregate(Sum('amount'))['amount__sum']
        transactions.today = transactions.filter(date_created__range = (date_today(), now()))
        transactions.today.sum = transactions.today.aggregate(Sum('amount'))['amount__sum']
        transactions.days7 = transactions.filter(date_created__range = (date_today()-timedelta(days=7), now()))
        transactions.days7.sum = transactions.days7.aggregate(Sum('amount'))['amount__sum']
        transactions.year = transactions.filter(date_created__year = date_today().year)
        transactions.year.sum = transactions.year.aggregate(Sum('amount'))['amount__sum']
        transactions.month = transactions.filter(date_created__month = date_today().month)
        transactions.month.sum = transactions.month.aggregate(Sum('amount'))['amount__sum']
        transactions.yesterday = transactions.filter(date_created__range = (date_today()-timedelta(days=1), date_today()))
        transactions.yesterday.sum = transactions.yesterday.aggregate(Sum('amount'))['amount__sum']
        
        return {
            'users': users, 
            'works': works,
            'ebooks': ebooks,
            'ebookfiles': ebookfiles,
            'wishlists': wishlists,
            'transactions': transactions,
        }

class InfoLangView(TemplateView):
    
    def get_template_names(self, **kwargs):
        if self.kwargs['template_name']:
            return (self.kwargs['template_name'])
        else:
            return ('languages.html')
            
    def get_context_data(self, **kwargs):
        languages=models.Work.objects.filter(num_wishes__gte = 1).values('language').annotate(lang_count=Count('language')).order_by('-lang_count')
        return {
            'wished_languages': languages, 
        }
    
class FAQView(FormView):
    template_name = "faq.html"
    form_class = DateCalculatorForm

    def form_valid(self, form):
        form.instance.status='DEMO'
        form.instance.type=BUY2UNGLUE
        form.instance.set_dollar_per_day()
        form.instance.update_left()
        form.instance._current_total=form.cleaned_data['revenue']
        return self.render_to_response(self.get_context_data(form=form))
    
    def get_initial(self):
        return {'target':10000, 'cc_date_initial': date_today()+timedelta(days=1461),'revenue':0, 'type':BUY2UNGLUE, 'status':'DEMO'}

    def get_context_data(self, **kwargs):
        cd = super(FAQView,self).get_context_data(**kwargs)
        cd.update({
                'location': self.kwargs["location"], 
                'sublocation': self.kwargs["sublocation"],
                })
        return cd

class GoodreadsDisplayView(TemplateView):
    template_name = "goodreads_display.html"
    def get_context_data(self, **kwargs):
        context = super(GoodreadsDisplayView, self).get_context_data(**kwargs)
        session = self.request.session
        gr_client = GoodreadsClient(key=settings.GOODREADS_API_KEY, secret=settings.GOODREADS_API_SECRET)
        
        user = self.request.user
        if user.is_authenticated():
            api_key = ApiKey.objects.filter(user=user)[0].key
            context['api_key'] = api_key

        if user.profile.goodreads_user_id is None:   
            # calculate the Goodreads authorization URL
            (context["goodreads_auth_url"], request_token) = gr_client.begin_authorization(self.request.build_absolute_uri(reverse('goodreads_cb')))
            logger.info("goodreads_auth_url: %s" %(context["goodreads_auth_url"]))
            # store request token in session so that we can redeem it for auth_token if authorization works
            session['goodreads_request_token'] = request_token['oauth_token']
            session['goodreads_request_secret'] = request_token['oauth_token_secret']
        else:
            gr_shelves = gr_client.shelves_list(user_id=user.profile.goodreads_user_id)
            context["shelves_info"] = gr_shelves
            gr_shelf_load_form = GoodreadsShelfLoadingForm()
            # load the shelves into the form
            choices = [('all:%d' % (gr_shelves["total_book_count"]),'all (%d)' % (gr_shelves["total_book_count"]))] +  \
                [("%s:%d" % (s["name"], s["book_count"]) ,"%s (%d)" % (s["name"],s["book_count"])) for s in gr_shelves["user_shelves"]]
            gr_shelf_load_form.fields['goodreads_shelf_name_number'].widget = Select(choices=tuple(choices))
            
            context["gr_shelf_load_form"] = gr_shelf_load_form
            
# also load any CeleryTasks associated with the user
            context["celerytasks"] = models.CeleryTask.objects.filter(user=user)
            
        return context

@login_required
def goodreads_auth(request):

    # calculate the Goodreads authorization URL
    gr_client = GoodreadsClient(key=settings.GOODREADS_API_KEY, secret=settings.GOODREADS_API_SECRET)
    (goodreads_auth_url, request_token) = gr_client.begin_authorization(request.build_absolute_uri(reverse('goodreads_cb')))
    logger.info("goodreads_auth_url: %s" %(goodreads_auth_url))
    # store request token in session so that we can redeem it for auth_token if authorization works
    request.session['goodreads_request_token'] = request_token['oauth_token']
    request.session['goodreads_request_secret'] = request_token['oauth_token_secret']
    
    return HttpResponseRedirect(goodreads_auth_url)

@login_required    
def goodreads_cb(request):
    """handle callback from Goodreads"""
    
    session = request.session
    authorized_flag = request.GET['authorize']  # is it '1'?
    request_oauth_token = request.GET['oauth_token']

    if authorized_flag == '1':
        request_token = {'oauth_token': session.get('goodreads_request_token'),
                         'oauth_token_secret': session.get('goodreads_request_secret')}
        gr_client = GoodreadsClient(key=settings.GOODREADS_API_KEY, secret=settings.GOODREADS_API_SECRET)
        
        access_token = gr_client.complete_authorization(request_token)
        
        # store the access token in the user profile
        profile = request.user.profile
        profile.goodreads_auth_token = access_token["oauth_token"]
        profile.goodreads_auth_secret = access_token["oauth_token_secret"]
    
        # let's get the userid, username
        user = gr_client.auth_user()
        
        profile.goodreads_user_id = user["userid"]
        profile.goodreads_user_name = user["name"]
        profile.goodreads_user_link = user["link"]
        
        profile.save()  # is this needed?

    # redirect to the Goodreads display page -- should observe some next later
    return HttpResponseRedirect(reverse('home'))

@require_POST
@login_required
@csrf_exempt    
def goodreads_flush_assoc(request):
    user = request.user
    if user.is_authenticated():
        profile = user.profile
        profile.goodreads_user_id = None
        profile.goodreads_user_name = None
        profile.goodreads_user_link = None
        profile.goodreads_auth_token = None
        profile.goodreads_auth_secret = None
        profile.save()
        logger.info('Goodreads association flushed for user %s', user)
    return HttpResponseRedirect(reverse('goodreads_display'))
      
@require_POST
@login_required      
@csrf_exempt
def goodreads_load_shelf(request):
    """
    a view to allow user load goodreads shelf into her wishlist
    """
    # Should be moved to the API
    goodreads_shelf_name_number = request.POST.get('goodreads_shelf_name_number', 'all:0')
    user = request.user
    try:
        # parse out shelf name and expected number of books
        (shelf_name, expected_number_of_books) = re.match(r'^(.*):(\d+)$', goodreads_shelf_name_number).groups()
        expected_number_of_books = int(expected_number_of_books)
        logger.info('Adding task to load shelf %s to user %s with %d books', shelf_name, user, expected_number_of_books)
        load_task_name = "load_goodreads_shelf_into_wishlist"
        load_task = getattr(tasks, load_task_name)
        task_id = load_task.delay(user.id, shelf_name, expected_number_of_books=expected_number_of_books)
        
        ct = models.CeleryTask()
        ct.task_id = task_id
        ct.function_name = load_task_name
        ct.user = user
        ct.description = "Loading Goodread shelf %s to user %s with %s books" % (shelf_name, user, expected_number_of_books)
        ct.save()
        
        return HttpResponse("<span style='margin: auto 10px auto 36px;vertical-align: middle;display: inline-block;'>We're on it! <a href='JavaScript:window.location.reload()'>Reload the page</a> to see the books we've snagged so far.</span>")
    except Exception,e:
        return HttpResponse("Error in loading shelf: %s " % (e))
        logger.info("Error in loading shelf for user %s: %s ", user, e)


@login_required
def goodreads_calc_shelves(request):

    # we should move towards calculating this only if needed (perhaps with Ajax), caching previous results, etc to speed up
    # performance
    
    if request.user.profile.goodreads_user_id is not None:
        gr_client = GoodreadsClient(key=settings.GOODREADS_API_KEY, secret=settings.GOODREADS_API_SECRET)
        goodreads_shelves = gr_client.shelves_list(user_id=request.user.profile.goodreads_user_id)
        #goodreads_shelf_load_form = GoodreadsShelfLoadingForm()
        ## load the shelves into the form
        #choices = [('all:%d' % (goodreads_shelves["total_book_count"]),'all (%d)' % (goodreads_shelves["total_book_count"]))] +  \
        #    [("%s:%d" % (s["name"], s["book_count"]) ,"%s (%d)" % (s["name"],s["book_count"])) for s in goodreads_shelves["user_shelves"]]
        #goodreads_shelf_load_form.fields['goodreads_shelf_name_number'].widget = Select(choices=tuple(choices))
    else:
        goodreads_shelf_load_form = None
    
    return HttpResponse(json.dumps(goodreads_shelves), content_type="application/json")
    

@require_POST
@login_required      
@csrf_exempt
def librarything_load(request):
    """
    a view to allow user load librarything library into her wishlist
    """
    # Should be moved to the API
    user = request.user

    
    try:        
        # figure out expected_number_of_books later
        
        lt_username = request.user.profile.librarything_id
        logger.info('Adding task to load librarything %s to user %s', lt_username, user )
        load_task_name = "load_librarything_into_wishlist"
        load_task = getattr(tasks, load_task_name)
        task_id = load_task.delay(user.id, lt_username, None)
        
        ct = models.CeleryTask()
        ct.task_id = task_id
        ct.function_name = load_task_name
        ct.user = user
        ct.description = "Loading LibraryThing collection of %s to user %s." % (lt_username, user)
        ct.save()
            
        return HttpResponse("<span style='margin: auto 10px auto 36px;vertical-align: middle;display: inline-block;'>We're on it! <a href='JavaScript:window.location.reload()'>Reload the page</a> to see the books we've snagged so far.</span>")
    except Exception,e:
        return HttpResponse("Error in loading LibraryThing library: %s " % (e))
        logger.info("Error in loading LibraryThing for user %s: %s ", user, e)

@require_POST
@login_required      
@csrf_exempt
def clear_wishlist(request):
    try:
        request.user.wishlist.works.clear()
        logger.info("Wishlist for user %s cleared", request.user)
        return HttpResponse('wishlist cleared')
    except Exception, e:
        return HttpResponse("Error in clearing wishlist: %s " % (e))
        logger.info("Error in clearing wishlist for user %s: %s ", request.user, e)

@require_POST
@login_required      
def msg(request):
    form = MsgForm(data=request.POST)
    if form.is_valid():
        if not request.user.is_staff and request.user not in form.cleaned_data['work'].last_campaign().managers.all():
            logger.warning("unauthorized attempt to send message by %s for %s"% (request.user,form.cleaned_data['work']))
            raise Http404
        supporter_message.send(sender=request.user,msg=form.cleaned_data["msg"], work=form.cleaned_data["work"],supporter=form.cleaned_data["supporter"])
        return HttpResponse("message sent")
    else:
        logger.info("Invalid form for user %s", request.user)
        raise Http404
   

class LibraryThingView(FormView):
    template_name="librarything.html"
    form_class = LibraryThingForm
    
    def get_context_data(self, **kwargs):
        context = super(LibraryThingView, self).get_context_data(**kwargs)
        form = kwargs['form']
        # get the books for the lt_username in the form
        lt_username=self.request.GET.get("lt_username",None)
        if lt_username is not None:
            lt = librarything.LibraryThing(username=lt_username)
            context.update({'books':list(lt.parse_user_catalog(view_style=5))})
        else:
            context.update({'books':None})
            
        # try picking up the LibraryThing api key -- and set to None if not available.  Not being used for
        # anything crucial at this moment, so a None is ok here
        try:
            context.update({'lt_api_key':settings.LIBRARYTHING_API_KEY})
        except:
            pass
        
        return context

    def form_valid(self,form):
        return super(LibraryThingView, self).form_valid(form)
    
@require_POST
@login_required      
@csrf_exempt
def clear_celery_tasks(request):
    try:
        request.user.tasks.clear()
        logger.info("Celery tasks for user %s cleared", request.user)
        return HttpResponse('Celery Tasks List cleared')
    except Exception, e:
        return HttpResponse("Error in clearing Celery Tasks: %s " % (e))
        logger.info("Error in clearing Celery Tasks for user %s: %s ", request.user, e)    

def celery_test(request):
    return HttpResponse("celery_test")

# routing views that try to redirect to the works page on a 3rd party site
#
# TODO: need to queue up a task to look up IDs if we have to fallback to 
# routing based on ISBN or search

def work_librarything(request, work_id):
    work = safe_get_work(work_id)
    isbn = work.first_isbn_13()
    if work.librarything_id:
        url = work.librarything_url
    elif isbn:
        # TODO: do the redirect here and capture the work id?
        url = "http://www.librarything.com/isbn/%s" % isbn
    else:
        term = work.title + " " + work.author()
        q = urlencode({'searchtpe': 'work', 'term': term})
        url = "http://www.librarything.com/search.php?" + q
    return HttpResponseRedirect(url)

def work_openlibrary(request, work_id):
    work = safe_get_work(work_id)
    isbns = ["ISBN:" + i.value for i in work.identifiers.filter(type='isbn')]
    url = None

    if work.openlibrary_id:
        url = work.openlibrary_url
    elif len(isbns) > 0:
        isbns = ",".join(isbns)
        u = 'http://openlibrary.org/api/books?bibkeys=%s&jscmd=data&format=json' % isbns
        try:
            j = json.loads(requests.get(u).content)
            # as long as there were some matches get the first one and route to it
            if len(j.keys()) > 0:
                first = j.keys()[0]
                url = "http://openlibrary.org" + j[first]['key'] 
        except ValueError:
            # fail at openlibrary
            logger.warning("failed to get OpenLibrary json at %s" % u)          
    # fall back to doing a search on openlibrary
    if not url:
        q = urlencode({'q': work.title + " " + work.author()})
        url = "http://openlibrary.org/search?" + q
    return HttpResponseRedirect(url)

def work_goodreads(request, work_id):
    work = safe_get_work(work_id)
    isbn = work.first_isbn_13()
    if work.goodreads_id:
        url = work.goodreads_url
    elif isbn:
        url = "http://www.goodreads.com/book/isbn/%s" % isbn
    else:
        q = urlencode({'query': work.title + " " + work.author()})
        url = "http://www.goodreads.com/search?" + q
    return HttpResponseRedirect(url)

@login_required
def emailshare(request, action):
    if request.method == 'POST':
        form=EmailShareForm(request.POST)
        if form.is_valid():
            subject = form.cleaned_data['subject']
            message = form.cleaned_data['message']
            sender = '%s via Unglue.it <%s>'%(request.user.username, request.user.email)
            recipient = form.cleaned_data['recipient']
            send_mail_task.delay(subject, message, sender, [recipient])
            try:
                next = form.cleaned_data['next']
            except:
                # if we totally failed to have a next value, we should still redirect somewhere useful
                next = 'https://unglue.it'
            return HttpResponseRedirect(next)
            
    else: 
        work = None
        status = None
        
        try:
            next = request.GET['next']
            work_id = next.split('/')[-2]
            work_id = int(work_id)
            work = models.Work.objects.get(pk=work_id)
            if not action:
                status = work.last_campaign().status
        except:
            pass
        context = {'request':request,'work':work,'site': Site.objects.get_current(), 'action': action}
        if work and action :
            message = render_to_string('emails/i_just_pledged.txt', context)
            subject = "Help me unglue "+work.title
        else:            
            # customize the call to action depending on campaign status
            if status == 'ACTIVE':
                message = render_to_string('emails/pledge_this.txt', context)
                subject = 'Please help me give this book to the world'
            elif work:
                message = render_to_string('emails/wish_this.txt', context)
                subject = 'This is one of my favorite books on Unglue.it'
            else:
                # for email shares not bound to a campaign or pledge
                message = render_to_string('emails/join_me.txt', context)
                subject = "Help me give books to the world"

        form = EmailShareForm(initial={ 'next':next, 'subject': subject, 'message': message})

    return render(request, "emailshare.html", {'form':form})    
    
def ask_rh(request, campaign_id):
    campaign = get_object_or_404(models.Campaign, id=campaign_id)
    return feedback(request, recipient=campaign.email, template="ask_rh.html", 
            message_template="ask_rh.txt", 
            redirect_url = reverse('work', args=[campaign.work.id]),
            extra_context={'campaign':campaign, 'subject':campaign })    
    
def feedback(request, recipient='support@gluejar.com', template='feedback.html', message_template='feedback.txt', extra_context=None, redirect_url=None):
    context = extra_context or {}
    context['num1'] = randint(0,10)
    context['num2'] = randint(0,10)
    context['answer'] = context['num1'] + context['num2']
    
    if request.method == 'POST':
        form=FeedbackForm(request.POST)
        if form.is_valid():
            context.update(form.cleaned_data)
            context['request']=request
            if extra_context:
                context.update(extra_context)
            message = render_to_string(message_template,context)
            send_mail_task.delay(context['subject'], message, context['sender'], [recipient])
            if redirect_url:
                return HttpResponseRedirect(redirect_url)
            else:
                return render(request, "thanks.html", context) 
            
        else:
            context['num1'] = request.POST['num1']
            context['num2']  = request.POST['num2']
        
    else:
        if request.user.is_authenticated():
            context['sender']=request.user.email;
        try:
            context['page'] = request.GET['page']
        except:
            context['page'] = '/'
        if not context.has_key('subject'):
            context['subject'] = "Feedback on page "+context['page']
        form = FeedbackForm(initial=context)
    context['form'] = form
    return render(request, template, context)    
        
def comment(request):
    latest_comments = Comment.objects.all().order_by('-submit_date')[:20]
    return render(request, "comments.html", {'latest_comments': latest_comments})

def campaign_archive_js(request):
    """ proxy for mailchimp js"""
    response = HttpResponse()
    r = requests.get(settings.CAMPAIGN_ARCHIVE_JS)
    response.status_code = r.status_code
    response.content = r.content
    response["Content-Type"] = "text/javascript"
    return response

def lockss(request, work_id):
    """
    manifest pages for lockss harvester -- individual works
    """
    work = safe_get_work(work_id)
    try:
        ebooks = work.ebooks().filter(edition__unglued=True)
    except:
        ebooks = None
    authors = list(models.Author.objects.filter(editions__work=work).all())
    
    return render(request, "lockss.html", {'work':work, 'ebooks':ebooks, 'authors':authors})
    
def lockss_manifest(request, year):
    """
    manifest pages for lockss harvester -- yearly indices
    (lockss needs pages listing all books unglued by year, with 
    programmatically determinable URLs)
    """
    year = int(year)
    start_date = date(year, 1, 1)
    end_date = date(year, 12, 31)
    try:
        ebooks = models.Edition.objects.filter(unglued=True).filter(created__range=(start_date, end_date))
    except:
        ebooks = None
    
    return render(request, "lockss_manifest.html", {'ebooks':ebooks, 'year': year})

class DownloadView(PurchaseView):
    template_name="download.html"
    form_class = CampaignThanksForm    
    def show_beg(self):
        if not self.campaign or self.campaign.type != THANKS:
            return  False
        elif self.user_license and self.user_license.thanked:
            return self.request.REQUEST.has_key('offer_id')
        elif self.lib_thanked:
            return False
        elif self.campaign.status != 'ACTIVE':
            return self.request.REQUEST.has_key('testmode')
        else: 
            return True
        
    def form_valid(self, form):
        p = PaymentManager()
        t, url = p.process_transaction('USD',  form.cleaned_data["preapproval_amount"],  
                host = PAYMENT_HOST_NONE, 
                campaign=self.campaign, 
                user=self.request.user,
                paymentReason="Unglue.it Contribution for {0}".format(self.campaign.name), 
                pledge_extra=form.trans_extra,
                )    
        if url:
            return HttpResponseRedirect(url)
        else:
            logger.error("Attempt to produce transaction id {0} failed".format(t.id))
            return HttpResponse("Our attempt to set up your contribution failed. We have logged this problem.")

    def get_form_kwargs(self):
        if self.kwargs.has_key('work'):
            self.work = self.kwargs["work"]
            self.show_beg= lambda: False
        else:
            self.work = safe_get_work(self.kwargs["work_id"])
        self.campaign = self.work.last_campaign()
        self.user_license = self.work.get_user_license(self.request.user)
        self.lib_thanked = self.work.lib_thanked(self.request.user)
        self.data = {
            'preapproval_amount':self.get_preapproval_amount(),
            'anonymous':True if self.request.user.is_anonymous() else self.request.user.profile.anon_pref,
            }
        if self.request.method  == 'POST':
            self.data.update(self.request.POST.dict())
            if not self.request.POST.has_key('anonymous'):
                del self.data['anonymous']
            return {'data':self.data}
        else:
            return {'initial':self.data}

    def get_context_data(self, **kwargs):
        context = super(FormView, self).get_context_data(**kwargs)
        # adapt funtion view to class view
        work =  self.work 
        request = self.request
        site = Site.objects.get_current()

        unglued_ebooks = work.ebooks().filter(edition__unglued=True)
        other_ebooks = work.ebooks().filter(edition__unglued=False)
        xfer_url = None
        acq=None
        formats = {}  # a dict of format name and url
        for ebook in work.ebooks().all():
            formats[ebook.format] = reverse('download_ebook', args=[ebook.id] )
    
        if request.user.is_authenticated(): 
            all_acqs=request.user.acqs.filter(work=work).order_by('-created')
            for an_acq in all_acqs:
                if not an_acq.expired:
                    # skip for THANKS
                    if an_acq.license == THANKED:
                        acq = None
                        break
                    # prepare this acq for download
                    if not an_acq.watermarked or an_acq.watermarked.expired:
                        if not an_acq.on_reserve:
                            watermark_acq.delay(an_acq)
                    acq = an_acq
                    formats['epub']= reverse('download_acq', kwargs={'nonce':acq.nonce, 'format':'epub'})
                    formats['mobi']= reverse('download_acq', kwargs={'nonce':acq.nonce, 'format':'mobi'})
                    xfer_url = settings.BASE_URL_SECURE + formats['epub']
                    kindle_url = settings.BASE_URL_SECURE + formats['mobi']
                    can_kindle = True
                    break
            
    
        if not acq:
            # google ebooks have a captcha which breaks some of our services
            non_google_ebooks = work.ebooks().exclude(provider='Google Books')
        
            #send to kindle 
        
            try:
                non_google_ebooks.filter(format='mobi')[0]
                can_kindle = True
            except IndexError:
                try:
                    non_google_ebooks.filter(format='pdf')[0]
                    can_kindle = True
                except IndexError:
                    can_kindle = False
            # configure the xfer url
            try:
                xfer_epub_ebook = non_google_ebooks.filter(format='epub')[0]
                xfer_url = settings.BASE_URL_SECURE + reverse('download_ebook',args=[xfer_epub_ebook.id])
            except:
                xfer_url = None
        agent = request.META.get('HTTP_USER_AGENT','')   
        iOS = 'iPad' in agent or 'iPhone' in agent or 'iPod' in agent
        iOS_app = iOS and not 'Safari' in agent
        android = 'Android' in agent
        desktop = not iOS and not android
        context.update({
            'unglued_ebooks': unglued_ebooks,
            'other_ebooks': other_ebooks,
            'formats': formats,
            'xfer_url': xfer_url,
            'kindle_url': kindle_url,
            'dropbox_key': settings.DROPBOX_KEY,
            'can_kindle': can_kindle,
            'base_url': settings.BASE_URL_SECURE,
            'iOS': iOS,
            'iOS_app': iOS_app,
            'iphone': 'iPhone' in agent,
            'android': android,
            'desktop': desktop,
            'mac_ibooks': 'Mac OS X 10.9' in agent or 'Mac OS X 10_9' in agent,
            'acq':acq,
            'show_beg': self.show_beg,
            'preapproval_amount': self.get_preapproval_amount(),
            'work': work, 
            'site': site,
            'action': "Contribution",
            'user_license': self.user_license,
            'lib_thanked': self.lib_thanked,
            'amount': self.request.session.pop('amount') if self.request.session.has_key('amount') else None,
            'testmode': self.request.REQUEST.has_key('testmode'),
        })
        return context

@login_required
def borrow(request, work_id):
    work = safe_get_work(work_id)
    library =  request.GET.get('library', '')
    libuser = None
    acq = None
    if library:
        try:
            libuser = User.objects.get(username = library)
        except User.DoesNotExist:
            libuser = None
        if libuser:
            acq = work.get_user_license(libuser).borrowable_acq
    if not libuser or not acq:
        acq=work.get_lib_license(request.user).borrowable_acq
    if acq:
        borrowed = acq.borrow(request.user)
        return DownloadView.as_view()(request, work=work)
    else:
        # shouldn't happen
        return work(request, work_id)

@login_required
def reserve(request, work_id):
    work = safe_get_work(work_id)
    lib =  request.GET.get('library', '')
    library = None
    try:
        library = Library.objects.get(user__username = lib)
    except Library.DoesNotExist:
        try:
            library = work.get_lib_license(request.user).next_acq.library
        except:
            library = None
        
    models.Hold.objects.get_or_create(library=library,work=work,user=request.user)
    return PurchaseView.as_view()(request,work_id=work_id)
    
def download_ebook(request, ebook_id):
    ebook = get_object_or_404(models.Ebook,id=ebook_id)
    ebook.increment()
    logger.info("ebook: {0}, user_ip: {1}".format(ebook_id, request.META['REMOTE_ADDR']))
    return HttpResponseRedirect(ebook.url)

def download_purchased(request, work_id):
    if request.user.is_anonymous:
        HttpResponseRedirect('/accounts/login/download/')
    return DownloadView.as_view()(request, work_id=work_id)

def download_campaign(request, work_id, format):
    work = safe_get_work(work_id)
    campaign = work.last_campaign()
    if campaign is None or (campaign.status != 'SUCCESSFUL'):
        raise Http404
    if campaign.type is BUY2UNGLUE:
        ebfs= models.EbookFile.objects.filter(edition__work=campaign.work, format=format).exclude(file='').order_by('-created')
        logger.info(ebfs.count())
        for ebf in ebfs:
            logger.info(ebf.file.url)
            return HttpResponseRedirect(ebf.file.url)
    raise Http404


def download_acq(request, nonce, format):
    acq = get_object_or_404(models.Acq,nonce=nonce)
    if acq.on_reserve:
        acq.borrow()
    if format == 'epub':
        return HttpResponseRedirect( acq.get_epub_url() )
    else:
        return HttpResponseRedirect( acq.get_mobi_url() )
    
def about(request, facet):
    template = "about_" + facet + ".html"
    try:
        return render(request, template)
    except TemplateDoesNotExist:
        return render(request, "about.html")

@login_required  
@csrf_exempt    
def ml_status(request):
    return render(request, "ml_status.html")

@require_POST
@login_required      
def ml_subscribe(request):
    request.user.profile.ml_subscribe(double_optin=False,send_welcome=True, merge_vars = {"OPTIN_IP":request.META['REMOTE_ADDR'],"OPTIN_TIME":now().isoformat()})
    return HttpResponseRedirect(reverse("notification_notice_settings"))

@require_POST
@login_required      
def ml_unsubscribe(request):
    request.user.profile.ml_unsubscribe()
    return HttpResponseRedirect(reverse("notification_notice_settings"))
    
def press(request):
    latest_items = models.Press.objects.order_by('-date')[:3]
    highlighted_items = models.Press.objects.filter(highlight=True).order_by('-date')
    all_items = models.Press.objects.exclude(highlight=True).order_by('-date')
    return render(request, "press_new.html", {
        'latest_items': latest_items,
        'highlighted_items': highlighted_items,
        'all_items': all_items
    })
    
def press_submitterator(request):
    if not request.user.is_staff:
        return render(request, "admins_only.html")
    else:
        title = ''
        if request.method == 'POST':
            form = PressForm(request.POST)
            if form.is_valid():
                form.save()
                title = form.cleaned_data['title']
        else:
            form = PressForm()
        
        return render(request, 'press_submitterator.html', {
            'form':form,
            'title':title
        })

@login_required
def kindle_config(request, work_id=None):
    if work_id:
        work = safe_get_work(work_id)
    else:
        work = None
    template = "kindle_config.html"
    if request.method == 'POST':
        form = KindleEmailForm(request.POST)
        if form.is_valid():
            request.user.profile.kindle_email = form.cleaned_data['kindle_email']
            request.user.profile.save()
            template = "kindle_change_successful.html"
    else:
        form = KindleEmailForm()    
    return render(request, template, {'form': form, 'work': work})

@require_POST
@csrf_exempt
def send_to_kindle(request, work_id, javascript='0'):

    # make sure to gracefully communicate with both js and non-js (kindle!) users
    def local_response(request, javascript, context, message):
        context['message'] = message
        if javascript == '1':
            return render(request,'kindle_response_message.html',context )
        else:
            return render(request, 'kindle_response_graceful_degradation.html', context)
    
    work=safe_get_work(work_id)
    context= {'work':work}
    acq = None
    if request.user.is_authenticated(): 
        all_acqs=request.user.acqs.filter(work=work).order_by('-created')
        for an_acq in all_acqs:
            if not an_acq.expired:
                # skip for THANKS
                if an_acq.license == THANKED:
                    acq = None
                    break
                # prepare this acq for download
                if not an_acq.watermarked or an_acq.watermarked.expired:
                    if not an_acq.on_reserve:
                        watermark_acq.delay(an_acq)
                acq = an_acq
                break
    
    if acq:
        ebook_url = acq.get_mobi_url()
        ebook_format = 'mobi'
        title = acq.work.title
    else:
        non_google_ebooks = work.ebooks().exclude(provider='Google Books')
        try:
            ebook = non_google_ebooks.filter(format='mobi')[0]
        except IndexError:
            try:
                ebook = non_google_ebooks.filter(format='pdf')[0]
            except IndexError:
                raise Http404

        # don't forget to increment the download counter!
        ebook.increment()
        ebook_url = ebook.url
        ebook_format = ebook.format
        logger.info('ebook: {0}, user_ip: {1}'.format(work_id, request.META['REMOTE_ADDR']))
        title = ebook.edition.title
    title = title.replace(' ', '_')
    context['ebook_url']=ebook_url
    context['ebook_format']=ebook_format

    if request.POST.has_key('kindle_email'):
        kindle_email = request.POST['kindle_email']
        try:
            validate_email(kindle_email)
        except ValidationError:
            return local_response(request, javascript,  context, 3)
        request.session['kindle_email'] = kindle_email
    elif request.user.is_authenticated():
        kindle_email = request.user.profile.kindle_email     
    context['kindle_email'] = kindle_email

    
    """
    TO FIX rigorously:
    Amazon SES has a 10 MB size limit (http://aws.amazon.com/ses/faqs/#49) in messages sent
    to determine whether the file will meet this limit, we probably need to compare the
    size of the mime-encoded file to 10 MB. (and it's unclear exactly what the Amazon FAQ means precisely by
    MB either: http://en.wikipedia.org/wiki/Megabyte) http://www.velocityreviews.com/forums/t335208-how-to-get-size-of-email-attachment.html might help

    for the moment, we will hardwire a 749229 limit in filesize:
    * assume conservative size of megabyte, 1000000B
    * leave 1KB for headers
    * mime encoding will add 33% to filesize
    This won't perfectly measure size of email, but should be safe, and is much faster than doing the check after download.
    """
    filehandle = urllib.urlopen(ebook_url)
    filesize = int(filehandle.info().getheaders("Content-Length")[0])
    if filesize > 7492232:
        logger.info('ebook %s is too large to be emailed' % work.id)
        return local_response(request, javascript,  context, 0)
        
    try:
        email = EmailMessage(from_email='notices@gluejar.com',
                to=[kindle_email])
        email.attach(title + '.' + ebook_format, filehandle.read())
        email.send()
    except:
        logger.warning('Unexpected error: %s', sys.exc_info())
        return local_response(request, javascript,  context, 1)

    if request.POST.has_key('kindle_email') and not request.user.is_authenticated():
        return HttpResponseRedirect(reverse('superlogin'))
    return local_response(request, javascript,  context, 2)
    
    
def marc(request, userlist=None):
    link_target = 'UNGLUE'
    libpref = {'marc_link_target': settings.MARC_CHOICES[1]}
    try:
        libpref = request.user.libpref
        link_target = libpref.marc_link_target
    except:
        if not request.user.is_anonymous():
            libpref = models.Libpref(user=request.user)
    unwanted = 'UNGLUE' if link_target == 'DIRECT' else 'DIRECT'
    if userlist:
        records = []
        user = get_object_or_404(User,username=userlist)
        for work in user.wishlist.works.all():
            records.extend(models.MARCRecord.objects.filter(edition__work=work,link_target=link_target))
            records.extend(models.MARCRecord.objects.filter(edition__work=work,link_target='B2U'))
    else:
        records = models.MARCRecord.objects.exclude(link_target=unwanted)
    return render(
        request,
        'marc.html',
        {'records': records,  'libpref' : libpref , 'userlist' : userlist}
    )

class MARCUngluifyView(FormView):
    template_name = 'marcungluify.html'
    form_class = MARCUngluifyForm
    success_url = reverse_lazy('MARCUngluify')
    
    # allow a get param to specify the edition
    def get_initial(self):
        if self.request.method == 'GET':
            edition = self.request.GET.get('edition',None)
            if models.Edition.objects.filter(id=edition).count():
                edition = models.Edition.objects.filter(id=edition)[0]
                if edition.ebooks.count() or edition.ebook_files.count():
                    return {'edition':edition.id}
        return {}

    def form_valid(self, form):
        edition = form.cleaned_data['edition']

        try:
            ungluify_record.makemarc(
                marcfile=self.request.FILES['file'],
                edition=edition
            )
            messages.success(
                self.request,
                "You have successfully added a MARC record. Hooray! Add another?"
            )
        except SAXParseException:
            messages.error(
                self.request,
                "Sorry, couldn't parse that file."
            )
        return super(MARCUngluifyView,self).form_valid(form)
        
class MARCConfigView(FormView):
    template_name = 'marc_config.html'
    form_class = MARCFormatForm
    success_url = reverse_lazy('marc')
    
    def form_valid(self, form):
        marc_link_target = form.cleaned_data['marc_link_target']
        try:
            libpref = self.request.user.libpref
        except:
            libpref = models.Libpref(user=self.request.user)
        libpref.marc_link_target = marc_link_target
        libpref.save()
        messages.success(
            self.request,
            "Your preferences have been changed."
        )
        if reverse('marc_config', args=[]) in self.request.META['HTTP_REFERER']:
            return HttpResponseRedirect(reverse('marc_config', args=[]))
        else:
            return super(MARCConfigView, self).form_valid(form)
            
def marc_concatenate(request):
    if request.method == 'POST':
        params=request.POST
    elif request.method == 'GET':
        params=request.GET
    else:
        return HttpResponseNotFound
    format = params['format']
    
    # extract the user-selected records from the params QueryDict
    selected_records = list(
        k for k in params if params[k] == u'on'
    )
    if not selected_records:
        messages.error(
            request,
            "Please select at least one record to download."
        )
        return HttpResponseRedirect(reverse('marc', args=[]))
    
    preamble = ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
                     '<collection '
                     'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
                     'xmlns="http://www.loc.gov/MARC21/slim" '
                     'xsi:schemaLocation="http://www.loc.gov/MARC21/slim '
                     'http://www.loc.gov/standards/marcxml/schema/'
                     'MARC21slim.xsd">')
    outfile = HttpResponse('', content_type='application/marc')
    outfile['Content-Disposition'] = 'attachment; filename='+ now().strftime('%Y%m%d%H%M%S') + '.' +  format

    if format == 'xml':
        outfile.write(preamble)
    for record in selected_records:
        record_id = long(record[7:])
        if format == 'xml':
            record_url = models.MARCRecord.objects.get(
                            pk=record_id
                         ).xml_record
        elif format == 'mrc':
            record_url = models.MARCRecord.objects.get(
                            pk=record_id
                         ).mrc_record
        try:
            record_file = default_storage.open(record_url).read()
            outfile.write(record_file)
        except IOError:
            logger.warning('MARC record with id number %s has a problem with its URL' % record_id)
    if format == 'xml':
        outfile.write('</collection>')

    return outfile