class Data(db.Model):
__tablename__ = "datas"
id = db.Column(db.Integer, primary_key=True)
smallInteger = db.Column(db.SmallInteger)
bigInteger = db.Column(db.BigInteger)
floatData = db.Column(db.Float(10))
numericData = db.Column(db.Numeric(10))
stringData = db.Column(db.String(250))
textData = db.Column(db.Text(200))
mediumText = db.Column(db.Text(65536))
longText = db.Column(db.Text(16777216))
largeBinary = db.Column(db.LargeBinary(300))
mediumBlob = db.Column(db.LargeBinary(65536))
longBlob = db.Column(db.LargeBinary(16777216))
pickle = db.Column(db.PickleType)
mediumPickle = db.Column(db.PickleType(65536))
longPickle = db.Column(db.PickleType(16777216))
unicodeData = db.Column(db.Unicode(10))
unicodeText = db.Column(db.UnicodeText)
booleanData = db.Column(db.Boolean(0))
dateData = db.Column(db.Date)
timeData = db.Column(db.Time)
dateTime = db.Column(db.DateTime)
interval = db.Column(db.Interval)
enumData = db.Column(db.Enum('father', 'mother'))
def __repr__(self):
return "Data {}".format(self.id)
class User(db.Model, UserMixin):
"""Represents a user."""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
email = db.Column(db.String(128), unique=True)
password = db.Column(db.LargeBinary(4096))
# This is a list of characters designating what permissions the user has:
# a: admin, etc.
permissions = db.Column(db.String(64))
# This is a list of metadata tags useful for filtering; for example, class,
# year, major, etc.
metadata_str = db.Column(db.LargeBinary(4096))
# Events where the user is a manager.
managing_events = db.relationship('Event',
backref='manager',
lazy='select')
def __init__(self, name, password, email):
self.name = name
self.password = encrypt(SECRET_KEY, password)
self.email = email
self.permissions = ""
self.metadata_str = ""
class Session(db.Model):
session_id = db.Column(db.String(), primary_key=True)
user = db.Column(db.String(), nullable=True)
token = db.Column(db.LargeBinary(), nullable=True)
refresh_token = db.Column(db.LargeBinary(), nullable=True)
expiry = db.Column(db.DateTime, nullable=True)
state = db.Column(db.String(), nullable=True)
verifier = db.Column(db.String(), nullable=True)
def __repr__(self):
return f'Session({self.user}, {self.session_id}, {self.expiry})'
@classmethod
def clean(cls):
# https://silvaneves.org/deleting-old-items-in-sqlalchemy.html
# https://stackoverflow.com/questions/5602918/select-null-values-in-sqlalchemy
expiration_time = 180
limit = datetime.datetime.now() - datetime.timedelta(
days=expiration_time)
cls.query.filter(cls.expiry < limit).delete()
cls.query.filter(cls.expiry.is_(None)).delete()
db.session.commit()
pass
is_authenticated = is_active = user is not None
is_anonymous = not is_authenticated
def get_id(self):
return self.session_id
class Passentry(db.Model):
"""Passentry store root password history for furture reference"""
__tablename__ = "passentry"
id = db.Column(db.Integer, primary_key=True)
connectiondate = db.Column(db.String(20), index=True)
password = db.Column(db.LargeBinary(500), index=True)
salt = db.Column(db.LargeBinary(500), index=True)
# Relations
target = db.relationship("Target", secondary="target_pass")
def __init__(self, connectiondate, password):
self.connectiondate = connectiondate
self.salt = os.urandom(16)
self.password = self.encryptpassword(password)
def __repr__(self):
"""Return main data of the passentry as a string"""
output = []
output.append("Date : {}".format(self.connectiondate))
output.append("Password: {}".format(self.decryptpassword()))
output.append("Target : {}".format(self.target[0].show_name()))
return "\n".join(output)
def notargetjson(self):
"""Return a json of passentry infos except target name"""
output = "{"
output = output + "\"date\": \"" + format(
self.connectiondate) + "\",\n"
output = output + "\"password\": \"" + \
format(self.decryptpassword()) + "\""
output = output + "}"
return output
def encryptpassword(self, password):
"""Encrypt the password"""
return self.generatefernet().encrypt(password.encode())
def decryptpassword(self):
"""Decrypt the password"""
return self.generatefernet().decrypt(self.password).decode()
def generatefernet(self):
"""Return a fernet object used to encrypt/decrypt the password"""
kdf = PBKDF2HMAC(algorithm=hashes.SHA256(),
length=32,
salt=self.salt,
iterations=100000,
backend=default_backend())
key = base64.urlsafe_b64encode(kdf.derive(config.SALT.encode()))
return Fernet(key)
class Physician(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement="auto")
key = db.Column(db.LargeBinary())
fname = db.Column(db.LargeBinary())
lname = db.Column(db.LargeBinary())
username = db.Column(db.String(256), index=True, unique=True)
userpwd = db.Column(db.String(256))
records = db.relationship("Record", backref="author", lazy="dynamic")
# "__init__" OVERRIDES DEFAULT CONSTRUCTOR
def __init__(self, fname, lname, username, userpwd):
key = Fernet.generate_key()
self.key = key
f = Fernet(key)
self.fname = f.encrypt(fname.encode("utf-8"))
self.lname = f.encrypt(lname.encode("utf-8"))
self.username = username #f.encrypt(username.encode('utf-8'))
self.userpwd = userpwd #f.encrypt(userpwd.encode('utf-8'))
# "__repr__" FACILITATES DISPLAY VIA FLASK SHELL SESSION ACCESS
def __repr__(self):
return "(Physician: {lname}, {fname})".format(lname=self.lname,
fname=self.fname)
# GETTERS USED TO RETRIEVE PHYSICIAN INFO
def get_key(self):
return self.key
def get_password(self):
return self.userpwd
def get_records(self):
records = Record.query.filter_by(phys_id=self.id)
return records
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String())
email = db.Column(db.String(), unique=True)
password = db.Column(db.LargeBinary())
def __init__(self, username, email, password):
self.username = username
self.email = email.lower()
self.password = self._encrypt_password(password)
def __repr__(self):
return "username: {}\nemail: {}\n".format(self.username, self.email)
def check_password(self, password):
return checkpw(password.encode('UTF-8'), self.password)
def reset_password(self, new_password):
self.password = self._encrypt_password(new_password)
@staticmethod
def _encrypt_password(password):
return hashpw(password.encode('UTF-8'), gensalt())
class Admin(UserMixin, db.Model):
__tablename__ = "admins"
id = db.Column(UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
# uuid = db.Column(UUID(as_uuid=True), default=uuid.uuid4, unique=True, nullable=False)
first_name = db.Column(db.String())
last_name = db.Column(db.String())
email = db.Column(db.String(), unique=True)
_password = db.Column(db.LargeBinary())
mobile = db.Column(db.String(), unique=True)
businesses = db.relationship("AdminBusiness", back_populates="admin")
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 __repr__(self):
return "<id {}>".format(self.id)
def serialize(self):
return {"email": self.email}
@hybrid_property
def password(self):
return self._password
@password.setter
def password(self, plaintext):
self._password = bcrypt.generate_password_hash(plaintext)
@hybrid_method
def validate(self, plaintext_password):
return bcrypt.check_password_hash(self.password, plaintext_password)
class User(UserMixin, db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(128),
index=True,
unique=True,
nullable=True)
password = db.Column(db.String(128), nullable=True)
name = db.Column(db.String(128))
email = db.Column(db.String(128), nullable=True)
picture = db.Column(db.LargeBinary(65536), nullable=True)
location = db.Column(db.String(200), nullable=True)
website = db.Column(db.String(200), nullable=True)
github = db.Column(db.String(200), nullable=True)
twitter = db.Column(db.String(200), nullable=True)
LinkedIn = db.Column(db.String(200), nullable=True)
def __init__(self, username, password, name=None):
self.username = username
self.password = password
if name is None:
name = username
self.name = name
def __repr__(self):
return '<User {}>'.format(self.name)
def set_password(self, password):
self.password_hash = generate_password_hash(self, password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model):
__tablename__ = "user"
__table_args__ = {"extend_existing": True}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), unique=True, nullable=False)
pwd = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255))
introduce = db.Column(db.Text, default="洗白白，吃饱饱")
headName = db.Column(db.String(255), default='default.png')
head = db.Column(db.LargeBinary(1048576))
right = db.Column(db.Integer, default=2)
uuid = db.Column(db.String(100), unique=True)
addtime = db.Column(db.DateTime, default=datetime.now())
# 反向引用
blogs = db.relationship('app.models.Blog')
comments = db.relationship('app.models.Comment')
cols = db.relationship('app.models.Collection')
likes = db.relationship('app.models.Like')
logs = db.relationship('app.models.UserLog')
def __repr__(self):
return "User:%s %s %s" % (self.name, self.pwd, self.id)
def check_pwd(self, pwdd):
from werkzeug.security import check_password_hash
return check_password_hash(self.pwd, pwdd)
class FileBin(db.Model):
__tablename__ = 'file_bin'
name = db.Column(db.String(64), primary_key=True)
bin = db.Column(db.LargeBinary(length=(2**32)-1))
def get_bin(self):
return base64.b64decode(self.bin)
class ImageFile(db.Model):
__tablename__ = 'ImageFile'
id = db.Column(db.Integer, primary_key=True)
image_name = db.Column(db.String(30), index=True)
image = db.Column(db.LargeBinary(length=2048))
def __repr__(self):
return '<User %r>' % image_name
class ItemImage(db.Model):
__tablename__ = 'item_image'
id = db.Column(db.Integer, primary_key=True)
item_id = db.Column(db.Integer, db.ForeignKey('item.id'), nullable=False)
image = db.Column(db.LargeBinary(65536), nullable=False)
def __repr__(self):
return '<ItemImage item_id:{}, id:{}>'.format(self.item_id, self.id)
class MuridModel(db.Model):
__tablename__ = "murid"
id = db.Column(db.Integer, primary_key=True)
nomor_induk = db.Column(db.String(5), nullable=False, unique=True)
nama = db.Column(db.String(64), nullable=False)
nama_panggilan = db.Column(db.String(24), nullable=False)
anak_ke = db.Column(db.String(2), nullable=False)
alamat = db.Column(db.Text, nullable=False)
dusun = db.Column(db.String(24), nullable=False)
kelurahan = db.Column(db.String(24), nullable=False)
kecamatan = db.Column(db.String(24), nullable=False)
kabupaten = db.Column(db.String(24), nullable=False)
provinsi = db.Column(db.String(24), nullable=False)
agama = db.Column(
db.Enum(
"Islam", "Kristen", "Katolik", "Hindu", "Buddha", "Kong Hu Cu", name="agama"
),
nullable=False,
)
tempat_lahir = db.Column(db.String(24), nullable=False)
tanggal_lahir = db.Column(db.String(24), nullable=False)
lulus = db.Column(db.Boolean, default=False)
nama_ibu_kandung = db.Column(db.String(64), nullable=False)
jenis_kelamin = db.Column(
db.Enum("Laki-laki", "Perempuan", name="gender"), nullable=False
)
tahun_pelajaran = db.Column(db.String(24), nullable=False)
foto_diri = db.Column(db.LargeBinary(__fotosize__))
nama_foto_diri = db.Column(db.String(64), unique=True)
kelas_id = db.Column(db.Integer, db.ForeignKey("kelas.id"))
kelas = db.relationship("KelasModel", back_populates="murid")
wali_murid = db.relationship("WaliMuridModel", back_populates="murid")
nilai = db.relationship("NilaiModel")
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("UserModel", back_populates="murid")
def can(self, perm):
return self.role is not None and self.role.has_permission(perm)
def is_administrator(self):
return self.can(Permission.ADMIN)
def __repr__(self):
return "Murid {}".format(self.nama)
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
return int(self.id)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64))
keyword = db.Column(db.String())
body = db.Column(db.String())
coverpic = db.Column(db.LargeBinary(length=2048))
timestamp = db.Column(db.DateTime, index=True, default=datetime.now())
reding = db.Column(db.Integer)
kind = db.Column(db.String(), db.ForeignKey('type.id'))
class Key(db.Model):
__tablename__ = "keys"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
aaguid = db.Column(db.LargeBinary(16))
credential_id = db.Column(db.LargeBinary(64))
client_data_hash = db.Column(db.LargeBinary(32))
public_key = db.Column(db.LargeBinary(77))
counter = db.Column(db.Integer, default=0)
attestation = db.Column(db.LargeBinary(1021))
info = db.Column(db.String(1000))
is_resident = db.Column(db.Boolean(), default=False)
last_access = db.Column(db.DateTime)
created = db.Column(db.DateTime)
user_id = db.Column(db.Integer, db.ForeignKey("user.did"))
def __repr__(self):
short_hex_cred_id = binascii.b2a_hex(self.credential_id)[:6].decode()
return f"<Key - {self.name} for {short_hex_cred_id}>"
class TaxiApprovalsModel(db.Model):
__bind_key__ = 'taxi'
__tablename__ = 'approvals'
__table_args__ = {'schema': 'taxi'}
id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey(PortalUserModel.id), nullable=False)
approval_name = db.Column(db.String(255))
approval_data = db.Column(db.LargeBinary())
approval_original_name = db.Column(db.String(255))
class Webauthn(db.Model):
__tablename__ = "webauthn"
id = db.Column(db.Integer, primary_key=True)
number = db.Column(db.Integer, default=0)
is_enabled = db.Column(db.Boolean, default=False)
user_identifier = db.Column(db.LargeBinary(64))
user_id = db.Column(db.Integer, db.ForeignKey("user.did"))
def __repr__(self):
return f"<Webauthn - {self.number} keys for user {self.user_id}>"
class Emoji(db.Model):
id = db.Column(db.Integer, primary_key=True)
shortcode = db.Column(db.String(length=80), nullable=False, index=True)
hash = db.Column(db.LargeBinary(length=HASH_LENGTH), nullable=False)
filename = db.Column(db.String)
__table_args__ = (db.UniqueConstraint('shortcode', 'hash'), )
@property
def imgsrc(self):
return uploaded_photos.url(self.filename)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
#image
image = db.Column(db.LargeBinary())
#
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return '<Post {}>'.format(self.body)
class Topic(db.Model):
"""话题"""
__tablename__ = "topic"
id = db.Column(db.Integer, primary_key=True)
topic_name = db.Column(db.String(30), nullable=False)
topic_avatar = db.Column(db.LargeBinary(length=2048))
topic_desc = db.Column(db.String(300))
category_id = db.Column(db.Integer, db.ForeignKey("topiccate.id"))
follow_topics = db.relationship("FollowTopic",
backref="topic",
lazy='dynamic',
cascade='all, delete-orphan')
question_topic = db.relationship("QuestionTopic", backref="topic")
def questions_excellans(self):
"""
列举话题本身下的所有问题，
以及最优回答，即评论最多的。
"""
questions_excellans = list() # 存放所有问题以及最优回答对象
for question in self.question_topic:
query = question.question.answers.filter_by().all() # 查询问题下的所有回答
question_answer = [] # 存放检索到的目标问题_回答集合
if query:
answer_excell = query[0]
count = answer_excell.comments.count()
for answer in query:
if answer.comments.count() > count:
answer_excell = answer
count = answer_excell.comments.count()
question_answer.append(question.question)
question_answer.append(answer_excell)
else:
question_answer.append(question.question)
question_answer.append(None)
question_answer.append(self)
questions_excellans.append(question_answer) # 添加进总集和并返回
return questions_excellans
@staticmethod
def insert_topic(name, desc, avatar, cate):
topic = Topic(topic_name=name,
topic_desc=desc,
topic_avatar=avatar,
category_id=cate)
return operate_model.db_add(topic)
@staticmethod
def delete_topic(topic_id):
topic = Topic.query.filter_by(id=topic_id).first()
if not topic:
return False
return operate_model.db_delete(topic)
class BeritaModel(db.Model):
__tablename__ = "berita"
id = db.Column(db.Integer, primary_key=True)
judul = db.Column(db.String(120), nullable=False)
deskripsi = db.Column(db.Text)
slug = db.Column(db.String(120))
dokumen = db.Column(db.LargeBinary(__filesize__))
nama_dokumen = db.Column(db.String(124), unique=True)
gambar = db.Column(db.LargeBinary(__fotosize__))
nama_gambar = db.Column(db.String(124), unique=True)
waktu_upload = db.Column(db.DateTime, index=True, default=datetime.utcnow)
tampilkan = db.Column(db.Boolean, default=False)
@staticmethod
def generate_slug(target, value, oldvalue, initiator):
if value and (not target.slug or value != oldvalue):
target.slug = slugify(value)
def __repr__(self):
return "Berita {}".format(self.judul)
class User(db.Model):
__tablename__ = "AuthUser"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True)
password = db.Column(db.LargeBinary())
dogecoin = db.Column(db.Integer, default=0)
def __init__(self, username, password, dogecoin=0):
self.username = username
self.password = password
self.dogecoin = dogecoin
class TLRelationReport(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String(30))
hour = db.Column(db.String(30))
csv_content = db.Column(db.LargeBinary(length=(2**32) - 1))
def __init__(self, date, hour, csv_content):
self.date = date
self.hour = hour
self.csv_content = csv_content
def __repr__(self):
return '<TLRelationReport %r>' % self.id
class Pattern(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), index=True, nullable=False)
filename = db.Column(db.String(120))
file = db.Column(db.LargeBinary())
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
comments = db.relationship('Comment', backref='pattern', lazy='dynamic')
tags = db.relationship('Tag', secondary=tags, backref='patterns')
image_filename = db.Column(db.String(120))
description = db.Column(db.String(1000))
def __repr__(self):
return '<Pattern: {}, user: {}>'.format(self.name, self.user_id)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
first_name = db.Column(db.String(64), unique=True)
last_name = db.Column(db.String(64), unique=True)
email = db.Column(db.String(128), index=True, unique=True)
photos = db.Column(db.LargeBinary(__maxsize__), nullable=True)
photos_filename = db.Column(db.String, nullable=True)
def __repr__(self):
return '<User {}>'.format(self.username)
class Report(db.Model):
__tablename__ = 'reports'
id = db.Column(db.Integer, primary_key=True)
period = db.Column(db.String(128))
type = db.Column(db.String(128))
summary = db.Column(db.Text())
description = db.Column(db.Text())
report = db.Column(db.LargeBinary())
institution_id = db.Column(db.String(128),
db.ForeignKey("institutions.id"))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
deleted_at = db.Column(db.DateTime)
created_by = db.Column(db.Integer, ForeignKey("users.id"))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
email = db.Column(db.String(), unique=True)
password = db.Column(db.LargeBinary())
role = db.Column(db.Integer())
def __init__(self,
id=None,
name=None,
email=None,
password=None,
role=None):
self.id = id
self.name = name
self.email = email
self.password = password
self.role = role
def __repr__(self):
return '<id {}>'.format(self.id)
def serialize(self):
return {
'id': self.id,
'name': self.name,
'email': self.email,
'role': self.role
}
def update_user_values(self, new_data):
if new_data.get('name'):
self.name = new_data.get('name').strip()
if new_data.get('email'):
self.email = new_data.get('email').strip()
if new_data.get('password'):
self.password = bcrypt.hashpw(
new_data.get('password').encode('utf-8'), bcrypt.gensalt())
if new_data.get('role') is not None:
self.role = int(new_data.get('role'))
@staticmethod
def from_json_to_model(json):
return User(name=json.get('name').strip(),
email=json.get('email').strip(),
password=bcrypt.hashpw(
json.get('password').encode('utf-8'),
bcrypt.gensalt()),
role=0)
class Video(db.Model):
__tablename__ = "video"
__table_args__ = {"extend_existing": True}
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
video_name = db.Column(db.String(255))
# url = db.Column(db.String(255))
video_data = db.Column(db.LargeBinary(4294967295))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
blog_id = db.Column(db.Integer, db.ForeignKey('blog.id'))
uuid = db.Column(db.String(100))
addtime = db.Column(db.DateTime, default=datetime.now())
def __repr__(self):
return "Video:%r %r %r" % (self.id, self.user_id, self.videoName)
class User_Image(db.Model):
__bind_key__ = 'my_data'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False, unique=True)
creator = db.Column(db.String(64), nullable=False, unique=False)
img_web_url = db.Column(db.String(64), nullable=False, unique=True)
img_dir_url = db.Column(db.String(64), nullable=False, unique=True)
thumb = db.Column(db.LargeBinary(), nullable=False, unique=False)
def __repr__(self):
return '<Image {}>'.format(self.name)
# todo add way to add items to db
class Business(db.Model):
"""[summary]
:param db: [description]
:type db: [type]
:return: [description]
:rtype: [type]
"""
__tablename__ = "businesses"
id = db.Column(db.Integer, primary_key=True)
business_name = db.Column(db.String, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.LargeBinary(127), nullable=False)
owner_full_name = db.Column(db.String(255))
phone_number = db.Column(db.String(11))
password_salt = db.Column(db.String(63))
created_at = db.Column(db.DateTime)
modified_at = db.Column(db.DateTime)
password_reset_code = db.Column(db.String(6))
password_reset_timeout = db.Column(db.DateTime)
last_successful_login = db.Column(db.DateTime)
last_unsuccessful_login = db.Column(db.DateTime)
description = db.Column(db.String)
profile_picture = db.Column(db.String)
def __init__(self, **kwargs):
super(Business, self).__init__(**kwargs)
self.created_at = datetime.now()
self.modified_at = datetime.now()
def update(self, changes: dict):
for key, val in changes.items():
setattr(self, key, val)
self.modified_at = datetime.now()
return self
def __repr__(self):
pass
