src/oai/handlers.py

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