class User(Base, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120),
unique=True,
nullable=False,
info={'validators': Email()})
password = db.Column(
db.String(225),
nullable=False,
info={
'validators':
Regexp(regex=r'((?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{6,20})',
message='Invalid Password Format')
})
active = db.Column(db.Boolean())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(20))
current_login_ip = db.Column(db.String(20))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __init__(self, *mixed, **kwargs):
super(User, self).__init__(*mixed, **kwargs)
with app.app_context():
self.password = hash_password(kwargs['password'])
def __repr__(self):
return '<User %r>' % self.email
class User(db.Model):
id = db.Column('uid', db.Integer, primary_key=True)
name = db.Column('name', db.String(100))
# TODO unique
email = db.Column('email', db.String(100), unique=True)
# TODO add passwords
def __init__(self, name, email):
self.name = name
self.email = email
@staticmethod
def is_valid_email(email):
# TODO can be improved by making it a single sql query
done = db.session.query(User.email).filter(User.email==email).scalar()
print(email, done)
exists = done is not None
return exists
@staticmethod
def check_valid_emails(emails):
valid = []
for email in emails:
valid.append(User.is_valid_email(email))
return valid
@staticmethod
def get_similar_users(search):
results = User.query.filter(User.email.like(search) | User.name.like(search)).all()
return results
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True)
password_hash = db.Column(db.String(64))
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, password):
return pwd_context.verify(password, self.password_hash)
def generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.query.get(data['id'])
return user
class Log(db.Model):
__tablename__ = 'logs'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
action = db.Column(db.String())
value = db.Column(db.String())
attendee_id = db.Column(db.Integer, db.ForeignKey("attendees.id"))
attendee = db.relationship("Attendee")
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
class Mall(db.Model):
id = db.Column(db.Integer, primary_key=True)
Name = db.Column(db.String(100), unique=True)
City = db.Column(db.String(100))
District = db.Column(db.String(100))
def __repr__(self):
return f'< {self.Name} >'
class Album(db.Model):
__tablename__ = "album"
album_id = db.Column(db.Integer, primary_key=True)
artist = db.Column(db.String(64))
title = db.Column(db.String(128))
image_url = db.Column(db.String(255))
last_edited_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
class Attendee(db.Model):
__tablename__ = 'attendees'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
checkin_status = db.Column(db.Integer, default=0)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
scan_value = db.Column(db.String(60), nullable=True)
scan_value_others = db.Column(db.Text, nullable=True)
name = db.Column(db.String(40))
email = db.Column(db.String(60))
school = db.Column(db.String(100))
# Tags are separated by `;`
tags = db.Column(db.Text, default=";")
notes = db.Column(db.Text, default="")
# 0 for participant, 10 for mentor, 11 for sponsor
type = db.Column(db.Integer, default=0)
event_id = db.Column(db.Integer, db.ForeignKey('events.id'))
event = db.relationship("Event", back_populates="attendees")
logs = db.relationship("Log", back_populates="attendee")
def __init__(self,
event,
name,
scan_value,
email,
school,
tags=";",
checkin_status=0,
notes="",
type=0,
scan_value_others=";"):
self.name = name
self.scan_value = scan_value
self.email = email
self.school = school
self.type = type
self.event = event
self.tags = tags
self.checkin_status = checkin_status
self.notes = notes
self.scan_value_others = scan_value_others
def as_dict(self):
return {
c.name: str(getattr(self, c.name))
if getattr(self, c.name) is not None else None
for c in self.__table__.columns
}
class Role(Base, RoleMixin):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False, unique=True)
description = db.Column(db.String(255))
def __init__(self, name, desc):
self.name = name
self.description = desc
def __repr__(self):
return '<Role %r -- %r>' % (self.name, self.description)
class Author(db.Model):
__tablename__ = 'authors'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
direction = db.Column(db.String(255))
date_of_birth = db.Column(db.String(255))
books = db.relationship('Book', backref='author')
def __repr__(self):
return self.name
class PublishHouse(db.Model):
__tablename__ = 'publish_houses'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
address = db.Column(db.String(255))
phone_num = db.Column(db.String(20))
website = db.Column(db.String(255))
books = db.relationship('Book', backref='publish_house')
def __repr__(self):
return self.name
class Movie(BaseModel, db.Model):
"""Model for movies table"""
__tablename__ = "movies"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
uuid = db.Column(db.String(128), nullable=True)
name = db.Column(db.String(128), nullable=False)
source = db.Column(db.String(128), nullable=False)
uri = db.Column(db.String(128), nullable=False)
width = db.Column(db.Integer, nullable=True)
height = db.Column(db.Integer, nullable=True)
numberOfFrames = db.Column(db.Integer, nullable=True)
fps = db.Column(db.Float(), default=0.0, nullable=True)
stripeStatus = db.Column(db.Float(), default=0.0, nullable=True)
cutStatus = db.Column(db.Float(), default=0.0, nullable=True)
docStatus = db.Column(db.Float(), default=0.0, nullable=True)
hasStripeImage = db.Column(db.Boolean(), default=False, nullable=False)
numberOfStripes = db.Column(db.Integer(), default=0, nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
tags = db.relationship('Tag', backref='movies', lazy=True)
def __init__(self,
uuid,
name,
source,
uri,
active,
width,
height,
numberOfFrames,
fps,
stripeStatus=0.0,
cutStatus=0.0,
docStatus=0.0,
numberOfStripes=0,
tags=[]):
super().__init__()
self.uuid = uuid
self.name = name
self.source = source
self.uri = uri
self.active = active
self.width = width
self.height = height
self.numberOfFrames = numberOfFrames
self.fps = fps
self.stripeStatus = stripeStatus
self.cutStatus = cutStatus
self.docStatus = docStatus
self.numberOfStripes = numberOfStripes
self.tags = tags
class Book(db.Model):
__tablename__ = 'books'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey('authors.id'), nullable=False)
genre_id = db.Column(db.Integer, db.ForeignKey('genres.id'))
year_of_writing = db.Column(db.String(255))
pages = db.Column(db.String(255))
publish_house_id = db.Column(db.Integer, db.ForeignKey('publish_houses.id'))
def __repr__(self):
return self.title
class ContactForm(db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=False)
name = db.Column(db.String(120))
message = db.column(db.String(5000))
def __init__(self, email, name, message):
self.email = email
self.name = name
self.message = message
def __repr__(self):
return f'{self.name}\n{self.email}\n{self.message}'
class Shop(db.Model):
id = db.Column(db.Integer, primary_key=True)
Type = db.Column(db.String(140))
Name = db.Column(db.String(140), unique=True)
malls = db.relationship('Mall',
secondary=shops_malls,
backref=db.backref(
'shops',
lazy='dynamic',
))
def __repr__(self):
return f'< {self.Name} >'
class UserModel(BaseModel):
__modelname__ = "User"
__tablename__ = "users"
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255))
username = db.Column(db.String(100), nullable=False, unique=True)
password_hash = db.Column(db.String(150), nullable=False)
role_id = db.Column(db.Integer, db.ForeignKey("roles.id"))
@classmethod
def get_username(cls, username):
return cls.query.filter_by(username=username).first()
@property
def fullname(self):
return f"{self.first_name} {self.last_name}"
def can(self, permission):
return self.role is not None and \
(self.role.permission and permission) == True
def is_admin(self):
return self.can(Permission.ADMINISTRATOR)
@property
def password(self):
raise AttributeError('`password` is not a readable attribute')
@password.setter
def password(self, password):
self.password_hash = generate_password_hash(password)
def verify_password(self, password):
return check_password_hash(self.password_hash, password)
# {
# "sub": 1 #userid,
# "role": "User",
# "groups": ["corecommerce:lead", "travel:member"],
# "iat": "23/12/1995",
# "exp": "29/30/1998"
# }
# @jwt_required
# @jwt_role("Administrator")
# @jwt_any_roles(["User", "Administrator"])
class RoleModel(db.Model):
__tablename__ = "roles"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50))
permission = db.Column(db.Integer, default=Permission.GENERAL)
users = db.relationship("UserModel", backref="role", lazy=True)
def __repr__(self):
return '<Role \'%s\'>' % self.name
@classmethod
def get_default(cls):
return cls.query.filter_by(permission=Permission.GENERAL).first()
@staticmethod
def insert():
roles = {
"User": [Permission.GENERAL],
"Administrator": [Permission.ADMINISTRATOR]
}
for r in roles:
role = RoleModel.query.filter_by(name=r).first()
if not role:
role = RoleModel(name=r)
role.permission = roles[r][0]
db.session.add(role)
db.session.commit()
class Ticket(db.Model):
__tablename__ = 'tickets'
id = db.Column(db.Integer,
primary_key=True,
unique=True,
autoincrement=True)
email = db.Column(db.String(), primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user = db.relationship("User")
submitted_at = db.Column(db.DateTime, default=datetime.datetime.now)
code = db.Column(db.Text, unique=True)
notes = db.Column(db.Text, default="")
def __init__(self, email, notes, user, ticketNumber=""):
self.email = email
self.notes = notes
self.user = user
self.generateCode()
def generateCode(self):
self.code = secrets.token_hex(16)
def json(self):
return {
"email": self.email,
"code": self.code,
"id": self.id,
"user": self.user.description,
"notes": self.notes
}
class BlacklistedTokenModel(db.Model):
__tablename__ = "blacklisted_tokens"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
token = db.Column(db.String(255), unique=True, nullable=False)
blackisted_at = db.Column(db.DateTime, nullable=False)
def __repr__(self):
return (f"<{self.__class__.__name__}(token={self.token})>")
@classmethod
def get(cls, token):
return cls.query.filter_by(token=token).first()
def save(self):
self.blackisted_at = current_datetime()
db.session.add(self)
db.session.commit()
@staticmethod
def check(token):
result = BlacklistedTokenModel.get(token)
if result:
return True
return False
class User(db.Model):
""" This will be the User class and will hold information regarding user accounts. """
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120),
unique=True) # will not allow the same username twice
user_email = db.Column(
db.String(120), unique=True
) # will not allow a user to register twice with the same email address
pwd_hash = db.Column(db.String(300))
def __init__(self, username, user_email, password):
self.username = username
self.user_email = user_email
self.pwd_hash = make_pw_hash(password)
def __repr__(self):
return f'{self.username}'
class Genre(db.Model):
__tablename__ = 'genres'
id = db.Column(db.Integer, primary_key=True)
genre = db.Column(db.String(255), nullable=False)
books = db.relationship('Book', backref='genre')
def __repr__(self):
return self.genre
class User(BaseModel, db.Model):
"""Model for users table"""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), nullable=False)
password = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean(), default=True, nullable=False)
# using func.now(), so time is calculated by the DB server and not by server server.
# https://stackoverflow.com/questions/13370317/sqlalchemy-default-datetime?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
created_date = db.Column(db.DateTime, nullable=False, default=func.now())
def __init__(self, username, email, password):
super().__init__()
self.username = username
self.email = email
self.password = password
class Genre(db.Model):
__tablename__ = 'genres'
id = db.Column(db.Integer, primary_key=True)
genre = db.Column(db.String(255), nullable=False, unique=True)
books = db.relationship('Book', backref='genre')
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __repr__(self):
return self.genre
class GroupModel(db.Model):
__modelname__ = "Group"
__tablename__ = "groups"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50))
@property
def leader(self):
return GroupModel.query.filter(
GroupModel.members.has(is_lead=True)).first()
class ContentElement(BaseModel, db.Model):
"""Model for content elements table"""
__tablename__ = "contentelement"
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
uuid = db.Column(db.String(128), nullable=True)
documentID = db.Column(db.Integer,
db.ForeignKey('document.id'),
nullable=True)
contentType = db.Column(db.String(16), nullable=True)
content = db.Column(db.String(), nullable=True)
def __init__(self, uuid, documentID, contentType, content):
super().__init__()
self.uuid = uuid
self.documentID = documentID
self.contentType = contentType
self.content = content
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), nullable=False, unique=True)
password_hash = db.Column(db.String(255), nullable=True)
created_on = db.Column(db.DateTime(), default=datetime.utcnow)
books = db.relationship('Book', backref='creator')
authors = db.relationship('Author', backref='creator')
genres = db.relationship('Genre', backref='creator')
publishers = db.relationship('PublishHouse', backref='creator')
def __init__(self, email, password=None):
self.email = email
if password is not None:
self.set_password(password)
else:
self.password_hash = None
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
@classmethod
def authenticate(cls, **kwargs):
email = kwargs.get('email')
password = kwargs.get('password')
if not email or not password:
return None
user = cls.query.filter_by(email=email).first()
if not user or not check_password_hash(user.password_hash, password):
return None
return user
class RevokedTokenModel(db.Model):
__tablename__ = 'revoked_tokens'
id = db.Column(db.Integer, primary_key=True)
jTokenId = db.Column(db.String(120))
def add(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jTokenId):
query = cls.query.filter_by(jTokenId=jTokenId).first()
return bool(query)
class Tag (BaseModel, db.Model):
"""Model for movies table"""
__tablename__ = "frametag"
id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False)
movieID = db.Column(db.Integer, db.ForeignKey('movies.id'), nullable=True)
fn = db.Column(db.Integer, nullable=True)
tag = db.Column(db.String(16), nullable=True)
def __init__(self, movieID, fn, tag):
super().__init__()
self.movieID = movieID
self.fn = fn
self.tag = tag
class Timezones(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(64), nullable=False)
t_offset = db.Column(db.Integer, nullable=False)
def __init__(self, id, name, offset):
self.id = id
self.name = name
self.t_offset = offset
def to_dict(self):
return dict(id=self.id,
timezone_name=self.name,
timezone_offset=self.t_offset)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(20), unique=True, nullable=False)
password = db.Column(db.String(), nullable=False)
name = db.Column(db.String(40))
is_admin = db.Column(db.Boolean(), default=False)
events = db.relationship("Event", secondary=eventUsers, lazy='dynamic')
def __init__(self, username, password, name, is_admin):
self.username = username
self.password = hash_password(password)
self.name = name
self.is_admin = is_admin
def as_dict(self):
return {
'name': self.name,
'id': self.id,
'is_admin': self.is_admin,
'events': [event.id for event in self.events]
}
class Client(db.Model):
__tablename__ = 'clients'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
user = db.relationship("User")
token = db.Column(db.String(), primary_key=True, unique=True)
token_expired_at = db.Column(
db.DateTime,
default=lambda _:
(datetime.datetime.now() + datetime.timedelta(days=5)))
token_created_at = db.Column(db.DateTime, default=datetime.datetime.now)
def __init__(self, user, token):
self.user = user
self.token = token
