apps/oai/handlers.py

   1 from oaipmh import server, common, metadata, error
   2 from catalogue.models import Book, Tag
   3 from api.models import Deleted
   4 from api.handlers import WL_BASE
   5 from librarian.dcparser import BookInfo
   6 from django.contrib.contenttypes.models import ContentType
   7 from django.contrib.auth.models import User
   8 from datetime import datetime
   9 from lxml import etree
  10 from lxml.etree import ElementTree
  11 from django.db.models import Q
  12 from django.conf import settings
  13 from django.contrib.sites.models import Site
  14
  15
  16 wl_dc_reader = metadata.MetadataReader(
  17     fields={
  18     'title':       ('textList', 'rdf:RDF/rdf:Description/dc:title/text()'),
  19     'creator':     ('textList', 'rdf:RDF/rdf:Description/dc:creator/text()'),
  20     'subject':     ('textList', 'rdf:RDF/rdf:Description/dc:subject.period/text() | rdf:RDF/rdf:Description/dc:subject.type/text() | rdf:RDF/rdf:Description/dc:subject.genre/text()'),
  21     'description': ('textList', 'rdf:RDF/rdf:Description/dc:description/text()'),
  22     'publisher':   ('textList', 'rdf:RDF/rdf:Description/dc:publisher/text()'),
  23     'contributor': ('textList', 'rdf:RDF/rdf:Description/dc:contributor.editor/text() | rdf:RDF/rdf:Description/dc:contributor.translator/text() | rdf:RDF/rdf:Description/dc:contributor.technical_editor/text()'),
  24     'date':        ('textList', 'rdf:RDF/rdf:Description/dc:date/text()'),
  25     'type':        ('textList', 'rdf:RDF/rdf:Description/dc:type/text()'),
  26     'format':      ('textList', 'rdf:RDF/rdf:Description/dc:format/text()'),
  27     'identifier':  ('textList', 'rdf:RDF/rdf:Description/dc:identifier.url/text()'),
  28     'source':      ('textList', 'rdf:RDF/rdf:Description/dc:source/text()'),
  29     'language':    ('textList', 'rdf:RDF/rdf:Description/dc:language/text()'),
  30     'isPartOf':     ('textList', 'rdf:RDF/rdf:Description/dc:relation.isPartOf/text()'),
  31     'hasPart':     ('textList', 'rdf:RDF/rdf:Description/dc:relation.hasPart/text()'),
  32     #    'relation':    ('textList', 'rdf:RDF/rdf:Description/dc:relation/text()'),
  33     #    'coverage':    ('textList', 'rdf:RDF/rdf:Description/dc:coverage/text()'),
  34     'rights':      ('textList', 'rdf:RDF/rdf:Description/dc:rights/text()')
  35     },
  36     namespaces={
  37     'dc': 'http://purl.org/dc/elements/1.1/',
  38     'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'}
  39     )
  40
  41
  42 class Catalogue(common.ResumptionOAIPMH):
  43     TAG_CATEGORIES = ['author', 'epoch', 'kind', 'genre']
  44
  45     def __init__(self, metadata_registry):
  46         super(Catalogue, self).__init__()
  47         self.metadata_registry = metadata_registry
  48
  49         self.oai_id = "oai:"+Site.objects.get_current().domain+":%s"
  50
  51         # earliest change
  52         year_zero = datetime(1990, 1, 1, 0, 0, 0)
  53
  54         try:
  55             earliest_change = \
  56                 Book.objects.order_by('changed_at')[0].changed_at
  57         except: earliest_change = year_zero
  58
  59         try:
  60             earliest_delete = \
  61                 Deleted.objects.exclude(slug__exact=u'').ordery_by('deleted_at')[0].deleted_at
  62         except: earliest_delete = year_zero
  63
  64         self.earliest_datestamp = earliest_change <= earliest_delete and \
  65             earliest_change or earliest_delete
  66
  67     def metadata(self, book):
  68         try:
  69             xml = etree.parse(book.xml_file)
  70         finally:
  71             book.xml_file.close()
  72         md = wl_dc_reader(xml)
  73         return md.getMap()
  74
  75     def record_for_book(self, book, headers_only=False):
  76         meta = None
  77         identifier = self.slug_to_identifier(book.slug)
  78         if isinstance(book, Book):
  79             #            setSpec = map(self.tag_to_setspec, book.tags.filter(category__in=self.TAG_CATEGORIES))
  80             header = common.Header(identifier, book.changed_at, [], False)
  81             if not headers_only:
  82                 meta = common.Metadata(self.metadata(book))
  83             about = None
  84         elif isinstance(book, Deleted):
  85             header = common.Header(identifier, book.deleted_at, [], True)
  86             if not headers_only:
  87                 meta = common.Metadata({})
  88             about = None
  89         if headers_only:
  90             return header
  91         return header, meta, about
  92
  93     def identify(self, **kw):
  94         ident = common.Identify(
  95             'Wolne Lektury',  # generate
  96             '%s/oaipmh' % WL_BASE,  # generate
  97             '2.0',  # version
  98             [m[1] for m in settings.MANAGERS],  # adminEmails
  99             self.earliest_datestamp,  # earliest datestamp of any change
 100             'persistent',  # deletedRecord
 101             'YYYY-MM-DDThh:mm:ssZ',  # granularity
 102             ['identity'],  # compression
 103             []  # descriptions
 104             )
 105         return ident
 106
 107     def books(self, tag, from_, until):
 108         if tag:
 109             # we do not support sets, since they are problematic for deleted books.
 110             raise errror.NoSetHierarchyError("Wolne Lektury does not support sets.")
 111             # books = Book.tagged.with_all([tag])
 112         else:
 113             books = Book.objects.all()
 114         deleted = Deleted.objects.exclude(slug__exact=u'')
 115
 116         books = books.order_by('changed_at')
 117         deleted = deleted.order_by('deleted_at')
 118         if from_:
 119             books = books.filter(changed_at__gte=from_)
 120             deleted = deleted.filter(deleted_at__gte=from_)
 121         if until:
 122             books = books.filter(changed_at__lte=until)
 123             deleted = deleted.filter(deleted_at__lte=until)
 124         return list(books) + list(deleted)
 125
 126     @staticmethod
 127     def tag_to_setspec(tag):
 128         return "%s:%s" % (tag.category, tag.slug)
 129
 130     @staticmethod
 131     def setspec_to_tag(s):
 132         if not s: return None
 133         cs = s.split(':')
 134         if len(cs) == 2:
 135             if not cs[0] in Catalogue.TAG_CATEGORIES:
 136                 raise error.NoSetHierarchyError("No category part in set")
 137             tag = Tag.objects.get(slug=cs[1], category=cs[0])
 138             return tag
 139         raise error.NoSetHierarchyError("Setspec should have two components: category:slug")
 140
 141     def getRecord(self, **kw):
 142         """
 143 Returns (header, metadata, about) for given record.
 144         """
 145         slug = self.identifier_to_slug(kw['identifier'])
 146         try:
 147             book = Book.objects.get(slug=slug)
 148             return self.record_for_book(book)
 149         except Book.DoesNotExist:
 150             book_type = ContentType.objects.get_for_model(Book)
 151             try:
 152                 deleted_book = Deleted.objects.get(content_type=book_type,
 153                                                   slug=slug)
 154             except:
 155                 raise error.IdDoesNotExistError("No item for this identifier")
 156             return self.record_for_book(deleted_book)
 157
 158     def validate_kw(self, kw):
 159         if 'resumptionToken' in kw:
 160             raise error.BadResumptionTokenError("No resumption token support at this point")
 161         if 'metadataPrefix' in kw and not self.metadata_registry.hasWriter(kw['metadataPrefix']):
 162             raise error.CannotDisseminateFormatError("This format is not supported")
 163
 164     def identifier_to_slug(self, ident):
 165         return ident.split(':')[-1]
 166
 167     def slug_to_identifier(self, slug):
 168         return self.oai_id % slug
 169
 170     def listIdentifiers(self, **kw):
 171         self.validate_kw(kw)
 172         records = [self.record_for_book(book, headers_only=True) for
 173                    book in self.books(None,
 174                            kw.get('from_', None),
 175                            kw.get('until', None))]
 176         return records, None
 177
 178     def listRecords(self, **kw):
 179         """
 180 can get a resumptionToken kw.
 181 returns result, token
 182         """
 183         self.validate_kw(kw)
 184         records = [self.record_for_book(book) for
 185                    book in self.books(None,
 186                            kw.get('from_', None),
 187                            kw.get('until', None))]
 188
 189         return records, None
 190
 191     def listMetadataFormats(self, **kw):
 192         formats = [('oai_dc',
 193                  'http://www.openarchives.org/OAI/2.0/oai_dc.xsd',
 194                  server.NS_OAIDC)]
 195         if 'identifier' in kw:
 196             slug = self.identifier_to_slug(kw['identifier'])
 197             try:
 198                 b = Book.objects.get(slug=slug)
 199                 return formats
 200             except:
 201                 try:
 202                     d = Deleted.objects.get(slug=slug)
 203                     return []
 204                 except:
 205                     raise error.IdDoesNotExistError("This id does not exist")
 206         else:
 207             return formats
 208
 209     def listSets(self, **kw):
 210         raise error.NoSetHierarchyError("Wolne Lektury does not support sets.")
 211         # tags = []
 212         # for category in Catalogue.TAG_CATEGORIES:
 213         #     for tag in Tag.objects.filter(category=category):
 214         #         tags.append(("%s:%s" % (tag.category, tag.slug),
 215         #                      tag.name,
 216         #                      tag.description))
 217         # return tags, None
 218
 219