class SwarmEvent(db.Model):
__tablename__ = 'SwarmEvent'
swarm_id = Column(db.Integer, primary_key=True)
hive_id = Column(db.String(80), db.ForeignKey(HiveModel.hive_id))
alert_period_begin = db.Column(db.DateTime(timezone=True))
alert_period_end = db.Column(db.DateTime(timezone=True))
temperature_variation = Column(Integer)
weight_variation = Column(Integer)
real = Column(Boolean, default=True)
class modelUsuario(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
nome_usuario = db.Column(db.String(80))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
data_nascimento = db.Column(db.DateTime())
sexo = db.Column(db.String(1))
telefone = db.Column(db.String(25))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('modelRole',
secondary=roles_users,
backref=db.backref('user', lazy='dynamic'))
class AboutInfo(db.Model):
__tablename__ = 'AboutInfo'
aboutinfo_id = db.Column(db.Integer, primary_key=True)
first = db.Column(db.String(100))
last = db.Column(db.String(100))
position = db.Column(db.String(100))
email = db.Column(db.String(100))
phone = db.Column(db.String(30))
img_url = db.Column(db.String(1000))
date = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
history = db.relationship('History',
backref='aboutinfo',
lazy='dynamic',
order_by='History.date.desc()')
def __init__(self, first, last, position, email, phone, img_url):
self.first = first
self.last = last
self.position = position
self.email = email
self.phone = phone
self.img_url = img_url
class Roles(db.Model):
__tablename__ = 'Roles'
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(100), unique=True)
edit_date = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
emails = db.relationship('Emails',
secondary=role_email,
backref=db.backref('roles', lazy='dynamic'),
lazy='dynamic')
def __init__(self, role_name):
self.role_name = role_name
def add_email(self, email):
if not self.has_email(email):
self.emails.append(email)
def remove_email(self, email):
if self.has_email(email):
self.emails.remove(email)
def has_email(self, email):
return self.emails.filter(
Emails.email_id == email.email_id).count() > 0
class modelChat(db.Model):
__tablename__ = 'chat'
id_chat = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer, db.ForeignKey('user.id'))
mensagem = db.Column(db.Text())
data_hora = db.Column(db.DateTime())
activate = db.Column(db.Boolean())
chat_and_usuario = db.relationship('modelUsuario')
class UploadedData(db.Model):
__tablename__ = 'uploaded_data'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
filename = db.Column(db.String(255), nullable=False)
description = db.Column(db.String(255), nullable=False)
uploaded_date = db.Column(db.DateTime(timezone=True),
server_default=func.now())
uploaded_by = db.Column(db.String(255))
class Properties(db.Model):
__tablename__ = 'Properties'
property_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200))
address_l1 = db.Column(db.String(200))
address_l2 = db.Column(db.String(200))
city = db.Column(db.String(200))
state = db.Column(db.String(2))
zipcode = db.Column(db.String(20))
type = db.Column(db.String(50))
beds = db.Column(db.Numeric())
baths = db.Column(db.Numeric())
sale_price = db.Column(db.Integer)
rent_price = db.Column(db.Integer)
for_sale = db.Column(db.Boolean())
for_rent = db.Column(db.Boolean())
is_public = db.Column(db.Boolean(), default=False)
status = db.Column(db.String(100))
area = db.Column(db.Integer)
notes = db.Column(db.String(2000))
date_posted = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
images = db.relationship('PropertyImgs',
backref='property',
lazy='dynamic',
order_by='PropertyImgs.date_added')
history = db.relationship('History',
backref='property',
lazy='dynamic',
order_by='History.date.desc()')
def __init__(self, input):
columns = Properties.__table__.columns
for c in columns:
if c.key in input:
setattr(self, c.key, input[c.key])
def add_image(self, image):
if not self.has_image(image):
self.images.append(image)
def remove_image(self, image):
if self.has_image(image):
self.images.remove(image)
def has_image(self, image):
return self.images.filter(
PropertyImgs.img_id == image.img_id).count() > 0
class PaymentHistory(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime(timezone=True), nullable=False)
payment_mode = db.Column(db.String(100), nullable=False)
amount = db.Column(db.Integer, nullable=False)
notes = db.Column(db.String(255))
client_id = db.Column(db.Integer,
db.ForeignKey('client.id'),
nullable=False)
class Incident(db.Model):
incidentID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
raisedID = db.Column(db.String(32), db.ForeignKey('account.username'))
affectedID = db.Column(db.String(32), db.ForeignKey('account.username'))
investigatingDepartmentID = db.Column(
db.Integer(), db.ForeignKey('department.departmentID'))
investigatingTechnicianID = db.Column(db.String(32),
db.ForeignKey('account.username'))
description = db.Column(db.String(250))
timeRaised = db.Column(db.DateTime())
priority = db.Column(db.String(2), nullable=False)
severity = db.Column(db.String(2), nullable=False)
impact = db.Column(db.String(2), nullable=False)
status = db.Column(db.String(32), nullable=False)
timeCompleted = db.Column(db.DateTime())
class Invoice(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime(timezone=True))
invoice_ref = db.Column(db.Integer, nullable=False)
item_breakdown = db.Column(db.PickleType)
cgst = db.Column(db.Integer, nullable=False)
sgst = db.Column(db.Integer, nullable=False)
client_id = db.Column(db.Integer,
db.ForeignKey('client.id'),
nullable=False)
class SensorFeed(db.Model):
__tablename__ = 'SensorFeed'
hive_id = db.Column(db.String(80), db.ForeignKey(HiveModel.hive_id))
temperature = db.Column(db.Integer)
ext_temperature = db.Column(db.Integer)
ext_humidity = db.Column(db.Integer)
wind = db.Column(db.Integer)
humidity = db.Column(db.Integer)
weight = db.Column(db.Integer)
timestamp = db.Column(db.DateTime(timezone=True), primary_key=True)
class User(db.Model, UserMixin):
__tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
creation_date = db.Column(db.DateTime(), default=datetime.utcnow)
last_login = db.Column(db.DateTime(), default=datetime.utcnow)
is_deleted = db.Column(db.Boolean(), default=False)
is_validated = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
comments = db.relationship('TimedComment', backref='user', lazy='dynamic')
def __init__(self, username, email, password, **kwargs):
self.username = username
self.email = email
self.password = password
def __repr__(self):
return self.username
# Flask-Login integration
def is_authenticated(self):
return True
def is_active(self): # line 37
return True
def is_anonymous(self):
return False
def get_id(self):
return self.id
# Required for administrative interface
def __unicode__(self):
return self.username
class Scan(db.Model):
__tablename__ = 'scans'
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime(), default=datetime.datetime.now())
finished = db.Column(db.DateTime(), default=None, nullable=True)
report = db.relationship('Report', backref='scan', lazy=True, cascade="all,delete", uselist=False)
checkpoints = db.relationship('Checkpoint', backref='scan', lazy=True, cascade='all,delete')
hashid = db.Column(db.String(200), nullable=False)
userid = db.Column(db.Integer(), db.ForeignKey('users.id'), nullable=False)
url = db.Column(db.Text())
alias = db.Column(db.String(200))
def __repr__(self):
return f'[Scan] #{self.id}'
def __init__(self, userid, url, alias, checkpoints):
reportstring = f'{url}-{str(datetime.datetime.now())}-{randint(0, 1000)}'
self.hashid = hashlib.sha256(reportstring.encode('utf-8')).hexdigest()
self.userid = userid
self.url = url
self.alias = alias
self._add_checkpoints(checkpoints)
return
def _add_checkpoints(self, checkpoints):
for checkpoint in checkpoints:
self.checkpoints.append(checkpoint)
db.session.add(self)
db.session.commit()
return
def update_scan_status(self):
self.finished = datetime.datetime.now()
db.session.add(self)
db.session.commit()
return
def add_report(self, seo, accessibility, usability, results):
Report(self.id, seo, accessibility, usability, results)
return
class Files(db.Model):
__tablename__ = 'Files'
file_id = db.Column(db.Integer, primary_key = True)
file_name = db.Column(db.String(200), unique=True)
file_url = db.Column(db.String(1000))
date = db.Column(db.DateTime(), onupdate = datetime.utcnow, default = datetime.utcnow)
history = db.relationship('History', backref = 'file', lazy = 'dynamic')
def __init__(self, file_name, file_url):
self.file_url = file_url
self.file_name = file_name
class Message(db.Model):
messageID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
messageText = db.Column(db.String(250))
senderID = db.Column(db.String(32),
db.ForeignKey('account.username'),
nullable=False)
receiverID = db.Column(db.String(32),
db.ForeignKey('account.username'),
nullable=False)
date = db.Column(db.DateTime())
class Note(db.Model):
noteID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
incidentID = db.Column(db.Integer(),
db.ForeignKey('incident.incidentID'),
nullable=False)
author = db.Column(db.String(32),
db.ForeignKey('account.username'),
nullable=False)
text = db.Column(db.String(250))
date = db.Column(db.DateTime())
class Users(UserMixin, db.Model):
__tablename__ = 'Users'
id = db.Column(db.Integer, primary_key=True)
first = db.Column(db.String(100))
last = db.Column(db.String(100))
email = db.Column(db.String(100))
password = db.Column(db.String(80))
is_master = db.Column(db.Boolean(), default=False)
is_admin = db.Column(db.Boolean(), default=False)
is_verified = db.Column(db.Boolean(), default=False)
join_date = db.Column(db.DateTime(), default=datetime.utcnow)
is_deleted = db.Column(db.Boolean(), default=False)
delete_date = db.Column(db.DateTime(), default=datetime.utcnow)
history_subj = db.relationship("History",
backref='user_info',
foreign_keys=[History.user_id],
order_by='History.date.desc()',
passive_deletes="all")
history_target = db.relationship("History",
backref='tgt_info',
foreign_keys=[History.tgt_user_id],
cascade_backrefs=False)
history = db.relationship(
'History',
primaryjoin=
"or_(Users.id == History.user_id, Users.id == History.tgt_user_id)",
order_by='History.date.desc()')
# query_class = QueryWithSoftDelete
def __init__(self, email):
self.email = email
class ShowSeries(db.Model):
__tablename__ = 'ShowSeries'
id = db.Column(db.Integer, primary_key = True)
site_id = db.Column(db.String(100))
title = db.Column(db.String(100))
description = db.Column(db.String(1000))
parent_id = db.Column(db.Integer, db.ForeignKey('ShowSeries.id'))
add_date = db.Column(db.DateTime(), default = datetime.utcnow)
modify_date = db.Column(db.DateTime(), onupdate = datetime.utcnow)
comments = db.relationship('TimedComment', backref = 'show_series', lazy='dynamic')
urls = db.relationship('ShowSeriesURL', backref = 'show_series', lazy='dynamic')
children = db.relationship("ShowSeries", backref = db.backref('parent',remote_side = id))
def __init__(self, title, **kwargs):
self.title = title
columns = ShowSeries.__table__.columns
for c in columns:
if c.key in kwargs:
setattr(self,c.key, kwargs[c.key])
class IncidentRequestPriority(db.Model):
requestID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
incidentID = db.Column(db.Integer(),
db.ForeignKey('incident.incidentID'),
nullable=False)
username = db.Column(db.String(32), db.ForeignKey('account.username'))
priority = db.Column(db.String(2), nullable=False)
severity = db.Column(db.String(2), nullable=False)
impact = db.Column(db.String(2), nullable=False)
reason = db.Column(db.String(250))
timeRequested = db.Column(db.DateTime())
class Ujian(db.Model):
__tablename__ = 'Ujian'
idUjian = db.Column(db.Integer, primary_key=True, autoincrement=True)
waktu = db.Column(db.DateTime(), nullable=False)
tempat = db.Column(db.String(32))
ruang = db.Column(db.String(32))
status = db.Column(db.String(15))
asesor = db.Column(db.Integer, db.ForeignKey('Asesor.idAsesor'))
def __init__(self, waktu, tempat, ruang, asesor):
self.waktu = waktu
self.tempat = tempat
self.ruang = ruang
self.asesor = asesor
class SessionModel(db.Model):
__tablename__ = 'session'
id = db.Column(db.Integer, primary_key=True)
start_time = db.Column(db.DateTime(), unique=False,
nullable=False) # first timestamp of chat session
report_id = db.Column(db.Integer,
db.ForeignKey('report.id'),
nullable=False)
zoom_names = db.relationship('ZoomNamesModel',
backref='session',
cascade="all,delete",
lazy=True)
class PropertyImgs(db.Model):
__tablename__ = 'PropertyImgs'
img_id = db.Column(db.Integer, primary_key=True)
property_id = db.Column(db.Integer,
db.ForeignKey('Properties.property_id'))
order = db.Column(db.Integer)
img_url = db.Column(db.String(1000))
date_added = db.Column(db.DateTime(),
onupdate=datetime.utcnow,
default=datetime.utcnow)
def __init__(self, property_id, img_url):
self.property_id = property_id
self.img_link = img_url
class Person(db.Model):
__table_args__ = {'extend_existing': True}
__tablename__ = 'person'
id = db.Column(db.Integer, primary_key=True)
type_person = db.Column(db.Boolean)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), nullable=False, unique=True)
phone = db.Column(db.Integer)
id_number = db.Column(db.String(255), nullable=False, unique=True)
id_type = db.Column(db.Integer, db.ForeignKey('id_type.id'))
license = db.Column(db.String(255))
effective_date = db.Column(db.DateTime())
address = db.Column(db.String(255))
def __init__(self,
type_person,
first_name=None,
last_name=None,
email=None,
phone=None,
id_number=None,
id_type=None,
license=None,
effective_date=None,
address=None):
if type_person:
self.type_person = type_person
if first_name:
self.first_name = first_name.lower()
if last_name:
self.last_name = last_name.lower()
if email:
self.email = email.lower()
if phone:
self.phone = phone
if id_number:
self.id_number = id_number
if id_type:
self.id_type = id_type
if license:
self.license = license
if effective_date:
self.effective_date = datetime.strptime(effective_date, "%Y-%m-%d")
if address:
self.address = address.lower()
class IncidentUpdate(db.Model):
updateID = db.Column(db.Integer(),
primary_key=True,
unique=True,
nullable=False)
incidentID = db.Column(db.Integer(),
db.ForeignKey('incident.incidentID'),
nullable=False)
technicianID = db.Column(db.String(32),
db.ForeignKey('account.username'),
nullable=False)
# priority = db.Column(db.String(2), nullable=False)
# severity = db.Column(db.String(2), nullable=False)
# impact = db.Column(db.String(2), nullable=False)
description = db.Column(db.String(250))
updateType = db.Column(db.String(32))
timeSpent = db.Column(db.Integer(), nullable=False)
date = db.Column(db.DateTime())
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
first_name = db.Column(db.String(150))
last_name = db.Column(db.String(150))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users)
applications = db.relationship('Application', backref='user')
@classmethod
def authenticate(cls, args):
user = User.query.filter_by(email=args['email']).first()
if user and verify_password(args['password'], user.password):
return user
return False
def name(self):
return '{} {}'.format(self.first_name, self.last_name)
class Replay(db.Model):
id = db.Column(db.Integer, primary_key=True)
player = db.Column(db.String(255))
color = db.Column(db.String(7))
challenge = db.Column(db.String(80))
replay = db.Column(db.Text())
created = db.Column(db.DateTime(), default=datetime.datetime.now)
def __init__(self, player, color, challenge, replay):
self.player = player
self.color = color
self.challenge = challenge
self.replay = replay
def __repr__(self):
return '<Replay {0}: {1} on {2} (created {3})>'.format(
self.id, self.player, self.challenge, self.created)
class ReportModel(db.Model):
__tablename__ = 'report'
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.Text(), unique=False, nullable=True)
report_time = db.Column(
db.DateTime(), unique=False, nullable=False
) # first timestamp of chat file, date by user or date of the request
class_id = db.Column(db.Integer,
db.ForeignKey('classroom.id'),
nullable=False)
sessions = db.relationship('SessionModel',
backref='report',
cascade="all,delete",
lazy=True)
student_statuses = db.relationship('StudentStatus',
backref='report',
cascade="all,delete",
lazy=True)
class Database(db.Model):
"""
Represents general information about the database
Attributes
----------
name : str
Name of the database.
size : int
size of the database, in bytes.
ttl_last_execution : datetime
Last time the ttl script ran on the database.
ttl_duration : int
duration of the last ttl script execution, in s.
backup_last_id : str
id of the last backup.
backup_duration : int
duration of the last backup execution, in s.
backup_last_execution : int
time of the end of the last backup execution.
backup_size : int
size of the last backup, in bytes.
backup_error : str
error message, if any, of the last backup.
"""
__tablename__ = 'Database'
name = db.Column(db.String(), nullable=False, primary_key=True)
size = db.Column(db.Integer(), nullable=False)
ttl_last_execution = db.Column(db.DateTime(), nullable=True)
ttl_duration = db.Column(db.Integer(), nullable=True)
backup_last_id = db.Column(db.String(), nullable=True)
backup_duration = db.Column(db.Integer(), nullable=True)
backup_last_execution = db.Column(db.Integer(), nullable=True)
backup_size = db.Column(db.Integer(), nullable=True)
backup_error = db.Column(db.String(), nullable=False)
def __init__(self, name):
self.name = name
self.size = 0
self.backup_error = ""
class Highscore(db.Model):
id = db.Column(db.Integer, primary_key=True)
player = db.Column(db.String(255))
color = db.Column(db.String(7))
score = db.Column(db.Integer)
challenge_scores = db.Column(db.Text)
created = db.Column(db.DateTime(), default=datetime.datetime.now)
def __init__(self, player, color, score, challenge_scores):
self.player = player
self.color = color
self.score = score
self.challenge_scores = challenge_scores
def __repr__(self):
return '<Highscore {0}: {1} scored {2} (created {3})>'.format(
self.id, self.player, self.score, self.created)
class History(db.Model):
__tablename__ = 'History'
history_id = db.Column(db.Integer, primary_key=True)
type = db.Column(db.String(20))
user_id = db.Column(db.Integer, db.ForeignKey('Users.id'))
tgt_user_id = db.Column(db.Integer, db.ForeignKey('Users.id'))
tgt_prop_id = db.Column(db.Integer,
db.ForeignKey('Properties.property_id'))
tgt_acn_id = db.Column(db.Integer, db.ForeignKey('Associations.acn_id'))
tgt_file_id = db.Column(db.Integer, db.ForeignKey('Files.file_id'))
tgt_about_id = db.Column(db.Integer,
db.ForeignKey('AboutInfo.aboutinfo_id'))
is_deleted = db.Column(db.Boolean(), default=False)
date = db.Column(db.DateTime(), default=datetime.utcnow)
content = db.relationship('HistoryContent',
backref='row_content',
lazy='dynamic')
# user = db.relationship('Users', backref='history', lazy='dynamic')
# tgt_user = db.relationship('Users', backref='history', lazy='dynamic')
def __init__(self, type, user_id, **kwargs):
self.type = type
self.user_id = user_id
# if 'content' in kwargs:
# self.content = kwargs['content']
if 'tgt_prop_id' in kwargs:
self.tgt_prop_id = kwargs['tgt_prop_id']
if 'tgt_user_id' in kwargs:
self.tgt_user_id = kwargs['tgt_user_id']
if 'tgt_acn_id' in kwargs:
self.tgt_acn_id = kwargs['tgt_acn_id']
if 'tgt_file_id' in kwargs:
self.tgt_file_id = kwargs['tgt_file_id']
if 'tgt_about_id' in kwargs:
self.tgt_about_id = kwargs['tgt_about_id']
