regluit/core/models/bibmodels.py

import logging
import math
import re
import urllib
import urllib2
import uuid

from decimal import Decimal
import unicodedata
from urlparse import urlparse

from sorl.thumbnail import get_thumbnail

from django.conf import settings
from django.contrib.auth.models import User
from django.contrib.contenttypes.fields import GenericRelation
from django.core.files.base import ContentFile
from django.core.urlresolvers import reverse
from django.db import models
from django.db.models import F
from django.db.models.signals import post_save, pre_delete

import regluit
from regluit.marc.models import MARCRecord as NewMARC
from regluit.utils.localdatetime import now
from regluit.questionnaire.models import Landing

import regluit.core.cc as cc
from regluit.core.epub import test_epub
from regluit.core.parameters import (
    AGE_LEVEL_CHOICES,
    BORROWED,
    BUY2UNGLUE,
    INDIVIDUAL,
    LIBRARY,
    OFFER_CHOICES,
    TESTING,
    TEXT_RELATION_CHOICES,
    THANKED,
    THANKS,
)

logger = logging.getLogger(__name__)


class Identifier(models.Model):
    # olib, ltwk, goog, gdrd, thng, isbn, oclc, olwk, doab, gute, glue, doi
    type = models.CharField(max_length=4, null=False)
    value = models.CharField(max_length=250, null=False)
    work = models.ForeignKey("Work", related_name="identifiers", null=False)
    edition = models.ForeignKey("Edition", related_name="identifiers", null=True)

    class Meta:
        unique_together = ("type", "value")

    @staticmethod
    def set(type=None, value=None, edition=None, work=None):
        # if there's already an id of this type for this work and edition, change it
        # if not, create it. if the id exists and points to something else, change it.
        identifier = Identifier.get_or_add(type=type, value=value, edition=edition, work=work)
        if identifier.work.id != work.id:
            identifier.work = work
            identifier.save()
        if identifier.edition and edition:
            if identifier.edition.id != edition.id:
                identifier.edition = edition
                identifier.save()
            others = Identifier.objects.filter(type=type, work=work, edition=edition).exclude(value=value)
            if others.count() > 0:
                for other in others:
                    other.delete()
        return identifier

    @staticmethod
    def get_or_add(type='goog', value=None, edition=None, work=None):
        try:
            return Identifier.objects.get(type=type, value=value)
        except Identifier.DoesNotExist:
            i = Identifier(type=type, value=value, edition=edition, work=work)
            i.save()
            return i

    def __unicode__(self):
        return u'{0}:{1}'.format(self.type, self.value)

