class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(), nullable=False)
last_name = db.Column(db.String(), nullable=False)
username = db.Column(db.String(), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=dt.utcnow)
def __init__(self, first_name, last_name, username, password):
self.first_name = first_name
self.last_name = last_name
self.username = username
self.password = bcrypt.generate_password_hash(password)
def __repr__(self):
return '<User {}>'.format(self.id)
def issue_token(self):
payload = {
'expires_at':
str(datetime.datetime.utcnow() + datetime.timedelta(days=1)),
'issued_at':
str(datetime.datetime.utcnow()),
'subject':
self.id
}
auth_token = jwt.encode(payload,
app.config.get('SECRET_KEY'),
algorithm='HS256')
return auth_token
@staticmethod
def decode(auth_token):
payload = jwt.decode(auth_token, app.config.get('SECRET_KEY'))
return payload['subject']
@staticmethod
def register(first_name, last_name, username, password):
user = User(first_name, last_name, username, password)
db.session.add(user)
db.session.commit()
auth_token = user.issue_token()
return auth_token
@staticmethod
def authenticate(username, password):
user = User.query.filter_by(username=username).first()
if user and bcrypt.check_password_hash:
auth_token = user.issue_token()
return auth_token
else:
raise Exception('Unauthorized')
@staticmethod
def is_authorized(auth_token):
return True if User.decode(auth_token) else False
class User(db.Model, Base):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, nullable=False)
username = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(50), nullable=False)
phone = db.Column(db.String(20), unique=True, nullable=False)
avatar = db.Column(db.String(255), nullable=True)
grade = db.Column(db.Integer, default=1, nullable=False)
@classmethod
def get_user(cls, user_id):
user = cls.query.filter_by(id=user_id).first()
return user
@classmethod
def save_data(cls, data):
user = cls.query.filter_by(username=data['username'],
phone=data['phone']).first()
if user:
return None
else:
user = cls(username=data['username'],
password=data['password'],
phone=data['phone'])
db.session.add(user)
db.session.commit()
return user
@classmethod
def verify_data(cls, data):
user = cls.query.filter_by(username=data['username'],
password=data['password']).first()
return user
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False, unique=True)
email = db.Column(db.String(100), nullable=False, unique=True)
password = db.Column(db.String(60), nullable=False)
image = db.Column(db.String(20), nullable=False, default='default.png')
posts = db.relationship('Post', backref='author', lazy=True)
comments = db.relationship('Comment', backref='author', lazy=True)
def get_reset_token(self, expire_seconds=1800):
s = Serializer(app.config['SECRET_KEY'], expire_seconds)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except Exception:
return None
return User.query.get(user_id)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.image}')"
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True)
password_hash = db.Column(db.String(128))
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 RegistrationDetail(db.Model, BaseMixin, ReprMixin):
name = db.Column(db.String(55), nullable=False)
value = db.Column(db.String(20), nullable=False)
retail_shop_id = db.Column(db.Integer(), db.ForeignKey('retail_shop.id', ondelete='CASCADE'))
retail_shop = db.relationship('RetailShop', foreign_keys=[retail_shop_id], back_populates='registration_details')
class User(db.Model):
id = db.Column(UUIDType(binary=False),
primary_key=True,
default=generate_uuid)
username = db.Column(db.String(50), nullable=False, unique=True)
pwdhash = db.Column(db.String(80), nullable=False)
carts = db.relationship('Cart',
backref='customer',
lazy=True,
cascade="all, delete-orphan, delete")
def __repr__(self):
return f"User('{self.username}')"
def __init__(self, username, password):
self.username = username
self.set_password(password)
def set_password(self, password):
self.pwdhash = bcrypt.generate_password_hash(password).decode('utf-8')
def check_password(self, password):
return bcrypt.check_password_hash(self.pwdhash, password)
def serialize(self):
return {
"id":
self.id,
"username":
self.username,
"carts": [{
"cart_id": cart.id,
"is_ordered": True if cart.order else False
} for cart in self.carts]
}
class Tweet(SearchableMixin, db.Model):
__searchable__ = ['textbody']
id = db.Column(db.Integer, primary_key=True)
identifier = db.Column(db.String(32), nullable=False)
textbody_source = db.Column(db.String(500), nullable=False)
textbody_markdown = db.Column(db.Text(), nullable=False)
userid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
comments = db.relationship('Comment', backref='tweet', lazy="dynamic")
created_utc = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
edited_utc = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
stickied = db.Column(db.Boolean, default=False)
is_banned = db.Column(db.Boolean, default=False)
is_nsfw = db.Column(db.Boolean, default=False)
is_edited = db.Column(db.Boolean, default=False)
comment_path_counter = db.Column(db.Integer, default=1, autoincrement=True)
likes = db.relationship('Like', backref='tweet', lazy='dynamic')
@classmethod
def get_identifier(cls):
while True:
ident = secrets.token_hex(nbytes=16)
if not cls.query.filter_by(identifier=ident).first():
return ident
def __repr__(self):
return '<Tweet {}>'.format(self.id)
class Role(BaseMixin, db.Model, RoleMixin, ReprMixin):
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
users = db.relationship('User',
back_populates='roles',
secondary='user_role')
class User(BaseMixin, db.Model, UserMixin, ReprMixin):
email = db.Column(db.String(127), unique=True, nullable=False)
password = db.Column(db.String(255), default='', nullable=False)
username = db.Column(db.String(127), nullable=True)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(45))
current_login_ip = db.Column(db.String(45))
login_count = db.Column(db.Integer)
roles = db.relationship('Role',
back_populates='users',
secondary='user_role')
permissions = db.relationship('Permission',
back_populates='users',
secondary='user_permission')
user_profile = db.relationship("UserProfile",
uselist=False,
back_populates="user",
cascade='all, delete-orphan',
lazy='subquery')
def has_permission(self, permission):
if isinstance(permission, str):
return permission in (permission.name
for permission in self.permissions)
else:
return permission in self.permissions
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
image_file = db.Column(db.String(20),
nullable=False,
default='default.jpg')
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref='author', lazy=True)
def get_reset_token(self, expires_sec=1800):
s = Serializer(current_app.config['SECRET_KEY'], expires_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
except:
return None
return User.query.get(user_id)
def __repr__(self):
return (self.username, self.email, self.image_file)
class Country(db.Model):
__tablename__ = "countries"
id = db.Column(db.Integer, primary_key=True, auto_increment=True)
name = db.Column(db.String(50), unique=True)
code = db.Column(db.String(50), unique=True)
provinces = db.relationship('Province', backref='Country', lazy=True)
class Contact(db.Model):
__tablename__ = 'contact'
__table_args__ = (
db.ForeignKeyConstraint(
["person_id", ],
["person.id",]
),
)
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
person_id = db.Column(db.Integer, primary_key=True)
person = db.relationship("Person")
email = db.Column(db.String(65))
cell_phone = db.Column(db.String(11))
phone = db.Column(db.String(11))
creation_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
modification_date = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.utcnow())
def __init__(self, person_id, email, cell_phone, phone):
self.person_id = person_id
self.email = email
self.cell_phone = cell_phone
self.phone = phone
def __repr__(self):
contact = 'id: {id}'
if email: contact+= f', email:{email}'
if cell_phone: contact+= f', cellphone:{cell_phone}'
return f'<Contact: {contact}'
class Hint(db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(255), unique=False, nullable=False)
h_type = db.Column(db.String(100), unique=False, nullable=False)
question_id = db.Column(db.Integer,
db.ForeignKey('question.id'),
nullable=False)
class User(db.Model):
__tablename__ = "account"
id = db.Column(db.Integer, primary_key=True)
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime, default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
name = db.Column(db.String(144), nullable=False)
username = db.Column(db.String(144), nullable=False)
password = db.Column(db.String(144), nullable=False)
equipment = db.relationship("Equipment")
def __init__(self, name, username, password):
self.name = name
self.username = username
self.password = password
def get_id(self):
return self.id
def is_active(self):
return True
def is_anonymous(self):
return False
def is_authenticated(self):
return True
def get_equipment(self):
return self.equipment
class LogBindBankCard(db.Model, LogBaseMixin, LogUserMixin):
"""绑卡表"""
__tablename__ = 'tb_bind_bankcard'
location = db.Column(db.String(200), comment="绑卡地点")
bind_time = db.Column(db.BigInteger, comment="绑卡时间", index=True)
result = db.Column(db.String(10), comment="绑卡结果", index=True)
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
user_email = db.Column(db.String(64), unique=True, index=True)
user_username = db.Column(db.String(64), unique=True, index=True)
user_posts = db.relationship('Topic', cascade="all, delete-orphan", backref='author', lazy='dynamic')
user_role = db.Column(db.String(10), index=True, default='User')
user_first_name = db.Column(db.String(64), index=True, nullable=True)
user_last_name = db.Column(db.String(64), index=True, nullable=True)
user_birthday = db.Column(db.DateTime(), index=True, nullable=True)
user_date = db.Column(db.DateTime(), index=True, nullable=True)
user_location = db.Column(db.String(64), index=True, nullable=True)
user_about = db.Column(db.String(140), index=True, nullable=True)
user_occupation = db.Column(db.String(100), index=True, nullable=True)
user_interests = db.Column(db.String(100), index=True, nullable=True)
password_hash = db.Column(db.String(128))
user_reply = db.relationship('Reply', cascade="all, delete-orphan", backref='reply_from', lazy='dynamic')
def __init__(self, user_email, user_username, user_password, user_role,
user_date):
self.user_email = user_email
self.user_username = user_username
self.user_role = user_role
self.password_hash = generate_password_hash(user_password)
self.user_date = user_date
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class School(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), unique=True)
slug = db.Column(db.String(120), index=True)
domains = db.Column(JSON, default=[])
is_demo = db.Column(db.Boolean(), default=False)
redeem_prize_email = db.Column(db.String(120))
launchable = db.Column(db.Boolean(), default=True)
is_destroyed = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def __init__(self,
name,
domains=[],
is_demo=False,
redeem_prize_email=None,
launchable=True):
self.name = name
self.slug = slugify(name, separator='-', to_lower=True)
self.domains = domains
self.is_demo = is_demo
self.redeem_prize_email = redeem_prize_email
self.launchable = launchable
def __repr__(self):
return '<School id={}, name={}, slug={}, domains={}, is_demo={}, redeem_prize_email={}, launchable={}, is_destroyed={}, created_at={}>'.format(
self.id, self.name, self.slug, self.domains, self.is_demo,
self.redeem_prize_email, self.launchable, self.is_destroyed,
self.created_at)
def active_users(self):
return [u for u in self.users if not u.is_destroyed]
def active_challenges(self):
return [c for c in self.challenges if not c.is_destroyed]
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), unique=True, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(256), nullable=False)
is_admin = db.Column(db.Boolean, default=False)
uuid = db.Column(db.String(36), unique=True)
def __init__(self, username, email, password, is_admin=False):
self.username = username
self.email = email
self.password = generate_password_hash(password)
self.is_admin = is_admin
self.uuid = str(uuid.uuid4())
def __repr__(self):
return f'User: {self.username}, {self.email}, {self.is_admin}, {self.uuid}'
@classmethod
def find_user_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_user_by_uuid(cls, uuid):
return cls.query.filter_by(uuid=uuid).first()
class ScheduleModel(ModelBase):
__tablename__ = 'schedules'
uuid = db.Column(db.String(80), primary_key=True, nullable=False)
name = db.Column(db.String(80), nullable=False, unique=True)
@validates('name')
def validate_name(self, _, value):
if not re.match("^([A-Za-z0-9_-])+$", value):
raise ValueError(
"name should be alphanumeric and can contain '_', '-'")
return value
def __repr__(self):
return f"Schedule(uuid = {self.uuid})"
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def update(self, **kwargs):
if super().update(**kwargs):
from src.services.schedules_registry import SchedulesRegistry
SchedulesRegistry().update_schedule(self)
return self
def delete_from_db(self):
super().delete_from_db()
from src.services.schedules_registry import SchedulesRegistry
SchedulesRegistry().delete_schedule(self)
def save_to_db(self):
super().save_to_db()
from src.services.schedules_registry import SchedulesRegistry
SchedulesRegistry().add_schedule(self)
class LogLoading(db.Model, LogBaseMixin):
"""加载表"""
__tablename__ = "tb_loading"
location = db.Column(db.String(200), comment="加载地")
load_time = db.Column(db.BigInteger, comment='加载时间', index=True)
result = db.Column(db.String(100), comment="加载结果", index=True)
class User(db.Model, UserMixin):
"""User table model"""
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(25), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
password = db.Column(db.String(30), nullable=False)
lessons = db.relationship('Lesson', backref='author', lazy=True)
class LogRegister(db.Model, LogBaseMixin, LogUserMixin):
"""注册表"""
__tablename__ = 'tb_register'
location = db.Column(db.String(200), comment="认证地")
reg_time = db.Column(db.BigInteger, comment="注册时间", index=True)
result = db.Column(db.String(100), comment="注册结果", index=True)
class Role(db.Model):
"""Hold Role Details."""
__tablename__ = 'sec_roles'
role_id = db.Column(db.Integer, primary_key=True)
role_name = db.Column(db.String(50), nullable=False, unique=True)
role_description = db.Column(db.String(255), nullable=False)
users = db.relationship('User', secondary='sec_users_roles',
backref=db.backref('users', lazy='dynamic'))
menus = db.relationship('navigation.models.Menu',
secondary='nav_roles_menus',
backref=db.backref('roles', lazy='dynamic'))
is_active = db.Column(db.Boolean(), nullable=False, server_default='1')
created_by = db.Column(db.Integer)
created_datetime = db.Column(db.DateTime, default=datetime.now())
modified_by = db.Column(db.Integer)
last_modified_datetime = db.Column(db.DateTime, nullable=True)
is_default = db.Column(db.Boolean(), default=False)
def __init__(self, role_name, role_description, created_by):
"""Create a new role."""
self.role_name = role_name
self.role_description = role_description
self.created_by = created_by
self.created_datetime = datetime.now()
def __repr__(self):
"""Represent an instance of the class."""
return self.role_name
class LogLogin(db.Model, LogBaseMixin, LogUserMixin):
"""登陆表"""
__tablename__ = "tb_login"
location = db.Column(db.String(200), comment="登陆地")
login_time = db.Column(db.BigInteger, comment="登陆时间", index=True)
result = db.Column(db.String(10), comment="登陆结果", index=True)
class User(UserMixin, db.Model):
__tablename__="users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String (200), nullable=False)
mobile = db.Column(db.String, nullable=False, unique=True)
email = db.Column(db.String (200), index = True, unique=True)
password_hash = db.Column(db.String(1200))
tokens = db.relationship("Token", backref="user", lazy=True)
order = db.relationship("Order", backref="user", lazy=True)
location = db.relationship("Location", backref="user", lazy=True)
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)
def check_user(self):
return User.query.filter_by(email=self.email).first()
def add(self):
db.session.add(self)
db.session.commit()
def get_json(self):
return {
"id": self.id,
"username": self.username,
"mobile": self.mobile,
"email": self.email
}
class LogRealnameAuth(db.Model, LogBaseMixin, LogUserMixin):
"""实名认证表"""
__tablename__ = "tb_realnameauth"
location = db.Column(db.String(200), comment="认证地")
auth_time = db.Column(db.BigInteger, comment="认证时间", index=True)
result = db.Column(db.String(10), comment="认证结果", index=True)
class Film(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String, nullable=False)
release_date = db.Column(db.Date, index=True, nullable=False)
uuid = db.Column(db.String(36), unique=True)
description = db.Column(db.Text)
distributed_by = db.Column(db.String(128), nullable=False)
length = db.Column(db.Float)
rating = db.Column(db.Float)
def __init__(self, title, release_date, description, distributed_by,
length, rating):
self.title = title
self.release_date = release_date
self.uuid = str(uuid.uuid4())
self.description = description
self.distributed_by = distributed_by
self.length = length
self.rating = rating
def __repr__(self):
return f'Film({self.title}, {self.release_date}, {self.uuid}, {self.distributed_by})'
def to_dict(self):
return {
'title': self.title,
'uuid': self.uuid,
'release_date': self.release_date.strftime('%Y-%m-%d'),
'distributed_by': self.distributed_by,
'description': self.description,
'length': self.length,
'rating': self.rating,
}
class LogFaceSign(db.Model, LogBaseMixin, LogUserMixin):
"""面签表"""
__tablename__ = 'tb_face_sign'
location = db.Column(db.String(200), comment="面签地")
face_sign_time = db.Column(db.BigInteger, comment="面签时间", index=True)
result = db.Column(db.String(10), comment="面签结果", index=True)
class User(db.Model):
"""User Model for storing user related details."""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
registered_on = db.Column(db.DateTime, nullable=False)
account_type = db.Column(db.Integer, nullable=True)
def __init__(self, username, password, account_type):
self.username = username
self.password = bcrypt.generate_password_hash(
password, app.config.get("BCRYPT_LOG_ROUNDS")).decode()
self.registered_on = datetime.datetime.now()
self.account_type = (account_type if account_type == 1
or account_type == 2 else None)
def encode_auth_token(self, user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
"exp":
datetime.datetime.utcnow() +
datetime.timedelta(days=1, seconds=0),
"iat":
datetime.datetime.utcnow(),
"sub":
user_id,
}
return jwt.encode(payload,
app.config.get("SECRET_KEY"),
algorithm="HS256")
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Validates the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token,
app.config.get("SECRET_KEY"),
algorithms=["HS256"])
is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)
if is_blacklisted_token:
return "Token blacklisted. Please log in again."
else:
return payload["sub"]
except jwt.ExpiredSignatureError:
return "Signature expired. Please log in again."
except jwt.InvalidTokenError:
return "Invalid token. Please log in again."
class Url(db.Model):
__tablename__ = "url"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
url = db.Column(db.String(256), nullable=False)
code = db.Column(db.String(6), nullable=False)
created_at = db.Column(db.DateTime,
default=datetime.datetime.utcnow(),
nullable=False)
last_usage = db.Column(db.DateTime, nullable=True)
usage_count = db.Column(db.Integer, default=0, nullable=False)
def to_json(self):
return {'url': self.url, 'code': self.code}
def stats_to_json(self):
result = {
'created_at': self.created_at.isoformat(),
'usage_count': self.usage_count
}
if self.last_usage is not None:
result['last_usage'] = self.last_usage.isoformat()
return result
def save(self):
db.session.add(self)
db.session.commit()
