class RadPostAuth(db.Model):
__tablename__ = 'radpostauth'
id = db.Column(UnsignedIntType, primary_key=True)
username = db.Column(db.String(64), nullable=False, server_default='', index=True)
radpass = db.Column('pass', db.String(64), nullable=False, server_default='')
reply = db.Column(db.String(32), nullable=False, server_default='')
authdate = db.Column(db.TIMESTAMP, nullable=False,
server_default=func.utc_timestamp(), server_onupdate=func.utc_timestamp()
# nullable=False, default=func.utc_timestamp(), onupdate=func.utc_timestamp()
# server_default=db.text('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP')
)
def __repr__(self):
return '<#{0}. RadPostAuth username {1}>'.format(self.id, self.username)
def __init__(self, author, subject, title, text,
date=func.utc_timestamp()):
self.steamid = author
self.subject = subject
self.title = title
self.text = text
self.date = date
def __init__(self, targetid, fromsteamid, comment, date=func.utc_timestamp(), atsecond=None):
self.targetid = targetid
self.fromsteamid = fromsteamid
self.comment = comment
self.date = date
self.edited = False
self.atsecond = atsecond
class DBComment(db.Model):
__tablename__ = 'comments'
id = db.Column(INTEGER(unsigned=True), primary_key=True)
targetid = db.Column(INTEGER(unsigned=True), nullable=False)
fromsteamid = db.Column(BIGINT(unsigned=True),
unique=False,
nullable=False)
comment = db.Column(TEXT(), nullable=False)
date = db.Column(DATETIME(), nullable=False)
last_modify = db.Column(DATETIME(), onupdate=func.utc_timestamp())
edited = db.Column(BOOLEAN(), default=False, nullable=False)
isanswer = db.Column(BOOLEAN(), default=False, nullable=False)
answerid = db.Column(INTEGER(unsigned=True), nullable=True, default=None)
atsecond = db.Column(INTEGER(unsigned=True), default=None, nullable=True)
def __init__(self,
targetid,
fromsteamid,
comment,
date=func.utc_timestamp(),
atsecond=None):
self.targetid = targetid
self.fromsteamid = fromsteamid
self.comment = comment
self.date = date
self.edited = False
self.atsecond = atsecond
def edit(self, newcomment, atsecond):
self.comment = newcomment
self.atsecond = atsecond
db.session.commit()
class Favorites(db.Model):
__tablename__ = 'favorites'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
description = db.Column(db.String(10))
ranking = db.Column(db.Integer, nullable=False)
created_date = db.Column(DateTime, default=datetime.datetime.utcnow)
category_area_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category', backref='favorites')
last_time = db.Column(DateTime, onupdate=func.utc_timestamp())
def __init__(self, title, description, ranking, created_date,
category_area_id):
self.title = title
self.description = description
self.ranking = ranking
self.created_date = created_date
self.category_area_id = category_area_id
@property
def serialize(self):
"""
Return serialized feature info
:return dict:
"""
return {
'id': self.id,
'title': self.title,
'description': self.description,
'ranking': self.ranking,
'created_date': self.created_date,
}
class Conference(BaseChanges, db.Base):
__tablename__ = 'conferences'
id = Column(INTEGER(11), primary_key=True)
title = Column(VARCHAR(255))
year = Column(VARCHAR(4), unique=True)
institution_id = Column(INTEGER(11), ForeignKey('institutions.id'))
institution = relationship('Institution')
members = relationship('MemberConferences', back_populates='conference')
vendors = relationship('Vendor',
secondary=vendor_conferences,
backref=backref('vendor_conferences',
lazy='dynamic'))
host_id = Column(INTEGER(11), ForeignKey('members.id'))
host = relationship('Member')
presentations = relationship('Presentation', back_populates='conference')
prof_cost = Column(
INTEGER(3)) # all costs are stored in cents for stripe purposes
stud_cost = Column(INTEGER(3))
vend_cost = Column(INTEGER(3))
start_date = Column(DATETIME())
end_date = Column(DATETIME())
folder_id = Column(VARCHAR(255))
created_at = Column(DATETIME(), default=func.utc_timestamp())
updated_at = Column(DATETIME(),
default=func.utc_timestamp(),
onupdate=func.utc_timestamp())
def __repr__(self):
return "<Conference(year=%s)>" % self.year
def __init__(self, conference_data):
self.year = conference_data['year']
self.prof_cost = conference_data['prof_cost']
self.stud_cost = conference_data['stud_cost']
self.vend_cost = conference_data['vend_cost']
self.start_date = conference_data['start_date']
self.end_date = conference_data['end_date']
self.title = conference_data['title']
#need to pass date object, but first I need format of date object coming from client-side
# folder_metadata = {
# 'name': conference_data['year'],
# 'mimeType': 'application/vnd.google-apps.folder',
# }
self.created_at = datetime.datetime.now()
self.updated_at = datetime.datetime.now()
class Institution(BaseChanges, db.Base):
__tablename__ = 'institutions'
id = Column(INTEGER(11), primary_key=True)
name = Column(VARCHAR(255), unique=True)
address_id = Column(INTEGER(11), ForeignKey('addresses.id'))
address = relationship('Address')
faculty_members = relationship('Member', back_populates='institution')
created_at = Column(DATETIME(), default=func.utc_timestamp())
updated_at = Column(DATETIME(),
default=func.utc_timestamp(),
onupdate=func.utc_timestamp())
def __repr__(self):
return "<Institution(name=%s)>" % self.name
def __init__(self, inst_data):
self.name = inst_data['name']
class Location(Base):
__tablename__ = 'location'
id = Column(Integer, primary_key=True)
name = Column(String(200))
address = Column(String(200))
image = Column(String(200))
timestamp = Column(DateTime,
onupdate=func.utc_timestamp(),
server_default=func.now())
class Address(BaseChanges, db.Base):
__tablename__ = 'addresses'
id = Column(INTEGER(11), primary_key=True)
street1 = Column(VARCHAR(255))
street2 = Column(VARCHAR(255))
city = Column(VARCHAR(255))
state_id = Column(INTEGER(11), ForeignKey('states.id'))
state = relationship('State', back_populates='addresses', uselist=False)
member = relationship('Member', uselist=False, back_populates='address')
zip = Column(VARCHAR(5))
created_at = Column(DATETIME(), default=func.utc_timestamp())
updated_at = Column(DATETIME(),
default=func.utc_timestamp(),
onupdate=func.utc_timestamp())
# @staticmethod
# def validate(addy_data):
# validations = {
# 'all_valid': False,
# 'errors': [],
# 'validated_data': {},
# 'int_errors':[]
# }
# all_valid = True
# try:
# blank_info = valids.check_blanks(addy_data)
# if not blank_info['all_valid']:
# all_valid = False
# for err in blank_info['errors']:
# validations['errors'].append(err)
# except:
# e = sys.exc_info()[:0]
# all_valid = False
# validations['int_errors'].append('Model Class: There was a problem when validating data. {}'.format(e))
# return validations
def __init__(self, address_data):
self.street1 = address_data['street1']
self.street2 = address_data[
'street2'] if 'street2' in address_data else ''
self.city = address_data['city']
self.state_id = address_data['state_id']
self.zip = address_data['zip']
def __init__(self,
targetid,
fromsteamid,
comment,
date=func.utc_timestamp(),
atsecond=None):
self.targetid = targetid
self.fromsteamid = fromsteamid
self.comment = comment
self.date = date
self.edited = False
self.atsecond = atsecond
class Ride(Base):
__tablename__ = 'ride'
id = Column(Integer, primary_key=True)
start_id = Column(Integer, ForeignKey('location.id'))
end_id = Column(Integer, ForeignKey('location.id'))
time = Column(Time)
date = Column(Date)
seats = Column(Integer, default=1)
info = Column(String(500))
timestamp = Column(DateTime,
onupdate=func.utc_timestamp(),
server_default=func.now())
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
firstname = Column(String(200))
lastname = Column(String(200))
email = Column(String(200), unique=True)
password = Column(String(200))
phone = Column(String(20))
image = Column(String(200))
timestamp = Column(DateTime,
onupdate=func.utc_timestamp(),
server_default=func.now())
class Member(BaseChanges, db.Base):
__tablename__ = 'members'
id = Column(INTEGER(11), primary_key=True)
first_name = Column(VARCHAR(255))
last_name = Column(VARCHAR(255))
address_id = Column(INTEGER(11), ForeignKey('addresses.id'))
address = relationship('Address')
email = Column(VARCHAR(255), unique=True)
password = Column(VARCHAR(255))
pw_salt = Column(VARCHAR(255))
officer = Column(BOOLEAN())
type = Column(VARCHAR(20))
active = Column(BOOLEAN())
institution_id = Column(INTEGER(11), ForeignKey('institutions.id'))
institution = relationship('Institution', back_populates='faculty_members')
host = relationship('Conference', uselist=False, back_populates='host')
presentations = relationship('Presentation',
secondary=member_presentations,
back_populates='presenters')
conferences = relationship('MemberConferences', back_populates='member')
created_at = Column(DATETIME(), default=func.utc_timestamp())
updated_at = Column(DATETIME(),
default=func.utc_timestamp(),
onupdate=func.utc_timestamp())
def __init__(self, member_data):
print member_data
self.first_name = member_data['first_name']
self.last_name = member_data['last_name']
# self.address_id = member_data['address_id']
self.email = member_data['email']
self.pw_salt = member_data['salt']
self.password = member_data['hash']
self.officer = True if 'officer' in member_data else False
self.active = False
self.type = member_data['type']
# self.institution_id = member_data['institution_id']
def __repr__(self):
return '<Member(id=%r,email=%r>' % (self.id, self.email)
class Vendor(BaseChanges, db.Base):
__tablename__ = 'vendors'
id = Column(INTEGER(11), primary_key=True)
name = Column(VARCHAR(255), unique=True)
address_id = Column(INTEGER(11), ForeignKey('addresses.id'))
contact_name = Column(VARCHAR(255))
contact_email = Column(VARCHAR(255))
contact_phone = Column(VARCHAR(15))
conferences = relationship('Conference',
secondary=vendor_conferences,
backref=backref('conf_vendors', lazy='dynamic'))
created_at = Column(DATETIME(), default=func.utc_timestamp())
updated_at = Column(DATETIME(),
default=func.utc_timestamp(),
onupdate=func.utc_timestamp())
def __init__(self, vend_info):
self.name = vend_info['name']
self.address_id = vend_info['address_id']
self.contact_name = vend_info['contact_name']
self.contact_email = vend_info['contact_email']
self.contact_phone = vend_info['contact_phone']
class LogSurvey(DeclarativeBase):
__tablename__ = 'sur_log_survey'
id_log_survey = Column(Integer, autoincrement=True, primary_key=True)
ip_server = Column(String(20), nullable=True)
ip_client = Column(String(20), nullable=True)
#status = Column(String(20), nullable=True);
relative_created = Column(String(20), nullable=True)
name = Column(String(255), nullable=True)
log_level = Column(String(20), nullable=True)
level_text = Column(String(20), nullable=True)
message = Column(Text, nullable=True)
file_name = Column(String(255), nullable=True)
path_name = Column(Text, nullable=True)
line_no = Column(String(10), nullable=True)
milliseconds = Column(String(20), nullable=True)
exception = Column(Text, nullable=True)
thread = Column(String(10), nullable=True)
current_page = Column(String(255), nullable=True)
user_name = Column(String(255), nullable=True)
active = Column(BIT, nullable=True, default=1)
#create_date = Column(DateTime, default=func.now());
create_date = Column(TIMESTAMP(timezone=True),
nullable=True,
default=func.utc_timestamp())
modules = Column(String(255), nullable=True)
#update_date = Column(DateTime ,onupdate=sql.func.utc_timestamp());
def __init__(self):
self.active = 1
def __unicode__(self):
return self.__repr__()
def __repr__(self):
return "<Log: %s - %s>" % (
self.create_date.strftime('%m/%d/%Y-%H:%M:%S'), self.message[:50])
def save(self):
DBSession.add(self)
DBSession.flush()
class Presentation(BaseChanges, db.Base):
__tablename__ = 'presentations'
id = Column(INTEGER(11), primary_key=True)
title = Column(VARCHAR(255), unique=True)
summary = Column(TEXT())
files_url = Column(
TEXT()) ##trying to utilize Google Drive for file upload
approved = Column(BOOLEAN())
duration = Column(INTEGER(2)) #time in minutes
datetime = Column(DATETIME())
presenters = relationship('Member',
secondary=member_presentations,
back_populates='presentations')
conference_id = Column(INTEGER(11), ForeignKey('conferences.id'))
conference = relationship('Conference',
back_populates='presentations',
uselist=False)
created_at = Column(DATETIME(), default=func.utc_timestamp())
updated_at = Column(DATETIME(),
default=func.utc_timestamp(),
onupdate=func.utc_timestamp())
def __init__(self, present_info):
self.title = present_info['title']
self.summary = present_info['summary']
self.approved = False
self.conference_id = present_info['conference_id']
self.duration = present_info['duration'] #time in minutes
self.add_files(
present_info['files']) if 'files' in present_info else None
self.presenters.append(**present_info['presenters'])
##Presenters should be added in the controller
#Check for year folder
# Create it if it doesn't exist
#Create a folder for the presentation (using presentation title)
#save folder id and place files in the folder if there are any
def add_files(self, files):
conference = Conference.query.get(self.conference_id)
#check for conference year folder, create if none
year_folder = drive.files().list(
q="name=" + conference['year'] +
" and mimeType='application/vnd.google-apps.folder'")
if len(year_folder['files']) == 0:
folder_params = {
'mimeType': "application/vnd.google-apps.folder",
'name': conference['year'],
'parents': sens.drive_root_folder_id
}
drive.files().create(body=folder_params).execute()
#check for presentation folder, create if none
present_folder = drive.files().list(
q="name=" + self.title +
" and mimeType='application/vnd.google-apps.folder'")
if len(present_folder['files']) == 0:
folder_params = {
'mimeType': "application/vnd.google-apps.folder",
'name': self.title,
'parents': year_folder['files'][0]['id']
}
drive.files().create(body=folder_params).execute()
#Upload each file to the folder
for file in files:
file_data = {
'name': file['name'],
'parents': present_folder['files'][0]['id']
}
drive.files.create(body=file_data, media_body=file['file'])
self.files_url = drive.files(
fileId=present_folder['files'][0]['id'])['webViewLink']
class Report(db.Model):
__tablename__ = 'reports'
report_id = db.Column(db.Integer, primary_key=True)
original_text = db.Column(LONGTEXT)
original_language = db.Column(TEXT)
translated_text = db.Column(LONGTEXT)
category = db.Column(TEXT)
radlex_annotations = db.Column(LONGTEXT)
creation_date = db.Column(db.DateTime(timezone=True),
default=func.utc_timestamp())
def __init__(self, original_text, original_language, category):
self.original_text = original_text
self.original_language = original_language
self.category = category
def __repr__(self):
return '<report_id {}>'.format(self.report_id)
@staticmethod
def get_last_n_reports(n):
"""Get the last n reports added to the database"""
return Report.query.order_by(Report.creation_date.desc()).limit(10)
@staticmethod
def add_report(original_text, original_language, category):
new_report = Report(original_text=original_text,
original_language=original_language,
category=category)
db.session.add(new_report)
db.session.commit()
return new_report
@staticmethod
def add_translated_text(report_id, translated_text):
report = Report.query.get(report_id)
report.translated_text = translated_text
db.session.commit()
return True
@staticmethod
@celery.task()
def translate_report(report_id):
report = Report.query.get(report_id)
api = UnbabelApi(username=app.config['UNBABEL_USERNAME'],
api_key=app.config['UNBABEL_API_KEY'],
sandbox=True)
callback_url = '{}/translate_report_callback/{}'.format(
app.config['ROOT_URL'], report_id)
api.post_translations(text=report.original_text,
source_language=report.original_language,
target_language='en',
callback_url=callback_url)
@staticmethod
@celery.task()
def annotate_report(report_id):
report = Report.query.get(report_id)
if report.original_language == 'en':
text_to_annotate = report.original_text
else:
text_to_annotate = report.translated_text
bioportal_api = Bioportal(app.config['BIOPORTAL_API_KEY'])
annotations = bioportal_api.annotator(text_to_annotate,
ontologies='RADLEX')
processed_annotations = process_bioportal_annotations(
annotations, bioportal_api)
annotations_str = unicode(str(processed_annotations))
report.radlex_annotations = annotations_str
db.session.commit()
@staticmethod
def is_processed(report_id):
"""Check if the report with id report_id is already processed. If the
text is in English, the text only needs to be annotated. Otherwise,
it needs to be translated and annotated."""
report = Report.query.get(report_id)
if report.radlex_annotations and (report.original_language == 'en'
or report.translated_text):
return True
else:
return False
@staticmethod
def get_dict(report_id, complete=False):
"""Returns a dictionary representation of the Report object. Beyond
the default attributes of the object, a "processed" attribute is added
to the dictionary, indicting if the report was already processed.Flask
If complete is "True", more lengthy information is sent. This
corresponds to 'original_text' 'translated_text' and
'radlex_annotations'."""
report = Report.query.get(report_id)
report_dict = report.__dict__
clean_report_dict = dict((k, report_dict[k])
for k in report_dict.keys()
if k not in ('_sa_instance_state'))
if not complete:
clean_report_dict = dict(
(k, clean_report_dict[k]) for k in clean_report_dict.keys()
if k not in ('original_text', 'translated_text',
'radlex_annotations'))
clean_report_dict['processed'] = Report.is_processed(report_id)
return clean_report_dict
def login(self, session, sessionID):
self.session_id = sessionID
self.session_date = func.utc_timestamp()
session.commit()
return (self.username, sessionID)
def __init__(self, author, subject, title, text, date=func.utc_timestamp()):
self.steamid = author
self.subject = subject
self.title = title
self.text = text
self.date = date
class DBUser(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(INTEGER(unsigned=True), primary_key=True)
username = db.Column(VARCHAR(30), unique=False)
email = db.Column(VARCHAR(255), unique=True)
verified = db.Column(BOOLEAN(), default=False)
is_translator = db.Column(BOOLEAN(), default=False)
is_mapper = db.Column(BOOLEAN(), default=False)
access = db.Column(SMALLINT(unsigned=True), default=rank_user_normal)
steamid = db.Column(BIGINT(unsigned=True), unique=True, nullable=False)
avatar = db.Column(TEXT())
token = db.Column(VARCHAR(32))
joindate = db.Column(DATETIME())
last_login = db.Column(DATETIME())
last_modify = db.Column(DATETIME(), onupdate=func.utc_timestamp())
def __init__(self, steamid, username=None, email=None, access=0):
self.steamid = steamid
self.username = username
self.email = email
self.access = access
self.joindate = func.utc_timestamp()
def get_id(self):
return unicode(self.id)
def is_anonymous(self):
return False
def is_authenticated(self):
return hasattr(self, 'id')
def is_active(self):
return hasattr(self, 'id')
def get_steamid(self):
return (self.steamid)
@staticmethod
def get_or_create(steamid, access):
rv = DBUser.query.filter_by(steamid=steamid).first()
if rv is None:
newuser = get_steam_userinfo(steamid)
rv = DBUser(steamid,
username=newuser["personaname"],
access=access)
db.session.add(rv)
db.session.commit()
if rv is not None and rv.access >= rank_momentum_normal:
rv.upgradeto_memberof_momentum()
return rv
def upgradeto_memberof_momentum(self):
if self.access >= rank_momentum_normal:
pre = DBTeam.query.filter_by(steamid=self.steamid).first()
if pre is None:
member = DBTeam(self.steamid,
nickname=self.username,
priority=rank_momentum_admin - self.access)
db.session.add(member)
db.session.commit()
else:
pre.user_rejoined()
def upgradeto_memberof_momentum_access(self, access):
if access >= rank_momentum_normal:
pre = DBTeam.query.filter_by(steamid=self.steamid).first()
if pre is None:
member = DBTeam(self.steamid,
nickname=self.username,
priority=rank_momentum_admin - int(access))
db.session.add(member)
db.session.commit()
else:
pre.user_rejoined()
def get_steam_userinfo(self):
return get_steam_userinfo(self.steamid) or {}
def get_friendslist(self):
return get_friendslist(self.steamid) or {}
def update_steam_userinfo(self, userinfo):
if userinfo is None:
return False
changes = False
if not self.username == userinfo['personaname'] and userinfo[
'personaname'] is not None:
self.username = userinfo['personaname']
changes = True
if not self.avatar == userinfo['avatar'] and userinfo[
'avatar'] is not None:
self.avatar = userinfo['avatar']
changes = True
if changes == True:
db.session.commit()
return changes
def update_translatorstatus(self, is_translator):
if self.is_translator != is_translator:
self.is_translator = is_translator
db.session.commit()
def update_mapperstatus(self, is_mapper):
if self.is_mapper != is_mapper:
self.is_mapper = is_mapper
db.session.commit()
def update_handlenewemail(self, email):
if email is not None:
#Here goes a random token sent to the email to confirm it
self.verified = False
sep = ''
self.token = sep.join([random.choice(saltset) for x in xrange(32)])
self.email = email
msg = Message("Momentum Mod Email Confirmation",
recipients=[self.email])
msg.html = "<p>In order to confirm your new email adress, you will need to follow:<br><a href='" + url_for(
'dashboard_settings_verifyemail',
token=str(self.token),
_external=True
) + "' target='_blank'>" + url_for(
'dashboard_settings_verifyemail',
token=str(self.token),
_external=True
) + "</a></p><p><small>If you did not request this email, you can ignore it.<br>We promise you that we won't spam you with useless emails. Only important facts! We won't either share your data. Your privacy is something we take seriouslly.</small></p><br><p><b>Kind regards,<br><i>Momentum Mod Team</i></b></p>"
mail.send(msg)
db.session.commit()
def update_verifyemail(self):
self.verified = True
self.token = None
db.session.commit()
def update_accesslevel(self, newaccess):
if not self.access == newaccess:
if newaccess < rank_user_banned:
newaccess = rank_user_banned
if newaccess < rank_webmaster:
newaccess = rank_webmaster
if self.access < rank_momentum_normal and newaccess >= rank_momentum_normal:
self.upgradeto_memberof_momentum_access(newaccess)
if self.access >= rank_momentum_normal and newaccess < rank_momentum_normal:
member = DBTeam.query.filter_by(steamid=self.steamid).first()
if member is not None:
member.user_teamleft()
self.access = newaccess
db.session.commit()
def update_lastlogin(self):
self.last_login = func.utc_timestamp()
db.session.commit()
def ban_user(self):
update_accesslevel(rank_user_banned)
def __repr__(self):
return '<User %r>' % self.username
def update_lastlogin(self):
self.last_login = func.utc_timestamp()
db.session.commit()
def __init__(self, steamid, username=None, email=None, access=0):
self.steamid = steamid
self.username = username
self.email = email
self.access = access
self.joindate = func.utc_timestamp()
def __init__(self, steamid, username=None, email=None, access=0):
self.steamid = steamid
self.username = username
self.email = email
self.access = access
self.joindate = func.utc_timestamp()
def update_lastlogin(self):
self.last_login = func.utc_timestamp()
db.session.commit()
