def AddBotHelpListener(bcc: Broadcast):
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#帮助")
])(GroupHelpMessage)
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#关于")
])(GroupAboutMessage)
def postGroupMessage(message: MessageChain, bcc: Broadcast) -> NoReturn:
bcc.postEvent(
GroupMessage(messageChain=message,
sender=Member(id=123456789,
memberName="member name",
permission=MemberPerm.Administrator,
group=Group(
id=123456789,
name="group name",
permission=MemberPerm.Administrator))))
def AddGroupAnswerListener(bcc: Broadcast):
bcc.receiver("GroupMessage")(GroupAddAnswer)
bcc.receiver("GroupMessage")(GroupDeleteAnswer)
bcc.receiver("GroupMessage", headless_decorators=[strictPlainCommand("#可用进群答案")])(
GroupAllowAnswer
)
bcc.receiver("MemberJoinRequestEvent")(MemberJoinRequest)
def AddGroupSentenceListener(bcc: Broadcast):
bcc.receiver("GroupMessage",
headless_decorators=[startWith("#添加群语录")])(GroupAddSentence)
bcc.receiver("GroupMessage")(GroupShowSentence)
bcc.receiver("GroupMessage")(GroupDeleteSentence)
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#随机语录")
])(GroupRandomSentence)
async def auto_parse_by_type(original_dict: dict) -> BaseEvent:
"""从尚未明确指定事件类型的对象中获取事件的定义, 并进行解析
Args:
original_dict (dict): 用 dict 表示的序列化态事件, 应包含有字段 `type` 以供分析事件定义.
Raises:
InvaildArgument: 目标对象中不包含字段 `type`
ValueError: 没有找到对应的字段, 通常的, 这意味着应用获取到了一个尚未被定义的事件, 请报告问题.
Returns:
BaseEvent: 已经被序列化的事件
"""
if not original_dict.get("type") and not isinstance(
original_dict.get("type"), str):
raise InvaildArgument(
"you need to provide a 'type' field for automatic parsing")
event_type = Broadcast.findEvent(original_dict.get("type"))
if not event_type:
raise ValueError("we cannot find a such event: {}".format(
original_dict.get("type")))
return await run_always_await(
event_type.parse_obj(
{k: v
for k, v in original_dict.items() if k != "type"}))
def __init__(self, app_configs: Dict, configs: Dict):
self.directs = {}
self.docs = {}
self.schedules = {}
self.inner_commands = {}
self.commands = {}
self.schedule_task_list = []
self.message_queue = Queue()
self.command_queue = Queue()
self.history = None
self.loop = asyncio.get_event_loop()
self.bcc = Broadcast(loop=self.loop)
self.counters = [0, 0]
if configs['debug']:
global defaultLogger
defaultLogger.close()
defaultLogger = DefaultLogger(level=DEBUG)
self.logger = defaultLogger
self.app = GraiaMiraiApplication(broadcast=self.bcc,
connect_info=Session(**app_configs),
logger=self.logger,
debug=configs['debug'])
self.prefix = configs['prefix']
self.db = Storage.load()
self.load_mods()
def __init__(self, config: GlobalConfig):
if not self.__first_init:
logger.info("Initializing")
self.__loop = asyncio.get_event_loop()
self.__bcc = Broadcast(loop=self.__loop)
self.__app = Ariadne(broadcast=self.__bcc,
chat_log_config=False,
connect_info=DefaultAdapter(
broadcast=self.__bcc,
ping=False,
mirai_session=MiraiSession(
host=config.mirai_host,
verify_key=str(config.verify_key),
account=config.bot_qq),
))
self.__saya = Saya(self.__bcc)
self.__saya.install_behaviours(BroadcastBehaviour(self.__bcc))
if _install_scheduler:
self.__sche = GraiaScheduler(loop=self.__loop,
broadcast=self.__bcc)
self.__saya.install_behaviours(
GraiaSchedulerBehaviour(self.__sche))
self.__app.debug = False
self.__config = config
AppCore.__first_init = True
logger.info("Initialize end")
else:
raise AppCoreAlreadyInitialized()
def __init__(self, config: dict):
if not self.__first_init:
logger.info("Initializing")
if any(parameter not in config
for parameter in self.necessary_parameters):
raise ValueError(
f"Missing necessary parameters! (miraiHost, authKey, BotQQ)"
)
self.__loop = asyncio.get_event_loop()
self.__bcc = Broadcast(loop=self.__loop)
self.__app = GraiaMiraiApplication(broadcast=self.__bcc,
connect_info=Session(
host=config["miraiHost"],
authKey=config["authKey"],
account=config["BotQQ"],
websocket=True),
enable_chat_log=False)
self.__saya = Saya(self.__bcc)
self.__saya.install_behaviours(BroadcastBehaviour(self.__bcc))
self.__app.debug = False
self.__config = config
AppCore.__first_init = True
logger.info("Initialize end")
else:
raise AppCoreAlreadyInitialized()
def AddGroupMuteMemberListener(bcc: Broadcast):
bcc.receiver("GroupMessage")(GroupMuteMember)
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#解除禁言")
])(GroupunmuteMember)
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#全体禁言")
])(GroupMuteAll)
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#解除全体禁言")
])(GroupUnMuteAll)
def __init__(self, account, key):
self.loop = asyncio.get_event_loop()
self.bcc = Broadcast(loop=self.loop)
self.scheduler = AsyncIOScheduler()
self.mirai = GraiaMiraiApplication(broadcast=self.bcc,
connect_info=Session(
host="http://localhost:8080",
authKey=key,
account=account,
websocket=True))
def AddGroupBlockListListener(bcc: Broadcast):
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#警告")
])(GroupWarnMember)
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#删除警告")
])(GroupCancelWarnMember)
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#拉黑")
])(GroupBlockMember)
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#解除拉黑")
])(GroupUnBlockMember)
def start(self):
message_handler = MsgHandler()
# message_handler.initHandler()
loop = asyncio.get_event_loop()
bcc = Broadcast(loop=loop)
app = GraiaMiraiApplication(
broadcast=bcc,
connect_info=Session(
host="http://*****:*****@bcc.receiver("FriendMessage")
async def friend_message_listener(graia_app: GraiaMiraiApplication,
friend: Friend,
message: MessageChain):
async def friend_sender(send_msg):
result = await graia_app.sendFriendMessage(
friend, MessageChain.create([send_msg]))
if result:
self.set_send_msg_flag(False)
threading.Timer(5.0, self.set_send_msg_flag).start()
msg = message.asDisplay()
log.i("receive friend message: %s" % msg)
await message_handler.handle(msg, friend_sender, friend=friend)
@bcc.receiver("GroupMessage")
async def group_message_listener(graia_app: GraiaMiraiApplication,
group: Group, member: Member,
message: MessageChain):
async def group_sender(send_msg):
should_respond = True
if member.id == aqiang_id:
should_respond = False
if should_respond:
result = await graia_app.sendGroupMessage(
group, MessageChain.create([send_msg]))
if result:
self.set_send_msg_flag(False)
threading.Timer(5.0, self.set_send_msg_flag).start()
msg = message.asDisplay()
log.i("receive group message: %s" % msg)
await message_handler.handle(msg, group_sender)
app.launch_blocking()
async def auto_parse_by_type(original_dict: dict) -> BaseEvent:
if not original_dict.get("type") and not isinstance(
original_dict.get("type"), str):
raise InvaildArgument(
"you need to provide a 'type' field for automatic parsing")
event_type = Broadcast.findEvent(original_dict.get("type"))
if not event_type:
raise ValueError("we cannot find a such event: {}".format(
original_dict.get("type")))
return await run_always_await(
event_type.parse_obj(
{k: v
for k, v in original_dict.items() if k != "type"}))
def AddGroupAdminListener(bcc: Broadcast):
bcc.receiver("GroupMessage", headless_decorators=[strictPlainCommand("#添加管理员")])(
GroupAddAdmin
)
bcc.receiver("GroupMessage", headless_decorators=[strictPlainCommand("#解除管理员")])(
GroupRemoveAdmin
)
bcc.receiver("GroupMessage", headless_decorators=[strictPlainCommand("#当前管理员")])(
GroupAvailableAdmin
)
def AddAnswerBookListener(bcc: Broadcast):
bcc.receiver("GroupMessage",
headless_decorators=[regexPlain(r"^#神启[\s]*([^\s]*)$")
])(AnswerBookGroup)
bcc.receiver("FriendMessage",
headless_decorators=[regexPlain(r"^#神启[\s]*([^\s]*)$")
])(AnswerBookFriend)
bcc.receiver("TempMessage",
headless_decorators=[regexPlain(r"^#神启[\s]*([^\s]*)$")
])(AnswerBookTemp)
def AddAppToUrlListener(bcc: Broadcast):
bcc.receiver("GroupMessage")(AppToUrlAutoConvertGenerator(GroupMessage))
bcc.receiver("FriendMessage")(AppToUrlAutoConvertGenerator(FriendMessage))
bcc.receiver("TempMessage")(AppToUrlAutoConvertGenerator(TempMessage))
bcc.receiver("GroupMessage",
headless_decorators=[strictPlainCommand("#提取App链接")])(
MessageAppToUrlGenerator(GroupMessage))
bcc.receiver("FriendMessage",
headless_decorators=[strictPlainCommand("#提取App链接")])(
MessageAppToUrlGenerator(FriendMessage))
bcc.receiver("TempMessage",
headless_decorators=[strictPlainCommand("#提取App链接")
])(MessageAppToUrlGenerator(TempMessage))
import asyncio
from graia.saya import Saya
from graia.broadcast import Broadcast
from graia.saya.builtins.broadcast import BroadcastBehaviour
from graia.scheduler import GraiaScheduler
from graia.scheduler.saya import GraiaSchedulerBehaviour
from graia.application.entry import (
GraiaMiraiApplication, Session
)
from utils import ModuleLoader, BotAttributes
from utils import logger
loop = asyncio.get_event_loop()
broadcast = Broadcast(loop=loop)
scheduler = GraiaScheduler(loop, broadcast)
saya = Saya(broadcast)
bot = BotAttributes("./config.json")
saya.install_behaviours(BroadcastBehaviour(broadcast))
saya.install_behaviours(GraiaSchedulerBehaviour(scheduler))
ModuleLoader.load(saya)
app = GraiaMiraiApplication(
broadcast=broadcast,
connect_info=Session(
host=bot.host,
authKey=bot.authKey,
account=bot.account,
websocket=True
@staticmethod
async def catch(interface: "DispatcherInterface"):
if interface.annotation is str:
return "1"
@Waiter.create_using_function([TestEvent])
def waiter(event: TestEvent):
return 1
event = TestEvent()
loop = asyncio.get_event_loop()
broadcast = Broadcast(
loop=loop,
debug_flag=False,
)
@broadcast.receiver(TestEvent)
async def r(r: str, d: str, c: str):
# loop.call_later(1, lambda: broadcast.postEvent(TestEvent()))
# print(await inc.wait(waiter))
pass
count = 40000
event = TestEvent()
listener = broadcast.getListener(r)
tasks = []
def AddGroupConfigChangeListener(bcc: Broadcast):
bcc.receiver("BotGroupPermissionChangeEvent")(GroupPermissionChange)
bcc.receiver("GroupNameChangeEvent")(GroupNameChange)
bcc.receiver("GroupEntranceAnnouncementChangeEvent")(
GroupEntranceAnnouncementChange)
bcc.receiver("GroupMuteAllEvent")(GroupMuteAll)
bcc.receiver("GroupAllowAnonymousChatEvent")(GroupAnonymousChat)
bcc.receiver("GroupAllowConfessTalkEvent")(GroupConfessTalk)
def MiraiRun(self):
Cfg = self.RecorderInstance.GetConfig
asyncio.set_event_loop(asyncio.new_event_loop())
loop = asyncio.get_event_loop()
bcc = Broadcast(loop=loop)
app = GraiaMiraiApplication(
broadcast=bcc,
connect_info=Session(
host="http://" + Cfg().
plugin_notifybot_mirai_api_http_locate, # 填入 httpapi 服务运行的地址
authKey=Cfg().plugin_notifybot_authkey, # 填入 authKey
account=Cfg().plugin_notifybot_qq_number, # 你的机器人的 qq 号
websocket=True # Graia 已经可以根据所配置的消息接收的方式来保证消息接收部分的正常运作.
))
@bcc.receiver("FriendMessage")
async def event_fm(app: GraiaMiraiApplication, friend: Friend,
msg: MessageChain):
self.PrintLog("Receive friend message: " + str(msg))
for Callback in self.RecorderInstance.GetCallbackCollection(
"QQInterface", "OnFriendMessage"):
try:
Callback(room_info)
except Exception as pe:
self.PrintLog("Plugin exception: " + repr(e))
traceback.print_exc()
await app.sendFriendMessage(
friend, MessageChain.create([Plain(text="机器人没有私聊功能")]))
def GetSelfName():
Names = Cfg().plugin_notifybot_say_selfname
if len(Names) > 0:
return Names[random.randint(0, len(Names) - 1)]
else:
return ""
def GetCalendarMessage():
try:
TxtResult = []
CalData = self.requirements[
"RoomPollingClient"].GetLiveCalendar()
ts = CalData["now"]
rts = datetime.datetime.fromtimestamp(ts)
prog_today_passed = None
prog_scheduled = None
for prog in CalData["programs"]:
prog_ts = prog["ts"]
prog_rts = datetime.datetime.fromtimestamp(prog_ts)
if prog_ts < ts and prog_rts.day == rts.day:
prog_today_passed = prog
if prog_ts >= ts:
prog_scheduled = prog
break
TxtResult.append("让我康康直播日历,")
if prog_scheduled:
prog_ts = prog_scheduled["ts"]
prog_rts = datetime.datetime.fromtimestamp(prog_ts)
if prog_rts.day == rts.day:
TxtResult.append("今天 " + prog_rts.strftime("%H:%M") +
" 有直播哦！标题：" + prog_scheduled["title"])
else:
if prog_today_passed:
TxtResult.append("今天播过了！标题：" +
prog_today_passed["title"])
TxtResult.append("今天接下来没有了！下一场：" +
prog_rts.strftime("%m-%d %H:%M") +
" 标题：" + prog_scheduled["title"])
else:
TxtResult.append("今天没有！下一场：" +
prog_rts.strftime("%m-%d %H:%M") +
" 标题：" + prog_scheduled["title"])
else:
if prog_today_passed:
TxtResult.append("今天播过了！标题：" +
prog_today_passed["title"])
TxtResult.append("之后的日历全是空的！")
else:
TxtResult.append("今天没有！之后的日历也全是空的！")
return "\n".join(TxtResult)
except Exception as e:
self.PrintLog("Query calendar failed: " + repr(e))
traceback.print_exc()
return "不知道咋回事，出错了"
def IsInvolved(msg):
for i in msg.get(At):
if i.target == Cfg().plugin_notifybot_qq_number:
return True
return False
async def ProcessRevoke(group, msg):
Ret = False
if IsInvolved(msg):
msgtxt = msg.asDisplay()
if "撤回" in msgtxt:
if self.LastSentMsgId[group.id] != 0:
await app.revokeMessage(self.LastSentMsgId[group.id])
self.LastSentMsgId[group.id] = 0
Ret = True
return Ret
async def SendGroupMsg(group, msg):
BotMsg = await app.sendGroupMessage(group,
MessageChain.create(msg))
self.LastSentMsgId[group] = BotMsg.messageId
async def ProcessAnyLiveMsg(group, msg):
Ret = False
msgtxt = msg.asDisplay()
Matched = False
for Keyword in Cfg().plugin_notifybot_recognise_selfname:
if Keyword in msgtxt:
if "播吗" in msgtxt:
Matched = True
break
if "播嘛" in msgtxt:
Matched = True
break
for Keyword in Cfg().plugin_notifybot_anylive_keyword:
if Keyword in msgtxt:
Matched = True
break
if Matched == True:
if (datetime.datetime.now() -
self.LastAnyLiveReportTime[group.id]).seconds > 60:
await SendGroupMsg(group.id, [Plain(GetCalendarMessage())])
Ret = True
self.LastAnyLiveReportTime[group.id] = datetime.datetime.now()
return Ret
async def ProcessConversations(group, member, msg):
Ret = False
SenderID = member.id
if Cfg().plugin_notifybot_conversation_blacklist.__contains__(
SenderID):
if random.random() >= Cfg(
).plugin_notifybot_conversation_blacklist[SenderID]:
return Ret
msgtxt = msg.asDisplay()
for Conv in Cfg().plugin_notifybot_conversations:
IsKeywordFound = False
for Keyword in Conv[0]:
if Keyword in msgtxt:
IsKeywordFound = True
break
if IsKeywordFound == True:
if len(Conv[1]) != 0:
while True:
RandItem = Conv[1][random.randint(
0,
len(Conv[1]) - 1)]
if random.random() <= RandItem[0]:
if RandItem[1] != "":
NewOvertalkCounter = self.OvertalkCounter[
group.id] - (datetime.datetime.now(
) - self.LastTalkTime[group.id]
).seconds / 60
if NewOvertalkCounter < 0:
NewOvertalkCounter = 0
NewOvertalkCounter += 1
self.LastTalkTime[
group.id] = datetime.datetime.now()
if NewOvertalkCounter > Cfg(
).plugin_notifybot_overtalk_threshold:
if self.OvertalkCounter[group.id] <= Cfg(
).plugin_notifybot_overtalk_threshold:
await SendGroupMsg(
group.id, [
Plain(
emoji.
emojize(Cfg(
).plugin_notifybot_overtalk_word,
use_aliases=True
))
])
else:
await SendGroupMsg(
group.id, [
Plain(
emoji.emojize(
RandItem[1],
use_aliases=True))
])
self.OvertalkCounter[
group.id] = NewOvertalkCounter
Ret = True
break
break
return Ret
async def ProcessRepeat(group, msg):
Ret = False
msgtxt = msg.include(Plain, Face, Image).asSerializationString()
if msgtxt == self.LastRepeatMsg[group.id]:
Matched = False
for Keyword in Cfg().plugin_notifybot_repeat_keyword:
if Keyword in msgtxt:
if random.random() < Cfg(
).plugin_notifybot_repeat_keyword_prob:
Matched = True
break
if random.random() < Cfg().plugin_notifybot_repeat_prob:
Matched = True
for Keyword in Cfg().plugin_notifybot_repeat_blacklist:
if Keyword in msgtxt:
Matched = False
break
if Matched == True:
NewMsg = msg.include(Face, Plain, Image).__root__
if len(NewMsg):
await SendGroupMsg(group.id, NewMsg)
Ret = True
self.LastRepeatMsg[group.id] = msgtxt
return Ret
@bcc.receiver("GroupMessage")
async def event_gm(app: GraiaMiraiApplication, group: Group,
member: Member, msg: MessageChain):
try:
if Cfg().plugin_notifybot_group_number.__contains__(group.id):
MsgSent = False
if MsgSent == False:
MsgSent = await ProcessRevoke(group, msg)
if MsgSent == False:
MsgSent = await ProcessAnyLiveMsg(group, msg)
if MsgSent == False:
MsgSent = await ProcessConversations(
group, member, msg)
if MsgSent == False:
MsgSent = await ProcessRepeat(group, msg)
except Exception as e:
self.PrintLog("Exception in gm processing: " + repr(e))
traceback.print_exc()
@bcc.receiver("TempMessage")
async def event_tm(app: GraiaMiraiApplication, group: Group,
member: Member, msg: MessageChain):
await app.sendTempMessage(
group, member, MessageChain.create([Plain(text="机器人没有私聊功能")]))
async def SendLiveOnMessageAsync():
for Grp in Cfg().plugin_notifybot_group_number:
if Cfg().plugin_notifybot_atall:
Message = [
Plain(text=GetSelfName() + "开播了！ " +
self.RecorderInstance.GetRoomTitle() +
"https://live.bilibili.com/" +
self.RecorderInstance.room_id),
AtAll()
]
else:
Message = [
Plain(text=GetSelfName() + "开播了！ " +
self.RecorderInstance.GetRoomTitle() +
"https://live.bilibili.com/" +
self.RecorderInstance.room_id),
]
try:
await SendGroupMsg(Grp, Message)
except Exception as e:
self.PrintLog("Send QQ live notify message failed: " +
repr(e))
traceback.print_exc()
def SendLiveOnMessage():
try:
fut = asyncio.run_coroutine_threadsafe(
SendLiveOnMessageAsync(), loop)
except Exception as e:
self.PrintLog("Send QQ live notify message failed: " + repr(e))
traceback.print_exc()
def ProcessLiveStartEvent(FileNameGen):
t = threading.Thread(target=SendLiveOnMessage)
t.daemon = True
t.start()
async def SendDiskWarningMessageAsync():
for MgrQQ in Cfg().plugin_notifybot_manager_qq_number:
try:
await app.sendFriendMessage(
MgrQQ, MessageChain.create([Plain(text="磁盘空间紧张！")]))
await asyncio.sleep(2)
except Exception as e:
self.PrintLog("Send disk warning message failed: " +
repr(e))
traceback.print_exc()
def DiskWarning():
try:
fut = asyncio.run_coroutine_threadsafe(
SendDiskWarningMessageAsync(), loop)
except Exception as e:
self.PrintLog("Send disk warning message failed: " + repr(e))
traceback.print_exc()
self.app = app
self.RecorderInstance.RegisterCallback("RecorderInstance",
"OnLiveStart",
ProcessLiveStartEvent)
self.RecorderInstance.RegisterCallback("DiskSpaceMonitor", "OnWarning",
DiskWarning)
self.LastAnyLiveReportTime = {}
self.LastTalkTime = {}
self.OvertalkCounter = {}
self.LastSentMsgId = {}
self.LastRepeatMsg = {}
for GrpNum in Cfg().plugin_notifybot_group_number:
self.LastAnyLiveReportTime[
GrpNum] = datetime.datetime.fromtimestamp(0)
self.LastTalkTime[GrpNum] = datetime.datetime.now()
self.OvertalkCounter[GrpNum] = 0
self.LastSentMsgId[GrpNum] = 0
self.LastRepeatMsg[GrpNum] = ""
app.launch_blocking()
def AddInitDatabaseListener(bcc: Broadcast):
bcc.receiver(ApplicationLaunched)(InitGroupDataBase)
import asyncio
from graia.application import GraiaMiraiApplication as GraiaApp, Session
from graia.broadcast import Broadcast
from graia.application.entry import Friend, FriendMessage, MessageChain, Group, GroupMessage, Plain
from graia.application.entry import ApplicationLaunched, MemberMuteEvent, At, MemberUnmuteEvent, Member
import yaml
import aiohttp
# 包含mirai-api-http的配置文件中的对应部分以及qq号
with open('setting.yml') as f:
setting = yaml.load(f, yaml.BaseLoader)
loop = asyncio.get_event_loop()
bcc = Broadcast(loop=loop)
app = GraiaApp(broadcast=bcc,
connect_info=Session(
host=f"http://{setting['host']}:{setting['port']}",
authKey=f"{setting['authKey']}",
account=setting['qq'],
websocket=setting['enableWebsocket']))
# 复读
# @bcc.receiver(FriendMessage)
async def echoer(app: GraiaApp, message: MessageChain, friend: Friend):
if message.asDisplay().startswith("复读"):
await app.sendFriendMessage(friend, message.asSendable())
echoer = bcc.receiver(FriendMessage)(echoer) # 如果不用修饰器
import asyncio
from os.path import abspath
from graia.application import GraiaMiraiApplication, Session
from graia.broadcast import Broadcast
from config import config
loop = asyncio.get_event_loop()
config_filename = 'config.cfg'
config_path = abspath('./config/' + config_filename)
def c(q):
return config(config_path, q)
bcc = Broadcast(loop=loop, debug_flag=c('debug_flag'))
app = GraiaMiraiApplication(
broadcast=bcc,
enable_chat_log=c('enable_chat_log'),
connect_info=Session(
host=c('host'), # 填入 httpapi 服务运行的地址
authKey=c('authkey'), # 填入 authKey
account=c('account'), # 你的机器人的 qq 号
websocket=c('websocket') # Graia 已经可以根据所配置的消息接收的方式来保证消息接收部分的正常运作.
))
