class Vat_return(SurrogatePK, Model, TimestampMixin):
__tablename__ = 'vat_returns'
organisation_id = reference_col('organisations', nullable=False)
period_key = Column(db.String(4))
vat_due_sales = Column(db.String(10))
vat_due_acquisitions = Column(db.String(10))
total_vat_due = Column(db.String(10))
vat_reclaimed_curr_period = Column(db.String(10))
net_vat_due = Column(db.String(10))
total_value_sales_ex_vat = Column(db.String(10))
total_value_purchases_ex_vat = Column(db.String(10))
total_value_goods_supplied_ex_vat = Column(db.String(10))
total_acquisitions_ex_vat = Column(db.String(10))
finalised = Column(db.Boolean(), default=True)
is_submitted = Column(db.Boolean(), default=False)
submitted_on = Column(db.DateTime, nullable = True)
submitted_by = Column(db.String(50), nullable=True)
def __init__(self, organisation_id, period_key, **kwargs):
db.Model.__init__(self, organisation_id=organisation_id, period_key=period_key, **kwargs)
def is_submitted(self):
"""Active or non active user (required by flask-login)"""
return self.is_submitted
class User(UserMixin, SurrogatePK, Model):
__tablename__ = 'users'
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(80), unique=True, nullable=False)
#: The hashed password
password = Column(db.String(128), nullable=True)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
first_name = Column(db.String(30), nullable=True)
last_name = Column(db.String(30), nullable=True)
active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
def __init__(self, username, email, password=None, **kwargs):
db.Model.__init__(self, username=username, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
return bcrypt.check_password_hash(self.password, value)
@property
def full_name(self):
return "{0} {1}".format(self.first_name, self.last_name)
def __repr__(self):
return '<User({username!r})>'.format(username=self.username)
class User(CRUDMixin, UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False, unique=True)
email = db.Column(db.String(128), nullable=False, unique=True)
pw_hash = db.Column(db.String(60), nullable=False)
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
remote_addr = db.Column(db.String(20))
active = db.Column(db.Boolean())
is_admin = db.Column(db.Boolean())
def __init__(self, password, **kwargs):
super(User, self).__init__(**kwargs)
self.set_password(password)
def __repr__(self):
return '<User #%s:%r>' % (self.id, self.username)
def set_password(self, password):
hash_ = bcrypt.generate_password_hash(password, 10).decode('utf-8')
self.pw_hash = hash_
def check_password(self, password):
return bcrypt.check_password_hash(self.pw_hash, password)
class User(UserMixin, SurrogatePK, Model, EntityBase):
"""A user of the app."""
__tablename__ = "users"
account = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(80), unique=True, nullable=False)
#: The hashed password
password = Column(db.LargeBinary(128), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
first_name = Column(db.String(30), nullable=True)
last_name = Column(db.String(30), nullable=True)
active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
def __init__(self, account, email, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, account=account, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def get_id(self):
"""获取用户ID"""
return self.id
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def full_name(self):
"""Full user name."""
return f"{self.first_name} {self.last_name}"
def __repr__(self):
"""Represent instance as a unique string."""
return f"<User({self.account!r})>"
@classmethod
def verify_auth_token(cls, token):
data = jwt.decode(token,
current_app.config["SECRET_KEY"],
algorithms=['HS256'])
return cls.query.get(data["id"])
def generate_token(self):
return jwt.encode({"id": self.id},
current_app.config["SECRET_KEY"],
algorithm='HS256')
class User(CRUDMixin, UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), nullable=False, unique=True)
pw_hash = db.Column(db.String(60), nullable=False)
created_ts = db.Column(
db.DateTime(timezone=True),
server_default=db.func.current_timestamp(),
)
updated_ts = db.Column(
db.DateTime(timezone=True),
onupdate=db.func.current_timestamp(),
)
remote_addr = db.Column(db.String(20))
active = db.Column(db.Boolean())
is_admin = db.Column(db.Boolean())
def __init__(self,
email,
password,
remote_addr,
active=False,
is_admin=False):
self.email = email
self.set_password(password)
self.created_ts = datetime.datetime.now()
self.remote_addr = remote_addr
self.active = active
self.is_admin = is_admin
def __repr__(self):
return '<User %s>' % self.email
def set_password(self, password):
self.pw_hash = bcrypt.generate_password_hash(password,
10).decode("utf-8")
def check_password(self, password):
return bcrypt.check_password_hash(self.pw_hash, password)
@classmethod
def stats(cls):
active_users = cache.get('active_users')
if not active_users:
active_users = cls.query.filter_by(active=True).count()
cache.set('active_users', active_users)
inactive_users = cache.get('inactive_users')
if not inactive_users:
inactive_users = cls.query.filter_by(active=False).count()
cache.set('inactive_users', inactive_users)
return {
'all': active_users + inactive_users,
'active': active_users,
'inactive': inactive_users
}
class Printer(db.Model):
__tablename__ = "printers"
id = db.Column(db.Integer, primary_key=True)
vendor = db.Column(db.String(100), nullable=True, unique=True)
product = db.Column(db.String(100), unique=True)
in_ep = db.Column(db.Integer, nullable=True)
out_ep = db.Column(db.Integer, nullable=True)
active = db.Column(db.Boolean())
langu = db.Column(db.String(100))
value = db.Column(db.Integer)
def __init__(self,
vendor=" ",
product=" ",
in_ep=0,
out_ep=0,
active=False,
langu='en',
value=1):
self.vendor = vendor
self.product = product
self.in_ep = in_ep
self.out_ep = out_ep
self.active = active
self.value = value
class User(db.Model, UserMixin):
"""
User model
Arguments:
id (int): Primary User Key
username (str): Unique username as chosen by the user
email (str): User's email address
password_hash (str): Users hashed password
"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
email = db.Column(db.String(120), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<User %r>' % self.username
def __str(self):
return self.username
class User(db.Model, UserMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
active = db.Column('is_active',
db.Boolean(),
nullable=False,
server_default='1')
# User authentication information. The collation='NOCASE' is required
# to search case insensitively when USER_IFIND_MODE is 'nocase_collation'.
username = db.Column(db.String(255, collation='NOCASE'),
nullable=False,
unique=True)
password = db.Column(db.String(255), nullable=False, server_default='')
# User information
first_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
last_name = db.Column(db.String(100, collation='NOCASE'),
nullable=False,
server_default='')
# Define the relationship to Role via UserRoles
roles = db.relationship(
'Role',
secondary='user_roles',
)
def __repr__(self):
return self.first_name
class VSRole(CRUDMixin, db.Model):
"""
角色模型
"""
__tablename__ = 'tbl_vsppm_role'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 角色名称
name = db.Column(db.String(128), nullable=False, unique=True)
# 角色描述
role = db.Column(db.String(128), nullable=False)
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
# 让VSRole和VSAcl产生关联
# 因为VSAcl和VSRole表中间还有一个vsppm_user_role表,所以添加secondary
# 正向引用是VSRole访问VSAcl,反向引用是从VSAcl访问表VSRole
acls = db.relationship('VSAcl',
secondary=vsppm_role_acl,
backref=db.backref('roles'))
def __init__(self, **kwargs):
super(VSRole, self).__init__(**kwargs)
def __repr__(self):
return '<VSRole #%s:%r>' % (self.id, self.name)
class VSGroup(CRUDMixin, db.Model):
"""
组模型
"""
__tablename__ = 'tbl_vsppm_group'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 组名称
name = db.Column(db.String(128), nullable=False, unique=True)
# 组负责人
admin = db.Column(db.String(60))
# 所属部门id
department_id = db.Column(db.Integer, nullable=False)
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
def __init__(self, **kwargs):
super(VSGroup, self).__init__(**kwargs)
def __repr__(self):
return '<VSGroup #%s:%r>' % (self.id, self.name)
class VSCompany(CRUDMixin, db.Model):
"""
公司模型
"""
__tablename__ = 'tbl_vsppm_company'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 公司名称
name = db.Column(db.String(128), nullable=False, unique=True)
# 公司负责人
admin = db.Column(db.String(60))
# 主页
website = db.Column(db.String(128))
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
def __init__(self, **kwargs):
super(VSCompany, self).__init__(**kwargs)
def __repr__(self):
return '<VSCompany #%s:%r>' % (self.id, self.name)
class VSAcl(CRUDMixin, db.Model):
"""
权限模型
"""
__tablename__ = 'tbl_vsppm_acl'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 权限模块名称
module = db.Column(db.String(128), nullable=False)
# 权限模块功能方法名称
method = db.Column(db.String(128), nullable=False)
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
def __init__(self, **kwargs):
super(VSAcl, self).__init__(**kwargs)
def __repr__(self):
return '<VSAcl #%s:%r:%r>' % (self.id, self.module, self.method)
class VSProject(CRUDMixin, db.Model):
""""
项目模型
"""
__tablename__ = 'tbl_sqlalchemy_project'
# 项目访问权限 open: 公开 private: 私有
access = db.Column(db.String(20), default='open')
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
# many to many
users = db.relationship(
"VSUser",
# 默认userlist=false为一对多关系,userlist=true为多对多关系
uselist=True,
secondary=project_user_association_table,
backref="projects",
# 关联的user表记录也会删除
cascade="save-update, merge, delete")
def __init__(self, **kwargs):
super(VSProject, self).__init__(**kwargs)
class Article(db.Model):
__tablename__ = 'articles'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(250))
link = db.Column(db.String(250))
pub_date = db.Column(db.DateTime)
desc = db.Column(db.Text)
was_published = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.now)
class Media(db.Model):
__tablename__ = "media"
id = db.Column(db.Integer, primary_key=True)
vid = db.Column(db.Boolean())
audio = db.Column(db.Boolean())
img = db.Column(db.Boolean())
used = db.Column(db.Boolean())
name = db.Column(db.String(50))
def __init__(self,
vid=False,
audio=False,
img=False,
used=False,
name=" "):
self.vid = vid
self.audio = audio
self.img = img
self.used = used
self.name = name
class User(UserMixin, SurrogatePK, Model):
"""A user of the app."""
__tablename__ = "users"
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(80), unique=True, nullable=False)
#: The hashed password
password = Column(db.LargeBinary(128), nullable=True)
created_at = Column(db.DateTime,
nullable=False,
default=dt.datetime.utcnow)
first_name = Column(db.String(30), nullable=True)
last_name = Column(db.String(30), nullable=True)
active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
def __init__(self, username, email, password=None, **kwargs):
"""Create instance."""
db.Model.__init__(self, username=username, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password):
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value):
"""Check password."""
return bcrypt.check_password_hash(self.password, value)
@property
def full_name(self):
"""Full user name."""
return f"{self.first_name} {self.last_name}"
def __repr__(self):
"""Represent instance as a unique string."""
return f"<User({self.username!r})>"
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 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 VSUser(CRUDMixin, db.Model):
""""
账户模型
"""
__tablename__ = 'tbl_sqlalchemy_user'
account = db.Column(db.String(56), nullable=False, unique=True)
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
active = db.Column(db.Boolean(), default=True)
def __init__(self, **kwargs):
super(VSUser, self).__init__(**kwargs)
class Page(db.Model):
__tablename__ = 'pages'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(64))
is_active = db.Column(db.Boolean(), default=True, unique=False)
slug = db.Column(db.String(220))
seo_title = db.Column(db.String(85))
seo_desc = db.Column(db.String(180))
seo_keywords = db.Column(db.String(200))
text = db.Column(db.UnicodeText)
desc = db.Column(db.UnicodeText)
def __repr__(self):
return self.name
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))
current_login_ip = db.Column(db.String(63))
login_count = db.Column(db.Integer)
groups = db.relationship('Group',
secondary=groups_users,
backref=db.backref('users', lazy='dynamic'))
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<User %r>' % self.username
class User(db.Model, UserMixin):
"""
Модель пользователей
"""
__tablename__ = 'users'
id = db.Column(db.BigInteger,
primary_key=True,
nullable=False,
autoincrement=True,
comment='ID пользователя')
name = db.Column(db.String(255),
nullable=False,
comment='Имя пользователя')
phone = db.Column(db.String(255),
nullable=False,
comment='Телефон пользователя')
email = db.Column(db.String(255),
nullable=False,
unique=True,
comment='Email пользователя')
password = db.Column(db.String(255),
nullable=False,
comment='Пароль пользователя')
created_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.now(),
comment='Дата создания')
updated_at = db.Column(db.DateTime(),
nullable=False,
default=datetime.now(),
comment='Дата обновления')
confirmed = db.Column(db.Boolean(), default=False, comment='Подтвержден?')
def __repr__(self):
return '<User %r>' % self.name
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
last_login_at = db.Column(db.DateTime())
current_login_at = db.Column(db.DateTime())
last_login_ip = db.Column(db.String(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer)
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary='roles_users',
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '%r %r' % (self.username, self.email)
def get_setup(self):
return dict(key=self.id,
username=self.username,
email=self.email,
admin=self.is_admin())
def change_admin(self):
admin = Role.query.filter(Role.name == 'admin').first()
if admin in self.roles:
self.roles.remove(admin)
else:
self.roles.append(admin)
def is_admin(self):
roles = [each.name for each in self.roles]
if 'admin' in roles:
return True
return False
class User(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
username = db.Column(db.String(255), unique=True, index=True)
password_hash = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
name = db.Column(db.String(64))
location = db.Column(db.String(64))
member_since = db.Column(db.DateTime(), default=datetime.utcnow)
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
avatar_hash = db.Column(db.String(32))
roles = db.relationship('Role',
secondary='roles_users',
backref=db.backref('users', lazy='dynamic'))
posts = db.relationship('Post', backref='author', lazy='dynamic')
img = db.relationship('StorageImg', backref='author', lazy='dynamic')
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
if self.email is not None and self.avatar_hash is None:
self.avatar_hash = self.gravatar_hash()
def __repr__(self):
return 'id-{}, username-{}'.format(self.id, self.username)
@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)
def generate_confirmation_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'confirm': self.id}).decode('utf-8')
def confirm(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
if data.get('confirm') != self.id:
return False
self.confirmed_at = datetime.utcnow()
db.session.add(self)
return True
def generate_reset_token(self, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({'reset': self.id}).decode('utf-8')
@staticmethod
def reset_password(token, new_password):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
user = User.query.get(data.get('reset'))
if user is None:
return False
user.password = new_password
db.session.add(user)
return True
def gravatar_hash(self):
return hashlib.md5(self.email.lower().encode('utf-8')).hexdigest()
def gravatar(self, size=100, default='identicon', rating='g'):
url = 'https://secure.gravatar.com/avatar'
hash = self.avatar_hash or self.gravatar_hash()
return '{url}/{hash}?s={size}&d={default}&r={rating}'.\
format(url=url, hash=hash, size=size, default=default, rating=rating)
def generate_email_change_token(self, new_email, expiration=3600):
s = Serializer(current_app.config['SECRET_KEY'], expiration)
return s.dumps({
'change_email': self.id,
'new_email': new_email
}).decode('utf-8')
def change_email(self, token):
s = Serializer(current_app.config['SECRET_KEY'])
try:
data = s.loads(token.encode('utf-8'))
except:
return False
if data.get('change_email') != self.id:
return False
new_email = data.get('new_email')
if new_email is None:
return False
if self.query.filter_by(email=new_email).first() is not None:
return False
self.email = new_email
self.avatar_hash = self.gravatar_hash()
db.session.add(self)
return True
def is_administrator(self):
for r in self.roles:
if str(r) == 'admin':
return True
return False
def is_writer(sefl):
for r in sefl.roles:
if str(r) == 'post':
return True
return False
def __str__(sefl):
return '{}'.format(sefl.username)
class User(UserMixin, SurrogatePK, Model):
"""A user of the app."""
__tablename__ = 'users'
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(80), unique=True, nullable=False)
#: The hashed password
password = Column(db.LargeBinary(128), nullable=True)
first_name = Column(db.String(30), nullable=True)
last_name = Column(db.String(30), nullable=True)
active = Column(db.Boolean(), default=False)
is_admin = Column(db.Boolean(), default=False)
email_confirmed = Column(db.Boolean(), nullable=True, default=False)
email_confirmed_at = Column(db.DateTime(timezone=True), nullable=True)
locale = db.Column(db.String(length=2), default='en')
created_at = Column(db.DateTime(timezone=True),
nullable=False,
default=maya.now().datetime)
last_seen = db.Column(db.DateTime(timezone=True))
last_message_read_time = db.Column(db.DateTime(timezone=True))
notifications = db.relationship('Notification',
backref='user',
lazy='dynamic')
tasks = db.relationship('Task', backref='user', lazy='dynamic')
messages = db.relationship('Message',
back_populates='user',
lazy='dynamic')
def __init__(self,
username: str,
email: str,
password: str = None,
**kwargs) -> None:
"""Create instance."""
db.Model.__init__(self, username=username, email=email, **kwargs)
if password:
self.set_password(password)
else:
self.password = None
def set_password(self, password: str) -> None:
"""Set password."""
self.password = bcrypt.generate_password_hash(password)
def check_password(self, value: str) -> bool:
"""Check password."""
is_good_password: bool = bcrypt.check_password_hash(
self.password, value)
return is_good_password
@property
def full_name(self) -> str:
"""Full user name."""
return '{0} {1}'.format(self.first_name, self.last_name)
def __repr__(self) -> str:
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
def get_reset_password_token(self, expires_in: int = 600) -> str:
token: str = jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256')
return token
@staticmethod
def verify_reset_password_token(token) -> Union['User', None]:
try:
user_id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['reset_password']
except InvalidTokenError:
return None
user: User = User.query.get(user_id)
return user
def confirm_email(self) -> None:
self.email_confirmed = True
self.email_confirmed_at = maya.now().datetime()
def get_confirmation_token(self) -> str:
token: str = jwt.encode({'confirm_email': self.id},
current_app.config['SECRET_KEY'],
algorithm='HS256')
return token
@staticmethod
def verify_confirmation_token(token: str) -> Union['User', None]:
try:
user_id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithms=['HS256'])['confirm_email']
except PyJWTError:
return None
user: User = User.query.get(user_id)
return user
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def add_notification(self, name, data):
notification = self.notifications.filter_by(user=self,
name=name).first()
if notification:
notification.update(payload=data)
else:
notification = Notification.create(name=name,
payload=data,
user=self)
return notification
def launch_task(self, name, description, *args, **kwargs):
rq_job = current_app.task_queue.enqueue('app.task.tasks.' + name,
*args, **kwargs)
task = Task(id=rq_job.get_id(),
name=name,
description=description,
user=self)
db.session.add(task)
return task
def get_tasks_in_progress(self):
return Task.query.filter_by(user=self, complete=False).all()
def get_task_in_progress(self, name):
return Task.query.filter_by(user=self, name=name,
complete=False).first()
def add_message(self, contents):
message = Message.create(user=self, body=contents)
return message
def new_messages(self):
last_read_time = self.last_message_read_time or maya.when(
'1900-1-1').datetime()
return Message.query.filter_by(user=self).filter(
Message.timestamp > last_read_time).count()
class User(CRUDMixin, UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), nullable=False, unique=True)
email = db.Column(db.String(128), nullable=False, unique=True)
pw_hash = db.Column(db.Binary(60))
created_ts = db.Column(
db.DateTime(timezone=True),
server_default=db.func.current_timestamp(),
)
updated_ts = db.Column(
db.DateTime(timezone=True),
onupdate=db.func.current_timestamp(),
)
remote_addr = db.Column(db.String(20))
active = db.Column(db.Boolean())
is_admin = db.Column(db.Boolean())
def __init__(self,
username,
email,
remote_addr,
password=None,
active=False,
is_admin=False):
self.username = username
self.email = email
if password is not None:
self.set_password(password)
else:
self.pw_hash = None
self.created_ts = datetime.datetime.now()
self.remote_addr = remote_addr
self.active = active
self.is_admin = is_admin
def __repr__(self):
return '<User %s>' % self.username
def set_password(self, password):
self.pw_hash = bcrypt.generate_password_hash(password, 10)
def check_password(self, password):
return bcrypt.check_password_hash(self.pw_hash, password)
@classmethod
def stats(self):
active_users = cache.get('active_users')
if not active_users:
active_users = self.query.filter_by(active=True).count()
cache.set('active_users', active_users)
inactive_users = cache.get('inactive_users')
if not inactive_users:
inactive_users = self.query.filter_by(active=False).count()
cache.set('inactive_users', inactive_users)
return {
'all': active_users + inactive_users,
'active': active_users,
'inactive': inactive_users
}
@classmethod
def getUserInfo(self, user_id):
user = self.query.filter_by(id=user_id).first_or_404()
return user
@classmethod
def getUserID(self, email):
try:
user = self.query.filter_by(email=email).one()
return user.id
except:
return None
class User(Model, SurrogatePK, UserMixin, ModelCacheMixin):
"""user model"""
__tablename__ = 'users'
username = db.Column(db.String(32),
unique=True,
index=True,
nullable=False) # username
password_hash = db.Column(db.String(128))
email = db.Column(db.String(128), default="") # Email
phone = db.Column(db.String(32), default="")
# sex = db.Column(
# db.Enum(SexEnum,
# values_callable=enum_value_cb
# ), default=SexEnum.empty)
sex = db.Column(db.String(8), default="")
active = db.Column(db.Boolean(), default=True)
nickname = db.Column(db.String(32), default="") # 昵称
avatar_hash = db.Column(db.String(32)) # 头像hash值
current_login_datetime = db.Column(db.DateTime, default=None) # 本次登录时间
last_login_datetime = db.Column(db.DateTime, default=None) # 上次登录时间
last_login_ip = db.Column(db.String(32), default="") # 上次登录IP
current_login_ip = db.Column(db.String(32), default="") # 当前登录IP
create_datetime = db.Column(db.DateTime,
nullable=False,
default=dt.datetime.now) # 创建（注册）时间
api_key = db.Column(db.String(128))
roles = db.relationship('Role',
secondary='user_roles',
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return '<%s %r>'.format(self.__class__.__name__, self.username)
@property
def password(self):
return self.password_hash
@password.setter
def password(self, password):
"""设置密码hash
使用了 flask-user 则不能进行加密， 因为 flask-user 设置密码之前已经加密了
flask-user usage:
```
user.password = User.gen_password("password")
```
"""
# for flask-user
self.password_hash = password
# for werkzeug
# self.password_hash = generate_password_hash(password)
@staticmethod
def gen_password(password):
"""
为非注册的用户生成密码hash
"""
from app import user_manager
return 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_hash)
# for werkzeug
# return check_password_hash(self.password_hash, 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, 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
if request:
self.current_login_ip = request.remote_addr
db.session.add(self)
if commit:
db.session.commit()
def to_dict(self, has_token=True):
data = {
"id": self.id,
"username": self.username,
"password_hash": self.password_hash,
"email": self.email,
"phone": self.phone,
# "sex": repr(self.sex),
"sex": self.sex,
"active": self.active,
"nickname": self.nickname,
"create_datetime": self.create_datetime,
"avatar": self.gravatar(),
"roles": [role.name for role in self.roles],
}
if has_token:
data.update({"token": self.generate_token()})
return data
def generate_token(self, expiration=60 * 60):
"""生成access token"""
s = Serializer(current_app.config["SECRET_KEY"], expiration)
# 把 id、username、roles 放进 token
token = s.dumps({
"id": self.id,
"username": self.username,
"roles": [role.name for role in self.roles]
}).decode()
return token
@staticmethod
def verify_token(token):
"""验证token
"""
s = Serializer(current_app.config["SECRET_KEY"])
try:
data = s.loads(token)
except SignatureExpired:
raise TokenTimeOutException
except Exception:
return None
return data
def gen_apikey(self):
self.api_key = gen_salt(128)
return self.api_key
class VSProject(CRUDMixin, db.Model):
""""
项目模型
"""
__tablename__ = 'tbl_vsppm_project'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 名称
name = db.Column(db.String(90), nullable=False, unique=True)
# 开始日期
begin = db.Column(db.Date())
# 结束日期
end = db.Column(db.Date())
# 项目类型
type = db.Column(db.String(20), default='sprint')
# 历时天数
days = db.Column(db.Integer)
# 状态
status = db.Column(db.String(30), default='wait')
# 描述
desc = db.Column(db.String(256))
# 公司id
company_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_company.id'))
# 部门id
department_id = db.Column(db.Integer,
db.ForeignKey('tbl_vsppm_department.id'))
# 项目开启者
opened_by_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id'))
# 项目开启日期
opened_datetime = db.Column(db.DateTime(timezone=True))
# 项目关闭者
closed_by_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id'))
# 项目关闭日期
closed_datetime = db.Column(db.DateTime(timezone=True))
# 项目取消者
canceled_by_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id'))
# 项目取消日期
canceled_datetime = db.Column(db.DateTime(timezone=True))
# 项目管理员id
manager_admin_id = db.Column(db.Integer,
db.ForeignKey('tbl_vsppm_user.id'))
# 测试管理员id
test_admin_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_user.id'))
# 发布管理员id
release_admin_id = db.Column(db.Integer,
db.ForeignKey('tbl_vsppm_user.id'))
# 需求管理员id
require_admin_id = db.Column(db.Integer,
db.ForeignKey('tbl_vsppm_user.id'))
access = db.Column(db.String(20), default='open')
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
# http://docs.sqlalchemy.org/en/rel_0_9/orm/join_conditions.html#handling-multiple-join-paths
opened_by = db.relationship('VSUser', foreign_keys=[opened_by_id])
closed_by = db.relationship('VSUser', foreign_keys=[closed_by_id])
canceled_by = db.relationship('VSUser', foreign_keys=[canceled_by_id])
manager_admin = db.relationship('VSUser', foreign_keys=[manager_admin_id])
test_admin = db.relationship('VSUser', foreign_keys=[test_admin_id])
release_admin = db.relationship('VSUser', foreign_keys=[release_admin_id])
require_admin = db.relationship('VSUser', foreign_keys=[require_admin_id])
# 项目成员
members = db.relationship('VSUser',
secondary=vsppm_project_member,
backref=db.backref('projects'))
company = db.relationship('VSCompany', backref=db.backref('projects'))
department = db.relationship('VSDepartment',
backref=db.backref('projects'))
def __init__(self, **kwargs):
super(VSProject, self).__init__(**kwargs)
def __repr__(self):
return '<VSProject #%s:%r>' % (self.id, self.name)
class VSUser(CRUDMixin, db.Model):
""""
账户模型
"""
__tablename__ = 'tbl_vsppm_user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# 账户名称
username = db.Column(db.String(20), nullable=False, unique=True)
# 邮箱
email = db.Column(db.String(128), nullable=False, unique=True)
# 手机号码
mobile = db.Column(db.String(11))
# 密码
password = db.Column(db.String(60), nullable=False)
# 真实姓名
real_name = db.Column(db.String(100), nullable=False)
# 头像
avatar = db.Column(db.String(256))
# 公司id
company_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_company.id'))
# 部门id
department_id = db.Column(db.Integer,
db.ForeignKey('tbl_vsppm_department.id'))
# 角色id
role_id = db.Column(db.Integer, db.ForeignKey('tbl_vsppm_role.id'))
# 创建时间
created_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 更新时间
updated_ts = db.Column(db.DateTime(timezone=True),
default=datetime.datetime.utcnow)
# 激活状态
active = db.Column(db.Boolean(), default=True)
# 第一个参数为你要关系到哪个模型的名字,也就是类名
# db.backref('users')第一个参数users为要反向引用的名字,也可以用其他名字
# 正向引用是VSUser访问VSCompany,反向引用是从VSCompany访问表VSUser
company = db.relationship('VSCompany', backref=db.backref('users'))
# 第一个参数为你要关系到哪个模型的名字,也就是类名
# db.backref('users')第一个参数users为要反向引用的名字,也可以用其他名字
# 正向引用是VSUser访问VSDepartment,反向引用是从VSDepartment访问表VSUser
department = db.relationship('VSDepartment', backref=db.backref('users'))
# 让VSUser和VSRole产生关联
# 因为VSUser和VSRole表中间还有一个vsppm_user_role表,所以添加secondary
# 正向引用是VSUser访问VSRole,反向引用是从VSRole访问表VSUser
role = db.relationship('VSRole', backref=db.backref('users'))
def __init__(self, password, **kwargs):
super(VSUser, self).__init__(**kwargs)
self.set_password(password)
def __repr__(self):
return '<VSUser #%s:%r>' % (self.id, self.username)
def set_password(self, password):
hash_ = bcrypt.generate_password_hash(password, 10).decode('utf-8')
self.password = hash_
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
def generate_token(self):
""""
:return
bool: function exec result
str: function exec data
"""
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=0, seconds=36000),
'iat':
datetime.datetime.utcnow(),
'iss':
'ken',
'data': {
'username': self.username,
'password': self.password
}
}
return JwtEncoder().encoder(payload=payload)
class User(db.Model, UserMixin):
"""
Define the User class for table 'auth_user' with the following columns:
guid varchar(64), unique identifier for the 'auth_type'
auth_type user_auth_type, authentication type of user (NYC.ID or a federated identity provider)
first_name varchar(64), first name of user
middle_initial varchar(1), middle initial of user (single character)
last_name varchar(64), last name of user
email varchar(254), email address of user
phone varchar(25), phone number of variable format
email_validated boolean, has user has validated its email address?
terms_of_use_accepted boolean, has the user accepted the latest terms of use?
agency_ein varchar(3), foreign key to 'agency' table
is_poc boolean, is the user an agency point of contact?
is_admin boolean, is the user an administrator (member of DORIS library staff)?
is_super boolean, is the user an all-powerful super user?
Most fields are provided by NYC.ID Authentication Web Service SAML Assertion.
The combination of "guid" and "auth_type" must be unique and therefore
is used as a primary composite key.
"""
__tablename__ = "auth_user"
# columns
guid = db.Column(db.String(64), primary_key=True)
auth_type = db.Column(
enum_user_auth_type, primary_key=True
) # FIXME: not needed since only agency users can login
first_name = db.Column(db.String(64), nullable=False)
middle_initial = db.Column(db.String(1))
last_name = db.Column(db.String(64), nullable=False)
email = db.Column(db.String(254), nullable=False, unique=True)
phone = db.Column(db.String(25))
email_validated = db.Column(db.Boolean(), nullable=False, default=False)
terms_of_use_accepted = db.Column(db.Boolean(),
nullable=False,
default=False)
is_poc = db.Column(db.Boolean(), nullable=False, default=False)
is_admin = db.Column(db.Boolean(), nullable=False, default=False)
is_super = db.Column(db.Boolean(), nullable=False, default=False)
# relationships
registrations = db.relationship(
"Registration",
primaryjoin="and_(User.guid == Registration.user_guid, "
"User.auth_type == Registration.user_auth_type)",
back_populates="registrant",
lazy="dynamic")
submissions = db.relationship(
"Document",
primaryjoin="and_(User.guid == Document.user_guid, "
"User.auth_type == Document.user_auth_type)",
back_populates="submitter",
lazy="dynamic")
events = db.relationship("_Event",
primaryjoin="and_(User.guid == _Event.user_guid, "
"User.auth_type == _Event.user_auth_type)",
back_populates="agent",
lazy="dynamic")
def __init__(self, guid, auth_type, first_name, middle_initial, last_name,
email, email_validated, terms_of_use_accepted):
self.guid = guid
self.auth_type = auth_type
self.first_name = first_name
self.middle_initial = middle_initial
self.last_name = last_name
self.email = email
self.email_validated = email_validated
self.terms_of_use_accepted = terms_of_use_accepted
def __repr__(self):
return '<User "{}" ({}, {})>'.format(self.name, self.guid,
self.auth_type, self.name)
def get_id(self):
"""
Overrides UserMixin.get_id()
"""
return USER_ID_DELIMETER.join((self.guid, self.auth_type))
@property
def registration(self):
"""
A user's latest registration, if any.
"""
return self.registrations.join("events").order_by(
desc("timestamp")).first()
@property
def is_registered(self):
"""
Is the user's latest registration, if any, approved?
"""
return self.registration.is_approved if self.registration is not None else False
@property
def agency(self):
"""
A user's agency is determined by its latest approved registration, if any.
"""
if self.is_registered:
return self.registration.agency
@property
def name(self):
if self.middle_initial is not None:
name = "{f} {m}. {l}".format(f=self.first_name.title(),
m=self.middle_initial.upper(),
l=self.last_name.title())
else:
name = " ".join((self.first_name.title(), self.last_name.title()))
return name
