async def feedbacklist(session: CommandSession):
if not headdeal(session):
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name':'page', #参数名
'des':'页码', #参数错误描述
'type':'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':1, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':None, #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
args = argDeal(session.current_arg_text.strip(),arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
page = args['page']
if page < 1:
await session.send("页码不能为负")
return
s = getlist(page)
await session.send(s)
async def mtransopt(session: CommandSession):
if not headdeal(session):
return
global mtransopt_list
#message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
#if perm_check(session,'-listener',user = True):
# await session.send('操作被拒绝，权限不足(p)')
# return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name': 'engine', #参数名
'des': '翻译引擎', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': engine_nick
},
{
'name': 'Source', #参数名
'des': '源语言', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': True, #是否转换为小写
'default': 'auto', #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': allow_st['Source']
},
{
'name': 'Target', #参数名
'des': '目标语言', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': True, #是否转换为小写
'default': 'zh', #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': allow_st['Target']
},
]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
user_id = str(user_id)
mtransopt_list[user_id] = args
data_save(config_filename, mtransopt_list)
await session.send("设置已保存")
async def legalPermList(session: CommandSession):
message_type = session.event['message_type']
if message_type != 'private':
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name':'groupname', #参数名
'des':'权限组名', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':None, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':None, #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
res = argDeal(session.current_arg_text.strip(),arglimit)
if not res[0]:
await session.send(res[1]+'=>'+res[2])
return
args = res[1]
permlist = perm_getGroup(args['groupname'])
if permlist == None:
await session.send("权限组不存在！")
return
s = "权限ID：" + permlist['name'] + "\n" + \
"描述：" + permlist['des'] + "\n" + \
"---权限列表---"
for g in permlist['perms']:
s = s + "\n" + g
await session.send(s)
async def permgroupList(session: CommandSession):
message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
if message_type != 'private':
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name': 'msgtype', #参数名
'des': '消息类型', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': True, #是否转换为小写
'default': message_type, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示允许任意字符串,值不为空时任意字符串将被转变为这个值
'私聊': 'private',
'private': 'private',
'群聊': 'group',
'group': 'group',
'好友': 'private',
'群': 'group',
}
},
{
'name': 'send_id', #参数名
'des': '对象ID', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': user_id, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
res = argDeal(session.current_arg_text.strip(), arglimit)
if not res[0]:
await session.send(res[1] + '=>' + res[2])
return
args = res[1]
res = perm_getPermGroupList(args['msgtype'], args['send_id'])
if not res[0]:
await session.send(res[1])
return
s = perm_GroupListToStr(res[2])
await session.send(s)
async def getpushlist(session: CommandSession):
if not headdeal(session):
return
await asyncio.sleep(0.2)
message_type = session.event['message_type']
group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
sent_id = 0
if message_type == 'private':
sent_id = user_id
elif message_type == 'group':
sent_id = group_id
else:
await session.send('未收录的消息类型:' + message_type)
return
logger.info(CQsessionToStr(session))
arglimit = [{
'name': 'page', #参数名
'des': '页码', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': 1, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
page = args['page']
if page < 1:
await session.send("页码不能为负")
return
s = get_pushTo_spylist(message_type, sent_id, page)
await session.send(s)
async def setGroupSetting(session: CommandSession):
if not headdeal(session):
return
await asyncio.sleep(0.2)
logger.info(CQsessionToStr(session))
arglimit = [{
'name': 'kind', #参数名
'des': 'kind', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': 'basic', #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
'basic': 'basic',
'基础': 'basic',
'template': 'template',
'模版': 'template',
'ai': 'ai',
'智能': 'ai',
'智能推送': 'ai',
'userinfo': 'userinfo',
'用户信息': 'userinfo',
'用户': 'userinfo',
'个人资料': 'userinfo'
}
}]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
res = getPushToSetting(
session.event['message_type'],
session.event[('group_id' if session.event['message_type'] == 'group'
else 'user_id')], args['kind'])
await session.send(res)
async def translist(session: CommandSession):
if not headdeal(session):
return
message_type = session.event['message_type']
group_id = (session.event['group_id'] if message_type == 'group' else None)
#user_id = session.event['user_id']
if message_type != 'group':
return
if perm_check(session, '-switch', user=True):
await session.send('操作被拒绝，权限不足(p)')
return
if not perm_check(session, 'trans'):
await session.send('操作未授权')
return
logger.info(CQsessionToStr(session))
arglimit = [{
'name': 'page', #参数名
'des': '页码', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': 1, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
page = args['page']
if page < 1:
await session.send("页码不能为负")
return
s = getlist(group_id, page)
await session.send(s)
async def getSetting(session: CommandSession):
if not headdeal(session):
return
await asyncio.sleep(0.2)
message_type = session.event['message_type']
group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
sent_id = 0
if message_type == 'private':
sent_id = user_id
elif message_type == 'group':
sent_id = group_id
else:
await session.send('未收录的消息类型:' + message_type)
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name': 'tweet_user_id', #参数名
'des': '推特用户ID', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name': 'kind', #参数名
'des': 'kind', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': 'basic', #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
'basic': 'basic',
'基础': 'basic',
'template': 'template',
'模版': 'template',
'ai': 'ai',
'智能': 'ai',
'智能推送': 'ai',
'userinfo': 'userinfo',
'用户信息': 'userinfo',
'用户': 'userinfo',
'个人资料': 'userinfo'
}
}
]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
res = getPushUnitSetting(message_type, sent_id, args['tweet_user_id'],
args['kind'])
logger.info(CQsessionToStr(session))
await session.send(res[1])
async def gettrans(session: CommandSession):
if not headdeal(session):
return
message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
#user_id = session.event['user_id']
if message_type != 'group':
return
if perm_check(session, '-switch', user=True):
await session.send('操作被拒绝，权限不足(p)')
return
if not perm_check(session, 'trans'):
await session.send('操作未授权')
return
logger.info(CQsessionToStr(session))
def checkTweetId(a, ad):
if a[:1] == '#':
ta = a[1:]
if not ta.isdecimal():
return None
res = mintweetID.find(lambda item, val: item[1] == val, int(ta))
if res == None:
return None
return res[0]
elif a.isdecimal() and int(a) > 1253881609540800000:
return a
else:
res = decode_b64(a)
if res == -1:
return None
return res
arglimit = [{
'name': 'tweet_id', #参数名
'des': '推特ID', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': checkTweetId, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
tweet_id = args['tweet_id']
ttm = trans_tmemory.tm.copy()
length = len(ttm)
for i in range(length - 1, -1, -1):
if ttm[i]['id'] == tweet_id:
await session.send(trans_img_path + encode_b64(ttm[i]['group'],offset=0)+'-'+str(ttm[i]['tasktype']) + '.png' +"\n" + \
str('[CQ:image,timeout=' + config.img_time_out + \
',file='+trans_img_path + encode_b64(ttm[i]['group'],offset=0)+'-'+str(ttm[i]['tasktype']) + '.png' + ']'))
return
await session.send("未查找到推文翻译")
async def trans(session: CommandSession):
if not headdeal(session):
return
message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
#user_id = session.event['user_id']
if message_type != 'group':
return
if perm_check(session, '-switch', user=True):
await session.send('操作被拒绝，权限不足(p)')
return
if not perm_check(session, 'trans'):
await session.send('操作未授权')
return
logger.info(CQsessionToStr(session))
if not rate_limit_bucket.consume(1):
await session.send("烤推繁忙，请稍后再试")
return
def checkTweetId(a, ad):
if a[:1] == '#':
ta = a[1:]
if not ta.isdecimal():
return None
res = mintweetID.find(lambda item, val: item[1] == val, int(ta))
if res == None:
return None
return res[0]
elif a.isdecimal() and int(a) > 1253881609540800000:
return a
else:
res = decode_b64(a)
if res == -1:
return None
return res
arglimit = [
{
'name': 'tweet_id', #参数名
'des': '推特ID', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': checkTweetId, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name': 'trans', #参数名
'des': '翻译内容', #参数错误描述
'type':
'dict', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': {
'type_html': '',
'source': '',
'text': {}
}, #默认值
'func': deal_trans, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
pool.submit(send_res, session, args[1])
await session.send("图片合成中...")
async def transswitch_private(session: CommandSession):
user_id = session.event['user_id']
arglimit = [
{
'name': 'msgtype', #参数名
'des': '消息类型', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': True, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示允许任意字符串,值不为空时任意字符串将被转变为这个值
#'私聊':'private',
#'private':'private',
'群聊': 'group',
'group': 'group',
#'好友':'private',
'群': 'group',
}
},
{
'name': 'send_id', #参数名
'des': '对象ID', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
res = argDeal(session.current_arg_text.strip(), arglimit)
if not res[0]:
await session.send(res[1] + '=>' + res[2])
return
args = res[1]
remote = {
'message_type': 'group',
'sent_id': args['sendid'],
'op_id': user_id
}
if perm_check(session, '-switch'):
await session.send('操作被拒绝，权限不足(p)')
return
if perm_check(session, '-switch', remote):
await session.send('操作被拒绝，权限不足(g)')
return
if perm_check(session, '*', remote):
await session.send('操作无效，存在“*”权限(g)')
return
if perm_check(session, 'trans', remote):
perm_del(session, 'trans', remote)
await session.send('烤推授权关闭')
else:
perm_add(
session,
'trans',
)
await session.send('烤推授权开启')
async def delOne(session: CommandSession):
if not headdeal(session):
return
message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
#user_id = session.event['user_id']
if perm_check(session,'-listener',user=True):
await session.send('操作被拒绝，权限不足(p)')
return
if message_type == 'group':
if not perm_check(session,'listener'):
await session.send('操作被拒绝，权限不足(g)')
return
elif message_type != 'private':
await session.send('未收录的消息类型:'+message_type)
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name':'tweet_user_id', #参数名
'des':'推特用户ID', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':None, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':'[A-Za-z0-9_]+$', #正则表达式匹配(match函数)
're_error':'用户名/用户ID 只能包含字母、数字或下划线',
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
args = argDeal(session.current_arg_text.strip(),arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
tweet_user_id = args['tweet_user_id']
app = ptwitterapps.getAllow('users_show')
if app == None:
await session.send("速率限制，请稍后再试")
return
if tweet_user_id.isdecimal():
res = tweetListener.tweet_event_deal.tryGetUserInfo(user_id=int(tweet_user_id))
if res == {}:
res = app.users_show(user_id = int(tweet_user_id))
if res[0]:
res = list(res)
res[1] = tweetListener.tweet_event_deal.get_userinfo(res[1])
else:
res = (True,res)
else:
res = tweetListener.tweet_event_deal.tryGetUserInfo(screen_name = tweet_user_id)
if res == {}:
res = app.users_show(screen_name = tweet_user_id)
if res[0]:
res = list(res)
res[1] = tweetListener.tweet_event_deal.get_userinfo(res[1])
else:
res = (True,res)
if not res[0]:
await session.send("查询不到这位V哦~复制都能弄歪来┐(ﾟ～ﾟ)┌")
userinfo = res[1]
#tweetListener.tweet_event_deal.seve_image(userinfo.screen_name,userinfo.profile_image_url_https,'userinfo')
#file_suffix = os.path.splitext(userinfo.profile_image_url_https)[1]
#'头像:' + '[CQ:image,timeout='+config.img_time_out+',file='+config.img_path+'userinfo/' + userinfo.screen_name + file_suffix + ']'+ "\n" + \
res = push_list.delPushunitFromPushToAndTweetUserID(
session.event['message_type'],
session.event[('group_id' if session.event['message_type'] == 'group' else 'user_id')],
userinfo['id']
)
s = '用户UID:'+ str(userinfo['id']) + "\n" + \
'用户ID:' + userinfo['screen_name'] + "\n" + \
'用户昵称:' + userinfo['name'] + "\n" + \
'头像:' + '[CQ:image,timeout='+config.img_time_out+',file=' + userinfo['profile_image_url_https'] + ']'+ "\n" + \
('已经从监听列表中叉出去了哦' if res[0] == True else '移除失败了Σ（ﾟдﾟlll）:'+res[1])
push_list.savePushList()
await session.send(s)
async def getuserinfo(session: CommandSession):
if not headdeal(session):
return
message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
#user_id = session.event['user_id']
if perm_check(session,'-listener',user=True):
await session.send('操作被拒绝，权限不足(p)')
return
if message_type == 'group':
if not perm_check(session,'listener'):
await session.send('操作被拒绝，权限不足(g)')
return
elif message_type != 'private':
await session.send('未收录的消息类型:'+message_type)
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name':'tweet_user_id', #参数名
'des':'推特用户ID', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':None, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':'[A-Za-z0-9_]+$', #正则表达式匹配(match函数)
're_error':'用户名/用户ID 只能包含字母、数字或下划线',
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
args = argDeal(session.current_arg_text.strip(),arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
tweet_user_id = args['tweet_user_id']
app = ptwitterapps.getAllow('users_show')
if app == None:
await session.send("速率限制，请稍后再试")
return
if tweet_user_id.isdecimal():
res = app.users_show(user_id = int(tweet_user_id))
else:
res = app.users_show(screen_name = tweet_user_id)
if not res[0]:
await session.send("查询不到这位V哦~复制都能弄歪来┐(ﾟ～ﾟ)┌")
userinfo = res[1]
#检测信息更新
tweetListener.tweet_event_deal.get_userinfo(userinfo,True)
#tweetListener.tweet_event_deal.seve_image(userinfo.screen_name,userinfo.profile_image_url_https,'userinfo',canCover=True)
#file_suffix = os.path.splitext(userinfo.profile_image_url_https)[1]
#'头像:' + '[CQ:image,timeout='+config.img_time_out+',file='+config.img_path+'userinfo/' + userinfo.screen_name + file_suffix + ']'+ "\n" + \
s = '用户UID:'+ str(userinfo.id) + "\n" + \
'用户ID:' + userinfo.screen_name + "\n" + \
'用户昵称:' + userinfo.name + "\n" + \
'头像:' + '[CQ:image,timeout='+config.img_time_out+',file=' + userinfo.profile_image_url_https + ']'+ "\n" + \
'描述:' + userinfo.description + "\n" + \
'推文受保护:' + str(userinfo.protected) + "\n" + \
'被关注数:' + str(userinfo.followers_count) + "\n" + \
'关注数:' + str(userinfo.friends_count) + "\n" + \
'发推数(包括转发)：' + str(userinfo.statuses_count) + "\n" + \
'账户创建时间：' + str(userinfo.created_at)
logger.info(CQsessionToStr(session))
await session.send(s)
async def addOne(session: CommandSession):
if not headdeal(session):
return
message_type = session.event['message_type']
group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
if perm_check(session,'-listener',user=True):
await session.send('操作被拒绝，权限不足(p)')
return
sent_id = 0
if message_type == 'private':
sent_id = user_id
elif message_type == 'group':
if not perm_check(session,'listener'):
await session.send('操作被拒绝，权限不足(g)')
return
sent_id = group_id
elif message_type != 'private':
await session.send('未收录的消息类型:'+message_type)
return
arglimit = [
{
'name':'tweet_user_id', #参数名
'des':'推特用户ID', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':None, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':'[A-Za-z0-9_]+$', #正则表达式匹配(match函数)
're_error':'用户名/用户ID 只能包含字母、数字或下划线',
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name':'nick', #参数名
'des':'昵称', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':'', #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':r'[\s\S]{0,50}', #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name':'des', #参数名
'des':'描述', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':'', #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':r'[\s\S]{0,100}', #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
args = argDeal(session.current_arg_text.strip(),arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
tweet_user_id = args['tweet_user_id']
app = ptwitterapps.getAllow('users_show')
if app == None:
await session.send("速率限制，请稍后再试")
return
if tweet_user_id.isdecimal():
res = tweetListener.tweet_event_deal.tryGetUserInfo(user_id=int(tweet_user_id))
if res == {}:
res = app.users_show(user_id = int(tweet_user_id))
if res[0]:
res = list(res)
res[1] = tweetListener.tweet_event_deal.get_userinfo(res[1])
else:
res = (True,res)
else:
res = tweetListener.tweet_event_deal.tryGetUserInfo(screen_name = tweet_user_id)
if res == {}:
res = app.users_show(screen_name = tweet_user_id)
if res[0]:
res = list(res)
res[1] = tweetListener.tweet_event_deal.get_userinfo(res[1])
else:
res = (True,res)
if not res[0]:
await session.send("查询不到这位V哦~复制都能弄歪来┐(ﾟ～ﾟ)┌")
userinfo = res[1]
nick = args['nick']
des = args['des']
if des == '':
des = userinfo['name']+'('+userinfo['screen_name']+')'
PushUnit = push_list.baleToPushUnit(
session.event['self_id'],
message_type,sent_id,
userinfo['id'],
user_id,user_id,
des,
nick = nick
)
res = push_list.addPushunit(PushUnit)
s = '用户UID:'+ str(userinfo['id']) + "\n" + \
'用户ID:' + userinfo['screen_name'] + "\n" + \
'用户昵称:' + userinfo['name'] + "\n" + \
'头像:' + '[CQ:image,timeout='+config.img_time_out+',file=' + userinfo['profile_image_url_https'] + ']'+ "\n" + \
('已经加入了DD名单了哦' if res[0] == True else '添加失败:'+res[1])
push_list.savePushList()
await session.send(s)
async def permDel(session: CommandSession):
message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
if message_type != 'private':
return
#if perm_check(session,'-listener',user = True):
# await session.send('操作被拒绝，权限不足(p)')
# return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name':'groupname', #参数名
'des':'权限组名', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':None, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':None, #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name':'perm_unit', #参数名
'des':'权限组名', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':'', #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':None, #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name':'msgtype', #参数名
'des':'消息类型', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':True, #是否转换为小写
'default':message_type, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':None, #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示允许任意字符串,值不为空时任意字符串将被转变为这个值
'私聊':'private',
'private':'private',
'群聊':'group',
'group':'group',
'好友':'private',
'群':'group',
}
},
{
'name':'send_id', #参数名
'des':'对象ID', #参数错误描述
'type':'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':user_id, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':None, #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
res = argDeal(session.current_arg_text.strip(),arglimit)
if not res[0]:
await session.send(res[1]+'=>'+res[2])
return
args = res[1]
if args['perm_unit'] == '':
args['perm_unit'] = None
if perm_check(args['msgtype'],args['send_id'],args['groupname'],args['perm_unit']):
await session.send("该权限已存在！")
return
res = perm_del(args['msgtype'],args['send_id'],user_id,args['groupname'],args['perm_unit'])
await session.send(res[1])
async def gettweetlist(session: CommandSession):
if not headdeal(session):
return
await asyncio.sleep(0.2)
message_type = session.event['message_type']
group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
if perm_check(session, '-listener', user=True):
await session.send('操作被拒绝，权限不足(p)')
return
sent_id = 0
if message_type == 'private':
sent_id = user_id
elif message_type == 'group':
if not perm_check(session, 'listener'):
await session.send('操作被拒绝，权限不足(g)')
return
sent_id = group_id
else:
await session.send('未收录的消息类型:' + message_type)
return
logger.info(CQsessionToStr(session))
#ID为空或者#号时尝试使用默认ID
def tryget(a, ad):
tweet_user_id = a
if tweet_user_id == '' or tweet_user_id == '#':
l = push_list.getLitsFromPushTo(message_type, sent_id)
if l == []:
return (False, '监听列表无成员，无法置入默认值')
tweet_user_id = str(l[0]['tweet_user_id'])
if tweet_user_id.isdecimal():
res = tweetListener.tweet_event_deal.tryGetUserInfo(
user_id=int(tweet_user_id))
if res == {}:
res = (False, '缓存中不存在此用户！')
else:
res = (True, res)
else:
res = tweetListener.tweet_event_deal.tryGetUserInfo(
screen_name=tweet_user_id)
if res == {}:
res = (False, '缓存中不存在此用户！')
else:
res = (True, res)
return res
arglimit = [
{
'name': 'userinfo', #参数名
'des': '推特用户ID', #参数错误描述
'type':
'dict', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': tryget, #函数，当存在时使用函数进行二次处理
'funcdealnull': True, #函数是否处理空值(控制默认值)
're': None, #正则表达式匹配(match函数)
're_error': '',
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name': 'page', #参数名
'des': '页码', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': 1, #默认值(不会进行二次类型转换)
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
userinfo = args['userinfo']
page = args['page']
if page <= 0:
await session.send("页码不正确！")
return
res = tweetListener.tweet_event_deal.getUserTSInCache(userinfo['id'])
if res == None:
await session.send("推文缓存中不存在此用户数据！")
return
tweets = res.tm
ttr = {
'none': '发推',
'retweet': '转推',
'quoted': '转评',
'reply_to_status': '回复',
'reply_to_user': '******'
}
msg = userinfo['name'] + "(" + userinfo['screen_name'] + ")的推文列表" + "\n"
msg = msg + "推文缩写ID,标识,推文简写内容" + "\n"
unit_cout = 0
for i in range(len(tweets) - 1, -1, -1):
if unit_cout >= (page - 1) * 5 and unit_cout < (page) * 5:
msg = msg + ("被" if tweets[i]['trigger_remote'] else "") + ttr[
tweets[i]['type']] + ',' + encode_b64(
tweets[i]['id']) + ',' + tweets[i]['text'][:20].replace(
"\n", " ") + "\n"
unit_cout = unit_cout + 1
totalpage = unit_cout // 5 + (0 if (unit_cout % 5 == 0) else 1)
if unit_cout > 5 or page != 1:
msg = msg + '页数：' + str(page) + '/' + str(totalpage) + ' '
msg = msg + '总推文缓存数：' + str(unit_cout)
await session.send(msg)
async def gettweettext(session: CommandSession):
if not headdeal(session):
return
message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
#user_id = session.event['user_id']
if perm_check(session, '-listener', user=True):
await session.send('操作被拒绝，权限不足(p)')
return
if message_type == 'group' and not perm_check(session, 'listener'):
await session.send('操作被拒绝，权限不足(g)')
return
logger.info(CQsessionToStr(session))
def checkTweetId(a, ad):
if a[:1] == '#':
ta = a[1:]
if not ta.isdecimal():
return None
res = mintweetID.find(lambda item, val: item[1] == val, int(ta))
if res == None:
return None
return res[0]
elif a.isdecimal() and int(a) > 1253881609540800000:
return a
else:
res = decode_b64(a)
if res == -1:
return None
return res
arglimit = [{
'name': 'tweet_id', #参数名
'des': '推特ID', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': checkTweetId, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
tweet_id = args['tweet_id']
tweet = tweet_event_deal.tryGetTweet(tweet_id)
if tweet == None:
if ptwitter.ptwitterapps.hasApp():
app = ptwitter.ptwitterapps.getAllow('statuses_lookup')
if app == None:
await session.send("速率限制，请稍后再试！")
return
res = app.statuses_lookup(id=tweet_id)
if not res[0] or res[1] == []:
await session.send("未查找到该推文！")
return
tweet = ptwitter.tweet_event_deal.deal_tweet(res[1][0])
else:
await session.send("未从缓存中查找到该推文！")
return
msg = "推文 " + encode_b64(tweet_id) + " 的内容如下：\n"
msg = msg + tweet_event_deal.tweetToStr(tweet, '', 1, '')
await session.send(msg)
async def dealfeedback(session: CommandSession):
if not headdeal(session):
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name':'feedid', #参数名
'des':'反馈ID', #参数错误描述
'type':'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':None, #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':None, #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name':'text', #参数名
'des':'反馈内容', #参数错误描述
'type':'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip':True, #是否strip
'lower':False, #是否转换为小写
'default':'', #默认值
'func':None, #函数，当存在时使用函数进行二次处理
're':None, #正则表达式匹配(match函数)
'vlimit':{
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
args = argDeal(session.current_arg.strip(),arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
feedbackunit = feedbacktmemory.find((lambda item,val: item['id'] == val),args['feedid'])
if feedbackunit == None:
await session.send("未搜索到ID:" + str(args['feedid']) + " 的反馈记录")
return
if args['text'] == '':
msg = "---历史反馈---\n" + "已处理：" + ("是" if feedbackunit['deal'] else "否") + "\n"
msg = msg + "反馈ID:" + str(feedbackunit['id']) + "\n"
if feedbackunit['message_type'] == 'group':
msg = msg + '来自群聊 ' + feedbackunit['group_id'] + "\n"
else:
msg = msg + '来自私聊' + "\n"
msg = msg + feedbackunit['nick'] + "(" + feedbackunit['user_id'] + ")" + "\n"
msg = msg + "反馈了：" + feedbackunit['text']
await session.send(msg)
return
else:
msg = "ID " + str(feedbackunit['id']) + " 的反馈回复：" + "\n"
msg = msg + args['text'].replace('[','[').replace(']',']')
try:
if feedbackunit['message_type'] == 'group':
await session.bot.send_msg_rate_limited(
self_id=feedbackunit['self_id'],
message_type=feedbackunit['message_type'],
group_id=int(feedbackunit['group_id']),
message=msg
)
else:
await session.bot.send_msg_rate_limited(
self_id=feedbackunit['self_id'],
message_type=feedbackunit['message_type'],
user_id=int(feedbackunit['user_id']),
message=msg
)
except:
await session.send("回复发送失败")
return
if not feedbackunit['deal']:
feedbackunit['deal'] = True
feedbacktmemory.save()
await session.send("回复已发送")
async def setAttr(session: CommandSession):
if not headdeal(session):
return
await asyncio.sleep(0.2)
message_type = session.event['message_type']
group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
if perm_check(session, '-listener', user=True):
await session.send('操作被拒绝，权限不足(p)')
return
sent_id = 0
if message_type == 'private':
sent_id = user_id
elif message_type == 'group':
if not perm_check(session, 'listener'):
await session.send('操作被拒绝，权限不足(g)')
return
sent_id = group_id
else:
await session.send('未收录的消息类型:' + message_type)
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name': 'tweet_user_id', #参数名
'des': '推特用户ID', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name': 'key', #参数名
'des': '设置名称', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
#携带图片发送
'upimg': 'upimg',
'图片': 'upimg',
'img': 'upimg',
#描述设置
'des': 'des',
'描述': 'des',
#昵称设置
'nick': 'nick',
'昵称': 'nick',
#消息模版
'retweet_template': 'retweet_template',
'转推模版': 'retweet_template',
'quoted_template': 'quoted_template',
'转推并评论模版': 'quoted_template',
'reply_to_status_template': 'reply_to_status_template',
'回复模版': 'reply_to_status_template',
'reply_to_user_template': 'reply_to_user_template',
'被提及模版': 'reply_to_user_template',
'none_template': 'none_template',
'发推模版': 'none_template',
#推特转发各类型开关
'retweet': 'retweet',
'转推': 'retweet',
'quoted': 'quoted',
'转推并评论': 'quoted',
'reply_to_status': 'reply_to_status',
'回复': 'reply_to_status',
'reply_to_user': '******',
'提及': 'reply_to_user',
'none': 'none',
'发推': 'none',
#智能推送开关
'ai_retweet': 'ai_retweet',
'智能转推': 'ai_retweet',
'ai_reply_to_status': 'ai_reply_to_status',
'智能转发回复': 'ai_reply_to_status',
'ai_passive_reply_to_status': 'ai_passive_reply_to_status',
'智能转发被回复': 'ai_passive_reply_to_status',
'ai_passive_quoted': 'ai_passive_quoted',
'智能转发被转推并评论': 'ai_passive_quoted',
'ai_passive_reply_to_user': '******',
'智能转发被提及': 'ai_passive_reply_to_user',
#推特个人信息变动推送开关
'change_id': 'change_ID',
'ID改变': 'change_ID',
'ID修改': 'change_ID',
'change_name': 'change_name',
'名称改变': 'change_name',
'名称修改': 'change_name',
'名字改变': 'change_name',
'名字修改': 'change_name',
'昵称修改': 'change_name',
'昵称改变': 'change_name',
'昵称修改': 'change_name',
'change_description': 'change_description',
'描述改变': 'change_description',
'描述修改': 'change_description',
'change_headimgchange': 'change_headimgchange',
'头像改变': 'change_headimgchange',
'头像修改': 'change_headimgchange'
}
},
{
'name': 'value', #参数名
'des': '设置值', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': '', #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
'true': '1',
'开': '1',
'打开': '1',
'开启': '1',
'false': '0',
'关': '0',
'关闭': '0',
'*': ''
}
}
]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
template_attr = ('retweet_template', 'quoted_template',
'reply_to_status_template', 'reply_to_user_template',
'none_template')
tweet_user_id = args['tweet_user_id']
attr = args['key']
attrv = args['value']
if str(tweet_user_id) not in push_list.spylist:
await session.send("用户不在监测列表内！")
return
if attr == 'des' or attr == 'nick' or attr in template_attr:
res = push_list.setPushunitAttr(message_type, sent_id, tweet_user_id,
attr, attrv)
elif attrv in ('0', '1'):
res = push_list.setPushunitAttr(message_type, sent_id, tweet_user_id,
attr, int(attrv))
else:
res = (False, '属性的值不合法！')
return
push_list.savePushList()
await session.send(res[1])
async def addOne(session: CommandSession):
if not headdeal(session):
return
message_type = session.event['message_type']
group_id = (session.event['group_id'] if message_type == 'group' else None)
user_id = session.event['user_id']
if perm_check(session, '-listener', user=True):
await session.send('操作被拒绝，权限不足(p)')
return
sent_id = 0
if message_type == 'private':
sent_id = user_id
elif message_type == 'group':
if not perm_check(session, 'listener'):
await session.send('操作被拒绝，权限不足(g)')
return
sent_id = group_id
else:
await session.send('未收录的消息类型:' + message_type)
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name': 'tweet_user_id', #参数名
'des': '推特用户ID', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': '[A-Za-z0-9_]+$', #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name': 'nick', #参数名
'des': '昵称', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': '', #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': r'[\s\S]{0,50}', #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
},
{
'name': 'des', #参数名
'des': '描述', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': '', #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': r'[\s\S]{0,100}', #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
args = argDeal(session.current_arg_text.strip(), arglimit)
if not args[0]:
await session.send(args[1] + '=>' + args[2])
return
args = args[1]
tweet_user_id = args['tweet_user_id']
#获取数据
res = tweetListener.tweet_event_deal.getUserInfo(tweet_user_id)
if not res[0]:
await session.send("查询不到信息，你D都能D歪来!?(･_･;?")
return
userinfo = res[1]
nick = args['nick']
des = args['des']
if des == '':
des = userinfo['name'] + '(' + userinfo['screen_name'] + ')'
PushUnit = push_list.baleToPushUnit(session.event['self_id'],
message_type,
sent_id,
userinfo['id'],
user_id,
user_id,
des,
nick=nick)
res = push_list.addPushunit(PushUnit)
s = '标识:'+ str(userinfo['id']) + "\n" + \
'用户ID:' + userinfo['screen_name'] + "\n" + \
'用户昵称:' + userinfo['name'] + "\n" + \
'头像:' + '[CQ:image,timeout='+config.img_time_out+',file=' + userinfo['profile_image_url_https'] + ']'+ "\n" + \
('已经加入了DD名单了哦' if res[0] == True else '添加失败:'+res[1])
push_list.savePushList()
await session.send(s)
async def globalRemove(session: CommandSession):
if not headdeal(session):
return
await asyncio.sleep(0.2)
message_type = session.event['message_type']
#group_id = (session.event['group_id'] if message_type == 'group' else None)
#user_id = session.event['user_id']
if perm_check(session, '-listener', user=True):
await session.send('操作被拒绝，权限不足(p)')
return
if message_type == 'group' and not perm_check(session, 'listener'):
await session.send('操作被拒绝，权限不足(g)')
return
logger.info(CQsessionToStr(session))
arglimit = [
{
'name': 'msgtype', #参数名
'des': '消息类型', #参数错误描述
'type':
'str', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': True, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示允许任意字符串,值不为空时任意字符串将被转变为这个值
'私聊': 'private',
'private': 'private',
'群聊': 'group',
'group': 'group',
'好友': 'private',
'群': 'group',
}
},
{
'name': 'send_id', #参数名
'des': '对象ID', #参数错误描述
'type':
'int', #参数类型int float str list dict (list与dict需要使用函数或正则表达式进行二次处理)
'strip': True, #是否strip
'lower': False, #是否转换为小写
'default': None, #默认值
'func': None, #函数，当存在时使用函数进行二次处理
're': None, #正则表达式匹配(match函数)
'vlimit': {
#参数限制表(限制参数内容,空表则不限制),'*':''表示匹配任意字符串,值不为空时任意字符串将被转变为这个值
}
}
]
res = argDeal(session.current_arg_text.strip(), arglimit)
if not res[0]:
await session.send(res[1] + '=>' + res[2])
return
args = res[1]
res = push_list.delPushunitFromPushTo(args['message_type'],
args['send_id'],
self_id=int(
session.event['self_id']))
push_list.savePushList()
await session.send(res[1])
