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)