异常保护

Administrator

4 天以前 48fb7a00951f91bdc707e5dd2d196e5bccb752c3

 trade/trade_manager.py

@@ -3,43 +3,39 @@
对一系列的代码交易变量，下单，撤单进行管理
"""
# 交易管理器
import copy
import datetime
import json
import threading
import time

import dask
import concurrent.futures

from code_attribute import gpcode_manager
from db import mysql_data, redis_manager
from db.redis_manager import RedisUtils
from db import mysql_data_delegate as mysql_data, redis_manager_delegate as redis_manager
from db.mysql_data_delegate import Mysqldb
from db.redis_manager_delegate import RedisUtils
from l2.l2_data_manager import OrderBeginPosInfo, TradePointManager
from log_module import async_log_util
from output import kp_client_msg_manager
from trade import trade_data_manager, l2_trade_util, trade_juejin, trade_huaxin
from trade import trade_data_manager, l2_trade_util, trade_juejin, trade_huaxin, trade_constant

import time as t
from l2 import l2_data_manager, l2_data_log

from log_module.log import *
from utils import import_util, tool
from trade.buy_money_count_setting import BuyMoneyUtil
from trade.huaxin.huaxin_trade_record_manager import TradeOrderIdManager
from trade.order_statistic import DealAndDelegateWithBuyModeDataManager
from trade.trade_data_manager import AccountMoneyManager, RadicalBuyDealCodesManager
from utils import import_util, tool, huaxin_util

trade_gui = import_util.import_lib("trade.trade_gui")

__db = 2
__redis_manager = redis_manager.RedisManager(2)

# 未交易
TRADE_STATE_NOT_TRADE = 0
# 下单
TRADE_STATE_BUY_PLACE_ORDER = 10
# 已委托买
TRADE_STATE_BUY_DELEGATED = 11
# 委托取消进行中
TRADE_STATE_BUY_CANCEL_ING = 13
# 撤销成功
TRADE_STATE_BUY_CANCEL_SUCCESS = 14
# 买成功
TRADE_STATE_BUY_SUCCESS = 12

guiTrade = trade_gui.THSGuiTrade() if trade_gui is not None else None
guiTrade = None  # trade_gui.THSGuiTrade() if trade_gui is not None else None

latest_trade_delegate_data = []

@@ -48,6 +44,7 @@
# 开启购买入口
class TradeStateManager:
    __instance = None
    __db = 2
    redisManager = redis_manager.RedisManager(2)

    def __new__(cls, *args, **kwargs):
@@ -66,12 +63,12 @@
    # 开启购买入口
    def open_buy(self):
        self.__trade_buy_state_cache = True
        RedisUtils.setex(self.__get_redis(), "trade_buy_state", tool.get_expire(), 1)
        RedisUtils.setex_async(self.__db, "trade_buy_state", tool.get_expire(), 1)

    # 关闭购买入口
    def close_buy(self):
        self.__trade_buy_state_cache = False
        RedisUtils.setex(self.__get_redis(), "trade_buy_state", tool.get_expire(), 0)
        RedisUtils.setex_async(self.__db, "trade_buy_state", tool.get_expire(), 0)

    # 是否可以下单
    @classmethod
@@ -94,6 +91,8 @@

# 交易目标票模式
class TradeTargetCodeModeManager:
    # 只买辨识度
    MODE_ONLY_BUY_SPECIAL_CODES = 2
    # 只买想买单
    MODE_ONLY_BUY_WANT_CODES = 1
    # 买所有
@@ -120,7 +119,7 @@
        self.__trade_buy_mode_cache = self.get_mode()

    def set_mode(self, mode):
        if mode != self.MODE_ONLY_BUY_WANT_CODES and mode != self.MODE_BUY_ALL:
        if mode != self.MODE_ONLY_BUY_WANT_CODES and mode != self.MODE_BUY_ALL and mode != self.MODE_ONLY_BUY_SPECIAL_CODES:
            raise Exception("mode参数值错误")
        self.__trade_buy_mode_cache = mode
        RedisUtils.setex(self.__get_redis(), "trade_buy_mode", tool.get_expire(), mode)
@@ -138,39 +137,47 @@
        return self.__trade_buy_mode_cache


# 根据分数禁止买的票管理
class ForbiddenBuyCodeByScoreManager:
# 自动撤卖模式管理
class AutoCancelSellModeManager:
    # 撤所有
    MODE_CANCEL_ALL = 0
    # 撤机器下单
    MODE_CANCEL_MECHINE = 1

    __instance = None
    __auto_cancel_sell_mode = MODE_CANCEL_ALL

    redisManager = redis_manager.RedisManager(2)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(ForbiddenBuyCodeByScoreManager, cls).__new__(cls, *args, **kwargs)
            cls.__instance.__redisManager = redis_manager.RedisManager(2)
            cls.__instance.__key = "forbidden_codes_by_score"
            cls.__instance.__forbidden_codes_by_score_cache = RedisUtils.smembers(cls.__instance.__get_redis(),
                                                                                  cls.__instance.__key)
            cls.__instance = super(AutoCancelSellModeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__auto_cancel_sell_mode = cls.get_mode()
        return cls.__instance

    def __get_redis(self):
        return self.__redisManager.getRedis()
    @classmethod
    def __get_redis(cls):
        return cls.redisManager.getRedis()

    def add_code(self, code):
        self.__forbidden_codes_by_score_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), self.__key, code)
    def set_mode(self, mode):
        if mode != self.MODE_CANCEL_ALL and mode != self.MODE_CANCEL_MECHINE:
            raise Exception("mode参数值错误")
        self.__auto_cancel_sell_mode = mode
        RedisUtils.setex(self.__get_redis(), "auto_cancel_sell_mode", tool.get_expire(), mode)

    def remove_code(self, code):
        self.__forbidden_codes_by_score_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), self.__key, code)
    # 是否可以下单
    @classmethod
    def get_mode(cls):
        # 默认设置为可交易
        val = RedisUtils.get(cls.__get_redis(), "auto_cancel_sell_mode")
        if val is None:
            return cls.MODE_CANCEL_ALL
        return int(val)

    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), self.__key, code)

    def is_in_cache(self, code):
        return code in self.__forbidden_codes_by_score_cache

    def clear(self):
        self.__forbidden_codes_by_score_cache.clear()
        RedisUtils.delete(self.__get_redis(), self.__key)
    def get_mode_cache(self):
        return self.__auto_cancel_sell_mode


# 代码的交易状态管理
@@ -183,13 +190,7 @@
    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(CodesTradeStateManager, cls).__new__(cls, *args, **kwargs)
            __redis = cls.__get_redis()
            # 初始化数据
            keys = RedisUtils.keys(__redis, "trade-state-*", auto_free=False)
            if keys:
                for key in keys:
                    code = key.replace("trade-state-", '')
                    cls.__trade_state_cache[code] = int(RedisUtils.get(__redis, key, auto_free=False))
            cls.__load_datas()

        return cls.__instance

@@ -197,24 +198,38 @@
    def __get_redis(cls):
        return cls.__redis_manager.getRedis()

    @classmethod
    def __load_datas(cls):
        __redis = cls.__get_redis()
        try:
            # 初始化数据
            keys = RedisUtils.keys(__redis, "trade-state-*", auto_free=False)
            if keys:
                for key in keys:
                    code = key.replace("trade-state-", '')
                    cls.__trade_state_cache[code] = int(RedisUtils.get(__redis, key, auto_free=False))
        finally:
            RedisUtils.realse(__redis)

    # 获取交易状态
    def get_trade_state(self, code):
        state = RedisUtils.get(self.__get_redis(), "trade-state-{}".format(code))
        if state is None:
            return TRADE_STATE_NOT_TRADE
            return trade_constant.TRADE_STATE_NOT_TRADE
        return int(state)

    def get_trade_state_cache(self, code):
        cache_result = tool.CodeDataCacheUtil.get_cache(self.__trade_state_cache, code)
        if cache_result[0]:
            return cache_result[1]
        val = self.get_trade_state(code)
        tool.CodeDataCacheUtil.set_cache(self.__trade_state_cache, code, val)
        return val
        return trade_constant.TRADE_STATE_NOT_TRADE

    def get_trade_state_dict(self):
        return copy.deepcopy(self.__trade_state_cache)

    # 设置交易状态
    def set_trade_state(self, code, state):
        logger_trade.info("set_trade_state {}-{}".format(code, state))
        async_log_util.info(logger_trade, "set_trade_state {}-{}".format(code, state))
        tool.CodeDataCacheUtil.set_cache(self.__trade_state_cache, code, state)
        RedisUtils.setex_async(self.__db, "trade-state-{}".format(code), tool.get_expire(), state)

@@ -253,41 +268,6 @@
        return codes

    # 设置交易账户的可用金额


# 账户可用资金管理
class AccountAvailableMoneyManager:
    __db = 2
    __redis_manager = redis_manager.RedisManager(2)
    __available_money_cache = None
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(AccountAvailableMoneyManager, cls).__new__(cls, *args, **kwargs)
            __redis = cls.__get_redis()
            result = RedisUtils.get(cls.__get_redis(), "trade-account-canuse-money")
            if result:
                cls.__available_money_cache = round(float(result), 2)
        return cls.__instance

    @classmethod
    def __get_redis(cls):
        return cls.__redis_manager.getRedis()

    def set_available_money(self, client_id, money):
        self.__available_money_cache = round(float(money), 2)
        RedisUtils.set(self.__get_redis(), "trade-account-canuse-money", money)

    # 获取交易账户的可用金额
    def get_available_money(self):
        result = RedisUtils.get(self.__get_redis(), "trade-account-canuse-money")
        if result is None:
            return None
        return round(float(result), 2)

    def get_available_money_cache(self):
        return self.__available_money_cache


# 保存交易成功的数据
@@ -379,24 +359,24 @@
        RedisUtils.realse(redis)


__CodesTradeStateManager = CodesTradeStateManager()


# 开始交易
def start_buy(code, capture_timestamp, last_data, last_data_index):
    @dask.delayed
def start_buy(code, capture_timestamp, last_data, last_data_index, mode=0, exec_index=None):
    def is_forbidden(code):
        if l2_trade_util.is_in_forbidden_trade_codes(code):
            return Exception("禁止交易")
        return None, None

    @dask.delayed
    def is_state_right(code):
        trade_state = CodesTradeStateManager().get_trade_state_cache(code)
        if trade_state != TRADE_STATE_NOT_TRADE and trade_state != TRADE_STATE_BUY_CANCEL_SUCCESS and trade_state != TRADE_STATE_BUY_CANCEL_ING:
        trade_state = __CodesTradeStateManager.get_trade_state_cache(code)
        if trade_state != trade_constant.TRADE_STATE_NOT_TRADE and trade_state != trade_constant.TRADE_STATE_BUY_CANCEL_SUCCESS and trade_state != trade_constant.TRADE_STATE_BUY_CANCEL_ING:
            return Exception("代码处于不可交易状态"), trade_state
        return None, trade_state

    @dask.delayed
    def is_money_enough(code):
        money = AccountAvailableMoneyManager().get_available_money_cache()
        money = AccountMoneyManager().get_available_money_cache()
        if money is None:
            return Exception("未获取到账户可用资金"), None
        price = gpcode_manager.get_limit_up_price(code)
@@ -407,66 +387,71 @@
            return Exception("账户可用资金不足"), price
        return None, price

    @dask.delayed
    def can_trade(*args):
        for arg in args:
            if arg[0] is not None:
                return arg[0], None, None
        return None, args[1][1], args[2][1]
    async_log_util.info(logger_trade, "{} trade.manager.start_buy 开始".format(code))
    try:
        try:
            ex = is_forbidden(code)[0]
            if ex:
                raise ex
            ex, trade_state = is_state_right(code)
            if ex:
                raise ex
            ex, price = is_money_enough(code)
            if ex:
                raise ex
        finally:
            async_log_util.info(logger_trade, "{} trade.manager.start_buy 判断是否可买".format(code))
        __CodesTradeStateManager.set_trade_state(code, trade_constant.TRADE_STATE_BUY_PLACE_ORDER)
        # 状态改变过后必须要有本地下单编号
        __buy(code, price, trade_state, capture_timestamp, last_data, last_data_index, mode, exec_index=exec_index)
    finally:
        async_log_util.info(logger_trade, "{} trade.manager.start_buy 结束".format(code))

    _start_time = tool.get_now_timestamp()

    f1 = is_forbidden(code)
    f2 = is_state_right(code)
    f3 = is_money_enough(code)
    dask_result = can_trade(f1, f2, f3)
    ex, trade_state, price = dask_result.compute()
    if ex is not None:
        raise ex

    # 并行改造
    # # 是否禁止交易
    # if l2_trade_util.is_in_forbidden_trade_codes(code):
    #     raise Exception("禁止交易")
    # trade_state = get_trade_state(code)
    # if trade_state != TRADE_STATE_NOT_TRADE and trade_state != TRADE_STATE_BUY_CANCEL_SUCCESS and trade_state != TRADE_STATE_BUY_CANCEL_ING:
    #     raise Exception("代码处于不可交易状态")
    # money = get_available_money()
    # if money is None:
    #     raise Exception("未获取到账户可用资金")
    # price = gpcode_manager.get_limit_up_price(code)
    # if price is None:
    #     raise Exception("尚未获取到涨停价")
    # # 买一手的资金是否足够
    # if price * 100 > money:
    #     raise Exception("账户可用资金不足")

    print("开始买入")
    logger_trade.info("{}开始买入".format(code))
    CodesTradeStateManager().set_trade_state(code, TRADE_STATE_BUY_PLACE_ORDER)
    _start_time = l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "买入判断时间", force=True)
    __buy(code, price, trade_state, capture_timestamp, last_data, last_data_index)
    l2_data_log.l2_time(code, tool.get_now_timestamp() - _start_time, "异步买入时间", force=True)
def test_order(code, last_data, exec_index):
    """
    TODO 测试下单
    @param code:
    @param last_data:
    @param exec_index:
    @return:
    """
    price = gpcode_manager.get_limit_up_price(code)
    __buy(code, price, trade_constant.TRADE_STATE_NOT_TRADE, 0, last_data, last_data["index"],  0, exec_index=exec_index)


# 中断买入
def break_buy(code, reason):
    trade_data_manager.TradeBuyDataManager.remove_buy_position_info(code)
    trade_data_manager.TradeBuyDataManager().remove_buy_position_info(code)


# 购买
# @tool.async_call
def __buy(code, price, trade_state, capture_timestamp, last_data, last_data_index):
def __buy(code, price, trade_state, capture_timestamp, last_data, last_data_index, mode=0, exec_index=None):
    async_log_util.info(logger_trade, "{} trade_manager.__buy 开始".format(code))
    try:
        if constant.API_TRADE_ENABLE:
            count = (constant.BUY_MONEY_PER_CODE // int(round(float(price) * 100))) * 100
            # 最低下单1手
            if count < 100:
                count = 100
            can_buy, money, msg = BuyMoneyUtil.get_buy_data(tool.get_now_time_str(), mode,
                                                            DealAndDelegateWithBuyModeDataManager().get_deal_codes_info(
                                                                mode),
                                                            DealAndDelegateWithBuyModeDataManager().get_delegates_codes_info(
                                                                mode))
            if not can_buy:
                raise Exception(msg)
            count = tool.get_buy_volume_by_money(price, money)

            # if mode == OrderBeginPosInfo.MODE_RADICAL:
            #     # 激进买入金额为1手
            #     count = 100
            if constant.TRADE_WAY == constant.TRADE_WAY_JUEJIN:
                trade_juejin.order_volume(code, price, count)
            elif constant.TRADE_WAY == constant.TRADE_WAY_HUAXIN:
                trade_huaxin.order_volume(code, price, count, last_data_index)
                if constant.IS_NEW_VERSION_PLACE_ORDER:
                    trade_huaxin.order_volume_new(code, price, count, last_data, exec_index=exec_index)
                else:
                    order_ref = huaxin_util.create_order_ref()
                    TradeOrderIdManager().add_order_ref(code, order_ref)
                    trade_huaxin.order_volume(code, price, count, last_data, order_ref=order_ref, exec_index=exec_index)
        else:
            guiTrade.buy(code, price)
        __place_order_success(code, capture_timestamp, last_data, last_data_index)
@@ -475,22 +460,23 @@
        logger_trade.error("{}买入异常{}".format(code, str(e)))
        logger_trade.exception(e)
        raise e
    finally:
        async_log_util.info(logger_trade, "{} trade_manager.__buy 结束".format(code))


# 下单成功
def __place_order_success(code, capture_timestamp, last_data, last_data_index):
    # 买入结束点
    use_time = round(time.time() * 1000) - capture_timestamp
    logger_trade.info("{}-从截图到下单成功总费时：{}".format(code, use_time))
    # 下单成功，加入固定代码库
    l2_data_manager.add_to_l2_fixed_codes(code)
    if constant.L2_SOURCE_TYPE == constant.L2_SOURCE_TYPE_THS:
        l2_data_manager.add_to_l2_fixed_codes(code)
    # 记录下单的那一帧图片的截图时间与交易用时
    trade_data_manager.TradeBuyDataManager.set_buy_position_info(code, capture_timestamp, use_time, last_data,
                                                                 last_data_index)

    trade_data_manager.TradeBuyDataManager().set_buy_position_info(code, capture_timestamp, use_time, last_data,
                                                                   last_data_index)
    print("买入结束")
    logger_trade.info("{}买入成功".format(code))
    kp_client_msg_manager.add_msg(code, "下单成功")
    async_log_util.info(logger_trade, "{}买入成功".format(code))
    # kp_client_msg_manager.add_msg(code, "下单成功")


# 下单失败
@@ -500,18 +486,28 @@
    CodesTradeStateManager().set_trade_state(code, trade_state)


__CodesTradeStateManager = CodesTradeStateManager()

__cancel_order_thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)


# 开始取消买入
def start_cancel_buy(code, force=False):
    trade_state = CodesTradeStateManager().get_trade_state_cache(code)
    if trade_state == TRADE_STATE_BUY_SUCCESS:
        return None
    if not force:
        if trade_state != TRADE_STATE_BUY_PLACE_ORDER and trade_state != TRADE_STATE_BUY_DELEGATED:
            return None
    """
    开始撤单
    @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:
        logger_trade.info("{}开始撤单".format(code))
        CodesTradeStateManager().set_trade_state(code, TRADE_STATE_BUY_CANCEL_ING)
        logger_trade.info("{}撤单方法开始".format(code))
        if trade_state == trade_constant.TRADE_STATE_BUY_SUCCESS:
            return None
        if not force:
            if trade_state != trade_constant.TRADE_STATE_BUY_PLACE_ORDER and trade_state != trade_constant.TRADE_STATE_BUY_DELEGATED:
                return None
        __CodesTradeStateManager.set_trade_state(code, trade_constant.TRADE_STATE_BUY_CANCEL_ING)
        if constant.API_TRADE_ENABLE:
            if constant.TRADE_WAY == constant.TRADE_WAY_JUEJIN:
                trade_juejin.cancel_order(code)
