class Seasons(DB.Model):
"""
Class representation of Seasons Table
"""
__tablename__ = "seasons"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
season_group_id = DB.Column(TINYINT, primary_key=True)
january = DB.Column(DB.String(1))
february = DB.Column(DB.String(1))
march = DB.Column(DB.String(1))
april = DB.Column(DB.String(1))
may = DB.Column(DB.String(1))
june = DB.Column(DB.String(1))
july = DB.Column(DB.String(1))
august = DB.Column(DB.String(1))
september = DB.Column(DB.String(1))
october = DB.Column(DB.String(1))
november = DB.Column(DB.String(1))
december = DB.Column(DB.String(1))
sched_group_id = DB.Column(
TINYINT, DB.ForeignKey("commons_db.routine_schedules.sched_group_id"))
sites = DB.relationship(
"Sites", backref=DB.backref("season_months", lazy="raise"), lazy="subquery")
routine_schedules = DB.relationship(
"RoutineSchedules", backref=DB.backref("seasons", lazy="subquery"),
uselist=True, lazy="subquery")
def __repr__(self):
return (f"Type < {self.__class__.__name__} > "
f"Season Group ID: {self.season_group_id}")
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 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 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 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 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 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 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 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 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 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 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 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 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 Markers(DB.Model):
"""
Class representation of markers table
"""
__tablename__ = "markers"
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb"}
marker_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)
description = DB.Column(DB.String(50))
latitude = DB.Column(DB.Float(9, 6))
longitude = DB.Column(DB.Float(9, 6))
in_use = DB.Column(DB.Boolean)
site = DB.relationship("Sites",
backref=DB.backref("markers", lazy="dynamic"),
lazy="select")
def __repr__(self):
return (f"Type <{self.__class__.__name__}> Marker ID: {self.marker_id}"
f" Site ID: {self.site_id} Description: {self.description}"
f" In Use: {self.in_use}")
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 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 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 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 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 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 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 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 SmsInboxUsers(DB.Model):
"""
Class representation of smsinbox_users table
"""
__tablename__ = "smsinbox_users"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
inbox_id = DB.Column(DB.Integer, primary_key=True)
ts_sms = DB.Column(DB.DateTime, default=datetime.utcnow())
ts_stored = DB.Column(DB.DateTime, default=datetime.utcnow())
mobile_id = DB.Column(DB.Integer,
DB.ForeignKey("comms_db_3.user_mobile.mobile_id"))
sms_msg = DB.Column(DB.String(1000))
read_status = DB.Column(DB.Integer, nullable=False)
web_status = DB.Column(DB.Integer, nullable=False)
gsm_id = DB.Column(DB.Integer, nullable=False)
mobile_details = DB.relationship("UserMobile",
backref=DB.backref("inbox_messages",
lazy="dynamic"),
lazy="select")
sms_tags = DB.relationship("SmsInboxUserTags",
backref="inbox_message",
lazy="subquery")
def __repr__(self):
return f"Type <{self.__class__.__name__}>"
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 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 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 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 UsersRelationship(Users):
"""
Class representation of users relation in mobile and organization of users
"""
__tablename__ = "users"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
organizations = DB.relationship(UserOrganizations,
backref=DB.backref("user",
lazy="joined",
innerjoin=True),
lazy="subquery")
ewi_restriction = DB.relationship("UserEwiRestrictions",
backref=DB.backref("user",
lazy="joined",
innerjoin=True),
lazy="joined",
uselist=False)
teams = DB.relationship("UserTeamMembers",
backref=DB.backref("user",
lazy="joined",
innerjoin=True),
lazy="subquery")
landline_numbers = DB.relationship("UserLandlines",
backref=DB.backref("user",
lazy="joined",
innerjoin=True),
lazy="subquery")
emails = DB.relationship("UserEmails",
backref=DB.backref("user",
lazy="joined",
innerjoin=True),
lazy="subquery")
# user_account relationship declared on UserAccounts
def __repr__(self):
return f"Type relationship"
