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)