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"