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
class Mail(db.Model):
__tablename__ = 'mail'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
title = db.Column(db.VARCHAR(128))
content = db.Column(db.TEXT)
create_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
class BaseModelMixin:
_model = None
readable_field = "id"
@declared_attr
def __tablename__(self) -> str:
return self.__name__.lower() # type: ignore
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
created_at = db.Column(db.DateTime(timezone=True), default=db.func.now())
updated_at = db.Column(
db.DateTime(timezone=True),
default=db.func.now(),
onupdate=db.func.now(),
)
@classmethod
def model(cls) -> Type[BaseModel]:
if not cls._model:
cls._model = sqlalchemy_to_pydantic(
cls, config=PydanticConfig, exclude=["id"]
)
return cls._model
def __repr__(self) -> str:
return f"<{self.__class__.__name__}: {getattr(self, self.readable_field)}>"
class MailUser(db.Model):
__tablename__ = 'mail_user'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
mail_id = db.Column(db.INTEGER)
to_user = db.Column(db.INTEGER)
read_time = db.Column(db.TIMESTAMP)
visible = db.Column(db.BOOLEAN, nullable=False, default=True)
class LoginLog(db.Model):
__tablename__ = 'login_log'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
user_id = db.Column(db.INTEGER)
create_time = db.Column(db.TIMESTAMP)
ip = db.Column(db.VARCHAR(32))
success_flag = db.Column(db.BOOLEAN)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.Unicode())
password = db.Column(db.String())
email = db.Column(db.String(128), unique=True)
class Message(db.Model):
__tablename__ = 'chat_messages'
id = db.Column(db.Integer(), primary_key=True)
text = db.Column(db.Unicode())
created_date = db.Column(db.DateTime())
room_id = db.Column(db.Integer(), db.ForeignKey('chat_rooms.id'))
user_name = db.Column(db.String(), db.ForeignKey('users.username'))
class DemoModel(db.Model):
"""This is a demo model that should be removed in production.
Note:
This is only a demo model provided by the template library
Magee Flask-RESTful. It should only be used for testing and
demo. Please make sure to remove the model in production mode.
For more information on how to use Flask-SQLAlchemy, visit
https://flask-sqlalchemy.palletsprojects.com/en/2.x/
Attributes:
id (Integer): the object's id
value (String): a string belongs to the entry
"""
__tablename__ = 'demo'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
value = db.Column(db.String(255))
def __init__(self, value):
# Clean the data
value = str(value).strip()
# Store the data in the object
self.value = value
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
def json(self):
return {'id': self.id, 'value': self.value}
def __repr__(self):
return f'<Demo(id={self.id}, value="{self.value}")>'
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_value(cls, value):
return cls.query.filter_by(value=value).all()
@classmethod
def search(cls, _id=None, value=None):
queries = []
if _id:
queries.append(DemoModel.id == _id)
if value:
queries.append(DemoModel.value == value)
return [cls.query.filter(*queries).all()]
class Karma(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(CIText(), unique=True)
value = db.Column(db.Integer())
def __init__(self, name):
self.name = name
self.value = 0
def __repr__(self):
return self.name + ': ' + str(self.value)
class UserModel(db.Model):
"""The model related to users.
To satisfy more requirements, add more fields to the model.
Make sure to register them in the constructor.
Note:
Changing the name of the field `id` is not recommended since JWT
will, by default, look for the attribute `id` in the model. For
more information if the name of the field is changed, consult
https://pythonhosted.org/Flask-JWT/
for the topic `identity_handler(callback)`
Attributes:
id (Integer): user's id
username (String): user's username
password_hash (LargeBinary): user's hashed password
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(32))
password_hash = db.Column(db.LargeBinary(60))
def __init__(self, username, password):
# Clean the data
username = str(username).strip()
password = str(password).strip()
if not is_valid_username(username):
raise ErrorMessagePromise('INVALID_USERNAME')
if not is_valid_password(password):
raise ErrorMessagePromise('INVALID_PASSWORD')
# Hash the password
password_hash = hash_data(password)
# Store the data in the object
self.username = username
self.password_hash = password_hash
def save(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class SignIn(db.Model):
__tablename__ = 'sign_in'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
title = db.Column(db.VARCHAR(128))
content = db.Column(db.TEXT)
begin_time = db.Column(db.TIMESTAMP)
end_time = db.Column(db.TIMESTAMP)
multiple_ip_flag = db.Column(db.BOOLEAN)
create_time = db.Column(db.TIMESTAMP)
last_update_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
visible = db.Column(db.BOOLEAN, nullable=False)
class Tag(db.Model):
id_tag = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
#blog_id = db.Column(db.Integer, db.ForeignKey('blog.id_blog'))
post_set = db.relationship('Post', backref='tag', lazy='dynamic')
create_date = db.Column(db.DateTime, default=datetime.date.today())
update_date = db.Column(db.DateTime, default=datetime.date.today())
status = db.Column(db.Boolean, default=True)
_tablename_ = 'tag'
class Register(db.Model):
__tablename__ = 'register'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
register_type_id = db.Column(db.INTEGER)
name = db.Column(db.VARCHAR(128))
gender = db.Column(db.BOOLEAN)
student_number = db.Column(db.VARCHAR(32))
telephone = db.Column(db.VARCHAR(32))
qq = db.Column(db.VARCHAR(32))
create_time = db.Column(db.TIMESTAMP)
ip = db.Column(db.VARCHAR(32))
class ForumSection(db.Model):
__tablename__ = 'forum_section'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
title = db.Column(db.VARCHAR(128))
content = db.Column(db.TEXT)
create_time = db.Column(db.TIMESTAMP)
last_update_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
subject_number = db.Column(db.INTEGER, default=0)
note_number = db.Column(db.INTEGER, default=0)
visible = db.Column(db.BOOLEAN, nullable=False, default=True)
class Badge(db.Model):
__tablename__ = 'badge'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
title = db.Column(db.VARCHAR(128))
content = db.Column(db.TEXT)
badge_img = db.Column(db.VARCHAR(128))
badge_type = db.Column(db.INTEGER)
create_time = db.Column(db.TIMESTAMP)
last_update_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
visible = db.Column(db.BOOLEAN, nullable=False)
class ForumNote(db.Model):
__tablename__ = 'forum_note'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
subject_id = db.Column(db.INTEGER)
section_id = db.Column(db.INTEGER)
content = db.Column(db.TEXT)
floor_number = db.Column(db.INTEGER)
create_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
visible = db.Column(db.BOOLEAN, nullable=False, default=True)
class Post(db.Model):
id_post = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80))
content = db.Column(db.String(255))
logo = db.Column(db.String(255), default=None, nullable=True)
create_date = db.Column(db.DateTime, default=datetime.date.today())
update_date = db.Column(db.DateTime, default=datetime.date.today())
tag_id = db.Column(db.Integer, db.ForeignKey('tag.id_tag'))
blog_id = db.Column(db.Integer, db.ForeignKey('blog.id_blog'))
status = db.Column(db.Boolean, default=True)
_tablename_ = 'post'
class ContestNotice(db.Model):
__tablename__ = 'contest_notice'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
title = db.Column(db.VARCHAR(128))
content = db.Column(db.TEXT)
contest_id = db.Column(db.INTEGER)
create_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
visible = db.Column(db.BOOLEAN, nullable=False, default=True)
class RegisterType(db.Model):
__tablename__ = 'register_type'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
name = db.Column(db.VARCHAR(128))
create_time = db.Column(db.TIMESTAMP)
last_update_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
running_flag = db.Column(db.BOOLEAN, nullable=False, default=False)
visible = db.Column(db.BOOLEAN, nullable=False, default=True)
class Karma(db.Model):
__hash__ = None
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(CIText(), unique=True)
value = db.Column(db.Integer())
def __init__(self, name):
self.name = name
self.value = 0
def __repr__(self):
return self.name + ': ' + str(self.value)
def __lt__(self, other):
return self.value < other.value
def __eq__(self, other):
return self.value == other.value and self.name == other.name
def __ne__(self, other):
return not self == other
class BadgeUser(db.Model):
__tablename__ = 'badge_user'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
user_id = db.Column(db.INTEGER)
badge_id = db.Column(db.INTEGER)
create_time = db.Column(db.INTEGER)
create_user = db.Column(db.INTEGER)
visible = db.Column(db.BOOLEAN)
class PermissionUser(db.Model):
__tablename__ = 'permission_user'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
permission_id = db.Column(db.INTEGER)
user_id = db.Column(db.INTEGER)
create_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
visible = db.Column(db.BOOLEAN, nullable=False, default=True)
class SignInUser(db.Model):
__tablename__ = 'sign_in_user'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
user_id = db.Column(db.INTEGER)
sign_in_id = db.Column(db.INTEGER)
create_time = db.Column(db.TIMESTAMP)
ip = db.Column(db.VARCHAR(32))
visible = db.Column(db.BOOLEAN)
class CoveryImg(db.Model):
__tablename__ = 'covery_img'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
img_name = db.Column(db.VARCHAR(128))
hyperlink_flag = db.Column(db.BOOLEAN, nullable=False, default=False)
article_flag = db.Column(db.BOOLEAN, nullable=False, default=False)
hyperlink = db.Column(db.VARCHAR(128))
visible = db.Column(db.BOOLEAN, nullable=False, default=True)
class FileType(db.Model):
__tablename__ = 'file_type'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
title = db.Column(db.VARCHAR(128))
create_time = db.Column(db.TIMESTAMP)
last_update_time = db.Column(db.TIMESTAMP)
create_user = db.Column(db.INTEGER)
visible = db.Column(db.BOOLEAN, nullable=False)
class SpecialJudge(db.Model):
__tablename__ = 'special_judge'
id = db.Column(db.INTEGER, autoincrement=True, primary_key=True)
problem_id = db.Column(db.INTEGER)
language = db.Column(db.VARCHAR(16))
code = db.Column(db.TEXT)
version = db.Column(db.VARCHAR(16))
compile_flag = db.Column(db.BOOLEAN, nullable=False, default=False)
class Author(db.Model):
id_author = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(120), unique=True)
name = db.Column(db.String(80))
password = db.Column(db.String(255))
website = db.Column(db.String(255), nullable=True)
profile = db.Column(db.String(255), default=None, nullable=True)
create_date = db.Column(db.DateTime, default=datetime.date.today())
update_date = db.Column(db.DateTime, default=datetime.date.today())
status = db.Column(db.Boolean, default=True)
_tablename_ = 'author'
def __init__(self, name=None, email=None, password=None):
self.name = name
self.email = email
self.password = password
self.create_date = datetime.datetime.now()
self.update_date = datetime.datetime.now()
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key = True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique = True, nullable = False)
password = db.Column(db.String(255), nullable = False)
active = db.Column(db.Boolean(), nullable = False)
roles = db.relationship('Role', secondary = roles_users, backref = 'users')
def __str__(self):
return self.first_name + " " + self.last_name + " <" + self.email + ">"
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True)
password = db.Column(db.String())
email = db.Column(db.String(128), nullable=False, unique=True)
first_name = db.Column(db.Unicode(30))
last_name = db.Column(db.Unicode(30))
facebook_id = db.Column(db.Unicode(256))
def password_match(self, input_password):
return pbkdf2_sha256.verify(input_password, self.password)
class Megazine(db.Model):
# __tablename__ = 'megazine'
id = db.Column(db.Integer, primary_key=True)
id_pub = db.Column(db.String(150), unique=True)
id_author = db.Column(db.String(150), db.ForeignKey('user.id_pub'))
title = db.Column(db.String(40))
about = db.Column(db.String(100))
timestamp = db.Column(db.DateTime, default=datetime.now())
def __init__(self, id_author, title, about):
self.id_pub = 'megazine-' + str(uuid1())
self.id_author = id_author
self.title = title
self.about = about
@classmethod
def find_by_id(cls, id_pub):
return cls.query.filter_by(id_pub=id_pub).first()
@classmethod
def find_by_author(cls, id_author):
return cls.query.filter_by(id_author=id_author).first()
# simpan
def save_to_db(self):
db.session.add(self)
db.session.commit()
# hapus
def delete_to_db(self):
db.session.delete(self)
db.session.commit()
def json(self):
return {
'id_pub': self.id_pub,
'id_author': self.id_author,
'title': self.title,
'about': self.about,
'timestamp': str(self.timestamp)
}
# di gunakan untuk debug
def __repr__(self):
return ('title {}'.format(self.title))
