class EyeExamReport(db.Model):
report_id = db.Column(db.Integer, primary_key=True)
patient_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete="NO ACTION"))
tech_id = db.Column(db.Integer,
db.ForeignKey(Technician.id, ondelete="NO ACTION"),
nullable=False)
expiration_date = db.Column(db.Date(), nullable=False)
l_S = db.Column(db.Numeric(3, 2), nullable=False)
r_S = db.Column(db.Numeric(3, 2), nullable=False)
l_CYL = db.Column(db.Numeric(3, 2))
r_CYL = db.Column(db.Numeric(3, 2))
l_Axis = db.Column(db.Integer)
r_Axis = db.Column(db.Integer)
def __init__(self, patient_id, tech_id, expiration_date, l_S, r_S, l_CYL,
r_CYL, l_Axis, r_Axis):
self.patient_id = patient_id
self.tech_id = tech_id
self.expiration_date = expiration_date
self.l_S = l_S
self.r_S = r_S
self.l_CYL = l_CYL
self.r_CYL = r_CYL
self.l_Axis = l_Axis
self.r_Axis = r_Axis
class Patient(db.Model):
practice_uuid:str
patient_id:str
patient_name:str
medical_aid:str
main_member:str
patient_birth_date:datetime
medical_number:str
case_number:str
patient_note:str
created_on:datetime
#updated_on:datetime
__tablename__ = 'patients'
id = db.Column(db.Integer(), primary_key=True)
practice_uuid = db.Column(db.String(36), nullable=False)
patient_name = db.Column(db.String(255), nullable=False)
medical_aid = db.Column(db.String(255), nullable=False)
main_member = db.Column(db.String(255), nullable=True)
patient_birth_date = db.Column(db.Date(), nullable=True)
medical_number = db.Column(db.String(255), nullable=True)
case_number = db.Column(db.String(255), nullable=True)
patient_note = db.Column(db.Text, nullable=True)
created_on = db.Column(db.DateTime(),default=datetime.utcnow)
#updated_on = db.Column(db.DateTime(),default=datetime.utcnow,onupdate=datetime.utcnow)
@hybrid_property
def patient_id(self):
if self.medical_number is not None:
return self.medical_number
else:
return self.case_number
@patient_id.expression
def patient_id(cls):
return case([(cls.case_number != None,
cls.case_number),], else_ = cls.medical_number)
class Patient(db.Model):
autopid = db.Column(db.String(9), primary_key=True)
pid = db.Column(db.String(9), unique=True)
name = db.Column(db.String(40))
age = db.Column(db.String(3))
doa = db.Column(db.Date())
tob = db.Column(db.String(20))
address = db.Column(db.String(100))
state = db.Column(db.String(20))
city = db.Column(db.String(20))
status = db.Column(db.String(15))
class Recommendation(db.Model):
__tablename__ = 'recommendation'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.String())
track_id = db.Column(db.String())
date_recommended_for = db.Column(db.Date())
def __init__(self, user_id, track_id):
self.track_id = track_id
self.user_id = user_id
self.date_recommended_for = date.today()
class Question(db.Model):
id = db.Column(db.Integer, primary_key=True)
CRN = db.Column(db.String(120), db.ForeignKey('course.CRN'))
date = db.Column(db.Date())
question = db.Column(db.String(300))
schemas = db.Column(db.String(1000), nullable=True)
def __init__(self, id, question, schemas, CRN=None):
self.id = id
self.question = question
self.schemas = schemas
self.CRN = CRN
class Patient(db.Model):
__tablename__ = "patients"
patient_ssn = db.Column(db.Integer(), unique=True)
patient_id = db.Column(db.Integer(), primary_key=True, index=True)
patient_name = db.Column(db.String(64))
age = db.Column(db.Integer())
admission_date = db.Column(db.Date())
bed_type = db.Column(db.String(64))
address = db.Column(db.String(64))
city = db.Column(db.String(64))
state = db.Column(db.String(64))
status = db.Column(db.String(64))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
date = db.Column(db.Date(), index=True, unique=False)
password = db.Column(db.String(128))
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class Invoice(db.Model):
id:int
practice_uuid:str
patient_id:str
medical_aid:str
date_created:datetime
date_invoice:datetime
invoice_id:str
invoice_file_url:str
tariff:str
po_number:int
hospital_name:str
admission_date:datetime
discharge_date:datetime
procedure:str
procedure_date:str
diagnosis:str
diagnosis_date:datetime
implants:str
intra_op:str
post_op:str
submitted_on:datetime
invoice_layout:int
status:str
credit_cent:int
remind_me:datetime
last_edited:datetime
last_edited_by:str
__tablename__ = 'invoices'
id = db.Column(db.Integer(), primary_key=True)
practice_uuid = db.Column(db.String(36), nullable=False)
patient_id = db.Column(db.String(255), nullable=False)
medical_aid = db.Column(db.String(255), nullable=False)
date_created = db.Column(db.DateTime(),default=datetime.utcnow)
date_invoice = db.Column(db.Date(),nullable=False)
invoice_id = db.Column(db.String(255),nullable=False)
invoice_file_url = db.Column(db.String(255),nullable=False)
tariff = db.Column(db.String(255),nullable=False)
po_number = db.Column(db.Integer(), nullable=True)
hospital_name = db.Column(db.String(255), nullable=True)
admission_date = db.Column(db.Date(), nullable=True)
discharge_date = db.Column(db.Date(), nullable=True)
procedure = db.Column(db.Text(), nullable=True)
procedure_date = db.Column(db.Date(), nullable=True)
diagnosis = db.Column(db.Text(), nullable=True)
diagnosis_date = db.Column(db.Date(), nullable=True)
implants = db.Column(db.Text(), nullable=True)
intra_op = db.Column(db.String(255), nullable=True)
post_op = db.Column(db.String(255), nullable=True)
submitted_on = db.Column(db.Date(),nullable=True)
invoice_layout = db.Column(db.Integer(), nullable=True)
status = db.Column(db.String(255), default="not-submitted")
credit_cent = db.Column(db.Integer(), default=0)
remind_me = db.Column(db.DateTime, nullable=True)
last_edited = db.Column(db.DateTime(),default=datetime.utcnow,onupdate=datetime.utcnow)
last_edited_by = db.Column(db.String(255), nullable=True)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name_first = db.Column(db.String(64))
name_second = db.Column(db.String(64))
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'))
position_id = db.Column(db.Integer, db.ForeignKey('departments.id'))
email = db.Column(db.String(64), unique=True)
tel = db.Column(db.String(15))
birth_date = db.Column(db.Date(), default=datetime.utcnow)
def __repr__(self):
return "Name: {} {}\nEmail: {}\nTel: {}".format(
self.name_first, self.name_second, self.email, self.tel)
class Data(db.Model):
id = db.Column(db.Integer, primary_key=True)
notes = db.Column(db.String(128), index=True, unique=False)
wdate = db.Column(db.Date(), default=date.today, index=True, unique=False)
weight_of_ort = db.Column(db.String(128), index=True, unique=False)
weight_of_compost = db.Column(db.String(128), index=True, unique=False)
groups = db.Column(db.String(128), index=True, unique=False)
#add columns here
def __init__(self, notes, wdate, weight_of_ort, weight_of_compost, groups):
self.notes = notes
self.wdate = wdate
self.weight_of_ort = weight_of_ort
self.weight_of_compost = weight_of_compost
self.groups = groups
def __repr__(self):
return '<Data %r>' % self.notes
class EthnicGroupByDimension(db.Model):
__tablename__ = "ethnic_groups_by_dimension"
subtopic_guid = db.Column("subtopic_guid", db.String())
page_guid = db.Column("page_guid", db.String())
page_title = db.Column("page_title", db.String())
page_version = db.Column("page_version", db.String())
page_status = db.Column("page_status", db.String())
page_publication_date = db.Column("page_publication_date", db.Date())
page_uri = db.Column("page_uri", db.String())
page_position = db.Column("page_position", db.Integer())
dimension_guid = db.Column("dimension_guid", db.String())
dimension_title = db.Column("dimension_title", db.String())
dimension_position = db.Column("dimension_position", db.Integer())
categorisation = db.Column("categorisation", db.String())
value = db.Column("value", db.String())
value_position = db.Column("value_position", db.Integer())
__table_args__ = (PrimaryKeyConstraint("dimension_guid", "value", name="ethnic_groups_by_dimension_value_pk"), {})
class User(db.Model, UserMixin):
__tablename__ = 'lr_users'
email = db.Column(db.String(255), primary_key=True)
_password = db.Column(db.String(255))
name = db.Column(TEXT, nullable=False)
date_of_birth = db.Column(db.Date(), nullable=False)
gender = db.Column(Enum('F', 'M', name='gender_types'), nullable=False)
current_address = db.Column(TEXT, nullable=False)
previous_address = db.Column(TEXT, nullable=False)
blocked = db.Column(BOOLEAN, nullable=False)
view_count = db.Column(db.Integer, nullable=False)
def get_id(self):
return self.email
@property
def password(self):
raise AttributeError("Password not readable")
@password.setter
def password(self, password):
self._password = password_utils.encrypt_password(password)
def check_password(self, password):
return password_utils.verify_password(password, self._password)
def to_json_for_match(self):
return json.dumps({
'name':
self.name,
'date_of_birth':
datetime.strftime(self.date_of_birth, '%Y-%m-%d'),
'gender':
self.gender,
'current_address':
self.current_address,
'previous_address':
self.previous_address
})
class Reservation(Base):
date = db.Column(db.Date(), nullable=False)
hour = db.Column(db.Integer, nullable=False)
account_id = db.Column(db.Integer,
db.ForeignKey('account.id'),
nullable=False)
def __init__(self, date, hour):
self.date = date
self.hour = hour
@staticmethod
def reserved_hours(date):
stmt = text("SELECT reservation.hour, account.household "
"FROM Reservation "
"LEFT JOIN account ON reservation.account_id=account.id "
"WHERE date = :reserved ").params(reserved=str(date))
res = db.engine.execute(stmt)
res = [(r[0], r[1]) for r in res]
return res
@staticmethod
def get_future_dates():
future_dates = [{
'date': date.today() + datetime.timedelta(days=x)
} for x in range(0, 13)]
for day in future_dates:
hours = []
reserved_hours = Reservation.reserved_hours(day['date'])
for h in range(0, 24):
if h not in list(map(lambda x: x[0], reserved_hours)):
hours.append(h)
day['hours'] = hours
day['reserved_hours'] = sorted(reserved_hours, key=lambda x: x[0])
return future_dates
@staticmethod
def get_reservations_by_household(household):
stmt = text("SELECT date, hour, id FROM reservation"
" WHERE account_id IN"
" (SELECT id FROM account"
" WHERE household = :household)"
" ORDER BY hour ASC").params(household=str(household))
res = db.engine.execute(stmt)
date_dict = {}
for row in res:
date = datetime.datetime.strptime(row[0],
'%Y-%m-%d').date() if isinstance(
row[0], str) else row[0]
date_key = date.strftime('%d.%m.')
reservation = "klo {}-{}".format(row[1], row[1] + 1)
date_obj = {"string": reservation, "id": row[2]}
if date_key in date_dict:
date_dict[date_key].append(date_obj)
else:
date_dict[date_key] = [date_obj]
return date_dict
class Payment(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date())
amount = db.Column(db.Integer())
booking_id = db.Column(db.Integer, db.ForeignKey("booking.id"))
class Sessao(db.Model):
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.Text)
data = db.Column(db.Date())
votacao = relationship("Votacao", back_populates="sessao")
