class LanguagesKnown(db.Model):
__tablename__ = 'languages_known'
id = db.Column(db.Integer, primary_key=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
language_id = db.Column(db.Integer,
db.ForeignKey('languages.id'),
nullable=False)
# Relationships
user = db.relationship('Users', backref='languages_known')
language = db.relationship('Languages', backref='languages_known')
def __init__(self, **kwargs):
self.id = kwargs.get('id')
self.user_id = kwargs.get('user_id')
self.language_id = kwargs.get('language_id')
def __repr__(self):
return '<LanguagesKnown -> id: {}, user_id: {}, language_id: {}'.format(
self.id, self.user_id, self.language_id)
def to_dict(self):
return dict(id=self.id,
user_id=self.user_id,
language_id=self.language_id)
class GroupMemberModel(db.Model):
__modelname__ = "Group Member"
__tablename__ = "group_members"
group_id = db.Column(db.Integer,
db.ForeignKey("groups.id"),
primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey("users.id"),
primary_key=True)
is_lead = db.Column(db.Boolean, default=False, nullable=False)
permission = db.Column(db.Integer, default=Permission.READ, nullable=False)
group = db.relationship("GroupModel",
backref=db.backref(
"members", cascade="delete, delete-orphan"))
user = db.relationship("UserModel",
backref=db.backref("groups_membership",
cascade="delete, delete-orphan"))
@db.validates('is_lead')
def validate_leader(self, key, is_lead):
# We can only have one leader in a group
if self.team.leader():
raise ValueError(f"{self.group.name} group already have a leader")
return is_lead
@property
def user_role(self):
return f"{self.group.name}:{'leader' if self.is_lead else 'member'}"
class Participants(db.Model):
__tablename__ = "participants"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.ForeignKey(User.id))
schedule_id = db.Column(db.ForeignKey(Schedule.schedule_id))
schedule = db.relationship('Schedule',
foreign_keys='Participants.schedule_id')
participant = db.relationship('User', foreign_keys='Participants.user_id')
def __init__(self, schedule_id, user_id):
self.schedule_id = schedule_id
self.user_id = user_id
def commit(self):
db.session.add(self)
db.session.commit()
@staticmethod
def clash(startTime, endTime, givenStartTime, givenEndTime):
if startTime <= givenStartTime:
return endTime >= givenStartTime
else:
return startTime <= givenEndTime
@staticmethod
def is_available(email, start_time, end_time, curr_schedule_id=None):
""""""
user_id = db.session.query(
User.id).filter(User.email == email).scalar()
print("User ID:", user_id)
schedules = db.session.query(Participants.schedule_id).filter(
Participants.user_id == user_id).all()
print("Schedules:", list(schedules))
clashing = False
if schedules is not None:
for schedule_id in schedules:
if curr_schedule_id is not None and schedule_id[
0] != curr_schedule_id:
schedule = db.session.query(Schedule).filter(
Schedule.schedule_id == schedule_id[0]).scalar()
if schedule is not None:
print('if schedule not none', schedule.start_time,
schedule.end_time)
clashing = clashing or Participants.clash(schedule.start_time, schedule.end_time,\
start_time, end_time)
print(clashing)
return (not clashing), user_id
@staticmethod
def delete_schedule_participants(schedule_id):
db.session.query(Participants).filter(
Participants.schedule_id == schedule_id).delete()
db.session.commit()
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 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 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 Availabilities(db.Model):
__tablename__ = 'availabilities'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
day_of_week = db.Column(db.Integer, nullable=False)
from_time = db.Column(db.Integer, nullable=False)
to_time = db.Column(db.Integer, nullable=False)
# Relationships
user = db.relationship('Users', backref='availabilities')
def __init__(self, user_id, day_of_week, from_time, to_time):
self.user_id = user_id
self.day_of_week = day_of_week
self.from_time = from_time
self.to_time = to_time
def __repr__(self):
return '<Availabilities -> id: {}, user_id: {}, day_of_week: {}, from_time: {}, to_time: {}'.format(
self.id, self.user_id, self.day_of_week, self.from_time,
self.to_time)
def to_dict(self):
return dict(id=self.id,
user_id=self.user_id,
day_of_week=self.day_of_week,
from_time=self.from_time,
to_time=self.to_time)
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 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 JobGroup(db.Model, CRUDMixin):
"""
Группа задач
"""
__tablename__ = 'job_groups'
id = db.Column(db.Integer, primary_key=True)
jobs = db.relationship('Job', backref='group', lazy='dynamic')
def __repr__(self) -> str:
return f'JobGroup {self.id}'
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 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 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 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 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 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 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
class RecordTypeModel(db.Model):
__modelname__ = "DNS Record Type"
__tablename__ = "dns_record_types"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False, unique=True)
value = db.Column(db.Integer)
records = db.relationship("RecordModel", backref="rtype", lazy="dynamic")
def __repr__(self):
return (f"<{self.__class__.__name__}"
f"(id={self.id})>"
f"(name={self.name})>"
f"(value={self.value})"
f">")
@db.validates("name")
def validate_name(self, key, name):
name = name.upper()
return name
@staticmethod
def seeding():
RTYPE_AVAILABLES = {
"A": dns.rdatatype.A,
"CNAME": dns.rdatatype.CNAME,
"PTR": dns.rdatatype.PTR,
"MX": dns.rdatatype.MX,
"TXT": dns.rdatatype.TXT,
"SRV": dns.rdatatype.SRV
}
for rtype in RTYPE_AVAILABLES:
record_type = RecordTypeModel.query.filter_by(name=rtype).first()
if not record_type:
record_type = RecordTypeModel(name=rtype)
record_type.value = RTYPE_AVAILABLES[rtype]
db.session.add(record_type)
db.session.commit()
@classmethod
def get(cls, rtype):
return cls.query.filter_by(name=rtype).first()
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 Event(db.Model):
__tablename__ = 'events'
# many-to-many relationship with User
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(140), nullable=False)
time = db.Column(db.DateTime, nullable=False) # TODO
updated_at = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
attendees = db.relationship("Attendee", back_populates='event')
def __init__(self, name, datestring):
self.name = name
self.time = parser.parse(datestring)
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
}
