def post(self, *args):
doctor = Doctor()
user = User()
order = Order()
self.set_header("Content-Type", "application/json")
if args[0] == 'addorderpeople':
self.write(
user.update_order_people_info(
self.current_user, self.get_argument('name'),
self.get_argument('id_card'),
self.get_argument('telephone'),
self.get_argument('hospital_card')))
elif args[0] == 'getordersize':
self.write(
doctor.get_ordersize_by_date(self.get_argument("date"),
self.get_argument("doctor_id")))
elif args[0] == 'createorder':
order_info = {
'user_id': self.current_user,
'doctor_id': self.get_argument('doctor_id'),
'community': self.get_argument('community'),
'doctor': self.get_argument('doctor'),
'hospital_card': self.get_argument('hospital_card'),
'id_card': self.get_argument('id_card'),
'name': self.get_argument('name'),
'telephone': self.get_argument('telephone'),
'time': self.get_argument('time')
}
self.write(order.create_order(order_info))
def get(self, *args):
doctor = Doctor()
user = User()
order = Order()
if args[0] == '':
self.render('doctor/index.html')
elif args[0] == 'neworder':
self.render('doctor/choose-doctor.html',
doctor_info=doctor.get_all_doctors())
elif args[0] == 'choosetime':
self.render('doctor/choose-time.html')
elif args[0] == 'createorder':
self.render('doctor/create-order.html',
doctor_info=doctor.get_doctor_by_id(
self.get_argument("doctor_id")),
order_people_info=user.get_order_people_info(
self.current_user))
elif args[0] == 'addorderpeople':
self.render('doctor/add-order-people.html')
elif args[0] == 'listorder':
self.render('doctor/list-order.html',
order_info=order.get_all_order_by_user(
self.current_user))
elif args[0] == 'orderdetail':
self.render('doctor/order-detail.html',
order_info=order.get_order_by_id(
self.get_argument('order_id')))
else:
self.write('<h1>功能正在开发，请耐心等待</h1>')
def getInitActiveOrders(self,market=None):
ackMsg = self.trading_client.get_openorders(market)
if type(ackMsg) == dict and ackMsg['success'] == True:
if not len(ackMsg['result']):
return ackMsg
else:
tmpActiveOrderList = []
ackResult = ackMsg['result']
for i in range(len(ackResult)):
obj = ackResult[i]
odid = str(obj['OrderUuid'])
symbol = str(obj['Exchange']).upper().split("-")
sym_ = symbol[:3]
_sym = symbol[3:]
orderType = str(obj['OrderType']).upper().split("_")[0]
price = float(obj['Price'])
side = str(obj['OrderType']).upper().split("_")[1]
qty = float(obj['QuantityRemaining'])
o = Order(self.exchCode, sym_, _sym, orderType, price, side, qty)
o.odid = odid
o.status = 'ACTIVE'
o.activeTs = nowStr()
tmpActiveOrderList.append(o)
return tmpActiveOrderList
else:
intAckMsg = self.handleUnknownMsg(ackMsg['message'])
'''log.error('Unexpected ackMsg::getInitActiveOrders %s %s' % (self.exchCode, intAckMsg))'''
return intAckMsg
def getInitActiveOrders(self):
ackMsg = self.trading_client.get_openorders()
if type(ackMsg) == dict:
if len(ackMsg['result']) == 0:
return ackMsg
else:
tmpActiveOrderList = []
for i in range(len(ackMsg['result'])):
obj = ackMsg['result'][i]
odid = str(obj['orderId'])
symbol = str(obj['instrument'])
sym_ = symbol.split('-')[0]
_sym = symbol.split('-')[1]
orderType = str(obj['type'])
price = float(obj['price'])
side = str(obj['direction'])
qty = float(obj['quantity'])
o = Order(self.exchCode, sym_, _sym, orderType, price,
side, qty)
o.odid = odid
o.status = 'ACTIVE'
o.activeTs = nowStr()
tmpActiveOrderList.append(o)
return tmpActiveOrderList
else:
intAckMsg = self.handleUnknownMsg(ackMsg['message'])
return intAckMsg
def customer_loop(self, id, containers_list, orders):
print("Hello in Klient App")
select_char = "s"
while select_char != "q":
select_char = input("Select action:\n"
"\t1. Show available offer\n"
"\t2. Submit your order\n"
"\t3. My orders\n"
"\t4. Exit\n").upper()
if select_char not in "1234" or len(select_char) != 1:
print("No such action")
continue
if select_char == '1':
for i in range(len(containers_list)):
containers_list[i].print_info(i)
elif select_char == '2':
order = Order()
for i in range(len(containers_list)):
containers_list[i].print_info(i)
container_id = int(input("Enter the container id: "))
order.set_order(id, containers_list[container_id], False)
orders.append(order)
elif select_char == '3':
for i in range(len(orders)):
if orders[i].id == id:
orders[i].print_order(i)
elif select_char == "4":
return
def VerifyCustomer(self,Command:VerifyCustomerCommand):
NewOrder = Order()
Saga = SagaParticipant()
Events = NewOrder.proccessForVerifyCustomerCommand(Command)
Saga.Create(Command.OrderId,Events[1].EventJsonData(),Command.SagaType)
NewOrder.applyForVerifyCustomerEvent(Events[0])
CustomerRepository().Create((NewOrder,Saga),Events,MessageId=Command.MessageId) #Insert the event to the database
def change(self):
i = 0
if (User[CurrentUser[1]].getType() == 0):
void.setAddress(self.Page2_Address.text())
self.stackedWidget.setCurrentIndex(2)
randFood = random.randint(0, len(Menu) - 1)
temp = CurrentCart.copy()
if (User[CurrentUser[1]].getType() == 0):
addPendingOrder(Order(void, temp))
elif (User[CurrentUser[1]].getType() != 0):
if (User[CurrentUser[1]].getType() == 2):
randomFood = Food(Menu[randFood].getName() + " *Free*", 0,
Menu[randFood].getCate(),
Menu[randFood].getSpice())
User[CurrentUser[1]].addUserOrder(randomFood)
addCurrentCart(randomFood)
self.Page3_label4.show()
addPendingOrder(Order(User[CurrentUser[1]], temp))
while i < len(User[CurrentUser[1]].order):
self.Page3_listView.addItem(
User[CurrentUser[1]].order[i].getName() + "\t\t\t" +
format(User[CurrentUser[1]].order[i].getPrice(), '.2f'))
i += 1
User[CurrentUser[1]].order.clear()
print(currentCartSize())
def manage_fx_hedge(portfolio, bar, order):
if Cp.hedge_fx is True and get_ccy(order.ticker) == 'USD':
# Case 1: New equity position opened, hedge the USD consideration
if portfolio.fx_position[order.ticker] == 0.0:
usd_amount_to_hedge = -1.0 * order.price * order.quantity
portfolio.fx_position[order.ticker] = usd_amount_to_hedge
fx_order = Order(open_date=bar['DealDate'],
ticker='USD-GBP',
quantity=usd_amount_to_hedge,
price=order.fx,
order_type='MKT',
ccy='GBP',
fx=1.0,
trade_status='OPEN')
# Case 2: Equity position being closed
else:
usd_amount_to_hedge = -1.0 * portfolio.fx_position[order.ticker]
portfolio.fx_position[order.ticker] = 0.0
fx_order = Order(open_date=bar['DealDate'],
ticker='USD-GBP',
quantity=usd_amount_to_hedge,
price=order.fx,
order_type='MKT',
ccy='GBP',
fx=1.0,
trade_status='CLOSE')
fx_order.trade_id = '{}_{}'.format(order.trade_id, order.ticker)
portfolio.orders.append(fx_order)
class DialogFrameSimple:
def __init__(self):
self.FrameName = "DialogFrameSimple"
self.customer_preferred_order = {}
self.cur_order = Order()
self.ongoing_order = {}
def ifPhoneHasArchived(self):
return self.cur_order.phone in self.customer_preferred_order
def ifCurOrderStarted(self):
return self.cur_order.ifOrderStarted()
def curUnfilledItem(self):
return self.cur_order.NotFilledAttribute()
def ifCurOrderOnlyPhone(self):
return self.cur_order.ifOnlyPhone()
def addCurOrderToArchive(self):
self.customer_preferred_order[self.cur_order.phone] = self.cur_order
self.ongoing_order[self.cur_order.phone] = self.cur_order
self.cur_order = Order()
def resetCurOrder(self):
self.cur_order = Order()
def __init__(self, sequence, id, slot, subtype, turns, resources, *args, **kw):
Order.__init__(self, sequence, id, slot, subtype, turns, resources)
assert subtype == self.subtype, "Type %s does not match this class %s" % (subtype, self.__class__)
# Figure out if we are in single or multiple mode
# Short mode: NOp(*args, (0, 1))
# Multiple Mode: NOp(*args, 0, 1)
short = (len(args) == len(self.names))
for name, type in self.names:
struct, size = ARG_STRUCTMAP[type]
if short:
size = 1
if size == 1:
setattr(self, name, args[0])
else:
if len(args) < size:
raise ValueError("Incorrect number of arguments, the arguments required for %s (of type %s) are %s" % (name, type, struct))
setattr(self, name, args[:size])
args = args[size:]
# FIXME: Need to figure out the length a better way
self.length = len(self.__str__()) - Header.size
def exit_position(portfolio, bar, ticker):
"""Creates new MKT orders to flatten current position for a ticker and cancels any associated STP orders"""
qty = -portfolio.position[ticker]
deal_date = bar['DealDate']
deal_price = bar['EntryPrice_' + ticker]
if qty != 0:
ccy = get_ccy(ticker)
fx = get_fx(bar, ticker)
# Add a Market Order to close current position
market_order = Order(open_date=deal_date,
ticker=ticker,
quantity=qty,
order_type='MKT',
price=deal_price,
ccy=ccy,
fx=fx)
market_order.trade_id = portfolio.trade_id[ticker]
market_order.trade_status = 'CLOSE'
portfolio.orders.append(market_order)
# Cancel any OPEN STP orders for the ticker
for stop_order in portfolio.orders:
if stop_order.ticker == ticker and stop_order.status == 'OPEN' and stop_order.order_type == 'STP':
stop_order.cancel_order(deal_date)
# Remove FX Hedge
manage_fx_hedge(portfolio, bar, market_order)
def from_dict(self, flower_shop_dict):
self.logged_user = None
self.name = ""
if 'name' in flower_shop_dict:
self.name = flower_shop_dict['name']
self.flowers = []
if 'flowers' in flower_shop_dict:
for flower_dict in flower_shop_dict['flowers']:
flower = Flower()
flower.from_dict(flower_dict)
self.flowers.append(flower)
self.bouquets = []
if 'bouquets' in flower_shop_dict:
for bouquet_dict in flower_shop_dict['bouquets']:
bouquet = Bouquet()
bouquet.from_dict(bouquet_dict, self.flowers)
self.bouquets.append(bouquet)
self.users = []
if 'users' in flower_shop_dict:
for user_dict in flower_shop_dict['users']:
user = User()
user.from_dict(user_dict)
self.users.append(user)
self.orders = []
if 'orders' in flower_shop_dict:
for order_dict in flower_shop_dict['orders']:
order = Order()
order.from_dict(order_dict, self.bouquets)
self.orders.append(order)
self.orders_id_counter = len(self.orders)
self.users_id_counter = len(self.users)
self.flowers_id_counter = len(self.flowers)
self.bouquets_id_counter = len(self.bouquets)
def utest_CheckOrders():
print '-- CheckOrders function --',
o1, o2 = [Order(BID, 999, 123.45, 100, 100) for _ in range(2)]
checkOrders(o1, o2)
o1, o2 = [Order(ASK, 9191, 32.54, 1000, 100) for _ in range(2)] # icebergs
checkOrders(o1, o2)
print 'OK'
def post(self, *args):
doctor = Doctor()
user = User()
order = Order()
self.set_header("Content-Type", "application/json")
if args[0] == 'addorderpeople':
self.write(user.update_order_people_info(
self.current_user,
self.get_argument('name'),
self.get_argument('id_card'),
self.get_argument('telephone'),
self.get_argument('hospital_card')
))
elif args[0] == 'getordersize':
self.write(doctor.get_ordersize_by_date(self.get_argument("date"), self.get_argument("doctor_id")))
elif args[0] == 'createorder':
order_info = {
'user_id': self.current_user,
'doctor_id': self.get_argument('doctor_id'),
'community': self.get_argument('community'),
'doctor': self.get_argument('doctor'),
'hospital_card': self.get_argument('hospital_card'),
'id_card': self.get_argument('id_card'),
'name': self.get_argument('name'),
'telephone': self.get_argument('telephone'),
'time': self.get_argument('time')
}
self.write(order.create_order(order_info))
def run(self):
global stop
while not stop:
time.sleep(5)
command = input("commande : ").split()
if len(command) > 0:
if command[0] == "order":
start = float(time.time()) + float(command[2])
end = start + float(command[3])
order = Order(float(command[1]), start, end, time.time())
lock.acquire(1)
Agent.send({"order": Agregate(AgType.COM, order)})
lock.release()
if command[0] == "go":
for i in range(60):
print("top ", i)
start = float(time.time()) + float(command[2])
end = start + float(command[3])
order = Order(float(command[1]), start, end,
time.time())
lock.acquire(1)
Agent.send({"ORDER": Agregate(AgType.COM, order)})
lock.release()
time.sleep(float(command[2]) + float(command[3]) + 3)
stop = True
if command[0] == "stop":
stop = True
def getNewOrdersForGivenTime(self, t):
newOrders = []
np.random.seed(t)
if t > 22 * 60:
return newOrders
if np.random.rand() < 0.3:
n = np.random.randint(1, 3)
np.random.shuffle(self.v)
for j in xrange(n):
order = Order(self.orderId)
order.finalLocation = np.random.choice(self.vShuffled[40:])
l = [e for e in self.map]
np.random.shuffle(l)
for j in l[0:np.random.randint(2, 4)]:
order.productionProcess.append({
"processinLine":
j,
"resourceNeeded":
np.random.choice(self.map[j]),
"processingTime":
np.random.randint(5, 10),
"materialNeeded[tons]":
np.random.randint(2, 10),
})
self.orderId += 1
newOrders.append(order)
return newOrders
def getInitActiveOrders(self):
ackMsg = self.trading_client.get_openorders()
if type(ackMsg) == list:
if not len(ackMsg):
return ackMsg
else:
tmpActiveOrderList = []
for i in range(len(ackMsg)):
obj = ackMsg[i]
odid = str(obj['order_id'])
symbol = str(obj['symbol'])
sym_ = symbol[0]
_sym = symbol[1]
orderType = str(obj['type'])
price = float(obj['price'])
side = str(obj['side'])
qty = float(obj['executed_amount'])
o = Order(self.exchCode, sym_, _sym, orderType, price,
side, qty)
o.odid = odid
o.status = 'ACTIVE'
o.activeTs = nowStr()
tmpActiveOrderList.append(o)
return tmpActiveOrderList
else:
intAckMsg = self.handleUnknownMsg(ackMsg['message'])
return intAckMsg
def MakeOrders(self, currentPortfolio, targetPortfolio):
orders = []
for currentAsset in currentPortfolio:
# if exists in target, buy/sell to get to target
tgtAssetArray = [
a for a in targetPortfolio if a._symbol == currentAsset._symbol
]
if len(tgtAssetArray) > 0:
symbol = tgtAssetArray[0]._symbol
price = tgtAssetArray[0]._sharePrice
numShares = tgtAssetArray[
0]._numShares - currentAsset._numShares
if numShares > 0:
orders.append(Order("Buy", Asset(symbol, price,
numShares)))
elif numShares < 0:
orders.append(
Order("Sell", Asset(symbol, price, -numShares)))
else:
# else, sell all
orders.append(Order("Sell", currentAsset))
for targetAsset in targetPortfolio:
# if not exists in current, buy all
if not any([
a for a in currentPortfolio
if a._symbol == targetAsset._symbol
]):
orders.append(Order("Buy", targetAsset))
return orders
def test_add_item(self):
order = Order(1)
pizza = Pizza("vegetarian_pizza", 0, "small")
order.add_item(pizza)
assert pizza.id == 1
assert 1 in order.ids_to_items
assert order.ids_to_items[1] == pizza
assert len(order.items) == 1
def CreateOrder(self, Command: CreateOrderCommand):
NewOrder = Order()
OrderId = randint(0, 1000)
Command.OrderId = str(OrderId)
Events = NewOrder.processForOrderCreationCommand(Command)
NewOrder.applyForOrderCreationEvent(Events[0])
OrderRepository().Create((NewOrder, ), Events)
return f'Your order have been placed to our system'
def arr_checker(self, arr):
"""
检查arr是否可折
:param arr:
:return:
"""
odd, even = self.get_need_seg(arr)
return Order.judge_list(odd) and Order.judge_list(even)
def __init__(self, config):
if not config:
self.bail(-1, "no config: Trader init")
self.config = config
self.debug = config["debug"]
#super(Trader, self).__init__(config)
self.order = Order(config)
self.predictor = PredictProMerge(config)
self.ts = StockTs(config)
def addOrderToCart(self, options):
orderObject = Order(self.authorizationToken)
orderObject.addItemToOrder(self.restaurantID, self.currentItem.itemID,
options, self.currentItem.quantity,
self.currentItem.special_instructions,
self.currentItem.substitution_preference)
data = orderObject.currentCart()
self.showTheCurrentCart(data)
def orderFood():
orderID = 0
print("Enter Customer Name: ")
name = input()
print("Enter Customer Mobile no: ")
mobile = input()
customer = Customer(orderID, name, mobile)
orderID = orderID + 1
menus = getRestaurentMenu(customer)
foodId = -1
quantity = -1
order1 = Order(1, datetime.now(), customer)
print("Welcome", name, "\n")
print("Please select your food...\n")
print("--------Menu--------\n")
for menu in menus:
print("ID--Name--Price")
print(menu.mid, menu.name, menu.price)
orderFlag = -1
while (orderFlag != 0):
print("Enter 1 to order food, enter 0 to close the Menu")
orderFlag = input()
if (int(orderFlag) == 0):
break
if (int(orderFlag) == 1):
print("Please enter food Id")
foodId = input()
print("Please enter quantity")
quantity = input()
#menus[foodId]
#print(menus[int(foodId)])
orderedMenu = menus[int(foodId)]
orderedMenu.quantity = quantity
order1.addMenu(orderedMenu)
print("******Invoice*******")
print("Order ID:{}, Date: {} Customer Name: {}, Mobile:{}".format(
order1.oid, order1.date.strftime("%c"), order1.Customer.name,
order1.Customer.mobile))
totalBill = 0.0
serial = 1
print("SL---Food----Price---Qy----total")
for order in order1.menus:
print(serial, order.name, order.price, order.quantity,
(float(order.price) * float(order.quantity)))
totalBill = float(totalBill) + (float(order.price) *
float(order.quantity))
serial = serial + 1
print("Grand Total :", totalBill)
print("******Invoice*******")
class clearAndSaveTest (unittest.TestCase):
def setUp(self):
'''
Setup the test case by loading the contant of the files to process the
attended result.
'''
self.__log = Log()
self.__originalFile1 = Order(self.__log)
self.__originalFile2 = Order(self.__log)
self.__originalFile1.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile4.xls'))
self.__originalFile2.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile5.xls'))
self.__attendedResult2 = []
for prodOrder in self.__originalFile1.getOrderList():
self.__originalFile2.append(prodOrder)
self.__originalFile2.popLeft()
for prodOrder in self.__originalFile2.getOrderList():
self.__attendedResult2.append(prodOrder)
def tearDown(self):
'''
Deleted the new files.
'''
os.remove(os.path.join(TEST_FILE_ROOT, 'OrderTestFile6.xls'))
os.remove(os.path.join(TEST_FILE_ROOT, 'OrderTestFile7.xls'))
def testClearAndSave(self):
'''
Order must be able to clear and save (removing old order) itself.
'''
order1 = Order(self.__log)
order2 = Order(self.__log)
order1.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile4.xls'))
order2.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile5.xls'))
for i in range(len(order1)):
order2.append(order1.popLeft())
i = i
order1.clear()
order1.save(os.path.join(TEST_FILE_ROOT, 'OrderTestFile6.xls'))
order2.save(os.path.join(TEST_FILE_ROOT, 'OrderTestFile7.xls'))
resultOrder1 = Order(self.__log)
resultOrder2 = Order(self.__log)
try:
resultOrder1.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile6.xls'))
except:
pass
resultOrder2.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile7.xls'))
result1 = []
result2 = []
for prodOrder in resultOrder1.getOrderList():
result1.append(prodOrder)
for prodOrder in resultOrder2.getOrderList():
result2.append(prodOrder)
self.assertListEqual(result1, [], 'Order failed to clear itself.')
self.assertListEqual(result2, self.__attendedResult2, 'Order failed to save itself.')
def _prepare_for_random(self, stack_space: list, insert_no: set,
result: list):
"""
递归函数，目的是为了寻找一条合适的路径就停下来，如果递归结束都没有找到，那就输出不存在
注意：现在还没有考虑递归深度的问题
stack_space:
[(now_address),(able_index)]
[(1,2,0,0),(2,3)]
[(1,0,2,0),(1,3)]
"""
# 栈中没东西，说明本层没有合适路径，需要退回上一层寻找，直接return
if not stack_space:
return
else:
# 最后一个数字查好了以后，栈中只可能有一个元素
# 如果没有数字可以插，表示需要判断这个元素是不是满足要求
if not insert_no:
# 把该元素弹出来，去判断是不是符合要求
temp_item = stack_space.pop()
temp_address = list(temp_item[0])
temp_routine = []
# 如果满足了要求，修改标志位，修改result（result必须是可变的），return
if self._find_one_routine(Order(temp_address), temp_routine):
result.append((temp_routine, Order(temp_address)))
# 修改标志位
self._random_flag = True
return
# 如果还有能插的位置，则对该栈中的元素洗牌后，依次弹出，弹的每一个去计算新表，然后递归调用
else:
# 这里其实也可以对插入数字的队列进行洗牌，显得更加的随机
curr_insert_no = insert_no.pop()
random.shuffle(stack_space)
while stack_space and (not self._random_flag):
# 弹出一个，进行操作
temp_item = stack_space.pop()
temp_address = temp_item[0].copy()
temp_index = deque(temp_item[1].copy())
# 下面进行插入操作，可行结果放到新的stack中，进行后续递归
new_stack_space = []
# 循环进行几次，取决有有多少个空位
loop_times = len(temp_index)
for i in range(loop_times):
curr_index = temp_index.popleft()
temp_address[curr_index] = curr_insert_no
if self.arr_checker(temp_address):
# 将新的一个下一折的地址和对应空位的信息打包放入新栈
new_stack_space.append(
((temp_address.copy()), temp_index.copy()))
# 还原操作
temp_address[curr_index] = 0
temp_index.append(curr_index)
# 某一个排列对应的next的新表做好了以后，直接递归调用求下一次的
self._prepare_for_random(new_stack_space, insert_no.copy(),
result)
class CtrlHeuristic:
def __init__(self):
self.h = Heuristic()
self.t = Text()
self.o = Order()
def execute(self, textL):
arrayResult = {
Constant.HERUGLON_NAMES[Constant.HERUGLON_PREPOSITION]: 0,
Constant.HERUGLON_NAMES[Constant.HERUGLON_VERB]: 0,
Constant.HERUGLON_NAMES[Constant.HERUGLON_VERB_SUBJUNCTIVE]: 0,
Constant.HERUGLON_NAMES[Constant.HERUGLON_NUMBER_PRETTY]: 0,
"Vocabulary": None
}
listPrettyNumber = {}
arrayPharagrap = self.t.getWords(textL)
vocabulary = {}
for word in arrayPharagrap:
class_word = self.h.classify(word)
class_word_type = class_word['type']
if (class_word_type == Constant.HERUGLON_UNKNOWN):
pass
vocabulary[word] = word
if (class_word_type == Constant.HERUGLON_NUMBER):
pass
if (class_word_type == Constant.HERUGLON_NUMBER_PRETTY):
listPrettyNumber[word] = word
elif (class_word_type == Constant.HERUGLON_VERB):
arrayResult[Constant.HERUGLON_NAMES[
Constant.HERUGLON_VERB]] += 1
elif (class_word_type == Constant.HERUGLON_VERB_SUBJUNCTIVE):
arrayResult[Constant.HERUGLON_NAMES[
Constant.HERUGLON_VERB]] += 1
arrayResult[Constant.HERUGLON_NAMES[
Constant.HERUGLON_VERB_SUBJUNCTIVE]] += 1
elif (class_word_type == Constant.HERUGLON_PREPOSITION):
arrayResult[Constant.HERUGLON_NAMES[
Constant.HERUGLON_PREPOSITION]] += 1
arrayResult[Constant.HERUGLON_NAMES[
Constant.HERUGLON_NUMBER_PRETTY]] = len(listPrettyNumber)
listWords = self.o.prepare(vocabulary.keys())
listOrderVocabulary = self.o.do(listWords)
arrayResult['Vocabulary'] = listOrderVocabulary
return arrayResult
def placeBuyOrder(self, quantity, unitPrice):
order = Order(quantity, unitPrice, "buy", self.orderCount)
if (self.availableBalance >= order.getTotal()):
self.orderCount += 1
self.orderBook.append(order)
self.availableBalance -= order.getTotal()
self.lockedBalance += order.getTotal()
self.recalculateTotalBalance()
print(order)
return order
else:
raise Exception("Not enough balance to place buy order")
def __init__(self, sequence, id, slot, subtype, turns, resources, *args, **kw):
Order.__init__(self, sequence, id, slot, subtype, turns, resources)
assert subtype == self.subtype, "Type %s does not match this class %s" % (subtype, self.__class__)
if len(self.properties) != len(args):
raise TypeError("The args where not correct, they should be of length %s" % len(self.properties))
for property, arg in zip(self.properties, args):
print property, arg, self.__class__.__dict__[property.name]
self.length += property.length(arg)
setattr(self, property.name, arg)
def testOrderLoading(self):
'''
Order must be able to load its ProductOrders from an excel file, get its
length and pop right its whole ProductOrder list.
'''
log = Log()
order = Order(log)
order.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile1.xls'))
result = []
for i in range(len(order)):
result.append(order.popRight())
i = i
self.assertListEqual(result, self.ATTENDED_RESULTS, 'Order failed to load its ProductOrder list from an excel file, get its length and popRight its whole ProductOrder list')
def generateSampleOrder():
from Order import Order
order = Order()
order.setLab(generateSampleLab())
order.setTestList(kgenerateTestList())
order.setPrescDetail(kgeneratePrescriptionDetail())
return order
def test_order():
"""
This is a perfect case!
A new order initialOrder is created an then used to create updatedOrder in perfect use case. No errors.
Asserts to check updating is happening correctly.
"""
initialOrder = Order(1568390243, 'abbb11', 'AAPL', 'B', 209.00000, 100)
updatedOrder = Order(1568390247,
'abbb11',
quantity=101,
orgOrder=initialOrder)
assert updatedOrder.ticker == 'AAPL'
assert updatedOrder.quantity == 101
assert updatedOrder.side == 'B'
def getOrder(self, oid):
##Construct Empty Order
querystep = "SELECT * from orderlist WHERE orderid = " + str(oid)
self.cursor.execute(querystep)
response = self.cursor.fetchall()
r = response[0]
if (len(response) == 0):
print("No orders by that ID.")
return
orderout = Order(r[1], r[0])
if (r[2] == 0):
orderout.setActive(False)
if (r[3] == 1):
orderout.setWorking(True)
##Construct Item Set
querystep = "SELECT * from itemslist WHERE OwnerOrder = " + str(oid)
self.cursor.execute(querystep)
response = self.cursor.fetchall()
for r in response:
ri = Item(r[1], r[3], r[2], r[4])
orderout.addItem(ri)
return orderout
def utest_Order():
print '-- Order --',
o = Order( BID, 999, 123.45, 100, 100)
checkOrder(o, True, False, 999, 123.45, 100, 100)
o1 = Order( BID, 9191, 32.54, 1000, 100) # iceberg
checkOrder(o1, True, True, 9191, 32.54, 1000, 100)
o2 = Order( ASK, 999, 123.45, 100, 100)
checkOrder(o2, False, False, 999, 123.45, 100, 100)
o3 = Order( ASK, 9191, 324, 1000, 100) # iceberg
checkOrder(o3, False, True, 9191, 324, 1000, 100)
print 'OK'
def get_depth(self, base, alt):
order_book = {'bids': [], 'asks': []}
pair, swapped = self.get_validated_pair((base, alt))
if pair is None:
return
pairstr = pair[0].lower() + "_" + pair[1].lower()
if swapped:
bids, asks = btceapi.getDepth(pairstr)
else:
asks, bids = btceapi.getDepth(pairstr)
order_book['bids'] = [Order(float(b[0]), float(b[1])) for b in bids]
order_book['asks'] = [Order(float(a[0]), float(a[1])) for a in asks]
return order_book
def setUp(self):
'''
Setup the test case by loading the contant of the files to process the
attended result.
'''
self.__log = Log()
self.__originalFile1 = Order(self.__log)
self.__originalFile2 = Order(self.__log)
self.__originalFile1.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile4.xls'))
self.__originalFile2.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile5.xls'))
self.__attendedResult2 = []
for prodOrder in self.__originalFile1.getOrderList():
self.__originalFile2.append(prodOrder)
self.__originalFile2.popLeft()
for prodOrder in self.__originalFile2.getOrderList():
self.__attendedResult2.append(prodOrder)
def __str__(self): output = [Order.__str__(self)] for property in self.properties: arg = list(getattr(self, property.name)) output.append(property.pack(arg)) return "".join(output)
def orders(self): """\ orders() Returns the number of orders this object has. """ return Order.number(self.id)
def __str__(self):
args = []
for name, type in self.names:
struct, size = ARG_STRUCTMAP[type]
attr = getattr(self, name)
if size == 1:
args.append(attr)
else:
args += list(attr)
output = Order.__str__(self)
try:
output += pack(self.substruct, *args)
return output
except TypeError, e:
s = str(e)
causedby = '%s %s' % self.names[int(s[:s.find(' ')])]
being = getattr(self, name)
traceback = sys.exc_info()[2]
while not traceback.tb_next is None:
traceback = traceback.tb_next
raise TypeError, '%s was %s\n%s' % (causedby, being, e), traceback
def testFilterLogging(self):
'''
Order must log the ProductOrder that was filtered and the reson why thy were
filtered.
'''
log =Log()
order1 = Order(log)
order2 = Order(log)
order1.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile2.xls'))
order2.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile3.xls'))
order1.filter(order2)
self.assertListEqual(log.getMsgList(), self.ATTENDED_LOG, 'Order failed to log the filtered ProductOrder.')
class Client: def __init__(self, client_id): self.client_id = client_id #Create one order. def createOrder(self, order_num): self.order = Order(self.client_id, order_num) self.order.addOrderItem() def getOrder(self): return self.order def cacelOrder(self): del self.order def submitOrder(self): occ = OrderControlCenter() print "This order has been sent to order control center!" occ.patchOrder(self.order)
def __init__(self, spark = 42, d = -1, k = -1, p = -1, c = -1, o = -1, f = -1):
self.d = d
self.k = k
self.p = p
self.c = c
self.o = o
self.f = f
Order.__init__(self, d = self.d, k = self.k, p = self.p, c = self.c, o = self.o)
self.families = ['Hominidae']
self.family = self.families[self.f]
def familyRandomize(self):
self.f = random.randint(0, 34)
self.family = self.families[self.f]
pass
if (self.f < 0):
familyRandomize(self)
if __name__== '__main__':
#print "The Answer to Life, the Universe and Everything is: ", self.TheAnswerToLifeTheUniverseAndEverything
pass
def get(self, *args):
doctor = Doctor()
user = User()
order = Order()
if args[0] == '':
self.render('doctor/index.html')
elif args[0] == 'neworder':
self.render('doctor/choose-doctor.html', doctor_info=doctor.get_all_doctors())
elif args[0] == 'choosetime':
self.render('doctor/choose-time.html')
elif args[0] == 'createorder':
self.render('doctor/create-order.html',
doctor_info=doctor.get_doctor_by_id(self.get_argument("doctor_id")),
order_people_info=user.get_order_people_info(self.current_user))
elif args[0] == 'addorderpeople':
self.render('doctor/add-order-people.html')
elif args[0] == 'listorder':
self.render('doctor/list-order.html', order_info=order.get_all_order_by_user(self.current_user))
elif args[0] == 'orderdetail':
self.render('doctor/order-detail.html', order_info=order.get_order_by_id(self.get_argument('order_id')))
else:
self.write('<h1>功能正在开发，请耐心等待</h1>')
def testFilterOrder(self):
'''
Order must be able to filter and remove the bad ProductOrder and those
already ordered.
The filters are:
- imcomplete or incoherent ProductOrder.
- Already ordered in the last 20 days ProductOrder, except if employee is the admin.
'''
log =Log()
order1 = Order(log)
order2 = Order(log)
order1.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile2.xls'))
order2.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile3.xls'))
order1.filter(order2)
result = []
for i in range(len(order1)):
result.append(order1.popLeft())
i = i
self.assertListEqual(result, self.ATTENDED_RESULTS, 'Order failed to filter and remove the bad and already ordered ProductOrder.')
def __init__(self, *args, **kw): self.no = 34 Order.__init__(self, *args, **kw)
def testClearAndSave(self):
'''
Order must be able to clear and save (removing old order) itself.
'''
order1 = Order(self.__log)
order2 = Order(self.__log)
order1.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile4.xls'))
order2.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile5.xls'))
for i in range(len(order1)):
order2.append(order1.popLeft())
i = i
order1.clear()
order1.save(os.path.join(TEST_FILE_ROOT, 'OrderTestFile6.xls'))
order2.save(os.path.join(TEST_FILE_ROOT, 'OrderTestFile7.xls'))
resultOrder1 = Order(self.__log)
resultOrder2 = Order(self.__log)
try:
resultOrder1.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile6.xls'))
except:
pass
resultOrder2.loadOrder(os.path.join(TEST_FILE_ROOT, 'OrderTestFile7.xls'))
result1 = []
result2 = []
for prodOrder in resultOrder1.getOrderList():
result1.append(prodOrder)
for prodOrder in resultOrder2.getOrderList():
result2.append(prodOrder)
self.assertListEqual(result1, [], 'Order failed to clear itself.')
self.assertListEqual(result2, self.__attendedResult2, 'Order failed to save itself.')
__author__ = 'Chema' from Order.Order import * x = Order() x.add([10,2]) x.add([5,1]) x.showOrders() x.remove([10,2]) x.showOrders()
previousOrderFile = sys.argv[2]
outputPath = '..\\..\\'
audioPath = '..\\'
#notify the closing of libreOffice and kill it
#a = ctypes.windll.user32.MessageBoxA(0, 'LibreOffice fermera dans 60 seconde.',
# '!!!Killing Notification!!!', 0)
#kill LibreOffice
os.system('taskkill /f /im soffice.bin')
#instanciate the log file
log = Log()
#load the data from the input files
dailyOrder = Order(log)
previousOrder = Order(log)
try:
dailyOrder.loadOrder(dailyOrderFile)
except:
#if nothing to order, simply log it and exit
log.logMsg(u'Rien a commander.')
log.outputLog(outputPath)
sys.exit(0)
try:
previousOrder.loadOrder(previousOrderFile)
except:
pass
#filter the daily order data
dailyOrder.filter(previousOrder)
def createOrder(self, order_num): self.order = Order(self.client_id, order_num) self.order.addOrderItem()
