class SubjectEntity(db.Model, CRUDMixin):
""" Stores the REDCap subject data """
__tablename__ = 'Subject'
id = db.Column("sbjID", db.Integer, primary_key=True)
redcap_id = db.Column("sbjRedcapID",
db.String(255),
nullable=False,
unique=True)
added_at = db.Column("sbjAddedAt",
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
last_checked_at = db.Column("sbjLastCheckedAt",
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
was_deleted = db.Column("sbjWasDeleted",
db.Boolean(),
nullable=False,
server_default='0')
def __repr__(self):
return """<SubjectEntity (sbjID: {0.id},
sbjRedcapID: {0.redcap_id}, sbjAddedAt: {0.added_at})>""".format(self)
@staticmethod
def get_by_redcap_id(redcap_id):
""" Search helper: WHERE redcap_id = 123"""
subject = SubjectEntity.query.filter_by(redcap_id=redcap_id).first()
print subject
return subject
def serialize(self):
"""Return object data for jsonification
Note: There is some `residual jsx code` that expects the
`events` array to be sent
"""
return {
'id': self.id,
'redcap_id': self.redcap_id,
'events': [],
'added_at': utils.localize_est_datetime(self.added_at),
'last_checked_at':
utils.localize_est_datetime(self.last_checked_at),
'was_deleted': self.was_deleted
}
class UserRoleEntity(db.Model, CRUDMixin):
""" Stores the user-role mapping """
__tablename__ = 'UserRole'
id = db.Column("urID", db.Integer, primary_key=True)
user_id = db.Column("usrID",
db.Integer,
db.ForeignKey('User.usrID', ondelete='CASCADE'),
nullable=False)
role_id = db.Column("rolID",
db.Integer,
db.ForeignKey('Role.rolID', ondelete='CASCADE'),
nullable=False)
added_at = db.Column('urAddedAt',
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
role = db.relationship('RoleEntity', uselist=False)
user = db.relationship('UserEntity', uselist=False)
def get_id(self):
""" return the unicode of the primary key value """
return unicode(self.id)
def __repr__(self):
return "<UserRoleEntity (\n\t" \
"urID: {0.id}, \n\t" \
" {0.user!r}, \n\t" \
" {0.role!r}, \n" \
" {0.added_at}, \n" \
")>".format(self)
class EventEntity(db.Model, CRUDMixin):
""" Stores a list of redcap events """
__tablename__ = 'Event'
id = db.Column("evtID", db.Integer, primary_key=True)
redcap_arm = db.Column("evtRedcapArm", db.String(255), nullable=False)
redcap_event = db.Column("evtRedcapEvent", db.String(255), nullable=False)
added_at = db.Column("evtAddedAt",
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
def get_unique_event_name(self):
""" Helper for generating the unique string `event_arm` """
uniq = "{}_{}".format(self.redcap_event, self.redcap_arm)
return uniq.lower().replace(" ", "_")
def serialize(self):
"""Return object data for jsonification """
return {
'id': self.id,
'redcap_arm': self.redcap_arm,
'redcap_event': self.redcap_event,
'unique_event_name': self.get_unique_event_name(),
'added_at': dump_datetime(self.added_at),
}
class EventEntity(db.Model, CRUDMixin):
""" Stores a list of redcap events """
__tablename__ = 'Event'
id = db.Column("evtID", db.Integer, primary_key=True)
redcap_arm = db.Column("evtRedcapArm", db.String(255), nullable=False)
redcap_event = db.Column("evtRedcapEvent", db.String(255), nullable=False)
day_offset = db.Column("evtDayOffset", db.Float, nullable=False,
server_default='0')
added_at = db.Column("evtAddedAt", db.DateTime(), nullable=False,
server_default='0000-00-00 00:00:00')
def get_unique_event_name(self):
""" Helper for generating the unique string `event_arm` """
uniq = "{}_{}".format(self.redcap_event, self.redcap_arm)
return uniq.lower().replace(" ", "_")
def __repr__(self):
return """<EventEntity (evtID: {0.id},
evtRedcapArm: {0.redcap_arm}, evtRedcapEvent: {0.redcap_event},
evtDayOffset: {0.day_offset}, evtAddedAt:{0.added_at})>""".format(self)
def serialize(self):
"""Return object data for jsonification """
return {
'id': self.id,
'redcap_arm': self.redcap_arm,
'redcap_event': self.redcap_event,
'day_offset': self.day_offset,
'unique_event_name': self.get_unique_event_name(),
'added_at': utils.localize_est_date(self.added_at),
}
class SubjectEntity(db.Model, CRUDMixin):
""" Stores the REDCap subject data """
__tablename__ = 'Subject'
id = db.Column("sbjID", db.Integer, primary_key=True)
redcap_id = db.Column("sbjRedcapID",
db.String(255),
nullable=False,
unique=True)
added_at = db.Column("sbjAddedAt",
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
last_checked_at = db.Column("sbjLastCheckedAt",
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
was_deleted = db.Column("sbjWasDeleted",
db.Boolean(),
nullable=False,
server_default='0')
# @OneToOne
# user = db.relationship('UserEntity', uselist=False, lazy='joined')
def __repr__(self):
return """<SubjectEntity (sbjID: {0.id},
sbjRedcapID: {0.redcap_id}, sbjAddedAt: {0.added_at})>""".format(self)
def serialize(self):
"""Return object data for jsonification
Note: There is some `residual jsx code` that expects the
`events` array to be sent
"""
return {
'id': self.id,
'events': [],
# 'events': [{'event_id': '1', 'event_files': '1'}],
# 'files': [f.name for f in self.files],
'added_at': dump_datetime(self.added_at),
'last_checked_at': dump_datetime(self.last_checked_at),
'was_deleted': self.was_deleted
}
class SubjectFileEntity(db.Model, CRUDMixin):
""" Stores the file metadata """
__tablename__ = 'SubjectFile'
id = db.Column("sfID", db.Integer, primary_key=True)
subject_id = db.Column("sbjID", db.Integer, db.ForeignKey('Subject.sbjID'),
nullable=False)
event_id = db.Column("evtID", db.Integer, db.ForeignKey('Event.evtID'),
nullable=False)
file_name = db.Column("sfFileName", db.String(255), nullable=False)
file_check_sum = db.Column("sfFileCheckSum", db.String(32), nullable=False)
file_size = db.Column("sfFileSize", db.String(255), nullable=False)
uploaded_at = db.Column("sfUploadedAt", db.DateTime(), nullable=False,
server_default='0000-00-00 00:00:00')
user_id = db.Column("usrID", db.Integer, db.ForeignKey('User.usrID'),
nullable=False)
# @OneToOne
subject = db.relationship('SubjectEntity', uselist=False, lazy='joined')
event = db.relationship('EventEntity', uselist=False, lazy='joined')
user = db.relationship('UserEntity', uselist=False, lazy='joined')
def get_full_path(self, prefix):
"""
Build the full path using the database info and the prefix
@TODO: implement the naming convention
"""
return os.path.join(prefix, self.file_name)
def __repr__(self):
return "<SubjectFileEntity (sfID: {0.id}, sbjID: {0.subject_id})>" \
"usrID: {0.user_id}".format(self)
def serialize(self):
"""Return object data for jsonification """
return {
'id': self.id,
'file_name': self.file_name,
'file_check_sum': self.file_check_sum,
'file_size': self.file_size,
'uploaded_at': dump_datetime(self.uploaded_at),
'subject_id': self.subject_id,
'event_id': self.event_id,
'user_id': self.user_id,
'user_name': self.user.get_name(),
# 'subject': self.subject.serialize(),
# 'event': self.event.serialize(),
# 'user': self.user.serialize(),
}
class UserEntity(db.Model, UserMixin, CRUDMixin):
""" Stores the basic information about the user.
Implements the functions as required by:
https://flask-login.readthedocs.org/en/latest/
"""
__tablename__ = 'User'
id = db.Column("usrID", db.Integer, primary_key=True)
email = db.Column("usrEmail", db.String(255), nullable=False, unique=True)
first = db.Column("usrFirst", db.String(255), nullable=False)
last = db.Column("usrLast", db.String(255), nullable=False)
minitial = db.Column("usrMI", db.String(1), nullable=False)
added_at = db.Column("usrAddedAt",
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
modified_at = db.Column("usrModifiedAt", db.TIMESTAMP(), nullable=False)
# server_default='CURRENT_TIMESTAMP')
email_confirmed_at = db.Column("usrEmailConfirmedAt",
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
active = db.Column("usrIsActive",
db.Boolean(),
nullable=False,
server_default='1')
access_expires_at = db.Column("usrAccessExpiresAt",
db.DateTime(),
nullable=False,
server_default='0000-00-00 00:00:00')
password_hash = db.Column("usrPasswordHash",
db.String(255),
nullable=False,
server_default='')
# @OneToMany
roles = db.relationship(RoleEntity,
secondary=UserRoleEntity.__tablename__,
backref=db.backref('users'),
lazy='dynamic')
"""
`lazy` defines when SQLAlchemy will load the data from the database:
'select' (which is the default) means that SQLAlchemy will load the
data as necessary in one go using a standard select statement.
'joined' tells SQLAlchemy to load the relationship in the same query as the
parent using a JOIN statement.
'subquery' works like 'joined' but instead SQLAlchemy will use a subquery.
'dynamic' is special and useful if you have may items. Instead of loading
the items SQLAlchemy will return another query object which you can
further refine before loading them items. This is usually what you want
if you expect more than a handful of items for this relationship.
"""
def is_active(self):
""" An user can be blocked by setting a flag in the database """
return self.active
def is_expired(self):
""" An user can be blocked by setting expiration date to yesterday"""
return self.access_expires_at < datetime.today()
def is_anonymous(self):
""" Flag instances of valid users """
return False
def is_authenticated(self):
""" Returns True if the user is authenticated, i.e. they have provided
valid credentials.
(Only authenticated users will fulfill the criteria of login_required.)
"""
return True
def get_id(self):
""" The id encrypted in the session """
return unicode(self.id)
def get_roles(self):
""" Return text representation of user roles """
return [role.name for role in self.roles]
"""
@property
def to_visible(self):
visible_props = ['id', 'email', 'first', 'last', 'minitial',
'added_at', 'modified_at', 'email_confirmed_at',
'is_active', 'access_expires_at']
return dict([(key, val) for key, val in self.__dict__.items()
if key in UserEntity.visible_props])
"""
def get_name(self):
"""
:rtype string
:return concat(first, ' ', last)
"""
return "{} {}".format(self.first, self.last)
def get_email_verification_token(self):
"""
:rtype string
:return the email verification token stored in the database
"""
return "token"
def serialize(self):
"""Return object data for jsonification"""
return {
'id': self.id,
'email': self.email,
'roles': [r.name for r in self.roles],
'first': self.first,
'last': self.last,
'minitial': self.minitial,
'is_active': True if self.active else False,
'is_expired': True if self.is_expired() else False,
'added_at': dump_datetime(self.added_at),
'email_confirmed_at': dump_datetime(self.email_confirmed_at),
'access_expires_at': dump_datetime(self.access_expires_at),
}
def __repr__(self):
return "<UserEntity (usrID: {0.id}, usrEmail: {0.email}, " \
"usrIsActive: {0.active})>".format(self)