class Work(models.Model):
    created = models.DateTimeField(auto_now_add=True, db_index=True,)
    title = models.CharField(max_length=1000)
    language = models.CharField(max_length=5, default="en", null=False, db_index=True,)
    openlibrary_lookup = models.DateTimeField(null=True)
    num_wishes = models.IntegerField(default=0, db_index=True)
    description = models.TextField(default='', null=True, blank=True)
    selected_edition = models.ForeignKey("Edition", related_name='selected_works', null=True)
    # repurposed earliest_publication to actually be publication range
    publication_range = models.CharField(max_length=50, null=True)
    featured = models.DateTimeField(null=True, blank=True, db_index=True,)
    is_free = models.BooleanField(default=False)
    landings = GenericRelation(Landing)
    related = models.ManyToManyField('self', symmetrical=False, null=True, through='WorkRelation', related_name='reverse_related')
    age_level = models.CharField(max_length=5, choices=AGE_LEVEL_CHOICES, default='') 

    class Meta:
        ordering = ['title']
    def __unicode__(self):
        return self.title

    def __init__(self, *args, **kwargs):
        self._last_campaign = None
        super(Work, self).__init__(*args, **kwargs)

    @property
    def googlebooks_id(self):
        try:
            preferred_id = self.preferred_edition.googlebooks_id
            # note that there should always be a preferred edition
        except AttributeError:
            # this work has no edition.
            return ''
        if preferred_id:
            return preferred_id
        try:
            return self.identifiers.filter(type='goog')[0].value
        except IndexError:
            return ''

    @property
    def googlebooks_url(self):
        if self.googlebooks_id:
            return "http://books.google.com/books?id=%s" % self.googlebooks_id
        else:
            return ''

    @property
    def goodreads_id(self):
        preferred_id = self.preferred_edition.goodreads_id
        if preferred_id:
            return preferred_id
        try:
            return self.identifiers.filter(type='gdrd')[0].value
        except IndexError:
            return ''

    @property
    def goodreads_url(self):
        return "http://www.goodreads.com/book/show/%s" % self.goodreads_id

    @property
    def librarything_id(self):
        try:
            return self.identifiers.filter(type='ltwk')[0].value
        except IndexError:
            return ''

    @property
    def librarything_url(self):
        return "http://www.librarything.com/work/%s" % self.librarything_id

    @property
    def openlibrary_id(self):
        try:
            return self.identifiers.filter(type='olwk')[0].value
        except IndexError:
            return ''

    @property
    def openlibrary_url(self):
        return "http://openlibrary.org" + self.openlibrary_id

    def cover_filetype(self):
        if self.uses_google_cover():
            return 'jpeg'
        else:
            # consider the path only and not the params, query, or fragment
            url = urlparse(self.cover_image_small().lower()).path

            if url.endswith('.png'):
                return 'png'
            elif url.endswith('.gif'):
                return 'gif'
            elif url.endswith('.jpg') or url.endswith('.jpeg'):
                return 'jpeg'
            else:
                return 'image'

    def uses_google_cover(self):
        if self.preferred_edition and self.preferred_edition.cover_image:
            return False
        else:
            return self.googlebooks_id

    def cover_image_large(self):
        if self.preferred_edition and self.preferred_edition.has_cover_image():
            return self.preferred_edition.cover_image_large()
        return "/static/images/generic_cover_larger.png"

    def cover_image_small(self):
        if self.preferred_edition and self.preferred_edition.has_cover_image():
            return self.preferred_edition.cover_image_small()
        return "/static/images/generic_cover_larger.png"

    def cover_image_thumbnail(self):
        try:
            if self.preferred_edition and self.preferred_edition.has_cover_image():
                return self.preferred_edition.cover_image_thumbnail()
        except IndexError:
            pass
        return "/static/images/generic_cover_larger.png"

    def authors(self):
        # assumes that they come out in the same order they go in!
        if self.preferred_edition and self.preferred_edition.authors.all().count() > 0:
            return  self.preferred_edition.authors.all()
        for edition in self.editions.all():
            if edition.authors.all().count() > 0:
                return edition.authors.all()
        return Author.objects.none()

    def relators(self):
        # assumes that they come out in the same order they go in!
        if self.preferred_edition and self.preferred_edition.relators.all().count() > 0:
            return  self.preferred_edition.relators.all()
        for edition in self.editions.all():
            if edition.relators.all().count() > 0:
                return edition.relators.all()
        return Relator.objects.none()

    def author(self):
        # assumes that they come out in the same order they go in!
        if self.relators().count() > 0:
            return self.relators()[0].name
        return ''

    def authors_short(self):
        # assumes that they come out in the same order they go in!
        if self.relators().count() == 1:
            return self.relators()[0].name
        elif self.relators().count() == 2:
            if self.relators()[0].relation == self.relators()[1].relation:
                if self.relators()[0].relation.code == 'aut':
                    return "%s and %s" % (self.relators()[0].author.name, self.relators()[1].author.name)
                else:
                    return "%s and %s, %ss" % (self.relators()[0].author.name, self.relators()[1].author.name, self.relators()[0].relation.name)
            else:
                return "%s (%s) and %s (%s)" % (self.relators()[0].author.name, self.relators()[0].relation.name, self.relators()[1].author.name, self.relators()[1].relation.name)
        elif self.relators().count() > 2:
            auths = self.relators().order_by("relation__code")
            if auths[0].relation.code == 'aut':
                return "%s et al." % auths[0].author.name
            else:
                return "%s et al. (%ss)" % (auths[0].author.name, auths[0].relation.name)
        return ''

    def kindle_safe_title(self):
        """
        Removes accents, keeps letters and numbers, replaces non-Latin characters with "#", and replaces punctuation with "_"
        """
        safe = u''
        nkfd_form = unicodedata.normalize('NFKD', self.title) #unaccent accented letters
        for c in nkfd_form:
            ccat = unicodedata.category(c)
            #print ccat
            if ccat.startswith('L') or  ccat.startswith('N'): # only letters and numbers
                if ord(c) > 127:
                    safe = safe + '#' #a non latin script letter or number
                else:
                    safe = safe + c
            elif not unicodedata.combining(c): #not accents (combining forms)
                safe = safe + '_' #punctuation
        return safe

    def last_campaign(self):
        # stash away the last campaign to prevent repeated lookups
        if hasattr(self, '_last_campaign_'):
            return self._last_campaign_
        try:
            self._last_campaign_ = self.campaigns.order_by('-created')[0]
        except IndexError:
            self._last_campaign_ = None
        return self._last_campaign_

    @property
    def preferred_edition(self):
        if self.selected_edition:
            return self.selected_edition
        if self.last_campaign():
            if self.last_campaign().edition:
                self.selected_edition = self.last_campaign().edition
                self.save()
                return self.last_campaign().edition
        try:
            self.selected_edition = self.editions.all().order_by('-cover_image', '-created')[0] # prefer editions with covers
            self.save()
            return self.selected_edition
        except IndexError:
            #should only happen if there are no editions for the work,
            #which can happen when works are being merged
            try:
                return WasWork.objects.get(was=self.id).work.preferred_edition
            except WasWork.DoesNotExist:
                #should not happen
                logger.warning('work {} has no edition'.format(self.id))
                return None

    def last_campaign_status(self):
        campaign = self.last_campaign()
        if campaign:
            status = campaign.status
        else:
            if self.first_ebook():
                status = "Available"
            else:
                status = "No campaign yet"
        return status

    def percent_unglued(self):
        status = 0
        campaign = self.last_campaign()
        if campaign is not None:
            if campaign.status == 'SUCCESSFUL':
                status = 6
            elif campaign.status == 'ACTIVE':
                if campaign.target is not None:
                    target = float(campaign.target)
                else:
                    #shouldn't happen, but did once because of a failed pdf conversion
                    return 0
                if target <= 0:
                    status = 6
                else:
                    if campaign.type == BUY2UNGLUE:
                        status = int(6 - 6*campaign.left/campaign.target)
                    else:
                        status = int(float(campaign.current_total)*6/target)
                    if status >= 6:
                        status = 6
        return status

    def percent_of_goal(self):
        campaign = self.last_campaign()
        return 0 if campaign is None else campaign.percent_of_goal()

    def ebooks_all(self):
        return self.ebooks(all=True)

    def ebooks(self, all=False):
        if all:
            return Ebook.objects.filter(edition__work=self).order_by('-created')
        else:
            return Ebook.objects.filter(edition__work=self, active=True).order_by('-created')

    def ebookfiles(self):
        return EbookFile.objects.filter(edition__work=self).exclude(file='').order_by('-created')

    def epubfiles(self):
        # filter out non-epub because that's what booxtream accepts
        return EbookFile.objects.filter(edition__work=self, format='epub').exclude(file='').order_by('-created')

    def mobifiles(self):
        return EbookFile.objects.filter(edition__work=self, format='mobi').exclude(file='').order_by('-created')

    def pdffiles(self):
        return EbookFile.objects.filter(edition__work=self, format='pdf').exclude(file='').order_by('-created')

    def formats(self):
        fmts = []
        for fmt in ['pdf', 'epub', 'mobi', 'html']:
            for ebook in self.ebooks().filter(format=fmt):
                fmts.append(fmt)
                break
        return fmts

    def make_ebooks_from_ebfs(self, add_ask=True):
        # either the ebf has been uploaded or a created (perhaps an ask was added or mobi generated)
        if self.last_campaign().type != THANKS:  # just to make sure that ebf's can be unglued by mistake
            return
        ebfs = EbookFile.objects.filter(edition__work=self).exclude(file='').order_by('-created')
        done_formats = []
        for ebf in ebfs:
            previous_ebooks = Ebook.objects.filter(url=ebf.file.url,)
            try:
                previous_ebook = previous_ebooks[0]
                for eb in previous_ebooks[1:]:  #housekeeping
                    eb.deactivate()
            except IndexError:
                previous_ebook = None

            if ebf.format not in done_formats:
                if ebf.asking == add_ask or ebf.format == 'mobi':
                    if previous_ebook:
                        previous_ebook.activate()
                    else:
                        ebook = Ebook.objects.get_or_create(
                            edition=ebf.edition,
                            format=ebf.format,
                            rights=self.last_campaign().license,
                            provider="Unglue.it",
                            url=ebf.file.url,
                        )
                    done_formats.append(ebf.format)
                elif previous_ebook:
                    previous_ebook.deactivate()
            elif previous_ebook:
                previous_ebook.deactivate()
        return

    def remove_old_ebooks(self):
        old = Ebook.objects.filter(edition__work=self, active=True).order_by('-created')
        done_formats = []
        for eb in old:
            if eb.format in done_formats:
                eb.deactivate()
            else:
                done_formats.append(eb.format)
        null_files = EbookFile.objects.filter(edition__work=self, file='')
        for ebf in null_files:
            ebf.file.delete()
            ebf.delete()

    @property
    def download_count(self):
        dlc = 0
        for ebook in self.ebooks(all=True):
            dlc += ebook.download_count
        return dlc

    def first_pdf(self):
        return self.first_ebook('pdf')

    def first_epub(self):
        return self.first_ebook('epub')

    def first_pdf_url(self):
        try:
            url = self.first_ebook('pdf').url
            return url
        except:
            return None

    def first_epub_url(self):
        try:
            url = self.first_ebook('epub').url
            return url
        except:
            return None

    def first_ebook(self, ebook_format=None):
        if ebook_format:
            for ebook in self.ebooks().filter(format=ebook_format):
                return ebook
        else:
            for ebook in self.ebooks():
                return ebook

    def wished_by(self):
        return User.objects.filter(wishlist__works__in=[self])

    def update_num_wishes(self):
        self.num_wishes = self.wishes.count()
        self.save()

    def priority(self):
        if self.last_campaign():
            return 5
        freedom = 1 if self.is_free else 0
        wishing = int(math.log(self.num_wishes)) + 1 if self.num_wishes else 0
        return min(freedom + wishing, 5)

    def first_oclc(self):
        if self.preferred_edition is None:
            return ''
        preferred_id = self.preferred_edition.oclc
        if preferred_id:
            return preferred_id
        try:
            return self.identifiers.filter(type='oclc')[0].value
        except IndexError:
            return ''

    def first_isbn_13(self):
        if self.preferred_edition is None:
            return ''
        preferred_id = self.preferred_edition.isbn_13
        if preferred_id:
            return preferred_id
        try:
            return self.identifiers.filter(type='isbn')[0].value
        except IndexError:
            return ''

    @property
    def earliest_publication_date(self):
        for edition in Edition.objects.filter(work=self, publication_date__isnull=False).order_by('publication_date'):
            if edition.publication_date and len(edition.publication_date) >= 4:
                return edition.publication_date

    @property
    def publication_date(self):
        if self.publication_range:
            return  self.publication_range
        for edition in Edition.objects.filter(work=self, publication_date__isnull=False).order_by('publication_date'):
            if edition.publication_date:
                try:
                    earliest_publication = edition.publication_date[:4]
                except IndexError:
                    continue
                latest_publication = None
                for edition in Edition.objects.filter(work=self, publication_date__isnull=False).order_by('-publication_date'):
                    if edition.publication_date:
                        try:
                            latest_publication = edition.publication_date[:4]
                        except IndexError:
                            continue
                        break
                if earliest_publication == latest_publication:
                    publication_range = earliest_publication
                else:
                    publication_range = earliest_publication + "-" + latest_publication
                self.publication_range = publication_range
                self.save()
                return publication_range
        return ''

    @property
    def has_unglued_edition(self):
        """
        allows us to distinguish successful campaigns with ebooks still in progress from successful campaigns with ebooks available
        """
        if self.ebooks().filter(edition__unglued=True):
            return True
        return False

    @property
    def user_with_rights(self):
        """
        return queryset of users (should be at most one) who act for rights holders with active claims to the work
        """
        claims = self.claim.filter(status='active')
        assert claims.count() < 2, "There is more than one active claim on %r" % self.title
        try:
            return claims[0].user
        except:
            return False

    def get_absolute_url(self):
        return reverse('work', args=[str(self.id)])

    def publishers(self):
        # returns a set of publishers associated with this Work
        return Publisher.objects.filter(name__editions__work=self).distinct()

    def create_offers(self):
        for choice in OFFER_CHOICES:
            if not self.offers.filter(license=choice[0]):
                self.offers.create(license=choice[0], active=True, price=Decimal(10))
        return self.offers.all()

    def get_lib_license(self, user):
        lib_user = (lib.user for lib in user.profile.libraries)
        return self.get_user_license(lib_user)

    def borrowable(self, user):
        if user.is_anonymous():
            return False
        lib_license = self.get_lib_license(user)
        if lib_license and lib_license.borrowable:
            return True
        return False

    def lib_thanked(self, user):
        if user.is_anonymous():
            return False
        lib_license = self.get_lib_license(user)
        if lib_license and lib_license.thanked:
            return True
        return False

    def in_library(self, user):
        if user.is_anonymous():
            return False
        lib_license = self.get_lib_license(user)
        if lib_license and lib_license.acqs.count():
            return True
        return False

    @property
    def lib_acqs(self):
        return  self.acqs.filter(license=LIBRARY)

    @property
    def test_acqs(self):
        return  self.acqs.filter(license=TESTING).order_by('-created')

    class user_license:
        acqs = Identifier.objects.none() # Identifier is just convenient.
        def __init__(self, acqs):
            self.acqs = acqs

        @property
        def is_active(self):
            return  self.acqs.filter(expires__isnull=True).count() > 0 or self.acqs.filter(expires__gt=now()).count() > 0

        @property
        def borrowed(self):
            loans = self.acqs.filter(license=BORROWED, expires__gt=now())
            if loans.count() == 0:
                return None
            else:
                return loans[0]

        @property
        def purchased(self):
            purchases = self.acqs.filter(license=INDIVIDUAL, expires__isnull=True)
            if purchases.count() == 0:
                return None
            else:
                return purchases[0]

        @property
        def lib_acqs(self):
            return  self.acqs.filter(license=LIBRARY)

        @property
        def next_acq(self):
            """ This is the next available copy in the user's libraries"""
            loans = self.acqs.filter(license=LIBRARY, refreshes__gt=now()).order_by('refreshes')
            if loans.count() == 0:
                return None
            else:
                return loans[0]

        @property
        def borrowable(self):
            return  self.acqs.filter(license=LIBRARY, refreshes__lt=now()).count() > 0

        @property
        def thanked(self):
            return  self.acqs.filter(license=THANKED).count() > 0

        @property
        def borrowable_acq(self):
            for acq in self.acqs.filter(license=LIBRARY, refreshes__lt=now()):
                return acq

        @property
        def is_duplicate(self):
            # does user have two individual licenses?
            pending = self.acqs.filter(license=INDIVIDUAL, expires__isnull=True, gifts__used__isnull=True).count()
            return self.acqs.filter(license=INDIVIDUAL, expires__isnull=True).count() > pending


    def get_user_license(self, user):
        """ This is all the acqs, wrapped in user_license object for the work, user(s) """
        if user is None:
            return None
        if hasattr(user, 'is_anonymous'):
            if user.is_anonymous():
                return None
            return self.user_license(self.acqs.filter(user=user))
        else:
            # assume it's several users
            return self.user_license(self.acqs.filter(user__in=user))

    @property
    def has_marc(self):
        for record in  NewMARC.objects.filter(edition__work=self):
            return True
        return False

    ### for compatibility with MARC output
    def marc_records(self):
        record_list = []
        record_list.extend(NewMARC.objects.filter(edition__work=self))
        for obj in record_list:
            break
        else:
            for ebook in self.ebooks():
                record_list.append(ebook.edition)
                break
        return record_list

