class Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
role_name = db.Column(db.String(256, convert_unicode=True), nullable=True)
users = relationship(
"User",
secondary=user_role_table,
back_populates="roles")
class Action(db.Model):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
__tablename__ = 'action'
name = db.Column(db.String(256, collation='utf8mb4_general_ci', convert_unicode=True), primary_key=True)
description = db.Column(db.Text(collation='utf8mb4_general_ci', convert_unicode=True), nullable=True)
created_at = db.Column(db.TIMESTAMP, default=datetime.now)
class HistoryWrongPass(db.Model):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
__tablename__ = 'history_wrong_password'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id',
ondelete='CASCADE'))
created_at = db.Column(db.TIMESTAMP, default=datetime.now)
class SocialLogin(db.Model):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
__tablename__ = 'social_login'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
social_id = db.Column(db.String(50), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='CASCADE'))
created_at = db.Column(db.TIMESTAMP, default=datetime.now)
social_name = db.Column(db.Enum(SocialName), nullable=False)
class UserAction(db.Model):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
__tablename__ = 'user_action'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
action_name = db.Column(db.String(256, convert_unicode=True),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id',
ondelete='CASCADE'))
created_at = db.Column(db.TIMESTAMP, default=datetime.now)
class RevokedToken(db.Model):
__tablename__ = 'revoked_token'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
jti = db.Column(db.String(255, convert_unicode=True), nullable=False)
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
class UserBookAction(db.Model):
__tablename__ = 'book_log'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id',
ondelete='CASCADE'))
book_id = db.Column(db.Integer, db.ForeignKey('book.id',
ondelete='CASCADE'))
log_name = db.Column(db.Enum(LogAction),
nullable=False,
default=LogAction.UPDATED)
created_at = db.Column(db.TIMESTAMP,
server_default=func.now(),
default=func.now(),
nullable=False)
book = relationship("Book", back_populates="users")
user = relationship("User", back_populates="books")
class Book(db.Model, TimestampMixin):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
__tablename__ = 'book'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255, convert_unicode=True),
nullable=False,
unique=True)
author = db.Column(db.Text(convert_unicode=True), nullable=True)
description = db.Column(db.Text(convert_unicode=True), nullable=True)
is_active = db.Column(db.Boolean, default=True)
star = db.Column(db.SmallInteger, default=5)
price = db.Column(db.Float, nullable=False)
quantity_in_stock = db.Column(db.Integer, nullable=False)
quantity_sold = db.Column(db.Integer, default=0)
users = relationship("UserBookAction", back_populates="book")
categories = relationship("Category",
secondary=category_book_table,
back_populates="books")
def update_attr(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
self.updated_at = datetime.now()
def to_dict(self):
from ducttapp.models import User, UserBookAction
user_created = db.session.query(User).filter(
self.id == UserBookAction.book_id).filter(
UserBookAction.log_name == LogAction.CREATED).filter(
User.id == UserBookAction.user_id).first().username or ""
return {
'id': self.id,
'name': self.name,
'description': self.description,
'is_active': self.is_active,
'created_at': self.created_at,
'updated_at': self.updated_at,
'quantity_in_stock': self.quantity_in_stock,
'price': self.price,
'user_created': user_created,
'categories': [x.id for x in self.categories]
}
class Category(db.Model, TimestampMixin):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255, convert_unicode=True), nullable=False, unique=True)
description = db.Column(db.Text(convert_unicode=True), nullable=True)
is_active = db.Column(db.Boolean, default=True)
users = relationship("UserCategoryAction", back_populates="category", cascade="all, delete-orphan")
books = relationship(
"Book",
secondary=category_book_table,
back_populates="categories")
def update_attr(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
self.updated_at = datetime.now()
def to_dict(self):
from ducttapp.models import User, UserCategoryAction
return {
'id': self.id,
'name': self.name,
'description': self.description,
'is_active': self.is_active,
'created_at': self.created_at,
'updated_at': self.updated_at,
'user_created': db.session.query(
User
).filter(
self.id == UserCategoryAction.category_id
).filter(
UserCategoryAction.log_name == LogAction.CREATED
).filter(
User.id == UserCategoryAction.user_id
).first().username or ""
}
class UserCategoryAction(db.Model):
__tablename__ = 'category_log'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='CASCADE'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id', ondelete='CASCADE'))
log_name = db.Column(db.Enum(LogAction), nullable=False, default=LogAction.UPDATED)
created_at = db.Column(db.TIMESTAMP, server_default=func.now(), default=func.now(), nullable=False)
category = relationship("Category", back_populates="users")
user = relationship("User", back_populates="categories")
def to_dict(self):
from ducttapp.models import User
return {
'id': self.id,
'log_name': self.log_name.value,
'created_at': self.created_at,
'username': db.session.query(
User
).filter(
self.user_id == User.id
).first().username or ""
}
class Signup_Request(db.Model):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
self.expired_time = (datetime.now() + timedelta(minutes=30))
__tablename__ = 'signup_request'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128, convert_unicode=True),
nullable=False,
unique=True)
email = db.Column(db.String(128, convert_unicode=True),
nullable=False,
unique=True)
password_hash = db.Column(db.Text(convert_unicode=True), nullable=False)
is_admin = db.Column(db.Boolean, default=False)
expired_time = db.Column(db.TIMESTAMP,
default=(datetime.now() + timedelta(minutes=30)))
user_token_confirm = db.Column(db.Text(), nullable=False)
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = bcrypt.generate_password_hash(password).decode(
'utf-8')
def token_verify_expired(self):
return self.expired_time < datetime.now()
def to_dict(self):
return {
"username": self.username,
"email": self.email,
"user_token_confirm": self.user_token_confirm
}
from ducttapp.models import db
from .base import TimestampMixin
from sqlalchemy.orm import relationship
from sqlalchemy import func
import enum
from datetime import datetime
category_book_table = db.Table(
'category_book',
db.Model.metadata,
db.Column('category_id', db.Integer, db.ForeignKey('category.id', ondelete='CASCADE')),
db.Column('book_id', db.Integer, db.ForeignKey('book.id', ondelete='CASCADE'))
)
class Category(db.Model, TimestampMixin):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255, convert_unicode=True), nullable=False, unique=True)
description = db.Column(db.Text(convert_unicode=True), nullable=True)
is_active = db.Column(db.Boolean, default=True)
users = relationship("UserCategoryAction", back_populates="category", cascade="all, delete-orphan")
books = relationship(
"Book",
secondary=category_book_table,
back_populates="categories")
from ducttapp.models import db
from flask_restplus import fields
from sqlalchemy.orm import relationship
user_role_table = db.Table(
'user_role',
db.Model.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('user.id', ondelete='CASCADE')),
db.Column('role_id', db.Integer, db.ForeignKey('role.id', ondelete='CASCADE'))
)
class Role(db.Model):
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
role_name = db.Column(db.String(256, convert_unicode=True), nullable=True)
users = relationship(
"User",
secondary=user_role_table,
back_populates="roles")
class RoleSchema:
role_res_schema = {
'id': fields.Integer(),
'role_name': fields.String()
}
class User(db.Model, TimestampMixin):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(128, convert_unicode=True), nullable=False)
email = db.Column(db.String(128, convert_unicode=True),
nullable=False,
unique=True)
fullname = db.Column(db.String(128, convert_unicode=True), nullable=True)
gender = db.Column(db.Boolean, nullable=True)
phone_number = db.Column(db.String(20), nullable=True)
birthday = db.Column(db.DateTime, nullable=True)
avatar = db.Column(db.String(256), nullable=True)
password_hash = db.Column(db.Text(convert_unicode=True), nullable=False)
is_admin = db.Column(db.Boolean, default=False)
is_active = db.Column(db.Boolean, default=True)
time_unlock = db.Column(db.TIMESTAMP, default=datetime.now)
history_pass_change = relationship("HistoryPassChange",
cascade="save-update, merge, delete")
history_wrong_pass = relationship("HistoryWrongPass",
cascade="save-update, merge, delete")
user_action = relationship("UserAction",
cascade="save-update, merge, delete")
social_login = relationship("SocialLogin",
cascade="save-update, merge, delete")
roles = relationship("Role",
secondary=user_role_table,
back_populates="users")
categories = relationship("UserCategoryAction",
back_populates="user",
cascade="all, delete-orphan")
books = relationship("UserBookAction",
back_populates="user",
cascade="all, delete-orphan")
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = bcrypt.generate_password_hash(password).decode(
'utf-8')
def check_password(self, password):
return bcrypt.check_password_hash(self.password_hash, password)
def update_attr(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
self.updated_at = datetime.now()
def to_dict(self):
return {
'id': self.id,
'email': self.email,
'username': self.username,
'is_active': self.is_active,
'updated_at': self.updated_at,
'fullname': self.fullname,
'phone_number': self.phone_number,
'gender': self.gender,
'birthday': self.birthday,
'avatar': self.avatar,
'roles': [r.id for r in self.roles]
}
