class Class(db.Model):
__tablename__ = "class"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(50))
desc = db.Column(db.String(200))
users = db.relationship("Access", backref="class", lazy="dynamic")
students = db.relationship("Class_Student",
backref="class",
lazy="dynamic")
def __repr__(self):
return "<Class: {}>".format(self.title)
class Item(db.Model):
__tablename__ = "items"
id = db.Column(db.Integer, nullable=False)
site = db.Column(db.String(length=16), nullable=False)
price = db.Column(db.Float)
start_time = db.Column(db.DateTime)
name = db.Column(db.String(length=128))
description = db.Column(db.String(length=64))
nickname = db.Column(db.String(length=50))
__table_args__ = (db.PrimaryKeyConstraint('site', 'id'), {})
@classmethod
def create_item(cls, site, id, db_session=None):
item = Item(site=site, id=id)
if db_session:
db_session.add(item)
else:
db.session.add(item)
if db_session:
db_session.commit()
else:
db.session.commit()
return item
@classmethod
def get_or_create_item(cls, site, id, db_session=None):
item = cls.get_item(site, id)
if not item:
item = cls.create_item(site, id, db_session)
return item
@classmethod
def get_item(cls, site, id):
item = cls.query.filter(cls.site == site).filter(cls.id == id)
return item.first()
def __str__(self):
return "{"\
f"'id':'{self.id}'"\
f", 'site':'{self.site}'"\
f", 'price':'{self.price}'"\
f", 'name':'{self.name}'"\
f", 'description':'{self.description}'"\
f", 'nickname':'{self.nickname}'"\
"}"
class User(UserMixin, CRUDMixin, db.Model):
__tablename__ = 'users_user'
name = db.Column(db.String(50))
email = db.Column(db.String(120), unique=True)
_password = db.Column(db.LargeBinary(120))
_salt = db.Column(db.String(120))
sites = db.relationship('Site', backref='owner', lazy='dynamic')
@hybrid_property
def password(self):
return self._password
# In order to ensure that passwords are always stored
# hashed and salted in our database we use a descriptor
# here which will automatically hash our password
# when we provide it (i. e. user.password = "******")
@password.setter
def password(self, value):
# When a user is first created, give them a salt
if self._salt is None:
self._salt = bytes(SystemRandom().getrandbits(128))
self._password = self._hash_password(value)
def is_valid_password(self, password):
"""Ensure that the provided password is valid.
We are using this instead of a ``sqlalchemy.types.TypeDecorator``
(which would let us write ``User.password == password`` and have the incoming
``password`` be automatically hashed in a SQLAlchemy query)
because ``compare_digest`` properly compares **all***
the characters of the hash even when they do not match in order to
avoid timing oracle side-channel attacks."""
new_hash = self._hash_password(password)
return compare_digest(new_hash, self._password)
def _hash_password(self, password):
pwd = password.encode("utf-8")
salt = bytes(self._salt)
rounds = current_app.config.get("HASH_ROUNDS", 100000)
buff = pbkdf2_hmac("sha512", pwd, salt, iterations=rounds)
return bytes(buff)
def __repr__(self):
return "<User #{:d}>".format(self.id)
class User(db.Model, UserMixin):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), nullable=True)
password_hash = db.Column(db.String(128))
logins = db.Column(db.Integer, default=0)
classes = db.relationship("Access", backref="user", lazy="dynamic")
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
"""Runs the passwords through a hash and appends."""
self.password_hash = generate_password_hash(str(password))
def check_password(self, password):
"""Checks a password against the hash."""
return check_password_hash(self.password_hash, password)
class Photo(Base,CRUDMixin):
__tablename__='photo'
uuid = db.Column(db.String(128), nullable=False)
filepath = db.Column(db.String(500), nullable=False)
analysed = db.Column(db.Boolean,default=False)
info = db.Column(db.String(1000),nullable=False)
def __init__(self,uuid,filepath,analysed=False,info=""):
self.uuid = uuid
self.filepath = filepath
self.analysed=analysed
self.info=info
def get_id(self):
return self.id
def serialize(self):
return {'uuid':self.uuid}
def serialize_all(self):
return {'uuid':self.uuid, 'filepath': self.filepath, 'analysed': self.analysed, 'info': self.info}
def __repr__(self):
return '<photo uuid=%r filepath=%r>' % (self.uuid,self.filepath)
class Student(db.Model):
__tablename__ = "student"
id = db.Column(db.Integer, primary_key=True)
student_id = db.Column(db.Integer)
student_name = db.Column(db.String(50))
rfid = db.Column(db.Integer)
roll = db.relationship("Roll_Student", backref="student", lazy="dynamic")
def __repr__(self):
return "<Student, id: {}, name: {}, dbId: {}>".format(
self.student_id,
self.student_name,
self.id,
)
class Station(db.Model):
__tablename__ = "station"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
password_hash = db.Column(db.String(128))
linked_roll = db.Column(db.Integer, db.ForeignKey('roll.id'))
linked_roll_rel = db.relationship("Roll", back_populates="linked_rfid")
scan = db.Column(db.Integer)
active = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<Station {}>'.format(self.name)
def set_password(self, password):
"""Runs the passwords through a hash and appends."""
self.password_hash = generate_password_hash(str(password))
def check_password(self, password):
"""Checks a password against the hash."""
return check_password_hash(self.password_hash, password)
def get_scan(self):
return self.scan if not self.active else None