async def get_blog_info(ctx):
search_channel = session.query(BlogsChannel).filter(
BlogsChannel.channel_id == ctx.channel.id).first()
if search_channel:
search_user = session.query(BlogsUser).filter(
and_(BlogsUser.channel_id == search_channel.channel_id,
BlogsUser.user_id == ctx.author.id)).first()
else:
search_user = None
return search_channel, search_user
async def on_message(self, ctx):
if ctx.author.bot:
return
if ctx.content != f'{bot_prefix}blog user profile': # blog statusコマンドが投稿にカウントされないように
search_channel = session.query(BlogsChannel).filter(
BlogsChannel.channel_id == ctx.channel.id).first()
if search_channel:
search_user = session.query(BlogsUser).filter(
and_(BlogsUser.channel_id == search_channel.channel_id,
BlogsUser.user_id == ctx.author.id)).first()
if search_user:
await BlogLevelSystem(ctx, search_channel,
search_user).check()
async def _remove(self, ctx, note_id: typing.Optional[int] = None):
notes = session.query(NotesDetail).filter(
and_(NotesDetail.user_id == f'{ctx.author.id}',
NotesDetail.id == f'{note_id}')).first()
if notes is None:
await ctx.send('存在しないidです')
return
if notes.user_id == ctx.author.id:
await db_manager.commit(session.query(NotesDetail).filter(
and_(NotesDetail.user_id == f'{ctx.author.id}',
NotesDetail.id == f'{note_id}')).delete(),
commit_type='delete')
async def remove(self, ctx, user: discord.User):
search_blocklist_user = session.query(BlocklistUser).filter(
and_(BlocklistUser.server_id == f'{ctx.guild.id}',
BlocklistUser.user_id == f'{user.id}')).first()
if search_blocklist_user:
embed = discord.Embed(
title=f"{user.name} をブロックリストから解除しますか？",
description="最後にもう一度、本当に解除しても問題ないですか？\n問題が無いようなら✅を押してください。",
color=0xffc629)
msg = await ctx.send(embed=embed)
await msg.add_reaction('✅')
await msg.add_reaction('✖')
await db_manager.commit(
Reactions(guild_id=msg.guild.id,
channel_id=msg.channel.id,
message_id=msg.id,
type='unregister',
action='BlockList',
content={"target_user_id": f"{user.id}"},
module_path='cogs.blocklist',
class_name='BlockList'))
else:
await embed_send(ctx, self.bot, 1, 'エラー', '登録されていないユーザーです')
async def reaction(self):
target_user_id = int(self.reactions.content['target_user_id'])
user = self.bot.get_user(int(target_user_id))
if self.emoji == '✅':
action = 'continue'
elif self.emoji == '✖':
action = 'cancel'
# TODO: 2021/3/15 elseで他のリアクションだったときの動作を作る
embed_title = str(
language['BlocklistReactions'][f'{self.reactions.type}']
[f'{action}']['title']).format(user.name)
embed_subtitle = language['BlocklistReactions'][
f'{self.reactions.type}'][f'{action}']['subtitle']
embed_color = language['BlocklistReactions'][f'{self.reactions.type}'][
f'{action}']['embed_color']
msg_channel = self.bot.get_channel(self.reactions.channel_id)
msg = await msg_channel.fetch_message(self.reactions.message_id)
embed = discord.Embed(title=embed_title,
description=embed_subtitle,
color=int(embed_color))
if self.reactions.type == 'register' and action != 'cancel':
target_user_mode = str(self.reactions.content['mode'])
await db_manager.commit(
BlocklistUser(server_id=self.reactions.guild_id,
user_id=target_user_id,
mode=target_user_mode))
elif self.reactions.type == 'unregister' and action != 'cancel':
await db_manager.commit(session.query(BlocklistUser).filter(
and_(BlocklistUser.server_id == self.reactions.guild_id,
BlocklistUser.user_id == target_user_id)).delete(),
commit_type='delete')
await msg.edit(embed=embed)
async def fissure_check():
for fissure in session.query(WarframeFissuresDetail).order_by(
WarframeFissuresDetail.tier):
if message.detail_id == fissure.id:
return True, fissure
else:
message_search_result = False
return message_search_result, fissure
async def add(self,
ctx,
user: discord.User = None,
mode: check_mode = None):
search_blocklist_server_settings = session.query(
BlocklistSettings).filter(
BlocklistSettings.server_id == f'{ctx.guild.id}').first()
if mode is not None:
if search_blocklist_server_settings: # サーバーIDが既に登録されてるか確認
search_blocklist_user = session.query(BlocklistUser).filter(
and_(BlocklistUser.server_id == f'{ctx.guild.id}',
BlocklistUser.user_id == f'{user.id}')).first()
if search_blocklist_user is None:
embed = discord.Embed(
title=f"{user.name} をブロックリストに登録しますか？",
description=
"怒りに我を忘れていないかもう一度冷静になって確認してみましょう\n問題が無いようなら✅を押してください。",
color=0xffc629)
msg = await ctx.send(embed=embed)
await msg.add_reaction('✅')
await msg.add_reaction('✖')
await db_manager.commit(
Reactions(guild_id=msg.guild.id,
channel_id=msg.channel.id,
message_id=msg.id,
type='register',
action='BlockList',
content={
"target_user_id": f"{user.id}",
"mode": f"{mode}"
},
module_path='cogs.blocklist',
class_name='BlockList'))
else:
await embed_send(ctx, self.bot, 1, 'エラー',
'既に登録されているユーザーです')
else:
await embed_send(
ctx, self.bot, 1, 'エラー',
f'サーバーが登録されていません。\n`{bot_prefix}blocklist register mode role`\nを実行した後に再度実行してください。'
)
else:
await embed_send(ctx, self.bot, 1, 'エラー', f'{mode}は存在しないモードです')
async def bot_eew_loop():
from ssm.cogs.eew import EewSendChannel
url = "https://dev.narikakun.net/webapi/earthquake/post_data.json"
result = requests.get(url).json()
logger.debug(result)
event_id = result['Head']['EventID']
search_event_id = session.query(Eew).filter(
Eew.event_id == event_id).first()
if search_event_id is None:
await db_manager.commit(Eew(event_id=event_id))
eew_manager = EewSendChannel(bot)
image_url = await eew_manager.get_nhk_image(
result['Body']['Earthquake']['OriginTime'])
search_eew_channel_list = session.query(EewChannel)
for channel in search_eew_channel_list:
logger.debug(f'{channel.channel_id}にEew情報を送信します')
asyncio.ensure_future(
eew_manager.main_title_send(channel, result, image_url))
async def list(self, ctx):
search_blocklist_users = session.query(BlocklistUser).filter(
BlocklistUser.server_id == f'{ctx.guild.id}').all()
guild = self.bot.get_guild(ctx.guild.id)
embed = discord.Embed(title=f'{guild.name}のブロックリスト', color=0x859fff)
for _user in search_blocklist_users:
if len(embed) < 1800:
user = self.bot.get_user(_user.user_id)
embed.add_field(name=f"ユーザー名: {user.name}",
value=f"理由: 無し",
inline=True)
await ctx.send(embed=embed)
async def register(self,
ctx,
mode='AutoKick',
add_role: discord.Role = None,
remove_role: discord.Role = None):
if ctx.author.guild_permissions.administrator:
search_blocklist_server = session.query(BlocklistServer).filter(
BlocklistServer.server_id == f'{ctx.guild.id}').first()
if not search_blocklist_server: # サーバーIDが既に登録されてるか確認
await db_manager.commit(
BlocklistServer(server_id=f'{ctx.guild.id}'))
search_blocklist_server_settings = session.query(
BlocklistSettings).filter(
BlocklistSettings.server_id == f'{ctx.guild.id}').first()
if not search_blocklist_server_settings: # 既に設定が存在するか確認
processing_mode_list = [
'AutoKick', 'AutoBan', 'AddRole', 'RemoveRole'
]
for check_mode in processing_mode_list:
if f'{mode}' == f'{check_mode}': # 存在するmodeか確認
logger.debug('モードの確認に成功しました')
if f'{mode}' == 'NoneRole' or f'{mode}' == 'AddRole' or f'{mode}' == 'RemoveRole':
add_role = add_role.id
remove_role = remove_role.id
else:
add_role = None
remove_role = None
await db_manager.commit(
BlocklistSettings(server_id=ctx.guild.id,
mode=mode,
add_role=add_role,
remove_role=remove_role))
await embed_send(ctx, self.bot, 0, '成功', '設定を保存しました!')
break
else:
await embed_send(ctx, self.bot, 1, 'エラー', '存在しないモードです')
else:
await embed_send(ctx, self.bot, 1, 'エラー', '既に設定が存在します')
async def api_request():
check_requests = session.query(ApiRequests).all()
for request in check_requests:
print(request.request_content)
if request.type == 'server_info':
if request.request_content is None:
content = {
"result": {
"type": "failed",
"text": "invalid server id"
}
}
else:
guild = bot.get_guild(request.request_content['server_id'])
if guild is None:
content = {
"result": {
"type": "failed",
"text": "invalid server id"
}
}
else:
content = {
"result": {
"type": "successful"
},
"body": {
"icon_url": f"{guild.icon_url}",
"name": f"{guild.name}"
}
}
await db_manager.commit(
ApiDetail(request_id=request.request_id, content=content))
await db_manager.commit(session.query(ApiRequests).filter(
ApiRequests.request_id == request.request_id).delete(),
commit_type='delete')
if request.request_content is not None:
print(request.request_content['server_id'])
async def setup(self, ctx):
search_category = session.query(BlogsCategory).filter(
BlogsCategory.category_id == ctx.channel.category_id).first()
search_channel = session.query(BlogsChannel).filter(
BlogsChannel.channel_id == ctx.channel.id).first()
if search_category:
if search_channel:
owner = self.bot.get_user(search_channel.owner_id)
embed = await EmbedManager().generate(
embed_title='登録に失敗',
embed_description=
f'`{ctx.channel.category.name}`は既に{owner.name}さんが既にブログとして登録しているチャンネルです。他のチャンネルをお使いになるか解除をお願いしてください。',
embed_content=[],
mode='failed')
await EmbedManager().send(ctx, embed, True, 5)
return
await db_manager.commit(
BlogsChannel(category_id=ctx.channel.category.id,
channel_id=ctx.channel.id,
owner_id=ctx.author.id))
await db_manager.commit(
BlogsUser(user_id=ctx.author.id, channel_id=ctx.channel.id))
embed = await EmbedManager().generate(
embed_title='登録に成功',
embed_description=
f'`{ctx.channel.name}`をブログとして登録しました。ようこそ{ctx.author.name}さん！',
embed_content=[],
mode='succesed')
else:
embed = await EmbedManager().generate(
embed_title='登録に失敗',
embed_description=
f'`{ctx.channel.category.name}`はブログカテゴリとして登録されていません。\nブログを登録するには`{bot_prefix}blog register category`を設定したいカテゴリ内のチャンネルで実行してください。※管理者権限が必要です',
embed_content=[],
mode='failed')
await ctx.send(embed=embed)
async def server_info(server_id: int, waiting_id: int = None) -> dict:
"""与えられたサーバーIDからサーバーの基本情報を返します"""
if waiting_id:
check_completed = session.query(ApiDetail).filter(
ApiDetail.request_id == waiting_id).first()
if check_completed is not None and check_completed.content['result'][
'type'] == 'successful':
return check_completed.content
request_id = random.randrange(10**10, 10**11)
content = {'server_id': server_id}
await db_manager.commit(ApiRequests(request_id=request_id,
type='server_info',
request_content=content),
autoincrement=True)
return {"result": {"type": "waiting", "id": f"{request_id}"}}
async def on_reaction_add(self, reaction, user):
if user == self.bot.user:
return
emoji = reaction.emoji
reaction_message_id = reaction.message.id # リアクションが付いたメッセージID
reaction_channel_id = reaction.message.channel.id # リアクションが付いたメッセージのあるチャンネルID
reaction_guild_id = reaction.message.guild.id # リアクションが付いたメッセージのあるギルド
logger.debug(f'リアクションがついたメッセージID: {reaction_message_id}')
logger.debug(f'リアクションがついたメッセージのあるチャンネル: {reaction_channel_id}')
logger.debug(f'リアクションが付いたメッセージのあるギルド: {reaction_guild_id}')
reactions = session.query(Reactions).filter(Reactions.message_id == reaction_message_id).first()
print(reactions)
if reactions:
exec(f'from {reactions.module_path} import {reactions.class_name}')
cls = eval(reactions.action)(reactions, self.bot, emoji)
await getattr(cls, 'reaction')()
async def _add(self, ctx, note, use_category=None, category_name=None):
if re.findall('<@(.*?)>', f'{note}') or re.findall(
'<@(.*?)>', f'{category_name}'):
await ctx.send('メンションは使用することができません')
return
logger.debug(note)
variable = await check_variable(note, 'addを使用するにはnoteをつける必要性があります',
ctx)
if variable == 0:
await db_manager.commit(NotesUser(user_id=ctx.author.id))
if use_category is not None and use_category == '-c' and category_name is not None:
logger.debug(f'カテゴリ「{category_name}」が指定されました')
else:
category_name = 'デフォルト'
search_category_name = session.query(NotesCategory).filter(
NotesCategory.category_name == f'{category_name}').all()
if len(search_category_name) == 0:
logger.debug(f'カテゴリ「{category_name}」が存在しないため作成します')
await db_manager.commit(
NotesCategory(category_name=f'{category_name}'))
add_note_result = await db_manager.commit(
NotesDetail(user_id=f'{ctx.author.id}',
content=f'{note}',
category_name=f'{category_name}'), True)
if add_note_result != 'IntegrityError':
embed = discord.Embed(title="ノートの登録に成功しました",
description="このメッセージは10秒後に自動で削除されます",
color=0xff7e70)
embed.add_field(name="id",
value=f"{add_note_result}",
inline=True)
embed.add_field(name="ノート内容", value=f"{note}", inline=True)
await ctx.send(embed=embed)
else:
await ctx.send('重複した内容のnoteは追加できません')
async def loop_bot_task():
from ssm.cogs.warframe import get_warframe_fissures_api, fissure_tier_conversion, warframe_fissures_embed, mission_eta_conversion
async def fissure_check():
for fissure in session.query(WarframeFissuresDetail).order_by(
WarframeFissuresDetail.tier):
if message.detail_id == fissure.id:
return True, fissure
else:
message_search_result = False
return message_search_result, fissure
# APIから情報を取得
fissure_list = get_warframe_fissures_api()
if fissure_list is None: # Json形式ではなかった場合用
return
for warframe_fissure_id in session.query(WarframeFissuresId).all():
for fissures in fissure_list:
search_warframe_fissure_detail = session.query(
WarframeFissuresDetail).filter(
WarframeFissuresDetail.api_id ==
f'{warframe_fissure_id.api_id}').first()
if warframe_fissure_id.api_id != fissures[5]:
await db_manager.commit(setattr(search_warframe_fissure_detail,
'status', 'True'),
commit_type='update',
show_commit_log=False)
else:
await db_manager.commit(setattr(search_warframe_fissure_detail,
'status', 'False'),
commit_type='update',
show_commit_log=False)
break
# API側で期限切れになっている亀裂がないかを確認
for i in fissure_list:
if i[6] is not True:
check_warframe_fissure_detail = session.query(
WarframeFissuresDetail).filter(
WarframeFissuresDetail.api_id == f'{i[5]}').first()
if not check_warframe_fissure_detail or check_warframe_fissure_detail.api_id != f'{i[5]}':
await db_manager.commit(WarframeFissuresId(api_id=f'{i[5]}'),
show_commit_log=False)
star_name = str(re.findall("(?<=\().+?(?=\))", i[0])).replace(
'{',
'').replace('}',
'').replace('[',
'').replace(']',
'').replace('\'', '')
await db_manager.commit(WarframeFissuresDetail(
api_id=f'{i[5]}',
node=f'{i[0]}',
enemy=f'{i[2]}',
type=f'{i[1]}',
tier=f'{i[3]}',
tier_original=f'{fissure_tier_conversion(i[3])}',
star_name=star_name,
eta=f'{i[4]}',
status=f'{i[6]}'),
show_commit_log=False)
else:
await db_manager.commit(setattr(check_warframe_fissure_detail,
'eta', f'{i[4]}'),
commit_type='update',
show_commit_log=False)
await db_manager.commit(setattr(check_warframe_fissure_detail,
'status', f'{i[6]}'),
commit_type='update',
show_commit_log=False)
# 新しい亀裂が登録されてるチャンネルに送信されてない場合は送信
for fissure_id in session.query(WarframeFissuresDetail).order_by(
WarframeFissuresDetail.tier):
check_already_fissure_message = session.query(
WarframeFissuresMessage).filter(
WarframeFissuresMessage.detail_id == fissure_id.id).first()
if not check_already_fissure_message:
for fissure_channel in session.query(
WarframeFissuresChannel).all():
channel = bot.get_channel(int(fissure_channel.channel_id))
embed = warframe_fissures_embed(
fissure_id.node, fissure_id.type, fissure_id.enemy,
fissure_tier_conversion(fissure_id.tier),
mission_eta_conversion(fissure_id.eta))
send_embed = await channel.send(embed=embed)
await db_manager.commit(WarframeFissuresMessage(
detail_id=fissure_id.id,
message_id=send_embed.id,
channel_id=send_embed.channel.id),
show_commit_log=False)
break
for message in session.query(WarframeFissuresMessage).order_by(
WarframeFissuresMessage.id):
message_search_result, fissure = await fissure_check()
channel = bot.get_channel(int(message.channel_id))
get_message = await channel.fetch_message(int(message.message_id))
if bool(strtobool(fissure.status)) is True:
logger.debug(f'亀裂のAPI ID: {fissure.api_id} この亀裂は終了してる')
embed = warframe_fissures_embed(
fissure.node, fissure.type, fissure.enemy,
fissure_tier_conversion(fissure.tier), '終了済み')
else:
logger.debug(f'亀裂のAPI ID: {fissure.api_id} この亀裂は終了していない')
embed = warframe_fissures_embed(
fissure.node, fissure.type, fissure.enemy,
fissure_tier_conversion(fissure.tier),
mission_eta_conversion(fissure.eta))
await get_message.edit(embed=embed)
# データに登録されている亀裂が期限切れになっていないかを確認
for test in session.query(WarframeFissuresDetail).all():
if bool(strtobool(test.status)) is True:
await db_manager.commit(session.delete(
session.query(WarframeFissuresId).filter(
WarframeFissuresId.api_id == f'{test.api_id}').first()),
commit_type='delete',
show_commit_log=False)
async def on_member_join(self, member: discord.Member):
search_user = session.query(BlocklistUser).filter(and_(BlocklistUser.server_id == f'{member.guild.id}', BlocklistUser.user_id == f'{member.id}')).first()
search_guild = session.query(BlocklistSettings).filter(BlocklistSettings.server_id == member.guild.id).first()
blocklist_action = BlocklistAction(search_guild=search_guild, search_user=search_user, member=member)
await blocklist_action.check_blocklist()
async def _list(self,
ctx,
note_author: typing.Optional[discord.User] = 'me',
*,
args: check_args = None):
if note_author == 'me':
note_author = ctx.author # ユーザー指定
if args is not None:
if type(args) is not dict:
await ctx.send(f'{args[1]}')
return
else:
if '-c' in args and args.get('-c') is not None:
category_name = args.get('-c')
notes = session.query(NotesDetail).filter(
and_(NotesDetail.user_id == f'{ctx.author.id}',
NotesDetail.category_name ==
f'{category_name}')).all()
if '--type' in args and 'category' == args.get('--type'):
notes = session.query(NotesDetail).filter(
NotesDetail.user_id == f'{ctx.author.id}').all()
else:
category_name = 'デフォルト'
notes = session.query(NotesDetail).filter(
and_(NotesDetail.user_id == f'{ctx.author.id}',
NotesDetail.category_name == f'{category_name}')).all()
note_list = ''
embed = discord.Embed(color=0x859fff)
for i in notes:
custom_message = ''
for emoji in re.finditer('e!(.*?)!e', f'{i.content}'):
base_message = re.sub("\(|\)|\'", "",
f'{i.content}').replace(',', '\n')
for n in emoji.groups(): # emoji
check_emoji_type = re.sub("\\D", "", n)
if len(str(check_emoji_type)) == 18:
get_emoji = self.bot.get_emoji(int(check_emoji_type))
print(get_emoji)
else:
get_emoji = discord.utils.get(ctx.guild.emojis,
name=f'{n}'.replace(
':', ''))
if len(custom_message) == 0:
custom_message = base_message.replace(
',', '\n').replace(f'e!{n}!e', f'{get_emoji}')
else:
custom_message = custom_message.replace(
',', '\n').replace(f'e!{n}!e', f'{get_emoji}')
if 'emoji' not in locals():
custom_message = i.content + '\n'
else:
del emoji
print(custom_message)
r_custom_message = i.content
embed.add_field(name=f"ID: {i.id}",
value=f"{custom_message}",
inline=True)
if not embed:
await embed_send(ctx, self.bot, 0, 'INFO', 'ノートは空のようです', 0x859fff)
return
await ctx.send(embed=embed)
