def base_permissions(self, owner, module): """Return the overwrites for the current table, can be overwriten by other table class (staff table for exemple)""" return { owner: discord.PermissionOverwrite(move_members=True, manage_channels=True), module.guild.get_role(conf('protect.punished_roles.prison')): discord.PermissionOverwrite(speak=False, send_messages=False, add_reactions=False), module.guild.get_role(conf('protect.punished_roles.isolation')): discord.PermissionOverwrite(read_messages=False), }
async def check_invites(self, message): invite_reg = re.search(INVITE_REGEX, message.content) if invite_reg: allowed = [ conf('staff_roles.administration_leader'), conf('staff_roles.administration'), ] for role in message.author.roles: if role.id in allowed: return invit_link = invite_reg.group(0).split(' ')[0] await self.shared_delete_message(message) await self.log_invite(message, invit_link)
class Table_rank_nitro(Table): index = 7 price = 10 max_size = 10 allowed_roles = [ conf('rank.nitro_role'), ] prefix = 'đź’€'
async def _just_join(self, user, inviter, first_join): separator_roles = [ self.guild.get_role(role_id) for role_id in conf('separator_roles') ] await self.shared_add_user_roles(user, *separator_roles) if first_join: await WelcomePanel.create(self.welcome_channel, user, self, inviter)
def load_custom_emojis(bot): """Load all custom emojis from ressource servers""" global custom_emoji resource_servers = conf('resource_servers') for server_id in resource_servers: emojis = bot.get_guild(server_id).emojis for emoji in emojis: custom_emoji[emoji_to_str(emoji)] = server_id
def question_embed(self): rules_channel = self.module.guild.get_channel(conf('rules_channel')) embed = discord.Embed( title=narr('welcome.panel.title'), colour=discord.Colour.blurple(), description=narr('welcome.panel.desc').format(rules=rules_channel.mention) # if does not work use url instead ) desc = "" for emoji, proposition in zip(self.base_buttons, narr('welcome.panel.responses')): desc += f"{emoji} : {proposition}\n" embed.add_field(name=narr('welcome.panel.responses_title'), value=desc, inline=False) return embed
async def _on_door_passed(self, user, inviter): await self.api.invited_by( user, inviter) # this will create the user if he respond correct role = self.guild.get_role(conf('rank.roles.0')) await self.shared_add_user_roles(user, role) channel = self.guild.get_channel(conf('join_leave_channel')) if inviter is None: await self.send( channel, narr('welcome.welcome_message_no_inviter').format( joiner_mention=user.mention, )) else: await self.send( channel, narr('welcome.welcome_message_inviter').format( joiner_mention=user.mention, inviter_name=inviter.display_name, )) inviter = self.guild.get_member( inviter.id ) # cast to member | we keep the inviter a user before for having it as inviter even if he is not on the server await self.trigger_hook('invite', inviter, user)
async def re_init_user(module, user): db_user = module.api.db_user(user) # create the user to_remove = [ role for role in user.roles if (role != module.guild.default_role) and (role.id not in STAFF_ROLES) ] await module.shared_remove_user_roles(user, *to_remove) # remove old roles default_roles = [ module.guild.get_role(role_id) for role_id in conf('separator_roles') ] # add separators roles default_roles.append(module.guild.get_role( db_user.rank.role_id)) # add rank base role await module.shared_add_user_roles(user, *default_roles)
async def _just_join(self, user, inviter, first_join): if not first_join: level_roles_id = conf('level_ranks') roles_to_add = [] db_user = self.api.db_user(user) for level in range(db_user.level): level_role_id = level_roles_id.get(level, None) if level_role_id is not None: roles_to_add.append(self.guild.get_role(level_role_id)) if len(roles_to_add) > 0: await self.shared_add_user_roles(user, *roles_to_add)
def __init__(self, main_bot, api): try: self.name = self.__class__.__name__.replace('Module', '').lower() token = conf(f'tokens.{self.name}') except: print( f"{self.__class__.__name__} don't have token association in config file !" ) raise Exception else: ModuleBot.__init__(self, token) self.main_bot = main_bot self.api = api self.commands = [] self.panels = [] self.under_modules = [] self._define_shared()
async def handle_level_up(self, user_id, levels): """Handle level up message (call the level up module here)""" narrs = narr('level_up') welcome_bots = [ mod for mod in self.main_bot.modules if mod.name in narrs.keys() ] for level in levels: mod = random.choice(welcome_bots) user = mod.guild.get_member(user_id) messsage = narr(f'level_up.{mod.name}', rand=True).format(name=user.mention, level=level) await mod.send_notification(user, messsage) level_role_id = conf('level_ranks').get(str(level), None) if level_role_id is not None: role_mod = self.main_bot.available_mod_bot await role_mod.shared_add_user_roles( user, role_mod.guild.get_role(level_role_id))
async def clean_stuff(self): for channel in self.category_channel.voice_channels: if channel != self.voice_channel: await self.shared_delete_channel(channel) overwrites = self.voice_channel.overwrites for user in overwrites.copy(): if isinstance(user, discord.member.Member): del overwrites[user] await self.shared_edit_channel(self.voice_channel, overwrites=overwrites) await self.shared_purge_channel(self.text_channel) embed = discord.Embed( title=narr('voc.introduction.title'), colour=discord.Colour.blurple(), description=narr('voc.introduction.desc').format( delay=self.delete_delay, voice_channel=self.voice_channel.mention, voice_invitation=conf('voc.voice_invitation')), ) await self.send(self.text_channel, embed=embed)
import discord import asyncio import datetime from marshmallow import Schema, fields, validate from utility.loader import narr, conf from utility.emoji import emoji_bar, str_to_emoji from bases.command_base import Command, UserField from objects.item import Stack from objects.rule import Rule ALLOWED = [ conf('staff_roles.administration_leader'), conf('staff_roles.administration'), conf('staff_roles.moderation_leader'), conf('staff_roles.moderation'), ] PRISON = conf('protect.punished_roles.prison') ISOLATION = conf('protect.punished_roles.isolation') class ReleaseSchemas(Schema): user = UserField(required=True) class ReleaseCommand(Command): name = 'release' schemas = ReleaseSchemas args_description = { 'user': "",
def role_rewards(self): return [conf(f'success_roles.{self.quest_name}'),]
async def send_notification(self, user, message, color=None): channel = self.guild.get_channel(conf('notification_channel')) embed = discord.Embed(description=message) if color is not None: embed.color = color await self.send(channel, user.mention, embed=embed)
import discord import threading import functools import time import asyncio import uuid from datetime import datetime import traceback from utility.loader import narr, conf from utility.emoji import str_to_emoji ERROR_PATH = conf('error_log_path') DO_RAISE_ERROR = False def shared_method(func): """Make a method usable and awaitable from the MainBot async loop""" @functools.wraps(func) async def inner(self, *args, **kwargs): self.last_req = time.time() task_id = str(uuid.uuid1()) self.tasks[task_id] = func(self, *args, **kwargs) return await self.task_finished(task_id) return inner def log_error(): with open(ERROR_PATH, 'a+') as f:
def rules_channel(self): return self.get_channel(conf('rules_channel'))
async def _on_guild_channel_create(self, channel): if channel.category_id == conf( 'voc.category_channel'): # voc handle this part itself return await self.set_channel_perm(channel)
class Command: name = '' schemas = CommandSchemas args_description = {} minArgs = 0 allowed_channels = conf('command_channels') #[] allowed_roles = [] banned_roles = [] dm_only = False _emoji = None @classmethod def description_from_name(cls, name): """Permit to get the command description without instanciating the command""" return narr(f'commands.{name}.desc') def get_emoji(self, name): return str_to_emoji(f':{name}', self.module) @property def description(self): return self.description_from_name(self.name) def __init__(self, arg_list, sender, channel, dm, bot, module, message): # argument handling args = {} if len(arg_list) > 0: if len(arg_list) < self.minArgs: pass for k, _ in self.args_description.items(): if len(args) >= len(arg_list): break args[k] = arg_list[len(args)] self.sender = sender self.channel = channel self.dm = dm self.bot = bot self.module = module self.message = message self.err = self.schemas().validate(args) if len(self.err) > 0: self.args = {} else: command_schemas = self.schemas() self.args = command_schemas.load(args) async def intern_run(self): if len(self.allowed_channels) > 0: if self.channel.id not in self.allowed_channels: #return await self.module.send(self.channel,'Mauvais channel !') return if self.dm_only and not self.dm: # return await self.module.send(self.channel,'Uniquement en dm !') return sender_roles = [role.id for role in self.sender.roles] if len(self.allowed_roles) > 0: inter = [r for r in sender_roles if r in self.allowed_roles] if len(inter) == 0: return await self.module.send( self.channel, self.sender.mention, embed=discord.Embed( description=narr('command.unauthorized'))) if len(self.banned_roles) > 0: inter = [r for r in sender_roles if r in self.banned_roles] if len(inter) > 0: # return await self.module.send(self.channel,'Accés restreint !') return if len(self.err) > 0: return await self.wrong_usage() await self.module.shared_delete_message(self.message) await self.module.trigger_hook('use_command', self.sender, self.name, self.args) return await self.run() async def run(self): if True: raise Exception('You need to overide this function') return '' async def wrong_usage(self): #TODO: faire une méthode interne qui renvoie un message de mauvaise utilisation et une méthode externe propre a chaque commande qui génère le message d'aide en cas de mauvaise utilisation # self.err.items() return await self.module.send( self.channel, self.sender.mention, embed=discord.Embed(description=narr('command.wrong_usage'))) async def cant(self, message=None): embed = discord.Embed( colour=discord.Colour.red(), description=message or narr('cant'), ) await self.module.send(self.channel, embed=embed) async def can(self, message=None): embed = discord.Embed( colour=discord.Colour.green(), description=message or narr('can'), ) await self.module.send(self.channel, embed=embed)
def run_bot(cls): """Blocking function that run the main bot""" main_bot = MainBot() main_bot.run(conf('tokens.main'))
async def use_tool(self,mod,user,tool): channel = mod.get_channel(conf(f"activity.{mod.name}")) await tool.item.panel.create(channel,user,mod,tool)
from mongoengine import connect from utility.loader import config_mode,conf config_mode('main') from main.main_bot import MainBot connect(conf('database.name'), host=conf('database.host'), port=conf('database.port'), username=conf('database.username'), password=conf('database.password'), ) MainBot.run_bot()
import discord import asyncio from marshmallow import Schema, fields, validate import os from utility.loader import narr, conf from bases.command_base import Command, UserField SECURITY_PWD = conf('security_pwd') STAFF_ROLES = conf('staff_roles').values() ALLOWED = [ conf('staff_roles.administration_leader'), ] async def re_init_user(module, user): db_user = module.api.db_user(user) # create the user to_remove = [ role for role in user.roles if (role != module.guild.default_role) and (role.id not in STAFF_ROLES) ] await module.shared_remove_user_roles(user, *to_remove) # remove old roles default_roles = [ module.guild.get_role(role_id) for role_id in conf('separator_roles') ] # add separators roles default_roles.append(module.guild.get_role( db_user.rank.role_id)) # add rank base role await module.shared_add_user_roles(user, *default_roles) async def after_reset(module):
def activity_channel(self): return conf(f'activity.{self.module_name}')
PickingModule, AnimalHuntingModule, DiggingModule, InsectHuntingModule, ExplorationModule, # NecromancyModule, ) from modules.welcome.welcome_module import WelcomeModule from modules.economy.economy_module import EconomyModule from modules.voc.voc_module import VocModule from modules.protect.protect_module import ProtectModule from modules.quest.quest_module import QuestModule # ALT 255 => espace pris en compte par discord GUILD_ID = conf('guild_id') PREFIX = conf('prefix') ENABLED_MODULES = [ BasicModule, ActivityModule, FishingModule, MiningModule, PickingModule, AnimalHuntingModule, DiggingModule, InsectHuntingModule, ExplorationModule, # NecromancyModule, RankModule, WelcomeModule, EconomyModule,
import discord import asyncio from marshmallow import Schema,fields,validate import os from utility.loader import narr, conf from bases.command_base import Command,UserField ERROR_PATH = conf('error_log_path') ALLOWED = [ conf('staff_roles.administration_leader'), ] class ErrorSchemas(Schema): action = fields.Str(required=True,validate=validate.OneOf(('show','clear'))) class ErrorCommand(Command): name = 'error' schemas = ErrorSchemas args_description = { 'action': "", } minArgs = 1 allowed_channels = [] allowed_roles = [*ALLOWED] async def run(self): action = self.args['action']
import discord import asyncio import datetime from marshmallow import Schema, fields, validate from utility.loader import narr, conf from bases.command_base import Command, UserField from api.api import AllreadyBanException ALLOWED = [ conf('staff_roles.administration_leader'), conf('staff_roles.administration'), conf('staff_roles.moderation_leader'), ] # allowed is also protected ==> staff leader and admins class BanSchemas(Schema): user = UserField(required=True) delete_days = fields.Int() class BanCommand(Command): name = 'ban' schemas = BanSchemas args_description = {'user': "", 'delete_days': ""} minArgs = 1 allowed_channels = [] allowed_roles = [*ALLOWED] async def run(self):
from datetime import datetime, timedelta from objects.item import Stack, Item from objects.rank import Rank from objects.rule import Infraction, InfractionRecap from objects.quest import Quest, Chapter, UserQuest, ChapterOutOfRangeException from utility.loader import conf try: from objects.quests.intro import IntroQuest except: print( "Error from importing IntroQuest into user, check all the reward are properties" ) STATS = conf('stats') def XP_FUNC(level): return int(math.exp(math.sqrt(level)) + 800) def default_quests(): """Return the default quests for a new player that first join the server (success and intro)""" default = [] default.append(IntroQuest) default += Quest.success() return [UserQuest.empty_quest(quest()).to_dict() for quest in default]
def info_channel(self): return self.get_channel(conf('rank.info_channel'))
import discord import re # from objects.rule import InfractionRecap from utility.loader import conf, narr from bases.module_base import Module from utility.emoji import str_to_emoji from modules.protect.commands.clear_command import ClearCommand from modules.protect.commands.infraction_command import InfractionCommand from modules.protect.commands.release_command import ReleaseCommand from modules.protect.commands.ban_command import BanCommand from modules.protect.commands.unban_command import UnbanCommand from modules.protect.commands.error_command import ErrorCommand from modules.protect.commands.reset_command import ResetCommand, ResetallCommand PRISON_ROLE = conf('protect.punished_roles.prison') ISOLATION_ROLE = conf('protect.punished_roles.isolation') PRISON_CHANNEL = conf('protect.prison_text_channel') ISOLATION_CHANNEL = conf('protect.isolation_text_channel') RELEASE_CHANNEl = conf('protect.release_text_channel') LOG_CHANNEL = conf('protect.log_channel') INVITE_REGEX = "(https?:\\/\\/)?(www\\.)?(discord\\.(gg|io|me|li)|discordapp\\.com\\/invite)\\/.+[a-z]" class ProtectModule(Module): @property def rules_channel(self): return self.get_channel(conf('rules_channel')) @property