class List(db.Model):
# many-to-one User db model relation
owner = db.relationship('User', back_populates="lists", uselist=False)
owner_id = db.Column(db.Integer, db.ForeignKey('users.id'))
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now, index=True)
list_items = db.relationship('ListItem',
back_populates='list',
lazy='dynamic',
cascade='all, delete-orphan')
purchased_list_items = db.relationship('PurchasedListItem',
back_populates='list',
lazy='dynamic',
cascade='all, delete-orphan')
__tablename__ = 'lists'
def __str__(self):
return ('<{class_name}('
'owner_name={self.owner.name}, '
'name="{self.name}")>'.format(
class_name=self.__class__.__name__, self=self))
class ListItem(db.Model):
list = db.relationship('List', back_populates="list_items")
list_id = db.Column(db.Integer, db.ForeignKey('lists.id'))
product = db.relationship('Product',
back_populates="list_items",
uselist=False)
product_id = db.Column(db.Integer, db.ForeignKey('products.id'))
id = db.Column(db.Integer, primary_key=True)
quantity = db.Column(db.Integer, nullable=False, default=1)
created_at = db.Column(db.DateTime, default=datetime.now, index=True)
purchased_item = db.relationship('PurchasedListItem',
back_populates='list_item',
cascade='all, delete-orphan',
uselist=False)
__tablename__ = 'list_items'
def __str__(self):
return ('<{class_name}('
'name={self.list.name})>'.format(
class_name=self.__class__.__name__, self=self))
def is_purchased(self):
return bool(self.purchased_item)
class StudentInfo(BaseModel, db.Model):
__tablename__ = 'student_info'
id = db.Column(db.Integer, db.ForeignKey('user.id'), primary_key=True)
sexual = db.Column(db.String(10), default='')
location = db.Column(db.String(10))
age = db.Column(db.String(5), default='')
school = db.Column(db.String(20))
grade = db.Column(db.String(20))
study_country = db.Column(db.String(10))
enrollment_time = db.Column(db.String(10), default='')
major = db.Column(db.String(20))
course_name = db.Column(db.String(100))
learn_range = db.Column(db.String(40))
weichat = db.Column(db.String(20), default='')
parent_phone = db.Column(db.String(16))
remark = db.Column(db.String(100), default='')
# file
test1 = db.Column(db.String(20), default='')
score1 = db.Column(db.String(10), default='')
test2 = db.Column(db.String(20), default='')
score2 = db.Column(db.String(10), default='')
test3 = db.Column(db.String(20), default='')
score3 = db.Column(db.String(10), default='')
test4 = db.Column(db.String(20), default='')
score4 = db.Column(db.String(10), default='')
test5 = db.Column(db.String(20), default='')
score5 = db.Column(db.String(10), default='')
admission_school = db.Column(db.String(20), default='')
admission_major = db.Column(db.String(20), default='')
course_tables = db.relationship('CourseTable', backref='student_info', cascade="all, delete-orphan")
feedbacks = db.relationship('StudyFeedback', backref='student_info', cascade="all, delete-orphan")
class User(BaseModel, db.Model, UserMixin):
__tablename__ = 'user'
phone = db.Column(db.String(32), unique=True)
password = db.Column(db.String(48))
chinese_name = db.Column(db.String(20))
english_name = db.Column(db.String(20))
photo_path = db.Column(db.String(255))
update_time = db.Column(db.DateTime, default=datetime.now)
create_time = db.Column(db.DateTime, default=datetime.now)
coursetb_update_time = db.Column(db.DateTime, default=datetime.now)
verify_token = db.Column(db.String(32), default='')
status = db.Column(db.String(10))
roles = db.relationship('Role', secondary=role_user_relationship,
backref=db.backref('users', lazy='dynamic'))
teacher = db.relationship('TeacherInfo', backref='user', uselist=False,
cascade="all, delete-orphan")
student = db.relationship('StudentInfo', backref='user', uselist=False,
cascade="all, delete-orphan")
def __init__(self, chinese_name='', englisth_name='', phone='', password=''):
self.chinese_name = chinese_name
self.english_name = englisth_name
self.phone = phone
self.password = password
self.photo_path = ''
self.status = 'enabled'
@property
def is_active(self):
return True
def get_id(self):
return self.id
class PurchasedListItem(db.Model):
# one-to-one User db model relation
purchased_by = db.relationship('User',
back_populates="purchased_list_items")
purchased_by_id = db.Column(db.Integer, db.ForeignKey('users.id'))
# many-to-one List db model relation
list = db.relationship('List',
back_populates="purchased_list_items",
uselist=False)
list_id = db.Column(db.Integer, db.ForeignKey('lists.id'))
# one-to-one ListItem model relation
list_item = db.relationship('ListItem', back_populates="purchased_item")
list_item_id = db.Column(db.Integer, db.ForeignKey('list_items.id'))
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.now, index=True)
__tablename__ = 'purchased_list_items'
def __str__(self):
return ('<{class_name}('
'name={self.list.name})'
'purchased_by={self.purchased_by.email}>'.format(
class_name=self.__class__.__name__, self=self))
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(140))
announce = db.Column(db.Text)
description = db.Column(db.Text)
created = db.Column(db.DateTime, default=datetime.now())
pub_date = db.Column(db.DateTime, nullable=True, default=datetime.now())
published = db.Column(db.Boolean, default=False)
is_draft = db.Column(db.Boolean, default=True)
tags = db.relationship('Tag',
secondary=post_tags,
backref=db.backref('posts', lazy='dynamic'))
attachments = db.relationship('Attachment',
cascade='all, delete-orphan',
backref='post')
def get_imgurls(self):
pattern = re.compile(r'src\s*=\s*"(.+?)"')
urls = re.findall(pattern, self.description)
return [op.join(basedir, url[1:]) for url in urls]
def assemble_text(self):
pattern = re.compile(r'<.*?>')
message = re.sub(pattern, '', self.description)
tags = ' '.join(['#' + x.title.replace(' ', '_') for x in self.tags])
return '{}\n{}\n{}'.format(self.title, message, tags)
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
def __repr__(self):
return self.title
class User(db.Model):
__tablename__ = 'Users'
Id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
Name = db.Column(db.Text(), nullable=True)
Email = db.Column(db.Text(), nullable=False)
DisplayName = db.Column(db.Text(), nullable=True)
FamilyName = db.Column(db.Text(), nullable=True)
RegistrationDate = db.Column(db.DateTime(), nullable=False)
LastVisit = db.Column(db.DateTime(), nullable=False)
wished_markers = db.relationship('Marker',
secondary=wishlist_markers,
backref='wishers')
owned_markers = db.relationship('Marker',
secondary=my_markers,
backref='owners')
cart_markers = db.relationship('Cart', backref='user')
def to_dict(self):
data = {
'id': self.Id,
'email': self.Email,
'name': self.Name,
'display_name': self.DisplayName,
'family_name': self.FamilyName,
'registration_date': self.RegistrationDate,
'last_visit': self.LastVisit
}
return data
class Todo(db.Model):
__tablename__ = "todo"
id = db.Column(
"id",
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False,
)
category_id = db.Column("category_id",
UUID(as_uuid=True),
db.ForeignKey("category.id"),
nullable=False)
priority_id = db.Column("priority_id",
UUID(as_uuid=True),
db.ForeignKey("priority.id"),
nullable=False)
description = db.Column("description", db.Unicode)
creation_date = db.Column("created_data",
db.DateTime,
default=datetime.datetime.utcnow)
is_done = db.Column("is_done", db.Boolean, default=False)
priority = db.relationship("Priority", foreign_keys=priority_id)
category = db.relationship("Category", foreign_keys=category_id)
class Note(db.Model):
__tablename__ = 'notes'
STATUS_DRAFT = 'draft'
STATUS_PUBLISHED = 'published'
SALE_TYPE_FREE = "free"
SALE_TYPE_PAY_AS_USE = "pay_as_use"
id = db.Column('id', db.String(64), primary_key=True)
user_id = db.Column('user_id', db.ForeignKey("users.id"), nullable=False)
title = db.Column('title', db.String(255))
description = db.Column('description', db.TEXT)
status = db.Column('status', db.String(32), nullable=False)
created_at = db.Column('created_at',
db.DATETIME,
default=datetime.now,
nullable=False)
updated_at = db.Column('updated_at',
db.DATETIME,
default=datetime.now,
onupdate=datetime.now)
user = db.relationship("User",
backref=db.backref("note_user", uselist=False),
lazy='joined')
tags = db.relationship('Tag',
secondary=NoteTag.__tablename__,
backref=db.backref('note_tags', lazy=True),
lazy='subquery')
def __repr__(self):
return "<Note '{}'>".format(self.id)
class Organisation(Base):
TYPE_CHOICE = [
('charity', 'Charity'),
('funder', 'Funder'),
('other', 'Other')
]
name = db.Column(db.String(100), nullable=False)
type = db.Column(ChoiceType(TYPE_CHOICE), nullable=False)
address = db.Column(db.Text(180))
created_by = db.Column(db.Integer, db.ForeignKey('user.id'))
contacts = db.relationship('Contact', backref='organisation')
activities = db.relationship('Activity', backref='contact_lookup')
@staticmethod
def create(**kwargs):
o = Organisation(**kwargs)
db.session.add(o)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
return o
class CommitteeContribution(BaseContribution):
donor_committee_id = db.Column(
db.Integer, db.ForeignKey("committee.id"), nullable=False
)
donor_committee = db.relationship(
"Committee",
foreign_keys=[donor_committee_id],
backref=db.backref("contributions_given", lazy=True),
)
recipient_name = db.Column(db.String)
recipient_city = db.Column(db.String(30))
recipient_state = db.Column(db.String(2))
recipient_zip = db.Column(db.String(9))
recipient_occupation = db.Column(db.String(38))
recipient_employer = db.Column(db.String(38))
other_fec_id = db.Column(db.String(9))
candidate_fec_id = db.Column(db.String(9))
recipient_committee_id = db.Column(db.Integer, db.ForeignKey("committee.id"))
recipient_committee = db.relationship(
"Committee",
foreign_keys=[recipient_committee_id],
backref=db.backref("committee_contributions_received", lazy=True),
)
candidate_id = db.Column(db.Integer, db.ForeignKey("candidate.id"))
candidate = db.relationship(
"Candidate", backref=db.backref("committee_contributions", lazy=True)
)
transaction_fec_id = db.Column(db.String(32))
file_num = db.Column(db.Numeric(22))
memo_cd = db.Column(db.String(1))
memo = db.Column(db.String)
fec_unique_id = db.Column(db.Numeric(19), unique=True, nullable=False)
class Task(db.Model, At, By):
__tablename__ = "Task"
PRIORITY_VALUES = [('low', 'low'), ('medium', 'medium'), ('high', 'high')]
STATUS_VALUES = [('TODO', 'TODO'), ('DOING', 'DOING'), ('DONE', 'DONE')]
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100))
description = db.Column(db.String(1000))
start_date = db.Column(db.Date(), nullable=False)
expected_end_date = db.Column(db.Date(), nullable=True)
actual_end_date = db.Column(db.Date())
task_status = db.Column(ChoiceType(STATUS_VALUES, impl=db.String(5)),
default='TODO',
nullable=True)
priority = db.Column(ChoiceType(PRIORITY_VALUES, impl=db.String(7)),
default='medium')
reporter_id = db.Column(db.Integer, db.ForeignKey('User.id'))
assignee_id = db.Column(db.Integer, db.ForeignKey('User.id'))
team_id = db.Column(db.Integer, db.ForeignKey('Team.id'))
reporter = db.relationship('User',
backref=db.backref('as_reporter'),
primaryjoin="User.id==Task.reporter_id")
assignee = db.relationship('User',
backref=db.backref('as_assignee'),
primaryjoin="User.id==Task.assignee_id")
team = db.relationship('Team', backref=db.backref('tasks', lazy='dynamic'))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), unique=True, index=True, nullable=False)
password = db.Column(db.String(32), nullable=False)
first_name = db.Column(db.String, nullable=False)
last_name = db.Column(db.String, nullable=True)
created_at = db.Column(db.DateTime, default=datetime.now, index=True)
tokens = db.relationship('Token',
back_populates='user',
lazy='dynamic',
cascade='all, delete-orphan')
lists = db.relationship('List',
back_populates='owner',
cascade='all, delete-orphan')
purchased_list_items = db.relationship('PurchasedListItem',
back_populates='purchased_by',
cascade='all, delete-orphan')
__tablename__ = 'users'
def __str__(self):
return ('<{class_name}('
'user_id={self.id}, '
'email="{self.email}")>'.format(
class_name=self.__class__.__name__, self=self))
def set_password(self, password):
self.password = hash_md5(password)
class User(BaseModel, UserMixin):
__tablename__ = 'user'
name = db.Column(db.String, nullable=False)
spotify_id = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
playlists = db.relationship(Playlist)
token = db.relationship(Token, uselist=False)
class Substudy(db.Model):
__tablename__ = "substudy"
id = db.Column(db.Integer, primary_key=True)
study_id = db.Column(db.Integer, db.ForeignKey('study.id'))
name = db.Column(db.String(80))
description = db.Column(db.String(1000))
cell_of_origin = db.Column(db.String(100))
tissue_hierarchy = db.Column(db.String(100))
columns = db.relationship("Column", backref='substudy')
tissues = db.relationship("SubstudyTissue", backref='substudy')
class Subject(BaseModel):
__tablename__ = 'subject'
topic = db.Column(db.Text, comment='考题题目')
type = db.Column(db.String(255), comment='考题类型')
answer = db.Column(db.Text, comment='考题答案')
scene_id = db.Column(db.Integer, db.ForeignKey('scene.id'),
comment='场景id')
scene = db.relationship('Scene',
backref=db.backref('subject',
lazy='dynamic'))
labels = db.relationship('Label', secondary=labels_subjects,
backref=db.backref('subjects', lazy='dynamic'))
class GroupHead(BaseModel):
__tablename__ = 'group_head'
total_group_score = db.Column(db.Integer, comment='组总得分', default=0)
group_id = db.Column(db.Integer, db.ForeignKey('group.id'),
comment='用户')
head_id = db.Column(db.Integer, db.ForeignKey('head.id'),
comment='标题')
head = db.relationship('Head',
backref=db.backref('group_head',
lazy='dynamic'))
group = db.relationship('Group',
backref=db.backref('group_head',
lazy='dynamic'))
class County(db.Model):
__tablename__ = "counties"
# One would think the code would be an integer, but the dataset seems to suggest it could be a string
code = db.Column(db.String(10), primary_key=True, unique=True)
name = db.Column(db.String(36), primary_key=True)
# Parents
region_code = db.Column(db.ForeignKey('regions.code'))
region = db.relationship('Region', foreign_keys=region_code)
# Children
cities = db.relationship("City", back_populates="county", lazy=True)
class Question(BaseModel):
__tablename__ = 'question'
number = db.Column(db.Integer, comment='题号')
total_question_score = db.Column(db.Integer, comment='考题总分')
subject_id = db.Column(db.Integer, db.ForeignKey('subject.id'),
comment='题目id')
subject = db.relationship('Subject',
backref=db.backref('question',
lazy='dynamic'))
paper_id = db.Column(db.Integer, db.ForeignKey('paper.id'),
comment='考卷id')
paper = db.relationship('Paper',
backref=db.backref('questions',
lazy='dynamic', order_by=number))
class Paper(BaseModel):
__tablename__ = 'paper'
name = db.Column(db.String(255), comment='考试名称')
total_paper_score = db.Column(db.Integer, comment='考卷总分')
exam_time = db.Column(db.Integer, comment='考试时间（分钟）')
remainder_time = db.Column(db.Integer, comment='剩余时间（分钟）')
head_id = db.Column(db.Integer, db.ForeignKey('head.id'),
comment='标题')
head = db.relationship('Head',
backref=db.backref('papers',
lazy='dynamic'))
status = db.Column(db.String(255), comment='状态', default='new')
users = db.relationship('User', secondary=users_papers,
backref=db.backref('papers', lazy='dynamic'))
class PaperQuestion(BaseModel):
__tablename__ = 'paper_question'
question_score = db.Column(db.Integer, comment='考题得分', default=0)
user_paper_id = db.Column(db.Integer, db.ForeignKey('user_paper.id'),
comment='用户的考卷')
user_answer = db.Column(db.Text, comment='用户答案')
user_paper = db.relationship('UserPaper',
backref=db.backref('paper_questions',
lazy='dynamic'))
question_id = db.Column(db.Integer, db.ForeignKey('question.id'),
comment='关联的考题')
question = db.relationship('Question',
backref=db.backref('paper_questions',
lazy='dynamic'))
status = db.Column(db.String(255), comment='状态', default='uncommitted')
class Recipe(CRUDMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250), nullable=False)
description = db.Column(db.String(250))
image_url = db.Column(db.String(250))
created_ts = db.Column(
db.DateTime(timezone=True),
server_default=db.func.current_timestamp(),
)
updated_ts = db.Column(
db.DateTime(timezone=True),
onupdate=db.func.current_timestamp(),
)
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', backref='recipe')
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User', backref='recipe')
def __init__(self, name, user_id, category_id, description, image_url):
self.name = name
self.description = description
self.image_url = image_url
self.created_ts = datetime.datetime.now()
self.user_id = user_id
self.category_id = category_id
def __repr__(self):
return '<Recipe %s>' % self.name
@property
def serialize(self):
"""Return object data in easily serializeable format"""
return {
'name': self.name,
'description': self.description,
'image': self.image_url,
'id': self.id
}
@classmethod
def getRecipeList(self, category_id):
list = self.query.filter_by(category_id=category_id)
return list
@classmethod
def getCurrentRecipe(self, recipe_id):
recipe = self.query.filter_by(id=recipe_id).one()
return recipe
class List(db.Model):
__tablename__ = 'lists'
id = db.Column(db.Integer, primary_key=True)
user = db.Column(db.String(300), nullable=False)
name = db.Column(db.String(300), nullable=False)
explore = db.Column(db.String(10), nullable=True)
link_code = db.Column(db.String(12), nullable=False)
items = db.relationship('Item', backref='/items')
star = db.relationship('Star', backref='/stared')
def add_list(self, list_items):
db.session.add(self)
db.session.commit()
items = list_items.split('\n')
output = [x.replace('\r', '') for x in items]
for i in output:
Item(item=i, list_id=self.id).add_item()
return self.link_code
def update_list_title(self, user, code, title):
query = self.query.filter_by(user=user, link_code=code).first()
if not query:
return False
query.name = title
db.session.commit()
return query
def check_correct_user(self, user, code):
if not self.query.filter_by(user=user, link_code=code).first():
return False
return True
@staticmethod
def generate_link_code(StringLength=12):
code = string.ascii_letters + string.digits
return ''.join(choice(code) for i in range(StringLength))
def query_list(self, user, link_code):
return self.query.filter_by(user=user, link_code=link_code).first()
def return_all_lists(self, user):
return self.query.filter_by(user=user).all()
def explore_lists(self):
return self.query.filter_by(explore='y').all()
class Quest(db.Model):
__tablename__ = "quests"
id = db.Column(
INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
)
user_id = db.Column(
INTEGER(unsigned=True),
db.ForeignKey("users.id", ondelete="cascade", onupdate="cascade"),
nullable=False,
)
name = db.Column(db.String(255), nullable=False)
category = db.Column(db.String(255), nullable=False)
description = db.Column(db.String(5000))
exp = db.Column(INTEGER(unsigned=True), default=0)
done = db.Column(db.Boolean, default=False)
created_at = db.Column(
db.DateTime,
server_default=db.func.current_timestamp(),
server_onupdate=db.func.current_timestamp(),
nullable=False,
)
updated_at = db.Column(
db.DateTime,
server_default=db.func.current_timestamp(),
server_onupdate=db.func.current_timestamp(),
nullable=False,
)
quests_shared = db.relationship("QuestShared",
backref="quest",
cascade="all")
quests_exp = db.relationship("QuestExp", backref="quest", cascade="all")
tasks = db.relationship("Task", backref="quest", cascade="all")
def __init__(self, user_id, name, category, description=None):
self.user_id = user_id
self.name = name
self.category = category
self.description = description
def to_dict(self):
return dict(
id=self.id,
name=self.name,
category=self.category,
description="" if self.description is None else self.description,
)
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(150))
slug = db.Column(db.String(140), unique=True)
pre_body = db.Column(db.Text)
body = db.Column(db.Text)
created = db.Column(db.DateTime, index=True, default=datetime.utcnow)
updated = db.Column(db.DateTime)
count = db.Column(db.Integer, default=0)
author_id = db.Column(db.Integer, db.ForeignKey('user.id'))
tags = db.relationship('Tag',
secondary='tags_posts',
backref=db.backref('posts', lazy='dynamic'))
def __init__(self, *args, **kwargs):
super(Post, self).__init__(*args, **kwargs)
self.generate_slug()
def generate_slug(self):
if self.title:
self.slug = slugify(self.title + str(datetime.utcnow()))
def __str__(sefl):
return '<{}>-{}'.format(sefl.id, sefl.title)
class Qrk(BaseMixin, db.Model):
__tablename__ = "qrks"
qrkID = db.Column(db.Integer, primary_key=True)
titel = db.Column(db.String, nullable=False)
x_achse_titel = db.Column(db.String, nullable=False)
y_achse_titel = db.Column(db.String, nullable=False)
obere_warngrenze = db.Column(db.Float)
untere_warngrenze = db.Column(db.Float)
obere_eingriffsgrenze = db.Column(db.Float)
untere_eingriffsgrenze = db.Column(db.Float)
stdabw = db.Column(db.Float)
activ = db.Column(db.Boolean, default=True)
mittelwert = db.Column(db.Float)
datei_pfad = db.Column(db.String)
messwerte = db.relationship('Messwert', backref="Qrk", lazy=False)
def __init__(self, titel, x_achse_titel, y_achse_titel):
self.titel = titel
self.x_achse_titel = x_achse_titel
self.y_achse_titel = y_achse_titel
class Role(Model):
"""Role model class"""
__tablename__ = 'roles'
role = db.Column(db.String(20), unique=True, nullable=False)
default = db.Column(db.Boolean, default=False, index=True)
users = db.relationship('User', backref='roles', lazy='dynamic')
role_permissions = db.relationship('RolePermission', backref='roles')
def __init__(self, role=None, default=False):
self.role = role
self.default = default
def __repr__(self):
return '<Role {}>'.format(self.role)
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Boolean, default=False, index=True)
permissions = db.Column(db.Integer)
users = db.relationship('User', backref='role', lazy='dynamic')
@staticmethod
def insert_roles():
roles = {
'User': (Permission.FOLLOW | Permission.COMMENT
| Permission.WRITE_ARTICLES, True),
'Moderator':
(Permission.FOLLOW | Permission.COMMENT | Permission.WRITE_ARTICLES
| Permission.MODERATE_COMMENTS, False),
'Administrator': (0xff, False)
}
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.permissions = roles[r][0]
role.default = roles[r][1]
db.session.add(role)
db.session.commit()
class RegistrationEvent(_Event):
"""
Define the RegistrationEvent class for table 'event_registration' with the following columns:
id integer, foreign key to `event.id`
registration_id integer, foreign key to 'document.id'
action registration_action, the action that was performed on the registration
"""
__tablename__ = "event_registration"
__mapper_args__ = {'polymorphic_identity': "registration"}
__table_args__ = (
db.UniqueConstraint(
"registration_id",
"action"), # only one of each action per registration
)
# columns
id = db.Column(db.Integer, db.ForeignKey(_Event.id), primary_key=True)
registration_id = db.Column(db.Integer,
db.ForeignKey("registration.id"),
nullable=False)
action = db.Column(db.Enum(*registration_action.ALL,
name="registration_action"),
nullable=False)
# relationships
registration = db.relationship("Registration", back_populates="events")
def __init__(self, user_guid, user_auth_type, registration_id, action):
super().__init__(user_guid, user_auth_type)
self.registration_id = registration_id
self.action = action
class _Event(db.Model):
"""
Define the Event class for table 'event' with the following columns:
id integer, primary key
timestamp datetime, when the event occurred
user_guid varchar(64), foreign key to 'auth_user.guid'
user_auth_type user_auth_type, foreign key to 'auth_user.auth_type'
"""
__tablename__ = "event"
__mapper_args__ = {'polymorphic_on': "type"}
__table_args__ = (db.ForeignKeyConstraint(
("user_guid", "user_auth_type"),
("auth_user.guid", "auth_user.auth_type"),
), )
# columns
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime, nullable=False)
user_guid = db.Column(db.String(64), nullable=False)
user_auth_type = db.Column(user_auth_type, nullable=False)
type = db.Column(db.Enum("document", "registration", name="event_type"),
nullable=False)
# relationships
agent = db.relationship("User",
primaryjoin="and_(_Event.user_guid == User.guid, "
"_Event.user_auth_type == User.auth_type)",
back_populates="events")
def __init__(self, user_guid, user_auth_type):
self.user_guid = user_guid
self.user_auth_type = user_auth_type
self.timestamp = datetime.utcnow()
