regluit/core/facets.py

from django.apps import apps
from django.contrib.auth.models import User
from django.db.models import Q
from regluit.core import cc

class BaseFacet(object):
    facet_name = 'all'
    model_filters ={}
    
    def __init__(self, outer_facet):
        self.outer_facet = outer_facet if outer_facet else None
        self.model = apps.get_model('core', 'Work')
    
    def _get_query_set(self):
        if self.outer_facet:
            return self.outer_facet.get_query_set()
        else:
            return self.model.objects.filter(is_free=True)

    def _filter_model(self, model, query_set):
        if self.outer_facet:
            return self.outer_facet.filter_model(model, query_set)
        else:
            return query_set
    
    def __unicode__(self):
        if self.facet_name == 'all':
            return 'Free eBooks'
        return unicode(self.facet_name)
    
    @property    
    def title(self):
        return self.__unicode__()
    
    @property    
    def label(self):
        return self.__unicode__()
    
    def get_query_set(self):
        return self._get_query_set()

    def filter_model(self, model, query_set):
        model_filter =  self.model_filters.get(model,None) 
        if model_filter:
            return model_filter( self._filter_model(model, query_set))
        else:
            return self._filter_model( model, query_set)

    def get_facet_path(self):
        if self.outer_facet:
            return self.outer_facet.get_facet_path() + self.facet_name + '/'
        else:
            return self.facet_name + '/'
            
    def facets(self):
        facets=[self]
        if self.outer_facet:
            facets= self.outer_facet.facets() + facets
        return facets

    def context(self):
        return {}
    
    def template(self):
        return 'facets/default.html'
    
    _stash_others = None
    def get_other_groups(self):
        if self._stash_others != None:
            return self._stash_others
        others = []
        used = self.facets()
        for group in facet_groups:
            in_use = False
            for facet in used:
                if group.has_facet(facet.facet_name) :
                    in_use = True
                    break
            if not in_use:
                others.append(group)
        self._stash_others=others
        return others

    @property
    def description(self):
        return self.__unicode__()
        
class FacetGroup(object):
    # a FacetGroup should implement title, facets, has_facet(self, facet_name) and get_facet_class(self, facet_name)
        
    def has_facet(self, facet_name):
        return facet_name in self.facets
        
    def get_facets(self):
        for facet_name in self.facets:
            yield self.get_facet_class(facet_name)(None)
    
class NamedFacet(BaseFacet):
    # set_name() must be defined in classes implementing NamedFacet
    def __init__(self, outer_facet):
        super(NamedFacet, self).__init__( outer_facet )
        self.set_name() 
    
class FormatFacetGroup(FacetGroup):
    
    def __init__(self):
        super(FacetGroup,self).__init__()
        self.title = 'Format'
        self.facets = ['pdf', 'epub', 'mobi']
        self.label = '{} is ...'.format(self.title)
    
    def get_facet_class(self, facet_name):
        class FormatFacet(NamedFacet):
            def set_name(self):
                self.facet_name=facet_name
            def format_filter(query_set):
                return query_set.filter(format=facet_name)
            def edition_format_filter(query_set):
                return query_set.filter(ebooks__format=facet_name)
            model_filters = {"Ebook": format_filter, "Edition": edition_format_filter}
            def get_query_set(self):
                return self._get_query_set().filter(editions__ebooks__format=self.facet_name)
            def template(self):
                return 'facets/format.html'
            @property
            def title(self):
                return "eBooks available in format: " + self.facet_name
            @property
            def description(self):
                return  "These eBooks available in %s format." % self.facet_name
        return FormatFacet    

idtitles = {'doab': 'indexed in DOAB', 'gtbg':'available in Project Gutenberg', 
            '-doab': 'not in DOAB', '-gtbg':'not from Project Gutenberg', }
idlabels = {'doab': 'DOAB', 'gtbg':'Project Gutenberg', 
            '-doab': 'not DOAB', '-gtbg':'not Project Gutenberg'}
