class RainfallThresholds(DB.Model):
"""
Class representation of rainfall_thresholds table
"""
__tablename__ = "rainfall_thresholds"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
rt_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)
threshold_name = DB.Column(DB.String(12), nullable=False)
threshold_value = DB.Column(DB.Float(8, 5), nullable=False)
site = DB.relationship("Sites",
backref=DB.backref("rainfall_thresholds",
lazy="dynamic"),
lazy="subquery")
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Rain Threshold ID: {self.rt_id}"
f" Site ID: {self.site_id} Thres Name: {self.threshold_name}"
f" Threshold Value: {self.threshold_value}")
class MarkerData(DB.Model):
"""
Class representation of marker_data table
"""
__tablename__ = "marker_data"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
data_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
mo_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.marker_observations.mo_id"),
nullable=False)
marker_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.markers.marker_id"),
nullable=False)
measurement = DB.Column(DB.Float)
marker = DB.relationship("Markers",
backref=DB.backref("marker_data", lazy="dynamic"),
lazy="select")
marker_observation = DB.relationship("MarkerObservations",
backref=DB.backref("marker_data",
lazy="subquery"),
lazy="select")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Data ID: {self.data_id}"
f" Marker ID: {self.marker_id} Measurement: {self.measurement}"
f" Marker Obs ID: {self.mo_id}")
class RainfallPriorities(DB.Model):
"""
Class representation of rainfall_priorities table
"""
__tablename__ = "rainfall_priorities"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
priority_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
rain_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.rainfall_gauges.rain_id"),
nullable=False)
site_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.sites.site_id"),
nullable=False)
distance = DB.Column(DB.Float(5, 2), nullable=False)
site = DB.relationship("Sites",
backref=DB.backref("rainfall_priorities",
lazy="dynamic"),
lazy="subquery")
rainfall_gauge = DB.relationship("RainfallGauges",
backref=DB.backref("rainfall_priorities",
lazy="dynamic"),
lazy="subquery")
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Priority ID: {self.priority_id}"
f" Rain ID: {self.rain_id} Distance: {self.distance}")
class MarkerHistory(DB.Model):
"""
Class representation of marker_history table
"""
__tablename__ = "marker_history"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
history_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
marker_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.markers.marker_id"),
nullable=False)
ts = DB.Column(DB.DateTime)
event = DB.Column(DB.String(20))
marker = DB.relationship("Markers",
backref=DB.backref("marker_histories",
lazy="dynamic"),
lazy="subquery")
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> History ID: {self.history_id}"
f" Marker ID: {self.marker_id} TS: {self.ts}"
f" Event: {self.event}")
class PublicAlerts(UserMixin, DB.Model):
"""
Class representation of public_alerts
"""
__tablename__ = "public_alerts"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
public_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
ts = DB.Column(DB.DateTime, nullable=False)
site_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.sites.site_id"),
nullable=False)
pub_sym_id = DB.Column(
DB.Integer,
DB.ForeignKey("ewi_db.public_alert_symbols.pub_sym_id"),
nullable=False)
ts_updated = DB.Column(DB.DateTime, nullable=False)
site = DB.relationship("Sites",
backref=DB.backref("public_alerts", lazy="dynamic"),
lazy="select")
# primaryjoin="PublicAlerts.site_id==Sites.site_id", lazy="joined", innerjoin=True)
alert_symbol = DB.relationship("PublicAlertSymbols",
backref="public_alerts",
lazy="select")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Public_ID: {self.public_id}"
f" Site_ID: {self.site_id} pub_sym_id: {self.pub_sym_id}"
f" TS: {self.ts} TS_UPDATED: {self.ts_updated}")
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 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 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}"
class IssuesRemindersSitePostings(UserMixin, DB.Model):
"""
Class representation of earthquake_events table
"""
__tablename__ = "issues_reminders_site_postings"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
iar_id = DB.Column(DB.Integer, DB.ForeignKey(
"commons_db.issues_and_reminders.iar_id"), primary_key=True)
site_id = DB.Column(DB.Integer, DB.ForeignKey(
"commons_db.sites.site_id"), primary_key=True)
event_id = DB.Column(DB.Integer, DB.ForeignKey(
"ewi_db.monitoring_events.event_id"))
event = DB.relationship(
"MonitoringEvents", backref=DB.backref("issues_reminders_site_posting", lazy="raise"), lazy="joined")
site = DB.relationship(
"Sites", backref=DB.backref("issues_reminders_site_posting", lazy="raise"), lazy="joined")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> iar_p_id: {self.iar_p_id}"
f" site_id: {self.site_id} event_id: {self.event_id}"
f" iar_id: {self.iar_id}")
class EarthquakeAlerts(DB.Model):
"""
Class representation of earthquake_alerts table
"""
__tablename__ = "earthquake_alerts"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
ea_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
eq_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.earthquake_events.eq_id"),
nullable=False)
site_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.sites.site_id"),
nullable=False)
distance = DB.Column(DB.Float(5, 3), nullable=False)
eq_event = DB.relationship("EarthquakeEvents",
backref=DB.backref("eq_alerts",
lazy="subquery"),
lazy="select")
site = DB.relationship("Sites",
backref=DB.backref("eq_alerts", lazy="dynamic"),
lazy="select")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> EQ Alert ID: {self.ea_id}"
f" Site ID: {self.site_id} Distance: {self.distance}")
class DataPresenceLoggers(DB.Model):
"""
Class representation of data_presence_loggers
"""
__tablename__ = "data_presence_loggers"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
logger_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.loggers.logger_id"),
primary_key=True)
presence = DB.Column(DB.Integer)
last_data = DB.Column(DB.DateTime)
ts_updated = DB.Column(DB.DateTime)
diff_days = DB.Column(DB.Integer)
logger = DB.relationship(
"Loggers",
backref="data_presence",
lazy="joined",
innerjoin=True,
primaryjoin="DataPresenceLoggers.logger_id==Loggers.logger_id")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> logger_id: {self.logger_id}"
f" presence: {self.presence} last_data: {self.last_data}"
f" ts_updated: {self.ts_updated} diff_days: {self.diff_days}")
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 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 UserMobiles(DB.Model):
"""
Class representation of user_mobiles table
"""
__tablename__ = "user_mobiles"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
user_id = DB.Column(SMALLINT, DB.ForeignKey(
"commons_db.users.user_id"), primary_key=True)
mobile_id = DB.Column(SMALLINT, DB.ForeignKey(
"comms_db_3.mobile_numbers.mobile_id"), primary_key=True)
priority = DB.Column(TINYINT)
status = DB.Column(TINYINT, nullable=False)
user = DB.relationship(UsersRelationship, backref=DB.backref(
"mobile_numbers", lazy="raise"),
lazy="joined", innerjoin=True)
mobile_number = DB.relationship(MobileNumbers, backref=DB.backref(
"user_details", lazy="joined", uselist=False),
lazy="joined", innerjoin=True)
def __repr__(self):
return (f"Type <{self.__class__.__name__}> User ID: {self.user_id}"
f" Mobile ID: {self.mobile_id} Priority: {self.priority}"
f" Status: {self.status}")
class MonitoringTriggersMisc(UserMixin, DB.Model):
"""
Class representation of monitoring_release_publishers table
"""
__tablename__ = "monitoring_triggers_misc"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
trig_misc_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
trigger_id = DB.Column(
DB.Integer,
DB.ForeignKey("ewi_db.monitoring_triggers.trigger_id"),
nullable=False)
od_id = DB.Column(DB.Integer,
DB.ForeignKey("ewi_db.monitoring_on_demand.od_id"))
eq_id = DB.Column(DB.Integer,
DB.ForeignKey("ewi_db.monitoring_earthquake.eq_id"))
# Changed to has_moms to accommodate multiple moms
has_moms = DB.Column(DB.Boolean)
trigger_parent = DB.relationship("MonitoringTriggers",
backref=DB.backref("trigger_misc",
lazy="joined",
uselist=False),
lazy="subquery",
uselist=False)
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Trigger Misc ID: {self.trig_misc_id}"
f" Trigger ID: {self.trigger_id} OD ID: {self.od_id}"
f" EQ ID: {self.eq_id} Has Moms: {self.has_moms}")
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 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 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 Users(DB.Model, UserMixin):
"""
Class representation of users table
"""
__tablename__ = "users"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
user_id = DB.Column(DB.Integer, primary_key=True)
salutation = DB.Column(DB.String(15))
first_name = DB.Column(DB.String(45))
middle_name = DB.Column(DB.String(45))
last_name = DB.Column(DB.String(45))
nickname = DB.Column(DB.String(45))
sex = DB.Column(DB.String(1))
status = DB.Column(DB.Integer, nullable=True)
birthday = DB.Column(DB.DateTime)
ewi_recipient = DB.Column(DB.Integer, nullable=True)
def get_id(self):
"""Filler docstring"""
return self.user_id
def __repr__(self):
return (f"Type <{self.__class__.__name__}> User ID: {self.user_id}"
f" First Name: {self.first_name} Last Name: {self.last_name}"
f" Status: {self.status}")
class BlockedMobileNumbers(DB.Model):
"""
Class representation of blocked_mobile_numbers table
"""
__tablename__ = "blocked_mobile_numbers"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
mobile_id = DB.Column(SMALLINT, DB.ForeignKey(
"comms_db_3.mobile_numbers.mobile_id"), primary_key=True)
reason = DB.Column(DB.String(500), nullable=False)
reporter_id = DB.Column(SMALLINT, DB.ForeignKey(
"commons_db.users.user_id"))
ts = DB.Column(DB.DateTime, nullable=False)
reporter = DB.relationship(Users, backref=DB.backref(
"blocked_mobile_numbers", lazy="raise"),
lazy="joined", innerjoin=True)
mobile_number = DB.relationship(MobileNumbers, backref=DB.backref(
"blocked_mobile"),
lazy="joined", innerjoin=True)
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Mobile ID: {self.mobile_id}"
f" Reason: {self.reason} Reporter ID: {self.user_id}"
f" TS: {self.ts}")
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 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 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 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 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 UserAlertInfo(DB.Model):
__tablename__ = "user_alert_info"
__bind_key__ = "comms_db_3"
uai_id = DB.Column(DB.Integer, primary_key=True)
send_alert = DB.Column(DB.Integer, nullable=False)
user_id = DB.Column(DB.Integer, DB.ForeignKey("users.user_id"))
def __repr__(self):
return f"Type <{self.send_alert}>"
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 NetworkCarriers(DB.Model):
"""
Class representation of network_carrier table
"""
__tablename__ = "network_carriers"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
network_id = DB.Column(DB.Integer, primary_key=True)
carrier = DB.Column(DB.String(45))
def __repr__(self):
return f"Class Representation"
class LoggerMobile(DB.Model):
__tablename__ = "logger_mobile"
__bind_key__ = "comms_db_3"
mobile_id = DB.Column(DB.Integer, primary_key=True)
logger_id = DB.Column(DB.Integer, nullable=False)
date_activated = DB.Column(DB.DateTime, default=datetime.datetime.utcnow)
sim_num = DB.Column(DB.String(12))
gsm_id = DB.Column(DB.Integer, nullable=False)
def __repr__(self):
return f"{self.date_activated}\n"
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"
