09:30之前的委托卖撤单

Administrator

2024-10-23 28b5d3d2fa51cb91fb1c9e6a8fb82eb1112bc165

09:30之前的委托卖撤单

 trade/huaxin_trade_api.py

@@ -17,7 +17,7 @@
    logger_system
from trade import huaxin_trade_data_update
from trade.huaxin_trade_order_processor import CancelOrderManager, HuaxinOrderEntity, TradeResultProcessor
from trade.huaxin_trade_record_manager import TradeOrderIdManager
from trade.huaxin_trade_record_manager import TradeOrderIdManager, DelegateSellOrderManager

from utils import socket_util, tool, huaxin_util, cb_data_util

@@ -72,6 +72,16 @@
                                  insertDate=insertDate, direction=direction)
        try:
            if str(order.direction) == str(huaxin_util.TORA_TSTP_D_Sell):
                try:
                    if huaxin_util.is_can_cancel(order.orderStatus):
                        DelegateSellOrderManager.add_delegate_sell_order(
                            (order.orderSysID, order.code, order.insertTime, limitPrice))
                    elif huaxin_util.is_canceled(order.orderStatus):
                        DelegateSellOrderManager.cancel_delegate_sell_order(order.orderSysID)
                    elif order.orderStatus == huaxin_util.TORA_TSTP_OST_AllTraded:
                        DelegateSellOrderManager.deal_delegate_sell_order(order.orderSysID)
                except Exception as e:
                    hx_logger_trade_debug.exception(e)
                # 刷新持仓列表
                huaxin_trade_data_update.add_position_list()
                if huaxin_util.is_deal(order.orderStatus):
@@ -80,7 +90,8 @@
            else:
                # 买入
                if tool.is_cb_code(code):
                    async_log_util.info(hx_logger_trade_debug, f"可转债买入：代码-{code} sinfo-{sinfo} 订单状态-{orderStatus}  需要卖的sinfo-{cb_data_util.need_sell_sinfos}")
                    async_log_util.info(hx_logger_trade_debug,
                                        f"可转债买入：代码-{code} sinfo-{sinfo} 订单状态-{orderStatus}  需要卖的sinfo-{cb_data_util.need_sell_sinfos}")
                    if sinfo in cb_data_util.need_sell_sinfos and str(
                            orderStatus) == huaxin_util.TORA_TSTP_OST_AllTraded:
                        # 可转债买入

 trade/huaxin_trade_record_manager.py

@@ -8,6 +8,8 @@
import json

from db.redis_manager_delegate import RedisUtils, RedisManager
from log_module import async_log_util
from log_module.log import logger_trade
from utils import tool, huaxin_util
from db import mysql_data_delegate as mysql_data, redis_manager_delegate as redis_manager

@@ -161,6 +163,7 @@
                codes.append(d["securityID"])
        return codes


# 交易订单号管理
class TradeOrderIdManager:
    __db = 2
@@ -245,3 +248,66 @@
        if code in self.__huaxin_order_id_cache:
            return self.__huaxin_order_id_cache[code]
        return set()


class DelegateSellOrderManager:
    __delegate_orders_dict = {}
    """
    处于委托状态的卖单管理
    """

    @classmethod
    def set_delegate_sell_orders(cls, datas):
        """
        设置处于委托状态的卖单
        :param datas:[(orderSysID, securityID, insertTime, limitPrice)]
        :return:
        """
        cls.__delegate_orders_dict.clear()
        for d in datas:
            cls.add_delegate_sell_order(d)

    @classmethod
    def get_delegate_sell_orders(cls, code):
        """
        获取处于委托状态的卖单
        :param code:
        :return: [(orderSysID, securityID, insertTime, limitPrice)]
        """
        orders = []
        for k in cls.__delegate_orders_dict:
            if cls.__delegate_orders_dict[k][1] == code:
                orders.append(cls.__delegate_orders_dict[k])
        return orders

    @classmethod
    def add_delegate_sell_order(cls, data):
        """
        添加委托
        :param data:
        :return:
        """
        cls.__delegate_orders_dict[data[0]] = data
        async_log_util.info(logger_trade,f"添加委托：{data}")

    @classmethod
    def cancel_delegate_sell_order(cls, orderSysID):
        """
        撤单
        :param orderSysID:
        :return:
        """
        if orderSysID in cls.__delegate_orders_dict:
            cls.__delegate_orders_dict.pop(orderSysID)
            async_log_util.info(logger_trade, f"委托撤单：{orderSysID}")

    @classmethod
    def deal_delegate_sell_order(cls, orderSysID):
        """
        成交
        :param orderSysID:
        :return:
        """
        if orderSysID in cls.__delegate_orders_dict:
            cls.__delegate_orders_dict.pop(orderSysID)
            async_log_util.info(logger_trade, f"委托成交：{orderSysID}")

 trade/trade_strategy.py

@@ -21,7 +21,7 @@
from log_module.log import logger_trade, logger_debug, logger_system, logger_local_huaxin_l1_trade_info, \
    logger_trade_position_api_request, logger_l2_error, hx_logger_l2_transaction, printlog
from trade import huaxin_trade_data_update, huaxin_sell_util, huaxin_trade_api
from trade.huaxin_trade_record_manager import PositionManager
from trade.huaxin_trade_record_manager import PositionManager, DelegateSellOrderManager
from trade.sell_rule_manager import TradeRuleManager, SellRule
from utils import outside_api_command_manager, middle_api_protocol, tool, huaxin_util, socket_util, cb_data_util
from utils.outside_api_command_manager import ActionCallback
@@ -433,10 +433,12 @@
                                    if r.buy1_volume >= buy1_volume:
                                        # 量价触发
                                        can_excute = True
                                        async_log_util.info(logger_trade, f"触发卖规则({code}-{d})：量触发{buy1_volume}/{r.buy1_volume}")
                                        async_log_util.info(logger_trade,
                                                            f"触发卖规则({code}-{d})：量触发{buy1_volume}/{r.buy1_volume}")
                                else:
                                    can_excute = True
                                    async_log_util.info(logger_trade, f"触发卖规则({code}-{d})：价格触发{buy1_price}/{r.buy1_price}")
                                    async_log_util.info(logger_trade,
                                                        f"触发卖规则({code}-{d})：价格触发{buy1_price}/{r.buy1_price}")
                                    # 价格触发
                                # 获取价格类型
                                if not can_excute:
@@ -538,6 +540,20 @@
            # 获取最近的成交价
            price, time_str = datas[-1][1], l2_huaxin_util.convert_time(datas[-1][3])
            L2DataProcessor.set_deal_price(code, price, time_str)
            # 获取当前票是否有09:30之前的委托卖
            try:
                delegate_sell_orders = DelegateSellOrderManager.get_delegate_sell_orders(code)
                if delegate_sell_orders:
                    for d in delegate_sell_orders:
                        if int(d[2].replace(":", "")) >= int("093000"):
                            continue
                        if round(d[3], 2) > price:
                            async_log_util.info(logger_trade, f"成交价格低于委托价格撤单：{price}-{d}")
                            # 已经不能成交，要撤单
                            huaxin_trade_api.cancel_order(2, d[1], d[0])
            except Exception as e:
                logger_debug.exception(e)
                logger_debug.error(f"集合竞价卖撤处理出错：{code} - {str(e)}")


# 做一些初始化的操作