def register_user(message):
reply_message = 'Welcome ' + \
str(message.from_user.first_name) + ' to F1 predictions!'
try:
cursor.execute("SELECT * FROM users WHERE username=?",
(message.from_user.username, ))
user = cursor.fetchall()
except mariadb.Error as e:
logger.error(
f'Error SELECTING FROM users WHERE username... MariaDB output: {e}'
)
if not user:
try:
cursor.execute(
"INSERT IGNORE INTO users (username,user_id,points) VALUES (?, ?, ?)",
(message.from_user.username, message.from_user.id, 0))
conn.commit()
except mariadb.Error as e:
logger.error(f'Error INSERTING username... MariaDB output: {e}')
bot.reply_to(message, reply_message)
logger.info('User created in database')
return True
bot.reply_to(message, "Wait, are you registered? I think so...")
def handle_exception(e):
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
logger.error(e)
logger.debug("{} {} {}".format(exc_type, fname, exc_tb.tb_lineno))
logger.debug(traceback.format_exc())
logger.critical(
"Provider does not have method correctly implemented cannot continue"
)
tt = threading.Thread(target=thread_shutdown, args=())
tt.start() # (schedule_shutdown, args=(), id='shutdown')
async def execute(self, ctx, *, query):
conn = await self.bot.connpool.acquire()
try:
await conn.execute(f"""{query}""")
await ctx.message.add_reaction('\U00002705')
logger.info(f"Successfully executed query: '{query}' on PG DB")
except Exception as e:
await ctx.message.add_reaction('\U0000274c')
logger.error(
f"Failed execute of query: '{query}' on PG DB - Error: {e}")
finally:
await self.bot.connpool.release(conn)
async def reload(self, ctx, cog: str):
"""Reload a cog"""
try:
self.bot.unload_extension(cog)
except Exception as e:
logger.error(
f"Attempted to unload cog: {cog} which was never loaded on start up. Bypassing and attempting "
f"to complete function.")
self.bot.load_extension(cog)
logger.info(f"Successfully reloaded extension: {cog}")
await ctx.send(f"`{cog}` successfully reloaded.")
async def load(self, ctx, ext):
"""Load an Extension. """
print(f'{ctx.author.name} loading {ext}')
try:
check = path(f'extensions/{ext}.py')
if not check.exists() or ext == 'AdminCommands':
return await ctx.send(f'{ext} is not a valid extension.')
self.bot.load_extension(f'extensions.{ext}')
logger.warning(f'{ext} Loaded by {ctx.author.name}')
print(f'{ext} Loaded')
return await ctx.send(f'{ext} Loaded')
except Exception as e:
logger.error(f'Error loading {ext}. Error: {e}')
logger.error(traceback.print_exc())
return print(e)
def get_list(message):
try:
cursor.execute("SELECT * FROM users")
users_fetched = cursor.fetchall()
except mariadb.Error as e:
logger.error(f'Error SELECTING FROM users... MariaDB output: {e}')
users = []
for user in users_fetched:
users.append(User(user[0], user[1], user[2]))
ordered_users = sorted(users, key=lambda x: x.points, reverse=True)
table = create_standings_table(ordered_users)
bot.send_message(message.chat.id,
f'<pre>{table}</pre>',
parse_mode=ParseMode.HTML)
def start_bot( logger, args ):
"""Create TahmatassuBot
Arguments:
logger {Logger} -- logger
args {dict} -- Command line arguments
"""
try:
config = ConfigParser()
config.read(args.config)
tahmatassu = TahmaTassuBot(token=config['DEFAULT']['token'],
tahmatassu_base_url=config['DEFAULT']['tahmatassuapi'],
bot_name=config['DEFAULT']['botname'])
tahmatassu.run()
except Exception as error:
logger.error(error)
logger.exception("message")
async def reload(self, ctx, ext):
""" Reload an extension. """
print(f'{ctx.author.name} reloading {ext}')
try:
check = path(f'extensions/{ext}.py')
if not check.exists():
return await ctx.send(f'{ext} is not a valid extension')
self.bot.unload_extension(f'extensions.{ext}')
print(f'{ext} Unloaded')
self.bot.load_extension(f'extensions.{ext}')
print(f'{ext} Loaded')
logger.warning(f'{ext} Reloaded by {ctx.author.name}')
return await ctx.send(f'{ext} Reloaded')
except Exception as e:
logger.error(f'Error reloading {ext}. Error: {e}')
logger.error(traceback.print_exc())
print(e)
def update(self):
self._unknown_options = []
try:
tmp_data = read_json_file(self._file)
except json.decoder.JSONDecodeError:
logger.error("runtime file error reading")
return
if tmp_data is None:
self.dump()
return
for key, value, in tmp_data.items():
if key.startswith('_'):
continue
if hasattr(self, key):
setattr(self, key, value)
else:
self._unknown_options.append(key)
if len(self._unknown_options) > 0:
logger.debug("Unknown options were passed in [{}]".format(','.join(
self._unknown_options)))
async def on_command_error(self, ctx, error):
"""Activates when an exception arises"""
if hasattr(ctx.command, 'on_error'):
return logger.debug("Exception found but handled by command's own error handler.")
error = getattr(error, 'original', error)
if isinstance(error, commands.CommandNotFound):
return logger.error(f"{str(ctx.author.id)} called the bot's prefix but no corresponding command located.")
if isinstance(error, commands.MissingRequiredArgument):
logger.error(f"{str(ctx.author.id)} invoked the command '{ctx.command.name}' but missed required "
f"arguments.")
return await ctx.error(f"Required arguments missed. {self.bot.command_prefix}help <command> for indepth usage.")
elif isinstance(error, commands.CheckFailure):
logger.debug(f"{str(ctx.author.id)} invoked the command '{ctx.command.name}' but didn't meet the checks.")
return await ctx.error("You do not meet the relevant checks inorder to invoke this command.")
else:
logger.error(f"Exception '{type(error).__name__}' raised in command when {ctx.author.id} invoked "
f"'{ctx.command}' {error}")
async def on_ready(self):
self.connpool = await postgresconn()
for cog in cogs:
try:
self.load_extension(cog)
logger.info(f'Successfully loaded extension: {cog}')
except Exception as e:
logger.error(f'Failed to load extension: {cog}\n{e}')
self.load_extension('jishaku')
logger.info(f'Client Logged in at {datetime.now()}')
await self.change_presence(activity=discord.Game(
name=f"Shard {str(self.shard_count)} | "
f"{str(len(self.guilds))} Guilds"))
conn = await self.connpool.acquire()
message_count = await conn.fetch(
'''SELECT messages_handled FROM bot_stats WHERE user_id=579399080799633448'''
)
self.message_count = int(message_count[0][0])
await self.connpool.release(conn)
async def send_photo(bot: Bot,
repo: Repo,
user_id: int,
photo,
caption: str,
disable_notification: bool = False):
"""
Безопасная рассылка
:param repo:
:param bot:
:param caption:
:param photo:
:param user_id:
:param disable_notification:
:return:
"""
try:
await bot.send_photo(chat_id=user_id,
photo=photo,
caption=caption,
disable_notification=disable_notification)
except exceptions.BotBlocked:
logger.error(
f"Пользователь [ID:{user_id}]: Бот заблокирован пользователем")
await repo.delete_customer(user_id)
except exceptions.ChatNotFound:
logger.error(f"Пользователь [ID:{user_id}]: Неверный ID пользователя")
except exceptions.RetryAfter as e:
logger.error(
f"Пользователь [ID:{user_id}]: Достигнут лимит рассылки. Засыпаю на {e.timeout} секунд."
)
await asyncio.sleep(e.timeout)
return await send_photo(user_id=user_id, photo=photo,
caption=caption) # Recursive call
except exceptions.UserDeactivated:
logger.error(
f"Пользователь [ID:{user_id}]: Аккаунт деактивирован/удалён")
except exceptions.TelegramAPIError:
logger.exception(f"Пользователь [ID:{user_id}]: Провалено")
except exceptions.BotKicked:
logger.exception(
f"Бот был удален из группы. Удаляю [ID:{user_id}] из базы")
await repo.delete_customer(user_id)
else:
logger.info(f"Пользователь [ID:{user_id}]: Успешно")
def connect(organization: Organization) -> Organization:
try:
client_id = current_app.config.get('BOT_CLIENT_ID')
client_secret = current_app.config.get('BOT_CLIENT_SECRET')
identity = authenticate(organization.organization_uid, client_id,
client_secret)
organization.token = identity.token
organization.domain = identity.domain
organization.token_expires_at = identity.expires
db.session.add(organization)
db.session.flush()
except ApiError as api_error:
logger.error('Received error response from API: %s' %
api_error.message)
# Any 4xx errors at this stage means our error
if 400 <= api_error.status < 500:
message = ('Unable to connect organization due to internal '
' error. Please contact bot developer.')
raise exceptions.InternalServerError(
payload={'detail': message}) from api_error
else:
raise exceptions.BadRequest(message='API Error',
payload={'detail': api_error.message
}) from api_error
except exc.IntegrityError as integrity_error:
logger.error(integrity_error)
db.session.rollback()
raise exceptions.OrganizationConnect(
message='Already connected',
payload={'detail': 'Requested organization already connected.'})
except (exc.SQLAlchemyError, RequestException) as internal_error:
logger.error(internal_error)
db.session.rollback()
raise exceptions.InternalServerError(
payload={'detail': 'Unable to connect organization.'})
else:
db.session.commit()
logger.info('Organization %s successfully connected' %
organization.organization_uid)
return organization
def error(bot, update, error):
logger.error('Update "%s" caused error "%s"' % (update, error))
def runtime_error(message):
logger.error("Runtime error: {}".format(message))
async def initialize_iterator(self):
ts = int(time.time() * 1000)
try:
async with websockets.connect(ws) as client:
# Logging in websocket server
if self._name:
await client.send(
json.dumps({
'op': 'login',
'args': {
'key':
self._key,
'subaccount':
self._name,
'sign':
hmac.new(self._secret.encode(),
f'{ts}websocket_login'.encode(),
'sha256').hexdigest(),
'time':
ts
}
}).encode())
else:
await client.send(
json.dumps({
'op': 'login',
'args': {
'key':
self._key,
'sign':
hmac.new(self._secret.encode(),
f'{ts}websocket_login'.encode(),
'sha256').hexdigest(),
'time':
ts
}
}).encode())
# Subscribing for data listening
if isinstance(self._currency, list):
for currency in self._currency:
await client.send(
json.dumps({
'op': 'subscribe',
'channel': 'ticker',
'market': currency
}))
else:
# Subscribing for data listening
await client.send(
json.dumps({
'op': 'subscribe',
'channel': 'ticker',
'market': self._currency
}))
# If we didnt subscribe for a stream, than there is a problem
resp = json.loads(await client.recv())
if not resp.get('type') == 'subscribed':
print(resp)
logger.error('Didnt subscribe')
return
# Listening to the stream of data
while True:
yield json.loads(await client.recv())
except Exception as e:
logger.error(e, repr(e))