class Application(db.Model):
id = db.Column(db.Integer, primary_key=True)
country_id = db.Column(db.Integer,
db.ForeignKey('country.id'),
nullable=False)
university = db.Column(db.String(64))
major = db.Column(db.String(64))
degree = db.Column(db.Enum('Master', 'Ph.D'))
term = db.Column(db.String(64))
result = db.Column(db.Enum('ad', 'offer', 'rej'))
applicant_id = db.Column(db.Integer,
db.ForeignKey('applicant.id'),
nullable=False)
tags = db.relationship("Tag",
secondary=db.Table(
'application_tag', db.Model.metadata,
db.Column("application_id",
db.Integer,
db.ForeignKey('application.id'),
primary_key=True),
db.Column("tag_id",
db.Integer,
db.ForeignKey('tag.id'),
primary_key=True)),
backref="applications")
def __repr__(self):
return '<Application #{}>'.format(self.id)
class WaliMuridModel(db.Model):
__tablename__ = "wali_murid"
id = db.Column(db.Integer, primary_key=True)
nama = db.Column(db.String(120), nullable=False)
agama = db.Column(
db.Enum(
"Islam", "Kristen", "Katolik", "Hindu", "Buddha", "Kong Hu Cu", name="agama"
),
nullable=False,
)
alamat = db.Column(db.Text, nullable=False)
kelurahan = db.Column(db.String(60), nullable=False)
kecamatan = db.Column(db.String(60), nullable=False)
kabupaten = db.Column(db.String(60), nullable=False)
provinsi = db.Column(db.String(60), nullable=False)
jenis_kelamin = db.Column(
db.Enum("Laki-laki", "Perempuan", name="gender"), nullable=False
)
tempat_lahir = db.Column(db.String(60), nullable=False)
tanggal_lahir = db.Column(db.String(60), nullable=False)
pekerjaan = db.Column(db.String(40), nullable=False)
nomor_telepon = db.Column(db.String(12), nullable=False)
murid_id = db.Column(db.Integer, db.ForeignKey("murid.id"))
murid = db.relationship("MuridModel", back_populates="wali_murid")
def __repr__(self):
return "Wali Murid {}".format(self.nama)
class UserModel(db.Model):
__tablename__ = 'users'
__table_args__ = {'mysql_charset': 'utf8', 'extend_existing': True}
gender_enums = ('male', 'female')
type_enums = ('unregistered', 'registered', 'manager', 'withdrawal')
id = db.Column(BIGINT(20, unsigned=True), primary_key=True, index=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(TEXT, nullable=False)
name = db.Column(db.String(80), nullable=True)
gender = db.Column(db.Enum(*gender_enums),
default=gender_enums[0],
server_default=gender_enums[0])
# TODO: 안드로이드 (Yongin_Client)에서 중복(unique) 불가 처리 필요.
nickname = db.Column(db.String(80), unique=True)
email = db.Column(db.String(80), unique=True, nullable=False)
type = db.Column(db.Enum(*type_enums),
default=type_enums[0],
server_default=type_enums[0])
created_date = db.Column(TIMESTAMP,
default=datetime.datetime.utcnow,
server_default=text('CURRENT_TIMESTAMP'))
def is_valid_password(self, input_value):
return bcrypt.check_password_hash(self.password, input_value)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), index=True, unique=True)
firstname = db.Column(db.String(120), nullable=False)
lastname = db.Column(db.String(120), nullable=False)
password = db.Column(db.String(140))
status = db.Column(db.SmallInteger, default=INACTIVE_USER)
role = db.Column(db.SmallInteger, default=ROLE_USER)
uwiId = db.Column(db.String(8))
userInitial = db.Column(db.String(9))
salutation = db.Column(
db.Enum(u'DR', u'MS', u'MR', u'MRS', u'NA', u'TBA1', u'TBA2'))
marker = db.Column(db.Enum(u'YES', u'NO'))
tutor = db.Column(db.Enum(u'YES', u'NO'))
lecturer = db.Column(db.Enum(u'YES', u'NO'))
def is_authenticated(self):
return True
def is_active(self):
return self.status == ACTIVE_USER
def is_admin(self):
return self.role == ROLE_ADMIN
def get_id(self):
return unicode(self.id)
def is_anonymous(self):
return False
def __repr__(self):
return '<User %r>' % (self.email)
class plantTypeDescription(db.Model):
__tablename__ = 'plantTypeDescription'
plantTypeID = db.Column(db.Integer,
db.ForeignKey(plantTypeInfo.plantTypeID),
primary_key=True)
fertilizer = db.Column(db.String(100), nullable=False)
weatherCondition = db.Column(db.Enum(weatherConditionTypes),
nullable=False)
sunlightCondition = db.Column(db.Enum(sunlightTypes), nullable=False)
waterRequirements = db.Column(db.Integer, nullable=False)
potSize = db.Column(db.Enum(potSizeTypes), nullable=False)
specialRequirements = db.Column(db.String(100), nullable=True)
def __init__(self,
plantTyepID,
fertilizer,
weatherCondition,
sunlightCondition,
waterRequirements,
potSize,
specialRequirements=None):
self.plantTypeID = plantTyepID
self.fertilizer = fertilizer
self.weatherCondition = weatherCondition
self.sunlightCondition = sunlightCondition
self.waterRequirements = waterRequirements
self.potSize = potSize
self.specialRequirements = specialRequirements
def __repr__(self):
return '<ID-{id} fertilizer-{fert} weather-{wea} sunlight-{sun} water-{water} pot-{pot} special-{spec}>'\
.format(id=self.plantTypeID,fert=self.fertilizer, wea=self.weatherCondition, sun=self.sunlightCondition, water=self.waterRequirements, pot=self.potSize, spec=self.specialRequirements)
class Company(db.Model):
__tablename__ = 'Company'
CompanyID = db.Column(db.Integer, primary_key=True)
CompanyType = db.Column(db.Enum('Decoration', 'Furniture'))
CompanyAuth = db.Column(db.Enum('Y', 'N'))
CompanyAddress = db.Column(db.String(45))
CompanyIntro = db.Column(db.String(200))
class TraceMain(db.Model):
__tablename__ = "trace_main"
id = db.Column(db.Integer, primary_key=True)
# 真实文件名
file_real_name = db.Column(db.String(256), nullable=False)
# 格式化文件名
file_format_name = db.Column(db.String(256), nullable=False)
# 文件路径
file_path = db.Column(db.String(256), nullable=False)
# 前端发送文件的时刻
send_file_time = db.Column(db.DateTime, index=True, default=datetime.now)
# 后台接收到文件的时刻
receive_file_time = db.Column(db.DateTime, default=datetime.now)
# trace_moe 传输表主键
trace_moe_id = db.Column(db.Integer, nullable=False)
# 前端查询文件方式
search_type = db.Column(db.Enum("upload", "link"),
nullable=False,
default="upload")
# 1 开始处理;2 请求 trace 中; 3 得到 trace 结果; 0 完成任务返回结果 ; -1 未开始
status = db.Column(db.Enum("-1", "1", "2", "3", "0"),
nullable=False,
default="-1")
# 发送结果给前端的时刻
return_result_time = db.Column(db.DateTime, default=datetime.now)
# 格式化识别结果
result_format = db.Column(db.Text, nullable=False)
class NilaiModel(db.Model):
__tablename__ = "nilai_model"
id = db.Column(db.Integer, primary_key=True)
deskripsi = db.Column(db.Text, nullable=False)
aspek_penilaian = db.Column(
db.Enum(
"Perkembangan Nilai Agama dan Moral",
"Perkembangan Sosial, Emosional",
"Perkembangan Bahasa",
"Perkembangan Kognitif",
"Perkembangan Fisik Motorik",
"Perkembangan Seni",
name="aspek_penilaian",
),
nullable=False,
)
semester = db.Column(
db.Enum("Semester I", "Semester II", name="semester"), nullable=False
)
tahun_pelajaran = db.Column(db.String(24), nullable=False)
murid_id = db.Column(db.Integer, db.ForeignKey("murid.id"))
def __repr__(self):
return "Nilai {}".format(self.aspek_penilaian)
class Users(db.Model):
id = db.Column(db.Integer,
db.ForeignKey(Authorization.id),
primary_key=True)
First_Name = db.Column(db.String(100), nullable=False)
Last_Name = db.Column(db.String(100))
Age = db.Column(db.Integer)
Height = db.Column(db.Integer)
Marital_Status = db.Column(db.Enum(marital_status))
Education = db.Column(db.String(300))
Profession = db.Column(db.String(300))
Religion = db.Column(db.Enum(religion))
Language = db.Column(db.Enum(language))
City = db.Column(db.String(100))
Country = db.Column(db.Enum(country))
Food = db.Column(db.Enum(food))
Drinks = db.Column(db.Enum(drinks))
Smokes = db.Column(db.Enum(smokes))
Skin_Tone = db.Column(db.Enum(skin_tone))
Build = db.Column(db.Enum(build))
Gender = db.Column(db.Enum(gender))
prefrences = db.relationship('User_Prefrences', backref='Users', lazy=True)
def __repr__(self):
return "info {}".format(self.First_Name)
class Machine(Base):
__tablename__ = 'machine'
name = db.Column(db.String, nullable=False, unique=True, index=True)
status = db.Column(db.Enum('OFF', 'ON', 'BROKEN', 'NOT_IN_USE'),
default='ON',
nullable=False,
index=True)
power_in_kilowatt = db.Column(db.Integer)
photo = db.Column(db.String)
average_num_workers = Column(db.Enum('1', '2', '3', '4', '5', '6', '7',
'8', '9', '10'),
default='1')
machine_to_lead_ratio = db.Column(db.Enum('1-1', '1-2', '1-3', '1-4',
'1-5'),
default='1-1',
nullable=False)
def to_dict(self):
return dict(id=self.id,
name=self.name,
status=self.status,
power_in_kilowatt=self.power_in_kilowatt,
photo=self.photo,
average_num_workers=self.average_num_workers,
machine_to_lead_ratio=self.machine_to_lead_ratio,
created_at=self.created_at.isoformat(),
updated_at=self.updated_at.isoformat())
def __repr__(self):
return '%d - %s' % (self.id, self.name)
class Page(db.Model):
__tablename__ = 'pages'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
name = db.Column(db.Text)
url = db.Column(db.Text)
postdata = db.Column(db.Text)
ua = db.Column(db.Text)
referer = db.Column(db.Text)
cookie = db.Column(db.Text)
method = db.Column(db.Enum('GET', 'POST'))
watch_type = db.Column(db.Enum('change', 'keyword'))
keyword = db.Column(db.Text)
notify_content = db.Column(db.Enum('diff', 'new', 'all'))
freq = db.Column(db.Integer)
last_check = db.Column(db.DateTime)
last_status = db.Column(db.Text)
user = db.relationship('User', backref=db.backref('pages'))
def __init__(self, name, url, postdata, ua, referer, cookie, method,
watch_type, keyword, notify_content, freq, user):
self.name = name
self.url = url
self.postdata = postdata
self.ua = ua
self.referer = referer
self.cookie = cookie
self.method = method
self.watch_type = watch_type
self.keyword = keyword
self.notify_content = notify_content
self.freq = freq
self.user = user
@classmethod
def all(cls):
return cls.query.all()
def save(self):
db.session.add(self)
db.session.commit()
app.dm.deletetask(self.id)
app.dm.addtask(self)
def delete(self):
db.session.delete(self)
db.session.commit()
app.dm.deletetask(self.id)
def update_check(self, status):
page = self.query.get(self.id)
if page:
page.last_check = datetime.now()
page.last_status = status
db.session.add(page)
db.session.commit()
def email(self):
return load_user(self.user_id).email
class MuridModel(db.Model):
__tablename__ = "murid"
id = db.Column(db.Integer, primary_key=True)
nomor_induk = db.Column(db.String(5), nullable=False, unique=True)
nama = db.Column(db.String(64), nullable=False)
nama_panggilan = db.Column(db.String(24), nullable=False)
anak_ke = db.Column(db.String(2), nullable=False)
alamat = db.Column(db.Text, nullable=False)
dusun = db.Column(db.String(24), nullable=False)
kelurahan = db.Column(db.String(24), nullable=False)
kecamatan = db.Column(db.String(24), nullable=False)
kabupaten = db.Column(db.String(24), nullable=False)
provinsi = db.Column(db.String(24), nullable=False)
agama = db.Column(
db.Enum(
"Islam", "Kristen", "Katolik", "Hindu", "Buddha", "Kong Hu Cu", name="agama"
),
nullable=False,
)
tempat_lahir = db.Column(db.String(24), nullable=False)
tanggal_lahir = db.Column(db.String(24), nullable=False)
lulus = db.Column(db.Boolean, default=False)
nama_ibu_kandung = db.Column(db.String(64), nullable=False)
jenis_kelamin = db.Column(
db.Enum("Laki-laki", "Perempuan", name="gender"), nullable=False
)
tahun_pelajaran = db.Column(db.String(24), nullable=False)
foto_diri = db.Column(db.LargeBinary(__fotosize__))
nama_foto_diri = db.Column(db.String(64), unique=True)
kelas_id = db.Column(db.Integer, db.ForeignKey("kelas.id"))
kelas = db.relationship("KelasModel", back_populates="murid")
wali_murid = db.relationship("WaliMuridModel", back_populates="murid")
nilai = db.relationship("NilaiModel")
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("UserModel", back_populates="murid")
def can(self, perm):
return self.role is not None and self.role.has_permission(perm)
def is_administrator(self):
return self.can(Permission.ADMIN)
def __repr__(self):
return "Murid {}".format(self.nama)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return int(self.id)
class Encashment(db.Model):
id = db.Column(db.Integer, primary_key = True)
emp_id = db.Column(db.Integer, db.ForeignKey('employees.id'), nullable = False)
amount = db.Column(db.Integer, nullable = False)
leaves_utilized = db.Column(db.Float, nullable=False)
manager_approval = db.Column(db.Enum('Approved','Unapproved'), nullable = True, default=None)
gm_approval = db.Column(db.Enum('Approved','Unapproved'), nullable = True, default=None)
hr_approval = db.Column(db.Enum('Approved','Unapproved'), nullable = True, default=None)
time_stamp = db.Column(db.Date(), nullable = False)
class Mod(db.Model):
__tablename__ = "mods"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(256))
pretty_name = db.Column(db.String(256))
description = db.Column(db.Text())
zip_file = db.Column(db.String(256))
workshop_id = db.Column(INTEGER(unsigned=True))
app = db.Column(db.Integer, default=440)
package_format = db.Column(db.Enum('VPK', 'ZIP', name='package_types'),
default='VPK')
manifest_steamid = db.Column(db.Integer)
item_slot = db.Column(db.String(64))
image_inventory = db.Column(db.String(256))
defindex = db.Column(db.Integer, nullable=True)
hide_downloads = db.Column(db.Boolean, default=False)
uploaded = db.Column(db.DateTime, default=datetime.datetime.utcnow)
visibility = db.Column(db.Enum('H', 'Pu', 'Pr', name='visibility_types'),
default='H') # Hidden, Public, Unlisted
completed = db.Column(db.Boolean, default=False, nullable=False)
enabled = db.Column(db.Boolean, default=True)
authors = db.relationship('User',
secondary="mod_author",
backref=db.backref('mod', lazy="dynamic"),
lazy="subquery",
order_by="ModAuthor.order")
equip_regions = db.relationship('TF2EquipRegion',
secondary=mod_equipregion,
backref=db.backref('mod', lazy="dynamic"),
lazy="subquery")
bodygroups = db.relationship('TF2BodyGroup',
secondary=mod_bodygroup,
backref=db.backref('mod', lazy="dynamic"),
lazy="subquery")
tags = db.relationship('Tag',
secondary=mod_tag,
backref=db.backref('mod', lazy="dynamic"),
lazy="subquery")
class_model = db.relationship(
'ModClassModel',
backref=db.backref('mod'),
collection_class=attribute_mapped_collection('class_name'),
lazy="subquery",
cascade='all')
__mapper_args__ = {"order_by": [db.desc(uploaded)]}
def __repr__(self):
return u"{} (id: {})".format(self.pretty_name, self.id)
def __init__(self, zip_file=None, author=None):
self.zip_file = zip_file
self.authors.append(author)
class HostTable(db.Model): id = db.Column(db.Integer, primary_key=True) host_type = db.Column(db.Enum(Host), unique=True, nullable=False) host_name = db.Column(db.String, unique=True, nullable=False) host_lang = db.Column(db.Enum(Language), nullable=False) host_url = db.Column(db.String, unique=True, nullable=False) host_search_engine = db.Column(db.String) def __repr__(self): return "Host(id=%s, host_name=%s, host_lang=%s, host_url=%s)" % \ (self.id, self.host_name, self.host_lang, self.host_url)
class Preference(db.Model):
itinerary_ID = db.Column(db.Integer,
db.ForeignKey('itinerary.ID'),
primary_key=True)
type = db.Column(db.Enum('shopping', 'culture', 'gastronomy', 'nightlife'),
primary_key=True)
range = db.Column(db.Enum('1', '2', '3', '4', '5'))
def __init__(self, itinerary_ID, type, range):
self.itinerary_ID = itinerary_ID
self.type = type
self.range = range
class CourseDistributions(db.Model):
__tablename__ = 'CourseDistributions'
campus = db.Column(db.Enum(CampusEnum), primary_key=True) # UBCV or UBCO
year = db.Column(db.String(4), primary_key=True) # Ex: 2012
session = db.Column(db.Enum(SessionEnum), primary_key=True) # W or S
subject = db.Column(db.String(4), primary_key=True) # Ex: BA, KIN, MATH
course = db.Column(db.String(3), primary_key=True) # Ex: 001, 200
detail = db.Column(db.String(3), primary_key=True) # Ex: A, B, C
# We note these fields are nullable
grade_0_9 = db.Column(db.Integer())
grade_10_19 = db.Column(db.Integer())
grade_20_29 = db.Column(db.Integer())
grade_30_39 = db.Column(db.Integer())
grade_40_49 = db.Column(db.Integer())
grade_lt50 = db.Column(db.Integer()) # Num less than 50
grade_50_54 = db.Column(db.Integer())
grade_55_59 = db.Column(db.Integer())
grade_60_63 = db.Column(db.Integer())
grade_64_67 = db.Column(db.Integer())
grade_68_71 = db.Column(db.Integer())
grade_72_75 = db.Column(db.Integer())
grade_76_79 = db.Column(db.Integer())
grade_80_84 = db.Column(db.Integer())
grade_85_89 = db.Column(db.Integer())
grade_90_100 = db.Column(db.Integer())
def to_dict(self):
return {
"grades": {
"0-9%": self.grade_0_9,
"10-19%": self.grade_10_19,
"20-29%": self.grade_20_29,
"30-39%": self.grade_30_39,
"40-49%": self.grade_40_49,
"<50%": self.grade_lt50,
"50-54%": self.grade_50_54,
"55-59%": self.grade_55_59,
"60-63%": self.grade_60_63,
"64-67%": self.grade_64_67,
"68-71%": self.grade_68_71,
"72-75%": self.grade_72_75,
"76-79%": self.grade_76_79,
"80-84%": self.grade_80_84,
"85-89%": self.grade_85_89,
"90-100%": self.grade_90_100
},
"campus": self.campus.name,
"year": self.year,
"session": self.session.name,
"subject": self.subject,
"course": self.course,
"detail": self.detail
}
class ResourceNode(db.Model):
id = db.Column(db.Integer, primary_key=True)
land_id = db.Column(db.Integer, db.ForeignKey('land.id'))
type = db.Column(db.Enum(ResourceType))
sub_type = db.Column(db.Enum(OreType))
available = db.Column(db.Integer)
def is_ore(self):
return self.type == ResourceType.ore
def __repr__(self):
return self.type.name + '-' + self.sub_type.name # + '[' + str(self.available) + ']'
class Features(db.Model):
__table_args__ = {'extend_existing': True}
ClientPriority = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
Title = db.Column(db.String(100), unique=True)
Description = db.Column(db.String(1000))
Client = db.Column(db.Enum(ClientChoice), nullable=False)
TargetDate = db.Column(db.String(20))
TargetArea = db.Column(db.Enum(TargetAreaChoice), nullable=False)
def __repr__(self):
return '<Title: {self.Title}>'
class Request(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(140), index=True)
description = db.Column(db.String(4096))
client = db.Column(db.Enum(Client), index=True)
priority = db.Column(db.Integer, index=True)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
target_date = db.Column(db.Date, index=True)
product_area = db.Column(db.Enum(Area), index=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def as_dict(self):
return {c.name: str(getattr(self, c.name)) for c in self.__table__.columns}
class Balance_sheet(db.Model):
id = db.Column(db.Integer, primary_key = True)
emp_id = db.Column(db.Integer, db.ForeignKey('employees.id'), nullable = False)
from_date = db.Column(db.Date(), nullable = False)
to_date = db.Column(db.Date(), nullable = False)
leave_type = db.Column(db.Enum('General','Medical'), nullable = False)
purpose = db.Column(db.String(200), nullable = False)
hr_remark = db.Column(db.String(128), nullable = True, default=None)
hr_approval = db.Column(db.Enum('Approved','Unapproved'), nullable = True, default=None)
manager_remark = db.Column(db.String(128), nullable = True, default=None)
manager_approval = db.Column(db.Enum('Approved','Unapproved'), nullable = True, default=None)
time_stamp = db.Column(db.Date(), nullable = False)
class HonorificsTable(db.Model): id = db.Column(db.Integer, primary_key=True) lang = db.Column(db.Enum(Language), nullable=False) raw = db.Column(db.String, unique=True, nullable=False) trans = db.Column(db.String, nullable=False) affix = db.Column(db.Enum(HonorificAffix), default=HonorificAffix.SUFFIX) opt_with_dash = db.Column(db.Boolean, default=True) opt_standalone = db.Column(db.Boolean, default=False) enabled = db.Column(db.Boolean, default=True) def __repr__(self): return "Honorific(raw=%s, trans=%s, lang=%s)" % \ (self.raw, self.trans, self.lang)
class Article(db.Model):
__tablename__ = 'articles'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.Text)
board_id = db.Column(db.Integer, db.ForeignKey('boards.id'))
body = db.Column(db.Text)
hits_count = db.Column(db.Integer, default=1)
likes_count = db.Column(db.Integer, default=0)
dislike_count = db.Column(db.Integer, default=0)
deleted = db.Column(db.Enum(YesOrNo), default='N')
reported = db.Column(db.Enum(YesOrNo), default='N')
created_at = db.Column(db.DateTime, index=True, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow)
class Sample(db.Model):
__tablename__ = "samples"
id = db.Column(db.Integer, primary_key=True)
sample_type = db.Column(db.Enum(SampleType))
collection_date = db.Column(db.DateTime)
disposal_instruction = db.Column(db.Enum(DisposalInstruction))
disposal_date = db.Column(db.DateTime, nullable=False)
creation_date = db.Column(db.DateTime, server_default=db.func.now(), nullable=False)
update_date = db.Column(db.DateTime, server_default=db.func.now(), server_onupdate=db.func.now(), nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey("users.id"))
class SenderInfo(db.Model):
__tablename__ = "sender_infos"
id = db.Column(db.Integer, primary_key=True)
address = db.Column(db.String(6), index=True)
address_type = db.Column(db.String)
aircraft = db.Column(db.String)
registration = db.Column(db.String(7))
competition = db.Column(db.String(3))
tracked = db.Column(db.Boolean)
identified = db.Column(db.Boolean)
aircraft_type = db.Column(db.Enum(AircraftType),
nullable=False,
default=AircraftType.UNKNOWN)
address_origin = db.Column(db.Enum(SenderInfoOrigin),
nullable=False,
default=SenderInfoOrigin.UNKNOWN)
# Relations
sender_id = db.Column(db.Integer, db.ForeignKey("senders.id"), index=True)
sender = db.relationship("Sender",
foreign_keys=[sender_id],
backref=db.backref("infos",
order_by=address_origin))
country_id = db.Column(db.Integer,
db.ForeignKey("countries.gid"),
index=True)
country = db.relationship("Country",
foreign_keys=[country_id],
backref=db.backref("sender_infos",
order_by=address_origin))
__table_args__ = (db.Index('idx_sender_infos_address_address_origin_uc',
'address',
'address_origin',
unique=True), )
def __repr__(self):
return "<SenderInfo: %s,%s,%s,%s,%s,%s,%s,%s,%s>" % (
self.address_type,
self.address,
self.aircraft,
self.registration,
self.competition,
self.tracked,
self.identified,
self.aircraft_type,
self.address_origin,
)
class Company(db.Model):
id = db.Column(db.Integer, primary_key=True)
# Foreign keys
id_game = db.Column(db.Integer, db.ForeignKey('game.id'), nullable=True)
id_user = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
# Data
player_number = db.Column(db.Integer, nullable=False)
player_type = db.Column(db.Enum("ai", "human"), default="ai")
name = db.Column(db.String(30), nullable=False, default='Company #')
score = db.Column(db.Integer, nullable=False, default=0)
balance = db.Column(db.Float, nullable=False, default=1000000000)
revenue = db.Column(db.Float, default=0)
profit = db.Column(db.Float, default=0)
global_bid_policy = db.Column(db.Enum("MC", "LCOE", "Fixed"), default="MC")
global_maintenance_policy = db.Column(db.Enum("Routine", "Proactive",
"Reactive"),
default="Routine")
state = db.Column(db.Enum("view", "build", "waiting", "ready"),
default="view")
joined_game = db.Column(db.Boolean, default=False)
show_QR = db.Column(db.Boolean, default=False)
# Relational data
game = db.relationship('Game')
user = db.relationship('User')
facilities = db.relationship('Facility')
prompts = db.relationship('Prompt')
# Methods
# Allows you to access object properties as an associative array ex: generator['state']
def __getitem__(self, key):
return getattr(self, key)
# Allows you to assign values to object properties as an associative array ex: generator['state'] = "new"
def __setitem__(self, key, value):
setattr(self, key, value)
def __repr__(self):
return (f"Company -\n"
f"\tId: {self.id}\n"
f"\tGame Id: {self.id_game}\n"
f"\tUser Id: {self.id_user}\n"
f"\tPlayer Num: {self.player_number}\n"
f"\tPlayer Type: {self.player_type}\n"
f"\tName: {self.name}\n"
f"\tState: {self.state}\n"
f"\tBalance: {self.balance}\n")
class ProductReport(db.Model):
"""
Product consumation log entry.
"""
__tablename__ = 'product_reports'
_id = db.Column(db.Integer, primary_key=True)
user = db.Column(db.String(128), nullable=False)
organisation = db.Column(db.Enum(OrganisationEnum), nullable=False)
product = db.Column(db.Enum(ProductEnum), nullable=False)
timestamp = db.Column(db.DateTime,
nullable=False,
server_default=db.func.now())
class EventLog(db.Model):
#__tablename__ = "events_log"
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
timestamp = db.Column(db.DateTime, nullable=False)
event = db.Column(db.Enum(Event), nullable=False)
security_key = db.Column(db.String(16), nullable=False)
user_name = db.Column(db.String(90), nullable=False)
profession = db.Column(db.Enum(Profession), nullable=False)
day_of_the_week = db.Column(db.Enum(DayOfTheWeek), nullable=False)
laboratory_name = db.Column(db.String(20), nullable=False)
class Submission(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(150), nullable=False)
subtitles = db.Column(ARRAY(db.String(150)), nullable=True)
# agency_ein = db.Column(db.String(4), db.ForeignKey('agency.ein'), nullable=False)
additional_creators = db.Column(ARRAY(db.String(150)), nullable=True)
subjects = db.Column(ARRAY(db.String), nullable=False)
description = db.Column(db.String(300), nullable=False)
date_published = db.Column(db.Date, nullable=False)
report_type = db.Column(db.Enum(ReportTypeEnum), nullable=False)
languages = db.Column(ARRAY(db.String()), nullable=False)
fiscal_years = db.Column(ARRAY(db.SmallInteger()), nullable=True)
calendar_years = db.Column(ARRAY(db.SmallInteger()), nullable=True)
boroughs = db.Column(ARRAY(db.Enum(BoroughEnum)), nullable=True)
school_districts = db.Column(ARRAY(db.Enum(SchoolDistrictEnum)),
nullable=True)
community_board_districts = db.Column(ARRAY(
db.Enum(CommunityBoardDistrictEnum)),
nullable=True)
def __init__(
self,
title,
# agency_ein,
subjects,
description,
date_published,
report_type,
languages,
subtitles=None,
additional_creators=None,
fiscal_years=None,
calendar_years=None,
boroughs=None,
school_districts=None,
community_board_districts=None):
self.title = title
# self.agency_ein = agency_ein
self.subjects = subjects
self.description = description
self.date_published = date_published
self.report_type = report_type
self.languages = languages
self.additional_creators = additional_creators
self.fiscal_years = fiscal_years
self.calendar_years = calendar_years
self.boroughs = boroughs
self.school_districts = school_districts
self.community_board_districts = community_board_districts
self.subtitles = subtitles
class Patient(UserMixin, db.Model):
"""
Create a Patient table
"""
# Ensures table will be named in plural and not in singular
# as is the name of the model
__tablename__ = 'patients'
##### Basic Information #####
id = db.Column(db.Integer, primary_key=True)
phone_number = db.Column(db.String(14), index=True, unique=True)
username = db.Column(db.String(60), index=True, unique=True)
first_name = db.Column(db.String(60), index=True)
last_name = db.Column(db.String(60), index=True)
password_hash = db.Column(db.String(128))
is_admin = db.Column(db.Boolean, default=False)
##### Fields for health system. #####
age = db.Column(db.Integer)
gender = db.Column(db.Enum('Male', 'Female'))
height = db.Column(db.Integer)
health_status = db.Column(
db.Enum('Normal', 'Confirmed Case', 'Suspected Case'))
records = db.relationship('Record', backref='patient', lazy='dynamic')
@property
def password(self):
"""
Prevent pasword from being accessed
"""
raise AttributeError('password is not a readable attribute.')
@password.setter
def password(self, password):
"""
Set password to a hashed password
"""
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
"""
Check if hashed password matches actual password
"""
return check_password_hash(self.password_hash, password)
def __repr__(self):
return '<Patient: {}{}>'.format(self.first_name, self.last_name)
