class StockModel(db.Model):
__tablename__ = 'stocks'
id = db.Column(db.Integer, primary_key=True)
stock_id = db.Column(db.String(80))
date = db.Column(db.String(80))
open_price = db.Column(db.Float)
max_price = db.Column(db.Float)
min_price = db.Column(db.Float)
close_price = db.Column(db.Float)
decline = db.Column(db.Float)
volume = db.Column(db.Integer)
amount = db.Column(db.Integer)
def __init__(self, stock_id, date, open_price, max_price, min_price,
close_price, decline, volume, amount):
self.stock_id = stock_id
self.date = date
self.open_price = open_price
self.max_price = max_price
self.min_price = min_price
self.close_price = close_price
self.decline = decline
self.volume = volume
self.amount = amount
def json(self):
return {
'stock_id': self.stock_id,
'date': self.date,
'open_price': self.open_price,
'max_price': self.max_price,
'min_price': self.min_price,
'close_price': self.close_price,
'decline': self.decline,
'volume': self.volume,
'amount': self.amount
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def save_list_to_db(cls, list):
for item in list:
db.session.add(item)
db.session.commit()
@classmethod
def get_by_date(cls, date):
return cls.query.filter(cls.date >= date).order_by(desc(cls.date))
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def get_max_date(cls):
return cls.query.order_by(desc(cls.date)).limit(1).first().date
class UserModel(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(120))
def __init__(self, name, email, password):
self.name = name
self.email = email
self.password = password
def add_user(self):
db.session.add(self)
db.session.commit()
def update_user(self):
db.session.commit()
@classmethod
def get_user(cls, name):
return cls.query.filter_by(name=name).first()
def delete_user(self):
db.session.delete(self)
db.session.commit()
@classmethod
def get_all_user(cls):
return cls.query.all()
class Question(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question = db.Column(db.String(80), unique=True, nullable=False)
dataset = db.Column(db.String(120), nullable=False)
procedures = db.relationship('Procedure',
backref='new_question',
lazy=True)
class ItemModel(db.Model
): ## Extend SQLAlchemy model for easier db interaction
## Setup SQLAchemy Variables
## Table
__tablename__ = 'items'
## Table Columns
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
price = db.Column(db.Float)
## Relate items and stores
store_id = db.Column(db.Integer, db.ForeignKey('stores.id'))
store = db.relationship('StoreModel')
def __init__(self, name: str, price: float, store_id: int):
self.name = name
self.price = price
self.store_id = store_id
def json(self) -> Dict:
return {
'id': self.id,
'name': self.name,
'price': self.price,
'store_id': self.store_id
}
@classmethod ## Keep as class because it returns an object of ItemModel
def find_by_name(cls, name: str):
"""
Search the items table for an existing item
:param name: Name of the item
:return: Item if exists in the db
"""
return cls.query.filter_by(name=name).first(
) ## Use SQLAlchemy to build model from database data
@classmethod
def find_all(cls):
return cls.query.all()
def save_to_db(self) -> None:
"""
Upsert an item into the items table
:return: None
"""
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
"""
Delete an item from the items table
:return: None
"""
db.session.delete(self)
db.session.commit()
class UserKey(db.Model):
__tablename__ = 'userkeys'
id = db.Column(db.Integer, primary_key=True)
accesskey = db.Column(db.String(64), unique=True)
secretkey = db.Column(db.String(64), unique=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, akey, skey):
self.accesskey = akey
self.secretkey = skey
class Board(db.Model):
__tablename__ = "boards"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
def __init__(self, title):
self.title = title
def serialize(self):
return {"id": self.id, "title": self.title}
class StoreModel(db.Model
): ## Extend SQLAlchemy model for easier db interaction
## Setup SQLAchemy Variables
## Table
__tablename__ = 'stores'
## Table Columns
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
## Pull back all items associated with given store
items = db.relationship(
'ItemModel', lazy='dynamic'
) ## List of item models but don't load until StoreModel.json is called
def __init__(self, name: str):
self.name = name
def json(self) -> Dict:
return {
'id': self.id,
'name': self.name,
'items': [item.json() for item in self.items.all()]
}
@classmethod ## Keep as class because it returns an object of ItemModel
def find_by_name(cls, name: str):
"""
Search the items table for an existing item
:param name: Name of the item
:return: Item if exists in the db
"""
return cls.query.filter_by(name=name).first(
) ## Use SQLAlchemy to build model from database data
@classmethod
def find_all(cls):
return cls.query.all()
def save_to_db(self) -> None:
"""
Upsert a new store into the store table
:return: None
"""
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
"""
Delete a store from the store table
:return: None
"""
db.session.delete(self)
db.session.commit()
class SubUser(db.Model):
__tablename__ = 'subusers'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, nullable=False)
secretkey = db.Column(db.String(64))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
def __init__(self, username):
self.username = username
def __repr__(self):
return '<SubUser: %r>' % self.username
class Bucket(db.Model):
__tablename__ = 'buckets'
id = db.Column(db.Integer, primary_key=True)
bkname = db.Column(db.String(64), unique=True, nullable=False)
permission = db.Column(db.String(64))
subusers = db.relationship('SubUser', backref='user', lazy=True)
userkeys = db.relationship('UserKey', backref='user', lazy=True)
def __init__(self, username):
self.username = username
def __repr__(self):
return '<User: %r>' % self.username
class UserModel(db.Model
): ## Extend SQLAlchemy model for easier db interaction
## Setup SQLAchemy Variables
## Table
__tablename__ = 'users'
## Table Columns
id = db.Column(db.Integer, primary_key=True) ## Auto incrementing
username = db.Column(db.String)
password = db.Column(db.String)
def __init__(self, username: str, password: str):
self.username = username
self.password = password
def json(self):
return {'id': self.id, 'username': self.username}
def save_to_db(self) -> None:
"""
Insert a new user into the user table
:return: None
"""
db.session.add(self)
db.session.commit()
def delete_from_db(self) -> None:
"""
Delete a user from the user table
:return: None
"""
db.session.delete(self)
db.session.commit()
@classmethod
def find_by_username(cls, username):
"""
Find a given user in the database for authentication
:param username: String input of the username
:return: User object, user, we will use for auth
"""
return cls.query.filter_by(username=username).first()
@classmethod
def find_by_id(cls, _id):
"""
Find a given user in the database for authentication
:param _id: INT input fo the user_id
:return: User object, user, we will use for auth
"""
return cls.query.filter_by(id=_id).first()
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True, nullable=False)
displayname = db.Column(db.String(64))
email = db.Column(db.String(64))
#opmask = db.Column(db.String(32))
#caps = db.Column(db.String(64))
subusers = db.relationship('SubUser', backref='user', lazy=True)
userkeys = db.relationship('UserKey', backref='user', lazy=True)
def __init__(self, username):
self.username = username
def __repr__(self):
return '<User: %r>' % self.username
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(80), unique=True, nullable=False)
hashed_pass = db.Column(db.String(120), nullable=False)
boards = db.relationship(
"Board",
secondary=boards,
lazy="subquery",
backref=db.backref("users", lazy=True),
)
def __init__(self, email, hashed_pass):
self.email = email
self.hashed_pass = hashed_pass
def __repr__(self):
return "<User %r>" % self.email
def generate_token(self):
try:
now = datetime.datetime.utcnow()
payload = {
"exp": now + datetime.timedelta(days=1),
"iat": now,
"sub": self.id,
}
token = jwt.encode(payload,
os.getenv("JWT_SECRET"),
algorithm="HS256").decode("utf-8")
return token
except Exception as e:
raise e
@staticmethod
def decode_auth_token(auth_token):
try:
payload = jwt.decode(auth_token, os.getenv("JWT_SECRET"))
return payload["sub"]
except jwt.ExpiredSignatureError:
return "Signature expired. Please log in again."
except jwt.InvalidTokenError:
return "Invalid token. Please log in again."
def get_boards(self):
boards = [b.serialize() for b in self.boards]
return boards
class GoldModel(db.Model):
__tablename__ = 'golds'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String(80))
buy = db.Column(db.Float)
sell = db.Column(db.Float)
def __init__(
self,
date,
buy,
sell,
):
self.date = date
self.buy = buy
self.sell = sell
def json(self):
return {
'date': self.date,
'buy': self.buy,
'sell': self.sell,
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def save_list_to_db(cls, list):
for item in list:
db.session.add(item)
db.session.commit()
@classmethod
def get_by_date(cls, date):
return cls.query.filter(cls.date >= date).order_by(desc(cls.date))
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def get_max_date(cls):
return cls.query.order_by(desc(cls.date)).limit(1).first().date
class FundModel(db.Model):
__tablename__ = 'funds'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
date = db.Column(db.String(80))
price = db.Column(db.Float)
def __init__(
self,
name,
date,
price,
):
self.name = name
self.date = date
self.price = price
def json(self):
return {
'name': self.name,
'date': self.date,
'price': self.price,
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def save_list_to_db(cls, list):
for item in list:
db.session.add(item)
db.session.commit()
@classmethod
def get_by_date(cls, date):
return cls.query.filter(cls.date >= date).order_by(desc(cls.date))
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def get_max_date(cls):
return cls.query.order_by(desc(cls.date)).limit(1).first().date
class TrainerModel(db.Model):
__tablename__ = 'trainers'
id = db.Column(db.String, primary_key=True)
first_name = db.Column(db.String(50))
middle_name = db.Column(db.String(50))
last_name = db.Column(db.String(50))
email = db.Column(db.String(100))
phone_No_1 = db.Column(db.String(25))
phone_No_2 = db.Column(db.String(25))
phone_No_3 = db.Column(db.String(25))
registration_date = db.Column(db.DateTime)
def __init__(self, first_name, middle_name, last_name, email, phone_No_1,
phone_No_2="", phone_No_3="", registration_date=None, _id=None):
self.first_name = first_name.lower()
self.middle_name = middle_name.lower()
self.last_name = last_name.lower()
self.email = email
self.phone_No_1, self.phone_No_2, self.phone_No_3 = phone_No_1, phone_No_2, phone_No_3
self.registration_date = registration_date or datetime.utcnow()
self.id = _id or uuid.uuid4().hex
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def json(self):
rd = self.registration_date
return {"id": self.id,
"first_name": self.first_name,
"middle_name": self.middle_name,
"last_name": self.last_name,
"email": self.email,
"phone_No_1": self.phone_No_1,
"phone_No_2": self.phone_No_2,
"phone_No_3": self.phone_No_3,
"registration_date": [rd.year, rd.month, rd.day, rd.hour, rd.minute, rd.second]}
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class ExchangeModel(db.Model):
__tablename__ = 'exchanges'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.String(80))
usd_twd = db.Column(db.Float)
eur_usd = db.Column(db.Float)
gbp_usd = db.Column(db.Float)
aud_usd = db.Column(db.Float)
nzd_usd = db.Column(db.Float)
def __init__(
self,
date,
usd_twd,
eur_usd,
gbp_usd,
aud_usd,
nzd_usd,
):
self.date = date
self.usd_twd = usd_twd
self.eur_usd = eur_usd
self.gbp_usd = gbp_usd
self.aud_usd = aud_usd
self.nzd_usd = nzd_usd
def json(self):
return {
'date': self.date,
'usd_twd': self.usd_twd,
'eur_usd': self.eur_usd,
'gbp_usd': self.gbp_usd,
'aud_usd': self.aud_usd,
'nzd_usd': self.nzd_usd
}
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def save_list_to_db(cls, list):
for item in list:
db.session.add(item)
db.session.commit()
@classmethod
def get_by_date(cls, date):
return cls.query.filter(cls.date >= date).order_by(desc(cls.date))
@classmethod
def get_all(cls):
return cls.query.all()
@classmethod
def get_max_date(cls):
return cls.query.order_by(desc(cls.date)).limit(1).first().date
class AdminModel(db.Model):
__tablename__ = 'admins'
id = db.Column(db.String, primary_key=True)
phone_No = db.Column(db.String(25))
password = db.Column(db.String(50))
def __init__(self, phone_no, password, _id=None):
self.phone_No = phone_no
self.password = password
self.id = _id or uuid.uuid4().hex
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def find_by_phone_no(cls, phone_no):
return cls.query.filter_by(username=phone_no).first()
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
import jwt
import datetime
import os
from common.db import db
boards = db.Table(
"boards_users",
db.Column("board_id",
db.Integer,
db.ForeignKey("boards.id"),
primary_key=True),
db.Column("user_id",
db.Integer,
db.ForeignKey("users.id"),
primary_key=True),
)
class User(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(80), unique=True, nullable=False)
hashed_pass = db.Column(db.String(120), nullable=False)
boards = db.relationship(
"Board",
secondary=boards,
lazy="subquery",
backref=db.backref("users", lazy=True),
)
def __init__(self, email, hashed_pass):
class CustomerModel(db.Model):
__tablename__ = 'customers'
id = db.Column(db.String, primary_key=True)
first_name = db.Column(db.String(50))
middle_name = db.Column(db.String(50))
last_name = db.Column(db.String(50))
gender = db.Column(db.String(10))
email = db.Column(db.String(100))
phone_No_1 = db.Column(db.String(25))
phone_No_2 = db.Column(db.String(25))
phone_No_3 = db.Column(db.String(25))
address = db.Column(db.String(250))
date_of_birth = db.Column(db.Date)
social_status = db.Column(db.String(25))
national_id = db.Column(db.String(25))
has_smartphone = db.Column(db.Boolean)
has_computer = db.Column(db.Boolean)
has_internet = db.Column(db.Boolean)
registration_date = db.Column(db.DateTime)
def __init__(self,
first_name,
last_name,
gender,
date_of_birth,
address,
email,
social_status,
national_id,
phone_No_1,
has_smartphone=False,
has_computer=False,
has_internet=False,
phone_No_2="",
phone_No_3="",
middle_name="",
registration_date=None,
_id=None):
self.first_name = first_name.lower()
self.middle_name = middle_name.lower()
self.last_name = last_name.lower()
self.gender = gender
self.email = email
self.phone_No_1, self.phone_No_2, self.phone_No_3 = phone_No_1, phone_No_2, phone_No_3
self.address = address
self.date_of_birth = date(*date_of_birth)
self.social_status = social_status
self.national_id = national_id
self.has_smartphone = has_smartphone
self.has_computer = has_computer
self.has_internet = has_internet
self.registration_date = registration_date or datetime.utcnow()
self.id = _id or uuid.uuid4().hex
# print(self.__dict__)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def json(self):
d = self.date_of_birth
rd = self.registration_date
return {
"id":
self.id,
"first_name":
self.first_name,
"middle_name":
self.middle_name,
"last_name":
self.last_name,
"gender":
self.gender,
"social_status":
self.social_status,
"national_id":
self.national_id,
"email":
self.email,
"phone_No_1":
self.phone_No_1,
"phone_No_2":
self.phone_No_2,
"phone_No_3":
self.phone_No_3,
"address":
self.address,
"date_of_birth": [d.year, d.month, d.day],
"has_smartphone":
self.has_smartphone,
"has_computer":
self.has_computer,
"has_internet":
self.has_internet,
"registration_date":
[rd.year, rd.month, rd.day, rd.hour, rd.minute, rd.second]
}
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
@classmethod
def find_by_email(cls, email):
return cls.query.filter_by(email=email).first()
class Procedure(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
status = db.Column(db.String(10), nullable=False)
accurancy = db.Column(db.Float, nullable=True)
model_path = db.Column(db.String(160), nullable=True)
class Output(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
procedure = db.Column(db.Integer,
db.ForeignKey('procedure.id'),
nullable=False)
name = db.Column(db.String(160), nullable=False)
class CourseModel(db.Model):
__tablename__ = "courses"
id = db.Column(db.String, primary_key=True)
name = db.Column(db.String(150))
category = db.Column(db.Enum)
trainers = db.Column(db.ARRAY(db.String, zero_indexes=True))
description = db.Column(db.Text(1500))
target_audience = db.Column(db.ARRAY(db.String(50), zero_indexes=True))
outcomes = db.Column(db.Text(1500))
requirements = db.Column(db.Text(1500))
start_date = db.Column(db.Date)
end_date = db.Column(db.Date)
total_lectures = db.Column(db.Integer)
lectures_per_week = db.Column(db.Integer)
lecture_duration = db.Column(db.Interval)
min_spg = db.Column(db.Integer) # spg stands for (students per group)
max_spg = db.Column(db.Integer)
def __init__(self,
name,
category,
trainers,
description,
target_audience,
outcomes,
requirements,
start_date,
end_date,
total_lectures,
lectures_per_week,
lecture_duration,
min_spg,
max_spg,
_id=None,
registration_date=None):
self.name = name
self.category = category
self.trainers = trainers
self.description = description
self.target_audience = target_audience
self.outcomes = outcomes
self.requirements = requirements
self.start_date = date(*start_date)
self.end_date = date(*end_date)
self.total_lectures = total_lectures
self.lectures_per_week = lectures_per_week
self.lecture_duration = timedelta(**lecture_duration)
self.min_spg = min_spg # spg stands for (students per group)
self.max_spg = max_spg
self.id = _id or uuid.uuid4().hex
self.registration_date = registration_date or datetime.utcnow()
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
def json(self):
sd = self.start_date
ed = self.end_date
rd = self.registration_date
return {
"id":
self.id,
"name":
self.name,
"category":
self.category,
"trainers":
self.trainers,
"description":
self.description,
"target_audience":
self.target_audience,
"outcomes":
self.outcomes,
"requirements":
self.requirements,
"start_date": [sd.year, sd.month, sd.day],
"end_date": [ed.year, ed.month, ed.day],
"total_lectures":
self.total_lectures,
"lectures_per_week":
self.lectures_per_week,
"lecture_duration":
self.lecture_duration,
"min_students_per_group":
self.min_spg,
"max_students_per_group":
self.max_spg,
"registration_date":
[rd.year, rd.month, rd.day, rd.hour, rd.minute, rd.second]
}
@classmethod
def find_by_id(cls, _id):
return cls.query.filter_by(id=_id).first()
