847 lines
31 KiB
Python
847 lines
31 KiB
Python
import logging
|
||
logging.basicConfig(level=logging.INFO, force=True, format="%(asctime)s %(name)s %(levelname)s: %(message)s", datefmt="%d-%m-%Y %H:%M:%S")
|
||
|
||
import typing
|
||
import disnake
|
||
from disnake.ext import commands
|
||
from disnake.ext import tasks
|
||
import requests
|
||
import numpy as np
|
||
import aiohttp
|
||
import asyncio
|
||
import sys
|
||
import os
|
||
import copy
|
||
import datetime
|
||
import math
|
||
import random
|
||
import inspect
|
||
import json
|
||
import shutil
|
||
import re
|
||
|
||
from constants.rimagochi_constants import *
|
||
from constants.global_constants import *
|
||
from libs.tokens_formatter import TOKENS
|
||
from database.db_classes import all_data as DataBaseClasses
|
||
from managers.DataBaseManager import DatabaseManager
|
||
from database.settings import config
|
||
|
||
from sqlalchemy.orm import declarative_base, relationship
|
||
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
|
||
from sqlalchemy.orm import sessionmaker
|
||
from sqlalchemy.schema import CreateTable
|
||
|
||
import gspread
|
||
from google.oauth2.service_account import Credentials
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
class AnyBots(commands.Bot):
|
||
logger = logging.getLogger(__name__)
|
||
'''
|
||
|
||
|
||
Any bot class
|
||
|
||
|
||
'''
|
||
def __init__(self, DataBaseManager):
|
||
super().__init__(
|
||
command_prefix="=",
|
||
intents=disnake.Intents.all()
|
||
)
|
||
self.DataBaseManager = DataBaseManager
|
||
self.costrolecreate = constants['costrolecreate']
|
||
self.costrolerenewal = constants['costrolerenewal']
|
||
self.dailycrumbs = constants['dailycrumbs']
|
||
self.casinospinslimit = constants['casinospinslimit']
|
||
|
||
async def on_ready(self, inherited = False):
|
||
self.krekchat = await self.fetch_guild(constants["krekchat"])
|
||
self.logger.info(self.krekchat.name)
|
||
self.sponsors = [disnake.utils.get(self.krekchat.roles, id=i) for i in constants["sponsors"]]
|
||
self.mutes = [disnake.utils.get(self.krekchat.roles, id=i) for i in constants["mutes"]]
|
||
self.ban_role = disnake.utils.get(self.krekchat.roles, id=constants["ban_role"])
|
||
self.me = disnake.utils.get(self.krekchat.roles, id=constants["me"])
|
||
self.moder = disnake.utils.get(self.krekchat.roles, id=constants["moder"])
|
||
self.curator = disnake.utils.get(self.krekchat.roles, id=constants["curator"])
|
||
self.everyone = disnake.utils.get(self.krekchat.roles, id=constants["everyone"])
|
||
self.staff = disnake.utils.get(self.krekchat.roles, id=constants["staff"])
|
||
self.level_roles = [disnake.utils.get(self.krekchat.roles, id=i) for i in constants["level_roles"]]
|
||
# lists
|
||
self.moderators = [disnake.utils.get(self.krekchat.roles, id=i) for i in constants["moderators"]]
|
||
# /lists
|
||
self.bots_talk_protocol_channel_id = constants["bots_talk_protocol_channel"]
|
||
self.databases_backups_channel_id = constants["databases_backups_channel"]
|
||
await self.change_presence(status=disnake.Status.online, activity=disnake.Game("Работаю"))
|
||
|
||
if not inherited:
|
||
self.logger.info(f"{datetime.datetime.now().strftime('%H:%M:%S %d-%m-%Y')}:: KrekFunBot activated")
|
||
|
||
async def RimagochiUserUpdate(self, member, session = None):
|
||
if session is None:
|
||
raise Exception("Реализация RimagochiUserUpdate без session ещё не сделана")
|
||
|
||
else:
|
||
await self.UserUpdate(member, session = session)
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['rimagochi_users'] as rimagochi_users_models:
|
||
stmt = self.DataBaseManager.select(rimagochi_users_models).where(rimagochi_users_models.id == member.id)
|
||
rimagochi_user = (await session.execute(stmt)).scalars().first()
|
||
|
||
if rimagochi_user is None:
|
||
rimagochi_user = rimagochi_users_models(id = member.id, settings = rimagochi_default_settings)
|
||
session.add(rimagochi_user)
|
||
|
||
async def CasinoUserUpdate(self, member, session = None):
|
||
if session is None:
|
||
raise Exception("Реализация CasinoUserUpdate без session ещё не сделана")
|
||
|
||
else:
|
||
await self.UserUpdate(member, session = session)
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['casino_user_account'] as casino_user_account_models:
|
||
stmt = self.DataBaseManager.select(casino_user_account_models).where(casino_user_account_models.id == member.id)
|
||
casino_user = (await session.execute(stmt)).scalars().first()
|
||
|
||
if casino_user is None:
|
||
casino_user = casino_user_account_models(id = member.id)
|
||
session.add(casino_user)
|
||
|
||
async def UserUpdate(self, member, session = None):
|
||
|
||
if session is None:
|
||
async with self.DataBaseManager.session() as session:
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['users'] as users_model:
|
||
stmt = self.DataBaseManager.select(users_model).where(users_model.id == member.id)
|
||
user = (await session.execute(stmt)).scalars().first()
|
||
|
||
if user is None:
|
||
user = users_model(id = member.id)
|
||
session.add(user)
|
||
|
||
return 0
|
||
else:
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['users'] as users_model:
|
||
stmt = self.DataBaseManager.select(users_model).where(users_model.id == member.id)
|
||
user = (await session.execute(stmt)).scalars().first()
|
||
|
||
if user is None:
|
||
user = users_model(id = member.id)
|
||
session.add(user)
|
||
return user
|
||
|
||
async def DeleteRole(self, role_id: int):
|
||
async with self.DataBaseManager.session() as session:
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['roles_custom'] as roles_custom:
|
||
stmt = self.DataBaseManager.select(roles_custom).where(
|
||
roles_custom.id == role_id
|
||
).with_for_update()
|
||
role = (await session.execute(stmt)).scalars().first()
|
||
if not role is None:
|
||
await session.delete(role)
|
||
|
||
krekchat = await self.fetch_guild(constants["krekchat"])
|
||
role = krekchat.get_role(role_id)
|
||
if not role:
|
||
return [True, "Кастомная роль успешно удалена из базы данных, но не найдена на сервере"]
|
||
# deleting from server
|
||
await role.delete()
|
||
return [True, "Кастомная роль успешно удалена"]
|
||
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['roles_prize'] as roles_prize:
|
||
async with self.DataBaseManager.models['roles_static'] as roles_static:
|
||
stmt = self.DataBaseManager.select(roles_prize).where(
|
||
roles_prize.id == role_id
|
||
).with_for_update()
|
||
prize_role = (await session.execute(stmt)).scalars().first()
|
||
if not prize_role is None:
|
||
await session.delete(prize_role)
|
||
stmt = self.DataBaseManager.select(roles_static).where(
|
||
roles_static.id == role_id
|
||
).with_for_update()
|
||
static_role = (await session.execute(stmt)).scalars().first()
|
||
if not static_role is None:
|
||
await session.delete(static_role)
|
||
krekchat = await self.fetch_guild(constants["krekchat"])
|
||
role = krekchat.get_role(role_id)
|
||
if not role:
|
||
return [True, "Призовая роль успешно удалена из базы данных, но не найдена на сервере"]
|
||
await role.delete()
|
||
return [True, "Призовая роль успешно удалена"]
|
||
|
||
return [False, "Такой роли не существует в базе данных"]
|
||
|
||
def PartitioningEmbeder(self, arr):
|
||
result = []
|
||
for i in range(len(arr)):
|
||
if i % 5 == 0:
|
||
result.append([])
|
||
result[-1].append(arr[i])
|
||
return result
|
||
|
||
async def CalculateRimagochiBattleStrength(self, users_animals: list):
|
||
sum_strenght = 0
|
||
for animal in users_animals:
|
||
if not animal.in_battle_slots:
|
||
continue
|
||
animal_model = copy.deepcopy(rimagochi_animals[animal.model_animal_id])
|
||
for gene in animal.genes:
|
||
genedata = rimagochi_genes[gene]
|
||
for effect in genedata['effects'].keys():
|
||
animal_model['params'][effect] += genedata['effects'][effect]
|
||
sum_strenght = sum_strenght + ((animal_model['params']['damage']*animal_model['params']['health'])+(animal_model['params']['damage']*animal_model['params']['health']*animal.level/4))
|
||
return sum_strenght
|
||
|
||
async def LevelRolesGiver(self, member, level):
|
||
try:
|
||
c = 0
|
||
if level >= 1: c += 1
|
||
if level >= 5: c += 1
|
||
if level >= 55: c += 1
|
||
if level >= 91: c += 1
|
||
for role in range(1, len(self.level_roles)):
|
||
if role == c:
|
||
await member.add_roles(self.level_roles[role])
|
||
continue
|
||
await member.remove_roles(self.level_roles[role])
|
||
except:
|
||
pass
|
||
|
||
def HexToRgb(self, value):
|
||
value = value.lstrip('#')
|
||
lv = len(value)
|
||
return tuple(int(value[i:i + lv // 3], 16) for i in range(0, lv, lv // 3))
|
||
|
||
def find_for_arr(self, arr, elem):
|
||
for i in range(len(arr)):
|
||
if arr[i] == elem:
|
||
return i
|
||
return -1
|
||
|
||
def AnimalLevelAdder(self, exp, level):
|
||
if(level+1<=max(rimagochi_constants["animals_exp_to_levels"].keys())):
|
||
if exp>=rimagochi_constants["animals_exp_to_levels"][level+1]:
|
||
exp = exp - rimagochi_constants["animals_exp_to_levels"][level+1]
|
||
level += 1
|
||
if (level+1<=max(rimagochi_constants["animals_exp_to_levels"].keys())):
|
||
return exp, level, rimagochi_constants["animals_exp_to_levels"][level+1] - exp
|
||
else:
|
||
return exp, level, float('inf')
|
||
else:
|
||
return exp, level, rimagochi_constants["animals_exp_to_levels"][level+1] - exp
|
||
else:
|
||
return exp, level, float('inf')
|
||
|
||
def CalculateLevel(self, messages, voiceactivity):
|
||
n = (messages + (voiceactivity / (180))) / 4
|
||
# return math.log((messages+(voiceactivity/(30)))+1, 1.11)
|
||
if n < 40:
|
||
return n / 3
|
||
else:
|
||
return math.log(n, 1.05) - 62
|
||
|
||
def TimeFormater(self, time_str: str = "", days: float = 0, hours: float = 0, minutes: float = 0, now_timestamp = None):
|
||
"""
|
||
Форматирует строку времени в timestamp и разложенное время
|
||
Поддерживает форматы: 1d2h30m, 1д2ч30мин, 1.5d, 1 день 2 часа 30 минут и т.п.
|
||
Возвращает объект класса FormatedTime
|
||
"""
|
||
|
||
class FormatedTime:
|
||
def __init__(self, time_units):
|
||
self.time_units = time_units
|
||
|
||
self.days, self.hours, self.minutes = time_units['d'], time_units['h'], time_units['m']
|
||
delta = datetime.timedelta(days=self.days, hours=self.hours, minutes=self.minutes)
|
||
self.future_time = 0
|
||
if now_timestamp is None:
|
||
self.future_time = datetime.datetime.now() + delta
|
||
else:
|
||
self.future_time = datetime.datetime.fromtimestamp(now_timestamp) + delta
|
||
self.timestamp = self.future_time.timestamp()
|
||
|
||
def __float__(self):
|
||
return self.timestamp
|
||
|
||
def __int__(self):
|
||
return int(self.timestamp)
|
||
|
||
def __repr__(self):
|
||
result = []
|
||
if self.days != 0:
|
||
result.append(f"{self.days} дней")
|
||
if self.hours != 0:
|
||
result.append(f"{self.hours} часов")
|
||
if self.minutes != 0:
|
||
result.append(f"{self.minutes} минут")
|
||
|
||
return ", ".join(result) + f" [{self.timestamp}]"
|
||
|
||
def to_dict(self):
|
||
return self.time_units
|
||
|
||
time_units = {'d': 0, 'h': 0, 'm': 0}
|
||
if any([days, hours, minutes]):
|
||
time_units = {'d': days, 'h': hours, 'm': minutes}
|
||
else:
|
||
time_str = time_str.lower().replace(' ', '').replace(',', '.')
|
||
|
||
replacements = {
|
||
r'дней?': 'd',
|
||
r'день': 'd',
|
||
r'д': 'd',
|
||
r'часов?': 'h',
|
||
r'час': 'h',
|
||
r'ч': 'h',
|
||
r'минут?': 'm',
|
||
r'мин': 'm',
|
||
r'м': 'm',
|
||
}
|
||
|
||
for pattern, replacement in replacements.items():
|
||
time_str = re.sub(pattern, replacement, time_str, flags=re.IGNORECASE)
|
||
|
||
pattern = r'(\d+(\.\d+)?)([dhm])'
|
||
matches = re.findall(pattern, time_str)
|
||
|
||
for value, _, unit in matches:
|
||
time_units[unit] += value
|
||
|
||
return FormatedTime(time_units)
|
||
|
||
class ErrEmbed(disnake.Embed):
|
||
def __init__(self, err_func: typing.Callable[..., typing.Awaitable[None]] | None = None, err_func_kwargs: dict | None = None, **kwargs):
|
||
color = kwargs.pop('color', 0x2F3136)
|
||
super().__init__(color=color, **kwargs)
|
||
self.err_func_kwargs: dict = err_func_kwargs or {}
|
||
self.err_func = err_func
|
||
|
||
async def send(self, description: str | None = None):
|
||
if self.err_func is None:
|
||
raise ValueError("err_func не задана")
|
||
|
||
if description is not None:
|
||
self.description = description
|
||
|
||
await self.err_func(embed = self, **self.err_func_kwargs)
|
||
|
||
class InfoEmbed(disnake.Embed):
|
||
def __init__(self, **kwargs):
|
||
color = kwargs.pop('color', 0x2F3136)
|
||
super().__init__(color = color, **kwargs)
|
||
|
||
class WarnEmbed(disnake.Embed):
|
||
def __init__(self, **kwargs):
|
||
color = kwargs.pop('color', 0xFFFF00)
|
||
super().__init__(color = color, **kwargs)
|
||
|
||
class AdminBot(AnyBots):
|
||
'''
|
||
|
||
|
||
Admin`s bot class
|
||
|
||
|
||
'''
|
||
def __init__(self, DataBase, stop_event, *, task_start = True):
|
||
super().__init__(DataBase)
|
||
self.task_start = task_start
|
||
self.stop_event = stop_event
|
||
|
||
async def on_ready(self, inherited = True):
|
||
await super().on_ready(inherited = True)
|
||
|
||
if self.task_start:
|
||
self.VoiceXpAdder.cancel()
|
||
self.CheckDataBase.cancel()
|
||
self.UpdatingTournamentData.cancel()
|
||
|
||
self.VoiceXpAdder.start()
|
||
self.CheckDataBase.start()
|
||
self.UpdatingTournamentData.start()
|
||
else:
|
||
self.UpdatingTournamentData.start() # Удалить обязательно!!!
|
||
|
||
self.logger.info(f"{datetime.datetime.now().strftime('%H:%M:%S %d-%m-%Y')}:: KrekFunLoopsBot activated")
|
||
|
||
async def BotOff(self):
|
||
self.VoiceXpAdder.cancel()
|
||
self.CheckDataBase.cancel()
|
||
self.UpdatingTournamentData.cancel()
|
||
|
||
self.stop_event.set()
|
||
|
||
async def on_disconnect(self):
|
||
if self.stop_event.is_set():
|
||
pass
|
||
else:
|
||
self.logger.error(f"{datetime.datetime.now().strftime('%H:%M:%S %d-%m-%Y')}:: Соединение с дискордом разорвано")
|
||
await self.BotOff()
|
||
|
||
async def check_bt_channel(self):
|
||
async def moder_dataparser(data: dict):
|
||
if not 'type' in data.keys():
|
||
raise json.JSONDecodeError("Некорректный JSON", '{"type":value}', 0)
|
||
async with self.DataBaseManager.session() as session:
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['users'] as users_model:
|
||
if data['type'] == "punishment":
|
||
options = data['options']
|
||
ratings = {'textmute': 10, 'voicemute': 10, 'warning': 5, 'ban': 50, 'reprimand': 15, 'newnick': 0}
|
||
user = await session.get(users_model, options['member'], with_for_update = True)
|
||
if user is None:
|
||
user = users_model(id = options['member'], carma = -ratings[options['severity']])
|
||
session.add(user)
|
||
else:
|
||
user.carma -= ratings[options['severity']]
|
||
|
||
elif data['type'] == "unpunishment":
|
||
options = data['options']
|
||
ratings = {'textmute': 10, 'voicemute': 10, 'warning': 5, 'ban': 50, 'reprimand': 15, 'newnick': 0}
|
||
user = await session.get(users_model, options['member'], with_for_update = True)
|
||
if user is None:
|
||
user = users_model(id = options['member'], carma = ratings[options['severity']])
|
||
session.add(user)
|
||
else:
|
||
user.carma += ratings[options['severity']]
|
||
|
||
elif data['type'] == "complaint":
|
||
options = data['options']
|
||
|
||
attack_member = await session.get(users_model, options['attack_member'], with_for_update = True)
|
||
if attack_member is None:
|
||
attack_member = users_model(id = options['attack_member'], carma = 10 if options['accepted'] else -1)
|
||
session.add(attack_member)
|
||
else:
|
||
attack_member.carma += 10 if options['accepted'] else -1
|
||
|
||
moderator = await session.get(users_model, options['moderator'], with_for_update = True)
|
||
if moderator is None:
|
||
moderator = users_model(id = options['moderator'], carma = 10)
|
||
session.add(moderator)
|
||
else:
|
||
moderator.carma += 10
|
||
|
||
else:
|
||
return 1
|
||
|
||
return 0
|
||
|
||
|
||
krekchat = await self.fetch_guild(self.krekchat.id)
|
||
bt_channel = await krekchat.fetch_channel(self.bots_talk_protocol_channel_id)
|
||
last_msg = None
|
||
|
||
while True:
|
||
stopflag = False
|
||
if not isinstance(bt_channel, disnake.TextChannel):
|
||
raise ValueError("В bt_channel как-то оказалось не disnake.TextChannel")
|
||
batch = await bt_channel.history(limit=10, before=last_msg).flatten()
|
||
for message in batch:
|
||
msg_stopflag = False
|
||
for reaction in message.reactions:
|
||
if reaction.emoji == "✅" or reaction.emoji == "❎":
|
||
msg_stopflag = True
|
||
break
|
||
else:
|
||
data = json.loads(message.content)
|
||
try:
|
||
result = 0
|
||
if not 'sender' in data:
|
||
raise json.JSONDecodeError("Некорректный JSON", '{"sender":value}', 0)
|
||
if data['sender'] == "ModBot":
|
||
result = await moder_dataparser(data)
|
||
if result:
|
||
raise json.JSONDecodeError("Некорерктный JSON", '', 0)
|
||
await message.add_reaction("✅")
|
||
except json.JSONDecodeError as e:
|
||
await message.add_reaction("❎")
|
||
except Exception as exc:
|
||
self.logger.error(f"{data} {exc}")
|
||
if msg_stopflag:
|
||
stopflag = True
|
||
break
|
||
last_msg = message
|
||
if stopflag:
|
||
break
|
||
|
||
async def give_crumbs_counter(self, incoming_crumbs: float, member, sponsor_roles, carma = 0):
|
||
modifier = (carma / 100) + (bool(set(sponsor_roles) & set(member.roles)) + 1)
|
||
add_crumbs = (incoming_crumbs * modifier) if incoming_crumbs * modifier >= 0 else 0
|
||
return add_crumbs
|
||
|
||
async def on_message(self, message):
|
||
if message.author.id == 479210801891115009 and message.content == "botsoff":
|
||
await message.reply(embed=disnake.Embed(description=f'Бот отключён', colour=0xff9900))
|
||
await self.BotOff()
|
||
if message.guild is None:
|
||
return
|
||
if message.channel.id == self.bots_talk_protocol_channel_id:
|
||
await self.check_bt_channel()
|
||
if message.author.bot:
|
||
return
|
||
crumb_per_word = 1 / 2
|
||
text = message.content
|
||
while " " in text:
|
||
text = text.replace(" ", " ")
|
||
add_crumbs = len(text.split(" ")) * crumb_per_word
|
||
|
||
async with self.DataBaseManager.session() as session:
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['users'] as users_model:
|
||
stmt = self.DataBaseManager.select(users_model).where(users_model.id == message.author.id)
|
||
user = (await session.execute(stmt)).scalars().first()
|
||
|
||
if user is None:
|
||
user = users_model(id = message.author.id, period_messages = 1, summary_messages = 1, crumbs = (await self.give_crumbs_counter(incoming_crumbs = add_crumbs, sponsor_roles = self.sponsors, member = message.author)))
|
||
session.add(user)
|
||
period_messages, period_voice_activity = 1, 0
|
||
|
||
else:
|
||
stmt = self.DataBaseManager.update(users_model).where(users_model.id == message.author.id).values(
|
||
period_messages = users_model.period_messages + 1,
|
||
summary_messages = users_model.summary_messages + 1,
|
||
crumbs = users_model.crumbs + (await self.give_crumbs_counter(incoming_crumbs = add_crumbs, sponsor_roles = self.sponsors, member = message.author, carma = user.carma))
|
||
)
|
||
await session.execute(stmt)
|
||
period_messages, period_voice_activity = user.period_messages + 1, user.period_voice_activity
|
||
|
||
await self.LevelRolesGiver(message.author, self.CalculateLevel(period_messages, period_voice_activity))
|
||
|
||
_url_cache = {}
|
||
@tasks.loop(seconds=3600)
|
||
async def UpdatingTournamentData(self):
|
||
krekchat = await self.fetch_guild(self.krekchat.id)
|
||
tournament_channel = await krekchat.fetch_channel(1396785366882582538)
|
||
if not isinstance(tournament_channel, disnake.TextChannel):
|
||
raise
|
||
webhooks = await tournament_channel.webhooks()
|
||
webhook = webhooks[0]
|
||
|
||
if not hasattr(self, 'tournament_table_client'):
|
||
SCOPES = ["https://www.googleapis.com/auth/spreadsheets.readonly"]
|
||
creds = Credentials.from_service_account_file("secrets/krekbottable-9a40985c56e2.json", scopes=SCOPES)
|
||
self.tournament_table_client = gspread.authorize(creds)
|
||
|
||
async def shorten_url_tinyurl(url: str) -> str:
|
||
if not hasattr(self, '_url_cache'):
|
||
self._url_cache = {}
|
||
|
||
if url in self._url_cache:
|
||
return self._url_cache[url]
|
||
|
||
async with aiohttp.ClientSession() as session:
|
||
async with session.get("https://tinyurl.com/api-create.php", params={"url": url}) as resp:
|
||
resp.raise_for_status()
|
||
short_url = await resp.text()
|
||
self._url_cache[url] = short_url
|
||
return short_url
|
||
|
||
spreadsheet = self.tournament_table_client.open_by_key("16t28W1nlexAS-J26Mk18EgtPUX3344XdB18c5glA3Fg")
|
||
sheet = spreadsheet.worksheet("Ответы на форму")
|
||
data = sheet.get_all_values()
|
||
|
||
class RowData:
|
||
def __init__(self, row):
|
||
if isinstance(row, RowData):
|
||
row = row.raw_data
|
||
self.points = int(row[-2])
|
||
self.discord_id = int(row[5]) if row[5] else None
|
||
self.nick = row[7]
|
||
self.links = row[8]
|
||
self.verified = row[-4]
|
||
self.cost = int(row[-5]) if row[-5] else 0
|
||
self.raw_data = row
|
||
|
||
def __lt__(self, other):
|
||
return (self.points, self.cost) < (other.points, other.cost)
|
||
|
||
def __le__(self, other):
|
||
return (self.points, self.cost) <= (other.points, other.cost)
|
||
|
||
def __gt__(self, other):
|
||
return (self.points, self.cost) > (other.points, other.cost)
|
||
|
||
def __ge__(self, other):
|
||
return (self.points, self.cost) >= (other.points, other.cost)
|
||
|
||
async def to_str(self, num: int | None = None):
|
||
try:
|
||
member = await krekchat.fetch_member(int(row.discord_id))
|
||
except:
|
||
member = None
|
||
|
||
if num is not None:
|
||
result = f"**{num}) "
|
||
else:
|
||
result = f"**-"
|
||
num = -2
|
||
|
||
result += f"[{self.nick}]("
|
||
result += f"https://docs.google.com/spreadsheets/d/1QkaNYezumeb-QJHSZ3x1vIi5ktf0ooDklYkrP6xSMZc/edit?gid=0&range=A{num+2}"
|
||
result += ")"
|
||
if member is None:
|
||
result += "**\n"
|
||
else:
|
||
result += f" ({member.mention})**\n"
|
||
|
||
result += f"`{self.points} очков`\n"
|
||
|
||
saved_links = [("youtu.be", "YouTube"), ("youtube.com", "YouTube"), ("twitch.tv", "Twitch")]
|
||
result += f"Стримы: "
|
||
|
||
links = []
|
||
for link in self.links.split():
|
||
for saved_link in saved_links:
|
||
if saved_link[0] in link:
|
||
links.append(f"[{saved_link[1]}]({await shorten_url_tinyurl(link)})")
|
||
break
|
||
else:
|
||
links.append(f"{link}")
|
||
|
||
result += ", ".join(links) + "\n"
|
||
result += f"Проверено модерацией: " + ("✅" if self.verified == "Прошло модерацию" else "❎")
|
||
return result
|
||
|
||
class Stack:
|
||
def __init__(self, name, data):
|
||
self.name = name
|
||
self.data_stack = []
|
||
|
||
for row in data:
|
||
if isinstance(row, RowData):
|
||
self.data_stack.append(RowData(row))
|
||
else:
|
||
self.data_stack.append(row)
|
||
|
||
def __iter__(self):
|
||
return iter(self.data_stack)
|
||
|
||
class Stacks:
|
||
def __init__(self, stack_size, data):
|
||
self.data_parts = []
|
||
for i in range(1, (len(data)+(stack_size-1))//stack_size+1):
|
||
self.data_parts.append(Stack(name = f"Топ {i*stack_size}" , data = data[stack_size*(i-1):stack_size*i]))
|
||
|
||
def __iter__(self):
|
||
return iter(self.data_parts)
|
||
|
||
def __getitem__(self, key):
|
||
return self.data_parts[key]
|
||
|
||
|
||
data = [RowData(i) for i in data[2:]]
|
||
|
||
data = [i for i in sorted(data, reverse = True) if i.points > 0]
|
||
fdata = Stacks(stack_size = 5, data = data)
|
||
|
||
color = 0x211125
|
||
|
||
embeds = []
|
||
|
||
embed = disnake.Embed(description = "[Оригинал таблицы](https://docs.google.com/spreadsheets/d/1QkaNYezumeb-QJHSZ3x1vIi5ktf0ooDklYkrP6xSMZc/edit?usp=sharing)\nᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠ\n# Таблица лидеров", colour=color)
|
||
embeds.append(embed)
|
||
|
||
row_num = 1
|
||
for stack in fdata[:5]:
|
||
embed = disnake.Embed(title = f"{stack.name}", description = "ᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠᅠ", colour=color)
|
||
|
||
for row in stack:
|
||
embed.add_field(name = "", value = f"{await row.to_str(num = row_num)}", inline = False)
|
||
row_num += 1
|
||
embeds.append(embed)
|
||
|
||
embed = disnake.Embed(description = "**Эта таблица обновляется каждый час и может содержать только топ-20 участников.\n\nБолее детальную и актуальную информацию можете найти в [оригинальной таблице](https://docs.google.com/spreadsheets/d/1QkaNYezumeb-QJHSZ3x1vIi5ktf0ooDklYkrP6xSMZc/edit?usp=sharing).**", colour=color)
|
||
embeds.append(embed)
|
||
|
||
await webhook.edit_message(1405594708016889909, content = "", embeds = embeds)
|
||
|
||
@tasks.loop(seconds=60)
|
||
async def VoiceXpAdder(self):
|
||
try:
|
||
channels = await self.krekchat.fetch_channels()
|
||
async with self.DataBaseManager.session() as session:
|
||
for channel in channels:
|
||
|
||
channel = self.get_channel(channel.id)
|
||
|
||
if (not isinstance(channel, disnake.VoiceChannel)) or channel.id == 1250314784914669598:
|
||
continue
|
||
|
||
for member in channel.members:
|
||
if member.bot:
|
||
continue
|
||
add_crumbs = 5
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['users'] as users_model:
|
||
stmt = self.DataBaseManager.select(users_model).where(users_model.id == member.id)
|
||
user = (await session.execute(stmt)).scalars().first()
|
||
|
||
if user is None:
|
||
user = users_model(
|
||
id = member.id,
|
||
period_voice_activity = 60,
|
||
summary_voice_activity = 60,
|
||
crumbs = (await self.give_crumbs_counter(incoming_crumbs = add_crumbs, sponsor_roles = self.sponsors, member = member))
|
||
)
|
||
session.add(user)
|
||
period_messages, period_voice_activity = 0, 60
|
||
|
||
else:
|
||
stmt = self.DataBaseManager.update(users_model).where(users_model.id == member.id).values(
|
||
period_voice_activity = users_model.period_voice_activity + 60,
|
||
summary_voice_activity = users_model.summary_voice_activity + 60,
|
||
crumbs = users_model.crumbs + (await self.give_crumbs_counter(incoming_crumbs = add_crumbs, sponsor_roles = self.sponsors, member = member, carma = user.carma))
|
||
)
|
||
await session.execute(stmt)
|
||
period_messages, period_voice_activity = user.period_messages, user.period_voice_activity + 60
|
||
await self.LevelRolesGiver(member, self.CalculateLevel(period_messages, period_voice_activity))
|
||
|
||
except Exception as e:
|
||
self.logger.exception(f"{datetime.datetime.now().strftime('%H:%M:%S %d-%m-%Y')}:: err VoiceXpAdder: {e}")
|
||
|
||
@tasks.loop(seconds=3600)
|
||
async def CheckDataBase(self):
|
||
try:
|
||
roles_for_delete = []
|
||
async with self.DataBaseManager.session() as session:
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['roles_custom'] as roles_custom:
|
||
|
||
stmt = self.DataBaseManager.select(roles_custom).join(roles_custom.creator).options(
|
||
self.DataBaseManager.contains_eager(roles_custom.creator)
|
||
).where(roles_custom.renewal_date <= datetime.datetime.now().timestamp()).with_for_update()
|
||
roles = (await session.execute(stmt)).scalars().all()
|
||
|
||
for role in roles:
|
||
if role.renewal_enabled:
|
||
if role.creator.crumbs >= self.costrolerenewal:
|
||
async with self.DataBaseManager.models['transaction_history_crumbs'] as transaction_history_crumbs:
|
||
transaction = transaction_history_crumbs(sender_id = role.creator.id, amount = self.costrolerenewal, description = f"Содержание роли {role.id}")
|
||
session.add(transaction)
|
||
role.creator.crumbs -= self.costrolerenewal
|
||
await role.renewal_date_update(self.TimeFormater)
|
||
continue
|
||
else:
|
||
roles_for_delete.append(role.id)
|
||
async with session.begin():
|
||
async with self.DataBaseManager.models['users'] as users_model:
|
||
stmt = self.DataBaseManager.update(users_model).where(users_model.staff_salary > 0).values(
|
||
crumbs = users_model.crumbs+users_model.staff_salary
|
||
)
|
||
await session.execute(stmt)
|
||
for role_id in roles_for_delete:
|
||
await self.DeleteRole(role_id)
|
||
# создание бэкапов
|
||
backup_file = await self.DataBaseManager.pg_dump()
|
||
krekchat = await self.fetch_guild(self.krekchat.id)
|
||
backups_channel = await krekchat.fetch_channel(self.databases_backups_channel_id)
|
||
if not isinstance(backups_channel, disnake.TextChannel):
|
||
raise ValueError("backups_channel is not disnake.TextChannel")
|
||
|
||
if "Backup failed" in backup_file:
|
||
await backups_channel.send(content=backup_file)
|
||
else:
|
||
await backups_channel.send(content=f"Бэкап бд за {datetime.datetime.now()}:", file=disnake.File(backup_file))
|
||
|
||
except Exception as e:
|
||
self.logger.exception(f"err CheckDataBase: {e}")
|
||
|
||
async def init_db(debug = False):
|
||
DataBaseEngine = create_async_engine(
|
||
config.Settings().DB_URL,
|
||
pool_size=20,
|
||
max_overflow=10,
|
||
pool_recycle=300,
|
||
pool_pre_ping=True,
|
||
echo=debug,
|
||
)
|
||
async with DataBaseEngine.begin() as conn:
|
||
await conn.run_sync(DataBaseClasses['base'].metadata.create_all)
|
||
|
||
return DatabaseManager(DataBaseEngine, DataBaseClasses)
|
||
|
||
async def run_bot(bot, token, stop_event):
|
||
try:
|
||
await bot.start(token)
|
||
except Exception as e:
|
||
logger.info(f"Бот {bot.user.name if hasattr(bot, 'user') else 'Unknown'} упал с ошибкой: {e}")
|
||
stop_event.set() # Сигнализируем об остановке
|
||
|
||
async def monitor_stop(stop_event, bots):
|
||
await stop_event.wait()
|
||
logger.info(f"{datetime.datetime.now().strftime('%H:%M:%S %d-%m-%Y')}:: Получен сигнал остановки, завершаю всех ботов...")
|
||
|
||
for bot in bots:
|
||
if not bot.is_closed():
|
||
try:
|
||
await bot.close()
|
||
except Exception as e:
|
||
logger.error(f"Ошибка при закрытии бота: {e}")
|
||
|
||
await asyncio.sleep(0.1)
|
||
|
||
async def main():
|
||
stop_event = asyncio.Event()
|
||
DataBase = None
|
||
all_bots = []
|
||
admin_bot = None
|
||
try:
|
||
|
||
DataBase = await init_db()
|
||
|
||
# Инициализация ботов
|
||
admin_bot = AdminBot(DataBase, stop_event)
|
||
economy_bot = AnyBots(DataBase)
|
||
rimagochi_bot = AnyBots(DataBase)
|
||
all_bots = [economy_bot, admin_bot, rimagochi_bot]
|
||
|
||
# Загрузка когов
|
||
economy_bot.load_extension("cogs.economy")
|
||
economy_bot.load_extension("cogs.roles")
|
||
economy_bot.load_extension("cogs.designer")
|
||
admin_bot.load_extension("cogs.admin")
|
||
rimagochi_bot.load_extension("cogs.rimagochi")
|
||
|
||
# Запуск монитора остановки и ботов
|
||
monitor_task = asyncio.create_task(monitor_stop(stop_event, all_bots))
|
||
bot_tasks = [
|
||
asyncio.create_task(run_bot(economy_bot, TOKENS["KrekFunBot"], stop_event)),
|
||
asyncio.create_task(run_bot(admin_bot, TOKENS["KrekAdminBot"], stop_event)),
|
||
asyncio.create_task(run_bot(rimagochi_bot, TOKENS["KrekRimagochiBot"], stop_event))
|
||
]
|
||
|
||
await asyncio.gather(*bot_tasks, monitor_task)
|
||
|
||
except KeyboardInterrupt:
|
||
logger.info("Боты остановлены по запросу пользователя")
|
||
except Exception as e:
|
||
logger.exception(f"Произошла критическая ошибка")
|
||
finally:
|
||
if admin_bot is not None:
|
||
await admin_bot.BotOff()
|
||
|
||
for bot in all_bots:
|
||
if not bot.is_closed():
|
||
await bot.close()
|
||
|
||
if DataBase is not None:
|
||
await DataBase.close()
|
||
|
||
current_task = asyncio.current_task()
|
||
pending = [t for t in asyncio.all_tasks() if t is not current_task and not t.done()]
|
||
for task in pending:
|
||
task.cancel()
|
||
await asyncio.gather(*pending, return_exceptions=True)
|
||
|
||
await asyncio.sleep(0.1)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
asyncio.run(main()) |