@@ -519,8 +515,12 @@
                trade_huaxin.cancel_order(code)
        else:
            guiTrade.cancel_buy(code)
        logger_trade.info("{}撤单方法结束".format(code))
        __cancel_success(code)
        # 再次撤单
        if constant.TRADE_WAY == constant.TRADE_WAY_HUAXIN:
            async_log_util.info(logger_trade, "{} trade_manager.start_cancel_buy 再次撤单开始".format(code))
            __cancel_order_thread_pool.submit(lambda: trade_huaxin.cancel_order(code, msg="再次撤单"))
            async_log_util.info(logger_trade, "{} trade_manager.start_cancel_buy 再次撤单结束".format(code))
        # 不需要再次撤单了
        # try:
        #     cancel_buy_again(code)
@@ -529,9 +529,10 @@
    except Exception as e:
        # 状态还原
        CodesTradeStateManager().set_trade_state(code, trade_state)
        logger_trade.error("{}撤单异常：{}".format(code, str(e)))
        async_log_util.error(logger_trade, "{}撤单异常：{}".format(code, str(e)))
        raise e
    logger_trade.info("{}撤单完毕".format(code))
    finally:
        async_log_util.info(logger_trade, "{} trade_manager.start_cancel_buy 结束".format(code))


# 再次撤单，防止没有撤掉
@@ -541,7 +542,7 @@
    for i in range(0, 5):
        # 如果时
        trade_state = CodesTradeStateManager().get_trade_state_cache(code)
        if trade_state != TRADE_STATE_BUY_CANCEL_ING and trade_state != TRADE_STATE_BUY_CANCEL_SUCCESS:
        if trade_state != trade_constant.TRADE_STATE_BUY_CANCEL_ING and trade_state != trade_constant.TRADE_STATE_BUY_CANCEL_SUCCESS:
            return
        try:
            logger_trade.info("{}：开始再次撤单", code)
