class Narratives(DB.Model):
"""
Class representation of narratives table
"""
__tablename__ = "narratives"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
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_id = DB.Column(DB.Integer)
timestamp = DB.Column(DB.DateTime,
default=datetime.datetime.utcnow,
nullable=False)
narrative = DB.Column(DB.String(500), nullable=False)
type_id = DB.Column(DB.Integer, nullable=False)
user_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.users.user_id"),
nullable=False)
site = DB.relationship("Sites",
backref=DB.backref("narratives", lazy="raise"),
lazy="select")
user_details = DB.relationship("Users",
backref=DB.backref("narratives",
lazy="raise"),
lazy="select")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Narrative ID: {self.id}"
f" Site ID: {self.site_id} Event ID: {self.event_id}"
f" Narrative: {self.narrative} Type ID: {self.type_id}")
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 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 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 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 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 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 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 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 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 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 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 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 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 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 MonitoringMoms(UserMixin, DB.Model):
"""
Class representation of monitoring_moms table
"""
__tablename__ = "monitoring_moms"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
moms_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
instance_id = DB.Column(DB.Integer,
DB.ForeignKey("ewi_db.moms_instances.instance_id"),
nullable=False)
observance_ts = DB.Column(DB.DateTime, nullable=False)
reporter_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.users.user_id"),
nullable=False)
remarks = DB.Column(DB.String(500), nullable=False)
narrative_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.narratives.id"),
nullable=False)
validator_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.users.user_id"),
nullable=False)
op_trigger = DB.Column(DB.Integer, nullable=False)
narrative = DB.relationship(
"Narratives",
backref="moms_narrative",
primaryjoin="MonitoringMoms.narrative_id==Narratives.id",
lazy="joined",
innerjoin=True)
reporter = DB.relationship(
"Users",
backref="moms_reporter",
primaryjoin="MonitoringMoms.reporter_id==Users.user_id",
lazy="joined",
innerjoin=True)
validator = DB.relationship(
"Users",
backref="moms_validator",
primaryjoin="MonitoringMoms.validator_id==Users.user_id",
lazy="joined",
innerjoin=True)
# Louie - New Relationship
moms_instance = DB.relationship(
"MomsInstances",
backref=DB.backref("moms",
lazy="dynamic",
order_by="desc(MonitoringMoms.observance_ts)"),
lazy="joined",
innerjoin=True)
def __repr__(self):
return (f"Type <{self.__class__.__name__}> MOMS ID: {self.moms_id}"
f" observance ts: {self.observance_ts} Remarks: {self.remarks}"
f" op_trigger: {self.op_trigger}")
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 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 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 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 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 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 OperationalTriggersSync(UserMixin, DB.Model):
"""
Class representation of operational_triggers
"""
__tablename__ = "operational_triggers_sync"
__bind_key__ = "ewi_db"
__table_args__ = {"schema": "ewi_db"}
update_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
trigger_id = DB.Column(DB.Integer, nullable=False)
ts = DB.Column(DB.DateTime, nullable=False)
site_id = DB.Column(DB.Integer,
DB.ForeignKey("commons_db.sites.site_id"),
nullable=False)
trigger_sym_id = DB.Column(DB.Integer, nullable=False)
ts_updated = DB.Column(DB.DateTime, nullable=False)
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> Update ID: {self.update_id} Trigger_ID: {self.trigger_id}"
f" Site_ID: {self.site_id} trigger_sym_id: {self.trigger_sym_id}"
f" ts: {self.ts} ts_updated: {self.ts_updated}"
f" | TRIGGER SYMBOL alert_level: {self.trigger_symbol.alert_level} source_id: {self.trigger_symbol.source_id}"
)
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 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 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 MarkerAlerts(DB.Model):
"""
Class representation of marker_alerts table
"""
__tablename__ = "marker_alerts"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
ma_id = DB.Column(DB.Integer, primary_key=True, nullable=False)
ts = DB.Column(DB.DateTime,
nullable=False,
default=datetime.datetime.utcnow)
marker_id = DB.Column(DB.Integer,
DB.ForeignKey("senslopedb.markers.marker_id"),
nullable=False)
displacement = DB.Column(DB.Float)
time_delta = DB.Column(DB.Float)
alert_level = DB.Column(DB.Integer)
marker = DB.relationship("Markers",
backref="marker_alerts",
lazy="subquery")
def __repr__(self):
return (
f"Type <{self.__class__.__name__}> MA ID: {self.ma_id}"
f" Marker ID: {self.marker_id} Displacement: {self.displacement}"
f" Alert Level: {self.alert_level} Time Delta: {self.time_delta}")
