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