class IdFacetGroup(FacetGroup):
    def __init__(self):
        super(FacetGroup,self).__init__()
        self.title = 'Collection'
        self.facets = idtitles.keys()
        self.label = 'Included in ...'        
    
    def get_facet_class(self, facet_name):
        class IdFacet(NamedFacet):
            def set_name(self):
                self.facet_name=facet_name
            def id_filter(query_set):
                if facet_name[0] == '-':
                    return query_set.exclude(identifiers__type=facet_name[1:])
                else:
                    return query_set.filter(identifiers__type=facet_name)
            model_filters = {}
            def get_query_set(self):
                if facet_name[0] == '-':
                    return self._get_query_set().exclude(identifiers__type=self.facet_name[1:])
                else:
                    return self._get_query_set().filter(identifiers__type=self.facet_name)
            def template(self):
                return 'facets/id.html'
            @property    
            def label(self):
                return idlabels[self.facet_name]
            @property
            def title(self):
                return idtitles[self.facet_name]
            @property
            def description(self):
                return  "These eBooks are {}.".format(idtitles[self.facet_name])
        return IdFacet    
        
        
class LicenseFacetGroup(FacetGroup):
    def __init__(self):
        super(FacetGroup,self).__init__()
        self.title = 'License'
        self.licenses = cc.LICENSE_LIST_ALL
        self.facets = cc.FACET_LIST
        self.label = '{} is ...'.format(self.title)
        
        
    def get_facet_class(self, facet_name):
        class LicenseFacet(NamedFacet):            
            def set_name(self):
                self.facet_name=facet_name
                self.license = cc.ccinfo(facet_name)
            def license_filter(query_set):
                return query_set.filter(rights=cc.ccinfo(facet_name))
            def edition_license_filter(query_set):
                return query_set.filter(ebooks__rights=cc.ccinfo(facet_name))
            model_filters = {"Ebook": license_filter, "Edition": edition_license_filter}
            def get_query_set(self):
                return self._get_query_set().filter(editions__ebooks__rights=self.license.license)
            def template(self):
                return 'facets/license.html'
            def context(self):
                return   {
                    'license': self.license,
                    }
            def label(self):
                return self.license.__str__()
            @property
            def title(self):
                return "license: " + self.license.title
            @property
            def description(self):
                return  "These eBooks are available under the %s license." % self.facet_name
        return LicenseFacet

TOPKW = ["Fiction", "Nonfiction", "Literature",  "History", "Classic Literature", 
    "Children's literature, English", "History and criticism", "Science", "Juvenile fiction", 
    "Sociology", "Software", "Science Fiction"]

class KeywordFacetGroup(FacetGroup):
    
    def __init__(self):
        super(FacetGroup,self).__init__()
        self.title = 'Keyword'
        # make facets in TOPKW available for display
        self.facets = [('kw.%s' % kw) for kw in TOPKW]
        self.label = '{} is ...'.format(self.title)
        
    def has_facet(self, facet_name):
    
        # recognize any facet_name that starts with "kw." as a valid facet name
        return facet_name.startswith('kw.')

    def get_facet_class(self, facet_name):
        class KeywordFacet(NamedFacet):
            def set_name(self):
                self.facet_name=facet_name
                # facet_names of the form 'kw.SUBJECT' and SUBJECT is therefore the 4th character on
                self.keyword=self.facet_name[3:].replace(';', '/')
            def get_query_set(self):
                return self._get_query_set().filter(subjects__name=self.keyword)
            def template(self):
                return 'facets/keyword.html'
            @property    
            def title(self):
                return self.keyword
            @property    
            def label(self):
                return self.keyword
            @property
            def description(self):
                return  "%s eBooks" % self.keyword
        return KeywordFacet    

class SearchFacetGroup(FacetGroup):
    
    def __init__(self):
        super(FacetGroup,self).__init__()
        self.title = 'Search Term'
        # make facets in TOPKW available for display
        self.facets = []
        self.label = '{} is ...'.format(self.title)
        
    def has_facet(self, facet_name):
    
        # recognize any facet_name that starts with "s." as a valid facet name
        return facet_name.startswith('s.')

    def get_facet_class(self, facet_name):
        class KeywordFacet(NamedFacet):
            def set_name(self):
                self.facet_name=facet_name
                # facet_names of the form 's.SUBJECT' and SUBJECT is therefore the 3rd character on
                self.term=self.facet_name[2:]
            def get_query_set(self):
                return self._get_query_set().filter(
                    Q(title__icontains=self.term) | 
                    Q(editions__authors__name__icontains=self.term) | 
                    Q(subjects__name__iexact=self.term)
                    )
                 
            def template(self):
                return 'facets/search.html'
            @property    
            def title(self):
                return self.term
            @property    
            def label(self):
                return self.term
            @property
            def description(self):
                return  "eBooks for {}".format(self.term)
        return KeywordFacet    

