async def show(self, ctx: commands.Context): await ctx.message.delete() guild_settings = self.welcome_message_repo.find(ctx.guild) em = discord.Embed(title="Current welcome message settings", color=discord.Color.blue()) em.add_field(name="Welcome message", value=str(guild_settings.welcome_message), inline=False) em.add_field( name="Welcome channel", value=str( discord.utils.get( ctx.guild.channels, id=int(guild_settings.welcome_message_channel_id)).name) if guild_settings.welcome_message_channel_id else "None", inline=False) em.add_field(name="Welcome messages status", value="Enabled" if guild_settings.welcome_message_enable else "Disabled", inline=False) add_author_footer(em, ctx.author) await ctx.channel.send(embed=em, delete_after=Config.base_long_success_duration)
async def flip_func(ctx: commands.Context): embed = discord.Embed(title="Coin flip", description=random.choice(["True", "False"]), color=discord.Color.gold()) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def start_work(self, ctx: commands.Context, hours: int = 1): await general_util.delete_message(self.bot, ctx) if not self.player_repo.is_idle(ctx.author.id): return await ctx.send(embed=general_util.generate_error_message( Strings.rpg_cant_perfor_action_no_idle), delete_after=Config.base_error_duration) if hours < 0 or hours > 12: return await ctx.send(embed=general_util.generate_error_message( Strings.rpg_work_invalid_work_time), delete_after=Config.base_error_duration) end_date = datetime.now(tz=timezone.utc) + timedelta(hours=hours) action = self.player_repo.create_action(ctx.author, ActionsEnum.WORK, end_date) reward_string = rpg_util.get_expected_rewards_string(action.rewards) embed = discord.Embed(title="Work started", description=reward_string, color=discord.Color.blue()) embed.add_field(name="Duration", value=f"{hours}h") embed.add_field(name="End time (UTC)", value=end_date.strftime("%d.%b.%Y %H:%M")) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def items_list(self, ctx: commands.Context, item_id:Optional[int]=None): await general_util.delete_message(self.bot, ctx) if item_id is None: items = self.item_repo.get_all_items() items_embeds = [] for item in items: embed = rpg_util.generate_item_embed(item) general_util.add_author_footer(embed, ctx.author) items_embeds.append(embed) if items_embeds: p_session = PaginatorSession(self.bot, ctx, pages=items_embeds) await p_session.run() else: await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_list_no_items), delete_after=Config.base_error_duration) else: item = self.item_repo.get_item_by_id(item_id) if item is None: return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_item_not_found", id=item_id)), delete_after=Config.base_error_duration) embed = rpg_util.generate_item_embed(item) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def action_rewards_list(self, ctx: commands.Context, action_id: Optional[int] = None): await general_util.delete_message(self.bot, ctx) if action_id is not None: if action_id not in ActionsEnum.val_list(): return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_list_actions_rewards_invalid_action_id), delete_after=Config.base_error_duration) action_rewards = self.rewards_repo.get_action_rewards(action_id) number_of_rewards = len(action_rewards) number_of_pages = math.ceil(number_of_rewards / 20) batches = [action_rewards[i * 20: i * 20 + 20] for i in range(number_of_pages)] pages = [] for batch in batches: embed = discord.Embed(title="Action rewards list", color=discord.Color.dark_blue()) general_util.add_author_footer(embed, ctx.author) for reward in batch: if reward.reward is not None: embed.add_field(name=f"ID: {reward.reward.id} - {ActionsEnum.get_name(reward.action_id)}", value=rpg_util.reward_to_string(reward.reward)) pages.append(embed) if pages: p_session = PaginatorSession(self.bot, ctx, pages=pages) await p_session.run() else: await ctx.send(embed=general_util.generate_error_message(Strings.rpg_list_actions_rewards_no_rewards), delete_after=Config.base_error_duration)
async def role_giver_list(self, ctx: commands.Context): await general_util.delete_message(self.bot, ctx) role_givers = self.role_giver_repo.get_guild_role_givers(ctx.guild.id) if not role_givers: embed = discord.Embed(title="Title giver list", description="*No title givers*", color=discord.Color.orange()) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration) else: pages = [] guild: discord.Guild = ctx.guild for role_giver in role_givers: embed = discord.Embed(title=role_giver.title, description=role_giver.description, color=discord.Color.blurple()) general_util.add_author_footer(embed, ctx.author) channel: Union[discord.Guild, None] = guild.get_channel( int(role_giver.channel_ID) ) if role_giver.channel_ID is not None else None embed.add_field(name="Channel", value=channel.name if channel is not None else "*No channel*") embed.add_field(name="Enabled", value="Yes" if role_giver.enabled else "No") roles = None role_ids = role_giver.role_IDs.split(";") if ( role_giver.role_IDs is not None and role_giver.role_IDs != "") else None if role_ids: roles = [ guild.get_role(int(role_id)) for role_id in role_ids ] roles = [role.name for role in roles if role is not None] roles = ( "\n".join(roles)) if roles is not None else "*No roles*" roles_splits = general_util.split_to_parts(roles, 1000) if len(roles_splits) == 1: embed.add_field(name="Roles", value=roles_splits[0]) else: for idx, role_split in enumerate(roles_splits): embed.add_field(name=f"Roles {idx + 1}", value=role_split) embed.add_field(name="ID", value=str(role_giver.id)) pages.append(embed) p_session = PaginatorSession(self.bot, ctx, Config.base_long_success_duration, pages=pages) await p_session.run()
async def _bot(self, ctx): em = discord.Embed(color=discord.Color.green(), title='Bot Info') em.description = 'Universal bot made by MatesXs using Pycord.py' em.add_field(name="Servers", value=str(len(self.bot.guilds))) em.add_field(name='Total Users', value=str(len(self.bot.users))) em.add_field( name='Channels', value=f"{sum(1 for g in self.bot.guilds for _ in g.channels)}") em.add_field(name="Library", value=f"[disnake](https://github.com/DisnakeDev/disnake)") em.add_field(name="Bot Latency", value=f"{round(self.bot.latency * 1000)} ms") em.add_field(name="Uptime", value=humanize.naturaldelta(datetime.datetime.utcnow() - self.start_date)) if Config.enable_invite_link: em.add_field( name="Invite", value= f"[Click Here](https://discordapp.com/oauth2/authorize?client_id={self.bot.user.id}&scope=bot%20applications.commands&permissions=8)" ) else: em.add_field(name="Invite", value=f"WIP") general_util.add_author_footer(em, ctx.message.author) await general_util.delete_message(self.bot, ctx) await ctx.channel.send(embed=em, delete_after=Config.base_long_success_duration)
async def get_action(self, ctx: commands.Context): await general_util.delete_message(self.bot, ctx) action = self.player_repo.get_action(ctx.author.id) embed = discord.Embed(title="Current action", color=discord.Color.blue()) if action is None: embed.description = "*No action*" else: if action.rewards: rewards_str = rpg_util.get_expected_rewards_string( action.rewards) if rewards_str != "": embed.description = rewards_str embed.add_field(name="Action type", value=ActionsEnum.get_name(action.action_id)) embed.add_field(name="Remaining time", value=humanize.naturaldelta( action.end_date.replace(tzinfo=timezone.utc) - datetime.now(tz=timezone.utc))) embed.add_field(name="End time (UTC)", value=action.end_date.strftime("%d.%b.%Y %H:%M")) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def get_player(self, ctx: commands.Context, *, player: Optional[Union[discord.Member, discord.User, int]] = None): await general_util.delete_message(self.bot, ctx) if player is None: player = ctx.author elif isinstance(player, int): player = await general_util.get_user(self.bot, player) if player is None: return ctx.send(embed=general_util.generate_error_message( Strings.rpg_player_get_player_doesnt_exist), delete_after=Config.base_error_duration) db_player = self.player_repo.get_player(player) embed = discord.Embed(title=f"{player.display_name} profile", color=discord.Color.blue()) embed.set_thumbnail( url=player.display_avatar.url if player. display_avatar is not None else player.default_avatar.url) embed.add_field(name="Level", value=str(db_player.level)) embed.add_field(name="XP", value=str(db_player.xp)) embed.add_field( name="XP to level", value=str( rpg_util.get_next_level_xp_requirement(db_player.level) - db_player.xp)) embed.add_field(name="Coins", value=str(db_player.money)) embed.add_field(name="Energy", value=str(db_player.energy)) embed.add_field( name="Inventory", value= f"{self.player_repo.get_current_size_of_inventory(player.id)}/{rpg_util.get_inventory_size(db_player.level)}" ) embed.add_field(name="Action", value=ActionsEnum.get_name(db_player.action.action_id) if db_player.action is not None else "None") if db_player.action is not None: embed.add_field( name="Remaining time", value=humanize.naturaldelta( db_player.action.end_date.replace(tzinfo=timezone.utc) - datetime.now(tz=timezone.utc))) embed.add_field( name="Return time (UTC)", value=db_player.action.end_date.strftime("%d.%b.%Y %H:%M")) if db_player.action.rewards: rewards_str = rpg_util.get_expected_rewards_string( db_player.action.rewards, length_limit=1000, header=False) if rewards_str != "": embed.add_field(name="Action reward", value=rewards_str) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def reposter_show(self, ctx: commands.Context): await general_util.delete_message(self.bot, ctx) settings = self.repost_settings_repo.get_repost_settings(ctx.guild.id) if settings is None: embed = discord.Embed(title="Content reposter", description="*There is no content reposter*", color=discord.Color.orange()) general_util.add_author_footer(embed, ctx.author) return await ctx.send(embed=embed, delete_after=Config.base_error_duration) embed = discord.Embed(title="Content reposter", description="**Enabled**" if settings.enabled else "**Disabled**", color=discord.Color.dark_blue()) general_util.add_author_footer(embed, ctx.author) repost_channel = await general_util.get_text_channel(ctx.guild, int(settings.repost_channel_id)) repost_channel_name = repost_channel.name if repost_channel is not None else "*Invalid*" embed.add_field(name="Repost channel", value=repost_channel_name) mode = "Whitelist" if not settings.blacklist_mode else "Blacklist" embed.add_field(name="Mode", value=mode) channels_title = "Blacklisted channels" if settings.blacklist_mode else "Whitelisted channels" if settings.mode_channel_ids is not None and settings.mode_channel_ids != "": channels_ids_string = settings.mode_channel_ids if settings.mode_channel_ids is not None else "" channel_ids = [int(chan_id) for chan_id in channels_ids_string.split(";") if chan_id != ""] channels_future = [general_util.get_text_channel(ctx.guild, chan_id) for chan_id in channel_ids] channels_result = await asyncio.gather(*channels_future) channels_result = [chan for chan in channels_result if chan is not None] channel_names = [chan.name for chan in channels_result] channel_names_print_string, _ = general_util.add_string_until_length(channel_names, 1000, "\n") test_database_ids = [str(chan.id) for chan in channels_result] test_database_string = ";".join(test_database_ids) if test_database_ids != settings.mode_channel_ids: # Modify database settings.mode_channel_ids = test_database_string self.repost_settings_repo.update() embed.add_field(name=channels_title, value=channel_names_print_string) else: embed.add_field(name=channels_title, value="*No channels set*") if not settings.any_emoji: emoji_ids = settings.emoji_ids.split(";") if settings.emoji_ids is not None else [] emojis = [] for emoji_id in emoji_ids: tmp_emoji = general_util.get_emoji_from_id(emoji_id, ctx.guild, self.bot) if tmp_emoji is not None: emojis.append(tmp_emoji) else: emojis.append(emoji_id) emojis = [str(emoji) for emoji in emojis if emoji is not None] emojis_string, _ = general_util.add_string_until_length(emojis, 1000, "\n") if emojis_string == "": emojis_string = "*No emojis*" embed.add_field(name="Emojis", value=emojis_string) else: embed.add_field(name="Emojis", value="Any") embed.add_field(name="Emojis threshold", value=str(settings.emoji_threshold)) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def role_giver_enable(self, ctx: commands.Context, role_giver_id: int): await general_util.delete_message(self.bot, ctx) role_giver = self.role_giver_repo.get_role_giver_by_id(role_giver_id) if role_giver is None: return await ctx.send(embed=general_util.generate_error_message( Strings.role_giver_doesnt_exist), delete_after=Config.base_error_duration) if role_giver.guild_ID != str(ctx.guild.id): return await ctx.send(embed=general_util.generate_error_message( Strings.role_giver_doesnt_belong_to_this_guild), delete_after=Config.base_error_duration) if role_giver.enabled: return await ctx.send(embed=general_util.generate_error_message( Strings.role_giver_enable_already_enabled), delete_after=Config.base_error_duration) if role_giver.role_IDs is None or role_giver.role_IDs == "": return await ctx.send(embed=general_util.generate_error_message( Strings.role_giver_enable_no_roles), delete_after=Config.base_error_duration) if role_giver.channel_ID is None: return await ctx.send(embed=general_util.generate_error_message( Strings.role_giver_enable_no_channel), delete_after=Config.base_error_duration) channel = await general_util.get_text_channel( ctx.guild, int(role_giver.channel_ID)) if channel is None: return await ctx.send(embed=general_util.generate_error_message( Strings.role_giver_enable_no_channel), delete_after=Config.base_error_duration) embed, number_of_roles = await generate_role_giver( role_giver, ctx.guild) if number_of_roles == 0: return await ctx.send(embed=general_util.generate_error_message( Strings.role_giver_enable_no_roles), delete_after=Config.base_error_duration) general_util.add_author_footer(embed, ctx.author) instance_message = await ctx.send(embed=embed) for i in range(number_of_roles): await instance_message.add_reaction(reactions[i]) role_giver.instance_message_ID = str(instance_message.id) role_giver.enabled = True self.role_giver_repo.update() await ctx.send(embed=general_util.generate_success_message( Strings.populate_string("role_giver_enable_success", id=role_giver.id)), delete_after=Config.base_success_duration)
async def handle_reaction_add(self, ctx: ReactionContext): if self.bot.user.id in (ctx.member.id, ctx.message.author.id): return if not isinstance(ctx.emoji, str): return if ctx.emoji not in self.flag_to_code.keys(): return if ctx.guild.id in self.guilds_usage.keys() and self.guilds_usage[ ctx.guild.id] >= Config.translate_usage_limit_per_10_mins: return await ctx.channel.send( embed=general_util.generate_error_message( Strings.populate_string( "translate_on_cooldown", limit=Config.translate_usage_limit_per_10_mins)), delete_after=Config.base_error_duration) if self.translator.get_usage().any_limit_exceeded: return await ctx.channel.send( embed=general_util.generate_error_message( Strings.translate_api_limit_exceeded), delete_after=Config.base_error_duration) trg_lan = self.flag_to_code[ctx.emoji] if trg_lan.upper() not in self.supp_list: return await ctx.channel.send( embed=general_util.generate_error_message( Strings.translate_unsupported_language), delete_after=Config.base_error_duration) if ctx.message.content is not None and ctx.message.content != "": if len(ctx.message.content) > 1000: return await ctx.channel.send( embed=general_util.generate_error_message( Strings.populate_string( "translate_message_too_large", message_url=ctx.message.jump_url)), delete_after=Config.base_error_duration) if ctx.guild.id in self.guilds_usage.keys(): self.guilds_usage[ctx.guild.id] += 1 else: self.guilds_usage[ctx.guild.id] = 1 result = str( self.translator.translate_text(ctx.message.content, target_lang=trg_lan.upper())) translate_result = discord.Embed( color=discord.Color.dark_blue(), description=str(result) + f"\n\n[Original]({ctx.message.jump_url})", title=f"Translation to {trg_lan.upper()}") general_util.add_author_footer(translate_result, ctx.member) await ctx.channel.send(embed=translate_result)
async def show_effect_enum(self, ctx: commands.Context): await general_util.delete_message(self.bot, ctx) effects = [] for effect in EffectEnum: effects.append(f"{effect.value}: {effect.name}") description, _ = general_util.add_string_until_length(effects, 4000, "\n") embed = discord.Embed(title="Available effects", description=description, color=discord.Color.dark_blue()) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def languages(self, ctx: commands.Context): await ctx.message.delete() response = discord.Embed(title="Translation supported languages", color=discord.Color.dark_blue()) general_util.add_author_footer(response, ctx.author) for lang in self.translator.get_target_languages(): response.add_field(name=f"{lang.name}", value=f"{lang.code}") await ctx.send(embed=response, delete_after=Config.base_long_success_duration)
async def ping(self, ctx: commands.Context): await general_util.delete_message(self.bot, ctx) em = discord.Embed(color=discord.Color.green(), title="Pong!") general_util.add_author_footer(em, ctx.message.author) start_time = time.time() message: discord.Message = await ctx.channel.send(embed=em) end_time = time.time() em.description = em.description = f'Bot: {round(self.bot.latency * 1000)} ms\nAPI: {round((end_time - start_time) * 1000)}ms' await message.edit(embed=em, delete_after=Config.base_success_duration)
async def invite(self, ctx): emb = discord.Embed(title='Invite Link', colour=discord.Color.dark_blue()) invite_link = f"https://discordapp.com/oauth2/authorize?client_id={self.bot.user.id}&scope=bot%20applications.commands&permissions=8" logger.info(invite_link) if Config.enable_invite_link: emb.description = f'[Click Here]({invite_link})' else: emb.description = "WIP" general_util.add_author_footer(emb, ctx.message.author) await ctx.send(embed=emb)
def generate_help_for_cog( cog: Base_Cog, ctx: commands.Context) -> Union[None, List[discord.Embed]]: if cog.hidden and ctx.author.id not in Config.developer_ids: return None coms = [ com for com in cog.walk_commands() if isinstance(com, commands.Command) and not com.hidden and command_check(com, ctx) ] number_of_coms = len(coms) if number_of_coms == 0: return None pages = [] if number_of_coms > Config.help_number_per_page: number_of_batches = math.ceil(number_of_coms / Config.help_number_per_page) batches = [ coms[i * Config.help_number_per_page:i * Config.help_number_per_page + Config.help_number_per_page] for i in range(number_of_batches) ] for idx, batch in enumerate(batches): emb = discord.Embed( title= f'{str(cog.qualified_name).replace("_", " ")} {idx + 1} Help', colour=discord.Color.green()) general_util.add_author_footer(emb, ctx.author) for com in batch: add_command_help(emb, com) if len(emb) > 6000: logger.warning(f"Help for {cog.qualified_name} is too long") else: pages.append(emb) else: emb = discord.Embed(title=f'{str(cog.qualified_name)} Help', colour=discord.Color.green()) general_util.add_author_footer(emb, ctx.author) for com in coms: add_command_help(emb, com) if len(emb) > 6000: logger.warning(f"Help for {cog.qualified_name} is too long") else: pages.append(emb) return pages
async def create_item(self, ctx: commands.Context, name:str, level_req:int, rarity:int, *, additional_info:Optional[str]=None): await general_util.delete_message(self.bot, ctx) name = name.replace("_", " ") if level_req < 0: return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_create_invalid_level_req), delete_after=Config.base_error_duration) if rarity not in RarityEnum.val_list(): return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_create_invalid_rarity), delete_after=Config.base_error_duration) description = None icon_path = None item_slot = None sell_value = None if additional_info is not None: additional_info_parts = additional_info.split(";") for add_inf_part in additional_info_parts: info_pair = add_inf_part.split(":") key = info_pair[0] val = info_pair[1] if key == "description": description = val elif key == "icon_path": icon_path = val elif key == "slot": if not val.isnumeric(): return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_items_create_key_not_numeric", key=key)), delete_after=Config.base_error_duration) val = int(val) if val not in ItemSlotEnum.val_list(): return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_create_invalid_slot), delete_after=Config.base_error_duration) item_slot = val elif key == "sell_value": if not val.isnumeric(): return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_items_create_key_not_numeric", key=key)), delete_after=Config.base_error_duration) val = int(val) if val < 0: return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_create_sell_value_negative), delete_after=Config.base_error_duration) sell_value = val item = self.item_repo.create_item(name, level_req, rarity, description=description, icon_path=icon_path, item_slot=item_slot, sell_value=sell_value) embed = rpg_util.generate_item_embed(item) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def actions_list(self, ctx: commands.Context): await general_util.delete_message(self.bot, ctx) action_index_list = ActionsEnum.val_list() actions_parts = [] for action_val in action_index_list: actions_parts.append(f"**{action_val}**: {ActionsEnum.get_name(action_val)}") actions_string, _ = general_util.add_string_until_length(actions_parts, 4000, "\n") embed = discord.Embed(title="List of actions", color=discord.Color.dark_blue(), description=actions_string) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def add_action_reward(self, ctx: commands.Context, action_id: Union[int, str], probability: float, *, content_string: str): await general_util.delete_message(self.bot, ctx) if isinstance(action_id, str): if action_id.isnumeric(): action_id = int(action_id) else: return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_edit_rewards_actions_create_action_id_invalid), delete_after=Config.base_error_duration) if action_id not in ActionsEnum.val_list(): return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_edit_rewards_actions_create_action_id_invalid), delete_after=Config.base_error_duration) action = ActionsEnum(action_id) if probability > 100 or probability < 0: return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_edit_rewards_actions_create_invalid_probability), delete_after=Config.base_error_duration) item_id = None xp = None money = None contents = content_string.split(";") for content in contents: parts = content.split(":") if len(parts) != 2: return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_edit_rewards_actions_create_invalid_content_string_format), delete_after=Config.base_error_duration) key = parts[0].lower() value = parts[1] if not value.isnumeric(): return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_edit_rewards_actions_create_invalid_key_value", key=key))) value = int(value) if key == "item": item = self.item_repo.get_item_by_id(value) if item is None: return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_edit_rewards_actions_create_invalid_key_value", key=key))) item_id = item.id elif key == "xp": if value < 0: return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_edit_rewards_actions_create_invalid_key_value", key=key))) xp = value elif key == "money": if value < 0: return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_edit_rewards_actions_create_invalid_key_value", key=key))) money = value else: return reward = self.rewards_repo.create_action_reward(action_id, probability, item=item_id, xp=xp, money=money) embed = discord.Embed(title=f"Action reward added for {action.name}", color=discord.Color.green(), description=rpg_util.reward_to_string(reward.reward)) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
def __generate_pool(self): embed = discord.Embed(title=self.title, color=discord.Color.gold()) general_util.add_author_footer(embed, self.ctx.author) embed.add_field(name="Pool duration", value=f"{self.timeout}min") embed.add_field(name="Minimum votes", value=str(self.minimum_votes)) description = (self.description + "\n\n") if self.description != "" else "" for question, reaction in zip(self.choices, reactions): description += f"{reaction}: {question}\n" assert len(description) < 4095, "Too large description" embed.description = description return embed
async def create_effect(self, ctx: commands.Context, item_id:int, effect_id:int, ammount:int): await general_util.delete_message(self.bot, ctx) if not self.item_repo.item_exist(item_id): return await ctx.send(embed=general_util.generate_error_message(Strings.populate_string("rpg_item_not_found", id=item_id)), delete_after=Config.base_error_duration) if effect_id not in EffectEnum.val_list(): return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_effect_create_invalid_effect_id), delete_after=Config.base_error_duration) effect = self.item_repo.create_effect(item_id, effect_id, ammount) embed = rpg_util.generate_effect_embed(effect) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def clear_actions(self, ctx: commands.Context): await general_util.delete_message(self.bot, ctx) if self.player_repo.is_idle(ctx.author.id): return await ctx.send(embed=general_util.generate_error_message( Strings.rpg_return_already_idle), delete_after=Config.base_error_duration) self.player_repo.delete_action(ctx.author.id) embed = discord.Embed( title=f"{ctx.author.display_name} returned back", description="*Returned home from journey without reward*", color=discord.Color.blue()) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed, delete_after=Config.base_long_success_duration)
async def process_reminder_creation(self, ctx: commands.Context, author: Union[discord.User, discord.Member, None], date: str, time: str, message: str): date_splits = date.split(".") time_splits = time.split(":") date_obj = parse_date_splits(date_splits, time_splits) if date_obj is None: return await ctx.send(embed=general_util.generate_error_message( Strings.reminder_invalid_time_or_date_format), delete_after=Config.base_error_duration) if (datetime.utcnow() + timedelta(minutes=1)) > date_obj: return await ctx.send(embed=general_util.generate_error_message( Strings.reminder_date_in_past), delete_after=Config.base_error_duration) message = general_util.split_to_parts(message, 3000)[0] embed = discord.Embed(title="Creating reminder", color=discord.Color.orange()) general_util.add_author_footer(embed, ctx.author) resp_msg = await ctx.send(embed=embed) reminder = self.reminder_repo.create_reminder(resp_msg.id, ctx.channel.id, author, date_obj, message) if reminder is None: return await resp_msg.edit( embed=general_util.generate_error_message( "Failed to create new reminder"), delete_after=Config.base_error_duration) embed = generate_reminder_embed( reminder, "⏰ Reminder created ⏰", "\n\nReact with 🙋 to subscribe for this reminder" if ctx.guild is not None else None) general_util.add_author_footer(embed, ctx.author) await resp_msg.edit(embed=embed) if ctx.guild is not None: await resp_msg.add_reaction("🙋") self.reminder_force_update = True
async def list_effects(self, ctx: commands.Context, item_id:Optional[int]=None): await general_util.delete_message(self.bot, ctx) effects = self.item_repo.get_all_effects(item_id) if not effects: return await ctx.send(embed=general_util.generate_error_message(Strings.rpg_items_effect_no_effects), delete_after=Config.base_error_duration) pages = [general_util.add_author_footer(rpg_util.generate_effect_embed(effect), ctx.author) for effect in effects] p_session = PaginatorSession(self.bot, ctx, pages=pages) await p_session.run()
async def weather_slash( self, inter: discord.CommandInteraction, where: str = commands.Param(description="Place where show weather"), when: str = commands.Param( autocomplete=when_autocomplete, default="UTC Now", description="UTC Time offset of weather prediction")): when = when.lower() if when == "utc now": time = timestamps.now() elif when == "utc tomorrow": time = timestamps.tomorrow() else: if when.isnumeric(): when = int(when) else: if when[-1] != "h": return await inter.send( embed=general_util.generate_error_message( Strings.weather_slash_invalid_when_format), delete_after=Config.base_error_duration) when = int(when[:-1]) time = timestamps.now() + timestamps.timedelta(hours=when) try: weather = self.get_time_specific_weather(where, time) except commands.CommandOnCooldown: return await inter.send(embed=general_util.generate_error_message( Strings.weather_api_reached_minute_limit), delete_after=Config.base_error_duration) if weather is None: return await inter.send(embed=general_util.generate_error_message( Strings.populate_string("weather_failed_to_get_weather", place=where)), delete_after=Config.base_error_duration) embed = generate_weather_embed(weather, where) general_util.add_author_footer(embed, inter.author) await inter.send(embed=embed)
async def weather_now(self, ctx: commands.Context, *, place: str): await general_util.delete_message(self.bot, ctx) try: weather = self.get_time_specific_weather(place, timestamps.now()) except commands.CommandOnCooldown: return await ctx.send(embed=general_util.generate_error_message( Strings.weather_api_reached_minute_limit), delete_after=Config.base_error_duration) if weather is None: return await ctx.send(embed=general_util.generate_error_message( Strings.populate_string("weather_failed_to_get_weather", place=place)), delete_after=Config.base_error_duration) embed = generate_weather_embed(weather, place) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed)
async def _send_result(ctx: commands.Context, result: dict, src: str): if "message" in result: # There is error in code execution return await ctx.send(embed=general_util.generate_error_message( result["message"]), delete_after=Config.base_error_duration) output = result["output"] output = general_util.split_to_parts(output, 1000) desc = ("**Output shortened**\n" if len(output) > 1 else "") + f"*{src}*" embed = discord.Embed(title=f"Ran your {result['language']} code", color=discord.Color.green(), description=desc) embed.add_field(name="Output", value=output[-1]) general_util.add_author_footer(embed, ctx.author) await ctx.send(embed=embed)
async def translate(self, ctx: commands.Context, target_language: str, *, text: str): if len(text) > 1000: return await ctx.send(embed=general_util.generate_error_message( Strings.populate_string("translate_message_too_large", message_url=ctx.message.jump_url)), delete_after=Config.base_error_duration) if ctx.guild.id in self.guilds_usage.keys() and self.guilds_usage[ ctx.guild.id] >= Config.translate_usage_limit_per_10_mins: return await ctx.send(embed=general_util.generate_error_message( Strings.populate_string( "translate_on_cooldown", limit=Config.translate_usage_limit_per_10_mins)), delete_after=Config.base_error_duration) if target_language.upper() not in self.supp_list: return await ctx.send(embed=general_util.generate_error_message( Strings.translate_unsupported_language), delete_after=Config.base_error_duration) if self.translator.get_usage().any_limit_exceeded: return await ctx.send(embed=general_util.generate_error_message( Strings.translate_api_limit_exceeded), delete_after=Config.base_error_duration) if ctx.guild.id in self.guilds_usage.keys(): self.guilds_usage[ctx.guild.id] += 1 else: self.guilds_usage[ctx.guild.id] = 1 result = str( self.translator.translate_text( text, target_lang=target_language.upper())) translate_result = discord.Embed( color=discord.Color.dark_blue(), description=str(result) + f"\n\n[Original]({ctx.message.jump_url})", title=f"Translation to {target_language.upper()}") general_util.add_author_footer(translate_result, ctx.author) await ctx.send(embed=translate_result)
async def get_inventory(self, ctx: commands.Context, simple: bool = False): await general_util.delete_message(self.bot, ctx) inventory = self.player_repo.get_inventory(ctx.author.id) if not inventory: embed = discord.Embed(title=f"{ctx.author.display_name} Inventory", description="*Your inventory is empty*", color=discord.Color.blue()) return await ctx.send( embed=embed, delete_after=Config.base_long_success_duration) if simple: parts = [] for inventory_slot in inventory: parts.append( rpg_util.generate_simple_item_text(inventory_slot.item)) pages = [] while parts: final_string, parts = general_util.add_string_until_length( parts, 4000, "\n") page = discord.Embed( title=f"{ctx.author.display_name} Inventory", description=final_string, color=discord.Color.blue()) general_util.add_author_footer(page, ctx.author) pages.append(page) else: pages = [] for inventory_slot in inventory: embed = rpg_util.generate_item_embed(inventory_slot.item) embed.title = f"{ctx.author.display_name} Inventory\n{inventory_slot.item.name}" general_util.add_author_footer(embed, ctx.author) pages.append(embed) p_session = PaginatorSession(self.bot, ctx, timeout=Config.base_long_success_duration, pages=pages) await p_session.run()