class Student(db.Model, Person, _ObjectWithSemester):
__tablename__ = 'student'
id = db.Column('student_id', db.BIGINT, primary_key=True)
surname = db.Column('student_surname', db.String(45), nullable=False)
firstname = db.Column('student_firstname', db.String(45), nullable=False)
middlename = db.Column('student_middlename', db.String(45))
stud_group_id = db.Column(db.ForeignKey('stud_group.stud_group_id',
ondelete='SET NULL',
onupdate='SET NULL'),
index=True)
semester = db.Column('student_semestr', db.SMALLINT)
alumnus_year = db.Column('student_alumnus_year', db.SMALLINT)
expelled_year = db.Column('student_expelled_year', db.SMALLINT)
status = db.Column('student_status',
db.Enum(*StudentStateDict.keys()),
nullable=False)
login = db.Column('student_login', db.String(45), unique=True)
card_number = db.Column('card_number', db.BIGINT, unique=True)
group_leader = db.Column('stud_group_leader',
db.BOOLEAN,
nullable=False,
default=False)
@property
def status_name(self):
if self.status and self.status in StudentStateDict:
return StudentStateDict[self.status]
@property
def role_name(self):
return 'Student'
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100))
login = db.Column(db.String(50), nullable=False, unique=True)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(100), nullable=False)
role = db.Column(db.String(30), nullable=False)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
updated_on = db.Column(db.DateTime(), default=datetime.utcnow, onupdate=datetime.utcnow)
def __repr__(self):
return "<{}:{}>".format(self.id, self.username)
# Flask-Login Support
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 str(self.id)
def is_authenticated(self):
return True
def is_anonymous(self):
"""False, as anonymous users aren't supported."""
return False
class Proficiency(db.Model):
"""
Proficiency object.
Used to display proficiency in languages and technologies.
"""
__tablename__ = 'proficiencies'
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(255), nullable=False) # "Programming",
icon = db.Column(db.String(255)) # "faReact",
iconColour = db.Column(db.String(255)) # "#61dbfb",
label = db.Column(db.String(255), nullable=False) # "React",
# "I've worked quite extensivelly with React both in spare time (example, this website) and at work.",
description = db.Column(db.String(255), nullable=False)
rating = db.Column(db.Integer, nullable=False) # 4
def as_dict(self):
return {
"id": self.id,
"category": self.category,
"icon": self.icon,
"iconColour": self.iconColour,
"label": self.label,
"description": self.description,
"rating": self.rating,
}
def __repr__(self):
return f"id: {id} | cat: {self.category} | label: {self.label} | rating: {'*' * self.rating}"
class Patient(db.Model):
__tablename__ = 'patients'
id = db.Column( db.Integer, primary_key=True)
policy_num = db.Column(db.Integer, unique=True, nullable=True)
first_name = db.Column( db.String(50), nullable =False)
middle_name = db.Column( db.String(120), nullable =True)
surname = db.Column(db.String(50), nullable=False)
def __repr__(self):
return '<Patient %r %r>' % (self.first_name, self.surname)
class Doctor(db.Model):
__tablename__ = 'doctors'
id = db.Column( db.Integer, primary_key=True)
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'), nullable=False)
department = db.relationship('Department', backref=db.backref('doctors', lazy=True))
first_name = db.Column( db.String(50), nullable =False)
middle_name = db.Column( db.String(120), nullable =True)
surname = db.Column(db.String(50), nullable=False)
def __repr__(self):
return '<Doctor %r %r>' % (self.first_name, self.surname)
class AdminUser(db.Model, Person):
id = db.Column('admin_user_id', db.BIGINT, primary_key=True)
surname = db.Column('admin_user_surname', db.String(45), nullable=False)
firstname = db.Column('admin_user_firstname',
db.String(45),
nullable=False)
middlename = db.Column('admin_user_middlename', db.String(45))
login = db.Column('admin_user_login',
db.String(45),
nullable=False,
unique=True)
@property
def role_name(self):
return 'AdminUser'
class Department(db.Model):
__tablename__='departments'
id = db.Column( db.Integer, primary_key=True)
name = db.Column( db.String(120),unique=True, nullable = False)
def __repr__(self):
return '<Отдел %r >' % (self.name)
class ConsultationType(db.Model):
__tablename__='consult_types'
id = db.Column( db.Integer, primary_key=True)
name = db.Column( db.String(120), nullable = False)
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'),nullable=False)
department = db.relationship('Department', backref = db.backref('consultations',lazy = True))
class Account(db.Model):
__tablename__ = "account"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128))
password = db.Column(db.String(128))
created = db.Column(db.DateTime)
def __init__(self, email, password, created):
self.email = email
self.password = password
self.created = created
def __repr__(self):
return "<{0} joined at {1})>".format(
self.email,
util.format_datetime(self.created))
class Teacher(db.Model, Person):
__tablename__ = 'teacher'
id = db.Column('teacher_id',
db.INTEGER,
primary_key=True,
autoincrement=True)
surname = db.Column('teacher_surname', db.String(45), nullable=False)
firstname = db.Column('teacher_firstname', db.String(45), nullable=False)
middlename = db.Column('teacher_middlename', db.String(45))
rank = db.Column('teacher_rank', db.String(45), nullable=False)
login = db.Column('teacher_login',
db.String(45),
nullable=False,
unique=True)
@property
def role_name(self):
return 'Teacher'
class ScheduleRecord(db.Model):
__tablename__='chedule_records'
id = db.Column(db.Integer, primary_key = True)
doctor_id = db.Column(db.Integer, db.ForeignKey('doctors.id'),nullable=False)
doctor = db.relationship('Doctor', backref=db.backref('schedules', lazy=True))
date = db.Column(db.Date,nullable=False)
status = db.Column(db.String(40), nullable=False)
unique_status = db.UniqueConstraint('doctor_id','date')
class Subject(db.Model):
__tablename__ = 'subject'
id = db.Column('subject_id',
db.INTEGER,
primary_key=True,
autoincrement=True)
name = db.Column('subject_name',
db.String(64),
nullable=False,
unique=True)
class Condition(db.Model):
__tablename__ = 'condition'
id = db.Column(db.Integer, primary_key=True)
info = db.Column(db.String(300), nullable=False)
def __init__(self, info):
self.info = info
def __repr__(self):
return '<Condition {}>'.format(self.info)
class StudGroup(db.Model, _ObjectWithSemester, _ObjectWithYear):
__tablename__ = 'stud_group'
__table_args__ = (db.UniqueConstraint('stud_group_year',
'stud_group_semester',
'stud_group_num',
'stud_group_subnum'), )
id = db.Column('stud_group_id',
db.INTEGER,
primary_key=True,
autoincrement=True)
year = db.Column('stud_group_year', db.SMALLINT, nullable=False)
semester = db.Column('stud_group_semester', db.SMALLINT, nullable=False)
num = db.Column('stud_group_num', db.SMALLINT, nullable=False)
subnum = db.Column('stud_group_subnum',
db.SMALLINT,
nullable=False,
default=0)
specialty = db.Column('stud_group_specialty',
db.String(200),
nullable=False)
specialization = db.Column('stud_group_specialization', db.String(200))
active = db.Column('stud_group_active',
db.BOOLEAN,
nullable=False,
default=True)
students = db.relationship('Student', lazy=True, backref='stud_group',\
order_by="Student.surname, Student.firstname, Student.middlename")
curriculum_units = db.relationship('CurriculumUnit',
lazy=True,
backref='stud_group',
order_by="CurriculumUnit.id")
@property
def num_print(self):
if self.num is None or self.subnum is None:
return None
return "%d.%d" % (self.num, self.subnum) if self.subnum != 0 else str(
self.num)
class Usage(db.Model):
__tablename__ = "usage"
id = db.Column(db.Integer, primary_key=True)
clustername = db.Column(db.String(128))
username = db.Column(db.String(128))
runningcores = db.Column(db.Integer)
notrunningcores = db.Column(db.Integer)
created = db.Column(db.DateTime)
def __init__(self, clustername, username, runningcores, notrunningcores, created):
self.clustername = clustername
self.username = username
self.runningcores = runningcores
self.notrunningcores = notrunningcores
self.created = created
def __repr__(self):
return "<{0:20s} on {1:10s} at {2} - running_cores: {3:8d}; not_running_cores: {4:8d}".format(
self.username, self.clustername,
util.format_datetime(self.created),
self.runningcores, self.notrunningcores)
class Venue(db.Model):
__tablename__ = 'Venue'
# note: elected not to put uniqueness constraints on name as there may be multiple venues with same name in different locations
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
city = db.Column(db.String(120))
state = db.Column(db.String(120))
address = db.Column(db.String(120))
phone = db.Column(db.String(120))
image_link = db.Column(db.String(500))
facebook_link = db.Column(db.String(120), unique=True)
# COMPLETED: implement any missing fields, as a database migration using Flask-Migrate
website = db.Column(db.String(120), unique=True)
seeking_talent = db.Column(db.Boolean, default=False)
seeking_description = db.Column(db.String(500))
shows = db.relationship('Show', backref='venue', lazy=True)
genres = db.relationship("Genre",
secondary=Venue_Genres,
backref=db.backref('venues', lazy=True))
@classmethod
def search(cls, search_term):
return cls.query.filter(cls.name.ilike(
'%{}%'.format(search_term))).all()
# helper method to get shows for a particular venue
def get_shows(self, when='all'):
query = db.session.query(Show,
Artist).join(Artist,
Artist.id == Show.artist_id)
if when == 'upcoming':
shows = query.filter(Show.venue_id == self.id,
Show.start_time > datetime.now()).order_by(
Show.start_time).all()
if when == 'past':
shows = query.filter(Show.venue_id == self.id,
Show.start_time <= datetime.now()).order_by(
Show.start_time).all()
if when == 'all':
shows = query.filter(Show.venue_id == self.id).order_by(
Show.start_time).all()
shows = Show.unpack_tuples(
shows) # convert from tuple to splatted dicts
shows = Show.datetimes_to_strings(
shows) # does what it says on the tin
return shows
class Figure(db.Model):
__tablename__ = 'figure'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
# db.BINARY doesn't work, haven't tried db.BLOB
content = db.Column(db.LargeBinary)
created = db.Column(db.DateTime)
def __init__(self, name, content, created):
self.name = name
self.content = content
self.created = created
def __repr(self):
return "<{0} created on {1}>".format(self.name, self.created)
class Venue(db.Model):
__tablename__ = 'Venue'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
genres = db.Column(db.ARRAY(db.String), nullable=True)
city = db.Column(db.String(120))
state = db.Column(db.String(120))
address = db.Column(db.String(120))
phone = db.Column(db.String(120))
image_link = db.Column(db.String(500))
website = db.Column(db.String(500), nullable=True)
facebook_link = db.Column(db.String(120))
seeking_talent = db.Column(db.Boolean)
seeking_description = db.Column(db.String(1000))
shows = db.relationship('Show',
backref='venue_show',
cascade="all,delete",
lazy=True)
def __repr__(self):
return f'<Venue {self.id} {self.name}>'
class Artist(db.Model):
__tablename__ = 'Artist'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
city = db.Column(db.String(120))
state = db.Column(db.String(120))
phone = db.Column(db.String(120))
genres = db.Column(db.ARRAY(db.String), nullable=True)
image_link = db.Column(db.String(500))
facebook_link = db.Column(db.String(120))
website = db.Column(db.String, nullable=True)
seeking_venue = db.Column(db.Boolean)
seeking_description = db.Column(db.String(1000))
shows = db.relationship('Show', backref='artist_show', lazy=True)
class WikidataEntity(db.Model):
id = db.Column(db.Integer, primary_key=True)
wd_id = db.Column(db.String(64), index=True)
data_type = db.Column(db.String(64))
label = db.Column(db.String(64))
description = db.Column(db.String(200))
P31 = db.Column(db.String(64))
cache_id = db.Column(db.String(300), nullable=True)
@staticmethod
def add_or_update(wd_id,
data_type=None,
label=None,
description=None,
P31=None,
cache_id=None,
do_session_commit=True,
**kwargs):
wd = WikidataEntity.query.filter_by(wd_id=wd_id,
cache_id=cache_id).first()
if wd:
added = False
else:
wd = WikidataEntity(wd_id=wd_id, cache_id=cache_id)
added = True
if data_type is not None:
wd.data_type = data_type
if label is not None:
wd.label = label
if description is not None:
wd.description = description
if P31 is not None:
wd.P31 = P31
db.session.add(wd)
if do_session_commit:
db.session.commit()
return added
@staticmethod
def do_commit():
try:
db.session.commit()
except:
db.session.rollback()
raise ValueError("Failed to commit to database session")
class bank_product(db.Model):
__tablename__ = 'bank_financial'
product_ID = db.Column('product_ID',
db.String(40),
primary_key=True,
nullable=False)
product_name = db.Column('product_name', db.String(100), nullable=False)
interest_rate = db.Column('interest_rate',
db.DECIMAL(4, 3),
nullable=False)
currencies = db.Column('currencies',
db.String(8),
nullable=False,
default='人民币')
duration = db.Column('duration', db.Integer, nullable=False)
duration_flag = db.Column('duration_flag', db.Boolean, default=True)
type_flag = db.Column('type_flag', db.Integer)
product_url = db.Column('product_url', db.String(400), nullable=False)
start_amount = db.Column('start_amount', db.Integer, nullable=False)
bank_name = db.Column('bank_name', db.String(8), nullable=False)
def __init__(self,
ID,
name,
rate,
duration,
duration_flag,
type,
url,
start_amount,
bank,
currencies='人民币'):
self.product_ID = ID
self.product_name = name
self.interest_rate = rate
self.duration = duration
self.duration_flag = duration_flag
self.type_flag = type
self.product_url = url
self.start_amount = start_amount
self.bank_name = bank
self.currencies = currencies
def to_json(self):
dic = {}
dic['product_name'] = self.product_name
dic['interest_rate'] = str(float(self.interest_rate)) + '%'
dic['currenices'] = self.currencies
if self.duration_flag == False:
if self.duration == 0:
dic['duration'] = '不限制时间'
else:
dic['duration'] = '至少{0}天'.format(str(self.duration))
else:
dic['duration'] = '{0}天'.format(str(self.duration))
if self.type_flag:
dic['type'] = '保本'
else:
dic['type'] = '非保本'
dic['url'] = self.product_url
dic['start_amount'] = '{0}万元'.format(str(self.start_amount / 10000.0))
return dic
def to_brief_json(self):
dic = {}
dic['ID'] = self.product_ID
dic['product_name'] = self.product_name
dic['rate'] = str(float(self.interest_rate)) + '%'
return dic
def to_buss_json(self):
dic = {}
dic['ID'] = self.product_ID
dic['product_name'] = self.product_name
dic['rate'] = float(self.interest_rate)
dic['duration'] = self.duration
dic['duration_flag'] = self.duration_flag
dic['bank_name'] = self.bank_name
dic['url'] = self.product_url
return dic
class Group(db.Model):
__tablename__ = 'wp_bp_groups'
slug = db.Column('slug', db.String)
id = db.Column('id', db.Integer, primary_key=True)
name = db.Column('name', db.String(255))
description = db.Column('description', db.String)
date_created = db.Column('date_created', db.DateTime())
post_id_item = db.relationship(
"Metadata",
primaryjoin="and_(Metadata.meta_value==Group.id, "
"Metadata.meta_key=='group_id')",
foreign_keys=id,
viewonly=True) # this is the full line of the metadata table
post_id = association_proxy('post_id_item', 'post_id')
terms = db.relationship("Term", secondary=association_table, viewonly=True)
terms_slugs = association_proxy('terms', 'slug')
contact_email = ""
contact_name = ""
website = ""
meetup_description = ""
telephone = ""
avatar_url = ""
cover_url = "https://www.incimages.com/uploaded_files/image/970x450/getty_509107562_2000133320009280346_351827.jpg"
def get_all_metadata(self):
metadata = Metadata.query.filter(
Metadata.post_id == self.post_id).all()
meta = {}
for metaentry in metadata:
if not metaentry.meta_key.startswith(
"_") and metaentry.meta_value != "":
if metaentry.meta_key == "telefon":
self.telephone = metaentry.meta_value
elif metaentry.meta_key == "name":
self.contact_name = metaentry.meta_value
elif metaentry.meta_key == "email":
self.contact_email = metaentry.meta_value
elif metaentry.meta_key == "internetseite":
self.website = metaentry.meta_value
elif metaentry.meta_key == "treffen":
self.meetup_description = metaentry.meta_value
else:
meta[metaentry.meta_key] = metaentry.meta_value
# add more metadata here if necessary
return meta
def get_avatar(self):
if self.avatar_url == "":
r = requests.get(
"{}/wp-json/buddypress/v1/groups/{}/avatar".format(
config.BEWEGUNGSMELDER_BASE, self.id))
if r.ok:
self.avatar_url = r.json()[0]["thumb"]
else:
logging.warning("Error retrieving avatar for group " +
self.name + "error is " + r.text)
return self.avatar_url
def get_cover(self):
logging.warning(
"Cover URL not available due do missing BuddyPress support")
return self.cover_url