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}")