class StatPost(db.Model):
__tablename__ = 'stat_post'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column('user_id', db.Integer(), db.ForeignKey('user.id'))
post_id = db.Column('post_id', db.Integer(), db.ForeignKey('post.id'))
like = db.Column(db.Boolean, default=None)
count = db.Column(db.Integer(), default=0)
class RolesUsers(db.Model):
__tablename__ = 'roles_users'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('user.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('role.id', ondelete='CASCADE'))
class UserRoles(db.Model):
"""User和Role的关联表"""
__tablename__ = "user_roles"
id = db.Column(db.Integer(), primary_key=True) # 必须加这一条，否则删除的时候sqlite会出错
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
class UserRoles(db.Model):
"""
Association table for Users and Roles
"""
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
class UserRoles(db.Model):
__tablename__ = 'user_roles'
id = db.Column(db.Integer(), primary_key=True)
user_id = db.Column(db.Integer(),
db.ForeignKey('users.id', ondelete='CASCADE'))
role_id = db.Column(db.Integer(),
db.ForeignKey('roles.id', ondelete='CASCADE'))
def __init__(self, user_id, role_id):
self.user_id = user_id,
self.role_id = role_id
def __repr__(self):
return f"user_id[{self.user_id}] to role_id[{self.user_role}]"
class User(db.Model):
__tablename__ = 'Users'
Id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
Name = db.Column(db.Text(), nullable=True)
Email = db.Column(db.Text(), nullable=False)
DisplayName = db.Column(db.Text(), nullable=True)
FamilyName = db.Column(db.Text(), nullable=True)
RegistrationDate = db.Column(db.DateTime(), nullable=False)
LastVisit = db.Column(db.DateTime(), nullable=False)
wished_markers = db.relationship('Marker',
secondary=wishlist_markers,
backref='wishers')
owned_markers = db.relationship('Marker',
secondary=my_markers,
backref='owners')
cart_markers = db.relationship('Cart', backref='user')
def to_dict(self):
data = {
'id': self.Id,
'email': self.Email,
'name': self.Name,
'display_name': self.DisplayName,
'family_name': self.FamilyName,
'registration_date': self.RegistrationDate,
'last_visit': self.LastVisit
}
return data
class Marker(db.Model):
__tablename__ = 'Markers'
Id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
Brand = db.Column(db.Text(), nullable=False)
Series = db.Column(db.Text(), nullable=False)
FullName = db.Column(db.Text(), nullable=False)
ColorGroup = db.Column(db.Text(), nullable=True)
ColorGroupFullName = db.Column(db.Text(), nullable=False)
Hex = db.Column(db.Text(), nullable=False)
ShortName = db.Column(db.Text(), nullable=False)
carts = db.relationship('Cart', backref='marker')
def __repr__(self):
return self.Brand + self.Series + self.Hex
def to_dict(self):
data = {
'id': self.Id,
'full_name': self.FullName,
'short_name': self.ShortName,
'brand': self.Brand,
'series': self.Series,
'hex': self.Hex,
'color_group_full_name': self.ColorGroupFullName,
'color_group': self.ColorGroup
}
return data
def by_brand_series_key(self):
return self.Brand + self.Series
class Role(CRUDMixin, db.Model):
"""
Role table: stores information about roles, which users can be tied to users
"""
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
class Data(db.Model):
__tablename__ = "Data"
__table_args__ = {'extend_existing': True}
fileid = db.Column(db.Integer, db.ForeignKey('Files.fileid'))
ticker = db.Column(db.String(80), nullable=False, primary_key=True)
per = db.Column(db.Integer())
date = db.Column(db.Date, nullable=False, primary_key=True)
time = db.Column(db.Time, nullable=False, primary_key=True)
open = db.Column(db.Float)
high = db.Column(db.Float)
low = db.Column(db.Float)
close = db.Column(db.Float)
vol = db.Column(db.Integer)
created = db.Column(db.DateTime,
default=datetime.now,
server_default=text('now()'))
updated = db.Column(db.DateTime,
default=datetime.now,
onupdate=datetime.now,
server_default=text('now()'))
def __repr__(self):
return f'{type(self).__name__} <{self.fileid}>: <{self.ticker}>-<{self.date}>-<{self.time}>'
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), unique=True)
description = db.Column(db.String(255))
def __repr__(self):
return self.name
class Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __repr__(self):
return self.name
class Role(db.Model):
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(50), unique=True)
def __init__(self, name):
self.name = name
def __repr__(self):
return self.name
class Token(BaseModel):
__tablename__ = 'token'
access_token = db.Column(db.String(), nullable=False)
token_type = db.Column(db.String(), nullable=False)
scope = db.Column(db.String(), nullable=False)
expires_in = db.Column(db.Integer(), nullable=False)
refresh_token = db.Column(db.String(), nullable=False)
user_id = db.Column(UUIDType(binary=False),
db.ForeignKey('user.id'),
nullable=False,
index=True,
unique=True)
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def get_id(self):
return self.id
def get_urole(self):
return self.role
class Store(db.Model):
__tablename__ = 'Stores'
Id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
Name = db.Column(db.Text(), nullable=False)
Site = db.Column(db.Text(), nullable=False)
Logo = db.Column(db.Text(), nullable=False)
def to_dict(self):
data = {
'id': self.Id,
'name': self.Name,
'site': self.Site,
'logo': self.Logo
}
return data
class Role(db.Model, RoleMixin):
"""
Role Model
Using Flask-Security's RoleMixin
Arguments:
id (int): Primary Role Key
name (str): Role name for reference in admin and for restrictions
description (str): Role description
"""
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __repr__(self):
if self.description is not None:
return '{0} - {1}'.format(self.name, self.description)
return '{0}'.format(self.name)
class Feature(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64))
description = db.Column(db.Text())
client = db.Column(db.String(24))
client_priority = db.Column(db.Integer())
target_date = db.Column(db.DateTime())
product_area = db.Column(db.String(24))
def to_json(self):
"""Return object data in easily serializeable format"""
return {
'id': self.id,
'title': self.title,
'description': self.description,
'client': self.client,
'client_priority': self.client_priority,
'target_date': dump_datetime(self.target_date),
'product_area': self.product_area
}
def __repr__(self):
return '<Feature {}>'.format(self.title)
class Settings(db.Model):
__table_args__ = {"schema": settings.SQLALCHEMY_DATABASE_SCHEMA}
__tablename__ = "settings"
id = db.Column(db.Integer(), primary_key = True)
max_likes_per_day = db.Column(db.Integer(), default = 600)
max_unlikes_per_day = db.Column(db.Integer(), default = 600)
max_follows_per_day = db.Column(db.Integer(), default = 350)
max_unfollows_per_day = db.Column(db.Integer(), default = 200)
max_comments_per_day = db.Column(db.Integer(), default = 100)
max_likes_to_like = db.Column(db.Integer(), default = 2000)
filter_users = db.Column(db.Boolean(), default = 1)
filter_business_accounts = db.Column(db.Boolean(), default = 1)
filter_verified_accounts = db.Column(db.Boolean(), default = 1)
filter_users_without_profile_photo = db.Column(db.Boolean(), default = 1)
filter_users_with_external_url = db.Column(db.Boolean(), default = 1)
max_followers_to_follow = db.Column(db.Integer(), default = 5000)
min_followers_to_follow = db.Column(db.Integer(), default = 10)
max_following_to_follow = db.Column(db.Integer(), default = 2000)
min_following_to_follow = db.Column(db.Integer(), default = 10)
max_followers_to_following_ratio = db.Column(db.Integer(), default = 10)
max_following_to_followers_ratio = db.Column(db.Integer(), default = 2)
min_media_count_to_follow = db.Column(db.Integer(), default = 3)
max_following_to_block = db.Column(db.Integer(), default = 2000)
like_delay = db.Column(db.Integer(), default = 30)
unlike_delay = db.Column(db.Integer(), default = 30)
follow_delay = db.Column(db.Integer(), default = 30)
unfollow_delay = db.Column(db.Integer(), default = 30)
comment_delay = db.Column(db.Integer(), default = 30)
def __repr__(self):
from app.utils.functions import config_to_dict
self_dict = config_to_dict(self)
msg = [k + '=' + str(v) for k, v in self_dict.items()]
return ','.join(msg)
pass
class TagsPosts(db.Model):
__tablename__ = 'tags_posts'
id = db.Column(db.Integer(), primary_key=True)
post_id = db.Column('post_id', db.Integer(), db.ForeignKey('post.id'))
tag_id = db.Column('tag_id', db.Integer(), db.ForeignKey('tag.id'))
"""
Model for user
"""
from flask_security import UserMixin, RoleMixin, SQLAlchemyUserDatastore
from app.database import db
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('users.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('roles.id')))
class Role(db.Model, RoleMixin):
"""
Role Model
Using Flask-Security's RoleMixin
Arguments:
id (int): Primary Role Key
name (str): Role name for reference in admin and for restrictions
description (str): Role description
"""
__tablename__ = 'roles'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __repr__(self):
class User(Model, SurrogatePK, UserMixin):
"""user model"""
__tablename__ = 'users'
username = db.Column(db.String(32), unique=True, index=True) # username
password_hash = db.Column(db.String(128))
email = db.Column(db.String(128), index=True, default=None) # Email
phone = db.Column(db.String(32), index=True, default=None)
sex = db.Column(db.Integer(), default=0)
active = db.Column(db.Boolean(), default=True)
nickname = db.Column(db.String(32), default="") # 昵称
avatar_hash = db.Column(db.String(32)) # 头像hash值
create_datetime = db.Column(db.DateTime,
nullable=False,
default=dt.datetime.now) # 创建（注册）时间
current_login_datetime = db.Column(db.DateTime, nullable=True) # 本次登录时间
last_login_datetime = db.Column(db.DateTime, nullable=True) # 上次登录时间
last_login_ip = db.Column(db.String(32), nullable=True) # 上次登录IP
current_login_ip = db.Column(db.String(32), nullable=True) # 当前登录IP
def get_user_id(self):
"""for authlib"""
return self.id
roles = db.relationship('Role',
secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<User %r>' % self.username
@property
def password(self):
return self.password_hash
@password.setter
def password(self, password):
"""设置密码hash"""
# for flask-user
# from app import user_manager
self.password_hash = user_manager.password_manager.hash_password(
password)
def verify_password(self, password):
"""验证密码"""
# from app import user_manager
return user_manager.password_manager.\
verify_password(password, self.password)
def gravatar(self, size=100, default='identicon', rating='g'):
"""生成头像"""
if request.is_secure:
url = 'https://secure.gravatar.com/avatar'
else:
url = 'http://www.gravatar.com/avatar'
hash = self.avatar_hash or hashlib.md5(
self.username.encode('utf-8')).hexdigest()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.format(
url=url, hash=hash, size=size, default=default, rating=rating)
def login_info_update(self, auto_commit=True):
import datetime as dt
from flask import request
self.last_login_datetime = self.current_login_datetime
self.current_login_datetime = dt.datetime.now()
self.last_login_ip = self.current_login_ip
self.current_login_ip = request.remote_addr
if auto_commit:
db.session.add(self)
db.session.commit()
from app.database import db
from model_base import BaseModel
from flask_security import UserMixin, RoleMixin
# Define models
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id')))
groups_users = db.Table(
'groups_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('group_id', db.Integer(), db.ForeignKey('group.id')))
class Role(BaseModel, RoleMixin):
__tablename__ = 'role'
name = db.Column(db.String(255), unique=True, index=True)
description = db.Column(db.String(255), index=True)
class User(BaseModel, UserMixin):
__tablename__ = 'user'
username = db.Column(db.String(255), unique=True, index=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), index=True)
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(63))
class Cart(db.Model):
__tablename__ = 'Carts'
Id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
Amount = db.Column(db.Integer(), nullable=True)
User_id = db.Column(db.Integer(), db.ForeignKey('Users.Id'))
Marker_id = db.Column(db.Integer(), db.ForeignKey('Markers.Id'))
from app.database import db
from model_base import BaseModel
labels_subjects = db.Table('labels_subjects',
db.Column('label_id', db.Integer(), db.ForeignKey('label.id')),
db.Column('subject_id', db.Integer(), db.ForeignKey('subject.id')))
groups_heads = db.Table('groups_heads',
db.Column('group_id', db.Integer(), db.ForeignKey('group.id')),
db.Column('head_id', db.Integer(), db.ForeignKey('head.id')))
users_papers = db.Table('users_papers',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('paper_id', db.Integer(), db.ForeignKey('paper.id')))
class Scene(BaseModel):
__tablename__ = 'scene'
describe = db.Column(db.Text, comment='场景描述')
class Label(BaseModel):
__tablename__ = 'label'
name = db.Column(db.String(255), comment='标签简述')
describe = db.Column(db.Text, comment='标签描述')
class Subject(BaseModel):
__tablename__ = 'subject'
topic = db.Column(db.Text, comment='考题题目')
from flask_security import UserMixin, RoleMixin
from app.database import db
roles_users = db.Table('roles_users',
db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))
)
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(100), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def get_id(self):
return self.id
def get_urole(self):
return self.role
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(100), unique=True)
description = db.Column(db.String(255))