class WorkRelation(models.Model):
    to_work = models.ForeignKey('Work', related_name='works_related_to')
    from_work= models.ForeignKey('Work', related_name='works_related_from')
    relation = models.CharField(max_length=15, choices=TEXT_RELATION_CHOICES)


class Author(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    name = models.CharField(max_length=255, unique=True)
    editions = models.ManyToManyField("Edition", related_name="authors", through="Relator")

    def __unicode__(self):
        return self.name

    @property
    def last_name_first(self):
        names = self.name.rsplit()
        if len(names) == 0:
            return ''
        elif len(names) == 1:
            return names[0]
        elif len(names) == 2:
            return names[1] + ", " + names[0]
        else:
            reversed_name = names[-1]+","
            for name in names[0:-1]:
                reversed_name += " "
                reversed_name += name
            return reversed_name

class Relation(models.Model):
    code = models.CharField(max_length=3, blank=False, db_index=True, unique=True)
    name = models.CharField(max_length=30, blank=True,)

class Relator(models.Model):
    relation = models.ForeignKey('Relation', default=1) #first relation should have code='aut'
    author = models.ForeignKey('Author')
    edition = models.ForeignKey('Edition', related_name='relators')
    class Meta:
        db_table = 'core_author_editions'

    @property
    def name(self):
        if self.relation.code == 'aut':
            return self.author.name
        else:
            return "%s (%s)" % (self.author.name, self.relation.name)

    def set(self, relation_code):
        if self.relation.code != relation_code:
            try:
                self.relation = Relation.objects.get(code=relation_code)
                self.save()
            except Relation.DoesNotExist:
                logger.warning("relation not found: code = %s" % relation_code)

class Subject(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    name = models.CharField(max_length=200, unique=True)
    works = models.ManyToManyField("Work", related_name="subjects")
    is_visible = models.BooleanField(default=True)
    authority = models.CharField(max_length=10, blank=False, default="")

    class Meta:
        ordering = ['name']

    def __unicode__(self):
        return self.name


    @property
    def kw(self):
        return 'kw.%s' % self.name

    def free_works(self):
        return self.works.filter(is_free=True)

class Edition(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    title = models.CharField(max_length=1000)
    publisher_name = models.ForeignKey("PublisherName", related_name="editions", null=True)
    publication_date = models.CharField(max_length=50, null=True, blank=True, db_index=True,)
    work = models.ForeignKey("Work", related_name="editions", null=True)
    cover_image = models.URLField(null=True, blank=True)
    unglued = models.BooleanField(default=False)
    note = models.ForeignKey("EditionNote", null=True)

    def __unicode__(self):
        if self.isbn_13:
            return "%s (ISBN %s) %s" % (self.title, self.isbn_13, self.publisher)
        if self.oclc:
            return "%s (OCLC %s) %s" % (self.title, self.oclc, self.publisher)
        if self.googlebooks_id:
            return "%s (GOOG %s) %s" % (self.title, self.googlebooks_id, self.publisher)
        else:
            return "%s (GLUE %s) %s" % (self.title, self.id, self.publisher)

    def cover_image_large(self):
        #550 pixel high image
        if self.cover_image:
            im = get_thumbnail(self.cover_image, 'x550', crop='noop', quality=95)
            if im.exists():
                return im.url
        elif self.googlebooks_id:
            url = "https://encrypted.google.com/books?id=%s&printsec=frontcover&img=1&zoom=0" % self.googlebooks_id
            im = get_thumbnail(url, 'x550', crop='noop', quality=95)
            if not im.exists() or im.storage.size(im.name) == 16392: # check for "image not available" image
                url = "https://encrypted.google.com/books?id=%s&printsec=frontcover&img=1&zoom=1" % self.googlebooks_id
                im = get_thumbnail(url, 'x550', crop='noop', quality=95)
            if im.exists():
                return im.url
            else:
                return ''
        else:
            return ''

    def cover_image_small(self):
        #80 pixel high image
        if self.cover_image:
            im = get_thumbnail(self.cover_image, 'x80', crop='noop', quality=95)
            if im.exists():
                return im.url
        if self.googlebooks_id:
            return "https://encrypted.google.com/books?id=%s&printsec=frontcover&img=1&zoom=5" % self.googlebooks_id
        else:
            return ''

    def cover_image_thumbnail(self):
        #128 pixel wide image
        if self.cover_image:
            im = get_thumbnail(self.cover_image, '128', crop='noop', quality=95)
            if im.exists():
                return im.url
        if self.googlebooks_id:
            return "https://encrypted.google.com/books?id=%s&printsec=frontcover&img=1&zoom=1" % self.googlebooks_id
        else:
            return ''

    def has_cover_image(self):
        if self.cover_image:
            return self.cover_image
        elif self.googlebooks_id:
            return True
        else:
            return False

    @property
    def publisher(self):
        if self.publisher_name:
            return self.publisher_name.name
        return ''

    @property
    def isbn_10(self):
        return regluit.core.isbn.convert_13_to_10(self.isbn_13)

    def id_for(self, type):
        if not self.pk:
            return ''
        try:
            return self.identifiers.filter(type=type)[0].value
        except IndexError:
            return ''

    @property
    def isbn_13(self):
        return self.id_for('isbn')

    @property
    def googlebooks_id(self):
        return self.id_for('goog')

    @property
    def librarything_id(self):
        return self.id_for('thng')

    @property
    def oclc(self):
        return self.id_for('oclc')

    @property
    def doi(self):
        return self.id_for('doi')

    @property
    def goodreads_id(self):
        return self.id_for('gdrd')

    @property
    def http_id(self):
        return self.id_for('http')

    @staticmethod
    def get_by_isbn(isbn):
        if len(isbn) == 10:
            isbn = regluit.core.isbn.convert_10_to_13(isbn)
        try:
            return Identifier.objects.get(type='isbn', value=isbn).edition
        except Identifier.DoesNotExist:
            return None

    def add_author(self, author_name, relation='aut'):
        if author_name:
            (author, created) = Author.objects.get_or_create(name=author_name)
            (relation, created) = Relation.objects.get_or_create(code=relation)
            (new_relator, created) = Relator.objects.get_or_create(author=author, edition=self)
            if new_relator.relation != relation:
                new_relator.relation = relation
                new_relator.save()

    def remove_author(self, author):
        if author:
            try:
                relator = Relator.objects.get(author=author, edition=self)
                relator.delete()
            except Relator.DoesNotExist:
                pass

    def set_publisher(self, publisher_name):
        if publisher_name and publisher_name != '':
            try:
                pub_name = PublisherName.objects.get(name=publisher_name)
                if pub_name.publisher:
                    pub_name = pub_name.publisher.name
            except PublisherName.DoesNotExist:
                pub_name = PublisherName.objects.create(name=publisher_name)
                pub_name.save()

            self.publisher_name = pub_name
            self.save()

    #### following methods for compatibility with marc outputter
    def downloads(self):
        return self.ebooks.filter(active=True)

    def download_via_url(self):
        return settings.BASE_URL_SECURE + reverse('download', args=[self.work.id])

    def authnames(self):
        return [auth.last_name_first for auth in self.authors.all()]

    @property
    def license(self):
        try:
            return self.ebooks.all()[0].rights
        except:
            return None

    @property
    def funding_info(self):
        if self.ebooks.all().count() == 0:
            return ''
        if self.unglued:
            return 'The book is available as a free download thanks to the generous support of interested readers and organizations, who made donations using the crowd-funding website Unglue.it.'
        else:
            if self.ebooks.all()[0].rights in cc.LICENSE_LIST:
                return 'The book is available as a free download thanks to a Creative Commons license.'
            else:
                return 'The book is available as a free download because it is in the Public Domain.'

    @property
    def description(self):
        return self.work.description

class EditionNote(models.Model):
    note = models.CharField(max_length=64, null=True, blank=True, unique=True)
    def __unicode__(self):
        return self.note

class Publisher(models.Model):
    created = models.DateTimeField(auto_now_add=True)
    name = models.ForeignKey('PublisherName', related_name='key_publisher')
    url = models.URLField(max_length=1024, null=True, blank=True)
    logo_url = models.URLField(max_length=1024, null=True, blank=True)
    description = models.TextField(default='', null=True, blank=True)

    def __unicode__(self):
        return self.name.name

class PublisherName(models.Model):
    name = models.CharField(max_length=255, blank=False, unique=True)

    publisher = models.ForeignKey('Publisher', related_name='alternate_names', null=True)

    def __unicode__(self):
        return self.name

    def save(self, *args, **kwargs):
        super(PublisherName, self).save(*args, **kwargs) # Call the "real" save() method.
        if self.publisher and self != self.publisher.name:
            #this name is an alias, repoint all editions with this name to the other.
            for edition in Edition.objects.filter(publisher_name=self):
                edition.publisher_name = self.publisher.name
                edition.save()


class WasWork(models.Model):
    work = models.ForeignKey('Work')
    was = models.IntegerField(unique=True)
    moved = models.DateTimeField(auto_now_add=True)
    user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True)

def safe_get_work(work_id):
    """
    use this rather than querying the db directly for a work by id
    """
    try:
        work = Work.objects.get(id=work_id)
    except Work.DoesNotExist:
        try:
            work = WasWork.objects.get(was=work_id).work
        except WasWork.DoesNotExist:
            raise Work.DoesNotExist()
    except ValueError:
        #work_id is not a number
        raise Work.DoesNotExist()
    return work

def path_for_file(instance, filename):
    return "ebf/{}.{}".format(uuid.uuid4().get_hex(), instance.format)

class EbookFile(models.Model):
    file = models.FileField(upload_to=path_for_file)
    format = models.CharField(max_length=25, choices=settings.FORMATS)
    edition = models.ForeignKey('Edition', related_name='ebook_files')
    created = models.DateTimeField(auto_now_add=True)
    asking = models.BooleanField(default=False)

    def check_file(self):
        if self.format == 'epub':
            return test_epub(self.file)
        return None

    @property
    def active(self):
        try:
            return Ebook.objects.filter(url=self.file.url)[0].active
        except:
            return False

send_to_kindle_limit = 7492232

class Ebook(models.Model):
    url = models.URLField(max_length=1024) #change to unique?
    created = models.DateTimeField(auto_now_add=True, db_index=True,)
    format = models.CharField(max_length=25, choices=settings.FORMATS)
    provider = models.CharField(max_length=255)
    download_count = models.IntegerField(default=0)
    active = models.BooleanField(default=True)
    filesize = models.PositiveIntegerField(null=True)
    version = models.CharField(max_length=255, null=True)

    # use 'PD-US', 'CC BY', 'CC BY-NC-SA', 'CC BY-NC-ND', 'CC BY-NC', 'CC BY-ND', 'CC BY-SA', 'CC0'
    rights = models.CharField(max_length=255, null=True, choices=cc.CHOICES, db_index=True)
    edition = models.ForeignKey('Edition', related_name='ebooks')
    user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True)

    def kindle_sendable(self):
        if not self.filesize or self.filesize < send_to_kindle_limit:
            return True
        else:
            return False

    def get_archive(self): # returns an archived file
        if self.edition.ebook_files.filter(format=self.format).count() == 0:
            if self.provider is not 'Unglue.it':
                try:
                    r = urllib2.urlopen(self.url)
                    try:
                        self.filesize = int(r.info().getheaders("Content-Length")[0])
                        if self.save:
                            self.filesize = self.filesize if self.filesize < 2147483647 else 2147483647  # largest safe positive integer
                            self.save()
                        ebf = EbookFile.objects.create(edition=self.edition, format=self.format)
                        ebf.file.save(path_for_file(ebf, None), ContentFile(r.read()))
                        ebf.file.close()
                        ebf.save()
                        ebf.file.open()
                        return ebf.file
                    except IndexError:
                        # response has no Content-Length header probably a bad link
                        logging.error('Bad link error: {}'.format(self.url))
                except IOError:
                    logger.error(u'could not open {}'.format(self.url))
            else:
                # this shouldn't happen, except in testing perhaps
                logger.error(u'couldn\'t find ebookfile for {}'.format(self.url))
                # try the url instead
                f = urllib.urlopen(self.url)
                return f
        else:
            ebf = self.edition.ebook_files.filter(format=self.format).order_by('-created')[0]
            try:
                ebf.file.open()
            except ValueError:
                logger.error(u'couldn\'t open EbookFile {}'.format(ebf.id))
                return None
            except IOError:
                logger.error(u'EbookFile {} does not exist'.format(ebf.id))
                return None
            return ebf.file

    def set_provider(self):
        self.provider = Ebook.infer_provider(self.url)
        return self.provider

    @property
    def rights_badge(self):
        if self.rights is None:
            return cc.CCLicense.badge('PD-US')
        return cc.CCLicense.badge(self.rights)

    @staticmethod
    def infer_provider(url):
        if not url:
            return None
        # provider derived from url. returns provider value. remember to call save() afterward
        if re.match(r'https?://books.google.com/', url):
            provider = 'Google Books'
        elif re.match(r'https?://www.gutenberg.org/', url):
            provider = 'Project Gutenberg'
        elif re.match(r'https?://(www\.|)archive.org/', url):
            provider = 'Internet Archive'
        elif url.startswith('http://hdl.handle.net/2027/') or url.startswith('http://babel.hathitrust.org/'):
            provider = 'Hathitrust'
        elif re.match(r'https?://\w\w\.wikisource\.org/', url):
            provider = 'Wikisource'
        elif re.match(r'https?://\w\w\.wikibooks\.org/', url):
            provider = 'Wikibooks'
        elif re.match(r'https://github\.com/[^/ ]+/[^/ ]+/raw/[^ ]+', url):
            provider = 'Github'
        else:
            provider = None
        return provider

    def increment(self):
        Ebook.objects.filter(id=self.id).update(download_count=F('download_count') +1)

    @property
    def download_url(self):
        return settings.BASE_URL_SECURE + reverse('download_ebook', args=[self.id])

    def is_direct(self):
        return self.provider not in ('Google Books', 'Project Gutenberg')

    def __unicode__(self):
        return "%s (%s from %s)" % (self.edition.title, self.format, self.provider)

    def deactivate(self):
        self.active = False
        self.save()

    def activate(self):
        self.active = True
        self.save()

def set_free_flag(sender, instance, created, **kwargs):
    if created:
        if not instance.edition.work.is_free and instance.active:
            instance.edition.work.is_free = True
            instance.edition.work.save()
    elif not instance.active and instance.edition.work.is_free and instance.edition.work.ebooks().count() == 0:
        instance.edition.work.is_free = False
        instance.edition.work.save()
    elif instance.active and not instance.edition.work.is_free and instance.edition.work.ebooks().count() > 0:
        instance.edition.work.is_free = True
        instance.edition.work.save()

post_save.connect(set_free_flag, sender=Ebook)

def reset_free_flag(sender, instance, **kwargs):
    # if the Work associated with the instance Ebook currenly has only 1 Ebook, then it's no longer a free Work
    # once the instance Ebook is deleted.
    if instance.edition.work.ebooks().count() == 1:
        instance.edition.work.is_free = False
        instance.edition.work.save()

pre_delete.connect(reset_free_flag, sender=Ebook)