class ExmoPair(db.Model):
"""docstring for PairSettings"""
id = db.Column(db.Integer, primary_key=True)
exchange_id = db.Column(db.Integer, db.ForeignKey('exchange.id'))
ticker = db.Column(db.String(24))
orders = db.relationship('ExmoOrder', backref='pair', lazy=True)
# * Exchange pair_settings:
min_quantity = db.Column(db.Float) # minimum quantity per order
max_quantity = db.Column(db.Float) # maximum quantity per order
min_price = db.Column(db.Float) # minimum order price
max_price = db.Column(db.Float) # maximum order price
min_amount = db.Column(db.Float) # minimum order amount
max_amount = db.Column(db.Float) # maximum order amount
def __init__(self, exchange_id, ticker):
self.exchange_id = exchange_id
self.ticker = ticker
self.update_pair_settings()
def update_pair_settings(self):
get_settings = ExmoAPI().pair_settings()
self.min_quantity = get_settings[self.ticker]['min_quantity']
self.max_quantity = get_settings[self.ticker]['max_quantity']
self.min_price = get_settings[self.ticker]['min_price']
self.max_price = get_settings[self.ticker]['max_price']
self.min_amount = get_settings[self.ticker]['min_amount']
self.max_amount = get_settings[self.ticker]['max_amount']
def __repr__(self):
return '<Pair {}>'.format(self.ticker)
class ExmoCurrency(db.Model):
"""docstring for Currency"""
id = db.Column(db.Integer, primary_key=True)
exchange_id = db.Column(db.Integer, db.ForeignKey('exchange.id'))
ticker = db.Column(db.String(24))
def __repr__(self):
return '<Currency {}>'.format(self.ticker)
class ExmoOrder(db.Model):
"""docstring for UserOrder"""
id = db.Column(db.Integer, primary_key=True)
trade_profile_id = db.Column(db.Integer, db.ForeignKey('trade_profile.id'))
pair_id = db.Column(db.Integer, db.ForeignKey('exmo_pair.id'))
status = db.Column(db.String(24)) # stop-loss||take-profit||open||cancel
# * Exchange order settings:
# order_id = db.Column(db.BigInteger) # order id
order_id = db.Column(db.String(24))
created = db.Column(db.DateTime) # date and time of order creation
order_type = db.Column(db.String(24)) # (market)_buy||sell_(total)
price = db.Column(db.Float) # order price
quantity = db.Column(db.Float) # quantity per order
amount = db.Column(db.Float) # order amount
# ! Relationship
trades = db.relationship('ExmoOrderTrades', backref='order', lazy=True)
def __init__(self, trade_profile_id, ticker, status, order_id):
self.trade_profile_id = trade_profile_id
self.pair_id = ExmoPair.query.filter_by(ticker=ticker).first().id
self.status = status
self.order_id = order_id
self.get_order_params(order_id)
def get_order_params(self, order_id):
trade_profile = TradeProfile.query.get(self.trade_profile_id)
current_pair = ExmoPair.query.get(self.pair_id)
user_open_orders = ExmoAPI(
trade_profile.public_key,
trade_profile.secret_key).user_open_orders()
current_order = user_open_orders[current_pair.ticker]
for item in current_order:
if item['order_id'] == str(order_id):
self.order_id = item['order_id']
self.created = datetime.fromtimestamp(int(item['created']))
self.order_type = item['type']
self.price = item['price']
self.quantity = item['quantity']
self.amount = item['amount']
def __repr__(self):
return '<ExmoOrder_id {}>'.format(self.order_id)
class TradeProfile(db.Model):
"""docstring for PrivateSettings"""
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
exchange_id = db.Column(db.Integer, db.ForeignKey('exchange.id'))
name = db.Column(db.String(12))
secret_key = db.Column(db.String(128))
public_key = db.Column(db.String(128))
# ! Relationship
# * Exmo:
exmo_orders = db.relationship('ExmoOrder',
backref='trade_profile',
lazy=True)
def __repr__(self):
return '<Name: {}>'.format(self.name)
class ExmoOrderTrades(db.Model):
id = db.Column(db.Integer, primary_key=True)
exmo_order_id = db.Column(db.Integer, db.ForeignKey('exmo_order.id'))
# * Exchange order settings:
trade_id = db.Column(db.String(24)) # transaction id
date = db.Column(db.DateTime) # transaction date and time
quantity = db.Column(db.Float) # quantity per transaction
price = db.Column(db.Float) # transaction price
amount = db.Column(db.Float) # transaction amount
class User(db.Model):
"""docstring for Users """
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), unique=True)
password = db.Column(db.String(512))
email = db.Column(db.String(120), unique=True)
roles = db.Column(db.Text)
is_active = db.Column(db.Boolean, default=True, server_default='true')
# ! Relationship
trade_profiles = db.relationship('TradeProfile', backref='user', lazy=True)
# ! Guard Flask-Praetorian help methods
@property
def rolenames(self):
try:
return self.roles.split(',')
except Exception:
return []
@classmethod
def lookup(cls, username):
return cls.query.filter_by(username=username).one_or_none()
@classmethod
def identify(cls, id):
return cls.query.get(id)
@property
def identity(self):
return self.id
def is_valid(self):
return self.is_active
def set_password(self, password):
self.password = guard.hash_password(password)
def __repr__(self):
return '<User: {}>'.format(self.username)
class Exchange(db.Model):
"""docstring for Exchange"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128))
# ! Relationship
trade_profiles = db.relationship('TradeProfile',
backref='exchange',
lazy=True)
# * Exmo:
exmo_currencies = db.relationship('ExmoCurrency',
backref='exchange',
lazy=True)
exmo_pairs = db.relationship('ExmoPair', backref='exchange', lazy=True)
def __repr__(self):
return '<Exchange {}>'.format(self.name)