class IssuesAndReminders(UserMixin, DB.Model):
"""
Class representation of issues_and_reminders table
"""
__tablename__ = "issues_and_reminders"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
iar_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
detail = DB.Column(DB.String(360))
user_id = DB.Column(DB.Integer, DB.ForeignKey(
"commons_db.users.user_id"), nullable=False)
ts_posted = DB.Column(DB.DateTime, nullable=False)
ts_expiration = DB.Column(DB.DateTime)
resolved_by = DB.Column(DB.Integer)
resolution = DB.Column(DB.String(360))
ts_resolved = DB.Column(DB.DateTime)
postings = DB.relationship(
"IssuesRemindersSitePostings", backref=DB.backref("issue_and_reminder", lazy="joined"), lazy="subquery")
# Louie - Relationship
issue_reporter = DB.relationship(
"Users", backref="issue_and_reminder", lazy="joined")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> IAR ID: {self.iar_id}"
f" Detail: {self.detail} user_id: {self.user_id}"
f" ts_posted: {self.ts_posted} ts_expiration: {self.ts_expiration}"
f" resolved_by: {self.resolved_by} resolution: {self.resolution}")
class OldMonitoringManifestation(UserMixin, DB.Model):
"""
Class representation of public_alert_manifestation table
"""
__tablename__ = "public_alert_manifestation"
manifestation_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
release_id = DB.Column(DB.Integer, DB.ForeignKey(
"public_alert_release.release_id"))
feature_id = DB.Column(DB.Integer, DB.ForeignKey(
"manifestation_features.feature_id"), nullable=False)
ts_observance = DB.Column(DB.DateTime, nullable=False)
reporter = DB.Column(DB.String(50), nullable=False)
remarks = DB.Column(DB.String(500))
narrative = DB.Column(DB.String(500))
validator = DB.Column(
DB.Integer, DB.ForeignKey("comms_db.users.user_id"))
op_trigger = DB.Column(DB.Integer, nullable=False)
release = DB.relationship(
"OldMonitoringReleases", backref=DB.backref("manifestation_details", lazy=True))
# manifestation_feature = DB.relationship("OldMonitoringManifestationFeatures", backref="manifestation", lazy=True)
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Manifestation ID: {self.manifestation_id}"
f" ts_observance: {self.ts_observance} Remarks: {self.remarks}"
f" release: {self.release}")
class UserAccounts(DB.Model):
"""
Class representation of user_teams table
"""
__tablename__ = "user_accounts"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
account_id = DB.Column(DB.Integer, primary_key=True)
user_fk_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.users.user_id"))
username = DB.Column(DB.String(45))
password = DB.Column(DB.String(200))
is_active = DB.Column(DB.Integer, nullable=True)
salt = DB.Column(DB.String(200))
user = DB.relationship(Users,
backref=DB.backref("account",
lazy="raise",
innerjoin=True),
lazy="joined",
uselist=False)
def __repr__(self):
return f"{self.email}"
class MarkerObservations(DB.Model):
"""
Class representation of marker_observations table
"""
__tablename__ = "marker_observations"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
mo_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
site_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.sites.site_id"),
nullable=False)
ts = DB.Column(DB.DateTime)
meas_type = DB.Column(DB.String(10))
observer_name = DB.Column(DB.String(100))
data_source = DB.Column(DB.String(3))
reliability = DB.Column(DB.Integer)
weather = DB.Column(DB.String(20))
site = DB.relationship("Sites",
backref=DB.backref("marker_observations",
lazy="dynamic"),
lazy="select")
# marker_data = DB.relationship(
# "MarkerData", backref="marker_observation_report", lazy="subquery")
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> MO ID: {self.mo_id}"
f" Site ID: {self.site_id} Meas Type: {self.meas_type}"
f" TS: {self.ts} Reliability: {self.reliability}"
f" Observer Name: {self.observer_name} Data Source: {self.data_source}"
)
class OperationalTriggerSymbols(UserMixin, DB.Model):
"""
Class representation of operational_triggers table
"""
__tablename__ = "operational_trigger_symbols"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
trigger_sym_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
alert_level = DB.Column(DB.Integer, nullable=False)
alert_symbol = DB.Column(DB.String(2), nullable=False)
alert_description = DB.Column(DB.String(100), nullable=False)
source_id = DB.Column(
DB.Integer,
DB.ForeignKey("ewi_db.trigger_hierarchies.source_id"),
nullable=False)
trigger_hierarchy = DB.relationship("TriggerHierarchies",
backref="trigger_symbols",
lazy="joined",
innerjoin=True) # lazy="select")
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Trigger Symbol ID: {self.trigger_sym_id}"
f" Alert Level: {self.alert_level} Alert Symbol: {self.alert_symbol}"
f" Alert Desc: {self.alert_description} Source ID: {self.source_id}"
f" | Trigger_Hierarchy {self.trigger_hierarchy}")
class InternalAlertSymbols(UserMixin, DB.Model):
"""
Class representation of internal_alert_symbols table
"""
__tablename__ = "internal_alert_symbols"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
internal_sym_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
alert_symbol = DB.Column(DB.String(4), nullable=False)
trigger_sym_id = DB.Column(
DB.Integer,
DB.ForeignKey("ewi_db.operational_trigger_symbols.trigger_sym_id"),
nullable=False)
alert_description = DB.Column(DB.String(120))
trigger_symbol = DB.relationship("OperationalTriggerSymbols",
lazy="select",
uselist=False,
backref=DB.backref(
"internal_alert_symbol",
lazy="select",
uselist=False))
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Internal Sym ID: {self.internal_sym_id}"
f" Alert Symbol: {self.alert_symbol} Trigger Sym ID: {self.trigger_sym_id}"
f" Alert Description: {self.alert_description} "
f" OP Trigger Symbols: {self.trigger_symbol}")
class GsmModules(DB.Model):
"""
"""
__tablename__ = "gsm_modules"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
gsm_id = DB.Column(DB.Integer, primary_key=True)
gsm_server_id = DB.Column(
DB.Integer, DB.ForeignKey("comms_db_3.gsm_servers.gsm_server_id"))
gsm_name = DB.Column(DB.String(10))
gsm_sim_num = DB.Column(DB.String(12))
network_id = DB.Column(
DB.Integer, DB.ForeignKey("comms_db_3.network_carriers.network_id"))
ser_port = DB.Column(DB.String(20))
pwr_on_pin = DB.Column(DB.Integer, nullable=True)
ring_pin = DB.Column(DB.Integer, nullable=True)
module_type = DB.Column(DB.Integer, nullable=True)
gsm_server = DB.relationship("GsmServers",
backref=DB.backref("gsm_modules",
lazy="subquery"),
lazy="raise")
network = DB.relationship("NetworkCarriers",
backref=DB.backref("gsm_modules",
lazy="subquery"),
lazy="select")
def __repr__(self):
return f"{self.gsm_name}\n"
class OldMonitoringReleases(UserMixin, DB.Model):
"""
Class representation of public_alert_release table
"""
__tablename__ = "public_alert_release"
release_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
event_id = DB.Column(DB.Integer, DB.ForeignKey(
"public_alert_event.event_id"), nullable=False)
data_timestamp = DB.Column(
DB.DateTime, nullable=False, default="0000-00-00 00:00:00")
internal_alert_level = DB.Column(DB.String(10), nullable=False)
release_time = DB.Column(DB.DateTime, nullable=False)
comments = DB.Column(DB.String(200))
bulletin_number = DB.Column(DB.Integer, nullable=False)
reporter_id_mt = DB.Column(DB.Integer, DB.ForeignKey(
"comms_db.users.user_id"), nullable=False)
reporter_id_ct = DB.Column(DB.Integer, DB.ForeignKey(
"comms_db.users.user_id"), nullable=False)
triggers = DB.relationship(
"OldMonitoringTriggers", backref="release", lazy="subquery")
reporter_mt = DB.relationship(
"OldUsers", backref="reporter_mts", primaryjoin="OldMonitoringReleases.reporter_id_mt==OldUsers.user_id", lazy="joined")
reporter_ct = DB.relationship(
"OldUsers", backref="reporter_cts", primaryjoin="OldMonitoringReleases.reporter_id_ct==OldUsers.user_id", lazy="joined")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Release ID: {self.release_id}"
f" Event ID: {self.event_id} Data TS: {self.data_timestamp}"
f" Int Alert Lvl: {self.internal_alert_level} Bulletin No: {self.bulletin_number}"
f" Release: {self.internal_alert_level} ")
class SmsOutboxLoggers(DB.Model):
__tablename__ = "smsoutbox_loggers"
__bind_key__ = "comms_db_3"
outbox_id = DB.Column(DB.Integer, primary_key=True)
ts_written = DB.Column(DB.DateTime, default=datetime.datetime.utcnow)
source = DB.Column(DB.String(10))
sms_msg = DB.Column(DB.String(1000))
def __repr__(self):
return f"Type <{self.sms_msg}>"
class RiskProfile(DB.Model):
"""
Class representation of ewi_templates table
"""
__tablename__ = "risk_profile"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
risk_profile_id = DB.Column(DB.Integer, primary_key=True)
entry = DB.Column(DB.String(1000))
timestamp = DB.Column(DB.String(45))
def __repr__(self):
return f"Class Representation"
class Sites(UserMixin, DB.Model):
"""
Class representation of Sites table
"""
__tablename__ = "sites"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
site_id = DB.Column(TINYINT, primary_key=True)
site_code = DB.Column(DB.String(3), nullable=False)
purok = DB.Column(DB.String(45))
sitio = DB.Column(DB.String(45))
barangay = DB.Column(DB.String(45), nullable=False)
municipality = DB.Column(DB.String(45), nullable=False)
province = DB.Column(DB.String(45), nullable=False)
region = DB.Column(DB.String(45), nullable=False)
active = DB.Column(DB.Boolean, nullable=False, default=True)
psgc = DB.Column(DB.Integer, nullable=False)
households = DB.Column(DB.String(255), nullable=False)
season = DB.Column(
DB.Integer, DB.ForeignKey("commons_db.seasons.season_group_id"))
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Site ID: {self.site_id}"
f" Site Code: {self.site_code}")
class GintagsReference(DB.Model):
"""
Class representation of general_data_references table
"""
__tablename__ = "gintags_reference"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
tag_id = DB.Column(DB.Integer, primary_key=True)
tag_name = DB.Column(DB.String(200))
tag_description = DB.Column(DB.String(1000))
def __repr__(self):
return f"Class Representation"
class ResourcesAndCapacities(DB.Model):
"""
Class representation of resources_and_capacities table
"""
__tablename__ = "resources_and_capacities"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
resources_and_capacities_id = DB.Column(DB.Integer, primary_key=True)
resource_and_capacity = DB.Column(DB.String(100))
status = DB.Column(DB.String(45))
owner = DB.Column(DB.String(45))
def __repr__(self):
return f"Class Representation"
class GsmServers(DB.Model):
"""
"""
__tablename__ = "gsm_servers"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
gsm_server_id = DB.Column(DB.Integer, primary_key=True)
name = DB.Column(DB.String(45))
platform_type = DB.Column(DB.String(45))
version = DB.Column(DB.Integer, nullable=True)
def __repr__(self):
return f"{self.name}\n"
class UserTeams(DB.Model):
"""
Class representation of user_teams table
"""
__tablename__ = "user_teams"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
team_id = DB.Column(DB.Integer, primary_key=True)
team_code = DB.Column(DB.String(20))
team_name = DB.Column(DB.String(20))
remarks = DB.Column(DB.String(45))
def __repr__(self):
return f"{self.team_code}"
class UserLandlines(DB.Model):
"""
Class representation of user_landlines table
"""
__tablename__ = "user_landlines"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
landline_id = DB.Column(DB.Integer, primary_key=True)
user_id = DB.Column(DB.Integer, DB.ForeignKey("commons_db.users.user_id"))
landline_num = DB.Column(DB.String(30))
remarks = DB.Column(DB.String(45))
def __repr__(self):
return f"Type <{self.landline_num}"
class MonitoringReleasePublishers(UserMixin, DB.Model):
"""
Class representation of monitoring_release_publishers table
"""
__tablename__ = "monitoring_release_publishers"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
publisher_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
release_id = DB.Column(
DB.Integer,
DB.ForeignKey("ewi_db.monitoring_releases.release_id"),
nullable=False)
user_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.users.user_id"),
nullable=False)
role = DB.Column(DB.String(45))
user_details = DB.relationship("Users",
backref=DB.backref("publisher",
lazy="select"),
lazy="joined",
innerjoin=True)
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Publisher ID: {self.publisher_id}"
f" Release ID: {self.release_id} User ID: {self.user_id}"
f" User Details: {self.user_details}")
class RiskAssessmentSummary(DB.Model):
"""
Class representation of ewi_templates table
"""
__tablename__ = "risk_assessment_summary"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
summary_id = DB.Column(DB.Integer, primary_key=True)
location = DB.Column(DB.String(150))
impact = DB.Column(DB.String(45))
adaptive_capacity = DB.Column(DB.String(45))
vulnerability = DB.Column(DB.String(45))
def __repr__(self):
return f"Class Representation"
class Loggers(DB.Model):
"""
Class representation of loggers table
"""
__tablename__ = "loggers"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
logger_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
site_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.sites.site_id"),
nullable=False)
logger_name = DB.Column(DB.String(7))
date_activated = DB.Column(DB.Date)
date_deactivated = DB.Column(DB.Date)
latitude = DB.Column(DB.Float)
longitude = DB.Column(DB.Float)
model_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.logger_models.model_id"),
nullable=False)
site = DB.relationship("Sites",
backref=DB.backref("loggers", lazy="dynamic"))
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Logger ID: {self.logger_id}"
f" Site_ID: {self.site_id} Logger NAme: {self.logger_name}"
f" Date Activated: {self.date_activated} Latitude: {self.latitude}"
)
class LoggerModels(DB.Model):
"""
Class representation of logger_models table
"""
__tablename__ = "logger_models"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
model_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
has_tilt = DB.Column(DB.Integer)
has_rain = DB.Column(DB.Integer)
has_piezo = DB.Column(DB.Integer)
has_soms = DB.Column(DB.Integer)
logger_type = DB.Column(DB.String(10))
loggers = DB.relationship("Loggers",
backref="logger_model",
lazy="subquery")
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> TSM ID: {self.tsm_id}"
f" TSM Name: {self.tsm_name} Number of Segments: {self.number_of_segments}"
f"Date Activated: {self.date_activated}")
class MomsFeatureAlerts(UserMixin, DB.Model):
"""
Class representation of moms_features table
"""
__tablename__ = "moms_feature_alerts"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
feature_alert_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
feature_id = DB.Column(DB.Integer,
DB.ForeignKey("ewi_db.moms_features.feature_id"),
nullable=False)
alert_level = DB.Column(DB.Integer)
description = DB.Column(DB.String(500))
feature = DB.relationship("MomsFeatures",
backref=DB.backref("alerts", lazy="subquery"),
lazy="select")
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Feature ID: {self.feature_alert_id}"
f" Feature Type: {self.feature_id} Alert Level: {self.alert_level}"
)
class MomsInstances(UserMixin, DB.Model):
"""
Class representation of moms_instances table
"""
__tablename__ = "moms_instances"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
instance_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
site_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.sites.site_id"),
nullable=False)
feature_id = DB.Column(DB.Integer,
DB.ForeignKey("ewi_db.moms_features.feature_id"),
nullable=False)
feature_name = DB.Column(DB.String(45))
site = DB.relationship("Sites",
backref=DB.backref("moms_instance", lazy="raise"))
feature = DB.relationship("MomsFeatures",
backref=DB.backref("instances", lazy="dynamic"),
lazy="joined",
innerjoin=True)
# site = DB.relationship("Sites", backref="moms_instance", lazy=True)
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Instance ID: {self.instance_id}"
f" Site ID: {self.site_id} Feature Name: {self.feature_name}")
class MonitoringTriggers(UserMixin, DB.Model):
"""
Class representation of monitoring_triggers table
"""
__tablename__ = "monitoring_triggers"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
trigger_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
release_id = DB.Column(
DB.Integer,
DB.ForeignKey("ewi_db.monitoring_releases.release_id"),
nullable=False)
internal_sym_id = DB.Column(
DB.Integer,
DB.ForeignKey("ewi_db.internal_alert_symbols.internal_sym_id"),
nullable=False)
ts = DB.Column(DB.DateTime, nullable=False)
info = DB.Column(DB.String(360))
internal_sym = DB.relationship(
"InternalAlertSymbols", backref=DB.backref("monitoring_triggers", \
lazy="dynamic"), lazy="joined", innerjoin=True)
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Trigger ID: {self.trigger_id}"
f" Release ID: {self.release_id} Internal Symbol ID: {self.internal_sym_id}"
f" TS: {self.ts} Info: {self.info}")
class SituationReport(DB.Model):
"""
Class representation of field_survey_logs table
"""
__tablename__ = "situation_report"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
situation_report_id = DB.Column(DB.Integer, primary_key=True)
timestamp = DB.Column(DB.String(45))
summary = DB.Column(DB.String(1000))
pdf_path = DB.Column(DB.String(255))
image_path = DB.Column(DB.String(255))
def __repr__(self):
return f"Class Representation"
class NodeAlerts(DB.Model):
"""
Class representation of node_alerts table
"""
__tablename__ = "node_alerts"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
na_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
ts = DB.Column(DB.DateTime, nullable=False)
tsm_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.tsm_sensors.tsm_id"),
nullable=False)
# Node ID, no need for relationships for the moment
node_id = DB.Column(DB.Integer, nullable=False)
disp_alert = DB.Column(DB.Integer, nullable=False)
vel_alert = DB.Column(DB.String(10), nullable=False)
na_status = DB.Column(DB.Integer)
tsm_sensor = DB.relationship("TSMSensors",
backref=DB.backref("node_alerts",
lazy="dynamic"),
lazy="subquery")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> NodeAlert ID: {self.na_id}"
f" ts: {self.ts} tsm_id: {self.tsm_id} node_id: {self.node_id}"
f" disp_alert: {self.disp_alert}"
f" vel_alert: {self.vel_alert} na_status: {self.na_status}"
f" || tsm_sensor: {self.tsm_sensor}")
class EarthquakeEvents(DB.Model):
"""
Class representation of earthquake_events table
"""
__tablename__ = "earthquake_events"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
eq_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
ts = DB.Column(DB.DateTime)
magnitude = DB.Column(DB.Float(4, 2))
depth = DB.Column(DB.Float(5, 2))
latitude = DB.Column(DB.Float(9, 6))
longitude = DB.Column(DB.Float(9, 6))
critical_distance = DB.Column(DB.Float(6, 3))
issuer = DB.Column(DB.String(20))
processed = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> EQ_ID: {self.eq_id}"
f" Magnitude: {self.magnitude} Depth: {self.depth}"
f" Critical Distance: {self.critical_distance} issuer: {self.issuer}"
)
class AlertStatusSync(DB.Model):
"""
Class representation of alert_status_sync table
"""
__tablename__ = "alert_status_sync"
__bind_key__ = "analysis_db"
__table_args__ = {"schema": "analysis_db"}
as_update_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
stat_id = DB.Column(DB.Integer, nullable=False)
ts_last_retrigger = DB.Column(DB.DateTime)
trigger_id = DB.Column(DB.Integer)
ts_set = DB.Column(DB.DateTime)
ts_ack = DB.Column(DB.DateTime)
alert_status = DB.Column(DB.Integer)
remarks = DB.Column(DB.String(450))
user_id = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> as_update_id: {self.as_update_id} stat ID: {self.stat_id}"
f" ts_last_retrigger: {self.ts_last_retrigger} ts_set: {self.ts_set}"
f" ts_ack: {self.ts_ack} alert_status: {self.alert_status}"
f" remarks: {self.remarks} user_id: {self.user_id}"
f" || TRIGGER: {self.trigger} || user: {self.user}")
class HazardData(DB.Model):
"""
Class representation of hazard_data table
"""
__tablename__ = "hazard_data"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
hazard_data_id = DB.Column(DB.Integer, primary_key=True)
hazard = DB.Column(DB.String(45))
speed_of_onset = DB.Column(DB.String(45))
early_warning = DB.Column(DB.String(100))
impact = DB.Column(DB.String(100))
def __repr__(self):
return f"Class Representation"
class MonitoringEvents(UserMixin, DB.Model):
"""
Class representation of monitoring_events table
"""
__tablename__ = "monitoring_events"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
event_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
site_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.sites.site_id"),
nullable=False)
event_start = DB.Column(DB.DateTime, nullable=False)
validity = DB.Column(DB.DateTime)
status = DB.Column(DB.String(20), nullable=False)
event_alerts = DB.relationship(
"MonitoringEventAlerts",
order_by="desc(MonitoringEventAlerts.ts_start)",
backref=DB.backref("event", lazy="joined", innerjoin=True),
lazy="subquery")
site = DB.relationship(Sites,
backref=DB.backref("monitoring_events",
lazy="dynamic"),
lazy="joined",
innerjoin=True)
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Event ID: {self.event_id}"
f" Site ID: {self.site_id} Validity: {self.validity}"
f" Status: {self.status}")
class UserOrganizations(DB.Model):
"""
Class representation of user_organization table
"""
__tablename__ = "user_organizations"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
user_org_id = DB.Column(DB.Integer, primary_key=True)
user_id = DB.Column(DB.Integer, DB.ForeignKey("commons_db.users.user_id"))
site_id = DB.Column(DB.Integer, DB.ForeignKey("commons_db.sites.site_id"))
org_name = DB.Column(DB.String(45))
org_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.organizations.org_id"))
site = DB.relationship(
Sites,
backref=DB.backref("user", lazy="select"),
primaryjoin="UserOrganizations.site_id==Sites.site_id",
lazy="joined",
innerjoin=True)
organization = DB.relationship(
Organizations,
backref=DB.backref("users", lazy="subquery"),
primaryjoin="UserOrganizations.org_id==Organizations.org_id",
lazy="joined",
innerjoin=True)
def __repr__(self):
return f"{self.org_name}"
