api/outside_api_command_callback.py

@@ -1479,6 +1479,14 @@
                                   client_id,
                                   request_id)

            elif ctype == "test_cancel_order":
                # 获取相同板块的涨停代码数量
                code = data.get("code")
                trade_manager.start_cancel_buy(code, force=True)
                self.send_response({"code": 0, "data": {}},
                                   client_id,
                                   request_id)

            elif ctype == "set_total_deal_big_order_threshold_money":
                code = data.get("code")
                money = data.get("money")

 huaxin_client/trade_client.py

@@ -355,6 +355,27 @@
            raise Exception('ReqOrderAction fail, ret[%d]' % ret)
        return

    # 批量撤买
    def batch_cancel_buy(self, code, order_infos, sinfos, order_action_refs, delay_s=0.0):
        """
        批量撤单
        @param code:
        @param order_infos:[(order_ref, order_sys_id)]
        @param sinfos:
        @param order_action_refs:
        @param delay_s:
        @return:
        """
        for i in range(len(order_infos)):
            order_ref, order_sys_id = order_infos[i][0],  order_infos[i][1]
            sinfo = sinfos[i]
            order_action_ref = order_action_refs[i]
            if order_sys_id:
                self.cancel_buy(code, sinfo, order_sys_id=order_sys_id, order_action_ref=order_action_ref, delay_s=delay_s)
            else:
                self.cancel_buy(code, sinfo,  order_ref=order_ref, order_action_ref=order_action_ref, delay_s=delay_s)
        return

    # 卖
    def sell(self, code, count, price, price_type, sinfo, order_ref=None):
        if sinfo in self.__sell_sinfo_set:
@@ -1061,18 +1082,34 @@
            orderSysID = data.get("orderSysID")
            orderRef = data.get("orderRef")
            orderActionRef = data.get("orderActionRef")
            sinfo = data["sinfo"]
            sinfo = data.get("sinfo")
            # =====批量撤单采用此种方法======
            # [(orderRef, orderSysID)]
            orderInfos = data.get("orderInfos")
            orderActionRefs = data.get("orderActionRefs")
            sinfos = data.get("sinfos")

            if direction == 1:
                # 撤买
                # 撤买 ，可采用单个撤单与批量撤单
                try:
                    if not orderSysID and orderRef is None:
                        raise Exception("没有找到系统订单号或者报单引用")
                    req_rid_dict[sinfo] = (client_id, request_id, sk)
                    self.trade_thread_pool.submit(
                        lambda: self.__tradeSimpleApi.cancel_buy(code, sinfo, order_sys_id=orderSysID,
                                                                 order_ref=orderRef, order_action_ref=orderActionRef))
                    async_log_util.info(logger_local_huaxin_trade_debug,
                                        f"撤单结束：code-{code} order_sys_id-{orderSysID} sinfo-{sinfo}")
                    if orderInfos:
                        # 批量撤买
                        if len(orderInfos) != len(orderActionRefs) or len(orderInfos) != len(sinfos):
                            raise Exception("批量撤单：订单数量与orderActionRefs/sinfos数量不匹配")
                        req_rid_dict[sinfo] = (client_id, request_id, sk)
                        self.trade_thread_pool.submit(
                            lambda: self.__tradeSimpleApi.batch_cancel_buy(code, orderInfos, sinfos, orderActionRefs))
                        async_log_util.info(logger_local_huaxin_trade_debug,
                                            f"批量撤单结束：code-{code} order_infos-{orderInfos} sinfos-{sinfos} order_action_refs-{orderActionRefs}")
                    else:
                        if not orderSysID and orderRef is None:
                            raise Exception("没有找到系统订单号或者报单引用")
                        req_rid_dict[sinfo] = (client_id, request_id, sk)
                        self.trade_thread_pool.submit(
                            lambda: self.__tradeSimpleApi.cancel_buy(code, sinfo, order_sys_id=orderSysID,
                                                                     order_ref=orderRef, order_action_ref=orderActionRef))
                        async_log_util.info(logger_local_huaxin_trade_debug,
                                            f"撤单结束：code-{code} order_sys_id-{orderSysID} sinfo-{sinfo}")
                except Exception as e:
                    send_response(json.dumps({"code": 1, "msg": str(e)}), TYPE_CANCEL_ORDER, client_id,
                                  request_id)

 servers/data_server.py

@@ -958,8 +958,11 @@
                                    buy_datas, sell_datas = deal_big_orders_result[0], deal_big_orders_result[1]
                                    limit_up_price = gpcode_manager.get_limit_up_price_as_num(code)
                                    limit_up_price_money_list = [x[0] for x in buy_datas if x[1] == limit_up_price]
                                    threshold_money = BeforeSubDealBigOrderManager().compute_re_limit_up_big_money_threshold(
                                        limit_up_price_money_list)
                                    if limit_up_price_money_list:
                                        threshold_money = BeforeSubDealBigOrderManager().compute_re_limit_up_big_money_threshold(
                                            limit_up_price_money_list)
                                    else:
                                        threshold_money = 299e4
                                    logger_debug.info(f"{code}-临时回封均大单：{threshold_money}")
                                    # 设置买单阈值
                                    th_buy = threshold_money
