def __init__(self, transport):
transport.log("[Market] Initializing")
# for now we have the id in the transport
self._myself = transport._myself
self._peers = transport._peers
self._transport = transport
self.query_ident = None
self.reputation = Reputation(self._transport)
self.orders = Orders(self._transport)
# TODO: Persistent storage of nicknames and pages
self.nicks = {}
self.pages = {}
# Register callbacks for incoming events
transport.add_callback('peer', self.on_peer)
transport.add_callback('query_page', self.on_query_page)
transport.add_callback('page', self.on_page)
transport.add_callback('negotiate_pubkey', self.on_negotiate_pubkey)
transport.add_callback('proto_response_pubkey',
self.on_response_pubkey)
self.load_page()
# Send Market Shout
transport.send(shout({'text': 'Market Initialized'}))
def get_all_orders():
"""creates end point to fetch all food orders"""
order_obj = Orders()
all_orders = order_obj.fetch_all_orders()
if len(all_orders) >= 1:
return jsonify({"response": all_orders}), 201
return jsonify({"response": "Empty orders"}), 400
def fetch_order(order_id):
"""This route fetches a sigle order by id"""
order_obj = Orders()
user_order = order_obj.fetch_order(int(order_id))
if user_order:
return jsonify({"response": user_order}), 201
return jsonify({"response": "order doesn't exist"}), 404
def __init__(self,
account,
client_id,
username,
password,
recepients,
seen_transactions=None,
endtime='16:00',
finviz_session=None):
self.account = account
self.client_id = client_id
self.username = username
self.password = password
self.recepients = recepients
self.seen_transactions = seen_transactions
if not self.seen_transactions:
self.seen_transactions = []
self.starttime = datetime.now().time()
self.endtime = datetime.strptime(endtime, '%H:%M').time()
self.finviz_session = finviz_session
self.session_running = False
self.tick_rate = 60
self.ameritrade = Ameritrade(self.account,
self.client_id,
print_auth=False)
self.starting_data = self.get_position_data()
self.orders = Orders(self.get_position_data('orders'))
self.notify(self.starting_data,
f'{self.account.nickname} start of day report',
'start_day')
def init_models(self):
self.orders_ask = Orders(self.market, Market.TYPE_ASK, self.preferences.get_grouping())
self.model_ask = Model(self, self.orders_ask, self.preferences)
self.ui.tableAsk.setModel(self.model_ask)
self.orders_bid = Orders(self.market, Market.TYPE_BID, self.preferences.get_grouping())
self.model_bid = Model(self, self.orders_bid, self.preferences)
self.ui.tableBid.setModel(self.model_bid)
def test_no_grouping(self):
orders = Orders(self.market, Market.TYPE_ASK)
self.market.depth_ask(0.00000000, 1)
self.market.depth_ask(0.00000001, 1)
self.market.depth_ask(0.00000002, 1)
self.assertEquals(3, orders.size())
def test_remove_empty(self):
orders = Orders(self.market, Market.TYPE_ASK, 1)
self.market.depth_ask(120, 20)
self.assertEquals(1, orders.size())
self.market.depth_ask(120, 0)
self.assertEquals(0, orders.size())
def update_order_status(order_id):
order_obj = Orders()
status = request.get_json()
if status:
order_status = status.get("status")
response = order_obj.update_order_status(order_status, order_id)
if response:
return jsonify({"response": response}), 201
return jsonify({"response": "no such order exists"}), 404
return jsonify({"response": "please supply status"})
def _make_resource(cls, folder, name, *args, **kw):
root = ShopFolder._make_resource(cls, folder, name, **kw)
# Payments module
cls.payments_class._make_resource(cls.payments_class, folder,
'%s/payments' % name,
title={'en': u'Payment module'})
# Modules
Modules._make_resource(Modules, folder,
'%s/modules' % name, title={'en': u'Modules'})
# Suppliers
Suppliers._make_resource(Suppliers, folder,
'%s/suppliers' % name, title={'en': u'Suppliers'})
# Customers
Customers._make_resource(Customers, folder,
'%s/customers' % name, title={'en': u'Customers'})
# Product Models
ProductModels._make_resource(ProductModels, folder, '%s/products-models' % name,
title={'en': u'Product Models'})
# Orders
Orders._make_resource(Orders, folder, '%s/orders' % name,
title={'en': u'Orders'})
# ShopUser_Groups
ShopUser_Groups._make_resource(ShopUser_Groups, folder, '%s/groups' % name,
title={'en': u'User groups'})
# Addresses
Addresses._make_resource(Addresses, folder, '%s/addresses' % name,
title={'en': u'Addresses'})
# Countries
Countries._make_resource(Countries, folder, '%s/countries' % name,
title={'en': u'countries'})
# Countries zone
CountriesZones._make_resource(CountriesZones, folder,
'%s/countries-zones' % name, title={'en': u'Countries Zones'})
# EnumeratesFolder
EnumeratesFolder._make_resource(EnumeratesFolder, folder,
'%s/enumerates' % name, title={'en': u'Enumerates'})
# Shipping
Shippings._make_resource(Shippings, folder, '%s/shippings' % name,
title={'en': u'Shipping'})
# Conditions of users
WebPage._make_resource(WebPage, folder, '%s/terms-and-conditions-of-use' % name,
**{'title': {'fr': u'Conditions Générales de ventes',
'en': u'Terms and conditions of user'},
'state': 'public'})
# Default cross Selling configuration
CrossSellingTable._make_resource(CrossSellingTable, folder,
'%s/cross-selling' % name,
title={'en': u'Cross selling'})
# Taxes
Taxes_TableResource._make_resource(Taxes_TableResource, folder, '%s/taxes' % name,
**{'title': {'fr': u'TVA',
'en': u'Taxes'}})
table = Taxes_TableHandler()
table.add_record({'value': '19.6'})
folder.set_handler('%s/taxes' % name, table)
def test_depth_ask(self):
orders = Orders(self.market, Market.TYPE_ASK, 1)
self.market.depth_ask(10, 1)
self.market.depth_ask(20, 1)
self.market.depth_ask(30, 1)
self.assertEquals(to_money(10), orders.get_price(0))
self.assertEquals(to_money(20), orders.get_price(1))
self.assertEquals(to_money(30), orders.get_price(2))
class ManageOrders(MethodView):
"""Class to define all the api end points"""
order1 = Orders(1, [{
"item_id": 1,
"item_name": "pizza",
"price": 40000,
"quantity": 1
}], "none", 23)
order2 = Orders(2, [{
"item_id": 1,
"item_name": "fresh juice",
"price": 20000,
"quantity": 2
}], "none", 45)
order3 = Orders(3, [{
"item_id": 1,
"item_name": "fried fish",
"price": 30000,
"quantity": 3
}], "none", 12)
orders = [order1, order2, order3]
def get(self, order_id):
"""function to get a single order or to get all the orders"""
if order_id is None:
# return a list of orders
return jsonify(
{'all orders': [order.__dict__ for order in self.orders]})
specific_order = [
order.__dict__ for order in self.orders
if order.__dict__["order_id"] == order_id
]
return jsonify({'order': specific_order[0]})
def post(self):
"""funtion to place a new order"""
# create a new user
order = Orders(
len(self.orders) + 1, request.json['order_items'], None,
request.json['user_id'])
self.orders.append(order)
return jsonify(order.__dict__)
def put(self, order_id):
"""function to update a specific order"""
# update a single user
for order in self.orders:
if order.__dict__["order_id"] == order_id:
order_json = request.get_json()
order.__dict__['order_status'] = order_json['order_status']
return jsonify({'orders': [order.__dict__ for order in self.orders]})
def test_total(self):
orders = Orders(self.market, Market.TYPE_ASK)
self.market.depth_ask(10, 3)
self.market.depth_ask(20, 2)
self.market.depth_ask(30, 1)
self.assertEquals(3, orders.size())
self.assertEquals(to_money(3), orders.get_total(0))
self.assertEquals(to_money(5), orders.get_total(1))
self.assertEquals(to_money(6), orders.get_total(2))
def test_grouping_price(self):
orders = Orders(self.market, Market.TYPE_ASK, 1)
# group 0
self.market.depth_ask(120.0, 1)
# group 1
self.market.depth_ask(120.4, 1)
self.market.depth_ask(121.0, 1)
# group 2
self.market.depth_ask(121.8, 1)
self.assertEquals(to_money(120.0), orders.get_price(0))
self.assertEquals(to_money(121.0), orders.get_price(1))
self.assertEquals(to_money(122.0), orders.get_price(2))
def __init__(self, transport):
transport.log("[Market] Initializing")
# for now we have the id in the transport
self._myself = transport._myself
self._peers = transport._peers
self._transport = transport
self.query_ident = None
self.reputation = Reputation(self._transport)
self.orders = Orders(self._transport)
# TODO: Persistent storage of nicknames and pages
self.nicks = {}
self.pages = {}
# Register callbacks for incoming events
transport.add_callback('peer', self.on_peer)
transport.add_callback('query_page', self.on_query_page)
transport.add_callback('page', self.on_page)
transport.add_callback('negotiate_pubkey', self.on_negotiate_pubkey)
transport.add_callback('proto_response_pubkey', self.on_response_pubkey)
self.load_page()
# Send Market Shout
transport.send(shout({'text': 'Market Initialized'}))
def __init__(self, transport):
transport.log("[market] Initializing")
# for now we have the id in the transport
self._myself = transport._myself
self._peers = transport._peers
self._transport = transport
self.query_ident = None
self.reputation = Reputation(self._transport)
self.orders = Orders(self._transport)
# if something comes in, store it:
self.nicks = {}
self.pages = {}
# register callbacks for incoming events
transport.add_callback('peer', self.on_peer)
transport.add_callback('query_page', self.on_query_page)
transport.add_callback('page', self.on_page)
transport.add_callback('negotiate_pubkey', self.on_negotiate_pubkey)
transport.add_callback('response_pubkey', self.on_response_pubkey)
self.load_page()
# send something
transport.send(shout({'text': 'xxxxx'}))
def getvalue(self, value):
print(value)
print(type(value))
if value == 1:
pass
elif value == 2:
self.hide()
view = Employee(self)
elif value == 3:
self.hide()
view = Table(self)
elif value == 4:
self.hide()
view = Reservations(self)
elif value == 5:
self.hide()
view = Category(self)
elif value == 6:
self.hide()
view = Settings(self)
elif value == 7:
self.hide()
view = Orders(self)
elif value == 8:
self.hide()
view = Menu(self)
elif value == 9:
self.hide()
view = Bill(self)
def test_parse_orders(self):
orders = Orders('10 IMG').parse_orders()
code = orders[0][1]
bundles = int(orders[0][0])
self.assertEqual(code, 'IMG')
self.assertEqual(bundles, 10)
def place_order():
option_place_order = int(
input(
"You will have to input the index of the product you would like to order. If you need to see the list of products, "
"select option 2.\n1. Prepare order\n2. Display all products\n3. Go back\n"
))
if option_place_order == 1:
index_product = int(
input(
"Introduce the index of the product you want to order(starting from 1):\n"
))
try:
products = Products.load_products()
if 0 < index_product <= products.__len__():
product_to_order = products[index_product - 1]
quantity = 0
loop = True
while loop:
quantity = int(
input(
"How many products of this kind you would like to order?\n"
))
if quantity > 0:
loop = False
delivery_address = input(
"Please write the address where this order should be delivered:\n"
)
prepared_order = Order(product_to_order.__dict__,
type(product_to_order).__name__,
quantity, delivery_address)
Orders.add_order(prepared_order)
input(
f"Your order has been placed successfully. Press enter key in order to continue\n"
)
except JSONDecodeError:
input(
"Error on retrieving the products. Press enter key in order to continue\n"
)
elif option_place_order == 2:
display_products()
place_order()
elif option_place_order == 3:
print("Going back...\n")
else:
error_handler()
remove_product()
def post(self):
"""funtion to place a new order"""
# create a new user
order = Orders(
len(self.orders) + 1, request.json['order_items'], None,
request.json['user_id'])
self.orders.append(order)
return jsonify(order.__dict__)
def __init__(self, password: str, address: str, email: str, phoneno: int,
credit_card_info: str, shipping_info: str):
super(Customer, self).__init__(password)
self.customer_name = Orders().customer_name
self.address = address
self.email = email
self.phoneno = phoneno
self.credit_card_info = credit_card_info
self.shipping_info = shipping_info
def __init__(self, transport, db):
"""Class constructor defines the basic attributes and callbacks
Attributes:
transport (CryptoTransportLayer): Transport layer
for messaging between nodes.
dht (DHT): For storage across the network (distributed hash table).
market_id (int): Indicates which local market we're working with.
peers: Active peers/nodes on the P2P network
db: Database ORM handler
orders: Orders for goods from database
pages:
mypage:
signature: Digitial signature
nickname: Short name of the node - a synonym for GUID
log: Log handler
settings: Local settings
gpg: Public PGP key class
"""
# Current
self.transport = transport
self.dht = transport.dht
self.market_id = transport.market_id
self.peers = self.dht.getActivePeers()
self.db = db
self.orders = Orders(transport, self.market_id, db)
self.pages = {}
self.mypage = None
self.signature = None
self.nickname = ""
self.log = logging.getLogger("[%s] %s" %
(self.market_id, self.__class__.__name__))
self.settings = self.transport.settings
self.gpg = gnupg.GPG()
self.all_messages = ('query_myorders', 'peer', 'query_page',
'query_listings', 'negotiate_pubkey',
'response_pubkey')
# Register callbacks for incoming events
self.transport.add_callbacks([(msg, {
'cb':
getattr(self, 'on_%s' % msg),
'validator_cb':
getattr(self, 'validate_on_%s' % msg)
}) for msg in self.all_messages])
self.nickname = self.settings.get('nickname', '')
# Periodically refresh buckets
loop = tornado.ioloop.IOLoop.instance()
refreshCB = tornado.ioloop.PeriodicCallback(self.dht._refreshNode,
constants.refreshTimeout,
io_loop=loop)
refreshCB.start()
def __init__(self, transport, db):
"""This class manages the active market for the application
Attributes:
_transport (CryptoTransportLayer): Transport layer for messaging between nodes.
_dht (DHT): For storage across the network.
_market_id (int): Indicates which local market we're working with.
"""
# Current
self._transport = transport
self._dht = transport.getDHT()
self._market_id = transport.getMarketID()
self._myself = transport.getMyself()
self._peers = self._dht.getActivePeers()
self._db = db
self.orders = Orders(transport, self._market_id, db)
# Legacy for now
self.pages = {}
self.welcome = False
self.mypage = None
self.signature = None
self._nickname = ""
self._log = logging.getLogger(
'[%s] %s' % (self._market_id, self.__class__.__name__))
self.settings = self._transport.settings
welcome = True
if self.settings:
if 'welcome' in self.settings.keys() and self.settings['welcome']:
welcome = False
# Register callbacks for incoming events
self._transport.add_callback('query_myorders', self.on_query_myorders)
self._transport.add_callback('peer', self.on_peer)
self._transport.add_callback('query_page', self.on_query_page)
self._transport.add_callback('query_listings', self.on_query_listings)
self._transport.add_callback('page', self.on_page)
self._transport.add_callback('negotiate_pubkey',
self.on_negotiate_pubkey)
self._transport.add_callback('proto_response_pubkey',
self.on_response_pubkey)
self.load_page(welcome)
# Periodically refresh buckets
loop = tornado.ioloop.IOLoop.instance()
refreshCB = tornado.ioloop.PeriodicCallback(self._dht._refreshNode,
constants.refreshTimeout,
io_loop=loop)
refreshCB.start()
def __init__(self, transport, node, store_file):
self._log = logging.getLogger(self.__class__.__name__)
self._log.info("Initializing")
# for now we have the id in the transport
self._myself = transport._myself
self._peers = transport._peers
self._transport = transport
self.query_ident = None
self.reputation = Reputation(self._transport)
self.orders = Orders(self._transport)
self.order_entries = self.orders._orders
# TODO: Persistent storage of nicknames and pages
self.nicks = {}
self.pages = {}
# store file
self.store_file = store_file
# assign Entangled Node to global
self.node = node
# Connect to database
MONGODB_URI = 'mongodb://localhost:27017'
_dbclient = MongoClient()
self._db = _dbclient.openbazaar
print type(self._db)
self.settings = self._db.settings.find_one()
welcome = True
if self.settings:
if 'welcome' in self.settings.keys() and self.settings['welcome']:
welcome = False
else:
# creates the settings collection if it does not already exist
# self.settings = self._db.create_collection('settings')
pass
# Register callbacks for incoming events
transport.add_callback('query_myorders', self.on_query_myorders)
transport.add_callback('peer', self.on_peer)
transport.add_callback('query_page', self.on_query_page)
transport.add_callback('page', self.on_page)
transport.add_callback('negotiate_pubkey', self.on_negotiate_pubkey)
transport.add_callback('proto_response_pubkey',
self.on_response_pubkey)
# loads the page in from memory
self.load_page(welcome)
# stored the page in the DHT once the reactor has been given time to startup and the entangled node has refreshed
delay = 1.0
reactor.callLater(delay, self.store_page)
def test_compute_orders(self):
orders = Orders('10 IMG')
compute_orders = orders.compute_orders()
order_code = compute_orders.get('IMG')
total_amount = order_code.get('total_price')
total_count = order_code.get('total_count')
bundles = order_code.get('bundles')[0]
bundle = bundles.get('bundle')
price = bundles.get('price')
count = bundles.get('count')
cost = bundles.get('cost')
self.assertIsNotNone(order_code)
self.assertEqual(total_count, 10)
self.assertEqual(total_amount, 800.0)
self.assertEqual(bundle, 10)
self.assertEqual(price, 800.0)
self.assertEqual(count, 1)
self.assertEqual(cost, 800.0)
def display_orders():
# display all existing orders
try:
orders = Orders.load_orders()
for index, placed_order in enumerate(orders, start=1):
print(f"{index}. {placed_order}")
input("\nPress enter key in order to continue\n")
except JSONDecodeError:
input(
"Error on retrieving the orders. Press enter key in order to continue\n"
)
def palce_order():
store = DataStruct()
user_order = request.get_json()
if user_order:
user_name = user_order.get("user_name")
menu_id = user_order.get("menu_id")
Orders(user_name, menu_id).save_order()
if len(store.orders):
return jsonify({"response": "success"}), 200
return jsonify({"reponse": "failure"}), 400
return jsonify({"response": "no data supplied"}), 404
def printOrders(self, result):
orders = Orders()
if self.debug == '1':
print('-- RESULT --')
print(result)
print('-- Getting ORDER --')
response = 0
while response == 0:
progress = orders.read(result['message']['message'])
orderresult = progress.get('message')
if self.debug == '1':
print('-- Raw result --')
print(orderresult)
response = len(orderresult.get('response'))
time.sleep(1)
self.printformat([orderresult.get('response')])
def test_ticker(self):
ordersA = Orders(self.market, Market.TYPE_ASK)
ordersB = Orders(self.market, Market.TYPE_BID)
self.market.depth_bid(3.5, 1)
self.market.depth_bid(3.3, 1)
self.market.depth_bid(3.0, 1)
self.market.depth_bid(2.2, 1)
self.market.depth_bid(1.3, 1)
self.market.depth_bid(1.0, 1)
self.market.depth_ask(4.6, 1)
self.market.depth_ask(5.0, 1)
self.market.depth_ask(5.2, 1)
self.market.depth_ask(6.0, 1)
self.market.depth_ask(6.5, 1)
self.market.ticker(3.0, 5.0)
self.assertEquals(4, ordersA.size())
self.assertEquals(to_money(5.0), ordersA.get_price(0))
self.assertEquals(4, ordersB.size())
self.assertEquals(to_money(3.0), ordersB.get_price(0))
def test_grouping(self):
orders = Orders(self.market, Market.TYPE_ASK, 0.6)
# group 0
self.market.depth_ask(0.0, 1)
# group 1
self.market.depth_ask(0.1, 1)
self.market.depth_ask(0.3, 1)
self.market.depth_ask(0.6, 1)
self.assertEquals(2, orders.size())
self.assertEquals(to_money(3), orders.get_volume(1))
# group 2
self.market.depth_ask(1.1, 1)
self.market.depth_ask(1.2, 1)
self.assertEquals(3, orders.size())
# remove group 2
self.market.depth_ask(1.1, 0)
self.market.depth_ask(1.2, 0)
self.assertEquals(2, orders.size())
def remove_order():
option_remove_order_menu = int(
input(
"You will have to input the index of the order you would like to cancel. If you need to see the list of orders, "
"select option 2.\n1. Cancel order\n2. Display all orders\n3. Go back\n"
))
if option_remove_order_menu == 1:
index_order_to_remove = int(
input(
"Introduce the index of the order to be removed(starting from 1):\n"
))
try:
orders = Orders.load_orders()
if 0 < index_order_to_remove <= orders.__len__():
order_to_remove = orders[index_order_to_remove - 1]
Orders.remove_order(order_to_remove)
input(
f"Order with number {index_order_to_remove} was cancelled successfully\nPress enter key in order to continue\n"
)
else:
order_option = int(
input(
"This order does not exist in the list. Input 1 to try again or any other number to return to the store menu:\n"
))
if order_option == 1:
remove_order()
except JSONDecodeError:
input(
"Error on retrieving the orders. Press enter key in order to continue\n"
)
elif option_remove_order_menu == 2:
display_orders()
remove_order()
elif option_remove_order_menu == 3:
print("Going back...\n")
else:
error_handler()
remove_order()
def __init__(self, transport, db):
"""This class manages the active market for the application
Attributes:
transport (CryptoTransportLayer): Transport layer for messaging between nodes.
dht (DHT): For storage across the network.
market_id (int): Indicates which local market we're working with.
"""
# Current
self.transport = transport
self.dht = transport.get_dht()
self.market_id = transport.get_market_id()
# self._myself = transport.get_myself()
self.peers = self.dht.getActivePeers()
self.db = db
self.orders = Orders(transport, self.market_id, db)
self.pages = {}
self.mypage = None
self.signature = None
self.nickname = ""
self.log = logging.getLogger(
'[%s] %s' % (self.market_id, self.__class__.__name__)
)
self.settings = self.transport.settings
self.gpg = gnupg.GPG()
# Register callbacks for incoming events
self.transport.add_callbacks([
('query_myorders', self.on_query_myorders),
('peer', self.on_peer),
('query_page', self.on_query_page),
('query_listings', self.on_query_listings),
('negotiate_pubkey', self.on_negotiate_pubkey),
('proto_response_pubkey', self.on_response_pubkey)
])
self.load_page()
# Periodically refresh buckets
loop = tornado.ioloop.IOLoop.instance()
refreshCB = tornado.ioloop.PeriodicCallback(self.dht._refreshNode,
constants.refreshTimeout,
io_loop=loop)
refreshCB.start()
def __init__(self, transport):
# Current
self._transport = transport
self._dht = transport._dht
self._market_id = self._transport._market_id
self._myself = self._transport._myself
self._peers = self._dht._activePeers
# Legacy for now
self.query_ident = None
self.reputation = Reputation(self._transport)
self.orders = Orders(self._transport)
self.order_entries = self.orders._orders
self.nicks = {}
self.pages = {}
self._log = logging.getLogger(
'[%s] %s' % (self._market_id, self.__class__.__name__))
self._log.info("Loading Market %s" % self._market_id)
MONGODB_URI = 'mongodb://localhost:27017'
_dbclient = MongoClient()
self._db = _dbclient.openbazaar
self.settings = self._transport.settings
welcome = True
if self.settings:
if 'welcome' in self.settings.keys() and self.settings['welcome']:
welcome = False
# Register callbacks for incoming events
self._transport.add_callback('query_myorders', self.on_query_myorders)
self._transport.add_callback('peer', self.on_peer)
self._transport.add_callback('query_page', self.on_query_page)
self._transport.add_callback('page', self.on_page)
self._transport.add_callback('negotiate_pubkey',
self.on_negotiate_pubkey)
self._transport.add_callback('proto_response_pubkey',
self.on_response_pubkey)
self.load_page(welcome)
def __init__(self, transport):
self._log = logging.getLogger(self.__class__.__name__)
self._log.info("Initializing")
# for now we have the id in the transport
self._myself = transport._myself
self._peers = transport._peers
self._transport = transport
self.query_ident = None
self.reputation = Reputation(self._transport)
self.orders = Orders(self._transport)
self.order_entries = self.orders._orders
# TODO: Persistent storage of nicknames and pages
self.nicks = {}
self.pages = {}
# Connect to database
MONGODB_URI = 'mongodb://localhost:27017'
_dbclient = MongoClient()
self._db = _dbclient.openbazaar
self.settings = self._db.settings.find_one()
welcome = True
if self.settings:
if 'welcome' in self.settings.keys() and self.settings['welcome']:
welcome = False
# Register callbacks for incoming events
transport.add_callback('query_myorders', self.on_query_myorders)
transport.add_callback('peer', self.on_peer)
transport.add_callback('query_page', self.on_query_page)
transport.add_callback('page', self.on_page)
transport.add_callback('negotiate_pubkey', self.on_negotiate_pubkey)
transport.add_callback('proto_response_pubkey',
self.on_response_pubkey)
self.load_page(welcome)
def tradeLogic(self, orderDict, callback):
with Orders() as order:
order.__db__.begin()
tradeLogicBegin = 'tradeLogicBegin'
self.savePoint(order, tradeLogicBegin)
tradeOrderPoint = 'tradeOrderPoint'
ruleListAll = [
self.checkFunds(orderDict, order),
self.insertOrder(orderDict, callback, order, tradeLogicBegin),
self.savePoint(order, tradeOrderPoint),
self.tradeOrder(orderDict, callback, order, tradeOrderPoint)
]
ruleListObject = RuleList()
for rule in ruleListAll:
ruleListObject.addRule(rule)
ruleListObject.executeRuleList()
order.__db__.commit()
def read(self, file_name):
with open(file_name) as file_input:
data = json.load(file_input)
for item in data["client"]:
client = Client(item["id"], item["name"], item["address"],
item["phonenumber"])
self.__clients.append(client)
for item in data["product"]:
product = Product(item["id"], item["price"],
item["delivery"], item["description"])
self.__products.append(product)
for item in data["orders"]:
orderses = []
for id in item["orderses"]:
orderses.append(self.__orderses.getByID(id))
orders = Orders(item["id"], item["client"], item["product"], item["amount"], item["date"],
orders)
self.__orderses.append(orders)
def details(id):
meal = meals.get_details(id)
title = 'Adelara|Meal details'
if hasattr(meal, 'id'):
if request.method == "GET":
return render_template('details.html', meal=meal, title=title)
elif request.method == "POST":
new_order = Orders(
id=app.current_id,
meal=meal,
quantity=int(request.form["quantity"]),
user=request.form["user"],
address=request.form["address"],
date=datetime.datetime.now().strftime("%m/%d/%Y at %H:%M:%S"))
app.current_id += 1
orders.add(new_order)
orders.get_all()
return render_template("success.html", order=new_order)
else:
return redirect(url_for('oops'))
def __init__(self, transport):
self._log = logging.getLogger(self.__class__.__name__)
self._log.info("Initializing")
# for now we have the id in the transport
self._myself = transport._myself
self._peers = transport._peers
self._transport = transport
self.query_ident = None
self.reputation = Reputation(self._transport)
self.orders = Orders(self._transport)
self.order_entries = self.orders._orders
# TODO: Persistent storage of nicknames and pages
self.nicks = {}
self.pages = {}
# Connect to database
MONGODB_URI = 'mongodb://localhost:27017'
_dbclient = MongoClient()
self._db = _dbclient.openbazaar
# Register callbacks for incoming events
transport.add_callback('query_myorders', self.on_query_myorders)
transport.add_callback('peer', self.on_peer)
transport.add_callback('query_page', self.on_query_page)
transport.add_callback('page', self.on_page)
transport.add_callback('negotiate_pubkey', self.on_negotiate_pubkey)
transport.add_callback('proto_response_pubkey',
self.on_response_pubkey)
self.load_page()
# Send Market Shout
transport.send(shout({'text': 'Market Initialized'}))
def test_size(self):
orders = Orders(self.market, Market.TYPE_ASK, 1)
# group 0
self.market.depth_ask(120.0, 1)
self.assertEquals(1, orders.size())
# group 1
self.market.depth_ask(120.1, 1)
self.assertEquals(2, orders.size())
# group 1
self.market.depth_ask(120.9, 1)
self.assertEquals(2, orders.size())
# group 1
self.market.depth_ask(121.0, 1)
self.assertEquals(2, orders.size())
# group 2
self.market.depth_ask(122.0, 1)
self.assertEquals(3, orders.size())
print parsed
yield parsed
def tracking_update(tracking, update):
for order in tracking:
while True:
try:
print update(**order)
except URLError:
print 'error!'
continue
break
def main():
"""@todo: Docstring for main.
:returns: @todo
"""
update = ORDERS.update
print tracking_update(generic_numbers(), update)
print tracking_update(fedex_numbers(), update)
if __name__ == "__main__":
ORDERS = Orders()
main()
class View(QMainWindow):
"""
Represents the combined view / control.
"""
def __init__(self, preferences, market):
QMainWindow.__init__(self)
self.preferences = preferences
self.market = market
# set up main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# improve ui on mac
if utilities.platform_is_mac():
self.adjust_for_mac()
# connect market signals to our logic
self.market.signal_log.connect(self.slot_log)
self.market.signal_wallet.connect(self.display_wallet)
self.market.signal_orderlag.connect(self.display_orderlag)
self.market.signal_userorder.connect(self.display_userorder)
self.market.signal_ticker.connect(self.update_ticker)
# connect ui signals to our logic
self.ui.pushButtonGo.released.connect(self.execute_trade)
self.ui.tableAsk.clicked.connect(self.slot_update_price_from_asks)
self.ui.tableBid.clicked.connect(self.slot_update_price_from_bids)
self.ui.pushButtonCancel.released.connect(self.cancel_order)
self.ui.textBrowserStatus.anchorClicked.connect(self.order_selected)
self.ui.pushButtonSize.released.connect(self.recalculate_size)
self.ui.pushButtonPrice.released.connect(self.update_price_best)
self.ui.pushButtonTotal.released.connect(self.recalculate_total)
self.ui.actionPreferences_2.triggered.connect(self.show_preferences)
# associate log channels with their check boxes
self.logchannels = [
[self.ui.checkBoxLogTicker, "tick"],
[self.ui.checkBoxLogTrade, "TRADE"],
[self.ui.checkBoxLogDepth, "depth"],
]
# set correct resizing for the bid and ask tables
self.ui.tableAsk.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.ui.tableBid.horizontalHeader().setResizeMode(QHeaderView.Stretch)
# set up info table
self.info = Info(self, self.preferences, self.ui.tableInfo.clicked)
self.ui.tableInfo.setModel(self.info)
self.ui.tableInfo.horizontalHeader().setResizeMode(QHeaderView.Stretch)
# connect to signals from info table
self.info.signal_base_balance_clicked.connect(self.set_trade_size_from_wallet)
self.info.signal_quote_balance_clicked.connect(self.set_trade_total_from_wallet)
# initializes dynamic ui elements
self.init()
# activate market
self.market.start()
# show main window
self.adjustSize()
self.show()
self.raise_()
def get_base_currency(self):
return self.preferences.get_currency(Preferences.CURRENCY_INDEX_BASE)
def get_quote_currency(self):
return self.preferences.get_currency(Preferences.CURRENCY_INDEX_QUOTE)
def init(self):
# initialize wallet values
self.info.set_wallet_a(None)
self.info.set_wallet_b(None)
# initialize ticker values
self.info.set_ticker_ask(None)
self.info.set_ticker_bid(None)
# adjust decimal values to current currencies
self.adjust_decimals()
# set up table models
self.init_models()
def init_models(self):
self.orders_ask = Orders(self.market, Market.TYPE_ASK, self.preferences.get_grouping())
self.model_ask = Model(self, self.orders_ask, self.preferences)
self.ui.tableAsk.setModel(self.model_ask)
self.orders_bid = Orders(self.market, Market.TYPE_BID, self.preferences.get_grouping())
self.model_bid = Model(self, self.orders_bid, self.preferences)
self.ui.tableBid.setModel(self.model_bid)
def adjust_decimals(self):
currencyQuote = self.get_quote_currency()
currencyBase = self.get_base_currency()
self.ui.doubleSpinBoxSize.setDecimals(currencyBase.decimals)
self.ui.doubleSpinBoxPrice.setDecimals(currencyQuote.decimals)
self.ui.doubleSpinBoxTotal.setDecimals(currencyQuote.decimals)
def adjust_for_mac(self):
"""
Fixes some stuff that looks good on windows but bad on mac.
"""
# the default fixed font is unreadable on mac, so replace it
font = QtGui.QFont("Monaco", 11)
self.ui.tableAsk.setFont(font)
self.ui.tableBid.setFont(font)
self.ui.tableInfo.setFont(font)
self.ui.textBrowserLog.setFont(font)
self.ui.textBrowserStatus.setFont(font)
self.ui.lineEditOrder.setFont(font)
self.ui.doubleSpinBoxSize.setFont(font)
self.ui.doubleSpinBoxPrice.setFont(font)
self.ui.doubleSpinBoxTotal.setFont(font)
# the space between application title bar and
# the ui elements is too small on mac
margins = self.ui.widgetMain.layout().contentsMargins()
margins.setTop(24)
self.ui.widgetMain.layout().setContentsMargins(margins)
def show_preferences(self):
result = self.preferences.show()
if result == True:
self.status_message("Preferences changed, restarting market.")
self.market.stop()
self.preferences.apply()
self.init()
self.market.start()
self.status_message("Market restarted successfully.")
def get_selected_trade_type(self):
if self.ui.radioButtonBuy.isChecked():
return "BUY"
else:
return "SELL"
def set_selected_trade_type(self, trade_type):
if trade_type == "BUY":
self.ui.radioButtonBuy.toggle()
else:
self.ui.radioButtonSell.toggle()
def slot_log(self, text):
logging.info(text)
text = self.prepend_date(text)
doOutput = False
if self.ui.checkBoxLogSystem.isChecked():
doOutput = True
for entry in self.logchannels:
if entry[1] in text:
doOutput = entry[0].isChecked()
if doOutput:
self.ui.textBrowserLog.append(text)
def prepend_date(self, text):
millis = int(round(time.time() * 1000)) % 1000
return "{}.{:0>3} {}".format(time.strftime("%X"), millis, text)
def status_message(self, text):
# call move cursor before append to work around link clicking bug
# see: https://bugreports.qt-project.org/browse/QTBUG-539
logging.info(text)
text = self.prepend_date(text)
self.ui.textBrowserStatus.moveCursor(QTextCursor.End)
self.ui.textBrowserStatus.append(text)
def get_trade_size(self):
return money.to_money(self.ui.doubleSpinBoxSize.value())
def set_trade_size(self, value):
self.ui.doubleSpinBoxSize.setValue(money.to_float(value))
def get_trade_price(self):
return money.to_money(self.ui.doubleSpinBoxPrice.value())
def set_trade_price(self, value):
self.ui.doubleSpinBoxPrice.setValue(money.to_float(value))
def get_trade_total(self):
return money.to_money(self.ui.doubleSpinBoxTotal.value())
def set_trade_total(self, value):
self.ui.doubleSpinBoxTotal.setValue(money.to_float(value))
def get_order_id(self):
return str(self.ui.lineEditOrder.text())
def set_order_id(self, text):
self.ui.lineEditOrder.setText(text)
def order_selected(self, url):
self.set_order_id(str(url.toString()))
def display_wallet(self):
self.info.set_wallet_a(self.market.get_balance(Preferences.CURRENCY_INDEX_BASE))
self.info.set_wallet_b(self.market.get_balance(Preferences.CURRENCY_INDEX_QUOTE))
def update_ticker(self, bid, ask):
self.info.set_ticker_bid(bid)
self.info.set_ticker_ask(ask)
def set_trade_size_from_wallet(self):
self.set_trade_size(self.market.get_balance(Preferences.CURRENCY_INDEX_BASE))
self.set_selected_trade_type("SELL")
def set_trade_total_from_wallet(self):
self.set_trade_total(self.market.get_balance(Preferences.CURRENCY_INDEX_QUOTE))
self.set_selected_trade_type("BUY")
def display_orderlag(self, ms, text):
self.info.set_orderlag(ms)
def execute_trade(self):
trade_type = self.get_selected_trade_type()
size = self.get_trade_size()
price = self.get_trade_price()
total = money.multiply(price, size)
trade_name = "BID" if trade_type == "BUY" else "ASK"
self.status_message(
"Placing order: {0} {1} at {2} (total {3})...".format( # @IgnorePep8
trade_name,
money.to_long_string(size, self.get_base_currency()),
money.to_long_string(price, self.get_quote_currency()),
money.to_long_string(total, self.get_quote_currency()),
)
)
if trade_type == "BUY":
self.market.buy(price, size)
else:
self.market.sell(price, size)
def recalculate_size(self):
price = self.get_trade_price()
if price == 0:
return
total = self.get_trade_total()
size = money.divide(total, price)
self.set_trade_size(size)
def recalculate_total(self):
price = self.get_trade_price()
size = self.get_trade_size()
total = money.multiply(price, size)
self.set_trade_total(total)
def display_userorder(self, price, size, order_type, oid, status):
if order_type == "":
self.status_message('Order <a href="{0}">{0}</a> {1}.'.format(oid, status))
if status == "removed" and self.get_order_id() == oid:
self.set_order_id("")
else:
self.status_message(
'{0} size: {1}, price: {2}, oid: <a href="{3}">{3}</a> - {4}'.format( # @IgnorePep8
str.upper(str(order_type)),
money.to_long_string(size, self.get_base_currency()),
money.to_long_string(price, self.get_quote_currency()),
oid,
status,
)
)
if status == "post-pending":
self.set_order_id(oid)
def slot_update_price_from_asks(self, index):
self.update_price_from_asks(index.row())
def update_price_from_asks(self, row):
value = self.orders_ask.get_price(row)
pip = money.pip(self.get_quote_currency()) * self.preferences.get_proposed_pips()
self.set_trade_price(value - pip)
def slot_update_price_from_bids(self, index):
self.update_price_from_bids(index.row())
def update_price_from_bids(self, row):
value = self.orders_bid.get_price(row)
pip = money.pip(self.get_quote_currency()) * self.preferences.get_proposed_pips()
self.set_trade_price(value + pip)
def cancel_order(self):
order_id = self.get_order_id()
self.status_message('Cancelling order <a href="{0}">{0}</a>...'.format(order_id))
self.market.cancel(order_id)
def update_price_best(self):
trade_type = self.get_selected_trade_type()
if trade_type == "BUY":
self.update_price_from_bids(0)
elif trade_type == "SELL":
self.update_price_from_asks(0)
def stop(self):
self.market.stop()
def test_is_valid_orders(self):
orders = Orders('10 IMG 15 FLAC 13 VID') # valid order format
self.assertIsNotNone(orders.parse_orders())
class Market(object):
def __init__(self, transport):
transport.log("[Market] Initializing")
# for now we have the id in the transport
self._myself = transport._myself
self._peers = transport._peers
self._transport = transport
self.query_ident = None
self.reputation = Reputation(self._transport)
self.orders = Orders(self._transport)
# TODO: Persistent storage of nicknames and pages
self.nicks = {}
self.pages = {}
# Register callbacks for incoming events
transport.add_callback('peer', self.on_peer)
transport.add_callback('query_page', self.on_query_page)
transport.add_callback('page', self.on_page)
transport.add_callback('negotiate_pubkey', self.on_negotiate_pubkey)
transport.add_callback('proto_response_pubkey', self.on_response_pubkey)
self.load_page()
# Send Market Shout
transport.send(shout({'text': 'Market Initialized'}))
def lookup(self, msg):
if self.query_ident is None:
self._transport.log("Initializing identity query")
self.query_ident = lookup.QueryIdent()
nickname = str(msg["text"])
key = self.query_ident.lookup(nickname)
if key is None:
print "Key not found for this nickname"
return ("Key not found for this nickname", None)
print "Found key:", key.encode("hex")
if self._transport.nick_mapping.has_key(nickname):
print "Already have a cached mapping, just adding key there."
response = {'nickname': nickname, 'pubkey': self._transport.nick_mapping[nickname][1].encode('hex'), 'signature': self._transport.nick_mapping[nickname][0].encode('hex'), 'type': 'response_pubkey', 'signature': 'unknown'}
self._transport.nick_mapping[nickname][0] = key
return (None, response)
self._transport.nick_mapping[nickname] = [key, None]
self._transport.send(protocol.negotiate_pubkey(nickname, key))
# Load default information for your market from your file
def load_page(self):
self._transport.log("[Market] Loading market config from " + sys.argv[1])
with open(sys.argv[1]) as f:
data = json.loads(f.read())
self._transport.log("[Market] Configuration data: " + json.dumps(data))
assert "desc" in data
nickname = data["nickname"]
desc = data["desc"]
tagline = "%s: %s" % (nickname, desc)
self.mypage = tagline
self.nickname = nickname
self.signature = self._transport._myself.sign(tagline)
self._transport.log("[Market] Tagline signature: " + self.signature.encode("hex"))
def query_page(self, pubkey):
self._transport.send(query_page(pubkey))
def on_page(self, page):
self._transport.log("[Market] Page returned: " + str(page))
pubkey = page.get('pubkey')
page = page.get('text')
print "Orders: ", self.orders.print_orders()
if pubkey and page:
self.pages[pubkey] = page
# Return your page info if someone requests it on the network
def on_query_page(self, peer):
self._transport.log("[Market] Someone is querying for your page")
self._transport.send(proto_page(self._transport._myself.get_pubkey(), self.mypage, self.signature, self.nickname))
def on_peer(self, peer):
self._transport.log("[Market] New peer")
def on_negotiate_pubkey(self, ident_pubkey):
self._transport.log("[Market] Someone is asking for your real pubKey")
assert "nickname" in ident_pubkey
assert "ident_pubkey" in ident_pubkey
nickname = ident_pubkey['nickname']
ident_pubkey = ident_pubkey['ident_pubkey'].decode("hex")
self._transport.respond_pubkey_if_mine(nickname, ident_pubkey)
def on_response_pubkey(self, response):
self._transport.log("[Market] got a pubkey!")
assert "pubkey" in response
assert "nickname" in response
assert "signature" in response
pubkey = response["pubkey"].decode("hex")
signature = response["signature"].decode("hex")
nickname = response["nickname"]
# Cache mapping for later.
if not self._transport.nick_mapping.has_key(nickname):
self._transport.nick_mapping[nickname] = [None, pubkey]
# Verify signature here...
# Add to our dict.
self._transport.nick_mapping[nickname][1] = pubkey
self._transport.log("[market] mappings: ###############")
for k, v in self._transport.nick_mapping.iteritems():
self._transport.log("'%s' -> '%s' (%s)" % (
k, v[1].encode("hex") if v[1] is not None else v[1],
v[0].encode("hex") if v[0] is not None else v[0]))
self._transport.log("##################################")
def test_is_invalid_orders(self):
# orders = Orders('IMG 10 FLAC 15 VID 13') # invalid order format
orders = Orders('IMG 10') # invalid order format
self.assertIsNone(orders.parse_orders())
