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}")
def get_ewi_recipients(site_ids=None, site_codes=None, alert_level=0):
"""
Function that get ewi recipients per site
"""
query = UsersRelationship.query.join(UserOrganizations).join(
Sites).options(
DB.subqueryload("mobile_numbers").joinedload("mobile_number",
innerjoin=True),
DB.subqueryload("organizations").joinedload("site",
innerjoin=True),
DB.subqueryload("organizations").joinedload("organization",
innerjoin=True),
DB.raiseload("*")).filter(Users.ewi_recipient == 1)
if site_ids:
query = query.filter(Sites.site_id.in_(site_ids))
if site_codes:
query = query.filter(Sites.site_code.in_(site_codes))
if alert_level != 0:
uer = UserEwiRestrictions
query = query.join(uer).filter(
DB.or_(uer.user_id.is_(None), uer.alert_level < alert_level))
user_per_site_query = query.all()
user_per_site_result = UsersRelationshipSchema(
many=True,
exclude=["emails", "teams", "landline_numbers",
"ewi_restriction"]).dump(user_per_site_query).data
return user_per_site_result
def get_dynaslope_users(active_only=True, return_schema_format=False):
"""
Function that gets all Dynaslope users and related data
"""
ur = UsersRelationship
query = ur.query.options(
DB.joinedload("account", innerjoin=True).raiseload("*"),
DB.raiseload("*")).order_by(ur.last_name)
if active_only:
# Note use status in users instead of is_active in UserAccounts
query = query.filter_by(status=1)
result = query.all()
if return_schema_format:
result = UsersRelationshipSchema(many=True,
exclude=[
"mobile_numbers", "organizations",
"ewi_restriction", "teams",
"landline_numbers", "emails"
]).dump(result).data
return result
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 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 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 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}")
def google_login(self, user):
db = DB()
GOOGLE_AUTH_URL = 'https://oauth2.googleapis.com/tokeninfo?id_token='
CORRECT_ISS_LIST = [
'accounts.google.com', 'https://accounts.google.com'
]
google_id = user['id']
google_token = user['token']
token_data = json.loads(
requests.get(GOOGLE_AUTH_URL + google_token).text)
if (token_data['iss']
not in CORRECT_ISS_LIST) or (token_data['sub'] != google_id):
return {'message': 'MODIFIED_TOKEN'}, 401
user_id = self.user_dao.google_login(user, db)
if user_id is None:
user_id = self.user_dao.get_user(google_id, db)
token = jwt.encode({
'id': user_id
},
SECRET_KEY['secret'],
algorithm=ALGORITHM['algorithm']).decode('utf-8')
if db:
db.close()
return {'token': token}, 200
def get_site_season(site_code=None, site_id=None, return_schema_format=True):
"""
"""
query = Sites.query.options(
DB.joinedload("season_months",
innerjoin=True).subqueryload("routine_schedules"),
DB.raiseload("*"))
is_many = True
if site_code or site_id:
is_many = False
if site_code:
query = query.filter_by(site_code=site_code)
if site_id:
query = query.filter_by(site_id=site_id)
result = query.first()
else:
result = query.all()
if return_schema_format:
schema = SitesSchema(many=is_many, include=["season_months"])
result = schema.dump(result).data
return result
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 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}")
def get_issues_and_reminders(offset=None,
limit=None,
start=None,
end=None,
site_ids=None,
include_count=None,
search=None,
event_id=None,
include_expired=None):
"""
Returns one or more row/s of narratives.
Args:
offset (Integer) -
limit (Integer) -
start () -
end () -
include_count (Boolean)
search (String)
event_id (Integer)
"""
print(get_process_status_log("get_issues_and_reminders", "start"))
iar = IssuesAndReminders
irp = IssuesRemindersSitePostings
# base = DB.session.query(iar)
base = iar.query.options(joinedload(iar.postings).joinedload(
irp.event)).filter(iar.resolution == None)
return_data = None
if start and end:
base = base.filter(iar.ts_posted.between(start, end))
if not event_id:
if search:
base = base.filter(iar.detail.ilike("%" + search + "%"))
if not include_expired:
base = base.filter(
DB.or_(iar.ts_expiration > datetime.now(),
iar.ts_expiration == None))
issues_and_reminders = base.order_by(DB.desc(
iar.ts_posted)).limit(limit).offset(offset).all()
DB.session.commit()
if include_count:
count = get_issues_count(base)
return_data = [issues_and_reminders, count]
else:
return_data = issues_and_reminders
else:
issues_and_reminders = base.order_by(DB.desc(
iar.timestamp)).filter(iar.event_id == event_id).all()
DB.session.commit()
return_data = issues_and_reminders
print(get_process_status_log("get_issues_and_reminders", "end"))
return return_data
def get_surficial_data(site_code=None,
marker_id=None,
data_id=None,
mo_id=None,
ts_order="asc",
end_ts=None,
start_ts=None,
limit=None,
anchor="marker_data"):
"""
Returns surficial data of a site or marker specified.
You can filter data more using start, end timestamps and a limit.
anchor (string): choose whether to return 'marker_observation'
or 'marker_data'
"""
if data_id:
filtered_query = md.query.filter(md.data_id == data_id)
elif mo_id:
filtered_query = mo.query.filter(mo.mo_id == mo_id)
else:
if anchor == "marker_observations":
base_query = mo.query
else:
base_query = md.query.join(mo)
if ts_order == "asc":
base_query = base_query.order_by(DB.asc(mo.ts))
elif ts_order == "desc":
base_query = base_query.order_by(DB.desc(mo.ts))
if marker_id:
filtered_query = base_query.filter(md.marker_id == marker_id)
if site_code:
filtered_query = base_query.join(Sites).filter(
Sites.site_code == site_code)
if end_ts:
if not isinstance(end_ts, datetime):
end_ts = datetime.strptime(end_ts, "%Y-%m-%d %H:%M:%S")
filtered_query = filtered_query.filter(mo.ts <= end_ts)
if start_ts:
if not isinstance(start_ts, datetime):
start_ts = datetime.strptime(start_ts, "%Y-%m-%d %H:%M:%S")
filtered_query = filtered_query.filter(mo.ts >= start_ts)
if limit:
filtered_query = filtered_query.limit(limit)
if limit == 1:
filtered_marker_data = filtered_query.first()
else:
filtered_marker_data = filtered_query.all()
return filtered_marker_data
def get_latest_data_presence(group, item_name="all"):
"""
group (str): type of data group to get,
can be "rain_gauges", "tsm" or "loggers"
item_name (str): defaults to "all", specific entry to query
(e.g. logger name like "agbta" for group "loggers")
"""
is_many = True
if item_name != "all":
is_many = False
options = False
if group == "rain_gauges":
table = DataPresenceRainGauges
options = DB.joinedload("rain_gauge").raiseload("*")
schema = DataPresenceRainGaugesSchema(
many=is_many, exclude=("rain_gauge.rainfall_alerts", "rain_gauge.rainfall_priorities"))
join_table = [RainfallGauges]
order = RainfallGauges.gauge_name
filter_attr = RainfallGauges.gauge_name
elif group == "tsm":
table = DataPresenceTSM
options = DB.joinedload("tsm_sensor")
schema = DataPresenceTSMSchema(many=is_many)
join_table = [TSMSensors, Loggers]
order = Loggers.logger_name
filter_attr = Loggers.logger_name
elif group == "loggers":
table = DataPresenceLoggers
schema = DataPresenceLoggersSchema(many=is_many)
join_table = [Loggers]
order = Loggers.logger_name
filter_attr = Loggers.logger_name
elif group == "surficial":
pass
else:
return "Data group inputs for querying data presence can only be 'rain_gauges', 'surficial', 'tsm' or 'loggers'"
if group != "surficial":
query = DB.session.query(table)
if options:
query = query.options(options)
for jt in join_table:
query = query.join(jt)
if item_name != "all":
query = query.filter(filter_attr == item_name).first()
else:
query = query.order_by(order).all()
result = schema.dump(query).data
else:
result = get_surficial_data_presence()
return jsonify(result)
def get_narratives(offset=None,
limit=None,
start=None,
end=None,
site_ids=None,
include_count=None,
search=None,
event_id=None,
raise_site=True):
"""
Returns one or more row/s of narratives.
Args:
offset (Integer) -
limit (Integer) -
start () -
end () -
site_ids (Integer) -
include_count (Boolean)
search (String)
event_id (Integer)
"""
nar = Narratives
base = nar.query
if raise_site:
base = base.options(DB.raiseload("site"))
if start is None and end is None:
pass
else:
base = base.filter(nar.timestamp.between(start, end))
if not event_id:
if site_ids:
base = base.filter(nar.site_id.in_(site_ids))
if search != "":
base = base.filter(nar.narrative.ilike("%" + search + "%"))
narratives = base.order_by(DB.desc(
nar.timestamp)).limit(limit).offset(offset).all()
DB.session.commit()
# DB.session.commit()
if include_count:
count = get_narrative_count(base)
return [narratives, count]
else:
return narratives
else:
narratives = base.order_by(DB.asc(
nar.timestamp)).filter(nar.event_id == event_id).all()
DB.session.commit()
return narratives
def get_latest_messages(mobile_id, messages_per_convo=20):
"""
"""
query_start = datetime.now()
siu = SmsInboxUsers
siut = SmsInboxUserTags
sms_inbox = DB.session.query(
siu.inbox_id.label("convo_id"),
siu.inbox_id,
bindparam("outbox_id", None),
siu.mobile_id,
siu.sms_msg,
siu.ts_sms.label("ts"),
siu.ts_sms.label("ts_received"),
bindparam("ts_written", None),
bindparam("ts_sent", None),
literal("inbox").label("source"),
bindparam("send_status", None)
).options(raiseload("*")).filter(siu.mobile_id == mobile_id).order_by(DB.desc(siu.ts_sms))
sou = SmsOutboxUsers
sous = SmsOutboxUserStatus
sout = SmsOutboxUserTags
outbox_sub = sout.query.join(sou).filter(
sout.outbox_id == sou.outbox_id).subquery()
sms_outbox = DB.session.query(
sous.stat_id.label("convo_id"),
bindparam("inbox_id", None),
sous.outbox_id,
sous.mobile_id,
sou.sms_msg,
sou.ts_written.label("ts"),
bindparam("ts_received", None),
sou.ts_written,
sous.ts_sent,
literal("outbox").label("source"),
sous.send_status
).options(raiseload("*")).join(sou).filter(sous.mobile_id == mobile_id) \
.order_by(DB.desc(sous.outbox_id))
union = sms_inbox.union(sms_outbox).order_by(
DB.desc(text("anon_1_ts"))).limit(messages_per_convo)
query_end = datetime.now()
print("")
print("SCRIPT RUNTIME: GET LATEST MESSAGES",
(query_end - query_start).total_seconds())
print("")
return union
def get_all_events_wo_relationship():
"""
Sample implementation of preventing lazy load on relationship
"""
events = MonitoringEvents.query.options(DB.raiseload(MonitoringEvents.releases)).filter(
MonitoringEvents.status == "finished").order_by(DB.desc(MonitoringEvents.event_id)).all()
event_data = MonitoringEventsSchema(
many=True, exclude=("releases", )).dump(events).data
return jsonify(event_data)
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 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 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}")
def get_contacts_per_site(site_ids=None,
site_codes=None,
only_ewi_recipients=True,
include_ewi_restrictions=False,
org_ids=None,
return_schema_format=True,
include_inactive_numbers=False):
"""
Function that get contacts per site
"""
query = UsersRelationship.query.join(UserOrganizations).join(Sites).join(
UserMobiles).options(
DB.subqueryload("mobile_numbers").joinedload("mobile_number",
innerjoin=True),
DB.subqueryload("organizations").joinedload("site",
innerjoin=True),
DB.subqueryload("organizations").joinedload("organization",
innerjoin=True),
DB.raiseload("*"))
if site_ids:
query = query.filter(Sites.site_id.in_(site_ids))
if site_codes:
query = query.filter(Sites.site_code.in_(site_codes))
if org_ids:
query = query.join(UserOrganizations).filter(
UserOrganizations.org_id.in_(org_ids))
if only_ewi_recipients:
query = query.filter(Users.ewi_recipient == 1)
schema_exclusions = [
"emails", "teams", "landline_numbers", "ewi_restriction"
]
if include_ewi_restrictions:
# uer = UserEwiRestrictions
query = query.options(DB.joinedload("ewi_restriction"))
schema_exclusions.remove("ewi_restriction")
if not include_inactive_numbers:
query = query.filter(UserMobiles.status == 1)
user_per_site_result = query.all()
if return_schema_format:
user_per_site_result = UsersRelationshipSchema(
many=True, exclude=schema_exclusions) \
.dump(user_per_site_result).data
return user_per_site_result
class UserAlertInfo(DB.Model):
__tablename__ = "user_alert_info"
__bind_key__ = "comms_db_3"
uai_id = DB.Column(DB.Integer, primary_key=True)
send_alert = DB.Column(DB.Integer, nullable=False)
user_id = DB.Column(DB.Integer, DB.ForeignKey("users.user_id"))
def __repr__(self):
return f"Type <{self.send_alert}>"
class NetworkCarriers(DB.Model):
"""
Class representation of network_carrier table
"""
__tablename__ = "network_carriers"
__bind_key__ = "comms_db_3"
__table_args__ = {"schema": "comms_db_3"}
network_id = DB.Column(DB.Integer, primary_key=True)
carrier = DB.Column(DB.String(45))
def __repr__(self):
return f"Class Representation"
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 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 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 GenericTiltTable(DB.Model):
"""
"""
__tablename__ = table_name
__bind_key__ = "senslopedb"
__table_args__ = {"schema": "senslopedb", "extend_existing": True}
data_id = DB.Column(DB.Integer, primary_key=True)
ts = DB.Column(DB.DateTime, nullable=False)
def __repr__(self):
return (f"Type <{self.__class__.__name__}> data_id: {self.data_id}"
f" ts: {self.ts}")
class UserEmails(DB.Model):
"""
Class representation of user_teams table
"""
__tablename__ = "user_emails"
__bind_key__ = "commons_db"
__table_args__ = {"schema": "commons_db"}
email_id = DB.Column(DB.Integer, primary_key=True)
user_id = DB.Column(DB.Integer, DB.ForeignKey("commons_db.users.user_id"))
email = DB.Column(DB.String(45))
def __repr__(self):
return f"{self.email}"
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}"
)
