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 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 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 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 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 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 SmsOutboxLoggers(DB.Model): __tablename__ = "smsoutbox_loggers" __bind_key__ = "comms_db_3" outbox_id = DB.Column(DB.Integer, primary_key=True) ts_written = DB.Column(DB.DateTime, default=datetime.datetime.utcnow) source = DB.Column(DB.String(10)) sms_msg = DB.Column(DB.String(1000)) def __repr__(self): return f"Type <{self.sms_msg}>"
class RiskProfile(DB.Model): """ Class representation of ewi_templates table """ __tablename__ = "risk_profile" __bind_key__ = "commons_db" __table_args__ = {"schema": "commons_db"} risk_profile_id = DB.Column(DB.Integer, primary_key=True) entry = DB.Column(DB.String(1000)) timestamp = DB.Column(DB.String(45)) def __repr__(self): return f"Class Representation"
class Sites(UserMixin, DB.Model): """ Class representation of Sites table """ __tablename__ = "sites" __bind_key__ = "commons_db" __table_args__ = {"schema": "commons_db"} site_id = DB.Column(TINYINT, primary_key=True) site_code = DB.Column(DB.String(3), nullable=False) purok = DB.Column(DB.String(45)) sitio = DB.Column(DB.String(45)) barangay = DB.Column(DB.String(45), nullable=False) municipality = DB.Column(DB.String(45), nullable=False) province = DB.Column(DB.String(45), nullable=False) region = DB.Column(DB.String(45), nullable=False) active = DB.Column(DB.Boolean, nullable=False, default=True) psgc = DB.Column(DB.Integer, nullable=False) households = DB.Column(DB.String(255), nullable=False) season = DB.Column( DB.Integer, DB.ForeignKey("commons_db.seasons.season_group_id")) def __repr__(self): return (f"Type <{self.__class__.__name__}> Site ID: {self.site_id}" f" Site Code: {self.site_code}")
class GintagsReference(DB.Model): """ Class representation of general_data_references table """ __tablename__ = "gintags_reference" __bind_key__ = "comms_db_3" __table_args__ = {"schema": "comms_db_3"} tag_id = DB.Column(DB.Integer, primary_key=True) tag_name = DB.Column(DB.String(200)) tag_description = DB.Column(DB.String(1000)) def __repr__(self): return f"Class Representation"
class ResourcesAndCapacities(DB.Model): """ Class representation of resources_and_capacities table """ __tablename__ = "resources_and_capacities" __bind_key__ = "commons_db" __table_args__ = {"schema": "commons_db"} resources_and_capacities_id = DB.Column(DB.Integer, primary_key=True) resource_and_capacity = DB.Column(DB.String(100)) status = DB.Column(DB.String(45)) owner = DB.Column(DB.String(45)) def __repr__(self): return f"Class Representation"
class GsmServers(DB.Model): """ """ __tablename__ = "gsm_servers" __bind_key__ = "comms_db_3" __table_args__ = {"schema": "comms_db_3"} gsm_server_id = DB.Column(DB.Integer, primary_key=True) name = DB.Column(DB.String(45)) platform_type = DB.Column(DB.String(45)) version = DB.Column(DB.Integer, nullable=True) def __repr__(self): return f"{self.name}\n"
class UserTeams(DB.Model): """ Class representation of user_teams table """ __tablename__ = "user_teams" __bind_key__ = "commons_db" __table_args__ = {"schema": "commons_db"} team_id = DB.Column(DB.Integer, primary_key=True) team_code = DB.Column(DB.String(20)) team_name = DB.Column(DB.String(20)) remarks = DB.Column(DB.String(45)) def __repr__(self): return f"{self.team_code}"
class UserLandlines(DB.Model): """ Class representation of user_landlines table """ __tablename__ = "user_landlines" __bind_key__ = "comms_db_3" __table_args__ = {"schema": "comms_db_3"} landline_id = DB.Column(DB.Integer, primary_key=True) user_id = DB.Column(DB.Integer, DB.ForeignKey("commons_db.users.user_id")) landline_num = DB.Column(DB.String(30)) remarks = DB.Column(DB.String(45)) def __repr__(self): return f"Type <{self.landline_num}"
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 RiskAssessmentSummary(DB.Model): """ Class representation of ewi_templates table """ __tablename__ = "risk_assessment_summary" __bind_key__ = "commons_db" __table_args__ = {"schema": "commons_db"} summary_id = DB.Column(DB.Integer, primary_key=True) location = DB.Column(DB.String(150)) impact = DB.Column(DB.String(45)) adaptive_capacity = DB.Column(DB.String(45)) vulnerability = DB.Column(DB.String(45)) def __repr__(self): return f"Class Representation"
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 LoggerModels(DB.Model): """ Class representation of logger_models table """ __tablename__ = "logger_models" __bind_key__ = "senslopedb" __table_args__ = {"schema": "senslopedb"} model_id = DB.Column(DB.Integer, primary_key=True, nullable=False) has_tilt = DB.Column(DB.Integer) has_rain = DB.Column(DB.Integer) has_piezo = DB.Column(DB.Integer) has_soms = DB.Column(DB.Integer) logger_type = DB.Column(DB.String(10)) loggers = DB.relationship("Loggers", backref="logger_model", lazy="subquery") def __repr__(self): return ( f"Type <{self.__class__.__name__}> TSM ID: {self.tsm_id}" f" TSM Name: {self.tsm_name} Number of Segments: {self.number_of_segments}" f"Date Activated: {self.date_activated}")
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 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 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 SituationReport(DB.Model): """ Class representation of field_survey_logs table """ __tablename__ = "situation_report" __bind_key__ = "commons_db" __table_args__ = {"schema": "commons_db"} situation_report_id = DB.Column(DB.Integer, primary_key=True) timestamp = DB.Column(DB.String(45)) summary = DB.Column(DB.String(1000)) pdf_path = DB.Column(DB.String(255)) image_path = DB.Column(DB.String(255)) def __repr__(self): return f"Class Representation"
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 EarthquakeEvents(DB.Model): """ Class representation of earthquake_events table """ __tablename__ = "earthquake_events" __bind_key__ = "senslopedb" __table_args__ = {"schema": "senslopedb"} eq_id = DB.Column(DB.Integer, primary_key=True, nullable=False) ts = DB.Column(DB.DateTime) magnitude = DB.Column(DB.Float(4, 2)) depth = DB.Column(DB.Float(5, 2)) latitude = DB.Column(DB.Float(9, 6)) longitude = DB.Column(DB.Float(9, 6)) critical_distance = DB.Column(DB.Float(6, 3)) issuer = DB.Column(DB.String(20)) processed = DB.Column(DB.Integer, nullable=False) def __repr__(self): return ( f"Type <{self.__class__.__name__}> EQ_ID: {self.eq_id}" f" Magnitude: {self.magnitude} Depth: {self.depth}" f" Critical Distance: {self.critical_distance} issuer: {self.issuer}" )
class AlertStatusSync(DB.Model): """ Class representation of alert_status_sync table """ __tablename__ = "alert_status_sync" __bind_key__ = "analysis_db" __table_args__ = {"schema": "analysis_db"} as_update_id = DB.Column(DB.Integer, primary_key=True, nullable=False) stat_id = DB.Column(DB.Integer, nullable=False) ts_last_retrigger = DB.Column(DB.DateTime) trigger_id = DB.Column(DB.Integer) ts_set = DB.Column(DB.DateTime) ts_ack = DB.Column(DB.DateTime) alert_status = DB.Column(DB.Integer) remarks = DB.Column(DB.String(450)) user_id = DB.Column(DB.Integer, nullable=False) def __repr__(self): return ( f"Type <{self.__class__.__name__}> as_update_id: {self.as_update_id} stat ID: {self.stat_id}" f" ts_last_retrigger: {self.ts_last_retrigger} ts_set: {self.ts_set}" f" ts_ack: {self.ts_ack} alert_status: {self.alert_status}" f" remarks: {self.remarks} user_id: {self.user_id}" f" || TRIGGER: {self.trigger} || user: {self.user}")
class HazardData(DB.Model): """ Class representation of hazard_data table """ __tablename__ = "hazard_data" __bind_key__ = "commons_db" __table_args__ = {"schema": "commons_db"} hazard_data_id = DB.Column(DB.Integer, primary_key=True) hazard = DB.Column(DB.String(45)) speed_of_onset = DB.Column(DB.String(45)) early_warning = DB.Column(DB.String(100)) impact = DB.Column(DB.String(100)) def __repr__(self): return f"Class Representation"
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 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}"