class Project(db.Model):
"""Represents table holding all projects"""
__tablename__ = 'project'
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(25), nullable=False)
description = db.Column(db.Text(), nullable=False)
owner_id = db.Column(db.Integer,
db.ForeignKey('user_data.id'),
nullable=False)
# Dataset is parent of view, thus this relationship helper class
datasets = db.relationship('Dataset',
backref=backref('project'),
lazy='dynamic', passive_deletes=True
)
# Project has a many-to-many relationship with User
# passive_deletes = True to make cascade on delete work correctly
# otherwise we get SET NULL-like behaviour
users = db.relationship("Access", backref='project', passive_deletes=True)
def __init__(self, name, descr, creator):
self.name = name
self.description = descr
self.owner_id = creator
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index = True, unique=True)
#how we relate this user to all of its many posts
posts = db.relationship('Post', backref='author', lazy='dynamic')
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id) # python 2
except NameError:
return str(self.id) # python 3
def __repr__(self):
return '<User %r>' % self.nickname
class AuthorizationData(database.Model):
id = database.Column(database.String(250), primary_key=True)
login = database.Column(database.String(50), unique=True)
password = database.Column(database.String(500), nullable=True)
def __repr__(self):
return 'User %ds>' % self.__login
class User(UserMixin, database.Model):
"""User account model."""
__tablename__ = 'flasklogin-users'
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(100), nullable=False, unique=False)
email = database.Column(database.String(40), unique=True, nullable=False)
role = database.Column(database.String(40), unique=True, nullable=False)
password = database.Column(database.String(200),
primary_key=False,
unique=False,
nullable=False)
enrolled = database.relationship("EduSchedu",
secondary=student_identifier,
backref=database.backref('enrolled'),
lazy='dynamic')
approlled = database.relationship("ApptSchedu",
secondary=student_appt,
backref=database.backref('approlled'),
lazy='dynamic')
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def set_password(self, password):
self.password = generate_password_hash(password, method='sha256')
def check_password(self, password):
return self.password
def __repr__(self):
return "%s" % (self.name)
class Role(database.Model, RoleMixin):
id = database.Column(database.Integer(), primary_key=True)
name = database.Column(database.String(80), unique=True)
description = database.Column(database.String(255))
def __str__(self):
return self.name
class Fund(database.Model):
__tablename__ = 'fund'
fund_id = database.Column(database.Integer, primary_key=True, autoincrement=True)
fund_name = database.Column(database.String(120), nullable=False)
def __init__(self, fund_name):
self.fund_name = fund_name
class User(db.Model):
"""
用户表
"""
id = db.Column(db.Integer, primary_key = True)
username = db.Column(db.String(64), index = True, unique = True)
password = db.Column(db.String(120), )
@property
def is_authenticated(self):
return True
@property
def is_active(self):
return True
@property
def is_anonymous(self):
return False
def get_id(self):
return str(self.id)
def __repr__(self):
return f'<User { self.username }>'
class User(database.Model, UserMixin):
__tablename__ = "user"
id = database.Column("id",
database.Integer,
primary_key=True,
autoincrement=True)
username = database.Column("username",
database.String(255),
unique=True,
nullable=False)
password = database.Column("password", database.Text, nullable=False)
email = database.Column("email",
database.String(255),
unique=True,
nullable=False)
posts = database.relationship("Post", backref="poster")
sentMessages = database.relationship("Message",
backref="sender",
lazy="dynamic",
foreign_keys="Message.senderId")
receivedMessages = database.relationship("Message",
backref="receiver",
lazy="dynamic",
foreign_keys="Message.receiverId")
def __init__(self, username, password, email):
self.username = username
self.password = password
self.email = email
class Registration(database.Model):
def __init__(self, user, tour, date, paid):
self.user = user
self.tour = tour
self.date = date
self.isPaid = paid
__tablename__ = 'registrations'
id = database.Column(database.Integer, primary_key=True)
tour_id = database.Column(database.Integer,
database.ForeignKey('tours.id'),
nullable=False)
tour = database.relationship('Tour',
backref=database.backref('registrations',
lazy='dynamic'))
user_id = database.Column(database.Integer,
database.ForeignKey('users.id'),
nullable=False)
user = database.relationship('User',
backref=database.backref('registrations',
lazy='dynamic'))
date = database.Column(database.DateTime)
isPaid = database.Column(database.Boolean)
def __repr__(self):
return '<Registration \'{}\'>'.format(self.id)
class Portfolio(db.Model): # type: ignore
""" Database Table for portfolio """
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.Text())
def __repr__(self) -> str:
return f"{self.id}"
class Post(db.Model):
id = db.Column(db.Integer, primary_key = True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post %r>' % (self.body)
class User(database.Model, UserMixin):
id = database.Column(database.Integer, primary_key=True)
email = database.Column(database.String(100), unique=True)
password = database.Column(database.String(255))
active = database.Column(database.Boolean)
roles = database.relationship(
'Role', secondary=user_role_relation_database, backref=database.backref('users'), lazy='dynamic'
)
class Stage(database.Model):
id = database.Column(database.Integer, primary_key=True, autoincrement=False)
name = database.Column(database.String(30), unique=True)
create_date = database.Column(database.DateTime, server_default=database.func.now())
modify_date = database.Column(database.DateTime, server_onupdate=database.func.now())
def __repr__(self):
return f'<User ID: {self.user_id}, Stage ID {self.id}, Name {self.name}>'
class Custom_Routes(db.Model): # type: ignore
""" Database Table for Html Routes """
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(150))
source = db.Column(db.Text())
def __repr__(self) -> str:
return f"{self.path}"
class Forum(database.Model):
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(64), index=True, unique=True)
short_name = database.Column(database.String(32), index=True, unique=True)
creator_id = database.Column(
database.Integer,
database.ForeignKey('users.id')
)
threads = database.relationship('Thread', backref='forum', lazy='dynamic')
class Consumption(database.Model):
id = database.Column(database.Integer, primary_key=True)
sum = database.Column(database.Integer, unique=False)
category = database.Column(database.String(150), unique=False)
creation_date = database.Column(database.DateTime)
user_id = database.Column(database.String(150), unique=False)
def __repr__(self):
return str(self.sum) + " " + str(self.category)
class Sbc(db.Model):
__tablename__ = 'sbc'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
connected = db.Column(db.Boolean)
description = db.Column(db.Text)
# Foreign keys:
logs = db.relationship('Logs', cascade="all, delete", backref='sbc', lazy=True)
forwarding = db.relationship('Forwarding', cascade="all, delete", backref="sbc", lazy=True)
class UserBadges(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
uid = db.Column(db.Integer, nullable=False)
badgesID = db.Column(db.Integer, nullable=False)
def addUserBadges(buid, bbadgesID):
user_badge = UserBadges(uid=buid, badgesID=bbadgesID)
db.session.add(user_badge)
db.session.commit()
return True
class Contact(db.Model): # type: ignore
""" Database Table for Contact details """
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(150))
email = db.Column(db.String(150))
message = db.Column(db.Text())
def __repr__(self) -> str:
return f"{self.name} -> {self.email}"
class Posts(db.Model): # type: ignore
""" Database Table for Blog post """
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(150))
body = db.Column(db.Text())
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
def __repr__(self) -> str:
return f"{self.title} -> {self.timestamp}"
class Posts(database.Model):
id = database.Column(database.Integer, primary_key=True)
title = database.Column(database.String)
date = database.Column(database.DateTime)
author = database.Column(database.String)
private = database.Column(database.Integer)
permissions = database.Column(database.String)
short = database.Column(database.String)
content = database.Column(database.String)
expiration = database.Column(database.DateTime)
enabled = database.Column(database.Integer)
class Commitment(database.Model):
__tablename__ = 'commitment'
commitment_id = database.Column(database.Integer, primary_key=True, autoincrement=True)
fund_id = database.Column(database.ForeignKey('fund.fund_id'), nullable=False)
date = database.Column(database.String(120), nullable=False)
amount = database.Column(database.Integer, nullable=False)
def __init__(self, fund_id, date, amount):
self.fund_id = fund_id
self.date = date
self.amount = amount
class EduSchedu(database.Model):
__tablename__ = 'classes'
id = database.Column(database.Integer, primary_key=True)
time = database.Column(TIME(), nullable=False)
dow = database.Column(database.Integer, default='')
classname = database.Column(database.String(100), default='')
zoomlink = database.Column(database.String(500), default='')
students = database.relationship("User",
secondary=student_identifier,
backref=database.backref('students'),
lazy='dynamic')
class Call(database.Model):
__tablename__ = 'call'
call_id = database.Column(database.Integer, primary_key=True, autoincrement=True)
investment_name = database.Column(database.String(120), nullable=False)
date = database.Column(database.String(120), nullable=False)
capital_requirement = database.Column(database.Integer, nullable=False)
def __init__(self, investment_name, date, capital_requirement):
self.investment_name = investment_name
self.date = date
self.capital_requirement = capital_requirement
class Address(database.Model):
__tablename__ = 'address'
address = database.Column(database.String(30), primary_key=True)
city = database.Column(database.String(10), nullable=False)
state_province = database.Column(database.String(10), nullable=False)
postal_code = database.Column(database.String(5), nullable=False)
country = database.Column(database.String(15), nullable=False)
def __repr__(self):
return '<Address {}>'.format(self.address)
class Like(database.Model):
id = database.Column(database.Integer, primary_key=True)
article_id = database.Column(database.Integer,
database.ForeignKey("article.id"),
nullable=False)
user_id = database.Column(database.Unicode(36),
database.ForeignKey("user.id"),
nullable=False)
def __repr__(self):
return "Like('{}', '{}', {}')".format(self.id, self.article_id,
self.user_id)
class Role(database.Model):
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(64), unique=True)
default = database.Column(database.Boolean, default=False, index=True)
permissions = database.Column(database.Integer)
users = database.relationship("User", backref="role", lazy="dynamic")
companies = database.relationship("Company",
backref="role",
lazy="dynamic")
def __init__(self, **kwargs):
super(Role, self).__init__(**kwargs)
if self.permissions is None:
self.permissions = 0
def add_permission(self, permission):
if not self.has_permission(permission):
self.permissions += permission
def has_permission(self, permission):
return self.permissions and permission == permission
@staticmethod
def insert_roles():
default_role = "User"
roles = {
"User": [
Permission.COMMENT, Permission.WRITE_ARTICLES,
Permission.MODERATE_COMMENTS
],
"Company": [
Permission.COMMENT, Permission.WRITE_ARTICLES,
Permission.MANAGE_PRODUCTS
]
}
for r in roles:
role = Role.query.filter_by(name=r).first()
if role is None:
role = Role(name=r)
role.reset_permissions()
for permission in roles[r]:
role.add_permission(permission)
role.default = (role.name == default_role)
database.session.add(role)
database.session.commit()
def remove_permission(self, permission):
if self.has_permission(permission):
self.permissions -= permission
def reset_permissions(self):
self.permissions = 0
class Todo(db.Model):
"""
Database Model for Table Todos of Users
"""
id = db.Column(db.Integer, primary_key=True)
task = db.Column(db.String(140))
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow())
owner_id = db.Column(db.Integer, db.ForeignKey("user.id"))
def __repr__(self):
return f"{self.task}"
class User(db.Model, UserMixin):
"""
Database Model for Table Users
"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
todos = db.relationship("Todo", backref="owner")
def set_password(self, password: str):
""" Set the hashed password for the user """
self.password_hash = generate_password_hash(password)
def check_password(self, password: str):
""" Check the users password """
return check_password_hash(self.password_hash, password)
def is_active(self):
""" True, as all users are active. """
return True
def get_id(self):
""" Return the email address to satisfy Flask-Login's requirements. """
return self.id
def is_authenticated(self):
""" Return True if the user is authenticated. """
return self.authenticated
def is_anonymous(self):
""" False, as anonymous users aren't supported. """
return False
def __repr__(self):
return f"{self.username} -> {self.email}"
def remove_todo(self, task: str):
""" Remove Todo from the user """
for i in self.todos:
if i.task == task:
db.session.delete(i)
db.commit()
else:
continue
def add_todo(self, task: str):
""" Add Todo to the user """
td = Todo(task=task,
owner=User.query.filter_by(username=self.username).first())
db.session.add(td)
db.session.commit()
class Role(database.Model):
def __init__(self, id_, name_):
self.id = id_
self.name = name_
__tablename__ = 'roles'
id = database.Column(database.Integer, primary_key=True)
name = database.Column(database.String(64), unique=True)
def __repr__(self):
return '<Role \'{}\', id: {}>'.format(self.name, self.id)
