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) # 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())