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 oysteini function
			print self.to_dict()
			print fileformat.write_action(self.to_dict())

		else:
			format = '%-15s: %50s \n'
			for field in book_fields:
				try:
					scratch += format % (field[1],eval('self.'+field[0]))
				except Id.DoesNotExist:
					scratch += format % (field[1], "None")
				except AttributeError:
					scratch += format % (field[1], '')
			authors = ', '.join(map(unicode, self.get_authors()))
			scratch += format % ('Authors', authors) 
#			scratch += 'Authors'.ljust(15, ' ') + ':'
#			scratch += authors.rjust(51, ' ')

		return scratch 

	def to_dict(self):
			dict = {}
			dict['action'] = 'edit-book'
			for field in book_fields:
				try:
					dict[field[0]] = eval('self.'+field[0])
				except AttributeError:
					dict[field[0]] = ' '
			
			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):
		if self.id:
			return self.id.id
		return None

	def setid(self,newid):
		if self.id:
			self.id.delete()
		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 __unicode__(self):
		return self.title

#	def print(self):
#		print '%13s %5s %30s %'

#	class Meta:
#		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 self.to_dict() 
		else:
			format = '%-10s: %50s \n'   				
			scratch = format % ('Name', ' '.join((self.first_name, self.last_name)))
			scratch += format % ('ID', self.id)

			books = ', '.join(map(lambda x: x.book.title, self.books.all()))
			scratch += format % ('Books', books)

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