class ChangeEmail(db.Model):
user_id = db.Column(db.Integer, primary_key=True, nullable=False)
change_email_token = db.Column(db.String(100),
primary_key=True,
nullable=False)
new_email = db.Column(db.String(200), nullable=False)
created_date = db.Column(db.DateTime(), nullable=False)
def __init__(self):
return
def __init__(self, dic):
self.from_dic(dic)
def is_valid(self):
if self.user_id < 0:
return False
if self.new_email.strip() == '':
return False
if not validate_email(self.new_email):
return False
return True
def from_dic(self, dic):
self.change_email_token = uuid.uuid4()
try:
self.user_id = int(dic.get("userId", ""))
except:
self.user_id = -1
self.new_email = dic.get("newEmail", "").strip().lower()
self.created_date = datetime.datetime.utcnow()
class Withdrawal(db.Model):
user_id = db.Column(db.Integer, primary_key=True, nullable=False)
withdrawal_id = db.Column(db.Integer, primary_key=True, nullable=False)
address = db.Column(db.String(100), nullable=False)
amount = db.Column(db.BigInteger, nullable=False)
withdrawal_token = db.Column(db.String(100), nullable=False)
cancelled = db.Column(db.Boolean, nullable=False)
transaction_id = db.Column(db.String(100), nullable=False)
created_date = db.Column(db.DateTime(), nullable=False)
confirmed_date = db.Column(db.DateTime())
sent_date = db.Column(db.DateTime())
def to_dic(self):
return {
"userId": self.user_id,
"withdrawalId": self.withdrawal_id,
"address": self.address,
"amount": self.amount,
"cancelled": self.cancelled,
"transactionId": self.transaction_id,
"createdDate": self.created_date,
"confirmedDate": self.confirmed_date,
"sentDate": self.sent_date
}
def clone(self):
return copy.copy(self)
def copy_values(self, item):
self.__dict__.update(item.__dict__)
class Email(db.Model):
email_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
address = db.Column(db.String(2000), nullable=False)
sent_date = db.Column(db.DateTime(), nullable=False, index=True)
subject = db.Column(db.String(2000), nullable=False)
body = db.Column(db.Text, nullable=False)
class Currency(db.Model):
currency_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
symbol = db.Column(db.String(5), unique=True, nullable=False)
name = db.Column(db.String(100), nullable=False)
price_decimal_point = db.Column(db.Integer, nullable=False)
def __init__(self):
self.price = 0
class Transaction(db.Model):
equity_id = db.Column(db.Integer, primary_key=True, nullable=False)
transaction_id = db.Column(db.Integer, primary_key=True, nullable=False)
user_id_long = db.Column(db.Integer, nullable=False)
user_id_short = db.Column(db.Integer, nullable=False)
quantity = db.Column(db.BigInteger, nullable=False)
price = db.Column(db.BigInteger, nullable=False)
is_buy = db.Column(db.Boolean, nullable=False)
created_date = db.Column(db.DateTime(), nullable=False)
@staticmethod
def id_comparer(item1, item2):
return 1 if item1.transaction_id < item2.transaction_id else -1 if item1.transaction_id > item2.transaction_id else 0
def clone(self):
return copy.copy(self)
def copy_values(self, item):
self.__dict__.update(item.__dict__)
@staticmethod
def get_user_ids(item):
result = [item.user_id_long]
if item.user_id_long != item.user_id_short:
result.append(item.user_id_short)
return result
class UserRegister(db.Model):
registration_token = db.Column(db.String(100),
primary_key=True,
nullable=False)
username = db.Column(db.String(100), index=True, nullable=False)
email = db.Column(db.String(200), index=True, nullable=False)
password = db.Column(db.String(200), nullable=False)
registration_date = db.Column(db.DateTime(), nullable=False)
def __init__(self):
return
def __init__(self, dic):
self.from_dic(dic)
def is_valid(self):
if not re.match('^[a-zA-Z0-9_\-]{6,}$', self.username):
return False
if self.email.strip() == '':
return False
if not validate_email(self.email):
return False
if len(self.password) < 8:
return False
return True
def set_password(self, password):
self.password = hashlib.sha512(
(password + app.config['SALT']).encode('utf-8')).hexdigest()
def from_dic(self, dic):
self.registration_token = uuid.uuid4()
self.username = dic.get("username", "").strip().lower()
self.email = dic.get("email", "").strip().lower()
self.password = dic.get("password", "")
self.registration_date = datetime.datetime.utcnow()
def to_dic(self):
return {
"registrationToken": self.registration_token,
"username": self.username,
"email": self.email,
"registrationDate": self.registration_date
}
class DepositAddress(db.Model):
user_id = db.Column(db.Integer, primary_key=True, nullable=False)
address_id = db.Column(db.Integer, primary_key=True, nullable=False)
address = db.Column(db.String(100), nullable=False)
created_date = db.Column(db.DateTime(), nullable=False)
def to_dic(self):
return {
"userId": self.user_id,
"addressId": self.address_id,
"address": self.address,
"createdDate": self.created_date
}
def clone(self):
return copy.copy(self)
def copy_values(self, item):
self.__dict__.update(item.__dict__)
class Contract(db.Model):
PRICE_MULTIPLIER = 1000
equity_id = db.Column(db.Integer, primary_key=True, nullable=False)
contract_id = db.Column(db.Integer, primary_key=True, nullable=False)
user_id = db.Column(db.Integer, nullable=False)
modified_id = db.Column(db.Integer, nullable=False)
is_long = db.Column(db.Boolean, nullable=False)
quantity = db.Column(db.BigInteger, nullable=False)
price = db.Column(db.BigInteger, nullable=False)
status = db.Column(db.Integer, nullable=False)
created_date = db.Column(db.DateTime(), nullable=False)
closed_date = db.Column(db.DateTime())
def get_price(self):
return self.price / (self.PRICE_MULTIPLIER + 0.0)
def clone(self):
return copy.copy(self)
def copy_values(self, item):
self.__dict__.update(item.__dict__)
@staticmethod
def is_opened(item):
return item.is_opened()
def is_opened(self):
return self.status == ContractStatus.OPENED
def get_quantity(self, equity):
return self.quantity * math.pow(10, equity.decimal_points_quantity)
@staticmethod
def id_comparer(item1, item2):
return 1 if item1.contract_id < item2.contract_id else -1 if item1.contract_id > item2.contract_id else 0
@staticmethod
def modified_id_comparer(item1, item2):
return 1 if item1.modified_id < item2.modified_id else -1 if item1.modified_id > item2.modified_id else 0
class Equity(db.Model):
PERCENT_MULTIPLIER = 10000
equity_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
symbol = db.Column(db.String(100), nullable=False)
name = db.Column(db.String(100), nullable=False)
broker = db.Column(db.String(100), nullable=False)
base_currency_index = db.Column(db.Integer, nullable=False)
decimal_points_price = db.Column(db.Integer, nullable=False)
decimal_points_quantity = db.Column(db.Integer, nullable=False)
smallest_quantity = db.Column(db.Integer, nullable=False)
api_index = db.Column(db.Integer, nullable=False)
api_symbol = db.Column(db.String(100), nullable=False)
tradable_requirement = db.Column(db.Integer, nullable=False)
margin_requirement = db.Column(db.Integer, nullable=False)
def __init__(self):
self.current_price = -1
return
def __init__(self, dic):
self.current_price = -1
self.from_dic(dic)
def clone(self):
return copy.copy(self)
def copy_values(self, item):
self.__dict__.update(item.__dict__)
def get_price(self):
return self.current_price / (self.decimal_points_price + 0.0)
def from_dic(self, dic):
self.equity_id = dic.get("equityId", None)
self.symbol = dic.get("symbol", "")
self.name = dic.get("name", "")
self.broker = dic.get("broker", "")
self.base_currency_index = dic.get("baseCurrencyIndex", 0)
self.decimal_points_price = dic.get("decimalPointsPrice", 1)
self.decimal_points_quantity = dic.get("decimalPointsQuantity", 1)
self.smallest_quantity = dic.get("smallestQuantity", "")
self.api_index = dic.get("apiIndex", "")
self.api_symbol = dic.get("apiSymbol", "")
self.tradable_requirement = dic.get("tradableRequirement", "")
self.margin_requirement = dic.get("marginRequirement", "")
def to_dic(self):
return {
"equityId": self.equity_id,
"symbol": self.symbol,
"name": self.name,
"broker": self.broker,
"baseCurrencyIndex": self.base_currency_index,
"decimalPointsPrice": self.decimal_points_price,
"decimalPointsQuantity": self.decimal_points_quantity,
"smallestQuantity": self.smallest_quantity,
"apiIndex": self.api_index,
"apiSymbol": self.api_symbol,
"tradableRequirement": self.tradable_requirement,
"marginRequirement": self.margin_requirement
}
class OrderId(db.Model):
equity_id = db.Column(db.Integer, primary_key=True, nullable=False)
order_id = db.Column(db.Integer, nullable=False)
class ExchangeFee(db.Model):
exchange_id = db.Column(db.Integer, primary_key=True, nullable=False)
maker_fee = db.Column(db.Integer, primary_key=True, nullable=False)
taker_fee = db.Column(db.Integer, primary_key=True, nullable=False)
class CurrentAddressCount(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
address_index = db.Column(db.Integer, nullable=False)
class Participant(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
def __repr__(self):
return '<Participant %s>' % self.name
class User(db.Model):
user_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
username = db.Column(db.String(100), unique=True, nullable=False)
email = db.Column(db.String(200), unique=True, nullable=False)
two_f_a_token = db.Column(db.String(100), nullable=False)
two_f_a_enabled = db.Column(db.Boolean, nullable=False)
password = db.Column(db.String(200), nullable=False)
balance = db.Column(db.BigInteger, nullable=False)
is_margin_called = db.Column(db.Boolean, nullable=False)
is_admin = db.Column(db.Boolean, nullable=False)
registration_date = db.Column(db.DateTime(), nullable=False)
def __init__(self):
self.margin_used = 0
self.margin_used_percent = 0.0
self.margin_used_orders = 0
self.margin_used_orders_percent = 0.0
def __init__(self, user_register):
self.margin_used = 0
self.margin_used_percent = 0.0
self.margin_used_orders = 0
self.margin_used_orders_percent = 0.0
self.from_user_register(user_register)
def clone(self):
return copy.copy(self)
def copy_values(self, item):
self.__dict__.update(item.__dict__)
def init_calculated_field(self):
self.margin_used = 0
self.margin_used_percent = 0.0
self.margin_used_orders = 0
self.margin_used_orders_percent = 0.0
def from_user_register(self, user_register):
self.username = user_register.username
self.email = user_register.email
self.two_f_a_token = ""
self.two_f_a_enabled = False
self.password = user_register.password
self.balance = 0.0
self.is_margin_called = False
self.is_admin = False
self.registration_date = datetime.datetime.utcnow()
def to_dic(self):
return {
"userId": self.user_id,
"username": self.username,
"email": self.email,
"twoFactorEnabled": self.two_f_a_enabled,
"balance": int(self.balance),
"isMarginCalled": self.is_margin_called,
"isAdmin": self.is_admin,
"registrationDate": self.registration_date
}
@staticmethod
def margin_used_percent_comparer_dec(item1, item2):
comp = 1 if item1.margin_used_percent > item2.margin_used_percent else -1 if item1.margin_used_percent < item2.margin_used_percent else 0
if comp != 0:
return comp
return -1 if item1.user_id > item2.user_id else 1 if item1.user_id < item2.user_id else 0
@staticmethod
def margin_used_orders_percent_comparer_dec(item1, item2):
comp = 1 if item1.margin_used_orders_percent > item2.margin_used_orders_percent else -1 if item1.margin_used_orders_percent < item2.margin_used_orders_percent else 0
if comp != 0:
return comp
return -1 if item1.user_id > item2.user_id else 1 if item1.user_id < item2.user_id else 0
def check_password(self, password):
return hashlib.sha512(
(password +
app.config['SALT']).encode('utf-8')).hexdigest() == self.password
def check_token(self, token):
if not self.two_f_a_enabled:
return True
totp = pyotp.TOTP(self.two_f_a_token)
return totp.verify(token)
def set_password(self, password):
self.password = hashlib.sha512(
(password + app.config['SALT']).encode('utf-8')).hexdigest()
def can_place_order(self, order):
pass
def can_execute_order(self, order, next_price):
pass
def add_to_balance_and_margin(self, balance, margin, margin_orders,
bitcoin_price):
self.balance += math.floor(balance)
self.margin_used += math.ceil(margin)
self.margin_used_orders += math.ceil(margin_orders)
self.margin_used_percent = self.margin_used / (self.balance + 0.0)
self.margin_used_orders_percent = self.margin_used_orders / (
self.balance + 0.0)
if self.is_margin_called and self.margin_used_percent / bitcoin_price < 1.0:
self.is_margin_called = False
class Order(db.Model):
equity_id = db.Column(db.Integer, primary_key=True, nullable=False)
order_id = db.Column(db.BigInteger, primary_key=True, nullable=False)
user_id = db.Column(db.Integer, nullable=False)
is_margin_call = db.Column(db.Boolean, nullable=False)
prev_order_id = db.Column(db.BigInteger, nullable=False)
next_order_id = db.Column(db.BigInteger, nullable=False)
modification_id = db.Column(db.BigInteger,
primary_key=True,
nullable=False)
is_long = db.Column(db.Boolean, nullable=False)
quantity = db.Column(db.BigInteger, nullable=False)
order_type = db.Column(db.Integer, nullable=False)
price = db.Column(db.BigInteger, nullable=False)
has_trigger_limit = db.Column(db.Boolean, nullable=False)
trigger_price = db.Column(db.BigInteger, nullable=False)
trigger_limit_price = db.Column(db.BigInteger, nullable=False)
has_trailing_limit = db.Column(db.Boolean, nullable=False)
trailing_start_transaction_id = db.Column(db.BigInteger, nullable=False)
trailing_stop_percent = db.Column(db.Integer, nullable=False)
trailing_stop_limit_percent = db.Column(db.Integer, nullable=False)
filled_quantity = db.Column(db.BigInteger, nullable=False)
status = db.Column(db.Integer, nullable=False)
created_date = db.Column(db.DateTime(), nullable=False)
closed_date = db.Column(db.DateTime())
def __init__(self):
self.effective_price = 0
self.trailing_price_max = -1
self.trailing_price = -1
self.trailing_price_limit = -1
def __init(self, dic):
self.effective_price = 0
self.trailing_price_max = -1
self.trailing_price = -1
self.trailing_price_limit = -1
self.from_dic(dic)
@staticmethod
def new_market_order(equity_id, order_id, user_id, is_long, quantity):
order = Order()
order.equity_id = equity_id
order.order_id = order_id
order.is_margin_call = False
order.user_id = user_id
order.prev_order_id = -1
order.next_order_id = -1
order.modification_id = order_id
order.is_long = is_long
order.order_type = OrderType.MARKET
order.price = -1
order.has_trigger_limit = False
order.trigger_price = 0
order.trigger_limit_price = 0
order.has_trailing_limit = False
order.trailing_start_transaction_id = 0
order.trailing_stop_percent = 0
order.trailing_stop_limit_percent = 0
order.filled_quantity = 0
order.status = OrderStatus.OPENED
order.created_date = datetime.datetime.utcnow()
order.closed_date = None
return order
def clone(self):
return copy.copy(self)
def copy_values(self, item):
self.__dict__.update(item.__dict__)
def close(self):
self.status = OrderStatus.CLOSED
self.closed_date = datetime.datetime.utcnow()
def is_filled(self):
return self.filled_quantity == self.quantity
def get_price(self):
return self.effective_price
def get_long_short_string(self):
return "long" if self.is_long else "short"
def get_quantity(self, equity):
return self.quantity * math.pow(10, equity.decimal_points_quantity)
def remaining_quantity(self, equity):
return (self.quantity - self.filled_quantity) * math.pow(
10, equity.decimal_points_quantity)
def update_trailing_price(self):
self.trailing_price = ((10000.0 + (
(1 if self.is_long else -1) * self.trailing_stop_percent)) /
10000.0)
self.effective_price = self.trailing_price
@staticmethod
def price_comparer(item1, item2):
comp = -1 if item1.price > item2.price else 1 if item1.price < item2.price else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def price_comparer_dec(item1, item2):
comp = 1 if item1.price > item2.price else -1 if item1.price < item2.price else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def trigger_price_comparer(item1, item2):
comp = -1 if item1.trigger_price > item2.trigger_price else 1 if item1.trigger_price < item2.trigger_price else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def trigger_price_comparer_dec(item1, item2):
comp = 1 if item1.trigger_price > item2.trigger_price else -1 if item1.trigger_price < item2.trigger_price else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def trailing_price_comparer(item1, item2):
comp = -1 if item1.trailing_price > item2.trailing_price else 1 if item1.trailing_price < item2.trailing_price else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def trailing_price_comparer_dec(item1, item2):
comp = 1 if item1.trailing_price > item2.trailing_price else -1 if item1.trailing_price < item2.trailing_price else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def trailing_price_max_comparer(item1, item2):
comp = -1 if item1.trailing_price_max > item2.trailing_price_max else 1 if item1.trailing_price_max < item2.trailing_price_max else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def trailing_price_max_comparer_dec(item1, item2):
comp = 1 if item1.trailing_price_max > item2.trailing_price_max else -1 if item1.trailing_price_max < item2.trailing_price_max else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def effective_price_comparer(item1, item2):
comp = -1 if item1.effective_price > item2.effective_price else 1 if item1.effective_price < item2.effective_price else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def effective_price_comparer_dec(item1, item2):
comp = 1 if item1.effective_price > item2.effective_price else -1 if item1.effective_price < item2.effective_price else 0
if comp != 0:
return comp
return -1 if item1.order_id > item2.order_id else 1 if item1.order_id < item2.order_id else 0
@staticmethod
def id_comparer(item1, item2):
return 1 if item1.order_id < item2.order_id else -1 if item1.order_id > item2.order_id else 0
@staticmethod
def modification_id_comparer(item1, item2):
return 1 if item1.modification_id < item2.modification_id else -1 if item1.modification_id > item2.modification_id else 0
@staticmethod
def is_opened_long_limit(item):
return item.is_opened() and item.is_limit() and item.is_long
@staticmethod
def is_opened_short_limit(item):
return item.is_opened() and item.is_limit() and not item.is_long
@staticmethod
def is_opened_long_trigger(item):
return item.is_opened() and item.is_trigger() and item.is_long
@staticmethod
def is_opened_short_trigger(item):
return item.is_opened() and item.is_trigger() and not item.is_long
@staticmethod
def is_opened_long_trailing(item):
return item.is_opened() and item.is_trailing() and item.is_long
@staticmethod
def is_opened_short_trailing(item):
return item.is_opened() and item.is_trailing() and not item.is_long
def should_trigger_execute(self, equity):
if self.is_long:
return equity.price >= self.trigger_price
else:
return equity.price <= self.trigger_price
def execute_trigger(self):
self.price = self.trigger_limit_price
self.order_type = OrderType.MARKET if self.price < 0 else OrderType.LIMIT
def set_trailing_price(self, equity):
self.trailing_price_max = equity.current_price
tsp = self.trailing_stop_percent if self.is_long else -self.trailing_stop_percent
pm = Equity.PERCENT_MULTIPLIER
float_price = ((pm + tsp) / (pm + 0.0)) * equity.current_price
if self.is_long:
self.trailing_price = math.floor(float_price)
else:
self.trailing_price = math.ceil(float_price)
self.trailing_price = ((pm + tsp) / (pm + 0.0)) * equity.current_price
if self.has_trailing_limit:
tslp = self.trailing_stop_limit_percent if self.is_long else -self.trailing_stop_limit_percent
pm = Equity.PERCENT_MULTIPLIER
float_price = ((pm + tslp) / (pm + 0.0)) * equity.current_price
if self.is_long:
self.trailing_price_limit = math.ceil(float_price)
else:
self.trailing_price_limit = math.floor(float_price)
self.calculate_effective_price()
def close_and_create_triggered_order(self, next_id, current_price):
self.close()
self.next_order_id = next_id
order_type = OrderType.LIMIT
price = -1
has_trigger_limit = False
trigger_price = 0
trigger_limit_price = 0
activation_price = 0
if self.order_type == OrderType.TRIGGER or (
self.order_type == OrderType.RANGE and self.price < 0):
if self.has_trigger_limit:
price = self.trigger_limit_price
else:
price = -1
order_type = OrderType.MARKET
activation_price = self.trigger_price
elif self.order_type == OrderType.TRAILING_STOP:
if self.has_trailing_limit:
price = self.trailing_price_limit
else:
price = -1
order_type = OrderType.MARKET
activation_price = self.trailing_price
elif self.order_type == OrderType.RANGE:
if self.is_long and self.trigger_price >= current_price or not self.is_long and self.trigger_price <= current_price:
if self.has_trigger_limit:
price = self.trigger_limit_price
else:
price = -1
order_type = OrderType.MARKET
activation_price = self.trigger_price
else:
if self.has_trailing_limit:
price = self.trailing_price_limit
order_type = OrderType.Range
has_trigger_limit = self.has_trigger_limit
trigger_price = self.trigger_price
trigger_limit_price = self.trigger_limit_price
else:
price = -1
order_type = OrderType.MARKET
activation_price = self.trailing_price
order = Order(equity_id=self.equity_id,
order_id=next_id,
user_id=self.user_id,
is_margin_call=False,
prev_order_id=self.order_id,
next_order_id=-1,
modification_id=next_id,
is_long=self.is_long,
quantity=self.quantity,
order_type=order_type,
price=price,
has_trigger_limit=has_trigger_limit,
trigger_price=trigger_price,
trigger_limit_price=trigger_limit_price,
has_trailing_limit=False,
trailing_start_transaction_id=-1,
trailing_stop_percent=0,
trailing_stop_limit_percent=0,
filled_quantity=0,
status=OrderStatus.OPENED,
created_date=datetime.datetime.utcnow(),
closed_date=None)
order.trailing_price = activation_price
order.calculate_effective_price()
return order
def is_opened(self):
return self.order_status == OrderStatus.OPENED
def is_limit(self):
if self.order_type == OrderType.LIMIT:
return True
elif self.order_type == OrderType.MARKET:
return True
elif self.order_type == OrderType.RANGE and self.price >= 0:
return True
return False
def is_trigger(self):
if self.order_type == OrderType.TRIGGER or self.order_type == OrderType.RANGE:
return True
def is_only_trigger(self):
return self.order_type == OrderType.TRIGGER
def is_trailing(self):
if self.order_type == OrderType.TRAILING_STOP:
return True
elif self.order_type == OrderType.RANGE and self.price == -1:
return True
return False
def is_only_trailing(self):
return self.order_type == OrderType.TRAILING_STOP
def get_order_type_string(self):
if self.order_type == OrderType.MARKET:
return "market_order"
elif self.order_type == OrderType.LIMIT:
return "limit_order"
elif self.order_type == OrderType.TRIGGER:
return "trigger_order"
elif self.order_type == OrderType.TRAILING_STOP:
return "trailing_order"
elif self.order_type == OrderType.RANGE:
return "range_order"
def intersects(self, order):
if self.is_long == order.is_long:
return False
if not self.is_limit_or_market() and not order.is_limit_or_market():
return False
if self.price < 0 or order.price < 0:
return True
if order.is_long:
return order.price >= self.price
else:
return order.price <= self.price
def is_limit_or_market(self):
return self.order_type == OrderType.LIMIT or self.order_type == OrderType.MARKET
def calculate_effective_price(self):
if self.order_type == OrderType.LIMIT:
self.effective_price = self.price
elif self.order_type == OrderType.TRIGGER:
self.effective_price = self.trigger_price
elif self.order_type == OrderType.TRAILING_STOP:
self.effective_price = self.trailing_price
elif self.order_type == OrderType.RANGE:
self.effective_price = max(self.trailing_price, self.trigger_price,
self.price)
def to_dic(self):
return {
"equityId": self.equity_id,
"userId": self.user_id,
"orderId": self.order_id,
"prev_order_id": self.prev_order_id,
"next_order_id": self.prev_order_id,
"isMarginCall": self.is_margin_call,
"isLong": self.is_long,
"quantity": self.quantity,
"orderType": self.order_type,
"price": self.price,
"hasTriggerLimit": self.has_trigger_limit,
"triggerPrice": self.trigger_price,
"triggerLimitPrice": self.trigger_limit_price,
"hasTrailingLimit": self.has_trailing_limit,
"trailingStopPercent": self.trailing_stop_percent,
"trailingStopLimitPercent": self.trailing_stop_limit_percent,
"filledQuantity": self.filled_quantity,
"status": self.status,
"createdDate": self.created_date,
"closedDate": self.closed_date
}
def to_dic_private(self):
return {
"equityId": self.equity_id,
"orderId": self.order_id,
"isLong": self.is_long,
"isMarginCall": self.is_margin_call,
"quantity": self.quantity,
"orderType": self.order_type,
"price": self.price,
"hasTriggerLimit": self.has_trigger_limit,
"triggerPrice": self.trigger_price,
"triggerLimitPrice": self.trigger_limit_price,
"hasTrailingLimit": self.has_trailing_limit,
"trailingStopPercent": self.trailing_stop_percent,
"trailingStopLimitPercent": self.trailing_stop_limit_percent,
"filledQuantity": self.filled_quantity,
"status": self.status,
"createdDate": self.created_date,
"closedDate": self.closed_date,
"is_deleted": self.is_deleted,
"modification_id": self.modification_id
}
def from_dic(self, dic):
self.equity_id = int(dic.get("equityId", -1))
self.user_id = int(dic.get("userId", -1))
self.order_id = None
self.prev_order_id = -1
self.next_order_id = -1
self.is_margin_call = dic.get("isMarginCall", False)
self.is_long = dic.get("isLong", True)
self.quantity = int(dic.get("quantity", -1))
self.order_type = int(dic.get("orderType", -1))
self.price = int(dic.get("price", -1))
self.has_trigger_limit = dic.get("hasTriggerLimit", False)
self.trigger_price = int(dic.get("triggerPrice", -1))
self.trigger_limit_price = int(dic.get("triggerLimitPrice", -1))
self.has_trailing_limit = dic.get("hasTrailingLimit", False),
self.trailing_stop_percent = int(dic.get("trailingStopPercent", -1))
self.trailing_stop_limit_percent = int(
dic.get("trailingStopLimitPercent", -1))
self.filled_quantity = 0
self.status = OrderStatus.OPENED
self.created_date = datetime.datetime.utcnow()
self.closed_date = None
def is_valid(self):
if self.equity_id < 0:
return False
if self.user_id < 0:
return False
if not isinstance(self.is_long, bool):
return False
if self.quantity < 0:
return False
if self.order_type < 0 or self.order_type > 4:
return False
if self.order_type == OrderType.MARKET:
self.price = 0
self.has_trailing_limit = False
self.trigger_price = 0
self.trigger_limit_price = 0
self.has_trailing_limit = False
self.trailing_stop_percent = 0
self.trailing_stop_limit_percent = 0
elif self.order_type == OrderType.LIMIT:
self.has_trailing_limit = False
self.trigger_price = 0
self.trigger_limit_price = 0
self.has_trailing_limit = False
self.trailing_stop_percent = 0
self.trailing_stop_limit_percent = 0
elif self.order_type == OrderType.TRIGGER:
self.price = 0
self.has_trailing_limit = False
self.trailing_stop_percent = 0
self.trailing_stop_limit_percent = 0
if self.has_trigger_limit:
if self.is_long:
if self.trigger_price > self.trigger_limit_price:
return False
else:
if self.trigger_price < self.trigger_limit_price:
return False
else:
self.trigger_limit_price = 0
elif self.order_type == OrderType.TRAILING_STOP:
self.price = 0
self.has_trigger_limit = False
self.trigger_price = 0
self.trigger_limit_price = 0
if not self.has_trailing_limit:
self.trailing_stop_limit_percent = 0
if 100 > self.trailing_stop_percent or self.trailing_stop_percent > 10000:
return False
if self.has_trailing_limit:
if 0 > self.trailing_stop_limit_percent or self.trailing_stop_limit_percent > 10000:
return False
elif self.order_type == OrderType.RANGE:
if self.price == 0:
if not self.has_trailing_limit:
self.trailing_stop_limit_percent = 0
if 100 > self.trailing_stop_percent or self.trailing_stop_percent > 10000:
return False
if self.has_trailing_limit:
if 0 > self.trailing_stop_limit_percent or self.trailing_stop_limit_percent > 10000:
return False
else:
self.has_trailing_limit = False
self.trailing_stop_percent = 0
self.trailing_stop_limit_percent = 0
if self.is_long:
if self.price > self.trigger_price:
return False
else:
if self.price < self.trigger_price:
return False
if self.has_trigger_limit:
if self.is_long:
if self.trigger_price > self.trigger_limit_price:
return False
else:
if self.trigger_price < self.trigger_limit_price:
return False
else:
self.trigger_limit_price = 0
if self.price < 0:
return False
if not isinstance(self.has_trigger_limit, bool):
return False
if self.trigger_price < 0:
return False
if self.trigger_limit_price < 0:
return False
if not isinstance(self.has_trailing_limit, bool):
return False
if self.trailing_stop_percent < 0:
return False
if self.trailing_stop_limit_percent < 0:
return False
class EquityPrice(db.Model):
equity_Id = db.Column(db.Integer, primary_key=True, nullable=False)
equity_price_id = db.Column(db.Integer, primary_key=True, nullable=False)
price = db.Column(db.BigInteger, nullable=False)
price_date = db.Column(db.DateTime(), nullable=False)
class DepositId(db.Model):
user_id = db.Column(db.Integer, primary_key=True, nullable=False)
address_id = db.Column(db.Integer, primary_key=True, nullable=False)
deposit_id = db.Column(db.Integer, nullable=False)
class SessionToken(db.Model):
user_id = db.Column(db.Integer, primary_key=True, nullable=False)
session_token = db.Column(db.String(100), primary_key=True, nullable=False)
ip_address = db.Column(db.String(100), nullable=False)
issued_date = db.Column(db.DateTime(), nullable=False)
expiry_date = db.Column(db.DateTime(), nullable=False)
class EquityPriceId(db.Model):
equity_Id = db.Column(db.Integer, primary_key=True, nullable=False)
equity_price_id = db.Column(db.Integer, nullable=False)
class TransactionId(db.Model):
equity_id = db.Column(db.Integer, primary_key=True, nullable=False)
transaction_id = db.Column(db.Integer, nullable=False)
class ContractId(db.Model):
equity_id = db.Column(db.Integer, primary_key=True, nullable=False)
contract_id = db.Column(db.Integer, nullable=False)
class ForgotPassword(db.Model):
user_id = db.Column(db.Integer, primary_key=True, nullable=False)
forgot_password_token = db.Column(db.String(100),
primary_key=True,
nullable=False)
created_date = db.Column(db.DateTime(), nullable=False)
class WithdrawalId(db.Model):
user_id = db.Column(db.Integer, primary_key=True, nullable=False)
withdrawal_id = db.Column(db.Integer, nullable=False)
