def test_maxPositionLots_tradeEqual(self):
'''持仓总单数设置为2，交易员买2单后。验证跟随者跟随订单情况'''
#下单时的手数为实际值除以100
openParam = { tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_210'], tradeOnlineData['orderParam_symbol']: tradeOnlineData['broker_EURCAD'], tradeOnlineData['orderParam_volume']: 300 }
TradeOnline.OnlineTradeEvent.tradeEvent(self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'], {'token': self.tradeToken}, openParam)
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'], {'token': self.tradeToken}, openParam)
#校验code等于0，为及时单开仓成功
self.assertEqual(openPositionRes["code"], tradeOnlineData['ws_code_0'])
#校验手数为下单时的手数为实际值除以100
self.assertEqual(openPositionRes["order"]["volume"], 300)
#保存orderID,待开仓使用
self.orderID = openPositionRes["order"]["order_id"]
#获取跟随者订单信息
followOrderParams = {webAPIData['orderStatus']:webAPIData['orderStatus_open']}
getFollowOrder = Order.getOrders(webAPIData['hostName'] + orderData['getOrders_url'], headers=self.followHeaders, params=followOrderParams)
#断言获取跟随订单成功
self.assertEqual(getFollowOrder.status_code, webAPIData['status_code_200'])
#断言订单列表存在2个持仓单
self.assertEqual(len(json.loads(getFollowOrder.text)['data']['items']), 2)
#获取交易员的所有交易订单，并平掉
tradeOrderParams = {webAPIData['orderStatus']:webAPIData['orderStatus_open']}
getTradeOrders = Order.getOrders(webAPIData['hostName'] + orderData['getOrders_url'], self.tradeHeaders, params=tradeOrderParams)
#获取订单成功，返回200 ok
self.assertEqual(getTradeOrders.status_code, webAPIData['status_code_200'])
tradeOrdersIDList = Order.getOrdersID(getTradeOrders)
#平掉当前用户所有订单,如果有
# #web sockets批量平仓
closeParam = { tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_219'], tradeOnlineData['orderParam_tickets']: tradeOrdersIDList }
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'], {'token': self.tradeToken}, closeParam)
#校验code等于0，为及时单平仓成功
self.assertEqual(closePositionRes["code"], tradeOnlineData['ws_code_0'])
def testAdd2(self):
menu = Order.initMenu()
order = []
Order.addItem(order, menu, "burger order")
Order.addItem(order, menu, "chicken order")
self.assertEqual(order[1].getName(), "chicken order")
self.assertEqual(order[1].getCost(), 2.99)
def test_close_Orders(self):
'''获取当前用户的所有交易订单，并平掉'''
params = {webAPIData['orderStatus']: webAPIData['orderStatus_open']}
getOrders = Order.getOrders(webAPIData['hostName'] +
orderData['getOrders_url'],
self.tradeHeaders,
params=params)
#获取订单成功，返回200 ok
self.assertEqual(getOrders.status_code, webAPIData['status_code_200'])
ordersIDList = Order.getOrdersID(getOrders)
#平掉当前用户所有订单,如果有
# #web sockets批量平仓
closeParam = {
tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_219'],
tradeOnlineData['orderParam_tickets']: ordersIDList
}
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'],
{'token': self.tradeToken}, closeParam)
#校验code等于0，为及时单平仓成功
self.assertEqual(closePositionRes["code"],
tradeOnlineData['ws_code_0'])
#校验rcmd等于210，为及时单开仓
self.assertEqual(closePositionRes["rcmd"],
tradeOnlineData['ws_code_219'])
#校验平掉的单号，为本测试及时单开仓的单号
self.assertEqual(closePositionRes['success_tickets'], ordersIDList)
def basic_test():
state = State()
prod1 = Product(5, 5)
prod2 = Product(10, 10)
state.products.append(prod1)
state.products.append(prod2)
robot1 = Robot(0, 0)
robot2 = Robot(1, 1)
robot2.state = "on_delivery"
robot2.time = 12
state.idle.append(robot1)
state.delivery.append(robot2)
pack = Pack(3, 3)
state.packs.append(pack)
order1 = Order(prod1, pack)
order2 = Order(prod2, pack)
state.orders.append(order1)
state.orders.append(order2)
return state
def main(argv): a=13; b=9; p=7951; output='Order\t'; bigOrder=1; for x in range(0,p): root=Root.findRoot(x,a,b,p); if root!='NOT_A_ROOT': root1=(x,root[0]); root2=(x,root[1]); res=(); order=Order.findOrder(root1,a,p); output = str(order)+'\t1-'+str(root1)+' '; if bigOrder< order: bigOrder=order; res=root1; #R=Addition.doubleP(root1,a,p); #output=output+'2-'+str(R)+' '; #for i in range(3,order): # R=Addition.addP(root1,R,a,p); # output=output+str(i)+'-'+str(R)+' '; #print output; order=Order.findOrder(root2,a,p); if bigOrder< order: bigOrder=order; res=root2; output = str(order)+'\t1-'+str(root2)+' '; #print output; print bigOrder, res;
def ValidaPrecoMymoney():
App.AbrirOrders()
Principal.AcessarFormularioDeOrders()
Order.EscolherProduto('MyMoney')
Order.ValidarPreco('$100')
Order.ClicarCancelar()
App.FecharOrders()
def displayChoice(name):
print("1:VEG Pizza\n2:Non-Veg Pizza\n3:Order\n4:Logout ")
pch = int(input("Enter your choice:"))
if (pch == 1):
x = vpizza.selectPizza()
print("\n")
print(x.pname, x.total_price)
pizzas.append(x)
input()
displayChoice(name)
elif (pch == 2):
x = nvpizza.selectPizza()
print("\n")
print(x.pname, x.total_price)
pizzas.append(x)
input()
displayChoice(name)
elif (pch == 3):
#for y in pizzas:
#print(y.pname,y.prize,y.quantity,y.total_price)
Order.billgen(pizzas, name)
print("\n\nThank you.....")
print("\nSigning out....")
elif (pch == 4):
print("\nSigning out....")
exit()
else:
print("Enter valid Option...\n")
input()
displayChoice(name)
def test_DeleteOrdersByFxcm(self):
'''登录->切换到福汇账号->获取交易token->检查持仓单列表是否有单，如果有单批量平仓>退出登录'''
userData['headers'][
userData['Authorization']] = userData['Bearer'] + self.token
# 获取交易员的accountindex
self.tradeAccountIndex_fxcm = Account.getSpecialAccountIndex(
headers=userData['headers'], brokerID=4)
# 切换到MT4账号
switchAccountRes = Account.switchAccount(
userData['hostName'] + userDataAccount['switchAccount'],
userData['headers'], self.tradeAccountIndex_fxcm[0])
self.assertEqual(switchAccountRes.status_code,
userData['status_code_200'])
# 获取交易token
getTokenRes = Trade.getToken(
userData['hostName'] + userDataAccount["getToken_url"],
userData['headers'])
FMCommon.printLog('getTokenRes: ' + getTokenRes.text)
self.assertEqual(getTokenRes.status_code, userData['status_code_200'])
tradeToken = str(json.loads(
getTokenRes.content)["data"]["Token"]).replace("=", "@")
'''获取当前用户的所有交易订单，并平掉'''
params = {
userData['orderStatus']: userData['orderStatus_open'],
"view": "TRADER"
}
getOrders = Order.getOrders(userData['hostName'] +
orderData['getOrders_url'],
userData['headers'],
params=params)
# 获取订单成功，返回200 ok
self.assertEqual(getOrders.status_code, userData['status_code_200'])
ordersIDList = Order.getOrdersID(getOrders)
print("ordersIDList:", ordersIDList)
time.sleep(2)
# 平掉当前用户所有订单,如果有
# #web sockets批量平仓
closeParam = {
userDataWebSocket['orderParam_code']:
userDataWebSocket['ws_code_219'],
userDataWebSocket['orderParam_tickets']: ordersIDList
}
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, userDataWebSocket['ws_host'], userDataWebSocket['ws_port'],
{'token': tradeToken}, closeParam)
if (closePositionRes["code"] == userDataWebSocket['ws_code_0']):
# 校验code等于0，为及时单平仓成功
# 校验rcmd等于210，为及时单开仓
self.assertEqual(closePositionRes["rcmd"],
userDataWebSocket['ws_code_219'])
# 校验平掉的单号，为本测试及时单开仓的单号
self.assertEqual(closePositionRes['success_tickets'], ordersIDList)
if (closePositionRes["code"] == 13):
print("订单不存在!")
def create_order(self, order_source):
data = self.get_source_base_data(order_source)
order = Order(**data)
order.save()
order = self.finalize_creation(order, order_source)
order_creator_finished.send(sender=type(self), order=order, source=order_source)
# reset product prices
for line in order.lines.exclude(product_id=None):
context_cache.bump_cache_for_product(line.product, shop=order.shop)
return order
def tearDown(self):
#清空测试环境，还原测试数据
#清除所有测试订单，如果有
'''获取交易员的所有交易订单，并平掉'''
tradeOrderParams = {webAPIData['orderStatus']:webAPIData['orderStatus_open']}
getTradeOrders = Order.getOrders(webAPIData['hostName'] + orderData['getOrders_url'], self.tradeHeaders, params=tradeOrderParams)
#获取订单成功，返回200 ok
self.assertEqual(getTradeOrders.status_code, webAPIData['status_code_200'])
tradeOrdersIDList = Order.getOrdersID(getTradeOrders)
#平掉当前用户所有订单,如果有
# #web sockets批量平仓
closeParam = { tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_219'], tradeOnlineData['orderParam_tickets']: tradeOrdersIDList }
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'], {'token': self.tradeToken}, closeParam)
#校验code等于0，为及时单平仓成功
self.assertEqual(closePositionRes["code"], tradeOnlineData['ws_code_0'])
'''获取跟随者的所有交易订单，并平掉'''
followOrderParams = {webAPIData['orderStatus']:webAPIData['orderStatus_open']}
getFollowOrders = Order.getOrders(webAPIData['hostName'] + orderData['getOrders_url'], self.followHeaders, params=followOrderParams)
#获取订单成功，返回200 ok
self.assertEqual(getFollowOrders.status_code, webAPIData['status_code_200'])
followOrdersIDList = Order.getOrdersID(getFollowOrders)
#平掉当前用户所有订单,如果有
# #web sockets批量平仓
closeParam = { tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_219'], tradeOnlineData['orderParam_tickets']: followOrdersIDList }
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'], {'token': self.followToken}, closeParam)
#校验code等于0，为及时单平仓成功
self.assertEqual(closePositionRes["code"], tradeOnlineData['ws_code_0'])
#还原风控参数
#设置全局风控参数。打开风控信号
globalRiskControlData = {webAPIData['signalSwitch']: webAPIData['signalSwitch_open']}
setRiskControl = RiskControl.setRiskControl(webAPIData['hostName'] + riskControlData['setRiskControl_url'], accountIndex=self.followPicoAccountIndex, headers = self.followHeaders, datas=globalRiskControlData)
self.assertEqual(setRiskControl.status_code, webAPIData['status_code_200'])
#设置针对单个交易员的风控参数。初始为默认值
specialTradeDatas = { "accountIndex": self.followPicoAccountIndex}
setRiskControlForTrader = RiskControl.setRiskControlForTrader(webAPIData['hostName'] + riskControlData['setRiskControlForTrader_url'] + self.tradeIndex, headers=self.followHeaders, datas=specialTradeDatas, interfaceName="setRiskControlForTrader")
self.assertEqual(setRiskControlForTrader.status_code, webAPIData['status_code_200'])
#还原针对单个交易员的风控品种参数。
symbolList = [{webAPIData['Symbol']: tradeOnlineData["fm_EURCAD"], webAPIData['FollowType']: 1, webAPIData['StrategyType']: 2, webAPIData['Direction']: 2,
webAPIData['FollowSize']: 1, webAPIData['Locked']: False }]
specialTradeDatas1 = { "accountIndex": int(self.followPicoAccountIndex), webAPIData['symbolList']: symbolList}
setRiskControlForTrader1 = RiskControl.setRiskControlForTraderSymbols(webAPIData['hostName'] + riskControlData['setRiskControlForTraderSymbols_url'] + self.tradeIndex, headers=self.followHeaders, datas=specialTradeDatas1, interfaceName="setRiskControlForTraderSymbols")
self.assertEqual(setRiskControlForTrader1.status_code, webAPIData['status_code_200'])
# 取消跟随关系
deleteFollow = FollowManage.deleteFollow(webAPIData['hostName'] + followData['deleteFollow_url'] + self.tradeIndex, headers = self.followHeaders, accountIndex=self.followPicoAccountIndex)
self.assertEqual(deleteFollow.status_code, webAPIData['status_code_200'])
#登出followme系统
tradeSignout = Auth.signout(webAPIData['hostName'] + authData['signout_url'], datas = self.tradeHeaders)
self.assertEqual(tradeSignout.status_code, webAPIData['status_code_200'])
followSignout = Auth.signout(webAPIData['hostName'] + authData['signout_url'], datas = self.followHeaders)
self.assertEqual(followSignout.status_code, webAPIData['status_code_200'])
def test_onOrder(self):
OB = Orderbook.Orderbook("abcd")
Order1 = Order.Order("abcd", 500, 10, "Buy", "NAN1")
Order2 = Order.Order("abcd", 500, 11, "Buy", "NAN1")
Order3 = Order.Order("abcd", 500, 12, "Sell", "NAN1")
Order4 = Order.Order("abcd", 500, 13, "Sell", "NAN1")
Order5 = Order.Order("abcd", 1000, 9, "Sell", "NAN1")
i = 0
for O in [Order1, Order2, Order3, Order4, Order5]:
O.Order_Id = i
i += 1
OB.onOrder(Order1)
OB.onOrder(Order2)
OB.onOrder(Order3)
OB.onOrder(Order4)
OB.onOrder(Order5)
self.assertEqual(OB.Bid_Queue, {10: [], 11: []})
self.assertEqual(len(OB.Ask_Queue), 2)
self.assertEqual(len(OB.Ask_Queue[12]), 1)
self.assertEqual(len(OB.Ask_Queue[13]), 1)
self.assertEqual(len(OB.Updates), 4)
OB = Orderbook.Orderbook("abcd")
Order1 = Order.Order("abcd", 500, 10, "Buy", "NAN1")
Order2 = Order.Order("abcd", 500, 11, "Buy", "NAN1")
Order3 = Order.Order("abcd", 500, 12, "Sell", "NAN1")
Order4 = Order.Order("abcd", 500, 13, "Sell", "NAN1")
Order5 = Order.Order("abcd", 1000, 14, "Buy", "NAN1")
i = 0
for O in [Order1, Order2, Order3, Order4, Order5]:
O.Order_Id = i
i += 1
OB.onOrder(Order1)
OB.onOrder(Order2)
OB.onOrder(Order3)
OB.onOrder(Order4)
OB.onOrder(Order5)
self.assertEqual(OB.Ask_Queue, {12: [], 13: []})
self.assertEqual(len(OB.Bid_Queue), 2)
self.assertEqual(len(OB.Bid_Queue[10]), 1)
self.assertEqual(len(OB.Bid_Queue[11]), 1)
self.assertEqual(len(OB.Updates), 4)
def test_order_address_immutability_unsaved_address(save):
billing_address = get_address()
if save:
billing_address.save()
order = Order(
shop=get_default_shop(),
billing_address=billing_address.to_immutable(),
order_date=now(),
status=get_initial_order_status()
)
order.save()
order.billing_address.name = "Mute Doge"
with pytest.raises(ValidationError):
order.billing_address.save()
def test2():
state = State()
r1 = Robot(20, 14)
r2 = Robot(20, 20)
r3 = Robot(20, 0)
r1.time = 14
r2.time = 8
r3.time = 8
r1.state = "on_delivery"
r2.state = "on_delivery"
r3.state = "on_delivery"
insort(state.delivery, r1)
insort(state.delivery, r2)
insort(state.delivery, r3)
pack1 = Pack(20, 0)
pack2 = Pack(20, 10)
pack3 = Pack(20, 20)
state.packs.append(pack1)
state.packs.append(pack2)
state.packs.append(pack3)
prod1 = Product(0, 0)
prod2 = Product(0, 10)
prod3 = Product(0, 20)
state.products.append(prod1)
state.products.append(prod2)
state.products.append(prod3)
ord1 = Order(prod1, pack1)
ord2 = Order(prod1, pack2)
ord3 = Order(prod1, pack3)
ord4 = Order(prod2, pack1)
ord5 = Order(prod2, pack2)
ord6 = Order(prod2, pack3)
ord7 = Order(prod3, pack1)
ord8 = Order(prod3, pack2)
ord9 = Order(prod3, pack3)
state.orders.append(ord1)
state.orders.append(ord2)
state.orders.append(ord3)
state.orders.append(ord4)
state.orders.append(ord5)
state.orders.append(ord6)
state.orders.append(ord7)
state.orders.append(ord8)
state.orders.append(ord9)
return state
def testTotalCost3(self):
menu = Order.initMenu()
order = []
Order.addItem(order, menu, "burger order")
Order.addItem(order, menu, "chicken order")
Order.addItem(order, menu, "fries order")
total = Order.calcTotal(order)
self.assertEqual(total, 8.97)
def testTotalCost2(self):
menu = Order.initMenu()
order = []
Order.addItem(order, menu, "burger order")
Order.addItem(order, menu, "burger order")
Order.addItem(order, menu, "burger order")
total = Order.calcTotal(order)
self.assertEqual(total, 11.97)
def _get_order_and_order_line(request):
order = Order(
shop=request.shop,
currency=request.shop.currency,
prices_include_tax=request.shop.prices_include_tax,
)
order.taxful_total_price = TaxfulPrice("100", request.shop.currency)
order.taxless_total_price = TaxlessPrice("50", request.shop.currency)
pi = _get_price_info(request.shop, Product(sku='6.0745'), quantity=2)
return (order, OrderLine(
order=order,
base_unit_price=pi.base_unit_price,
discount_amount=pi.discount_amount,
quantity=pi.quantity,
))
def scan(account, type, date):
data = Data.get_stock_list()
print(data)
orders = []
totalEquity = (account.balances['combinedBalances'][1]['totalEquity'])
#remove bought stocks
print("Checking for stocks already bought")
for currPos in account.positions['positions']:
for stock in data:
if currPos == stock:
print(currPos + 'has been bought')
data.remove(stock)
# stock hasn't been bought and could be traded
for stock in data:
df = pd.read_csv('Data/' + stock + '.csv', index_col='Date')
try:
buy = s.strat2(stock, df, date)
if buy:
currPrice = si.get_live_price(stock)
newOrder = o.Order(stock, currPrice, df, date)
newOrder.setLong(df, totalEquity, date)
orders.append(newOrder)
except:
print('Error Getting Stock Prices')
pass
if len(orders) == 0:
print('Hold portfolio')
else:
print("Opportunities on {}".format(date))
rank_orders(orders, 'MACD')
for order in orders:
print(order.symbol, order.dEMA, order.rsi, order.dMACD)
def display_menu(self, a):
if (a[1] == "Login"):
obj = Welcome()
obj.Readfile()
obj.user_check()
elif (a[1] == "Menu"): # If user write 1 goto the Menu class.
obj1 = Menu()
obj1.Readfile()
obj1.menu_display()
elif (a[1] == "Cart"): # If user write 2 goto the cart class.
obj2 = Cart()
obj2.Read_file()
obj2.select(sys.argv)
obj2.cart_display(sys.argv)
elif (a[1] == "Payment"): # If user write 3 goto the Payment class.
obj1 = Payment()
obj1.Read_file()
obj1.payment_display(sys.argv)
obj1.updateorder(sys.argv)
obj1.Bill_pay(sys.argv)
elif (a[1] == "Order"): # If user write 4 goto the Oreder class.
obj1 = Order()
obj1.Read_file()
obj1.order_display(sys.argv)
obj1.cancelorder(sys.argv)
def main(ichi, period, gd):
ichi.update()
order_obj = Order.Order(ichi, gd)
order_obj.signal_achat()
order_obj.signal_vente()
time.sleep(period)
main(ichi, period, gd)
def send_orders(products, order_id, url=None):
for product_id, sku_num in products:
order = Order.Order(product_id,sku_num, order_id)
weight_price = {'sku_num': sku_num, 'weight': order.weight, 'price': order.price}
data ={}
try:
file = open('Orders.txt', 'r')
data = json.loads(file.read())
file.close()
except IOError:
pass
file = open('Orders.txt', 'w')
data[order.id] = weight_price
file.write(json.dumps(data))
response = UrlHelpers.send_order_to_wms(order, url)
print('status_code: ' + str(response.status_code))
data = response.json()
if response.status_code == 200:
print(data)
sending_orders.append(order)
try:
if data.get('trackingNumber', None) is not None:
processed_orders.append(data)
except Exception as e:
print(data)
print(e)
file.close()
print('All orders sent: %s' % len(sending_orders))
print('Number processed orders : %s' % len(processed_orders))
return order.id
def SetOrder(self, order_type='basic', order_per_batch=1, num_order=100):
self.order_generator = od.Order(self.shelves,
self.tools_data,
order_type = order_type,
order_per_batch = order_per_batch,
num_order = num_order,
order_gap = 5)
def test_date_methods(self):
self.assertTrue(self.order.isCurrent())
checkDate = datetime(2013, 12, 25)
autoExpireDate = datetime(2017, 12, 25)
self.order.setAutoExpireDate(autoExpireDate)
self.assertTrue(self.order.isCurrent(checkDate))
discontinuedDate = datetime(2015, 12, 25)
self.order.setDiscontinuedDate(discontinuedDate)
self.assertTrue(self.order.isCurrent(checkDate))
self.assertFalse(self.order.isDiscontinued(checkDate))
startDate = datetime(2014, 12, 25)
self.order.setStartDate(startDate)
self.assertFalse(self.order.isCurrent(checkDate))
self.order.setDiscontinued(True)
self.assertFalse(self.order.isDiscontinued(checkDate))
checkDate2 = datetime(2016, 12, 25)
self.assertTrue(self.order.isDiscontinued(checkDate2))
self.assertTrue(self.order.isFuture(checkDate))
self.assertFalse(self.order.isDrugOrder())
obj = Order(orderId = 9112)
self.assertTrue(self.order.equals(obj))
def test_signalSwitch_close(self):
'''账号持仓总手数设置为3，交易员买3手。验证跟随者跟随订单情况'''
#下单时的手数为实际值除以100(300/100)
openParam = { tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_210'], tradeOnlineData['orderParam_symbol']: tradeOnlineData['broker_EURCAD'], tradeOnlineData['orderParam_volume']: 300 }
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'], {'token': self.tradeToken}, openParam)
#校验code等于0，为及时单开仓成功
self.assertEqual(openPositionRes["code"], tradeOnlineData['ws_code_0'])
#校验手数为下单时的手数为实际值除以100(300/100)
self.assertEqual(openPositionRes["order"]["volume"], 300)
#保存orderID,待开仓使用
self.orderID = openPositionRes["order"]["order_id"]
#获取订单信息
followOrderParams = {webAPIData['orderStatus']:webAPIData['orderStatus_open']}
getFollowOrder = Order.getOrders(webAPIData['hostName'] + orderData['getOrders_url'], headers=self.followHeaders, params=followOrderParams)
#断言获取跟随订单成功
self.assertEqual(getFollowOrder.status_code, webAPIData['status_code_200'])
# #断言订单列表为空
self.assertEqual(json.loads(getFollowOrder.text)['data']['items'], [])
#平掉测试订单
closeParam = { tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_211'], tradeOnlineData['orderParam_ticket']: self.orderID, tradeOnlineData['orderParam_volume']: 300 }
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'], {'token': self.tradeToken}, closeParam)
#校验code等于0，为及时单平仓成功
self.assertEqual(closePositionRes["code"], tradeOnlineData['ws_code_0'])
#校验rcmd等于210，为及时单开仓
self.assertEqual(closePositionRes["rcmd"], tradeOnlineData['ws_code_211'])
#校验平掉的单号，为本测试及时单开仓的单号
self.assertEqual(closePositionRes['order']["order_id"], self.orderID)
class OrdersT:
arr = Order();
type = str();
def __init__(self, Orders, type):
self.arr=Orders
self.type=type
def sell(self, total_amount):
topDepth = self.market.getTopDepth()
orderPrice = topDepth['bids'][0]
new_order = self.trader.sendOrder(
Order.Order(type="sell", amount=total_amount, price=orderPrice))
self.trader.saveOrder(new_order)
logging.info("New order : " + str(new_order.toJson()))
if new_order.id == -1:
logging.info("Sell Order failed")
return
i = 0
while i < ORDER_WAIT_TIME:
remote_order = self.trader.getRemoteOrder(new_order)
if remote_order is not None:
self.trader.saveOrder(remote_order)
if remote_order.status == Order.PARR_COMPLETED or remote_order.status == Order.COMPLETED:
logging.info("Sell Order success")
return
time.sleep(1)
i += 1
logging.info("Sell Order timeout")
self.trader.cancelOrderById(new_order.id)
def generate_case():
state = State()
#Generating ROBOTS
for i in range(0, randint(2, 4)):
robot = Robot(randint(0, 10), randint(0, 10))
if (randint(0, 10) < 4):
robot.state = "on_delivery"
robot.time = randint(3, 22)
insort(state.delivery, robot)
else:
state.idle.append(robot)
total_prods = randint(1, 4)
#GENERATING PRODUCTS
for i in range(0, total_prods):
prod = Product(randint(0, 10), randint(0, 10))
state.products.append(prod)
total_packs = randint(1, 4)
#GENERATING PACKING STATIONS
for i in range(0, total_packs):
pack = Pack(randint(0, 10), randint(0, 10))
state.packs.append(pack)
#GENERATING ORDERS
for i in range(1, 5):
product = state.products[randint(0, total_prods - 1)]
packing = state.packs[randint(0, total_packs - 1)]
order = Order(product, packing)
state.orders.append(order)
return state
def test_maxPositionLots_tradeMore(self):
'''账号持仓总手数设置为3，交易员买4手。验证跟随者跟随订单情况'''
#下单时的手数为实际值除以100(400/100)
openParam = {
tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_210'],
tradeOnlineData['orderParam_symbol']:
tradeOnlineData['broker_EURCAD'],
tradeOnlineData['orderParam_volume']: 400
}
openPositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'],
{'token': self.tradeToken}, openParam)
#校验code等于0，为及时单开仓成功
self.assertEqual(openPositionRes["code"], tradeOnlineData['ws_code_0'])
#校验手数为下单时的手数为实际值除以100(300/100)
self.assertEqual(openPositionRes["order"]["volume"], 400)
#保存orderID,待开仓使用
self.orderID = openPositionRes["order"]["order_id"]
#获取订单的跟随订单
getFollowOrdersOfOrder = Order.getFollowOrdersOfOrder(
webAPIData['hostName'] + orderData['getFollowOrdersOfOrder_url1'],
headers=self.tradeHeaders,
params={"pageSize": 100},
tradeOrderID=str(self.orderID),
existOrder=0)
#断言获取跟随订单成功
self.assertEqual(getFollowOrdersOfOrder.status_code,
webAPIData['status_code_200'])
#断言当前的测试用户没有跟随订单
nickNameOfOrderList = []
for item in json.loads(getFollowOrdersOfOrder.text)["data"]["items"]:
nickNameOfOrderList.append(item['CustomerNickName'])
self.assertNotIn(self.followNickName, nickNameOfOrderList,
"当前测试用户未生成跟随订单")
getFollowOrder = FollowManage.getFollowOrder(
getFollowOrdersOfOrder,
nickName=self.followNickName,
accountIndex=self.followPicoAccountIndex)
#断言跟随者持仓单列表为空，即没有产生跟随订单
self.assertEqual(getFollowOrder, None)
#平掉测试订单
closeParam = {
tradeOnlineData['orderParam_code']: tradeOnlineData['ws_code_211'],
tradeOnlineData['orderParam_ticket']: self.orderID,
tradeOnlineData['orderParam_volume']: 400
}
closePositionRes = TradeOnline.OnlineTradeEvent.tradeEvent(
self, tradeOnlineData['ws_host'], tradeOnlineData['ws_port'],
{'token': self.tradeToken}, closeParam)
#校验code等于0，为及时单平仓成功
self.assertEqual(closePositionRes["code"],
tradeOnlineData['ws_code_0'])
#校验rcmd等于210，为及时单开仓
self.assertEqual(closePositionRes["rcmd"],
tradeOnlineData['ws_code_211'])
#校验平掉的单号，为本测试及时单开仓的单号
self.assertEqual(closePositionRes['order']["order_id"], self.orderID)
def update_order():
ensure_admin()
data = json.loads(request.stream.read())
db = DataAccessOrders()
or_handler = OrderHandler(db)
order = Order(data["date"], data["time"], data["name"], data["telefon"],
data["email"], data["location"], data["eventType"],
data["note"], data["id"])
return jsonify(or_handler.update_order(order))
def createOrder(self, productname, productcode):
if self.isblacklisted:
raise CustomerNotAllowedException(
"Customer is not allowed to create the order because it is blacklisted."
)
order = Order(productname, productcode)
return order
def getLatestOrders(self, order_type):
orders = []
if order_type == 'buy':
result = self.api.getBuyOrders()
else:
result = self.api.getSellOrders()
for ord in result:
orders.append(Order.fromCNBTCOrder(ord))
return orders
def make_random_market(N=10000):
market = OrderBook()
for i in range(N):
market.submit(Order.gen_random_order())
return market
def orderMenuItem__on_click():
Order.launch()
def setUp(self):
self.order = Order()
self.order.setOrderId(9112)
self.order.setOrderNumber('911')
class TestOrderFunctions(unittest.TestCase):
def setUp(self):
self.order = Order()
self.order.setOrderId(9112)
self.order.setOrderNumber('911')
def test_copy_methods(self):
copy1 = self.order.copy()
copy2 = self.order.copyForModification()
self.assertEqual(self.order.OrderAction.ORDER, 'ORDER')
self.assertEqual(self.order.Urgency.ROUTINE, 'ROUTINE')
self.assertIs(copy2, self.order)
self.assertIsNot(copy1, self.order)
self.assertIsNot(copy1, copy2)
self.assertEqual(self.order.hashCode(), self.order.getOrderId())
def test_date_methods(self):
self.assertTrue(self.order.isCurrent())
checkDate = datetime(2013, 12, 25)
autoExpireDate = datetime(2017, 12, 25)
self.order.setAutoExpireDate(autoExpireDate)
self.assertTrue(self.order.isCurrent(checkDate))
discontinuedDate = datetime(2015, 12, 25)
self.order.setDiscontinuedDate(discontinuedDate)
self.assertTrue(self.order.isCurrent(checkDate))
self.assertFalse(self.order.isDiscontinued(checkDate))
startDate = datetime(2014, 12, 25)
self.order.setStartDate(startDate)
self.assertFalse(self.order.isCurrent(checkDate))
self.order.setDiscontinued(True)
self.assertFalse(self.order.isDiscontinued(checkDate))
checkDate2 = datetime(2016, 12, 25)
self.assertTrue(self.order.isDiscontinued(checkDate2))
self.assertTrue(self.order.isFuture(checkDate))
self.assertFalse(self.order.isDrugOrder())
obj = Order(orderId = 9112)
self.assertTrue(self.order.equals(obj))
