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