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