class School(db.Model):
__tablename__ = "school"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
logo = db.Column(db.String(240), nullable=False)
color = db.Column(db.String(120), nullable=False)
members = db.relationship('User')
class User(Model):
__tablename__ = 'users'
id = Column(db.Integer, primary_key=True, doc='id')
username = Column(db.String(), unique=True, nullable=False, index=True, doc='user name')
email = Column(db.String(), unique=True, nullable=False, index=True, doc='password')
password = Column(db.Binary(128), nullable=True)
inserted_at = Column(db.DateTime, nullable=False, index=True,
server_default=db.func.now(), doc='insert time')
updated_at = Column(db.DateTime, nullable=False, index=True,
server_default=db.func.now(), onupdate=db.func.now(),
doc='update time')
token: str = None
def __init__(self, username, email, password=None, **kwargs):
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)
def __repr__(self):
return f'<User({self.username!r})>'
class Test(db.Model):
"""Test data model"""
__tablename__ = '{{cookiecutter.table_prefix}}_test'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
email = db.Column(db.String(128), unique=True, index=True)
created_timestamp = db.Column(db.DateTime, server_default=func.now())
updated_timestamp = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
def __init__(self, name, email):
self.name = name
self.email = email
def to_json(self):
"""
Convert to JSON object
"""
return {
'id': self.id,
'name': self.name,
'email': self.email,
'created_timestamp': self.created_timestamp,
'updated_timestamp': self.updated_timestamp
}
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(UserMixin, db.Model):
"""User account model."""
__tablename__ = 'flasklogin-users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False, unique=False)
email = db.Column(db.String(40), unique=True, nullable=False)
password = db.Column(db.String(200),
primary_key=False,
unique=False,
nullable=False)
website = db.Column(db.String(60),
index=False,
unique=False,
nullable=True)
created_on = db.Column(db.DateTime,
index=False,
unique=False,
nullable=True)
last_login = db.Column(db.DateTime,
index=False,
unique=False,
nullable=True)
def set_password(self, password):
"""Create hashed password."""
self.password = generate_password_hash(password, method='sha256')
def check_password(self, password):
"""Check hashed password."""
return check_password_hash(self.password, password)
def __repr__(self):
return '<User {}>'.format(self.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.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, 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(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
def __repr__(self):
return '<User {}>'.format(self.username)
class User(db.Model):
__tablename__ = "users_user"
id = db.Column(UUID(), primary_key=True, default=uuid.uuid4)
email = db.Column(db.String(255), nullable=False, index=True)
is_active = db.Column(db.Boolean, nullable=False)
username = db.Column(db.String(64), index=True, nullable=False)
password = db.Column(db.String(248), nullable=False)
class Bangumi(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(160), index=True, unique=True, nullable=False)
time = db.Column(db.DateTime, default=datetime.now)
url = db.Column(db.String(160))
def __repr__(self):
return f'<{type(self).__name__} {self.name}>'
class Artist(db.Model):
id = db.Column(db.Integer, primary_key=True)
artist = db.Column(db.String(100), index=True)
about = db.Column(db.String(200))
disc_artist = db.relationship("Disc", backref="artist", lazy="dynamic")
disc_a_d = db.relationship("ArtistDisc", backref="artist", lazy="dynamic")
def __str__(self):
return f"<Artist: {self.name}>"
class ExampleUserModel(UserMixin, PkModel):
"""Example model class for a user."""
__tablename__ = "testusers"
username = Column(db.String(80), unique=True, nullable=False)
email = Column(db.String(80), unique=True, nullable=False)
def __init__(self, username, email):
"""Create instance."""
super().__init__(username=username, email=email)
class Role(db.Model, RoleMixin):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __str__(self):
return self.name
def __hash__(self):
return hash(self.name)
class User(models.BaseModel):
"""
Sample user model
"""
__tablename__ = "auth_user"
first_name = db.Column(db.String(32), nullable=False)
last_name = db.Column(db.String(32), nullable=False)
username = db.Column(db.String(32), nullable=False, unique=True)
password = db.Column(db.String(32), nullable=False)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __init__(self, username, email):
self.username = username
self.email = email
def __repr__(self):
return '<User %s>' % 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 BlogPost(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=True)
content = db.Column(db.Text, nullable=True)
author = db.Column(db.String(20), nullable=False, default='N/a')
date_posted = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
def __repr__(self):
return 'Blog post ' + str(self.id)
class User(db.Model):
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 __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class BooksRatings(db.Model):
__tablename__ = "BooksRatings"
id = db.Column(db.String(255), primary_key=True)
userid = db.Column(db.String(255))
book = db.Column(db.String(255))
bookrating = db.Column(db.String(255))
def __init__(self, userid, book, bookrating):
self.userid = userid
self.book = book
self.bookrating = bookrating
class Project(db.Model):
__tablename__ = "project"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120), nullable=False)
description = db.Column(db.Text())
goal = db.Column(db.Float)
current_amount = db.Column(db.Float)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
school_id = db.Column(db.String(120), db.ForeignKey('school.id'))
transactions = db.relationship('Transaction')
reports = db.relationship('Report')
def __repr__(self):
return '<Project %r>' % self.title
class DictItem(db.Model):
__tablename__ = 'ts_dict_item'
id = db.Column(db.Integer, primary_key=True, info='主键')
dict_code = db.Column(db.String(30, 'utf8mb4_bin'), info='字典编码')
item_code = db.Column(db.String(30, 'utf8mb4_bin'), info='项编码')
item_value = db.Column(db.String(64, 'utf8mb4_bin'), info='项值')
sort_no = db.Column(db.Integer, info='排序')
item_desc = db.Column(db.String(128, 'utf8mb4_bin'), info='描述')
is_valid = db.Column(db.String(1, 'utf8mb4_bin'), server_default=db.FetchedValue(), info='是否有效 Y启用 N不启用')
org_code = db.Column(db.String(30, 'utf8mb4_bin'), nullable=False, info='机构代码')
create_by = db.Column(db.String(30, 'utf8mb4_bin'), info='创建人')
create_time = db.Column(db.DateTime, server_default=db.FetchedValue(), info='创建时间')
update_by = db.Column(db.String(30, 'utf8mb4_bin'), info='更新人')
update_time = db.Column(db.DateTime, server_default=db.FetchedValue(), info='更新时间')
revision = db.Column(db.Integer, server_default=db.FetchedValue(), info='版本号')
__table_args__ = (
db.UniqueConstraint('dict_code', 'item_code', name='dict_item_code_uk'),
)
def __init__(self, **kwargs):
super(DictItem, self).__init__(**kwargs)
def __repr__(self):
return "<DictItem %s>" % self.item_name
class Admin(db.Model, UserMixin):
__tablename__ = 'admin'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
def __init__(self, email, username, password):
self.email = email
self.username = username
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model):
"""Basic user model
"""
id = db.Column(db.Integer, primary_key=True)
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(255), nullable=False)
active = db.Column(db.Boolean, default=True)
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.password = pwd_context.hash(self.password)
def __repr__(self):
return "<User %s>" % self.username
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
def __init__(self, name, price):
self.name = name
self.price = price
def json(self):
return {'name': self.name, 'price': self.price}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey("stores.id"))
store = db.relationship('StoreModel')
def __init__(self, name, price,store_id):
self.name = name
self.price = price
self.store_id = store_id
def json(self):
return {'name': self.name, 'price': self.price}
@classmethod
def find_by_name(cls, name):
# SELECT * FROM items WHERE name=name LIMIT 1
return ItemModel.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(64), unique=True, index=True)
username = db.Column(db.String(64), unique=True, index=True)
password_hash = db.Column(db.String(128))
def __init__(self, username, password, company):
self.username = username
self.password = password
self.company = company
@password.setter
def password(self, password):
self.password_hash = encrypt_password(password)
class StoreModel(db.Model):
__tablename__ = 'stores'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
items = db.relationship('ItemModel', lazy='dynamic')
def __init__(self, name, price):
self.name = name
self.price = price
def json(self):
return {'name': self.name, 'items': [item.json() for item in self.items.all()]}
@classmethod
def find_by_name(cls, name):
return cls.query.filter_by(name=name).first()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
class UserModel(db.Model):
"""
User Model
"""
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128), nullable=False, unique=True)
name = db.Column(db.String(128), nullable=False)
password = db.Column(db.String(128), nullable=False)
is_active = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime, server_default=db.func.now())
updated_at = db.Column(
db.DateTime,
server_default=db.func.now(),
server_onupdate=db.func.now()
)
def __init__(self, data):
self.email = data.get('email')
self.name = data.get('name')
self.password = self.__generate_hash(data.get('password'))
def __repr__(self):
return'<id {}>'.format(self.id)
def save(self):
db.session.add(self)
db.session.commit()
def update(self, data):
for key, item in data.items():
if key == 'password':
item = self.__generate_hash(item)
setattr(self, key, item)
self.updated_at = datetime.datetime.utcnow()
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def __generate_hash(self, password):
return bcrypt.generate_password_hash(password, rounds=10).decode("utf-8")
def check_hash(self, password):
return bcrypt.check_password_hash(self.password, password)
class Message(db.Model):
__tablename__ = "message"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
is_sender = db.Column(db.Boolean, nullable=False)
other_id = db.Column(db.Integer, nullable=False)
time = db.Column(db.DateTime, nullable=False)
body = db.Column(db.String(120), nullable=False)
