class Printer(UserTags):
__tablename__ = "printers"
company_id = db.Column(db.Integer,
db.ForeignKey("book_companies.id",
name="printer_book_company_fk1",
ondelete="CASCADE"),
primary_key=True,
nullable=False)
book_id = db.Column(db.Integer,
db.ForeignKey("books.id",
name="printer_book_fk1",
ondelete="CASCADE"),
primary_key=True,
nullable=False)
company = relationship("BookCompany")
book = relationship("Book")
def __init__(self, **kwargs):
self.book = kwargs["book"]
self.book_id = self.book.id
self.company = kwargs["company"]
self.company_id = self.company.id
self.creator = kwargs["creator"]
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.creator.id
class Pseudonym(Base, UserTags):
"""
Copied from original schema:
Is this table ever going into any use?
"""
__tablename__ = "pseudonyms"
person_id = db.Column(db.Integer,
db.ForeignKey("contributors.id",
name="pseudonym_book_person_fk1",
ondelete="CASCADE"),
primary_key=True)
book_id = db.Column(db.Integer,
db.ForeignKey("books.id",
name="pseudonym_book_fk1",
ondelete="CASCADE"),
primary_key=True)
# Pseudonyms are weird so only require the last!
lastname = db.Column(db.String(255, collation="utf8_bin"), nullable=False)
firstname = db.Column(db.String(255, collation="utf8_bin"), nullable=True)
person = relationship("Contributor")
book = relationship("Book")
def __init__(self, **kwargs):
self.person = kwargs["person"]
self.person_id = self.person.id
self.book = kwargs["book"]
self.book_id = self.book.id
self.lastname = kwargs["lastname"]
self.firstname = kwargs["firstname"]
self.creator = kwargs["creator"]
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.creator.id
class Imprint(Base, UserTags):
__tablename__ = "imprints"
mother_company_id = db.Column(
db.Integer,
db.ForeignKey("book_companies.id",
name="imprint_book_company_fk1",
ondelete="CASCADE"))
imprint_company_id = db.Column(
db.Integer,
db.ForeignKey("book_companies.id",
name="imprint_book_company_fk2",
ondelete="CASCADE"))
mother_company = relationship("BookCompany",
foreign_keys="Imprint.mother_company_id")
imprint_company = relationship("BookCompany",
foreign_keys="Imprint.imprint_company_id")
def __init__(self, **kwargs):
self.mother_company = kwargs["mother_company"]
self.mother_company_id = self.mother_company.id
self.imprint_company = kwargs["imprint_company"]
self.imprint_company_id = self.imprint_company.id
self.creator = kwargs["creator"]
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.creator.id
class BookContribution(Base, UserTags):
"""
Consider that 99% of books will need the same roles over and over.
"""
__tablename__ = "book_contributions"
book_id = db.Column(
db.Integer,
db.ForeignKey("books.id",
name="book_participant_book_fk1",
ondelete="CASCADE"))
contributor_id = db.Column(
db.Integer,
db.ForeignKey("contributors.id",
name="book_participant_book_person_fk1",
ondelete="CASCADE"))
role_id = db.Column(
db.Integer,
db.ForeignKey("roles.id",
name="book_participant_role_fk1",
ondelete="CASCADE"))
active = db.Column(db.Boolean,
nullable=False,
default=True,
server_default=db.false())
book = relationship("Book")
contributor = relationship("Contributor")
role = relationship("Role")
creator = relationship("Librarian",
foreign_keys="BookContribution.creator_id")
last_modifier = relationship(
"Librarian", foreign_keys="BookContribution.last_modifier_id")
def __init__(self, **kwargs):
self.book = kwargs["book"]
self.book_id = self.book.id
self.contributor = kwargs["contributor"]
self.contributor_id = self.contributor.id
self.role = kwargs["role"]
self.role_id = self.role.id
self.active = kwargs.get("active", True)
self.creator = kwargs["creator"]
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.creator.id
def __str__(self):
return "Person %s worked on book %s as the role %s" % \
(str(self.contributor), str(self.book), str(self.role))
def __repr__(self):
return str(self)
def __eq__(self, other):
return (self.book_id == other.book_id
and self.contributor_id == other.contributor_id
and self.role_id == other.role_id)
def __hash__(self):
return hash((self.book_id, self.contributor_id, self.role_id))
class Role(Base, UserTags):
"""
The purpose of this table is to enumerate the contributions we are interested
in for the books.
The name is for the actual contribution we are interested in while
display_text is for how it is prompted for in the app's forms.
"""
__tablename__ = "roles"
name = db.Column(db.String(255, collation="utf8_bin"),
unique=True,
nullable=False)
display_text = db.Column(db.String(255, collation="utf8_bin"),
nullable=False)
creator = relationship("Librarian", foreign_keys="Role.creator_id")
last_modifier = relationship("Librarian",
foreign_keys="Role.last_modifier_id")
def __init__(self, **kwargs):
self.name = kwargs["name"]
self.display_text = kwargs["display_text"]
self.creator = kwargs["creator"]
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.creator.id
@staticmethod
def get_preset_role(role_name):
role = Role.query.filter_by(
id=Role.get_preset_role_id(role_name)).first()
return role
@staticmethod
@cache.memoize(app.config["FOREVER_TIMEOUT"])
def get_preset_role_id(role_name):
role = Role.query.filter_by(name=role_name).first()
return role.id
def __str__(self):
return "%s (%d)" % (self.name, self.id)
def __repr__(self):
return self.name + "#" + str(self.id)
class UserTags(db.Model):
"""
Those that will extend this class may take the convention that, upon creation,
the last_modifier is the same as the creator.
"""
__abstract__ = True
date_created = db.Column(db.DateTime,
default=db.func.current_timestamp(),
server_default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime,
default=db.func.current_timestamp(),
server_default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
@declared_attr
def creator_id(self):
return db.Column(db.Integer, db.ForeignKey("librarians.id"))
@declared_attr
def last_modifier_id(self):
return db.Column(db.Integer, db.ForeignKey("librarians.id"))
class Contributor(Base, UserTags):
__tablename__ = "contributors"
lastname = db.Column(db.String(255, collation="utf8_bin"), nullable=False)
firstname = db.Column(db.String(255, collation="utf8_bin"), nullable=False)
active = db.Column(db.Boolean,
nullable=False,
default=True,
server_default=db.false())
creator = relationship("Librarian", foreign_keys="Contributor.creator_id")
last_modifier = relationship("Librarian",
foreign_keys="Contributor.last_modifier_id")
__table_args__ = (db.UniqueConstraint("lastname",
"firstname",
name="uname"), )
def __init__(self, **kwargs):
self.lastname = kwargs["lastname"]
self.firstname = kwargs["firstname"]
self.creator = kwargs["creator"]
self.active = kwargs.get("active", True)
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.creator.id
def __str__(self):
return str({
"id": self.id,
"lastname": self.lastname,
"firstname": self.firstname
})
def __repr__(self):
return self.__str__()
def make_plain_person(self):
return Person(lastname=self.lastname, firstname=self.firstname)
class Genre(Base, UserTags):
__tablename__ = "genres"
name = db.Column(db.String(40, collation="utf8_bin"),
nullable=False,
unique=True)
creator = relationship("Librarian", foreign_keys="Genre.creator_id")
last_modifier = relationship("Librarian",
foreign_keys="Genre.last_modifier_id")
def __init__(self, **kwargs):
self.name = kwargs["name"]
self.creator = kwargs["creator"]
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.creator.id
class BookCompany(Base, UserTags):
"""
List?! List?! This is better off in NoSQL form!
"""
__tablename__ = "book_companies"
name = db.Column(db.String(255, collation="utf8_bin"),
nullable=False,
unique=True)
creator = relationship("Librarian", foreign_keys="BookCompany.creator_id")
last_modifier = relationship("Librarian",
foreign_keys="BookCompany.last_modifier_id")
def __init__(self, **kwargs):
self.name = kwargs["name"]
self.creator = kwargs["creator"]
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.creator.id
def __str__(self):
return self.name
class Book(Base, UserTags):
__tablename__ = "books"
isbn = db.Column(db.String(13, collation="utf8_bin"),
nullable=False,
unique=True,
index=True)
title = db.Column(db.String(255, collation="utf8_bin"),
nullable=False,
index=True)
genre_id = db.Column(db.Integer,
db.ForeignKey("genres.id", name="book_genre_fk"))
publisher_id = db.Column(
db.Integer,
db.ForeignKey("book_companies.id",
name="book_book_company_fk1",
ondelete="CASCADE"))
publish_year = db.Column(db.Integer,
nullable=False,
default=ISBN_START,
server_default=str(ISBN_START))
comments = db.Column(db.Text, nullable=True)
genre = relationship("Genre")
publisher = relationship("BookCompany")
def __init__(self, **kwargs):
if not isbn_check(kwargs["isbn"]):
raise ConstraintError("Invalid ISBN", self.isbn)
self.publish_year = int(kwargs["publish_year"])
self.isbn = kwargs["isbn"]
self.title = kwargs["title"]
self.genre = kwargs["genre"]
self.genre_id = self.genre.id
self.creator = kwargs["creator"]
self.creator_id = self.creator.id
self.last_modifier = kwargs["creator"]
self.last_modifier_id = self.last_modifier.id
self.publisher = kwargs["publisher"]
self.publisher_id = self.publisher.id
def __str__(self):
return self.title + "/" + self.isbn
def __repr__(self):
return self.title + "/" + self.isbn + "/" + str(self.id)
class Librarian(Base, UserMixin):
__tablename__ = "librarians"
username = db.Column(db.String(50, collation="utf8_bin"),
nullable=False,
unique=True)
password = db.Column(db.String(255, collation="utf8_bin"), nullable=False)
can_read = db.Column(db.Boolean,
nullable=False,
default=False,
server_default=db.false())
can_write = db.Column(db.Boolean,
nullable=False,
default=False,
server_default=db.false())
can_exec = db.Column(db.Boolean,
nullable=False,
default=False,
server_default=db.false())
is_user_active = db.Column(db.Boolean,
nullable=False,
default=True,
server_default=db.true())
def __init__(self, **kwargs):
self.username = kwargs["username"]
self.password = kwargs["password"]
self.can_read = kwargs.get("can_read", False)
self.can_write = kwargs.get("can_write", False)
self.can_exec = kwargs.get("can_exec", False)
self.is_user_active = kwargs.get("is_user_active", True)
def __repr__(self):
return self.username + "/" + str(self.id)
def get_id(self):
return self.id
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
def last_modifier_id(self):
return db.Column(db.Integer, db.ForeignKey("librarians.id"))
def creator_id(self):
return db.Column(db.Integer, db.ForeignKey("librarians.id"))
