class Submit(db.Model):
__tablename__ = 'submits'
id = db.Column(db.Integer, primary_key=True)
status = db.Column(db.String(16), nullable=False)
code = db.Column(db.String(100 * 1024), nullable=False)
language = db.Column(db.String(16), nullable=False)
submitted_on = db.Column(db.DateTime, nullable=False)
fk_user = db.Column(db.Integer,
db.ForeignKey('users.id'),
index=True,
nullable=False)
user = db.relationship('User', foreign_keys='Submit.fk_user')
fk_team = db.Column(db.Integer,
db.ForeignKey('teams.id'),
index=True,
nullable=False)
team = db.relationship('Team', foreign_keys='Submit.fk_team')
fk_problem = db.Column(db.Integer,
db.ForeignKey('problems.id'),
index=True,
nullable=False)
problem = db.relationship('Problem', foreign_keys='Submit.fk_problem')
class Contest(db.Model):
__tablename__ = 'contests'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, nullable=False)
rate = db.Column(db.SMALLINT)
open_to_public = db.Column(db.Boolean, nullable=False)
password = db.Column(db.String(128))
create_dt = db.Column(db.DateTime, nullable=False)
start_dt = db.Column(db.DateTime, nullable=False)
close_dt = db.Column(db.DateTime)
duration = db.Column(db.Time, nullable=False)
fk_owner = db.Column(db.Integer, db.ForeignKey('users.id'), index=True, nullable=False)
owner = db.relationship('User', foreign_keys='Contest.fk_owner')
def hash_password(self, password):
password = password.encode('utf-8')
self.password = pwd_context.encrypt(password)
def verify_password(self, password):
password = password.encode('utf-8')
return pwd_context.verify(password, self.password)
class User(db.Model):
__tablename__ = 'users'
# noinspection PyTypeChecker
ROLE = IntEnum('Role', {
'staff': 0,
'superuser': 1,
})
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(30), unique=True, nullable=False)
password = db.Column(db.String(100), nullable=False)
name = db.Column(db.String(30))
surname = db.Column(db.String(30))
email = db.Column(db.String(320), nullable=False, unique=True)
role = db.Column(TypeEnum(ROLE), nullable=False, default=ROLE.staff)
bl = Resource('bl.user')
def __repr__(self):
return '{} ({})'.format(self.login, self.get_full_name())
def get_full_name(self):
return '{} {}'.format(self.name or '', self.surname or '').strip()
def is_superuser(self):
return self.role == self.ROLE.superuser
class Device(db.Model):
__tablename__ = "devices"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
device_id = db.Column(db.String(128), unique=True, nullable=False)
device_type = db.Column(db.String(128), nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
pn_token = db.Column(db.String(256), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', backref=db.backref('devices', lazy='joined'))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow, onupdate=datetime.utcnow)
def __init__(self, device_id: str, device_type: str, pn_token: str=None, active: bool=True, user=None, created_at: datetime=datetime.utcnow()):
self.device_id = device_id
self.device_type = device_type # "apple" "android"
self.pn_token = pn_token
self.active = active
self.user = user
self.created_at = created_at
self.updated_at = created_at
# noinspection PyPep8
@staticmethod
def query_active_devices_for_user(user: User):
return Device.query.filter(Device.user_id == user.id, Device.active == True, Device.pn_token.isnot(None))
# noinspection PyPep8
@staticmethod
def query_active_devices_for_group(group: Group, discard_user_ids:List[int]=None):
discard_user_ids = discard_user_ids or []
user_ids = [user.user_id for user in group.associated_users if user.user_id not in discard_user_ids]
return Device.query.filter(Device.user_id.in_(tuple(user_ids)), Device.active == True,
Device.pn_token.isnot(None))
@staticmethod
def create_or_update(device_id, device_type: str, user:User=None, active: bool = True, pn_token: str=None):
device = Device.first_by(device_id=device_id)
if not device:
device = Device(device_id=device_id, device_type=device_type, user=user, active=active, pn_token=pn_token)
db.session.add(device)
else:
device.device_type = device_type
device.active = active
if user:
device.user = user
if pn_token:
device.pn_token = pn_token
return device
@staticmethod
def first_by(**kwargs):
"""Get first db device that match to device_id"""
return Device.query.filter_by(**kwargs).first()
@staticmethod
def first(*criterion):
"""Get first db entity that match to criterium"""
return Device.query.filter(*criterion)
class EventDescriptor(db.Model):
__tablename__ = "event_descriptors"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False)
description = db.Column(db.String(128), nullable=False)
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
def __init__(self, id: int, name: str, description: str):
self.id = id
self.name = name
self.description = description
class User(db.Model, UserMixin):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
# Authentication
# 128 characters is a sensible default for the max length of full names
full_name = db.Column(db.String(128))
# What should we call you? (for example, when we send you email?)
preferred_name = db.Column(db.String(128))
# 254 characters is the maximum length of an email address
email = db.Column(db.String(254), unique=True, nullable=False)
email_confirmed = db.Column(db.Boolean, default=False, nullable=False)
password = db.Column(db.String(128), nullable=False)
role = db.Column(db.String(128))
# Activity tracking
created_at = db.Column(db.DateTime, nullable=False,
default=dt.datetime.utcnow)
def __init__(self, **kwargs):
# Call Flask-SQLAlchemy's constructor
super(User, self).__init__(**kwargs)
# Custom setup
self.password = User.encrypt_password(kwargs['password'])
@classmethod
def encrypt_password(cls, password):
return bcrypt.generate_password_hash(password).decode('UTF-8')
@classmethod
def authenticate(cls, email, password):
found_user = cls.query.filter_by(email=email).first()
if found_user:
authenticated_user = bcrypt.check_password_hash(
found_user.password, password)
if authenticated_user:
# Return the user in the event we want to store information in the session
return found_user
return False
def __repr__(self):
return f"{self.name}"
class Example(db.Model):
__tablename__ = "examples"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), nullable=False)
good = db.Column(db.Boolean(), default=True, server_default="TRUE")
def __repr__(self):
return f"<Example({self.name})>"
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key = True)
username = db.Column(db.String(64), index= True,unique=True)
email = db.Column(db.String(64), unique = True, index=True)
password = db.Column(db.String(128), nullable=False, server_default='')
ct = db.Column(db.DateTime())
latest_online = db.Column(db.DateTime())
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
role = db.relationship('Role', back_populates= 'users')
# active = db.Column('is_active', db.Boolean(), nullable=False,
# server_default='1')
sign_in_count = db.Column(db.Integer, nullable=False, default=0) #如果ip不一样，那么这里加1
last_login_time = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(128))
current_login_time = db.Column(db.DateTime())
current_login_ip = db.Column(db.String(128))
@classmethod
def encryptpassword(cls, password, salt='$!@>HUI&DWQa`'):
import hashlib
def sha256(ascii_str):
return hashlib.sha256(ascii_str.encode('ascii')).hexdigest()
hash1 = sha256(password)
hash2 = sha256(hash1 + salt)
return hash2
def passwordmatch(self, password=''):
return self.password == User.encryptpassword(password)
@classmethod
def find_by_identity(cls, identity):
return User.query.filter(or_(User.username == identity, User.email == identity)).first()
def save(self):
db.session.add(self)
db.session.commit()
return None
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
# User Authentication fields
username = db.Column(db.String(50), nullable=True,
unique=True) # changed nullable to True
password = db.Column(db.String(255), nullable=False)
# User fields
active = db.Column(db.Boolean())
# changed nullable to True
first_name = db.Column(db.String(50), nullable=True)
# changed nullable to True
last_name = db.Column(db.String(50), nullable=True)
# Relationship
user_emails = db.relationship('UserEmail')
roles = db.relationship('Role', secondary='user_roles')
class City(db.Model):
__tablename__ = 'cities'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), nullable=False, unique=True)
bl = Resource('bl.city')
def __str__(self):
return self.name
def __repr__(self):
return "[{}] {}".format(self.__class__.__name__, self.name)
class UserEmail(db.Model):
__tablename__ = 'user_emails'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', uselist=False)
# User email information
email = db.Column(db.String(255), nullable=False, unique=True)
email_confirmed_at = db.Column(db.DateTime())
is_primary = db.Column(db.Boolean(), nullable=False, server_default='0')
class Recipe(db.Model):
__tablename__ = "recipes"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
description = db.Column(db.String(512))
created_on = db.Column(db.DateTime(),
nullable=False,
default=datetime.utcnow)
updated_on = db.Column(db.DateTime(),
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
@property
def json(self):
return {
"id": self.id,
"name": self.name,
"description": self.description
}
class Team(db.Model):
__tablename__ = 'teams'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, nullable=False)
fk_owner = db.Column(db.Integer,
db.ForeignKey('users.id'),
index=True,
nullable=False)
owner = db.relationship('User', foreign_keys='Team.fk_owner')
def to_json(self):
return dict(id=self.id, name=self.name, owner=self.owner.to_json())
class Pubs(db.Model, TimestampMixin):
__tablename__ = "pubs"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False, unique=True)
author = db.Column(db.String(128), db.ForeignKey('users.username'))
text = db.Column(db.Text(), nullable=False)
def __init__(self, name: str, text: str, author: str):
self.name = name
self.text = text
self.author = author
def to_json(self):
return {
'id': self.id,
'name': self.name,
'author': self.author,
'text': self.text
}
class Vacancy(db.Model):
__tablename__ = 'vacancies'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
short_description = db.Column(db.String(300), nullable=False)
text = db.Column(db.Text(), nullable=False)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
category = db.relationship('Category', backref=db.backref('vacancies'))
name_in_url = db.Column(db.String(50), nullable=False, unique=True)
visits = db.Column(db.Integer, nullable=False, default=0)
salary = db.Column(db.String(50))
description = db.Column(db.String(200)) # for search spider
keywords = db.Column(db.String(1000))
city_id = db.Column(db.Integer, db.ForeignKey('cities.id'))
city = db.relationship('City', backref=db.backref('vacancies'))
is_hidden = db.Column(db.Boolean, nullable=False, default=False)
is_deleted = db.Column(db.Boolean, nullable=False, default=False)
updated_at = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
who_updated = db.relationship('User')
condition_is_hidden = ConditionHidden()
condition_is_deleted = ConditionDeleted()
bl = Resource("bl.vacancy")
def __repr__(self):
return "[{}] {}".format(self.__class__.__name__, self.title)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), unique=True, nullable=False)
email = db.Column(db.String(32), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
firstname = db.Column(db.String(32), nullable=False, default='')
lastname = db.Column(db.String(32), nullable=False, default='')
def hash_password(self, password):
password = password.encode('utf-8')
self.password = pwd_context.encrypt(password)
def verify_password(self, password):
password = password.encode('utf-8')
return pwd_context.verify(password, self.password)
def to_json(self):
return dict(id=self.id,
username=self.username,
email=self.email,
firstname=self.firstname,
lastname=self.lastname)
class Recipe(db.Model):
__tablename__ = 'receitas'
ID = db.Column(db.Integer, primary_key=True, nullable=False)
titulo = db.Column(db.String(200), nullable=False)
ingredientes = db.Column(db.Text, nullable=False)
modo_preparo = db.Column(db.Text, nullable=False)
latest_change_date = db.Column(db.DateTime, nullable=False)
texto = db.Column(db.Text, nullable=True)
tempo_preparo = db.Column(db.String(200), nullable=True)
imagem = db.Column(db.Text, nullable=True)
autor = db.Column(db.Integer, db.ForeignKey('users.ID'), nullable=False)
reviews = db.Column(db.Integer, nullable=False)
stars = db.Column(db.Integer, nullable=False)
def get_id(self):
return self.ID
def as_dict(self):
return {
c.name: getattr(self, c.name)
for c in self.__table__.columns
if type(getattr(self, c.name)) is not datetime.datetime
}
class Files(db.Model,TimestampMixin):
__tablename__ = "files"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False, unique=True)
extension = db.Column(db.String(10))
data = db.Column(db.LargeBinary)
def __init__(self,
name: str,
extension: str,
data: bytes):
self.name = name
self.extension = extension
self.data = data
def to_json(self):
return {
'id': self.id,
'name': self.name,
'extension': self.extension,
}
class Event(db.Model):
__tablename__ = "events"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
event_descriptor_id = db.Column(db.Integer,
db.ForeignKey('event_descriptors.id'),
nullable=False)
event_descriptor = db.relationship('EventDescriptor',
backref=db.backref('events',
lazy='joined'))
entity_type = db.Column(db.String(128))
entity_id = db.Column(db.Integer)
entity_description = db.Column(db.String(128))
entity_2_type = db.Column(db.String(128))
entity_2_id = db.Column(db.Integer)
entity_2_description = db.Column(db.String(128))
entity_3_type = db.Column(db.String(128))
entity_3_id = db.Column(db.Integer)
entity_3_description = db.Column(db.String(128))
expiration_date = db.Column(db.DateTime)
group_id = db.Column(db.Integer, db.ForeignKey('groups.id'))
group = db.relationship('Group',
backref=db.backref('events', lazy='joined'))
is_processed = db.Column(db.Boolean, default=False, nullable=False)
creator_id = db.Column(db.Integer, db.ForeignKey('users.id'))
creator = db.relationship('User',
backref=db.backref('events', lazy='joined'))
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
def __init__(self, event_descriptor_id: int):
self.event_descriptor_id = event_descriptor_id
def push_notification_data(self):
event_descriptor = self.event_descriptor
message_template = event_descriptor.description
if self.entity_description:
message_template = message_template.replace(
"{1}", self.entity_description)
if self.entity_2_description:
message_template = message_template.replace(
"{2}", self.entity_2_description)
if self.entity_3_description:
message_template = message_template.replace(
"{3}", self.entity_3_description)
devices = Device.query_active_devices_for_group(
group=self.group, discard_user_ids=[self.creator_id]).all()
pn_tokens = [device.pn_token for device in devices]
return "Hi", message_template, pn_tokens
class Problem(db.Model):
__tablename__ = 'problems'
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.Integer, nullable=False)
rate = db.Column(db.SMALLINT)
time_limit = db.Column(db.SMALLINT, nullable=False) ## seconds
space_limit = db.Column(db.SMALLINT, nullable=False) ## megabytes
body = db.Column(db.String(100 * 1024), nullable=False)
fk_contest = db.Column(db.Integer,
db.ForeignKey('contests.id'),
index=True,
nullable=False)
contest = db.relationship('Contest', foreign_keys='Problem.fk_contest')
__table_args__ = (db.UniqueConstraint('number', 'fk_contest'), )
class Group(db.Model):
__tablename__ = "groups"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128))
associated_users = db.relationship("UserGroupAssociation",
back_populates="group")
users = association_proxy('associated_users', 'user')
created_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
def __init__(self, name: str):
self.name = name
@staticmethod
def get(id: int):
"""Get db entity that match the id"""
return Group.query.get(id)
class MailTemplate(db.Model):
__tablename__ = 'mailtemplates'
# noinspection PyTypeChecker
MAIL = IntEnum('Mail', {
'CV': 0,
'REPLY': 1,
})
id = db.Column(db.Integer, primary_key=True)
mail = db.Column(TypeEnum(MAIL), nullable=False)
title = db.Column(db.String, nullable=False)
subject = db.Column(db.String(79), nullable=False)
html = db.Column(db.Text, nullable=False)
help_msg = db.Column(db.Text)
updated_at = db.Column(db.Date, onupdate=datetime.datetime.now,
default=datetime.datetime.now)
bl = Resource('bl.mailtemplate')
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
who_updated = db.relationship('User')
def __repr__(self):
return str(self.title)
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
class Users(db.Model, Timestamp):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_name = db.Column(db.String(255), nullable=False)
last_name = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(128), unique=True)
password = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean, default=True, nullable=False)
def __init__(self,
first_name: str,
last_name: str,
password: str,
email: str = ''):
self.first_name = first_name
self.last_name = last_name
self.email = email
self.password = bcrypt.generate_password_hash(
password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode()
def to_json(self):
return {
'id': self.id,
'firstName': self.first_name,
'lastName': self.last_name,
'email': self.email,
'active': self.active,
}
def encode_auth_token(self, user_id: int):
"""Generates the auth token"""
try:
exp_days = current_app.config.get('TOKEN_EXPIRATION_DAYS')
exp_sec = current_app.config.get('TOKEN_EXPIRATION_SECONDS')
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=exp_days, seconds=exp_sec),
'iat':
datetime.datetime.utcnow(),
'id':
user_id
}
return jwt.encode(payload,
current_app.config.get('SECRET_KEY'),
algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token: bytes):
"""
Decodes the auth token
- :param auth_token:
- :return integer|string
"""
try:
payload = jwt.decode(auth_token,
current_app.config.get('SECRET_KEY'))
return payload['id']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
class Role(db.Model):
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.String(64), index= True)
users = db.relationship('User', back_populates= 'role')