@@ -556,11 +557,13 @@

# 取消委托成功
def __cancel_success(code):
    trade_data_manager.TradeBuyDataManager.remove_buy_position_info(code)
    trade_data_manager.TradeBuyDataManager().remove_buy_position_info(code)
    # 下单成功，加入固定代码库
    l2_data_manager.remove_from_l2_fixed_codes(code)
    logger_trade.info("{}撤单成功".format(code))
    kp_client_msg_manager.add_msg(code, "撤单成功")
    if constant.L2_SOURCE_TYPE == constant.L2_SOURCE_TYPE_THS:
        l2_data_manager.remove_from_l2_fixed_codes(code)
    async_log_util.info(logger_trade, "{}撤单成功".format(code))
    # 暂时注释掉，有可能拖慢进程
    # kp_client_msg_manager.add_msg(code, "撤单成功")


# 处理交易成功数据
@@ -574,24 +577,22 @@
            continue
        # 买入成功
        if code is not None and int(data["type"]) == 0:
            l2_trade_util.forbidden_trade(code)
            l2_trade_util.forbidden_trade(code, msg="交易成功", force=True)
            state = CodesTradeStateManager().get_trade_state_cache(code)
            if state != TRADE_STATE_BUY_SUCCESS:
                CodesTradeStateManager().set_trade_state(code, TRADE_STATE_BUY_SUCCESS)
            if state != trade_constant.TRADE_STATE_BUY_SUCCESS:
                CodesTradeStateManager().set_trade_state(code, trade_constant.TRADE_STATE_BUY_SUCCESS)
                # 删除买撤记录的临时信息
                kp_client_msg_manager.add_msg(code, "买入成交")
                l2_data_manager.TradePointManager().delete_buy_cancel_point(code)
                l2_data_manager.TradePointManager().delete_buy_point(code)
                # 移除交易窗口分配
                if trade_gui is not None:
                    trade_gui.THSBuyWinManagerNew.cancel_distribute_win_for_code(code)
            # 交易成功时间过去3s之后，且当前委托列表里面还有该代码数据就再次执行撤单
            if tool.trade_time_sub(tool.get_now_time_str(), _time) > 3:
                # 获取到当前是否委托
                for dd in latest_trade_delegate_data:
                    if dd["code"] == code:
                        logger_trade.info("{}交易成功触发，重复下单撤单".format(code))
                        start_cancel_buy(code, True)
            # 新版下单不处理
            if not constant.IS_NEW_VERSION_PLACE_ORDER:
                if tool.trade_time_sub(tool.get_now_time_str(), _time) > 3:
                    # 获取到当前是否委托
                    for dd in latest_trade_delegate_data:
                        if dd["code"] == code:
                            logger_trade.info("{}交易成功触发，重复下单撤单".format(code))
                            start_cancel_buy(code, True)


