class LabManagerUser(db.Model, SBBase, UserMixin): __tablename__ = 'labmanager_users' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) login = db.Column(db.Unicode(50), unique = True, nullable = False) name = db.Column(db.Unicode(50), nullable = False) password = db.Column(db.Unicode(50), nullable = False) # hash def __init__(self, login = None, name = None, password = None): self.login = login self.name = name self.password = password def __repr__(self): return "LabManagerUser(%(userlogin)r, %(username)r, %(userpassword)r)" % dict(userlogin=self.login, username=self.name, userpassword=self.password) def __unicode__(self): return self.name def get_id(self): return u"labmanager_admin::%s" % self.login @classmethod def exists(self, login, word): return db.session.query(self).filter(sql.and_(self.login == login, self.password == word)).first()
class Course(db.Model, SBBase): __tablename__ = 'courses' __table_args__ = (db.UniqueConstraint('lt_id', 'context_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) lt_id = db.Column(db.Integer, db.ForeignKey('learning_tools.id'), nullable=False) name = db.Column(db.Unicode(50), nullable=False) context_id = db.Column(db.Unicode(50), nullable=False) lt = relation('LearningTool', backref=backref('courses', order_by=id, cascade='all, delete')) def __init__(self, name=None, lt=None, context_id=None): self.name = name self.lt = lt self.context_id = context_id def __repr__(self): return "Course(name=%(coursename)r, lt=%(courselms)r, context_id=%(coursecontext)r)" % dict( coursename=self.name, courselms=self.lt, coursecontext=self.context_id) def __unicode__(self): return gettext(u"%(coursename)s on %(courselms)s", coursename=self.name, courselms=self.lt)
class ShindigCredentials(db.Model, SBBase): __tablename__ = 'shindig_credentials' __table_args__ = (db.UniqueConstraint('lt_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) lt_id = db.Column(db.Integer, db.ForeignKey('learning_tools.id'), nullable=False) # The URL of the Shindig server. Example: http://shindig.epfl.ch (no trailing slash) shindig_url = db.Column(db.Unicode(50), nullable=False) lt = relation('LearningTool', backref=backref('shindig_credentials', order_by=id, cascade='all, delete')) def __init__(self, lt=None, shindig_url=None): self.lt = lt self.shindig_url = shindig_url def __repr__(self): return "ShindigCredentials(lt=%(lmslms)r, shindig_url=%(shindigurl)r)" % dict( lmslms=self.lt, shindigurl=self.shindig_url) def __unicode__(self): return gettext(u"ShindigCredentials for %(lmsname)s", lmsname=self.lt.name)
class Laboratory(db.Model, SBBase): __tablename__ = 'laboratories' __table_args__ = (db.UniqueConstraint('laboratory_id', 'rlms_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key = True) name = db.Column(db.Unicode(255), nullable = False) laboratory_id = db.Column(db.Unicode(255), nullable = False) rlms_id = db.Column(db.Integer, db.ForeignKey('rlmss.id'), nullable = False) visibility = db.Column(db.Unicode(50), nullable = False, index = True, default = u'private') available = db.Column(db.Boolean, nullable = False, index = True, default = False) default_local_identifier = db.Column(db.Unicode(50), nullable = False, default = u"") publicly_available = db.Column(db.Boolean, nullable = False, index = True, default = False) # Not unique: otherwise there wouldn't be more than one with '' as value public_identifier = db.Column(db.Unicode(50), nullable = False, default = u"") go_lab_reservation = db.Column(db.Boolean, nullable = False, index = True, default = False) rlms = relation(RLMS.__name__, backref = backref('laboratories', order_by=id, cascade = 'all,delete')) def __init__(self, name = None, laboratory_id = None, rlms = None, visibility = None, available = None): self.name = name self.laboratory_id = laboratory_id self.rlms = rlms self.visibility = visibility self.available = available def __unicode__(self): return gettext(u"%(name)s at %(rlms)s", name=self.name, rlms=self.rlms)
class GoLabOAuthUser(db.Model, UserMixin): __tablename__ = 'GoLabOAuthUsers' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) display_name = db.Column(db.Unicode(255), index=True, nullable=False) email = db.Column(db.Unicode(255), index=True, nullable=False, unique=True) admin = db.Column(db.Boolean, index=True, nullable=True) def __init__(self, email, display_name, admin=False): self.email = email self.display_name = display_name self.admin = admin @property def is_admin(self): return self.admin == True def get_id(self): return u"golab::%s" % self.email def __repr__(self): return "GoLabOAuthUsers(%r, %r)" % (self.email, self.display_name) def __unicode__(self): return u"%s <%s>" % (self.display_name, self.email)
class RLMSTypeCache(db.Model): __tablename__ = 'rlmstype_cache' id = db.Column(db.Integer, primary_key = True) rlms_type = db.Column(db.Unicode(255), nullable = False, index = True) key = db.Column(db.Unicode(255), index = True) value = db.Column(db.UnicodeText(512 * 1024 * 1024)) # 512 MB datetime = db.Column(db.DateTime, index = True) def __init__(self, rlms_type, key, value, datetime): self.rlms_type = rlms_type self.key = key self.value = value self.datetime = datetime
class AllowedHost(db.Model): __tablename__ = 'AllowedHosts' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) url = db.Column(db.Unicode(100), index=True, nullable=False) creation = db.Column(db.DateTime, index=True, nullable=False) last_update = db.Column(db.DateTime, index=True, nullable=False) def __init__(self, url): self.url = url self.creation = datetime.datetime.utcnow() self.last_update = self.creation def update(self): self.last_update = datetime.datetime.utcnow()
class RLMSCache(db.Model): __tablename__ = 'rlms_caches' id = db.Column(db.Integer, primary_key = True) rlms_id = db.Column(db.Integer, db.ForeignKey('rlmss.id'), nullable = False) key = db.Column(db.Unicode(255), index = True) value = db.Column(db.UnicodeText(512 * 1024 * 1024)) # 512 MB datetime = db.Column(db.DateTime, index = True) rlms = relation(RLMS.__name__, backref = backref('caches', order_by=id, cascade = 'all,delete')) def __init__(self, rlms_id, key, value, datetime): self.rlms_id = rlms_id self.key = key self.value = value self.datetime = datetime
class BasicHttpCredentials(db.Model, SBBase): __tablename__ = 'basic_http_credentials' __table_args__ = (db.UniqueConstraint('lt_login'), db.UniqueConstraint('lt_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key = True) lt_id = db.Column(db.Integer, db.ForeignKey('learning_tools.id'), nullable = False) # Arguments for the LT to connect the LabManager lt_login = db.Column(db.Unicode(50), nullable = False) lt_password = db.Column(db.Unicode(50), nullable = False) # Arguments for the LabManager to connect the LT. Might be null lt_url = db.Column(db.Unicode(300), nullable = True) labmanager_login = db.Column(db.Unicode(50), nullable = True) labmanager_password = db.Column(db.Unicode(50), nullable = True) lt = relation('LearningTool', backref=backref('basic_http_authentications', order_by=id, cascade='all, delete')) def __init__(self, lt_login = None, lt_password = None, lt = None, lt_url = None, labmanager_login = None, labmanager_password = None): self.lt = lt self.lt_login = lt_login self.lt_password = lt_password self.lt_url = lt_url self.labmanager_login = labmanager_login self.labmanager_password = labmanager_password def __repr__(self): return "BasicHttpCredentials(lt_login=%(lmslogin)r, lt_password=%(lmspassword)r, lt=%(lmslms)r, lt_url=%(lmsurl)r, labmanager_login=%(labmanlogin)r, labmanager_password=%(labmanpassword)r)" % dict(lmslogin=self.lt_login, lmspassword=self.password, lmslms=self.lt, lmsurl=self.lt_url, labmanlogin=self.labmanager_login, labmanpassword=self.labmanager_password) def __unicode__(self): return gettext(u"Basic HTTP auth for %(name)s", name=self.lt.name) def update_password(self, old_password): if self.lt_password != old_password: self.lt_password = hashlib.new('sha', self.lt_password.encode('utf8')).hexdigest()
class LocationCache(db.Model): __tablename__ = 'LocationCache' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) pack = db.Column(db.Unicode(255), index=True, nullable=False) lookup_time = db.Column(db.DateTime, index=True, nullable=False) hostname = db.Column(db.Unicode(255), index=True) city = db.Column(db.Unicode(255), index=True) country = db.Column(db.Unicode(255), index=True) most_specific_subdivision = db.Column(db.Unicode(255), index=True) def __init__(self, pack, lookup_time, hostname, city=None, country=None, most_specific_subdivision=None): self.pack = pack self.lookup_time = lookup_time self.hostname = hostname self.city = city self.country = country self.most_specific_subdivision = most_specific_subdivision
class LearningTool(db.Model, SBBase): __tablename__ = 'learning_tools' __table_args__ = (db.UniqueConstraint('name'), db.UniqueConstraint('full_name'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key = True) name = db.Column(db.Unicode(50), nullable = False, index = True) full_name = db.Column(db.Unicode(50), nullable = False, index = True) url = db.Column(db.Unicode(300), nullable = False) def __init__(self, name = None, full_name = None, url = None): self.name = name self.full_name = full_name self.url = url def __repr__(self): return "LearningTool(%(lmsname)r, %(lmsfullname)r, %(lmsurl)r)" % dict(lmsname=self.name, lmsfullname=self.full_name, lmsurl=self.url) def __unicode__(self): return self.name
class PermissionToLtUser(db.Model, SBBase): __tablename__ = 'permissions2ltuser' __table_args__ = (db.UniqueConstraint('permission_to_lt_id', 'lt_user_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key = True) permission_to_lt_id = db.Column(db.Integer, db.ForeignKey('permissions2lt.id'), nullable = False, index = True) lt_user_id = db.Column(db.Integer, db.ForeignKey('lt_users.id'), nullable = False, index = True) # LTI data key = db.Column(db.Unicode(100), nullable = False, unique = True) secret = db.Column(db.Unicode(100), nullable = False) permission_to_lt = relation('PermissionToLt', backref=backref('lt_user_permissions', order_by=id, cascade='all, delete')) lt_user = relation('LtUser', backref=backref('lt_user_permissions', order_by=id, cascade='all, delete')) def __init__(self, permission_to_lt = None, lt_user = None, key = None, secret = None): self.permission_to_lt = permission_to_lt self.lt_user = lt_user self.key = key self.secret = secret
class PermissionToCourse(db.Model, SBBase): __tablename__ = 'permissions2course' __table_args__ = (db.UniqueConstraint('permission_to_lt_id', 'course_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key = True) configuration = db.Column(db.Unicode(10 * 1024), nullable = True) permission_to_lt_id = db.Column(db.Integer, db.ForeignKey('permissions2lt.id'), nullable = False) course_id = db.Column(db.Integer, db.ForeignKey('courses.id'), nullable = False) permission_to_lt = relation('PermissionToLt', backref=backref('course_permissions', order_by=id, cascade='all, delete')) course = relation('Course', backref=backref('permissions', order_by=id, cascade='all, delete')) def __init__(self, course = None, permission_to_lt = None, configuration = None): self.course = course self.configuration = configuration self.permission_to_lt = permission_to_lt def __repr__(self): return "PermissionToCourse(course=%(coursecourse)r, configuration=%(courseconfiguration)r, permission_to_lt=%(coursepermission)r)" % dict(coursecourse=self.course, courseconfiguration=self.configuration, coursepermission=self.permission_to_lt) def __unicode__(self): return gettext(u"%(coursename)s from %(lmsname)s on %(permission)s", coursename=self.course.name, lmsname=self.course.lt.name, permission=self.permission_to_lt)
class ManualApplication(db.Model): __tablename__ = 'ManualApplications' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Unicode(100), index=True, nullable=False) owner_id = db.Column(db.Integer, ForeignKey('GoLabOAuthUsers.id')) identifier = db.Column(db.Unicode(36), index=True, nullable=False, unique=True) creation = db.Column(db.DateTime, index=True, nullable=False) last_update = db.Column(db.DateTime, index=True, nullable=False) owner = relation("GoLabOAuthUser", backref="manual_apps") def __init__(self, name, owner, identifier): if identifier is None: identifier = unicode(uuid.uuid4()) while EmbedApplication.query.filter_by( identifier=identifier).first() is not None: identifier = unicode(uuid.uuid4()) self.identifier = identifier self.name = name self.owner = owner self.creation = datetime.datetime.utcnow() self.last_update = datetime.datetime.utcnow()
class RLMS(db.Model, SBBase): __tablename__ = 'rlmss' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key = True) name = db.Column(db.Unicode(255)) kind = db.Column(db.Unicode(50), nullable = False) location = db.Column(db.Unicode(255), nullable = False) url = db.Column(db.Unicode(300), nullable = False) version = db.Column(db.Unicode(50), nullable = False) configuration = db.Column(db.Unicode(10 * 1024)) publicly_available = db.Column(db.Boolean, nullable = False, index = True, default = False) # Not unique (otherwise there couldn't be two empty names) public_identifier = db.Column(db.Unicode(50), nullable = False, default = u'') default_autoload = db.Column(db.Boolean, nullable = True, index = True, default = None) def __init__(self, kind = None, url = None, name = None, location = None, version = None, configuration = '{}', publicly_available = False, public_identifier = u'', default_autoload = None): self.kind = kind self.location = location self.name = name self.url = url self.version = version self.configuration = configuration self.publicly_available = publicly_available self.public_identifier = public_identifier self.default_autoload = default_autoload def __repr__(self): return "RLMS(kind = %(rlmskind)r, url=%(rlmsurl)r, location=%(rlmslocation)r, version=%(rlmsversion)r, configuration=%(rlmsconfiguration)r, publicly_available=%(publicly_available)r, public_identifier = %(public_identifier)r, default_autoload = %(default_autoload)r)" % dict(rlmskind=self.kind, rlmsurl=self.url, rlmslocation=self.location, rlmsversion=self.version, rlmsconfiguration=self.configuration, publicly_available = self.publicly_available, public_identifier = self.public_identifier, default_autoload = self.default_autoload) def get_name(self): if self.name: return self.name return self.kind def __unicode__(self): return gettext(u"%(kind)s on %(location)s", kind=self.kind, location=self.location)
class LtUser(db.Model, SBBase, UserMixin): __tablename__ = 'lt_users' __table_args__ = (db.UniqueConstraint('login','lt_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key = True) login = db.Column(db.Unicode(50), nullable = False, index = True) full_name = db.Column(db.Unicode(50), nullable = False) password = db.Column(db.Unicode(128), nullable = False) access_level = db.Column(db.Unicode(50), nullable = False) lt_id = db.Column(db.Integer, db.ForeignKey('learning_tools.id'), nullable = False) lt = relation('LearningTool', backref = backref('users', order_by=id, cascade = 'all,delete')) courses = relationship("Course", secondary=users2courses_relation, backref="users") def __init__(self, login = None, full_name = None, lt = None, access_level = None): self.login = login self.full_name = full_name self.lt = lt self.access_level = access_level def __unicode__(self): return u"%(lmslogin)s@%(lmsname)s" % dict(lmslogin=self.login, lmsname=self.lt.name) def get_id(self): return u"lt_user::%s::%s" % (self.lt.name, self.login) @classmethod def exists(self, login, word, lt_id): return db.session.query(self).filter_by(login = login, password = word, lt_id = int(lt_id)).first()
class EmbedApplicationTranslation(db.Model): __tablename__ = 'EmbedApplicationTranslation' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) embed_application_id = db.Column(db.Integer, ForeignKey('EmbedApplications.id')) url = db.Column(db.Unicode(255), index=True, nullable=False) language = db.Column(db.Unicode(10), index=True, nullable=False) embed_application = relation("EmbedApplication", backref="translations") def __init__(self, embed_application, url, language): self.embed_application = embed_application self.url = url self.language = language @property def full_url(self): if self.embed_application.uses_proxy: return url_for('proxy.proxy', url=self.url, _external=True) return self.url
class RequestPermissionLT(db.Model, SBBase): __tablename__ = 'request_permissions_lt' __table_args__ = (db.UniqueConstraint('laboratory_id', 'lt_id'), db.UniqueConstraint('local_identifier', 'lt_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) local_identifier = db.Column(db.Unicode(100), nullable=False, index=True) laboratory_id = db.Column(db.Integer, db.ForeignKey('laboratories.id'), nullable=False) lt_id = db.Column(db.Integer, db.ForeignKey('learning_tools.id'), nullable=False) configuration = db.Column(db.Unicode(10 * 1024)) # JSON document accessible = db.Column(db.Boolean, nullable=False, index=True, default=False) laboratory = relation(Laboratory.__name__, backref=backref('lab_requestpermissions', order_by=id, cascade='all,delete')) lt = relation(LearningTool.__name__, backref=backref('lab_requestpermissions', order_by=id, cascade='all,delete')) def __init__(self, lt=None, laboratory=None, configuration=None, local_identifier=None, accessible=None): self.lt = lt self.laboratory = laboratory self.configuration = configuration self.local_identifier = local_identifier self.accessible = accessible def __unicode__(self): return gettext(u"'%(localidentifier)s': lab %(labname)s to %(ltname)s", localidentifier=self.local_identifier, labname=self.laboratory.name, ltname=self.lt.name)
def __repr__(self): return "ShindigCredentials(lt=%(lmslms)r, shindig_url=%(shindigurl)r)" % dict(lmslms=self.lt, shindigurl=self.shindig_url) def __unicode__(self): return gettext(u"ShindigCredentials for %(lmsname)s", lmsname=self.lt.name) ################################################## # # LT User # # LT Users (administrators or teachers) can # authenticate and change stuff at LT level. # users2courses_relation = db.Table('users2courses', db.Column('course_id', db.Integer, db.ForeignKey('courses.id')), db.Column('lt_user_id', db.Integer, db.ForeignKey('lt_users.id')) ) class LtUser(db.Model, SBBase, UserMixin): __tablename__ = 'lt_users' __table_args__ = (db.UniqueConstraint('login','lt_id'), TABLE_KWARGS) id = db.Column(db.Integer, primary_key = True) login = db.Column(db.Unicode(50), nullable = False, index = True) full_name = db.Column(db.Unicode(50), nullable = False) password = db.Column(db.Unicode(128), nullable = False) access_level = db.Column(db.Unicode(50), nullable = False) lt_id = db.Column(db.Integer, db.ForeignKey('learning_tools.id'), nullable = False) lt = relation('LearningTool', backref = backref('users', order_by=id, cascade = 'all,delete'))
class EmbedApplication(db.Model): __tablename__ = 'EmbedApplications' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) url = db.Column(db.Unicode(255), index=True, nullable=False) name = db.Column(db.Unicode(100), index=True, nullable=False) owner_id = db.Column(db.Integer, ForeignKey('GoLabOAuthUsers.id')) height = db.Column(db.Integer) scale = db.Column( db.Integer) # value multiplied by 100; 9850 represents 98.5 identifier = db.Column(db.Unicode(36), index=True, nullable=False, unique=True) creation = db.Column(db.DateTime, index=True, nullable=False) last_update = db.Column(db.DateTime, index=True, nullable=False) description = db.Column(db.UnicodeText, nullable=True) age_ranges_commas = db.Column( db.Unicode(100), nullable=True) # golab format, comma separated domains_json = db.Column(db.Unicode(255), nullable=True) # JSON-encoded domains in a list uses_proxy = db.Column( db.Boolean, nullable=True) # If True, then it should use the https proxy owner = relation("GoLabOAuthUser", backref="embed_apps") def __init__(self, url, name, owner, height=None, identifier=None, creation=None, last_update=None, scale=None, description=None, age_ranges_range=None, domains=None): if creation is None: creation = datetime.datetime.utcnow() if last_update is None: last_update = datetime.datetime.utcnow() if identifier is None: identifier = unicode(uuid.uuid4()) while EmbedApplication.query.filter_by( identifier=identifier).first() is not None: identifier = unicode(uuid.uuid4()) self.url = url self.name = name self.owner = owner self.identifier = identifier self.creation = creation self.last_update = last_update self.height = height self.scale = scale self.description = description self.age_ranges_range = age_ranges_range or "[4, 20]" self.domains = domains or '' @property def full_url(self): """With proxy if needed""" if self.uses_proxy: return url_for('proxy.proxy', url=self.url, _external=True) return self.url @property def domains(self): if not self.domains_json: return [] return json.loads(self.domains_json) or [] @domains.setter def domains(self, domains): self.domains_json = json.dumps(domains or []) @property def domains_text(self): return ', '.join(self.domains) @domains_text.setter def domains_text(self, domains): self.domains = [ domain.strip() for domain in domains.split(',') if domain.strip() ] @property def age_ranges(self): if not self.age_ranges_commas: return [] return self.age_ranges_commas.split(',') @age_ranges.setter def age_ranges(self, age_ranges): self.age_ranges_commas = ','.join(age_ranges or []) @property def age_ranges_range(self): return EmbedApplication.age_ranges2text(self.age_ranges) @staticmethod def age_ranges2text(age_ranges): minimum = 20 maximum = 4 for age_range in age_ranges: if age_range == '<6': minimum = 4 elif age_range == '>18': maximum = 20 else: number_low = int(age_range.split('-')[0]) number_high = int(age_range.split('-')[1]) if number_low < minimum: minimum = number_low if number_high > maximum: maximum = number_high if maximum == 20 and minimum == 20: minimum = 18 if minimum == 4 and maximum == 4: maximum = 6 return "[%s, %s]" % (minimum, maximum) @staticmethod def text2age_ranges(age_ranges_range): # [4, 12] => ['<6', '6-8', '8-10', '10-12'] age_ranges_splitted = age_ranges_range[1:-1].split(',') min_age = int(age_ranges_splitted[0].strip()) max_age = int(age_ranges_splitted[1].strip()) new_age_ranges = [] for x in xrange(min_age, max_age + 2, 2): if x in (4, 6) and '<6' not in new_age_ranges: new_age_ranges.append('<6') elif x == 8: new_age_ranges.append('6-8') elif x == 10: new_age_ranges.append('8-10') elif x == 12: new_age_ranges.append('10-12') elif x == 14: new_age_ranges.append('12-14') elif x == 16: new_age_ranges.append('14-16') elif x == 18: new_age_ranges.append('16-18') elif x == 20: new_age_ranges.append('>18') return new_age_ranges @age_ranges_range.setter def age_ranges_range(self, age_ranges_range): self.age_ranges = EmbedApplication.text2age_ranges(age_ranges_range) def update(self, url=None, name=None, height=None, scale=None, description=None, domains=None, age_ranges_range=None, domains_text=None): if url is not None: self.url = url if name is not None: self.name = name if height is not None: self.height = height if scale is not None: self.scale = scale if description is not None: self.description = description if domains is not None: self.domains = domains if age_ranges_range is not None: self.age_ranges_range = age_ranges_range if self.domains_text is not None: self.domains_text = domains_text self.last_update = datetime.datetime.utcnow()
revision = 'e657e849733' down_revision = '298c12227419' import json from alembic import op import sqlalchemy as sa import sqlalchemy.sql as sql from labmanager.db import db from labmanager.application import app metadata = db.MetaData() rlms = db.Table( 'rlmss', metadata, db.Column('id', db.Integer()), db.Column('name', db.Unicode(50)), db.Column('kind', db.Unicode(50)), db.Column('version', db.Unicode(50)), db.Column('configuration', db.Unicode(10 * 1024)), ) def upgrade(): with app.app_context(): for id, name, kind, version, configuration in db.session.execute( sql.select([ rlms.c.id, rlms.c.name, rlms.c.kind, rlms.c.version, rlms.c.configuration ])): kwargs = {}
class UseLog(db.Model): __tablename__ = 'UseLogs' __table_args__ = (TABLE_KWARGS) id = db.Column(db.Integer, primary_key=True) datetime = db.Column(db.DateTime, index=True, nullable=False) date = db.Column(db.Date, index=True, nullable=False) day_of_week = db.Column(db.Integer, index=True, nullable=False) # 0..6 (datetime.weekday()) hour_of_day = db.Column(db.Integer, index=True, nullable=False) # 0..23 year = db.Column(db.Integer, index=True, nullable=False) # 2017 month = db.Column(db.Integer, index=True, nullable=False) # 1..12 local_timezone = db.Column(db.Integer, index=True, nullable=False) local_datetime = db.Column(db.DateTime, index=True, nullable=False) local_date = db.Column(db.Date, index=True, nullable=False) local_day_of_week = db.Column(db.Integer, index=True, nullable=False) # 0..6 (datetime.weekday()) local_hour_of_day = db.Column(db.Integer, index=True, nullable=False) # 0..23 local_year = db.Column(db.Integer, index=True, nullable=False) # 2017 local_month = db.Column(db.Integer, index=True, nullable=False) # 1..12 url = db.Column(db.Unicode(255), index=True) ip_address = db.Column(db.Unicode(100), index=True) web_browser = db.Column(db.Unicode(255), index=True) browser_platform = db.Column(db.Unicode(100), index=True) browser_name = db.Column(db.Unicode(100), index=True) browser_version = db.Column(db.Unicode(100), index=True) browser_language = db.Column(db.Unicode(100), index=True) first_language = db.Column(db.Unicode(10), index=True) second_language = db.Column(db.Unicode(10), index=True) third_language = db.Column(db.Unicode(10), index=True) all_languages = db.Column(db.Unicode(100), index=True) city = db.Column(db.Unicode(255), index=True) country = db.Column(db.Unicode(255), index=True) hostname = db.Column(db.Unicode(255), index=True) def __init__(self, url, ip_address, web_browser, user_agent, timezone_minutes, lang_header, dtime=None): if dtime is None: dtime = datetime.datetime.utcnow() self.datetime = dtime self.date = dtime.date() self.day_of_week = dtime.weekday() self.hour_of_day = dtime.hour self.year = dtime.year self.month = dtime.month try: timezone_minutes = int(timezone_minutes) except: timezone_minutes = 0 if timezone_minutes > 840 or timezone_minutes < -840: timezone_minutes = 0 self.local_timezone = timezone_minutes local_dtime = dtime - datetime.timedelta(minutes=timezone_minutes) self.local_datetime = local_dtime self.local_date = local_dtime.date() self.local_day_of_week = local_dtime.weekday() self.local_hour_of_day = local_dtime.hour self.local_year = local_dtime.year self.local_month = local_dtime.month self.url = url if self.url: self.url = self.url[:255] if lang_header: self.all_languages = lang_header[:100] langs = [lang.split(';')[0] for lang in lang_header.split(',')] if len(langs) >= 1: self.first_language = langs[0][:10] if len(langs) >= 2: self.second_language = langs[1][:10] if len(langs) >= 3: self.third_language = langs[2][:10] self.ip_address = ip_address self.web_browser = web_browser if self.web_browser: self.web_browser = web_browser[:255] if user_agent: self.browser_platform = user_agent.platform self.browser_name = user_agent.browser self.browser_version = user_agent.version self.browser_language = user_agent.language