worblehat-old/python/web/library/models.py

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 __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)
	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)