class Comments(db.Model):
# Generates default class name for table. For changing use
# __tablename__ = 'users'
# User id.
id = db.Column(db.Integer, primary_key=True)
# User id.
noteid = db.Column(db.Integer, db.ForeignKey('notes.id'))
# User name.
username = db.Column(db.String(length=80))
# User email address.
description = db.Column(db.String(length=250))
# Creation time for user.
created = db.Column(db.DateTime, default=datetime.utcnow)
def __repr__(self):
# This is only for representation how you want to see user information after query.
return "<User(id='%s', name='%s', title='%s', description='%s', created='%s')>" % (
self.id, self.username, self.title, self.description, self.created)
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(
db.String(120),
unique=True,
nullable=False)
password = db.Column(
db.String(120),
nullable=False)
age = db.Column(db.Integer, nullable=True)
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
return cls.query.filter_by(username=username).first()
@staticmethod
def hash_pass(password):
return bcrypt.hashpw(password.encode('utf8'), bcrypt.gensalt())
@staticmethod
def check_pass(password, hashed):
return bcrypt.checkpw(password.encode('utf8'), hashed)
class ItemImage(db.Model):
__tablename__ = 'item_image'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
item_id = db.Column(
db.Integer,
db.ForeignKey('item.id', onupdate='CASCADE', ondelete='CASCADE'))
url = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
def __init__(self, url='', item_id=None):
self.url = url
self.item_id = item_id
def postRecord(self):
db.session.add(self)
db.session.commit()
db.session.refresh(self)
return self
@classmethod
def getImage(cls, image_id):
record = cls.query.filter_by(id=image_id).first()
return record
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)
age = db.Column(db.Integer, nullable=True)
def save_to_db(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 get_one(cls, username):
def to_json(item):
return {'id': item.id, 'username': item.username, 'age': item.age}
user = cls.query.filter_by(username=username).first()
return {'user': to_json(user)}
@classmethod
def update(cls, username, data):
user = cls.query.filter_by(username=username).first()
try:
user.age = data['age']
db.session.commit()
return True
except exc.SQLAlchemyError as er:
print(er)
return False
@staticmethod
def hash_pass(password):
return bcrypt.hashpw(password.encode('utf8'), bcrypt.gensalt())
@staticmethod
def check_pass(password, hashed):
return bcrypt.checkpw(password.encode('utf8'), hashed)
class RevokedTokenModel(db.Model):
__tablename__ = 'revoked_token'
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(120))
def add(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
class Candlestick(db.Model):
__tablename__ = 'candlesticks'
__table_args__ = (db.UniqueConstraint(
'datetime', 'asset_id', name='unique_candlesticks_date_asset_id'), )
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
datetime = db.Column(db.DateTime, nullable=False)
low_price = db.Column(db.Float, nullable=True, default=None)
high_price = db.Column(db.Float, nullable=True, default=None)
open_price = db.Column(db.Float, nullable=True, default=None)
close_price = db.Column(db.Float, nullable=True, default=None)
volume = db.Column(db.Float, nullable=True)
weighted_volume = db.Column(db.Float, nullable=True)
asset_id = db.Column(db.Integer, db.ForeignKey('assets.id'))
asset = db.relationship('Asset',
back_populates='candlesticks',
uselist=False)
def __repr__(self) -> str:
return (
f'Candlestick(datetime={self.datetime}, close_price={self.close_price}, open_price={self.open_price}, '
f'low_price={self.low_price}, high_price={self.high_price}), volume={self.volume}'
)
__str__ = __repr__
class Asset(db.Model):
__tablename__ = 'assets'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ticker = db.Column(db.String, nullable=True, default=True)
isin = db.Column(db.String, nullable=True, default=True)
currency = db.Column(db.String, nullable=True, default='USD')
candlesticks = db.relationship('Candlestick', back_populates='asset')
def __repr__(self) -> str:
return f'Asset(isin={self.isin}, currency={self.currency}, ticker={self.ticker})'
__str__ = __repr__
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
display_name = db.Column(db.String(15), nullable=False)
image = db.Column(db.String(255))
name = db.Column(db.String(50), nullable=False)
name_ruby = db.Column(db.String(50), nullable=False)
birthday = db.Column(db.Date)
payment = db.Column(db.String(255))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
auth = db.relationship('Auth', backref='user')
item = db.relationship('Item', backref='user')
def __init__(self,
display_name,
image='',
name='',
name_ruby='',
birthday='',
payment=''):
self.display_name = display_name
self.image = image
self.name = name
self.name_ruby = name_ruby
self.birthday = birthday
self.payment = payment
def setAttr(self,
display_name,
image='',
name='',
name_ruby='',
birthday='',
payment=''):
self.display_name = display_name
self.image = image
self.name = name
self.name_ruby = name_ruby
self.birthday = birthday
self.payment = payment
def postRecord(self):
db.session.add(self)
db.session.commit()
return self
@classmethod
def getUserInfo(cls, user_id):
record = cls.query.filter_by(id=user_id).first()
return record
class RevokedTokenModel(db.Model):
__tablename__ = 'revoked_token'
id = db.Column(db.Integer, primary_key=True)
jti = db.Column(db.String(120))
def add(self):
db.session.add(self)
db.session.commit()
@classmethod
def is_jti_blacklisted(cls, jti):
query = cls.query.filter_by(jti=jti).first()
return bool(query)
class ApiRequestMetadata(db.Model):
__tablename__ = 'api_request_metadata'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
request_id = db.Column(db.String(length=32))
start_at = db.Column(db.DateTime, nullable=True, default=None)
end_at = db.Column(db.DateTime, nullable=True, default=None)
duration = db.Column(db.Float, nullable=True, default=None)
method = db.Column(db.String(5), nullable=True, default=None)
base_url = db.Column(db.String)
log_file = db.Column(db.String, nullable=True, default=None)
status = db.Column(db.SmallInteger, nullable=True, default=None)
class Blacklist(db.Model):
# Generates default class name for table. For changing use
# __tablename__ = 'users'
# Blacklist id.
id = db.Column(db.Integer, primary_key=True)
# Blacklist invalidated refresh tokens.
refresh_token = db.Column(db.String(length=255))
def __repr__(self):
# This is only for representation how you want to see refresh tokens after query.
return "<User(id='%s', refresh_token='%s', status='invalidated.')>" % (
self.id, self.refresh_token)
class Page(db.Model):
__tablename__ = "pages" # table name will default to name of the model
# Create columns
id = db.Column(db.Integer, primary_key=True)
# page name
name = db.Column(db.String(length=120))
# Creation time for page.
created = db.Column(db.DateTime, default=datetime.utcnow)
# set relationship
pages = db.relationship('LanguageDetail', backref='pages', lazy=True)
# this is not essential, but a valuable method to overwrite as this is what we will see when we print out an instance in a REPL.
def __repr__(self):
return "<Page(id='%s', name='%s', created='%s')>" % (
self.id, self.name, self.created)
class Address(db.Model):
__tablename__ = 'address'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
postal_code = db.Column(db.Integer, nullable=False)
prefecture = db.Column(db.String(50))
municipalities = db.Column(db.String(255), nullable=False)
other = db.Column(db.String(255))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now)
def __init__(self, postal_code='', prefecture='', city='', municipalities='', other=''):
self.postal_code = postal_code
self.prefecture = prefecture
self.city = city
self.municipalities = municipalities
self.other = other
def postRecord(self):
db.session.add(self)
db.session.commit()
return {
'id': self.id,
'postal_code': self.postal_code,
'prefecture': self.prefecture,
'city': self.city,
'municipalities': self.municipalities,
'other': self.other
}
class User(db.Model):
__tablename__ = 't_tag'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
code = db.Column(db.String(255))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now)
def __init__(self, code):
self.code = code
@classmethod
def getUserInfo(cls, user_id):
record = cls.query.filter_by(id=user_id).first()
return {
'id': record.id,
'image': record.image,
'display_name': record.display_name
}
class Reservation(db.Model):
id = db.Column(db.Integer, primary_key=True)
rsv_uuid = db.Column(UUID(as_uuid=True))
rsv_name = db.Column(db.String(256))
due_date = db.Column(db.DateTime)
num_limit = db.Column(db.Integer)
num_now = db.Column(db.Integer)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(128))
password = db.Column(db.String(128))
email = db.Column(db.String(128))
user_role = db.Column(db.String, default='user')
user_rev_id = db.Column(UUID(as_uuid=True))
def generate_token(self, permission_level):
payload = {
'exp': datetime.utcnow() + timedelta(minutes=60),
'iat': datetime.utcnow(),
'user': self.email,
'sub': permission_level
}
access_token = jwt.encode(payload,
os.environ['SECRET_KEY'],
algorithm='HS256')
return access_token
@staticmethod
@auth.verify_token
def verify_token(token):
g.user = None
try:
decoded = jwt.decode(token,
os.environ['SECRET_KEY'],
algorithm='HS256')
except:
return False
if 'email' and 'sub' in decoded:
g.user = decoded['user']
g.admin = decoded['sub']
return True
return False
class RemainingFormat(db.Model):
__tablename__ = 'remaining_format'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
item = db.relationship('Item', backref='remaining_format')
def __init__(self, name=''):
self.name = name
def setAttr(self, name=''):
self.name = name
def postRecord(self):
db.session.add(self)
db.session.commit()
return self
@classmethod
def getRecord(cls, category_id):
record = cls.query.filter_by(id=category_id).first()
return record
@classmethod
def addTestData(cls):
models = []
data_lists = ['whole', 'day', 'week', 'month']
for data in data_lists:
models.append(cls(data))
db.session.add_all(models)
db.session.commit()
class Category(db.Model):
__tablename__ = 'category'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
item = db.relationship('Item', backref='category')
def __init__(self, name=''):
self.name = name
def setAttr(self, name=''):
self.name = name
def postRecord(self):
db.session.add(self)
db.session.commit()
return self
@classmethod
def getCategory(cls, category_id):
record = cls.query.filter_by(id=category_id).first()
return record
@classmethod
def addTestData(cls):
categories = []
data_lists = ['grain', 'vegetable', 'fruit', 'other']
for data in data_lists:
categories.append(cls(data))
db.session.add_all(categories)
db.session.commit()
class Auth(db.Model):
__tablename__ = 'auth'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(
db.Integer,
db.ForeignKey('user.id', onupdate='CASCADE', ondelete='CASCADE'))
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(300), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
def __init__(self, user_id='', email='', password=''):
self.user_id = user_id
self.email = email
self.password = hashlib.sha256(password.encode('utf-8')).hexdigest()
def setAttr(self, user_id='', email='', password=''):
self.user_id = user_id
self.email = email
self.password = hashlib.sha256(password.encode('utf-8'))
def postRecord(self):
db.session.add(self)
db.session.commit()
return
@classmethod
def getRecordsAll(cls):
records = cls.query.all()
return records
@classmethod
def getRecordByEmail(cls, email):
record = cls.query.filter_by(email=email).first()
return record
@classmethod
def getRecordsByUserId(cls, user_id):
record = cls.query.filter_by(user_id=user_id).first()
return record
class LanguageDetail(db.Model):
__tablename__ = "language_details" # table name will default to name of the model
# Create columns
id = db.Column(db.Integer, primary_key=True)
# page id
page_id = db.Column(db.Integer, db.ForeignKey('pages.id'))
# language id
lang_id = db.Column(db.Integer, db.ForeignKey('languages.id'))
# language content
content = db.Column(db.Text)
# language content translated
translate = db.Column(db.Text)
# Creation time for language details.
created = db.Column(db.DateTime, default=datetime.utcnow)
# this is not essential, but a valuable method to overwrite as this is what we will see when we print out an instance in a REPL.
def __repr__(self):
return "<LanguageDetail(id='%s', page_id='%d', lang_id='%d', content='%s', translate='%s')>" % (
self.id, self.page_id, self.lang_id, self.content, self.translate)
class Blacklist(db.Model):
id = db.Column(db.Integer, primary_key=True)
refresh_token = db.Column(db.String(length=256))
class Item(db.Model):
__tablename__ = 'item'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(20), nullable=False) # 商品名
description = db.Column(db.Text) # 商品説明文
period = db.Column(db.Integer, nullable=False) # 販売日数
remaining_days = db.Column(db.Integer, nullable=False)
remaining_format_id = db.Column(
db.Integer,
db.ForeignKey('remaining_format.id',
onupdate='CASCADE',
ondelete='CASCADE'))
category_id = db.Column(db.Integer,
db.ForeignKey('category.id',
onupdate='CASCADE',
ondelete='CASCADE')) # 設定したカテゴリのID
shipment = db.Column(db.Integer, nullable=False) # 配送にかかる時間（日）
price = db.Column(db.Integer, nullable=False) # 商品の値段
state = db.Column(db.Integer) # 商品の状態
user_id = db.Column(
db.Integer,
db.ForeignKey('user.id', onupdate='CASCADE', ondelete='CASCADE'))
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated_at = db.Column(db.DateTime,
nullable=False,
default=datetime.now,
onupdate=datetime.now)
item_image = db.relationship('ItemImage', backref='item')
def __init__(self,
name=None,
description=None,
period=None,
remaining_days=None,
remaining_format_id=None,
category_id=None,
shipment=None,
price=None,
state=None,
user_id=None):
self.name = name
self.description = description
self.period = period
self.remaining_days = remaining_days
self.remaining_format_id = remaining_format_id
self.category_id = category_id
self.shipment = shipment
self.price = price
self.state = state
self.user_id = user_id
def postRecord(self):
db.session.add(self)
db.session.commit()
@classmethod
def getProductById(cls, item_id):
record = cls.query.filter_by(id=item_id).first()
return record
class User(db.Model):
# Generates default class name for table. For changing use
# __tablename__ = 'users'
# User id.
id = db.Column(db.Integer, primary_key=True)
# User name.
username = db.Column(db.String(length=80))
# User password.
password = db.Column(db.String(length=80))
# User email address.
email = db.Column(db.String(length=80))
# Creation time for user.
created = db.Column(db.DateTime, default=datetime.utcnow)
# Unless otherwise stated default role is user.
user_role = db.Column(db.String, default='user')
# Generates auth token.
def generate_auth_token(self, permission_level):
# Check if admin.
if permission_level == 1:
# Generate admin token with flag 1.
token = jwt.dumps({'email': self.email, 'admin': 1})
# Return admin flag.
return token
# Check if admin.
elif permission_level == 2:
# Generate admin token with flag 1.
token = jwt.dumps({'email': self.email, 'admin': 2})
# Return admin flag.
return token
# Return normal user flag.
return jwt.dumps({'email': self.email, 'admin': 0})
# Generates a new access token from refresh token.
@staticmethod
@auth.verify_token
def verify_auth_token(token):
# Create a global none user.
g.user = None
try:
# Load token.
data = jwt.loads(token)
except:
# If any error return false.
return False
# Check if email and admin permission variables are in jwt.
if 'email' and 'admin' in data:
# Set email from jwt.
g.user = data['email']
# Set admin permission from jwt.
g.admin = data['admin']
# Return true.
return True
# If does not verified, return false.
return False
def __repr__(self):
# This is only for representation how you want to see user information after query.
return "<User(id='%s', name='%s', password='******', email='%s', created='%s')>" % (
self.id, self.username, self.password, self.email, self.created)
class Country(db.Model):
__tablename__ = "countries" # table name will default to name of the model
# Create columns
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# name
name = db.Column(db.String(length=120))
# currency
currency = db.Column(db.String(length=50))
# fx
fx = db.Column(db.String(length=50))
# land_register
land_register = db.Column(db.Float)
# light_of_lien
right_of_lien = db.Column(db.Float)
# solvency
solvency = db.Column(db.Float)
# abstract_lr
abstract_lr = db.Column(db.Float)
# valuation_fee
valuation_fee = db.Column(db.Float)
# solvency_rate
solvency_rate = db.Column(db.Float)
# reference_1
reference_1 = db.Column(db.Float)
# reference_2
reference_2 = db.Column(db.Float)
# stamp_duty
stamp_duty = db.Column(db.Float)
# country_costs
country_costs = db.Column(db.Float)
# created
created = db.Column(db.DateTime, default=datetime.utcnow)
# set relationship
# countries = db.relationship('User', backref='countries', lazy=True)
# this is not essential, but a valuable method to overwrite as this is what we will see when we print out an instance in a REPL.
def __repr__(self):
return "<Country(id='%s', name='%s', currency='%s', fx='%s', land_register='%f, right_of_lien='%f, solvency='%f, abstract_lr='%f, valuation_fee='%f, solvency_rate='%f, reference_1='%f, reference_2='%f, stamp_duty='%f, country_costs='%f')>" % (
self.id, self.name, self.currency, self.fx, self.land_register, self.right_of_lien, self.solvency, self.abstract_lr, self.valuation_fee, self.solvency_rate, self.reference_1, self.reference_2, self.stamp_duty, self.country_costs)
