class Role(db.Model): id = db.Column(db.String(32), default=lambda: str(uuid4()).replace('-', ''), primary_key=True) name = db.Column(db.String(32), unique=True, nullable=False, index=True) permits = db.relationship('Permission', secondary=authority, backref=db.backref('roles', lazy='dynamic')) users = db.relationship('Users', backref='role', lazy='dynamic') def generate_access_key(self): s = Serializer(app.config['SECRET_KEY'], expires_in=app.config['SECURITY']['expiration']) return s.dumps({'id': self.id}).decode('utf-8') @staticmethod def verify_access_authority(page, access_key): s = Serializer(app.config['SECRET_KEY']) try: role_id = s.loads(access_key.encode('utf-8'))['id'] role = Role.query.get(role_id) permissions = role.permits permits = [each.permit for each in permissions] return True if page in permits else False except SignatureExpired and BadSignature: return False def __init__(self, name): self.name = name def __repr__(self): return "用户 <%s>" % self.name
class Routes(db.Model): id = db.Column(db.Integer, primary_key=True) end_lat = db.Column(db.Float(), nullable=False) end_lon = db.Column(db.Float(), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) def __repr__(self): return f'Route {self.id}: ({self.user_id}, end_lat: {self.end_lat}, end_lon: {self.end_lon})'
class Entry(db.Model): entry_id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, unique=False) start_time = db.Column(db.DateTime, unique=False) end_time = db.Column(db.DateTime, unique=False) break_length = db.Column(db.Integer, unique=False) def __init__(self, user_id, start_time, end_time): self.entry_id = None self.user_id = user_id self.start_time = start_time self.end_time = end_time self.break_length = None self.created_at = dt.datetime.now() # Sets the Entry ID: def __setEntryID__(self, entry_id): self.entry_id = entry_id # Returns the Entry ID: def __getEntryID__(self): return self.entry_id # Sets the User ID: def __setUserID__(self, user_id): self.user_id = user_id # Returns the User ID: def __getUserID__(self): return self.user_id # Sets the Start Time: def __setStartTime__(self, start_time): self.start_time = start_time # Returns the Start Time: def __getStartTime__(self): return self.start_time # Sets the End Time: def __setEndTime__(self, end_time): self.end_time = end_time # Returns the End Time: def __getEndTime__(self): return self.end_time # Sets the BreakLength: def __setBreakLength__(self, break_length): self.break_length = break_length # Returns the BreakLength: def __getBreakLength__(self): return self.break_length
class Permission(db.Model): id = db.Column(db.Integer, primary_key=True) permit = db.Column(db.String(32), unique=True, nullable=False, index=True) def __init__(self, permit): self.permit = permit def __repr__(self): return "使用 <%s> 模块的权限" % self.permit
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(80), unique=True, nullable=False) password = db.Column(db.String(64), nullable=False) routes = db.relationship('Routes', backref='author', lazy=True) def __repr__(self): return f'User {self.id}: ({self.username}, {self.email})'
class UserStatus(db.Model): id = db.Column(db.String(32), default=lambda: str(uuid4()).replace('-', ''), primary_key=True) state = db.Column(db.String(16), unique=True, nullable=False) user = db.relationship('Users', backref='state', lazy='dynamic') def __repr__(self): return "帐号状态: <%s> " % self.state
class Updates(db.Model): __tablename__ = "updates" id = db.Column(db.Integer, primary_key=True) client_id = db.Column(db.Integer) data = db.Column(MutableList.as_mutable(db.PickleType)) def __init__(self, client_id=None, data=None): self.client_id = client_id self.data = data
class Patient(db.Model): __tablename__ = 'patients' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) birth_year = db.Column(db.Integer) birth_month = db.Column(db.Integer) birth_day = db.Column(db.Integer) phone_number = db.Column(db.String) address = db.Column(db.String) notes = db.Column(db.String) rr_id = db.Column(db.Integer, unique=True) def __init__(self, name=None, birth_year=None, birth_month=None, birth_day=None, phone_number=None, address=None, notes=None, rr_id=None): self.name = name self.birth_year = birth_year self.birth_month = birth_month self.birth_day = birth_day self.phone_number = phone_number self.address = address self.notes = notes self.rr_id = rr_id def __repr__(self): return "{}, {}/{}/{}, #: {}".format(self.name, self.birth_month, self.birth_day, self.birth_year, self.phone_number)
class User(UserMixin, db.Model): __tablename__ = "users" id = db.Column(UUID(as_uuid=True), primary_key=True) username = db.Column(db.String(64), unique=True) password_hash = db.Column(db.String(128)) admin = db.Column(db.BOOLEAN(), default=False, nullable=False) books = db.relationship('Reading', backref='books', lazy=True) added_books = db.relationship("Inventory", back_populates="user") def __init__(self, username): self.username = username self.id = self.get_id() def __repr__(self): return "<User: %r>" % self.username @property def password(self): return self.password_hash @password.setter def password(self, password): self.password_hash = generate_password_hash(password, SECURITY["iterations"]).decode("utf-8") def verify_password(self, password): if self.password_hash is None: return False return check_password_hash(self.password_hash, password) def get_id(self): if self.id is not None: return self.id else: return uuid.uuid4() @staticmethod def find(username): return User.query.filter_by(username=username).first() @staticmethod def get(user_id): try: res = User.query.get(user_id) except OperationalError: res = User.query.get(user_id) return res
class Inventory(db.Model): __tablename__ = "inventories" id = db.Column(UUID(as_uuid=True), primary_key=True) book = db.Column(db.String(32), nullable=False) author = db.Column(db.String(32), nullable=True) url = db.Column(db.String(128), unique=True, nullable=False) added_date = db.Column(db.DateTime(), default=datetime.utcnow) readings = db.relationship("Reading", back_populates="book") vacant_date = db.Column(db.DateTime(), default=datetime.utcnow) user_id = db.Column(UUID(as_uuid=True), db.ForeignKey('users.id')) user = db.relationship('User', back_populates="added_books") def __init__(self, book, author, url): self.id = uuid.uuid4() self.author = author self.book = book self.url = url def __repr__(self): if self.user is not None: return "<<%r>>(Added by: %s): %r" % (self.book, self.user.username, self.url) else: return "<<%r>>: %r" % (self.book, self.url) @staticmethod def exists(url): return Inventory.query.filter_by(url=url).count() > 0 @staticmethod def get_book(book_name): return Inventory.query.filter_by(book=book_name).first()
class Reading(db.Model): __tablename__ = "reading" id = db.Column(UUID(as_uuid=True), primary_key=True) book_id = db.Column(UUID(as_uuid=True), db.ForeignKey('inventories.id')) book = db.relationship('Inventory', back_populates="readings") progress = db.Column(db.Integer(), nullable=False) user_id = db.Column(UUID(as_uuid=True), db.ForeignKey("users.id"), nullable=False) chapter_id = db.Column(UUID(as_uuid=True), db.ForeignKey("chapters.id"), nullable=False) def __init__(self, book, user_id): chapter = Chapters.get_first_chapter(book.book) self.book = book self.id = uuid.uuid4() self.user_id = user_id self.chapter_id, self.progress = chapter.id, chapter.index def __repr__(self): return "<User: %r>: 《%r》" % (self.user_id, self.book.book) def get_progress(self): chapter = Chapters.get(self.chapter_id) remains = Chapters.query.filter( Chapters.book == chapter.book, Chapters.index > chapter.index).count() return "%s_%s_%s_%s_%s" % (self.book.book, chapter.chapter, chapter.title, chapter.id, remains) @staticmethod def exists(book, user_id): return Reading.query.filter(Reading.book == book, Reading.user_id == user_id).count() > 0
class Keeper(db.Model): id = db.Column(db.Integer, primary_key=True) label = db.Column(db.String(32), nullable=False) account = db.Column(db.String(48), nullable=False) password = db.Column(db.String(48), nullable=False) password_original = db.Column(db.String(48)) link = db.Column(db.Text, nullable=True) generated_date = db.Column(db.DateTime, default=datetime.utcnow(), nullable=False) modified_date = db.Column(db.DateTime, default=datetime.utcnow(), nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), index=True) def __repr__(self): return '<password in keeper with label: %s, account: %s, password: %s>' % ( self.label, self.account, self.password)
class BannedUrls(db.Model): __tablename__ = "banned_url" url = db.Column(db.String(128), unique=True, nullable=False, primary_key=True) def __init__(self, url): self.url = url def __repr__(self): return "Banned URL: <<%r>>" % self.url @staticmethod def all(): return BannedUrls.query.all()
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(16), unique=True, nullable=False) email = db.Column(db.String(100), unique=True, nullable=False) password = db.Column(db.String(60), nullable=False) reset_code = db.Column(db.String(6), unique=True, nullable=True) updated_time = db.Column(db.Float, nullable=True) profile_image = db.Column(db.String(32), nullable=False, default='default.jpg') confirmed = db.Column(db.Boolean, nullable=False, default=False) def get_token(self, salt): """ This function will get a token (for email verification/password reset), based on the user's id :param salt: The salt to add to the user's id, in order to create 2 different signatures (tokens) based on the user's needs - different tokens for email verification and password reset (str) :return: the token to use for the verification/reset (str) """ # CHANGE THIS to our secret key later s = Serializer(app.config['SECRET_KEY'], 1800) # Tokens last for 30 mins # Added salt because the tokens can be used for both password reset and email verification return s.dumps({'user_id': self.id}, salt=salt) @staticmethod def verify_token(token, salt): """ This function will verify that a certain token is valid and refers to a specific user :param token: the token to check if valid (str) :param salt: the salt to use while serializing (str) :return: the user that the token refers to if it's valid (User) or None if it isn't (or the user id doesn't exist) """ s = Serializer(app.config['SECRET_KEY'], salt=salt) try: user_id = s.loads(token)['user_id'] except: return None return User.query.get(user_id) def __repr__(self): return f"User('{self.username}', '{self.email}')"
class Job(db.Model): job_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(120), unique=False) org_id = db.Column(db.Integer, unique=False) description = db.Column(db.String(200), unique=False) address = db.Column(db.String(200), unique=False) # Passing a Double into a Float, or a Float into a Double latitude = db.Column(db.Float, unique=False) longitude = db.Column(db.Float, unique=False) # Constructor def __init__(self, name, description, address, org_id): self.job_id = None self.name = name self.org_id = org_id self.created_at = dt.datetime.now() self.description = description self.address = address self.latitude = None self.longitude = None # Sets the Job ID: def __setJobID__(self, job_id): self.job_id = job_id # Returns the Job ID: def __getJobID__(self): return self.job_id # Sets the Name: def __setName__(self, name): self.name = name # Returns the Name: def __getName__(self): return self.name # Sets the Org ID: def __setOrgID__(self, org_id): self.org_id = org_id # Returns the Org ID: def __getOrgID__(self): return self.org_id # Sets the description: def __setDescription__(self, description): self.description = description # Returns the description: def __getDescription__(self): return self.description # Sets the Address: def __setAddress__(self, address): self.address = address # Returns the address: def __getAddress__(self): return self.address # Sets the latitude: def __setLatitude__(self, latitude): self.latitude = latitude # Returns the Longitude: def __getLatitude__(self): return self.latitude # Sets the Longitude: def __setLongitude__(self, longitude): self.longitude = longitude # Returns the Longitude: def __getLongitude__(self): return self.longitude
class Login(db.Model): Id = db.Column(db.Integer, primary_key=True, nullable=False) login = db.Column(db.String(100), nullable=False) senha = db.Column(db.String(12), nullable=False)
class Chapters(db.Model): __tablename__ = "chapters" id = db.Column(UUID(as_uuid=True), primary_key=True) url = db.Column(db.String(128), unique=True, nullable=False) book = db.Column(db.String(32), nullable=False) chapter = db.Column(db.String(32), nullable=False) title = db.Column(db.String(32), nullable=False) index = db.Column(db.Integer(), nullable=False) content = db.Column(db.Text(), nullable=False) readers = db.relationship("Reading", backref="chapter", lazy=True) def __init__(self, url, book, chapter, title, index, content): self.id = uuid.uuid4() self.url = url self.book = book self.chapter = chapter self.title = title self.index = index self.content = content def __repr__(self): return "<<%r>>: %r" % (self.book, self.chapter) @staticmethod def get_books(): books = [each.book for each in Chapters.query.distinct(Chapters.book)] last_chapters = [ Chapters.query.filter_by(book=book).order_by( Chapters.index.desc()).first() for book in books ] return [ "%s_%s_%s" % (chapter.book, chapter.chapter, chapter.title) for chapter in last_chapters ] @staticmethod def get_first_chapter(book_name): chapter = Chapters.query.filter_by(book=book_name).order_by( Chapters.index).first() return chapter @staticmethod def get_last_chapter(book_name): chapter = Chapters.query.filter_by(book=book_name).order_by( Chapters.index.desc()).first() return chapter @staticmethod def get(chapter_id): return Chapters.query.get(chapter_id) @staticmethod def download(book_name): chapters = Chapters.query.filter_by(book=book_name).order_by( Chapters.index).all() doc = "" doc += "#%s\n\n" % book_name for c in chapters: doc += "\n\n##%s %s\n\n" % (c.chapter, c.title) doc += c.content return doc def menu(self): return "%s\t%s_%s" % (self.chapter, self.title, self.id)
__author__ = 'LimeQM' from Server import app, db from uuid import uuid4 from itsdangerous import TimedJSONWebSignatureSerializer as Serializer, SignatureExpired, BadSignature authority = db.Table( 'authorities', db.Model.metadata, db.Column('permission_id', db.Integer, db.ForeignKey('permission.id')), db.Column('role_id', db.String(32), db.ForeignKey('role.id'))) class Role(db.Model): id = db.Column(db.String(32), default=lambda: str(uuid4()).replace('-', ''), primary_key=True) name = db.Column(db.String(32), unique=True, nullable=False, index=True) permits = db.relationship('Permission', secondary=authority, backref=db.backref('roles', lazy='dynamic')) users = db.relationship('Users', backref='role', lazy='dynamic') def generate_access_key(self): s = Serializer(app.config['SECRET_KEY'], expires_in=app.config['SECURITY']['expiration']) return s.dumps({'id': self.id}).decode('utf-8') @staticmethod def verify_access_authority(page, access_key): s = Serializer(app.config['SECRET_KEY']) try:
class User(db.Model): user_id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True) password_hash = db.Column(db.String, unique=False) salt = db.Column(db.String(32), unique=False) admin = db.Column(db.Boolean, unique=False) # Foreign Key org_id = db.Column(db.Integer, unique=False) first_name = db.Column(db.String(80), unique=False) last_name = db.Column(db.String(80), unique=False) email = db.Column(db.String(120), unique=True) phone = db.Column(db.String(120), unique=False) break_length = db.Column(db.Integer, unique=False) # Constructor def __init__(self, username, password, first_name, last_name, email, phone, admin, org_id): self.user_id = None self.username = username self.password = password self.password_hash = None self.salt = None self.org_id = org_id self.admin = admin self.first_name = first_name self.last_name = last_name self.email = email self.phone = phone self.break_length = None self.created_at = dt.datetime.now() # # Testing Constructor # def __schemaInit__(self, admin, email, first_name, last_name, org_id, password, phone, username): # user = User(first_name, last_name, email) # user.__setUserName__(username) # user.__setPassword__(password) # user.__setOrgID__(org_id) # user.__setAdminStatus__(admin) # user.__setPhone__(phone) # return user # Sets the user's User ID: def __setUserID__(self, user_id): self.user_id = user_id # Returns the user's User ID: def __getUserID__(self): return self.user_id # Sets the user's Username: def __setUserName__(self, username): self.username = username # Returns the user's Username: def __getUserName__(self): return self.username # Sets the user's Password Hash: def __setPasswordHash__(self, password_hash): self.password_hash = password_hash # Returns the user's Password Hash: def __getPasswordHash__(self): return self.password_hash # Sets the user's Salt: def __setSalt__(self, salt): self.salt = salt # Returns the user's Salt: def __getSalt__(self): return self.salt # Sets the user's Org ID: def __setOrgID__(self, org_id): self.org_id = org_id # Returns the user's Org ID: def __getOrgID__(self): return self.org_id # Sets the user's User ID: def __setAdminStatus__(self, admin): self.admin = admin # Returns the user's User ID: def __getAdminStatus__(self): return self.admin # Sets the user's First Name: def __setFirstName__(self, first_name): self.first_name = first_name # Returns the user's First Name: def __getFirstName__(self): return self.first_name # Sets the user's Last Name: def __setLastName__(self, last_name): self.last_name = last_name # Returns the user's Last Name: def __getLastName__(self): return self.last_name # Sets the user's Phone Number (Default == Null) : def __setPhone__(self, phone): self.phone = phone # Returns the user's Phone Number: def __getPhone__(self): return self.phone # Sets the user's Email Address: def __setEmail__(self, email): self.email = email # Returns the user's Email Address: def __getEmail__(self): return self.email # Sets the user's Break Length Address: def __setBreakLength__(self, break_length): self.break_length = break_length # Returns the user's Break Length Address: def __getBreakLength__(self): return self.break_length # Sets the user's Password Hash: def __setPassword__(self, password): self.password = password # Returns the user's Password Hash: def __getPassword__(self): return self.password # ???? def __repr__(self): return "<User(name={self.first_name!r})>".format(self=self)
class Users(db.Model): id = db.Column(db.Integer, primary_key=True) role_id = db.Column( db.String(32), db.ForeignKey('role.id'), index=True, default=lambda: Role.query.filter_by(name='user').first().id) state_id = db.Column( db.String(32), db.ForeignKey('user_status.id'), default=lambda: UserStatus.query.filter_by(state='reserve').first().id) email = db.Column(db.String(32), unique=True) username = db.Column(db.String(16)) password = db.Column(db.String(128)) finger_print = db.Column( db.String(28), default=lambda: ''.join(sample(ascii_letters + digits, 28)), nullable=False) keeper = db.relationship('Keeper', backref='owner', lazy='dynamic') keeper_key = db.Column(db.String(64)) keeper_active = db.Column(db.Boolean, default=False) keeper_length = db.Column(db.SmallInteger, default=12) register_date = db.Column(db.DateTime, default=lambda: datetime.utcnow()) last_signin_date = db.Column(db.DateTime, default=lambda: datetime.utcnow()) @staticmethod def hash_password(password): return crypt.generate_password_hash( password, app.config['SECURITY']['iterations']) @staticmethod def pad(original): data = str(original).encode() padding_length = AES.block_size - len(data) % AES.block_size return original + padding_length * chr(padding_length) @staticmethod def unpad(padded): return padded[:-ord(padded[len(padded) - 1:])] def generate_keeper_key(self, pin): sha = SHA256.new() sha.update(("%s%s" % (self.finger_print, pin)).encode()) return sha.hexdigest() def verify_keeper_key(self, pin): return self.generate_keeper_key(pin) == self.keeper_key def encrypt(self, data, pin, iv): cipher = AES.new("%s%s" % (self.finger_print, pin), AES.MODE_CBC, self.pad(iv)) return "{0}".format(b64encode(cipher.encrypt(self.pad(data))).decode()) def decrypt(self, ciphered, pin, iv): cipher = AES.new("%s%s" % (self.finger_print, pin), AES.MODE_CBC, self.pad(iv)) return self.unpad(cipher.decrypt(b64decode(ciphered))).decode() def verify_password(self, _password): try: return crypt.check_password_hash(self.password, _password) except: return False def generate_auth_token(self): s = Serializer(app.config['SECRET_KEY'], expires_in=app.config['SECURITY']['expiration']) return s.dumps({'id': self.id}).decode('utf-8') @staticmethod def verify_auth_token(token): s = Serializer(app.config['SECRET_KEY']) try: data = s.loads(token.encode('utf-8')) return Users.query.get(data['id']) except SignatureExpired and BadSignature: return None except: return None def user_info(self): return { 'name': self.username, 'access_key': self.role.generate_access_key(), 'keeper_active': self.keeper_active, 'keeper_length': self.keeper_length } def __repr__(self): return '<User %s>' % (self.username)