class SupporterFacetGroup(FacetGroup):
    
    def __init__(self):
        super(FacetGroup,self).__init__()
        self.title = 'Supporter Faves'
        # make facets in TOPKW available for display
        self.facets = []
        self.label = '{} are ...'.format(self.title)
        
    def has_facet(self, facet_name):
    
        # recognize any facet_name that starts with "@" as a valid facet name
        return facet_name.startswith('@')

    def get_facet_class(self, facet_name):
        class SupporterFacet(NamedFacet):
            def set_name(self):
                self.facet_name = facet_name
                self.username = self.facet_name[1:]
                try:
                    user = User.objects.get(username=self.username)
                    self.fave_set = user.wishlist.works.all()
                except User.DoesNotExist:
                    self.fave_set = self.model.objects.none()
            
            def get_query_set(self):
                return self._get_query_set().filter(pk__in=self.fave_set)
                 
            def template(self):
                return 'facets/supporter.html'

            @property
            def description(self):
                return  "eBooks faved by @{}".format(self.username)
        return SupporterFacet    
   
class PublisherFacetGroup(FacetGroup):
    
    def __init__(self):
        super(FacetGroup,self).__init__()
        self.title = 'Publisher'
        # don't display facets
        self.facets = []
        self.label = 'Published by ...'

    def has_facet(self, facet_name):
    
        # recognize any facet_name that starts with "pub." as a valid facet name
        return facet_name.startswith('pub.')

    def get_facet_class(self, facet_name):
        class PublisherFacet(NamedFacet):
            def set_name(self):
                self.facet_name=facet_name
                # facet_names of the form 'pub.PUB_ID' and PUB_ID is therefore the 5th character on
                self.pub_id=self.facet_name[4:]
                pubmodel = apps.get_model('core', 'Publisher')
                try:
                    self.publisher =  pubmodel.objects.get(id=self.pub_id)
                except pubmodel.DoesNotExist:
                    self.publisher =  None
                except ValueError: # pub_id is not a number
                    self.publisher =  None
            def pub_filter(query_set):
                return query_set.filter(edition__publisher_name__publisher__id=facet_name[4:])
            def edition_pub_filter(query_set):
                return query_set.filter(publisher_name__publisher__id=facet_name[4:])
            model_filters = {"Ebook": pub_filter, "Edition": edition_pub_filter }
            def get_query_set(self):
                return self._get_query_set().filter(editions__publisher_name__publisher=self.publisher)
            def template(self):
                return 'facets/publisher.html'
            @property    
            def title(self):
                return self.publisher.name.name if self.publisher else ""
            @property    
            def label(self):
                return self.publisher.name.name if self.publisher else ""
            @property
            def description(self):
                return  "eBooks published by %s" % self.title
        return PublisherFacet    

# order of groups in facet_groups determines order of display on /free/    
facet_groups = [KeywordFacetGroup(), FormatFacetGroup(),  LicenseFacetGroup(), PublisherFacetGroup(), IdFacetGroup(), SearchFacetGroup(), SupporterFacetGroup()]

def get_facet(facet_name):
    for facet_group in facet_groups:
        if facet_group.has_facet(facet_name):
            return facet_group.get_facet_class(facet_name)
    return BaseFacet

def get_all_facets(group='all'):
    facets=[]
    for facet_group in facet_groups:
        if group == 'all' or facet_group.title == group:
            facets = facets + facet_group.facets
    return facets

def get_facet_object(facet_path):
    facets = facet_path.replace('//','/').strip('/').split('/')
    facet_object = None
    for facet in facets:
        facet_object = get_facet(facet)(facet_object)
    return facet_object

order_by_keys = {
    'newest':['-featured', '-created'],
    'oldest':['created'],
    'featured':['-featured', '-num_wishes'],
    'popular':['-num_wishes'],
    'title':['title'],
    'none':[], #no ordering 
}   
           
def get_order_by(order_by_key):
    # return the args to use as arguments for order_by
    return order_by_keys.get(order_by_key,'')