class State(db.Model):
__tablename__ = 'state'
id = db.Column(db.Integer, primary_key=True)
transitions = db.relationship("Transition",
secondary=transition_state_table,
backref='trans')
prev_states = db.relationship(
"State",
secondary=prev_state_table,
primaryjoin=id == prev_state_table.c.prev_states_id,
secondaryjoin=id == prev_state_table.c.prev_state_id,
backref="prev",
single_parent=True,
cascade="all, delete-orphan",
# post_update=True,
passive_deletes=True)
description = db.Column(db.Integer)
db.ForeignKeyConstraint(['description'], ['description.id'],
use_alter=True,
name='fk_desc_state',
ondelete=True)
def __init__(self, transitions, prev_states, description):
self.transitions = transitions
self.prev_states = prev_states
self.description = description
def __repr__(self):
return '<State ({}, {}, {}, {})>'.format(self.id, self.description,
self.transitions,
self.prev_states)
class CurriculumUnit(db.Model, _CurriculumUnit):
__tablename__ = 'curriculum_unit'
__table_args__ = (db.UniqueConstraint('subject_id', 'stud_group_id'), )
id = db.Column('curriculum_unit_id',
db.INTEGER,
primary_key=True,
autoincrement=True)
subject_id = db.Column(db.ForeignKey('subject.subject_id'),
nullable=False,
index=True)
stud_group_id = db.Column(db.ForeignKey('stud_group.stud_group_id'),
nullable=False,
index=True)
teacher_id = db.Column(db.ForeignKey('teacher.teacher_id'),
nullable=False,
index=True)
mark_type = db.Column('mark_type',
db.Enum(*MarkTypeDict.keys()),
nullable=False)
hours_att_1 = db.Column('hours_att_1', db.SMALLINT, nullable=False)
hours_att_2 = db.Column('hours_att_2', db.SMALLINT, nullable=False)
hours_att_3 = db.Column('hours_att_3', db.SMALLINT, nullable=False)
subject = db.relationship('Subject')
teacher = db.relationship('Teacher')
att_marks = db.relationship('AttMark',
lazy=True,
backref='curriculum_unit')
class Appointment(db.Model):
__tablename__='appointments'
id = db.Column(db.Integer, primary_key=True)
record = db.relationship('Record', uselist=False)
doctor_id= db.Column(db.Integer, db.ForeignKey('doctors.id'), nullable=False)
doctor = db.relationship('Doctor')
date = db.Column(db.Date, nullable=False)
time = db.Column(db.Time, nullable=False)
unique_time = db.UniqueConstraint('doctor_id','date','time')
class Record(db.Model):
__tablename__='records'
id= db.Column(db.Integer, primary_key = True)
appointment_id = db.Column(db.Integer, db.ForeignKey('appointments.id'), nullable=False)
appointment = db.relationship('Appointment')
patient_id = db.Column(db.Integer, db.ForeignKey('patients.id'),nullable = False)
patient = db.relationship('Patient')
consult_type_id = db.Column(db.Integer, db.ForeignKey('consult_types.id'),nullable=False)
consult_type = db.relationship('ConsultationType')
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 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 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 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 Term(db.Model):
__tablename__ = 'wp_terms'
id = db.Column('term_id', db.Integer, primary_key=True)
name = db.Column('name', db.String)
slug = db.Column('slug', db.String)
term_group = db.Column(
'term_group',
db.Integer) # this is unused and here only for completeness
taxonomy_item = db.relationship('Taxonomy',
primaryjoin="Taxonomy.term_id == Term.id",
foreign_keys=id)
type = association_proxy('taxonomy_item', 'taxonomy')
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 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 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 Event(db.Model):
__tablename__ = 'wp_em_events'
name = db.Column('event_name', db.String)
slug = db.Column('event_slug', db.String)
event_id = db.Column('event_id', db.Integer, primary_key=True)
full_event = db.relationship("FullEvent",
primaryjoin="Event.event_id == FullEvent.id",
foreign_keys=event_id,
viewonly=True)
post_id = db.Column('post_id', db.Integer)
start = db.Column('event_start', db.DateTime())
end = db.Column('event_end', db.DateTime())
all_day = db.Column('event_all_day', db.Boolean)
content = db.Column('post_content', db.String)
location_id = db.Column('location_id', db.Integer,
db.ForeignKey('wp_em_locations.location_id'))
location = db.relationship("Location",
primaryjoin="Event.location_id == Location.id",
foreign_keys=location_id,
viewonly=True)
# because location_id is not a ForeignKey, we need primaryjoin
group_id = db.Column('group_id', db.Integer,
db.ForeignKey('wp_bp_groups.id'))
group = db.relationship("Group",
primaryjoin="Event.group_id == Group.id",
foreign_keys=group_id,
viewonly=True)
event_type = association_proxy('full_event', 'veranstaltungsart')
recurrence = db.Column("recurrence", db.Integer)
recurrence_id = db.Column("recurrence_id", db.Integer)
recurrence_parent = db.relationship(
"Event",
primaryjoin="Event.recurrence_id == Event.event_id",
remote_side=[event_id],
foreign_keys=recurrence_id,
backref="recurrence_children")
visibility = db.Column(
"event_status",
db.Integer) # 0 means not visible, None and 1 mean visible
telephone = ""
contact_email = ""
accessible = "Nein"
website = ""
terms = db.relationship("Term", secondary=association_table, viewonly=True)
terms_slugs = association_proxy('terms', 'slug')
def get_full_image(self):
try: # remove this try later
return BEWEGUNGSMELDER_BASE + self.full_event.image
except AttributeError:
return "error"
def get_thumbnail_image(self):
try: # remove this try later
thumb = re.sub(r"(\.[a-zA-Z]*$)", r"-150x150\g<1>", self.full_event.image) \
if "bpthumb" not in self.full_event.image else self.full_event.image
return BEWEGUNGSMELDER_BASE + thumb
except AttributeError:
return "error"
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 == "Kontakt-Telefon":
self.telephone = metaentry.meta_value
elif metaentry.meta_key == "Barrierefrei":
self.accessible = metaentry.meta_value
elif metaentry.meta_key == "Kontakt-Email":
self.contact_email = metaentry.meta_value
elif metaentry.meta_key == "Veranstaltungsart":
continue
elif metaentry.meta_key == "weiterführende Links 1":
self.website = metaentry.meta_value
else:
meta[metaentry.meta_key] = metaentry.meta_value
# add more metadata here if necessary
return meta
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
class AttMark(db.Model):
__tablename__ = 'att_mark'
__table_args__ = (db.UniqueConstraint('curriculum_unit_id',
'student_id'), )
att_mark_id = db.Column(db.INTEGER, primary_key=True, autoincrement=True)
curriculum_unit_id = db.Column(
db.ForeignKey('curriculum_unit.curriculum_unit_id'), nullable=False)
student_id = db.Column(db.ForeignKey('student.student_id'),
nullable=False,
index=True)
att_mark_1 = db.Column(db.SMALLINT)
att_mark_2 = db.Column(db.SMALLINT)
att_mark_3 = db.Column(db.SMALLINT)
att_mark_exam = db.Column(db.SMALLINT)
att_mark_append_ball = db.Column(db.SMALLINT)
student = db.relationship('Student')
@property
def result_print(self):
att_marks = (self.att_mark_1, self.att_mark_2, self.att_mark_3)
if any(m is None for m in att_marks):
return None
mark_results = MarkResult[self.curriculum_unit.mark_type]
min_ball = MarkResult["test_simple"][1]["min"]
max_ball = mark_results[-1]["max"]
if self.curriculum_unit.mark_type == "exam" and self.att_mark_exam is None:
return None
if any(m < min_ball for m in att_marks):
return min(att_marks), mark_results[0]
hours = (self.curriculum_unit.hours_att_1,
self.curriculum_unit.hours_att_2,
self.curriculum_unit.hours_att_3)
ball_raw = sum(
[att_marks[i] * hours[i]
for i in range(len(att_marks))]) / sum(hours)
# Округление
ball = int(ball_raw)
if ball_raw - ball >= 0.5:
ball += 1
if self.curriculum_unit.mark_type == "exam":
ball += self.att_mark_exam
if self.curriculum_unit.mark_type in (
"exam", "test_diff") and self.att_mark_append_ball is not None:
ball += self.att_mark_append_ball
if ball > max_ball:
ball = max_ball
for mr in mark_results:
if mr["min"] <= ball <= mr["max"]:
return ball, mr
@property
def fill_data(self):
r = {
"att_1": self.att_mark_1 is not None,
"att_2": False,
"att_3": False,
"all": False
}
r["att_2"] = r["att_1"] and self.att_mark_2 is not None
r["all"] = r["att_3"] = r["att_2"] and self.att_mark_3 is not None
if self.curriculum_unit.mark_type == "exam":
r["all"] = r["all"] and self.att_mark_exam is not None
return r
