def processor(bot, update): user = update.message.from_user text = update.message.text action, params = db_user.get_action(user.id) settings = utils.get_settings() db_user.update(user) # Check if it is group chat if update.message.chat.id < 0: if text.startswith('/'): log_message( update.message.reply_text(utils.get_constant('not_chat'))) return # logging logger.info('{} {} ({}:@{}): {}'.format(user.first_name, user.last_name, user.id, user.username, text)) # Constant behavior for button in settings['constant_behavior']: if utils.get_constant(button) == text: behave(settings['constant_behavior'][button], bot, update) return # Checking menu if action in settings: for button in settings[action]['keyboard']: if get_button_text(button) == text: behave(button, bot, update) else: action_manager(bot, update, action)
async def deck_start(self, ctx: Context, *, description: str): literal = literals('deck_start') partner_role: Role = discord.utils.get( await self.deck_handler.guild.fetch_roles(), id=get_constant('partner_role')) partner_channel = await self.client.fetch_channel( get_constant('partner_channel')) if not isinstance(author := ctx.author, Member): author = await self.deck_handler.guild.fetch_member(ctx.author.id)
async def deck_end(self, ctx: Context, *, deck: DeckConverter = None): literal = literals('deck_end') partner_role: Role = discord.utils.get( await self.deck_handler.guild.fetch_roles(), id=get_constant('partner_role')) partner_channel = await self.client.fetch_channel( get_constant('partner_channel')) if deck is None: deck = await DeckConverter().convert(ctx, str(ctx.channel.id)) if not isinstance(author := ctx.author, Member): author = await self.deck_handler.guild.fetch_member(ctx.author.id)
async def predicate(ctx: Context): partner_role_id = get_constant('partner_role') shtelo_guild_id = get_constant('shtelo_guild') guild = await ctx.bot.fetch_guild(shtelo_guild_id) member = None if guild is not None: member = await guild.fetch_member(ctx.author.id) if member is None: return False role = discord.utils.get(member.roles, id=partner_role_id) if role is None: return False return True
async def send_command_help(self, ctx: Context, command: Command): literal = literals('send_command_help') command_name = command.qualified_name default_signature = get_command_default_signature(command) footer = get_command_signature(command) description = '' if command.help is not None: description = command.help + '\n' elif command.brief is not None: description = command.brief + '\n' description += f'`{default_signature}`' embeds = ChainedEmbed(title=get_constant('default_prefix') + command_name, description=description) embeds.set_thumbnail(url=self.client.user.avatar_url) if not command.enabled: embeds.add_field(name=literal['disabled_name'], value=literal['disabled_value']) if isinstance(command, CustomGroup): embeds.add_field(name=literal['subcommand'], value=f'\n{brief_group(command)}\n') for check in command.checks: data = get_check(check.name) if data is None: continue embeds.add_field(name=f'{data["emoji"]} {data["name"]}', value=data["description"]) if command.cog is not None: category = command.cog.qualified_name if isinstance(command.cog, CustomCog): category = command.cog.emoji + ' ' + category footer += ' · ' + category embeds.set_footer(text=footer) for embed in embeds.to_list(): await ctx.send(embed=embed)
async def update_application(member: Member, state: str, remarks: str, on_error=None, keys=None, rows=None): sheet = get_constant('application') if keys is None or rows is None: keys, rows = get_application_sheet() result = False for i, row in enumerate(rows): if str(member) in row and row[APPLICATION_STATE] != state: row[APPLICATION_STATE] = state if remarks is not None and not row[APPLICATION_REMARKS]: row[APPLICATION_REMARKS] = str(remarks).replace('->', '→') result = row.copy() break if not result: if on_error is not None: await on_error() raise BadArgument(f'application not found') result[-1] = sheet['active_time_formula'].format(i + 2) sheet_write(sheet['sheet_id'], sheet['insert_range'].format(i + 2), [result]) return result
def predicate(ctx: Context) -> bool: client_permissions: dict = dict( ctx.guild.get_member(get_constant('kenken_id')).guild_permissions) for perm, value in permissions.items(): if client_permissions[perm] != value: return False return True
def __init__(self, args: list): intents = Intents.default() intents.members = True super().__init__([get_constant('default_prefix')], intents=intents) self.load_all_extensions() get_event_loop().run_until_complete( self.start( config('TOKEN') if 'b' not in args else config('BETA_TOKEN')))
def get_application_sheet(): sheet = get_constant('application') rows = sheet_read(sheet['sheet_id'], sheet['read_range']) keys = rows.pop(0) for reply in rows: while len(reply) < len(keys): reply.append('') return keys, rows
async def regulation_all(self, ctx: Context): literal = literals('regulation_all') message = await ctx.send(literal['start']) paragraphs = wrap_codeblock(doc_read( get_constant('regulation')['doc_id']), split_paragraph=True) await message.edit(content=literal['done']) for p in paragraphs: await ctx.author.send(p)
async def channel_create_voice(self, ctx: Context, *, name: str): literal = literals('channel_create_voice') deck: Deck = await DeckConverter().convert(ctx, str(ctx.channel.id)) check_deck_manager(deck, ctx.author) tester_role: Role = ctx.guild.get_role(get_constant('tester_role')) member_role: Role = ctx.guild.get_role(get_constant('member_role')) overwrites = { ctx.guild.default_role: PermissionOverwrite(view_channel=False, connect=False), deck.role: PermissionOverwrite(view_channel=True, connect=True), tester_role: PermissionOverwrite(view_channel=True), member_role: PermissionOverwrite(view_channel=True) } channel = await deck.category_channel.create_voice_channel( name, overwrites=overwrites) await ctx.send(literal['done'] % channel.mention)
def fetch_regulation(self): if self.regulation is None \ or self.regulation.data is None: paragraphs = wrap_codeblock(doc_read( get_constant('regulation')['doc_id']), split_paragraph=True) self.regulation = FreshData(paragraphs, SECOND_PER_HOUR) else: paragraphs = self.regulation.data return paragraphs
def get_command_signature(command: Command): parent = command.full_parent_name if len(command.aliases) > 0: aliases = '|'.join(command.aliases) fmt = '[%s|%s]' % (command.name, aliases) if parent: fmt = parent + ' ' + fmt alias = fmt else: alias = command.name if not parent else parent + ' ' + command.name return ('%s%s %s' % (get_constant('default_prefix'), alias, command.signature)).rstrip()
async def application_approve(self, ctx: Context, member: Member, *, remarks: str = None): literal = literals('application_approve') message = await ctx.send(literal['start']) if remarks is None: remarks = member.id await update_application(member, APPLICATION_APPROVED, remarks, message.delete) tester_role = ctx.guild.get_role(get_constant('tester_role')) member_role = ctx.guild.get_role(get_constant('member_role')) tasks = list() if tester_role in member.roles: tasks.append(member.remove_roles(tester_role)) if member_role not in member.roles: tasks.append(member.add_roles(member_role)) tasks.append(message.edit(content=literal['done'] % member.mention)) await asyncio.wait(tasks)
def get_student(bot, update): action, params = db_user.get_action(update.message.from_user.id) user = update.message.from_user text = update.message.text if action == 'get_student': if len(params) > 0: # If we have more than one param(it's probably date) then print group's schedule with that param date = params[0] log_message( update.message.reply_text( schedule.get_student(date=date, group=text))) default_menu(bot, update) else: # If we have none params, then we should save date and let user enter group date = text.split(',')[0] groups = [[KeyboardButton(utils.get_constant('back_to_menu'))]] for group in schedule.get_student_groups(date): groups.append([KeyboardButton(group['title'])]) log_message( update.message.reply_text(utils.get_constant('enter_group'), reply_markup=ReplyKeyboardMarkup( groups, one_time_keyboard=True))) db_user.set_action(user_id=user.id, action='get_student/{date}'.format(date=date)) else: # Choose date if action isn't "get_student" dates = [[KeyboardButton(utils.get_constant('back_to_menu'))]] for date in sorted(schedule.get_student_dates(), reverse=True): dates.append( [KeyboardButton(date + ', ' + schedule.get_weekday(date))]) log_message( update.message.reply_text(utils.get_constant('enter_date'), reply_markup=ReplyKeyboardMarkup( dates, one_time_keyboard=True))) db_user.set_action(user_id=user.id, action='get_student')
def item_group(self): """returns the major item grouping for an item, e.g. mace, armor etc""" own_type = self.type.lower() for g in ("axes", "bows", "claws", "daggers", "maces", "staves", "swords", "wands", "helms", "armors", "gloves", "boots", "shields", "belts", "quivers"): for k, v in get_constant(g.upper(), as_dict=True).items(): if k.lower() in own_type: # see if there is a subtype if isinstance(v, str): return g.title() else: return v.get("subtype", g.title()) raise ValueError("%s is not a recognized item type." % self.type)
def load_all_extensions(self): for file_name in listdir(get_path('extensions')): if not file_name.endswith('_cog.py') and not file_name.endswith( '_cmd.py'): continue module = file_name[:-3] Log.auto(f'loading extension: {module}') try: self.load_extension(get_constant('extension_name') % module) except ExtensionAlreadyLoaded as e: Log.error(f'extension already loaded: {e.name}') self.reload_extension(e.name) except (ExtensionFailed, NoEntryPointError, ExtensionFailed) as e: Log.error(e) raise e
def add_member(member: Member, nickname=None, rows=None): sheet = get_constant('member_list') if rows is None: rows = sheet_read(sheet['sheet_id'], sheet['range']) if nickname is None: nickname = get_nickname_of(member) result = [ int(rows[-1][0]) + 1, nickname, str(member.roles[-1]), str(member.id), str(to_kst(member.joined_at)) ] rows.append(result.copy()) if result: sheet_write(sheet['sheet_id'], sheet['range'], rows) return result
async def after_ready(self): self.shtelo_guild = self.client.get_guild(get_constant('shtelo_guild')) self.partner_channel = self.client.get_channel( get_constant('partner_channel')) self.member_role = self.shtelo_guild.get_role( get_constant('member_role')) self.tester_role = self.shtelo_guild.get_role( get_constant('tester_role')) self.title_div_role = self.shtelo_guild.get_role( get_constant('title_div_role')) self.deck_div_role = self.shtelo_guild.get_role( get_constant('deck_div_role')) self.partner_role = self.shtelo_guild.get_role( get_constant('partner_role'))
def edit_member(query: str, nickname: Optional[str] = None, state: Optional[str] = None, rows=None): sheet = get_constant('member_list') if rows is None: rows = sheet_read(sheet['sheet_id'], sheet['range']) result = None for row in rows: if query in row: if nickname is not None: row[MEMBER_LIST_NICKNAME] = nickname if state is not None: row[MEMBER_LIST_STATE] = state result = row.copy() break if result: sheet_write(sheet['sheet_id'], sheet['range'], rows) return result
def sub_student(bot, update): user = update.message.from_user action, params = db_user.get_action(user.id) text = update.message.text if action == 'sub_student': if text == utils.get_constant('unsubscribe'): text = None log_message( update.message.reply_text( utils.get_constant('suc_unsubscribe'))) else: log_message( update.message.reply_text( utils.get_constant('suc_subscribe_group').format( group=text))) db_user.set_sub_student(user_id=user.id, group=text) default_menu(bot, update) else: groups = [[KeyboardButton(utils.get_constant('back_to_menu'))]] for group in schedule.get_student_list(): groups.append([KeyboardButton(group)]) sub = db_user.get_sub_student(user.id) info = utils.get_constant('not_subscribed_info') if sub is not None: info = utils.get_constant('subscribed_info_group').format( group=sub) groups[0].append(KeyboardButton(utils.get_constant('unsubscribe'))) log_message( update.message.reply_text( utils.get_constant('subscribe_group').format(info=info), reply_markup=ReplyKeyboardMarkup(groups, one_time_keyboard=True))) db_user.set_action(user_id=user.id, action='sub_student')
def log(cls, log: str, path: str = '', **kwargs): now = datetime.now() stack = inspect.stack() try: class_ = stack[2][0].f_locals["self"].__class__.__name__ except KeyError: class_ = None method_ = stack[2][0].f_code.co_name context = f'{now} - {class_}.{method_} : {log}' print(context) if not path: return message: Message = kwargs.get('message') if message is not None: if message.guild is not None: zer0ken = message.guild.get_member(get_constant('zer0ken_id')) if zer0ken is None: print('--not logged : zer0ken not in this guilds') return else: print('--not logged : DM') return
async def on_send(self, request: Request): literal = literals('on_send') key = request.addition.strip() async def respond(data_, key_): here_request = request.generate_respond(signal=BotProtocol.HERE, addition=key_ + ' ') addition_length = MESSAGE_MAX_LENGTH - len(str(here_request)) - 1 here_request.addition += data_[:addition_length] data_ = data_[addition_length:] await request.message.channel.send(str(here_request), delete_after=1) if data_: for d in split_by_length(data_): await request.message.channel.send(d, delete_after=1) done_request = request.generate_respond(signal=BotProtocol.DONE, addition=key_) await request.message.channel.send(str(done_request), delete_after=1) if key == literal['application']: data = json.dumps(get_application_sheet(), ensure_ascii=False) await respond(data, key) if key == literal['regulation']: data = doc_read(get_constant('regulation')['doc_id']) await respond(data, key)
async def receive_automatically(self, message: Message): literal = literals('receive_automatically') async def failed(): await self.partner_channel.send(literal['failed'] % message.author.mention) if message.channel.id != get_constant( 'self_introduction_channel') or len(message.content) < 10: return keys, rows = get_application_sheet() application = get_application_of(message.author, rows) if application is None or application[APPLICATION_STATE]: return trigger_member_name = application[APPLICATION_INVITER] trigger_role = self.member_role if not trigger_member_name: trigger_member_name = application[APPLICATION_SUBACCOUNT] trigger_role = None try: trigger_member = await MemberConverter().convert( await self.client.get_context(message), trigger_member_name) except BadArgument as e: await failed() raise e if trigger_role is not None and trigger_role not in trigger_member.roles: await failed() return remark = str(message.author.id) if not application[APPLICATION_INVITER]: remark = literal['subaccount'] % (trigger_member.id, remark) await self.receive_application(message.author, remark, None, keys, rows) await message.add_reaction(CONFIRM_EMOJI) if application[APPLICATION_INVITER]: add_member(message.author, application[APPLICATION_NICKNAME]) await self.partner_channel.send( literal['done'] % (message.author.mention, message.jump_url), embed=get_application_embed(application))
def sub_teacher(bot, update): user = update.message.from_user action, params = db_user.get_action(user.id) text = update.message.text if action == 'sub_teacher': if text == utils.get_constant('unsubscribe'): text = None log_message( update.message.reply_text( utils.get_constant('suc_unsubscribe'))) else: log_message( update.message.reply_text( utils.get_constant('suc_subscribe_teacher').format( teacher=text))) db_user.set_sub_teacher(user_id=user.id, name=text) default_menu(bot, update) else: teachers = [[KeyboardButton(utils.get_constant('back_to_menu'))]] for teacher in schedule.get_teacher_list(): teachers.append([KeyboardButton(teacher)]) sub = db_user.get_sub_teacher(user.id) info = utils.get_constant('not_subscribed_info') if sub is not None: info = utils.get_constant('subscribed_info_teacher').format( teacher=sub) teachers[0].append( KeyboardButton(utils.get_constant('unsubscribe'))) log_message( update.message.reply_text( 'Выберите или введите преподавателя, на которого вы хотите подписатся\n' + info, reply_markup=ReplyKeyboardMarkup(teachers, one_time_keyboard=True))) db_user.set_action(user_id=user.id, action='sub_teacher')
def action_manager(bot, update, action): if action == 'get_student': try: get_student(bot, update) except schedule.ScheduleException as ex: if ex.code == 200: log_message( update.message.reply_text( utils.get_constant('no_schedule_for_date'))) elif ex.code == 201: log_message( update.message.reply_text( utils.get_constant('no_group_schedule'))) else: log_message( update.message.reply_text( utils.get_constant('unknown_error').format( code=ex.code, message=ex.message))) elif action == 'get_teacher': try: get_teacher(bot, update) except schedule.ScheduleException as ex: if ex.code == 200: log_message( update.message.reply_text( utils.get_constant('no_schedule_for_date'))) elif ex.code == 201: log_message( update.message.reply_text( utils.get_constant('no_teacher_schedule'))) else: log_message( update.message.reply_text( utils.get_constant('unknown_error').format( code=ex.code, message=ex.message))) elif action == 'sub_student': sub_student(bot, update) elif action == 'sub_teacher': sub_teacher(bot, update) elif action == 'close_keyboard': close_keyboard(bot, update) elif action == 'default_menu': default_menu(bot, update) return
import hashlib from sqlalchemy import types, true, false from sqlalchemy.ext.compiler import compiles from sqlalchemy.databases import postgres from app import db import constants from utils import norm, normfind, get_constant GEMS = get_constant("GEMS", as_dict=True) class tsvector(types.TypeDecorator): """ using tsvectors for full text search in sqlalchemy, custom type definition http://stackoverflow.com/questions/13837111/ """ impl = types.UnicodeText @compiles(tsvector, 'postgresql') def compile_tsvector(element, compiler, **kw): return 'tsvector' def in_page_group(group_name): premium_pages = Location.query.filter( Location.is_premium, Location.is_character == false(),
"""force a fetch of all the constants""" CONSTANTS = [ "GEMS", "UNIQUES", "QUIVERS", "BELTS", "WANDS", "STAVES", "DAGGERS", "CLAWS", "GLOVES", "BOOTS", "SHIELDS", "HELMS", "ARMORS", "BOWS", "AXES", "MACES", "SWORDS", "PREFIXES", "SUFFIXES", "CURRENCIES", "FLASK_SIZES", "MISC_FLASKS", "QUEST_ITEMS", ] for c in CONSTANTS: get_constant(c)
from flask import request, render_template from flask.views import View, MethodView from jinja2 import contextfilter from jinja2.filters import do_mark_safe from sqlalchemy import false, not_, and_ from app import app, db, manager import constants from models import (Item, Location, Property, Requirement, Modifier, in_page_group) from utils import get_constant # init constants CHROMATIC_RE = r"B+G+R+" GEMS = get_constant("GEMS", as_dict=True) QUIVERS = get_constant("QUIVERS", as_dict=True) @app.template_filter('percent') def percent_filter(x): return "%.2f%%" % (x * 100) @app.template_filter('socket') def socket_filter(x): """outputs nice html for a socket string""" out = [] for c in x: if c == "B": out.append('<span class="label label-primary"> </span>')
def predicate(ctx: Context) -> bool: return ctx.author.id in (get_constant('zer0ken_id'), )
async def on_message(self, message): if message.author.id == get_constant('kenken_id'): return await super().on_message(message)
TWO_HANDED_WEAPONS[k] = v """ """force a fetch of all the constants""" CONSTANTS = [ "GEMS", "UNIQUES", "QUIVERS", "BELTS", "WANDS", "STAVES", "DAGGERS", "CLAWS", "GLOVES", "BOOTS", "SHIELDS", "HELMS", "ARMORS", "BOWS", "AXES", "MACES", "SWORDS", "PREFIXES", "SUFFIXES", "CURRENCIES", "FLASK_SIZES", "MISC_FLASKS", "QUEST_ITEMS", ] for c in CONSTANTS: get_constant(c)