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(UserMixin, PkModel):
"""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)
_password = Column("password", 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)
@hybrid_property
def password(self):
"""Hashed password."""
return self._password
@password.setter
def password(self, value):
"""Set password."""
self._password = bcrypt.generate_password_hash(value)
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)
name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
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(100))
current_login_ip = db.Column(db.String(100))
login_count = db.Column(db.Integer())
roles = db.relationship(
'Role',
secondary=role_users,
backref=db.backref('users', lazy='dynamic')
)
def get_security_payload(self):
return {
'id': self.id,
'name': self.name,
'email': self.email,
}
def __str__(self):
return self.email
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.Binary(128), nullable=True)
created_at = Column(db.DateTime, nullable=False, default=dt.datetime.utcnow)
active = 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 '{0} {1}'.format(self.first_name, self.last_name)
def __repr__(self):
"""Represent instance as a unique string."""
return '<User({username!r})>'.format(username=self.username)
class User(db.Model, SerializerMixin):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128), unique=True)
password = db.Column(db.String(512))
first_name = db.Column(db.String(32))
last_name = db.Column(db.String(64), nullable=True)
email = db.Column(db.String(128), unique=True)
is_active = db.Column(db.Boolean(), default=True)
created_at = db.Column(
db.DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
)
class User(UserMixin, PkModel):
"""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."""
super().__init__(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(UserMixin, CRUDMixin, db.Model):
__tablename__ = 'users'
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String, nullable=False) # The hashed password
created_at = db.Column(db.DateTime(), nullable=False)
first_name = db.Column(db.String(30), nullable=True)
last_name = db.Column(db.String(30), nullable=True)
active = db.Column(db.Boolean())
is_admin = db.Column(db.Boolean())
def __init__(self, username=None, email=None, password=None,
first_name=None, last_name=None,
active=False, is_admin=False):
self.username = username
self.email = email
if password:
self.set_password(password)
self.active = active
self.is_admin = is_admin
self.created_at = dt.datetime.utcnow()
self.first_name = first_name
self.last_name = last_name
def set_password(self, password):
self.password = bcrypt.generate_password_hash(password)
def check_password(self, password):
return bcrypt.check_password_hash(self.password, password)
@property
def full_name(self):
return "{0} {1}".format(self.first_name, self.last_name)
def __repr__(self):
return '<User "{username}">'.format(username=self.username)
class Demo(SurrogatePK, Model):
"""
用户表
"""
__tablename__ = "demo"
field_1 = Column(db.String(512), nullable=False, unique=True, comment="字段1")
field_2 = Column(db.String(512), nullable=False, unique=True, comment="字段2")
active = Column(db.Boolean(), default=False, nullable=False, comment="是否有效")
created = Column(db.DateTime, nullable=False, default=datetime.now, comment="创建时间")
updated = Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now, comment="更新时间")
# 状态枚举
ERROR = -1
WAIT_RUN = 0
RUNNING = 1
SUCCEED = 2
FAIL = 3
# 默认倒序
__mapper_args__ = {"order_by": created.desc()}
def __repr__(self):
return str(f"user_id={self.user_id} user_name={self.user_name}")
class Setting(OurMixin, db.Model):
__tablename__ = 'settings'
id = db.Column(db.VARCHAR(length=36), primary_key=True)
name = db.Column(db.VARCHAR(length=128), nullable=False)
section = db.Column(db.VARCHAR(length=128), nullable=False,
default='main', server_default='main')
human_name = db.Column(db.TEXT(), nullable=True,
default='', server_default='')
value = db.Column(db.TEXT(), nullable=True, default='', server_default='')
vartype = db.Column(db.Enum('int', 'str', 'bool', 'float', 'list'), nullable=False)
allowed = db.Column(db.Text, nullable=True)
system = db.Column(db.Boolean(), default=False, server_default='0')
description = db.Column(db.TEXT(), nullable=True,
default='', server_default='')
@property
def title(self):
if self.human_name:
return self.human_name
else:
return self.name.replace('-', ' ').title()
@property
def choices(self):
return json.loads(self.allowed)
@property
def val(self):
"""
Gets the value as the proper type.
"""
if self.vartype == 'list':
return list(literal_eval(self.value))
else:
return __builtins__[self.vartype](self.value)
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.String(128), nullable=True)
created_at = Column(db.DateTime, nullable=False,
default=datetime.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 __str__(self):
"""String representation of the user. Shows the users email address."""
return self.email
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)
def get_id(self):
"""Return the email address to satisfy Flask-Login's requirements"""
return self.id
@property
def full_name(self):
"""Full user name."""
return "{0} {1}".format(self.first_name, self.last_name)
@property
def is_active(self):
"""Active or non active user (required by flask-login)"""
return self.active
@property
def is_authenticated(self):
"""Return True if the user is authenticated."""
if isinstance(self, AnonymousUserMixin):
return False
else:
return True
@property
def is_anonymous(self):
"""False, as anonymous users aren't supported."""
return False
class User(UserMixin, OurMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.VARCHAR(length=36), primary_key=True)
username = db.Column(db.String())
firstname = db.Column(db.String(32))
lastname = db.Column(db.String(32))
password = db.Column(db.String())
active = db.Column(db.Boolean(), default=True, server_default='1')
_roles = db.relationship(
'Role', secondary=user_role_table, backref='users')
type = db.Column(db.String(50))
roles = association_proxy('_roles', 'name', creator=_role_find_or_create)
def __init__(self, **kwargs):
# A bit of duplication here keeps the kwargs being
# set but encrypts the password.
for k, v in kwargs.items():
if k != 'password':
setattr(self, k, v)
else:
self.set_password(v)
OurMixin.__init__(self)
UserMixin.__init__(self)
def validate(self):
return_value = success()
not_unique = User.filter(User.username == self.username).count()
if not_unique:
return_value['success'] = False
return_value['messages'].append("That user exists already.")
if not self.email:
return_value['success'] = False
return_value['messages'].append("An email address is required to create a user.")
return return_value
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, value):
return check_password_hash(self.password, value)
def is_authenticated(self):
if isinstance(self, AnonymousUserMixin):
return False
else:
return True
def is_active(self):
return self.active
def is_anonymous(self):
if isinstance(self, AnonymousUserMixin):
return True
else:
return False
def add_roles(self, *roles):
self.roles.extend([role for role in roles if role not in self.roles])
def remove_roles(self, *roles):
self.roles = [role for role in self.roles if role not in roles]
def has_role(self, role):
return True if role in self.roles else False
def get_id(self):
return self.id
def __repr__(self):
return '<User {}:{}>'.format(self.id, self.username)
class User(db.Model, UserMixin):
""" 用户模型 """
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=True)
email = db.Column(db.String(80), unique=True, nullable=True)
phone = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(80), nullable=False)
active = db.Column(db.Boolean, default=True)
first_name = db.Column(db.String(30), nullable=True)
last_name = db.Column(db.String(30), nullable=True)
is_admin = db.Column(db.Boolean(), default=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
def __init__(self, **kwargs):
""" 创建实例 """
super(User, self).__init__(**kwargs)
if self.password:
self.set_password(self.password)
else:
self.password = None
def __repr__(self):
""" 将实例表示为唯一字符串 """
# return "<User %s>" % self.username
# return '<User {}>'.format(self.username)
return '<User {username!r}>'.format(username=self.username)
def __unicode__(self):
return self.username
@property
def is_active(self):
""" 是否激活 """
return True
@property
def is_authenticated(self):
""" 是否已登录认证 """
# if isinstance(self, AnonymousUserMixin):
# return False
# else:
# return True
return False
@property
def is_anonymous(self):
""" 是否游客 """
# if isinstance(self, AnonymousUserMixin):
# return True
# else:
# return False
return False
def get_id(self):
""" 返回一个能够识别唯一用户的ID """
# return unicode(self.id)
return str(self.id)
def set_password(self, password):
""" 设置密码 """
# 在python3中，你需要使用在generate_password_hash()上使用decode('utf-8')方法
self.password = bcrypt.generate_password_hash(password).decode('utf-8')
def check_password(self, password):
""" 验证密码 """
return bcrypt.check_password_hash(self.password, password)
