class Book(db.Model):
__table_args__ = (db.UniqueConstraint('name', 'lang', 'version'), {
"mysql_charset": "utf8mb4"
})
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
lang = db.Column(db.String(20))
version = db.Column(db.Integer)
cover = db.Column(db.Integer)
desc = db.Column(db.Text)
def __init__(self, name, lang, version, cover, desc):
self.name = name
self.lang = lang
self.version = version
self.cover = cover
self.desc = desc
def __repr__(self):
return '<Book %r>' % self.id
def to_dict(self):
return {
"id": self.id,
"name": self.name,
"language": self.lang,
"version": self.version,
"desc": self.desc,
"cover": ""
}
class User(db.Model):
__tablename__ = 'user__user'
id = col(db.Integer, primary_key=True)
email = col(db.String(100), unique=True)
password = col(db.Text)
roles = col(db.Text)
is_active = col(db.Boolean, default=True)
db.UniqueConstraint(email)
@property
def rolenames(self):
try:
return self.roles.split(',')
except Exception:
return []
@classmethod
def lookup(cls, email):
return cls.query.filter_by(email=email).one_or_none()
@classmethod
def identify(cls, id):
return cls.query.get(id)
@property
def identity(self):
return self.id
def is_valid(self):
return self.is_active
class ColorScheme(db.Model):
__tablename__ = 'colorscheme'
id = db.Column(db.Integer, primary_key=True)
hex = db.Column(db.String(255), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
shift_category_id = db.Column(db.Integer,
db.ForeignKey('shiftcategory.id'),
nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
__table_args__ = (db.UniqueConstraint('user_id',
'shift_category_id',
name='_user_color_scheme_uc'), )
def __repr__(self):
user = session.query(User).filter(
User.id == self.user_id).one_or_none()
shiftcategory = session.query(ShiftCategory).filter(
ShiftCategory.id == self.shift_category_id).one_or_none()
return '{}({})({})'.format(self.hex, user.name, shiftcategory.name)
class LockedHour(db.Model):
_tablename_ = 'LockedHour'
__table_args__ = (db.UniqueConstraint('dayId',
'hour',
name='unique_day_hour'), )
id = db.Column(db.String, unique=True, primary_key=True)
dayId = db.Column(db.String)
ownerId = db.Column(db.String)
hour = db.Column(db.String)
shortDescription = db.Column(db.String)
scheduleType = db.Column(db.Integer)
def __repr__(self):
return "id: {}, dayId: {}, ownerId: {}, hour: {}, shortDescription: {}, scheduleType" \
.format(self.id, self.dayId, self.ownerId, self.hour, self.shortDescription, self.scheduleType)
def toDict(self):
return dict(
zip([
"id", "dayId", "ownerId", "hour", "shortDescription",
"scheduleType"
], self.toList()))
def toList(self):
return [
self.id, self.dayId, self.ownerId, self.hour,
self.shortDescription, self.scheduleType
]
class THCMeasurement(db.Model):
"""
THCMeasurement stores the number of answers for red, yellow and green for
one question asked to one team in one session of Team Health Check.
A whole session of Team Health Check done with one team would therefore
produce several of these measurements - one for each question.
"""
__tablename__ = "m_thc"
# Primary key
pk = db.Column(db.Integer, primary_key=True)
# UUID for measurement
measurement_id = db.Column(UUID(as_uuid=True),
unique=True,
nullable=False,
default=uuid4)
# Date of measurement
measurement_date = db.Column(db.DateTime, nullable=False)
# Name of the session (to group with other team's results)
session_name = db.Column(db.String, nullable=False)
# Team and question ID
team_id = db.Column(db.Integer, db.ForeignKey("teams.team_id"))
question_id = db.Column(db.Integer,
db.ForeignKey("res_thc_questions.question_id"))
# Result
result_red = db.Column(db.Integer)
result_yellow = db.Column(db.Integer)
result_green = db.Column(db.Integer)
# Relationship to team
team = db.relationship("Team")
# Relationship to question
question = db.relationship("THCQuestion")
# The triple (session, team, question) makes the measurement unique:
__table_args__ = (db.UniqueConstraint(session_name, team_id,
question_id), )
def __repr__(self):
return (
"<THCMeasurement: measurement_id={}, measurement_date={}, session_name={}, team_id={}, "
"question_id={}, result_red={}, result_yellow={}, result_green={}>"
.format(
self.measurement_id,
self.measurement_date,
self.session_name,
self.team_id,
self.question_id,
self.result_red,
self.result_yellow,
self.result_green,
))
class Follow(db.Model):
__tablename__ = 'follow'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=True,
default=None,
unique=True)
follow_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=True,
default=None)
user = db.relationship("User", foreign_keys=[user_id])
follow = db.relationship("User", foreign_keys=[follow_id])
__table_args__ = (db.UniqueConstraint('user_id',
'follow_id',
name='_user_follow_uc'), )
class StatusCategoryStatusMapping(db.Model):
__tablename__ = "status_category_status_mappings"
id = db.Column(db.Integer, primary_key=True, nullable=False)
activity_id = db.Column(db.Integer,
db.ForeignKey("activities.activity_id"),
nullable=True)
status = db.Column(db.String, nullable=False)
status_category = db.Column(db.Enum(StatusCategory), nullable=False)
activity = db.relationship("Activity", backref="status_mappings")
__table_args__ = (
db.UniqueConstraint("activity_id", "status"),
db.Index(
"ix_status_activity_id_null",
"status",
unique=True,
postgresql_where=(activity_id.is_(None)),
),
)
class BurndownMeasurement(db.Model):
__tablename__ = "m_burndown"
pk = db.Column(db.Integer, primary_key=True)
measurement_id = db.Column(UUID(as_uuid=True),
unique=True,
nullable=False,
default=uuid4)
measurement_date = db.Column(db.DateTime, nullable=False)
activity_id = db.Column(db.Integer,
db.ForeignKey("activities.activity_id"))
sprint_id = db.Column(db.Integer, db.ForeignKey("sprints.sprint_id"))
sp_not_done = db.Column(db.Integer)
sp_added = db.Column(db.Integer, default=0)
sp_swapped = db.Column(db.Integer, default=0)
# Relationship to sprint
sprint = db.relationship("Sprint")
# Relationship to activity
activity = db.relationship("Activity")
# TODO: Relationship to team
# A burndown-measurement is unique per sprint and measurement datetime
__table_args__ = (db.UniqueConstraint(measurement_date, sprint_id), )
def __repr__(self):
return (
"<BurndownMeasurement: measurement_id={}, measurement_date={}, sprint_id={}, "
"sp_not_done={}, sp_added={}, sp_swapped={}".format(
self.measurement_id,
self.measurement_date,
self.sprint_id,
self.sp_not_done,
self.sp_added,
self.sp_swapped,
))
class Office(db.Model):
__tablename__ = 'office'
id = db.Column(db.Integer, primary_key=True)
cp_id = db.Column(db.String(10),
db.ForeignKey('congressperson.id'),
nullable=False)
city = db.Column(db.String(100), nullable=False)
phone = db.Column(db.String(10), nullable=True)
info_json = db.Column(db.String(2048), nullable=True)
__table_args__ = (db.UniqueConstraint("cp_id", "city"), )
@property
def info(self):
try:
self.__info
except AttributeError:
self.__info = json.loads(self.info_json)
return self.__info
@info.setter
def info(self, info):
self.__info = info
self.info_json = json.dumps(self.__info)
class Checkout(db.Model):
id = db.Column(db.Integer, primary_key=True)
checkout_date = db.Column(db.DateTime, nullable=False, default=func.now())
return_date = db.Column(db.DateTime)
book_id = db.Column(db.Integer, db.ForeignKey('book.id'))
book = db.relationship('Book',
backref=db.backref('checkout', lazy='dynamic'))
room_id = db.Column(db.Integer, db.ForeignKey('room.id'))
room = db.relationship('Room',
backref=db.backref('checkout', lazy='dynamic'))
person_id = db.Column(db.Integer, db.ForeignKey('person.id'))
person = db.relationship('Person',
backref=db.backref('chekout', lazy='dynamic'))
__table_args__ = (db.UniqueConstraint('book_id',
'checkout_date',
name='_one_checkout_at_a_time'), )
def __repr__(self):
return '<Checkout Book ID=%r to room=%r from %s to %s>' % (
self.book.id, self.room.id, self.checkout_date, self.return_date)
class Book(db.Model):
id = db.Column(db.Integer, primary_key=True)
isbn13 = db.Column(db.String(13))
inside_cover_id = db.Column(db.String(30))
title = db.Column(db.String)
description = db.Column(db.String)
thumbnail_url = db.Column(db.String)
date_added = db.Column(db.DateTime, default=func.now())
#TODO: status
__table_args__ = (db.UniqueConstraint('isbn13',
'inside_cover_id',
name='_isbn_coverid_uc'), )
def __repr__(self):
return '<Book id=%s, isbn13=%r, inside_cover_id=%r, date_added=%s, title=%r>' % (
self.id, self.isbn13, self.inside_cover_id, self.date_added,
self.title)
def append_google_book_data(self):
if not self.isbn13:
raise ValueError('No isbn13')
google_data = google_books_info(self.isbn13)
self.title = google_data['title']
self.description = google_data['description']
self.thumbnail_url = google_data['imageLinks']['thumbnail']
# allow chaining
return self
@property
def is_available(self):
"""True if available, ie true if not currently checked out. False otherwise."""
return self.checkout.filter(Checkout.return_date == None).count() == 0
def open_checkout(self):
"""Returns the open Checkout for this book, or None if there's no open checkouts."""
return self.checkout.filter(Checkout.return_date == None).scalar()
def last_checked_out(self):
"""Date last checked out, or None if never checked out.
Doesn't tell you anything about whether it's available or not."""
return db.session.query(func.max(
Checkout.checkout_date)).filter_by(book_id=self.id).scalar()
def teaser(self, chars=120):
"""Teaser text for description"""
# TODO: this should probably be a macro or something, it's not specific to this text field only
if self.description:
return self.description[:chars]
@validates('isbn13')
def validate_isbn(self, key, isbn_raw):
"""Convert to stripped ISBN13, validating in the process"""
# raises InvalidIsbn if bad
return toI13(isbn_raw)
@validates('thumbnail_url')
def validate_optional_img_url(self, key, url):
if url is None:
return None
return normalize_url(url)