默认交易模式变更/真实下单位置计算位置修改

Administrator

6 小时以前 2f2516749615da866e96d8d24e499b7ecbb63a3e

 trade/l2_trade_util.py

@@ -1,143 +1,52 @@
# 是否在禁止交易代码中
from code_attribute import gpcode_manager
from db import redis_manager_delegate as redis_manager
from db.redis_manager_delegate import RedisUtils
from log_module import async_log_util
from log_module.log import logger_trade
from utils import tool
from trade import trade_record_log_util
from trade.buy_radical.block_special_codes_manager import BlockSpecialCodesManager

__redis_manager = redis_manager.RedisManager(2)


class WhiteListCodeManager:
    __instance = None
    __redis_manager = redis_manager.RedisManager(2)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(WhiteListCodeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.__white_codes_cache = RedisUtils.smembers(cls.__get_redis(), "white_list_codes")

        return cls.__instance

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

    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(), "white_list_codes")
        self.__white_codes_cache.clear()
        if data:
            self.__white_codes_cache |= data

    def add_code(self, code):
        self.__white_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), "white_list_codes", code)
        RedisUtils.expire(self.__get_redis(), "white_list_codes", tool.get_expire())

    def remove_code(self, code):
        self.__white_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "white_list_codes", code)

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

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

    def list_codes(self):
        return RedisUtils.smembers(self.__get_redis(), "white_list_codes")

    def list_codes_cache(self):
        return self.__white_codes_cache

    def clear(self):
        self.__white_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "white_list_codes")


class BlackListCodeManager:
    __instance = None
    __redis_manager = redis_manager.RedisManager(2)

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = super(BlackListCodeManager, cls).__new__(cls, *args, **kwargs)
            # 初始化设置
            # 获取交易窗口的锁
            cls.__instance.__forbidden_trade_codes_cache = RedisUtils.smembers(cls.__get_redis(),
                                                                               "forbidden-trade-codes")

        return cls.__instance

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

    def add_code(self, code):
        self.__forbidden_trade_codes_cache.add(code)
        RedisUtils.sadd(self.__get_redis(), "forbidden-trade-codes", code)
        RedisUtils.expire(self.__get_redis(), "forbidden-trade-codes", tool.get_expire())

    def sync(self):
        data = RedisUtils.smembers(self.__get_redis(),
                                   "forbidden-trade-codes")
        self.__forbidden_trade_codes_cache.clear()
        if data:
            self.__forbidden_trade_codes_cache |= data

    def remove_code(self, code):
        self.__forbidden_trade_codes_cache.discard(code)
        RedisUtils.srem(self.__get_redis(), "forbidden-trade-codes", code)

    def is_in(self, code):
        return RedisUtils.sismember(self.__get_redis(), "forbidden-trade-codes", code)

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

    def list_codes(self):
        codes = RedisUtils.smembers(self.__get_redis(), "forbidden-trade-codes")
        self.__forbidden_trade_codes_cache = codes
        return codes

    def list_codes_cache(self):
        return self.__forbidden_trade_codes_cache

    def clear(self):
        self.__forbidden_trade_codes_cache.clear()
        RedisUtils.delete(self.__get_redis(), "forbidden-trade-codes")


#  初始化禁止交易代码库
def init_forbidden_trade_codes():
    BlackListCodeManager().clear()
    BlackListCodeManager().add_code("000000")
    gpcode_manager.BlackListCodeManager().clear()
    gpcode_manager.BlackListCodeManager().add_code("000000")


# 移除禁止交易代码
def remove_from_forbidden_trade_codes(code):
    BlackListCodeManager().remove_code(code)
    gpcode_manager.BlackListCodeManager().remove_code(code)


# 添加代码到禁止交易
def add_to_forbidden_trade_codes(code):
    BlackListCodeManager().add_code(code)
def __add_to_forbidden_trade_codes(code):
    gpcode_manager.BlackListCodeManager().add_code(code)


# 禁止代码交易
def forbidden_trade(code, msg=None):
    add_to_forbidden_trade_codes(code)
    async_log_util.warning(logger_trade, f"{code}加入黑名单原因：{msg}")
    # l2_data_manager.remove_from_l2_fixed_codes(code)
    # l2_code_operate.L2CodeOperate.get_instance().remove_l2_listen(code, "禁止代码交易")
# force 是否强制加入黑名单
def forbidden_trade(code, msg=None, force=False):
    need_add = False
    if force:
        need_add = True
    else:
        # 检查是否在想买单中
        if gpcode_manager.HumanRemoveForbiddenManager().is_in_cache(code):
            # 人为移除黑，不可再拉黑
            need_add = False
        else:
            need_add = True

    if need_add:
        if not is_in_forbidden_trade_codes(code):
            trade_record_log_util.add_forbidden_buy_log(code, msg)
        __add_to_forbidden_trade_codes(code)
        async_log_util.warning(logger_trade, f"{code}加入黑名单原因：{msg}")



def is_in_forbidden_trade_codes(code):
    return BlackListCodeManager().is_in_cache(code)
    return gpcode_manager.BlackListCodeManager().is_in_cache(code)


if __name__ == "__main__":
    # add_to_forbidden_trade_codes("000977")
    WhiteListCodeManager().add_code("002977")