306 lines
9.8 KiB
Python
306 lines
9.8 KiB
Python
from django.db import models
|
|
import web.library.fileformat
|
|
|
|
book_fields = [('title' , 'Title'), ('isbn' , 'ISBN'), ('id.id' , 'Identifier'),
|
|
('subtitle' , 'Subtitle'), ('category' , 'Category'), ('publisher' , 'Publisher'),
|
|
('published_year' , 'Published year'), ('edition' , 'Edition'), ('num_pages' , 'Number of pages'),
|
|
('series' , 'Series'), ('description' , 'Description')]
|
|
|
|
|
|
|
|
class Category(models.Model):
|
|
id = models.CharField(max_length=255, primary_key=True)
|
|
name = models.CharField(max_length=255)
|
|
|
|
def to_string(self):
|
|
str = 'category %s\nName: %s\n' % (self.id, self.name)
|
|
str += 'Placement: %s\n' % self.placements_str()
|
|
str += 'Books:\n'
|
|
for book in self.books.all():
|
|
str += ' %-13s %-10s %s\n' % (book.isbn, book.getid() or '', book.title)
|
|
if len(self.books.all()) == 0:
|
|
str += ' (no books in this category)\n'
|
|
return str
|
|
|
|
def to_dict(self):
|
|
return { 'action': 'edit-category',
|
|
'id': self.id, 'name': self.name,
|
|
'placement': self.placements_str() }
|
|
|
|
def placements_str(self):
|
|
return ', '.join(map(lambda pl: pl.shelf, self.placement.all()))
|
|
|
|
def __unicode__(self):
|
|
return self.name
|
|
|
|
class BookSeries(models.Model):
|
|
id = models.CharField(max_length=20, primary_key=True)
|
|
title = models.CharField(max_length=511)
|
|
|
|
def __unicode__(self):
|
|
return self.title
|
|
|
|
class ReferenceType(models.Model):
|
|
name = models.CharField(max_length=31)
|
|
|
|
def __unicode__(self):
|
|
return self.name
|
|
|
|
class Book(models.Model):
|
|
isbn = models.CharField(max_length=13, primary_key=True)
|
|
# id = models.CharField(max_length=255)
|
|
title = models.CharField(max_length=511)
|
|
subtitle = models.CharField(max_length=511, null=True, blank=True)
|
|
category = models.ForeignKey(Category, null=True, blank=True, related_name='books')
|
|
publisher = models.CharField(max_length=255, null=True, blank=True)
|
|
published_year = models.IntegerField(null=True, blank=True)
|
|
edition = models.IntegerField(null=True, blank=True)
|
|
num_pages = models.IntegerField(null=True, blank=True)
|
|
series = models.ForeignKey(BookSeries, related_name='books', null=True, blank=True)
|
|
description = models.CharField(max_length=1023, null=True, blank=True)
|
|
picture = models.ImageField(upload_to='pictures', null=True, blank=True)
|
|
thumbnail = models.ImageField(upload_to='thumbnails', null=True, blank=True)
|
|
# references = models.ManyToManyField(Reference, related_name='books',null=True, blank=True)
|
|
|
|
#Generate a string from book info
|
|
def to_string(self, commit=False):
|
|
scratch = ''
|
|
if commit:
|
|
# generate commit string by sending self.to_dict to fileformat function
|
|
print fileformat.write_action(self.to_dict())
|
|
|
|
else:
|
|
if self.getid():
|
|
scratch = 'book %s %s\n' % (self.isbn, self.getid())
|
|
else:
|
|
scratch = 'book %s\n' % self.isbn
|
|
scratch += 'Title: %s\n' % self.title
|
|
if self.subtitle:
|
|
scratch += 'Subtitle: %s\n' % self.subtitle
|
|
scratch += 'ISBN: %s\n' % self.isbn
|
|
scratch += 'Persons:\n'
|
|
for bp in self.persons.all():
|
|
scratch += ' %s %s %s (%s)\n' % (bp.person.id,
|
|
bp.person.first_name, bp.person.last_name,
|
|
bp.relation)
|
|
if len(self.persons.all()) == 0:
|
|
scratch += ' (no persons associated with this book)\n'
|
|
if self.series: scratch += 'Part of series: %s %s\n' % (self.series.id, self.series.title)
|
|
scratch += 'Category: %s\n' % self.category.id
|
|
if self.publisher: scratch += 'Publisher: %s\n' % self.publisher
|
|
if self.published_year: scratch += 'Published year: %s\n' % self.published_year
|
|
if self.edition: scratch += 'Edition: %s\n' % self.edition
|
|
if self.num_pages: scratch += 'Number of pages: %s\n' % self.num_pages
|
|
if self.description:
|
|
scratch += 'Description:\n%s\n' % '\n'.join(map(lambda line: ' '+line,
|
|
self.description.split('\n')))
|
|
|
|
return scratch
|
|
|
|
def to_dict(self):
|
|
dict = {}
|
|
dict['action'] = 'edit-book'
|
|
|
|
dict['isbn'] = self.isbn
|
|
dict['title'] = self.title
|
|
dict['category'] = self.category.id
|
|
dict['subtitle'] = self.subtitle
|
|
dict['publisher'] = self.publisher
|
|
dict['published_year'] = self.published_year
|
|
dict['edition'] = self.edition
|
|
dict['num_pages'] = self.num_pages
|
|
if self.series:
|
|
dict['series'] = self.series.id
|
|
else:
|
|
dict['series'] = ''
|
|
dict['description'] = self.description
|
|
|
|
people = self.persons.all()
|
|
dict['persons'] = {}
|
|
for bookperson in people:
|
|
person = bookperson.person
|
|
if bookperson.relation.name in dict['persons']:
|
|
dict['persons'][bookperson.relation.name].append(person.id)
|
|
else:
|
|
dict['persons'][bookperson.relation.name] = [person.id]
|
|
|
|
dict['references'] = {}
|
|
for reference in self.references.all():
|
|
if reference.reference_type.name in dict['references']:
|
|
dict['references'][reference.reference_type.name].append(reference.text)
|
|
else:
|
|
dict['references'][reference.reference_type.name] = [reference.text]
|
|
|
|
#TODO: add thumbnail and image fields
|
|
|
|
return dict
|
|
|
|
|
|
def getid(self):
|
|
try:
|
|
if self.id:
|
|
return self.id.id
|
|
except Id.DoesNotExist:
|
|
pass
|
|
return None
|
|
|
|
def setid(self,newid):
|
|
try:
|
|
if self.id:
|
|
self.id.delete()
|
|
except Id.DoesNotExist:
|
|
pass
|
|
newid = Id(book=self,id=newid)
|
|
newid.save()
|
|
|
|
def get_authors(self):
|
|
people = self.persons.all()
|
|
authors = []
|
|
for person in people:
|
|
if person.relation.name == 'Author':
|
|
authors.append(person.person)
|
|
return authors
|
|
|
|
def get_persons(self, relation):
|
|
return map(lambda bp: bp.person,
|
|
filter(lambda bp: bp.relation.name == relation,
|
|
self.persons.all()))
|
|
|
|
def __unicode__(self):
|
|
return self.title
|
|
|
|
# def print(self):
|
|
# print '%13s %5s %30s %'
|
|
|
|
# class Meta:
|
|
# order_with_respect_to = 'published_year'
|
|
# unique_together=(("isbn","id"),)
|
|
|
|
class Reference(models.Model):
|
|
book = models.ForeignKey(Book, related_name='references')
|
|
reference_type = models.ForeignKey(ReferenceType)
|
|
text = models.CharField(max_length=1023)
|
|
|
|
def __unicode__(self):
|
|
return self.text
|
|
|
|
class Id(models.Model):
|
|
id = models.CharField(max_length=511, primary_key=True)
|
|
book = models.OneToOneField(Book)
|
|
|
|
def __unicode__(self):
|
|
return self.id
|
|
|
|
class AlternativeTitle(models.Model):
|
|
book = models.ForeignKey(Book, related_name='alt_titles')
|
|
alt_title = models.CharField(max_length=511)
|
|
def __unicode__(self):
|
|
return self.book.title+"="+self.alt_title
|
|
|
|
class Copy(models.Model):
|
|
book = models.ForeignKey(Book, related_name='copies')
|
|
number = models.IntegerField()
|
|
owner = models.CharField(max_length=9)
|
|
def __unicode__(self):
|
|
return self.book.title+" "+str(self.number)+" "+self.owner
|
|
|
|
class Person(models.Model):
|
|
id = models.CharField(max_length=255, primary_key=True)
|
|
first_name = models.CharField(max_length=255)
|
|
last_name = models.CharField(max_length=255)
|
|
references = models.ManyToManyField(Reference, related_name='persons', null=True, blank=True)
|
|
|
|
def to_string(self, commit=False):
|
|
if commit:
|
|
#generate commit-string
|
|
print fileformat.write_action(self.to_dict())
|
|
else:
|
|
scratch = 'person %s\n' % self.id
|
|
scratch += 'Name: %s %s\n' % (self.first_name, self.last_name)
|
|
scratch += 'Books:\n'
|
|
for bp in self.books.all():
|
|
scratch += ' %s %s (%s)\n' % (bp.book.isbn, bp.book.title, bp.relation.name)
|
|
if len(self.books.all()) == 0:
|
|
scratch += ' (no books associated with this person)\n'
|
|
|
|
return scratch
|
|
|
|
def to_dict(self):
|
|
dict = {}
|
|
dict['action'] = 'edit-person'
|
|
dict['id'] = self.id
|
|
dict['first_name'] = self.first_name
|
|
dict['last_name'] = self.last_name
|
|
|
|
return dict
|
|
|
|
|
|
def __unicode__(self):
|
|
return self.first_name + u' ' + self.last_name
|
|
|
|
# class Meta:
|
|
# order_with_respect_to = 'last_name'
|
|
|
|
class Relation(models.Model):
|
|
name = models.CharField(max_length=31, primary_key=True)
|
|
|
|
def __unicode__(self):
|
|
return self.name
|
|
|
|
class BookPerson(models.Model):
|
|
book = models.ForeignKey(Book, related_name='persons')
|
|
person = models.ForeignKey(Person, related_name='books')
|
|
relation = models.ForeignKey(Relation)
|
|
|
|
def __unicode__(self):
|
|
return self.person.first_name +u' '+ self.person.last_name+ u' '+ self.relation.name+ u' of '+self.book.title
|
|
|
|
class Placement(models.Model):
|
|
category = models.ForeignKey(Category, related_name='placement')
|
|
shelf = models.CharField(max_length=10)
|
|
|
|
def __unicode__(self):
|
|
return self.category.name+" at "+self.shelf
|
|
|
|
def as_list(self):
|
|
shelf = self.shelf
|
|
return [self.category, shelf[0], int(shelf[1]), int(shelf[2])]
|
|
|
|
def get_shelf(self):
|
|
return self.shelf[0]
|
|
|
|
def get_row(self):
|
|
return int(self.shelf[2])
|
|
|
|
def get_column(self):
|
|
return int(self.shelf[1])
|
|
|
|
@staticmethod
|
|
def shelf_as_list(shelfname):
|
|
placements = Placement.objects.filter(shelf__startswith=shelfname)
|
|
rows = max(map(lambda x: x.get_row(), placements))
|
|
columns = max(map(lambda x: x.get_column(), placements))
|
|
shelf_list = [ [[] for i in xrange(rows+1)] for j in xrange(columns+1)]
|
|
for placement in placements:
|
|
shelf_list[placement.get_column()][placement.get_row()].append(placement.category)
|
|
return shelf_list
|
|
|
|
@staticmethod
|
|
def shelf_as_list_row_then_col(shelfname):
|
|
placements = Placement.objects.filter(shelf__startswith=shelfname)
|
|
rows = max(map(lambda x: x.get_row(), placements))
|
|
columns = max(map(lambda x: x.get_column(), placements))
|
|
shelf_list = [ [[] for i in xrange(columns+1)] for j in xrange(rows+1)]
|
|
for placement in placements:
|
|
shelf_list[placement.get_row()][placement.get_column()].append(placement.category)
|
|
return shelf_list
|
|
|
|
@staticmethod
|
|
def get_all_shelves():
|
|
shelves = set()
|
|
for item in Placement.objects.all():
|
|
shelves.add(item.get_shelf())
|
|
return list(shelves)
|
|
|
|
|