@@ -984,8 +987,11 @@
                                 output_util.money_desc(th_sell),  # 卖单阈值
                                 big_money_rate * 100  # 大单成交比
                                 ),
                                # 涨停大单净买入
                                output_util.money_desc(deal_big_money_info[1]),
                                # 累计总大单阈值
                                output_util.money_desc(deal_big_money_info[2]),
                                # 原累计大单阈值（非人为设置）
                                output_util.money_desc(deal_big_money_info[3]),
                            ]
                            if len(codes) == 1:

 trade/huaxin/huaxin_trade_api.py

@@ -615,7 +615,57 @@
    try:
        return __read_response(request_id, blocking)
    finally:
        # huaxin_trade_data_update.add_delegate_list("撤单")
        huaxin_trade_data_update.add_money_list()


def batch_cancel_order(direction, code, orderInfos: list, blocking=False,
                       request_id=None,
                       recancel=False):
    """
    测单
    @param direction: 1-买  2-卖
    @param code:
    @param orderInfos:[(orderRef, orderSysID)]
    @param blocking:
    @param request_id:
    @param recancel:
    @return:
    """
    if tool.trade_time_sub(tool.get_now_time_str(), "14:57:00") >= 0 and tool.trade_time_sub(tool.get_now_time_str(),
                                                                                             "15:00:01") <= 0:
        # 集合竞价不撤单
        return

    if not recancel:
        for orderInfo in orderInfos:
            CancelOrderManager().start_cancel(code, orderInfo[0], orderInfo[1])
    sinfos = []
    for i in range(len(orderInfos)):
        sinfo = f"cb_{code}_{round(time.time() * 1000)}_{random.randint(0, 10000)}_{i}"
        sinfos.append(sinfo)
    order_action_refs = []
    for i in range(len(orderInfos)):
        order_action_ref = huaxin_util.create_order_ref()
        order_action_refs.append(order_action_ref)
    if not request_id:
        request_id = __get_request_id(ClientSocketManager.CLIENT_TYPE_TRADE)
    # 加入撤单记录，用于校验最后的撤单是否成功
    if code not in __canceling_order_dict:
        __canceling_order_dict[code] = set()
    for orderInfo in orderInfos:
        __canceling_order_dict[code].add(json.dumps((orderInfo[0], orderInfo[1])))
    # 执行2次撤单，防止没有撤到
    for i in range(2):
        request_id = __request(ClientSocketManager.CLIENT_TYPE_TRADE,
                               {"type": ClientSocketManager.CLIENT_TYPE_TRADE, "trade_type": 2,
                                "direction": direction,
                                "code": code,
                                "orderInfos": orderInfos,
                                "orderActionRefs": order_action_refs,
                                "sinfos": sinfos}, request_id=request_id, is_trade=True)
    try:
        return __read_response(request_id, blocking)
    finally:
        huaxin_trade_data_update.add_money_list()



 trade/trade_huaxin.py

@@ -190,8 +190,9 @@
            orders.append({'orderSysID': order_info[1], 'accountId': order_info[0]})
        if orders:
            async_log_util.info(logger_trade, f"{code}：华鑫开始执行撤单 {msg}")
            huaxin_trade_api.batch_cancel_order(huaxin_trade_api.TRADE_DIRECTION_BUY, code,
                                                [('', order["orderSysID"]) for order in orders])
            for order in orders:
                huaxin_trade_api.cancel_order(huaxin_trade_api.TRADE_DIRECTION_BUY, code, order["orderSysID"])
                __TradeOrderIdManager.remove_order_id(code, order["accountId"], order["orderSysID"])
            async_log_util.info(logger_trade, f"{code}：华鑫撤单结束，撤单数量：{len(orders)}")

@@ -200,11 +201,12 @@

    if order_refs_info:
        order_refs_info = copy.deepcopy(order_refs_info)
        async_log_util.info(logger_trade, f"{code}：华鑫开始执行撤单 {msg}")
        huaxin_trade_api.batch_cancel_order(huaxin_trade_api.TRADE_DIRECTION_BUY, code,
                                            [(order_ref, '') for order_ref in order_refs_info])
        for order_ref in order_refs_info:
            async_log_util.info(logger_trade, f"{code}：华鑫开始执行撤单 {msg}")
            huaxin_trade_api.cancel_order(huaxin_trade_api.TRADE_DIRECTION_BUY, code, '', orderRef=order_ref)
            __TradeOrderIdManager.remove_order_ref(code, order_ref)
            async_log_util.info(logger_trade, f"{code}：华鑫执行撤单结束")
        async_log_util.info(logger_trade, f"{code}：华鑫执行撤单结束")


if __name__ == "__main__":

 trade/trade_manager.py

@@ -493,6 +493,12 @@

# 开始取消买入
def start_cancel_buy(code, force=False):
    """
    开始撤单
    @param code:
    @param force:
    @return:
    """
    async_log_util.info(logger_trade, "{} trade_manager.start_cancel_buy 开始".format(code))
    trade_state = __CodesTradeStateManager.get_trade_state_cache(code)
    try: