class MDPilotDetectionVariable(Base):
"""
Pilot < -- > CDDetectionVariable
"""
__tablename__ = 'md_pilot_detection_variable'
__table_args__ = (UniqueConstraint('pilot_code', 'detection_variable_id', 'derived_detection_variable_id',
name='md_pilot_detection_variable_natural1_uq'),
)
# Generating the Sequence
md_pilot_detection_variable_id_seq = Sequence('md_pilot_detection_variable_id_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer, server_default=md_pilot_detection_variable_id_seq.next_value(), primary_key=True)
# Data columns
derivation_function_formula = Column(Text, nullable=True)
derivation_weight = Column(Numeric(precision=5, scale=2))
valid_from = Column(ArrowType(timezone=True), server_default=utcnow())
valid_to = Column(ArrowType(timezone=True), nullable=True)
detection_variable_usage_status = Column(String(3))
# Foreign Keys
pilot_code = Column(String(3), ForeignKey('pilot.pilot_code'))
main_data_source_type = Column(String(3), ForeignKey('cd_data_source_type.data_source_type'))
# Two relationship from detection variable
detection_variable_id = Column(Integer, ForeignKey('cd_detection_variable.id'))
derived_detection_variable_id = Column(Integer, ForeignKey('cd_detection_variable.id'), nullable=True)
# Relationship with other Tables
pilot = relationship('Pilot')
class FrailtyStatusTimeline(Base):
"""
Multiple relationship intermediate table
user_in_role -- time_interval -- cd_frailty_status
"""
__tablename__ = 'frailty_status_timeline'
__table_args__ = (UniqueConstraint('time_interval_id', 'user_in_role_id', 'frailty_status',
name='frailty_status_timeline1_uq'),
)
time_interval_id = Column(Integer, ForeignKey('time_interval.id'), primary_key=True)
user_in_role_id = Column(Integer, ForeignKey('user_in_role.id'), primary_key=True)
created = Column(ArrowType(timezone=True), server_default=utcnow(), nullable=False)
changed = Column(ArrowType(timezone=True), server_onupdate=utcnow(), primary_key=True)
frailty_status = Column(String(9), ForeignKey('cd_frailty_status.frailty_status'), primary_key=True)
# Data
frailty_notice = Column(String(200))
# FK
changed_by = Column(Integer, ForeignKey('user_in_role.id'), nullable=False)
# Relationships
time_interval = relationship('TimeInterval')
cd_frailty_status = relationship('CDFrailtyStatus')
class CDRole(Base):
"""
This table stores all data related to the roles for users in the system. The idea is to stablish a role-access
level entry points to limit user iterations int he system.
"""
__tablename__ = 'cd_role'
# __searchable__ = ['role_name']
# Generating the Sequence
cd_role_seq = Sequence('cd_role_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer, server_default=cd_role_seq.next_value(), primary_key=True)
role_name = Column(String(50), nullable=False, unique=True)
role_abbreviation = Column(String(3))
role_description = Column(String(350), nullable=True)
valid_from = Column(ArrowType(timezone=True), server_default=utcnow())
valid_to = Column(ArrowType(timezone=True), nullable=True)
# FK's
stakeholder_abbreviation = Column(String(3), ForeignKey('stakeholder.abbreviation'))
# one2many
user_in_role = relationship('UserInRole')
def __repr__(self):
return "<CDRole(id='%s', role_name='%s', role_abbreviation='%s', role_description='%s'," \
"valid_from='%s', valid_to='%s')>" % (self.id, self.role_name,
self.role_abbreviation, self.role_description, self.valid_from,
self.valid_to)
class UserInRole(Base):
"""
This table allows to store all related data from User who makes the executed_action
"""
__tablename__ = 'user_in_role'
# Generating the Sequence
user_in_role_seq = Sequence('user_in_role_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer,
server_default=user_in_role_seq.next_value(),
primary_key=True)
valid_from = Column(ArrowType(timezone=True), default=arrow.utcnow())
valid_to = Column(ArrowType(timezone=True))
pilot_source_user_id = Column(Integer, unique=False)
# one2many
user_in_system_id = Column(Integer, ForeignKey('user_in_system.id'))
cd_role_id = Column(Integer, ForeignKey('cd_role.id'))
pilot_code = Column(String(4), ForeignKey('pilot.code'))
# m2m
action = relationship("ExecutedAction", cascade="all, delete-orphan")
def __repr__(self):
return "<UserInRole(id='%s', valid_from='%s'. valid_to='%s')>" % (
self.id, self.valid_from, self.valid_to)
class ExecutedAction(Base):
"""
Multi relationship table.
User - CDAction -- Activity -- Location
"""
__tablename__ = 'executed_action'
__table_args__ = (UniqueConstraint('execution_datetime', 'user_in_role_id', 'cd_action_id', 'location_id',
name='executed_action_uq'),
)
# Generating the Sequence
executed_action_id_seq = Sequence('executed_action_id_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer, server_default=executed_action_id_seq.next_value(), primary_key=True)
# Associated information
acquisition_datetime = Column(ArrowType(timezone=True), server_default=utcnowtimestamp())
execution_datetime = Column(ArrowType(timezone=True))
rating = Column(Numeric(precision=5, scale=2))
sensor_id = Column(Integer)
position = Column(String(100))
data_source_type = Column(String(1000)) # An "array" containing the data source
extra_information = Column(String(1000)) # An "array" containing extra information
# FK keys
user_in_role_id = Column(Integer, ForeignKey('user_in_role.id'))
cd_action_id = Column(Integer, ForeignKey('cd_action.id'))
executed_activity_id = Column(Integer, ForeignKey('executed_activity.id'), nullable=True)
location_id = Column(Integer, ForeignKey('location.id'))
# Relationship with other TABLES
cd_action = relationship("CDAction")
executed_activity = relationship("ExecutedActivity")
location = relationship("Location")
class Instance(Base, TaskMixin, NetworkableMixin, ProjectMixin,
RegionableNixin, ZonableMixin, ServiceAccountMixin):
__tablename__ = 'instances'
id = Column(UUIDType,
server_default=text("uuid_generate_v4()"),
primary_key=True)
name = Column(String, nullable=False)
tags = Column(HSTORE)
state = Column(Enum(InstanceState),
default=InstanceState.BUILDING,
nullable=False)
image_id = Column(UUIDType, ForeignKey('images.id', ondelete='SET NULL'))
keypairs = relationship(Keypair, secondary='instance_keypairs')
created_at = Column(ArrowType(timezone=True),
server_default=text('clock_timestamp()'),
nullable=False,
index=True)
updated_at = Column(ArrowType(timezone=True),
server_default=text('clock_timestamp()'),
onupdate=text('clock_timestamp()'),
nullable=False)
class Assessment(Base):
"""
Assessments are input by geriatric/medical/caregiver staff (author_id) on specific geriatric factor or detection
variable values (GES,GEF,GFG) represented as data points on interactive dashboards. An assessment can consist of a
comment and flag markers (for risk status or data validity), any of the 3.
"""
__tablename__ = 'assessment'
# Generating the Sequence
assessment_seq = Sequence('assessment_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer,
server_default=assessment_seq.next_value(),
primary_key=True)
assessment_comment = Column(String)
data_validity_status = Column(String(1))
created = Column(ArrowType(timezone=True),
default=arrow.utcnow(),
nullable=False)
updated = Column(ArrowType(timezone=True))
# Many2One
risk_status = Column(String(1),
ForeignKey('cd_risk_status.risk_status'),
nullable=False)
author_id = Column(Integer, ForeignKey('user_in_role.id'))
def __repr__(self):
return "<Assessment(assessment_comment='%s', data_validity_status='%s')>" % (
self.activity_name, self.data_validity_status)
class TimeInterval(Base):
"""
Defines some different interval times to calculate the variation measures over an action.
"""
__tablename__ = 'time_interval'
# Generating the Sequence
time_interval_seq = Sequence('time_interval_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer,
server_default=time_interval_seq.next_value(),
primary_key=True)
interval_start = Column(ArrowType(timezone=True), nullable=False)
interval_end = Column(ArrowType(timezone=True),
nullable=False) # Calculated by the period
# Many2One
typical_period = Column(String(3),
ForeignKey('cd_typical_period.typical_period'))
# Relationships
variation_measure_value = relationship('VariationMeasureValue')
numeric_indicator_value = relationship('NumericIndicatorValue')
geriatric_factor_value = relationship('GeriatricFactorValue')
activity = relationship('Activity')
def __repr__(self):
return "<TimeInterval(interval_start='%s', interval_end='%s')>" % \
(self.interval_start,
self.interval_end)
class CRProfile(Base):
"""
Initial referent personal and health profile data of the care recipient at the time of inclusion in observation.
"""
__tablename__ = 'cr_profile'
# Generating the Sequence
cr_profile_seq = Sequence('cr_profile_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer,
server_default=cr_profile_seq.next_value(),
primary_key=True)
ref_height = Column(Float(4))
ref_weight = Column(Float(4))
ref_mean_blood_pressure = Column(Numeric(precision=5, scale=2))
date = Column(ArrowType(timezone=True))
birth_date = Column(ArrowType(timezone=True), nullable=False)
gender = Column(Boolean, nullable=False)
# Many2One
user_in_role_id = Column(Integer, ForeignKey('user_in_role.id'))
def __repr__(self):
return "<CRProfile(id='%s', ref_height='%s', ref_weight='%s', ref_mean_blood_pressure='%s', date='%s'," \
"birth_date='%s', gender='%s')>" % (self.id, self.ref_height, self.ref_weight,
self.ref_mean_blood_pressure, self.date, self.birth_date,
self.gender)
class CDRole(Base):
"""
This table contains information about the roles of the system. It stores the role information and its
validity in the system
"""
__tablename__ = 'cd_role'
# Generating the Sequence
cd_role_seq = Sequence('cd_role_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer,
server_default=cd_role_seq.next_value(),
primary_key=True)
role_name = Column(String(50), nullable=False, unique=True)
role_abbreviation = Column(String(3))
role_description = Column(String(350), nullable=True)
valid_from = Column(ArrowType(timezone=True), default=arrow.utcnow())
valid_to = Column(ArrowType(timezone=True), nullable=True)
# One2Many
user_in_role = relationship('UserInRole')
# Many2One
stakeholder_abbreviation = Column(String(3),
ForeignKey('stakeholder.abbreviation'))
# M2M Relationship
assessment_audience_role = relationship('AssessmentAudienceRole')
def __repr__(self):
return "<CDRole(id='%s', role_name='%s', role_abbreviation='%s', role_description='%s'," \
"valid_from='%s', valid_to='%s')>" % (self.id, self.role_name,
self.role_abbreviation, self.role_description, self.valid_from,
self.valid_to)
class ProjectMembers(Base):
__tablename__ = 'project_members'
id = Column(UUIDType,
server_default=text("uuid_generate_v4()"),
primary_key=True)
user_id = Column(UUIDType,
ForeignKey('authn_users.id', ondelete='CASCADE'),
nullable=False,
index=True)
role_id = Column(UUIDType,
ForeignKey('authz_roles.id', ondelete='RESTRICT'),
nullable=False,
index=True)
project_id = Column(UUIDType,
ForeignKey('projects.id', ondelete='CASCADE'),
nullable=False,
index=True)
created_at = Column(ArrowType(timezone=True),
server_default=text('clock_timestamp()'),
nullable=False,
index=True)
updated_at = Column(ArrowType(timezone=True),
server_default=text('clock_timestamp()'),
onupdate=text('clock_timestamp()'),
nullable=False)
class ExecutedTransformedAction(Base):
"""
Multi relationship table
USER - CDTransformedAction - CDEAM
"""
__tablename__ = 'executed_transformed_action'
# Generating the Sequence
executed_activity_id_seq = Sequence('executed_activity_id_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer, server_default=executed_activity_id_seq.next_value(), primary_key=True)
transformed_acquisition_datetime = Column(ArrowType(timezone=True), server_default=utcnow())
transformed_execution_datetime = Column(ArrowType(timezone=True))
# FK keys
executed_action_id = Column(Integer, ForeignKey('executed_action.id'), nullable=True)
cd_transformed_action_id = Column(Integer, ForeignKey('cd_transformed_action.id'))
user_in_role_id = Column(Integer, ForeignKey('user_in_role.id'))
# Relationships with other tables
cd_transformed_action = relationship('CDTransformedAction')
executed_action = relationship('ExecutedAction')
def __repr__(self):
return "<ExecutedTransformedAction(id='%s', transformed_acquisition_datetime='%s', " \
"transformed_execution_datetime='%s')>" % (self.id, self.transformed_acquisition_datetime,
self.transformed_execution_datetime)
class CareProfile(Base):
"""
Care profile stores individuals related data about interventions, attentions and the summary
of their personal information.
"""
__tablename__ = 'care_profile'
user_in_role_id = Column(Integer,
ForeignKey('user_in_role.id'),
primary_key=True)
individual_summary = Column(String, nullable=False)
attention_status = Column(String(1))
intervention_status = Column(String(1))
last_intervention_date = Column(ArrowType(timezone=True))
created = Column(ArrowType(timezone=True),
default=arrow.utcnow(),
nullable=False)
last_updated = Column(ArrowType(timezone=True))
# Many 2 one Relationships
created_by = Column(Integer, ForeignKey('user_in_role.id'), nullable=False)
last_updated_by = Column(Integer, ForeignKey('user_in_role.id'))
def __repr__(self):
return "<CareProfile(user_in_role_id='%s', individual_summary='%s', attention_status='%s', " \
"intervention_status = '%s', last_intervention_date='%s')>" % \
(self.user_in_role_id, self.individual_summary, self.attention_status,
self.intervention_status, self.last_intervention_date)
class Participant(db.Model, PrimaryKeyMixin):
__tablename__ = 'participants'
name = Column(Unicode)
phone = Column(Unicode)
email = Column(Unicode)
occupation = Column(Unicode)
employees = Column(Unicode)
website = Column(Unicode)
selected_prizes = Column(Unicode)
job_title = Column(Unicode)
added = Column(ArrowType(), default=arrow.now)
subscribed_to_newsletter = Column(ArrowType(), nullable=True)
__table_args__ = (
CheckConstraint(
"email ~ '{}' AND length(email) > 4".format(NO_WHITESPACE_REGEX)),
Index('index_unique_lowercase_email',
text('lower(email)'),
unique=True),
)
def __repr__(self):
return '<Participant "{}">'.format(self.email)
class Pilot(Base):
"""
The pilot table stores the information about the Pilots in a defined locations and what users are participating
"""
__tablename__ = 'pilot'
pilot_code = Column(String(3), unique=True, nullable=False, primary_key=True)
pilot_name = Column(String(50), unique=True, nullable=False)
population_size = Column(BigInteger)
latest_data_submission_completed = Column(ArrowType(timezone=True), nullable=True)
latest_derived_detection_variables_computed = Column(ArrowType(timezone=True), nullable=True)
latest_configuration_update = Column(ArrowType(timezone=True), nullable=True)
newest_submitted_data = Column(ArrowType(timezone=True), nullable=True)
time_of_computation = Column(ArrowType(timezone=True), nullable=True)
# One2Many
user_in_role = relationship('UserInRole')
location = relationship('Location')
# M2M Relationship
#md_pilot_detection_variable = relationship('MDPilotDetectionVariable')
def __repr__(self):
return "<Pilot(pilot_code='%s', pilot_name='%s', population_size='%s')>" % \
(self.pilot_code, self.pilot_name, self.population_size)
class PayloadValue(Base):
"""
Metric < -- > CDAction
"""
__tablename__ = 'payload_value'
cd_metric_id = Column(Integer, ForeignKey('cd_metric.id'), primary_key=True)
cd_action_id = Column(Integer, ForeignKey('cd_action.id'), primary_key=True)
acquisition_datetime = Column(ArrowType(timezone=True), primary_key=True) # Same as executed_action registered time
execution_datetime = Column(ArrowType(timezone=True), nullable=False)
value = Column(String(50), nullable=False)
cd_action = relationship('CDAction')
class Lead(db.Model):
__tablename__ = 'leads'
id = Column(Integer, primary_key=True)
name = Column(String)
phone = Column(String)
question = Column(String)
source = Column(String)
date = Column(ArrowType(timezone=True))
brack_report_date = Column(ArrowType(timezone=True))
winner = Column(String)
id2 = Column(Integer)
status = Column(Integer)
comment = Column(String)
commentbrack = Column(String)
price = Column(Float)
domain = Column(String)
giga_brack_notification = Column(String)
brack_rejected_once = Column(Boolean)
moderator_response = Column(String)
status_text = Column(String, ForeignKey('lead_statuses.name'))
quality_name = Column('quality', String, ForeignKey('lead_qualities.name'),
nullable=False, default='notset')
quality = relationship('LeadQuality', foreign_keys='[Lead.quality_name]', lazy='joined')
status_object = relationship('LeadStatus', foreign_keys='[Lead.status_text]', lazy='joined')
@staticmethod
def get_all_qualities():
return LeadQuality.get_all()
@staticmethod
def get_all_statuses():
return LeadStatus.get_all()
def is_brack(self):
return self.status_object.is_brack()
def __getitem__(self, key):
return self.__dict__[key]
def __iter__(self):
return iter(self.__dict__)
def __len__(self):
return len(self.__dict__)
def __repr__(self):
return 'Lead({}, {})'.format(self.id, self.phone)
class CDDetectionVariable(Base):
"""
Stores the definitions and descriptions of detection variables defined on all levels - Measures, NUIs, GEFs, GESs,
and Factor Groups (including "Overall" as specific parent factor group). DetectionVariable entity that is related
through foreign keys to VariationMeasure, NumericIndicator, and Geriatric Factor entities. It can be determined
through the value of DetectionVariableType attribute (MEA, NUI, GES, GEF...) to which table exactly is the each
record in DetectionVariable related. The entity has a reflexive one-to-many relation defining the hierarchy of the
variables - denoting which NUIs aggregate to which Sub-Factor, which Sub-Factors constitute which Factor, Factors a
GEF Group etc.
"""
__tablename__ = 'cd_detection_variable'
# Generating the Sequence
cd_detection_variable_seq = Sequence('cd_detection_variable_seq',
metadata=Base.metadata)
# Creating the columns
id = Column(Integer,
server_default=cd_detection_variable_seq.next_value(),
primary_key=True)
detection_variable_name = Column(String(100), nullable=False)
valid_from = Column(ArrowType(timezone=True), default=arrow.utcnow())
valid_to = Column(ArrowType(timezone=True))
default_derivation_weight = Column(Numeric(precision=5, scale=2))
source_datatype = Column(String(25))
base_unit = Column(String(50))
# FK
detection_variable_type = Column(
String(3),
ForeignKey('cd_detection_variable_type.detection_variable_type'),
nullable=False)
default_typical_period = Column(
String(3), ForeignKey('cd_typical_period.typical_period'))
# Self FK column
cd_detection_variable = relationship(
'CDDetectionVariable',
remote_side=[id]) # Self relationship with id column
derived_detection_variable_id = Column(
Integer, ForeignKey('cd_detection_variable.id'))
# Relationship
variation_measure_value = relationship('VariationMeasureValue')
numeric_indicator_value = relationship('NumericIndicatorValue')
geriatric_factor_value = relationship('GeriatricFactorValue')
def __repr__(self):
return "<CDDetectionVariable(id='%s', detection_variable_name='%s', derivation_weight='%s')>" % \
(self.id, self.detection_variable_name, self.derivation_weight)
class UserInRole(Base):
"""
This table allows to store all related data from User who makes the executed_action
"""
__tablename__ = 'user_in_role'
# Generating the Sequence
user_in_role_seq = Sequence('user_in_role_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer,
server_default=user_in_role_seq.next_value(),
primary_key=True)
valid_from = Column(ArrowType(timezone=True), default=arrow.utcnow())
valid_to = Column(ArrowType(timezone=True))
pilot_source_user_id = Column(String(20))
# Many2One
user_in_system_id = Column(Integer, ForeignKey('user_in_system.id'))
cd_role_id = Column(Integer, ForeignKey('cd_role.id'))
pilot_code = Column(String(4), ForeignKey('pilot.code'))
# M2M relationships
action = relationship("ExecutedAction", cascade="all, delete-orphan")
frailty_status_timeline = relationship(
'FrailtyStatusTimeline',
foreign_keys='FrailtyStatusTimeline.user_in_role_id')
frailty_status_timeline_changed_by = relationship(
'FrailtyStatusTimeline',
foreign_keys='FrailtyStatusTimeline.changed_by')
# One2Many relationship
cr_profile = relationship("CRProfile", cascade="all, delete-orphan")
variation_measure_value = relationship('VariationMeasureValue')
numeric_indicator_value = relationship('NumericIndicatorValue')
source_evidence = relationship('SourceEvidence')
geriatric_factor_value = relationship('GeriatricFactorValue')
assessment = relationship('Assessment')
activity = relationship('Activity')
# one2many (Multiple)
created_by = relationship("CareProfile",
foreign_keys='CareProfile.created_by')
last_updated_by = relationship("CareProfile",
foreign_keys='CareProfile.last_updated_by')
def __repr__(self):
return "<User(id='%s', valid_from='%s'. valid_to='%s')>" % (
self.id, self.valid_from, self.valid_to)
class Stakeholder(Base):
"""
This table contains the information about the stakeholders of the different cd_roles in the system
"""
__tablename__ = 'stakeholder'
abbreviation = Column(String(3), primary_key=True)
stakeholder_name = Column(String(100), nullable=False)
stakeholder_description = Column(String(250))
valid_from = Column(ArrowType(timezone=True), default=arrow.utcnow())
valid_to = Column(ArrowType(timezone=True))
# One2Many relationship
cd_role = relationship("CDRole")
class UserAction(Base):
"""
This table stores all user actions in DB. Each user has its historical data stored to study its actions in the
system. The idea is to have some reference in case of security breach.
"""
__tablename__ = 'user_action'
__searchable__ = ['date', 'user_in_system_id']
# Generating the Sequence
user_action_seq = Sequence('user_action_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer, server_default=user_action_seq.next_value(), primary_key=True)
route = Column(String(25))
data = Column(String(255))
ip = Column(String(60))
agent = Column(String(255))
date = Column(ArrowType(timezone=True), server_default=utcnow())
status_code = Column(Integer)
# One2Many
user_in_system_id = Column(Integer, ForeignKey('user_in_system.id'))
def __repr__(self):
return "<UserAction(route='%s', data='%s', ip='%s', agent='%s', date='%s', satus_code='%s')>" % (
self.route, self.date, self.ip, self.agent, self.date, self.status_code)
class CDEAM(Base):
"""
This table stores the duration of each related action/activity in a location
"""
__tablename__ = 'cd_eam'
# Generating the Sequence
cd_eam_seq = Sequence('cd_eam_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer, server_default=cd_eam_seq.next_value(), primary_key=True)
eam_name = Column(String(50), unique=True)
duration = Column(Integer)
creation_date = Column(ArrowType(timezone=True), server_default=utcnow())
# one2one
# activity_id = Column(Integer, ForeignKey('activity.id'))
# activity = relationship("Activity", back_populates="cd_eam")
# many2many
start_range = relationship("CDEAMStartRangeRel")
cd_transformed_action = relationship("CDEAMCDTransformedActionRel")
location = relationship("CDEAMLocationRel")
def __repr__(self):
return "<EAM(duration='%s')>" % self.duration
class Activity(Base):
"""
Activity is a collection of different actions. For example "Make breakfast is an activity and could have some actions
like:
--> Put the milk in the bowl
--> Open the fridge
--> .....
"""
__tablename__ = 'activity'
# Generating the Sequence
activity_id_seq = Sequence('activity_id_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer,
server_default=activity_id_seq.next_value(),
primary_key=True)
activity_name = Column(String(50))
activity_description = Column(String(200))
creation_date = Column(ArrowType(timezone=True), default=arrow.utcnow())
instrumental = Column(Boolean, default=False, nullable=False)
data_source_type = Column(String(200))
# One2one
eam = relationship("EAM", uselist=False, back_populates="activity")
# one2many
expected_inter_behaviour = relationship(
"InterBehaviour", foreign_keys='InterBehaviour.expected_activity_id')
real_inter_behaviour = relationship(
"InterBehaviour", foreign_keys='InterBehaviour.real_activity_id')
def __repr__(self):
return "<Activity(activity_name='%s')>" % self.activity_name
class CDActivity(Base):
"""
CDActivity contains the codebook of possible Activities in the project.
An activity is set of different performed actions:
--> Open the fridge
--> Put the milk in the bowl
--> .....
"""
__tablename__ = 'cd_activity'
# Generating the Sequence
activity_id_seq = Sequence('cd_activity_id_seq', metadata=Base.metadata)
# Creating the columns
id = Column(Integer, server_default=activity_id_seq.next_value(), primary_key=True)
activity_name = Column(String(50), unique=True)
activity_description = Column(String(200), nullable=True)
creation_date = Column(ArrowType(timezone=True), server_default=utcnow()) # Creation date automatic
instrumental = Column(Boolean, default=False, nullable=False) # Default value set to False --> Normal Activities
# One2one
# user_in_eam = relationship("UserInEAM", uselist=False, back_populates="cd_activity")
# One2Many
executed_activity = relationship("ExecutedActivity", cascade="all, delete-orphan")
# one2many
# expected_inter_behaviour = relationship("InterBehaviour", foreign_keys='InterBehaviour.expected_activity_id')
# real_inter_behaviour = relationship("InterBehaviour", foreign_keys='InterBehaviour.real_activity_id')
def __repr__(self):
return "<CDActivity(activity_name='%s')>" % self.activity_name
class Image(Base, TaskMixin, ProjectMixin, RegionableNixin):
__tablename__ = 'images'
id = Column(UUIDType, server_default=text("uuid_generate_v4()"), primary_key=True)
name = Column(String, nullable=False)
file_name = Column(String, unique=True, nullable=False)
locked = Column(Boolean, default=False, nullable=False)
state = Column(Enum(ImageState), default=ImageState.CREATING, nullable=False)
visibility = Column(Enum(ImageVisibility), default=ImageVisibility.PRIVATE, nullable=False)
created_at = Column(ArrowType(timezone=True), server_default=text('clock_timestamp()'), nullable=False, index=True)
updated_at = Column(ArrowType(timezone=True), server_default=text('clock_timestamp()'),
onupdate=text('clock_timestamp()'), nullable=False)
members = relationship(Project, secondary='image_members')
class ImageMembers(Base):
__tablename__ = 'image_members'
image_id = Column(UUIDType, ForeignKey('images.id', ondelete='CASCADE'), nullable=False, primary_key=True)
project_id = Column(UUIDType, ForeignKey('projects.id', ondelete='CASCADE'), nullable=False, primary_key=True)
created_at = Column(ArrowType(timezone=True), server_default=text('clock_timestamp()'), nullable=False, index=True)
class DnsProvider(db.Model):
__tablename__ = 'dns_providers'
id = Column(
Integer(),
primary_key=True,
)
name = Column(String(length=256), unique=True, nullable=True)
description = Column(Text(), nullable=True)
provider_type = Column(String(length=256), nullable=True)
credentials = Column(Vault, nullable=True)
api_endpoint = Column(String(length=256), nullable=True)
date_created = Column(ArrowType(),
server_default=text('now()'),
nullable=False)
status = Column(String(length=128), nullable=True)
options = Column(JSON, nullable=True)
domains = Column(JSON, nullable=True)
certificates = relationship("Certificate",
backref='dns_provider',
foreign_keys='Certificate.dns_provider_id',
lazy='dynamic')
def __init__(self, name, description, provider_type, credentials):
self.name = name
self.description = description
self.provider_type = provider_type
self.credentials = credentials
@property
def plugin(self):
return plugins.get(self.plugin_name)
def __repr__(self):
return "DnsProvider(name={name})".format(name=self.name)
class Payment(db.Model):
__tablename__ = 'payments'
id = Column(Integer, primary_key=True)
uid = Column(String)
amount = Column(Numeric)
date = Column(ArrowType(timezone=True))
method = Column(String)
status = Column(String)
comment = Column(String)
def __init__(self, uid, amount, date, method, status, comment=''):
self.uid = uid
self.amount = amount
self.date = date
self.method = method
self.status = status
self.comment = comment
if not self.comment:
t = customers_payment_data_table
q = select([t]).where(t.c.uid == self.uid).\
where(t.c.payment_method == self.method)
r = engine.execute(q).first()
if r is not None:
self.comment = r['payment_info']
def __repr__(self):
return '<Payment {}>'.format(self.id)
class Phrase(db.Model):
__tablename__ = 'query'
id = Column(Integer, primary_key=True)
name = Column(String, unique=True)
last_parsed_date = Column(ArrowType(timezone=True))
@classmethod
def get_parse_dates(cls):
phrases = {x.q: str(x.date_created) for x in Page.pages_query()}
phrases_all = {x.name for x in cls.query}
for phrase in phrases_all:
if phrase not in phrases:
phrases[phrase] = None
return sorted(phrases.items())
@classmethod
def rotate(cls, n):
q = cls.query
q_1 = q.filter(cls.last_parsed_date.is_(None)).order_by(
func.random()).limit(n)
q_2 = q.filter(cls.last_parsed_date.isnot(None)).order_by(
cls.last_parsed_date)
names_random = [x.name for x in q_1]
m = max(0, n - len(names_random))
names = [x.name for x in q_2.limit(m * 5)]
random.shuffle(names)
return names_random + names[:m]
def upgrade():
op.add_column('device',
sa.Column('registered_at', ArrowType(), nullable=True))
op.create_unique_constraint(None, 'device', ['id'])
op.drop_column('device', 'registred_at')
op.create_unique_constraint(None, 'device_log', ['id'])
op.create_unique_constraint(None, 'device_task', ['id'])