# 处理委托成功数据
@@ -602,23 +603,23 @@
    latest_trade_delegate_data.extend(datas)
    codes = []
    for data in datas:

        code = data["code"]
        if code is not None:
            codes.append(code)
            trade_state = CodesTradeStateManager().get_trade_state_cache(code)
            # 设置下单状态的代码为已委托
            if trade_state == TRADE_STATE_BUY_PLACE_ORDER:
                CodesTradeStateManager().set_trade_state(code, TRADE_STATE_BUY_DELEGATED)
    ing_codes = CodesTradeStateManager().get_codes_by_trade_state(TRADE_STATE_BUY_CANCEL_ING)
    if ing_codes is not None:
        for code in ing_codes:
            if code in codes:
                # 强制重新取消
                start_cancel_buy(code, True)
            else:
                CodesTradeStateManager().set_trade_state(code, TRADE_STATE_BUY_CANCEL_SUCCESS)
                l2_data_manager.remove_from_l2_fixed_codes(code)
            if trade_state == trade_constant.TRADE_STATE_BUY_PLACE_ORDER:
                CodesTradeStateManager().set_trade_state(code, trade_constant.TRADE_STATE_BUY_DELEGATED)
    if constant.TRADE_WAY == constant.TRADE_WAY_JUEJIN:
        ing_codes = CodesTradeStateManager().get_codes_by_trade_state(trade_constant.TRADE_STATE_BUY_CANCEL_ING)
        if ing_codes is not None:
            for code in ing_codes:
                if code in codes:
                    # 强制重新取消
                    start_cancel_buy(code, True)
                else:
                    CodesTradeStateManager().set_trade_state(code, trade_constant.TRADE_STATE_BUY_CANCEL_SUCCESS)
                    l2_data_manager.remove_from_l2_fixed_codes(code)


def __clear_data(code):
@@ -657,6 +658,29 @@
        RedisUtils.realse(redis_l2)


# 买入成功
def buy_success(code):
    # 加入黑名单
    if not l2_trade_util.is_in_forbidden_trade_codes(code):
        l2_trade_util.forbidden_trade(code, "buy success", force=True)
        mode = TradePointManager().get_latest_place_order_mode(code)
        if mode is None:
            mode = OrderBeginPosInfo.MODE_NORMAL
        DealAndDelegateWithBuyModeDataManager().add_deal_code(code, tool.get_now_time_str(), mode)
        if mode == OrderBeginPosInfo.MODE_RADICAL:
            RadicalBuyDealCodesManager().add_deal_code(code)
    # 取s消所有的挂单
    if constant.API_TRADE_ENABLE:
        if not constant.IS_NEW_VERSION_PLACE_ORDER:
            # 新版本拆单下单不撤单
            if constant.TRADE_WAY == constant.TRADE_WAY_JUEJIN:
                trade_juejin.cancel_order(code)
            elif constant.TRADE_WAY == constant.TRADE_WAY_HUAXIN:
                trade_huaxin.cancel_order(code)
    else:
        guiTrade.cancel_buy(code)


if __name__ == "__main__":
    print(CodesTradeStateManager().get_codes_by_trade_states_cache([0, 1]))
    print(CodesTradeStateManager().get_trade_state_cache("002235"))