Exemple #1
0
    async def on_member_join(self, member):
        collection = db["welcome"]
        data = collection.find_one({"_id": member.guild.id})
        if data != None:
            channel_id = get_field(data, "channel_id")
            text = get_field(data, "message")
            role_ids = get_field(data, "roles")

            if channel_id != None and text != None:
                channel = member.guild.get_channel(channel_id)
                if channel != None:
                    msg = switch(text, "{user}", f"{member.mention}")

                    await channel.send(msg)

            if role_ids != None:
                stored_roles = [member.guild.get_role(ID) for ID in role_ids]
                roles = []
                my_pos = member.guild.me.top_role.position

                for role in stored_roles:
                    if role != None and role.position < my_pos:
                        roles.append(role)
                del stored_roles

                await member.add_roles(*roles)
Exemple #2
0
    async def auto_role_info(self, ctx):
        collection = db["tokens"]
        result = collection.find_one({"_id": ctx.guild.id},
                                     projection={
                                         "add": True,
                                         "remove": True
                                     })
        to_add = get_field(result, "add")
        to_remove = get_field(result, "remove")

        if to_add is None or to_add == {}:
            add_desc = "Отсутствуют"
        else:
            add_desc = ""
            for id_key in to_add:
                add_desc += f"**->** <@&{id_key}> • {to_add[id_key]}+ 💰\n"

        if to_remove is None or to_remove == {}:
            remove_desc = "Отсутствуют"
        else:
            remove_desc = ""
            for id_key in to_remove:
                remove_desc += f"**<-** <@&{id_key}> • {to_remove[id_key]}+ 💰\n"

        reply = discord.Embed(title="🎫 Действия с ролями",
                              color=ctx.guild.me.color)
        reply.add_field(name="**Выдаются за токены**",
                        value=add_desc,
                        inline=False)
        reply.add_field(name="**Снимаются за токены**",
                        value=remove_desc,
                        inline=False)
        reply.set_thumbnail(url=f"{ctx.guild.icon_url}")
        await ctx.send(embed=reply)
Exemple #3
0
    async def balance(self, ctx, *, member_s=None):
        if member_s is None:
            member = ctx.author
        else:
            member = detect.member(ctx.guild, member_s)

        if member is None:
            reply = discord.Embed(
                title="💢 Упс",
                description=
                f"Вы указали {member_s}, подразумевая участника, но он не был найден",
                color=col("dr"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        else:
            collection = db["tokens"]
            result = collection.find_one(
                {
                    "_id": ctx.guild.id,
                    f"members.{member.id}": {
                        "$exists": True
                    }
                },
                projection={f"members.{member.id}": True})
            amount = get_field(result, "members", f"{member.id}")
            if amount is None:
                amount = 0

            reply = discord.Embed(title=f"Баланс {member}",
                                  description=f"**{amount}** 💰",
                                  color=member.color)
            reply.set_thumbnail(url=f"{member.avatar_url}")
            await ctx.send(embed=reply)
Exemple #4
0
async def process_auto_roles(member, data=None):
    if data is None:
        collection = db["tokens"]
        data = collection.find_one({"_id": member.guild.id},
                                   projection={
                                       "add": True,
                                       "remove": True,
                                       f"members.{member.id}": True
                                   })
    to_add = get_field(data, "add")
    to_remove = get_field(data, "remove")
    bal = get_field(data, "members", f"{member.id}")
    if to_add is None:
        to_add = {}
    if to_remove is None:
        to_remove = {}
    if bal is None:
        bal = 0

    can_be_added = []
    can_be_removed = []
    for id_key in to_add:
        if to_add[id_key] <= bal:
            if not (id_key in to_remove and to_remove[id_key] <= bal
                    and to_remove[id_key] >= to_add[id_key]):
                can_be_added.append(int(id_key))
    for id_key in to_remove:
        if to_remove[id_key] <= bal:
            can_be_removed.append(int(id_key))

    to_remove = []
    to_add = []
    for role_id in can_be_removed:
        role = member.guild.get_role(role_id)
        if role in member.roles:
            to_remove.append(role)
    for role_id in can_be_added:
        role = member.guild.get_role(role_id)
        if role is not None and role not in member.roles:
            to_add.append(role)

    await member.remove_roles(*to_remove)
    await member.add_roles(*to_add)
Exemple #5
0
    async def top(self, ctx, page="1"):
        interval = 10

        if not page.isdigit():
            reply = discord.Embed(
                title="💢 Упс",
                description=f"Номер страницы ({page}) должен быть целым числом",
                color=col("dg"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        else:
            page = int(page)
            collection = db["tokens"]
            result = collection.find_one({"_id": ctx.guild.id},
                                         projection={"members": True})
            member_list = get_field(result, "members")

            if member_list is None or member_list == {}:
                reply = discord.Embed(title="📊 Топ участников",
                                      description="🚕 🚗 🚓",
                                      color=ctx.guild.me.color)
                reply.set_thumbnail(url=f"{ctx.guild.icon_url}")
                await ctx.send(embed=reply)

            else:
                total_pairs = len(member_list)
                total_pages = (total_pairs - 1) // interval + 1
                if page > total_pages or page < 1:
                    reply = discord.Embed(
                        title="📖 Страница не найдена",
                        description=f"Всего страниц: {total_pages}")
                    reply.set_footer(text=f"{ctx.author}",
                                     icon_url=f"{ctx.author.avatar_url}")
                    await ctx.send(embed=reply)

                else:
                    member_list = [(int(key), member_list[key])
                                   for key in member_list]
                    member_list.sort(reverse=True, key=lambda pair: pair[1])
                    lower_bound = (page - 1) * interval
                    upper_bound = min(page * interval, total_pairs)

                    desc = ""
                    for i in range(lower_bound, upper_bound):
                        pair = member_list[i]
                        member = ctx.guild.get_member(pair[0])
                        desc += f"**{i+1})** {member} • **{pair[1]}** 💰\n"

                    reply = discord.Embed(title="📊 Топ участников",
                                          description=desc,
                                          color=ctx.guild.me.color)
                    reply.set_thumbnail(url=f"{ctx.guild.icon_url}")
                    await ctx.send(embed=reply)
Exemple #6
0
    async def warns(self, ctx, *, member_s=None):
        if member_s == None:
            member = ctx.author
        else:
            member = detect.member(ctx.guild, member_s)

        if member is None:
            reply = discord.Embed(
                title="💢 Упс",
                description=
                f"Вы указали {member_s}, подразумевая участника, но он не был найден",
                color=col("dr"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        else:
            collection = db["warns"]
            result = collection.find_one(
                {
                    "_id": ctx.guild.id,
                    f"{member.id}": {
                        "$exists": True
                    }
                },
                projection={f"{member.id}": True})

            member_warns = get_field(result, f"{member.id}")
            if member_warns is None:
                desc = "Отсутствуют"
                member_warns = []
            else:
                desc = ""

            reply = discord.Embed(title=f"📚 Предупреждения {member}",
                                  description=desc,
                                  color=col("o"))
            reply.set_thumbnail(url=f"{member.avatar_url}")
            for i in range(len(member_warns)):
                w = member_warns[i]
                dt = f"{w['timestamp']}"[:-10].replace("-", ".")
                mod = ctx.guild.get_member(w['mod_id'])

                reply.add_field(name=f"🔸 **{i+1}**",
                                value=(f"**Модератор:** {mod}\n"
                                       f"**Причина:** {w['reason']}\n"
                                       f"**Дата и время:** `{dt}` (UTC)\n"),
                                inline=False)

            await ctx.send(embed=reply)
Exemple #7
0
    async def unwarn(self, ctx, member_s, number):
        p = ctx.prefix
        number = number.lower()
        if not has_permissions(ctx.author, ["ban_members"]):
            reply = discord.Embed(title="❌ Недостаточно прав",
                                  description=("**Необходимые права:**\n"
                                               f"> Банить участников"),
                                  color=col("dr"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        else:
            member = detect.member(ctx.guild, member_s)
            if member is None:
                reply = discord.Embed(
                    title="💢 Упс",
                    description=
                    f"Вы указали {member_s}, подразумевая участника, но он не был найден",
                    color=col("dr"))
                reply.set_footer(text=f"{ctx.author}",
                                 icon_url=f"{ctx.author.avatar_url}")
                await ctx.send(embed=reply)

            elif number != "all" and not number.isdigit():
                reply = discord.Embed(
                    title="💢 Ошибка",
                    description=
                    (f"Номер варна должен быть целым числом или параметром `all`. Введено: {number}\n"
                     f"Подробнее: `{p}unwarn`"),
                    color=col("dr"))
                reply.set_footer(text=f"{ctx.author}",
                                 icon_url=f"{ctx.author.avatar_url}")
                await ctx.send(embed=reply)
            else:
                collection = db["warns"]
                desc = None
                if number == "all":
                    collection.find_one_and_update(
                        {
                            "_id": ctx.guild.id,
                            f"{member.id}": {
                                "$exists": True
                            }
                        }, {"$unset": {
                            f"{member.id}": ""
                        }})
                    desc = (f"**Участник:** {member}\n"
                            f"**Модератор:** {ctx.author}\n"
                            f"**Все предупреждения** сняты")
                else:
                    number = int(number)
                    result = collection.find_one(
                        {
                            "_id": ctx.guild.id,
                            f"{member.id}": {
                                "$exists": True
                            }
                        },
                        projection={f"{member.id}": True})
                    member_warns = get_field(result, f"{member.id}")

                    if member_warns is None or member_warns == []:
                        error_desc = f"У участника {member} нет предупреждений"
                    elif len(member_warns) < number or number < 1:
                        error_desc = f"Варн не найден. Всего варнов: {len(member_warns)}"
                    else:
                        member_warns.pop(number - 1)
                        collection.find_one_and_update(
                            {
                                "_id": ctx.guild.id,
                                f"{member.id}": {
                                    "$exists": True
                                }
                            }, {"$set": {
                                f"{member.id}": member_warns
                            }})
                        desc = (f"**Участник:** {member}\n"
                                f"**Модератор:** {ctx.author}\n"
                                f"**Номер:** {number}")

                if desc is None:
                    reply = discord.Embed(title="💢 Ошибка",
                                          description=error_desc)
                    reply.set_footer(text=f"{ctx.author}",
                                     icon_url=f"{ctx.author.avatar_url}")
                    await ctx.send(embed=reply)

                else:
                    log_emb = discord.Embed(title="♻ Сняты предупреждения",
                                            description=desc,
                                            color=col("dg"))
                    log_emb.set_footer(text=f"{ctx.author}",
                                       icon_url=f"{ctx.author.avatar_url}")
                    await ctx.send(embed=log_emb, delete_after=3)
                    await post_log(ctx.guild, log_emb)
                    await ctx.message.delete()
Exemple #8
0
    async def warn(self, ctx, member_s, *, reason="не указана"):
        if not has_permissions(ctx.author, ["ban_members"]):
            reply = discord.Embed(title="❌ Недостаточно прав",
                                  description=("**Необходимые права:**\n"
                                               f"> Банить участников"),
                                  color=col("dr"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        else:
            member = detect.member(ctx.guild, member_s)
            if member is None:
                reply = discord.Embed(
                    title="💢 Упс",
                    description=
                    f"Вы указали {member_s}, подразумевая участника, но он не был найден",
                    color=col("dr"))
                reply.set_footer(text=f"{ctx.author}",
                                 icon_url=f"{ctx.author.avatar_url}")
                await ctx.send(embed=reply)

            elif member.top_role.position >= ctx.author.top_role.position and ctx.author.id != ctx.guild.owner_id:
                reply = discord.Embed(
                    title="💢 Упс",
                    description="Роль этого участника не ниже Вашей",
                    color=col("dr"))
                reply.set_footer(text=f"{ctx.author}",
                                 icon_url=f"{ctx.author.avatar_url}")
                await ctx.send(embed=reply)

            else:
                collection = db["warns"]

                result = collection.find_one({
                    "_id": ctx.guild.id,
                    f"{member.id}": {
                        "$exists": True
                    }
                })
                member_warns = get_field(result, f"{member.id}")
                if member_warns is None:
                    total_warns = 0
                else:
                    total_warns = len(member_warns)

                if total_warns >= 5:
                    reply = discord.Embed(
                        title="💢 Лимит",
                        description=
                        "У участника не может быть больше **5** предупреждений",
                        color=col("dr"))
                    reply.set_footer(text=f"{ctx.author}",
                                     icon_url=f"{ctx.author.avatar_url}")
                    await ctx.send(embed=reply)

                elif total_warns >= 4:
                    sec = 24 * 3600
                    log_emb = discord.Embed(
                        title="⛔ Пользователь временно забанен",
                        description=
                        (f"**Пользователь:** {member}\n"
                         f"**Модератор:** {ctx.author}\n"
                         f"**Длительность:** {visual_delta(datetime.timedelta(seconds=sec))}\n"
                         f"**Причина:** набрал 5 или более предупреждений"),
                        color=discord.Color.red())
                    await do_tempban(member, ctx.author, sec, reason)

                    await post_log(ctx.guild, log_emb)
                    await ctx.send(embed=log_emb, delete_after=3)
                    await ctx.message.delete()
                    await try_send(member, embed=log_emb)

                    log_emb = await withdraw_tempban(ctx.guild, member.id)
                    if log_emb != None:
                        await post_log(ctx.guild, log_emb)

                else:
                    warn_json = {
                        "mod_id": ctx.author.id,
                        "reason": reason,
                        "timestamp": datetime.datetime.utcnow()
                    }

                    collection.find_one_and_update(
                        {"_id": ctx.guild.id},
                        {"$addToSet": {
                            f"{member.id}": warn_json
                        }},
                        upsert=True)

                    warn_log = discord.Embed(
                        title="🔸 Предупреждение",
                        description=(f"**Участник:** {member}\n"
                                     f"**Модератор:** {ctx.author}\n"
                                     f"**Причина:** {reason}\n"),
                        color=col("o"))
                    await ctx.send(embed=warn_log, delete_after=3)
                    await post_log(ctx.guild, warn_log)
                    await ctx.message.delete()
                    await try_send(member, embed=warn_log)
Exemple #9
0
from classes.player import Player

# tournament info
year = '2021'
tourn_id = '521'
tour_code = 'r'
sim_tourns = 60000
cut_line = 70

# download tournament field
url = f'https://statdata.pgatour.com/{tour_code}/{tourn_id}/{year}/field.json'
r = requests.get(url)
r = r.json()

# download tournament field
field = get_field(tour='PGA')
field = list(field['name'])

# get data
os.environ['AWS_DEFAULT_REGION'] = 'us-west-2'

# download data
sql = ('SELECT * FROM "golf-processed"."adjusted_sg_table_processed_all"')

stroke_data = wr.athena.read_sql_query(sql, database="golf-processed")

stroke_data = stroke_data[stroke_data['full'].isin(field)]

stroke_data['weighted'] = (stroke_data['lt_sg:tot'] *
                           .7) + (stroke_data['st_sg:tot'] * .3)
Exemple #10
0
    async def how_set(self, ctx):
        p = ctx.prefix
        if not has_permissions(ctx.author, ["administrator"]):
            reply = discord.Embed(title="❌ Недостаточно прав",
                                  description=("**Необходимые права:**\n"
                                               f"> Администратор"),
                                  color=col("dr"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        else:
            collection = db["welcome"]
            w_data = collection.find_one({"_id": ctx.guild.id})

            collection = db["levers"]
            on_off = collection.find_one({"_id": ctx.guild.id})

            wc_id = get_field(w_data, "channel_id")
            wm = get_field(w_data, "message")
            wr = get_field(w_data, "roles")

            antis_on = get_field(on_off, "antispam")
            if antis_on == None:
                antis_on = False
            stats_on = get_field(on_off, "stats_on")
            if stats_on == None:
                stats_on = False

            if wc_id == None:
                wc_desc = "Отключен"
            else:
                wc_desc = f"<#{wc_id}>"
            if wm == None:
                wm_desc = "Отсутствует"
            else:
                wm_desc = wm
            if wr == None:
                wr_desc = "> Отключены\n"
            else:
                wr_desc = ""
                for r_id in wr:
                    wr_desc += f"> <@&{r_id}>\n"

            if antis_on:
                antis_desc = "✅ Включен"
            else:
                antis_desc = "❌ Выключен"
            if stats_on:
                stats_desc = "✅ Включена"
            else:
                stats_desc = "❌ Выключена"

            reply = discord.Embed(
                title="Текущие настройки бота",
                description=("**Действия с новичками**\n"
                             "Сообщение:\n"
                             f"> {wm_desc}\n"
                             "Канал:\n"
                             f"> {wc_desc}\n"
                             "Роли:\n"
                             f"{wr_desc}\n"
                             "**Статистика сервера:**\n"
                             f"> {stats_desc}\n\n"
                             "**Антиспам:**\n"
                             f"> {antis_desc}\n\n"
                             f"Таблица ролей за токены: `{p}auto-role-info`"),
                color=col(30, 30, 130))
            reply.set_thumbnail(url=f"{ctx.guild.icon_url}")
            await ctx.send(embed=reply)
Exemple #11
0
    async def change_tokens(self, ctx, amount, *, member_s=None):
        collection = db["tokens"]
        if member_s is None:
            member = ctx.author
        else:
            member = detect.member(ctx.guild, member_s)

        result = collection.find_one({"_id": ctx.guild.id},
                                     projection={"master_role": True})
        mr_id = get_field(result, "master_role")

        if not has_roles(ctx.author, [mr_id]):
            reply = discord.Embed(title="❌ Недостаточно прав",
                                  description=("**Необходимые права:**\n"
                                               "> Администратор\n"
                                               "или\n"
                                               "> Роль переводчика токенов"),
                                  color=col("dr"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        elif member is None:
            reply = discord.Embed(
                title="💢 Упс",
                description=
                f"Вы указали {member_s}, подразумевая участника, но он не был найден",
                color=col("dr"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        elif try_int(amount) is None:
            reply = discord.Embed(
                title="💢 Упс",
                description=
                f"Аргумент \"{amount}\" должен быть целым числом, как `5` или `-5`",
                color=col("dr"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

        else:
            amount = int(amount)
            amount_desc = f"{amount}"
            if amount_desc[0] != "-":
                amount_desc = f"+{amount_desc}"

            collection.find_one_and_update(
                {"_id": ctx.guild.id},
                {"$inc": {
                    f"members.{member.id}": amount
                }},
                projection={
                    f"members.{member.id}": True,
                    "add": True,
                    "remove": True
                },
                upsert=True)
            reply = discord.Embed(
                title="♻ Выполнено",
                description=f"{amount_desc} 💰 участнику **{member}**",
                color=col("dg"))
            reply.set_footer(text=f"{ctx.author}",
                             icon_url=f"{ctx.author.avatar_url}")
            await ctx.send(embed=reply)

            await process_auto_roles(member)
Exemple #12
0
    async def on_message(self, message):
        if message.guild != None:

            if not has_permissions(message.author, ["manage_messages"]):
                server_id = message.guild.id
                collection = db["levers"]

                options = collection.find_one({"_id": server_id})
                antispam = get_field(options, "antispam")
                if antispam is None:
                    antispam = False

                if antispam:
                    global spam_buffer
                    user_id = message.author.id
                    weight = len(message.content)
                    reached_critical_point = False

                    if weight <= 10:
                        min_delay = datetime.timedelta(seconds=1)
                    elif weight >= 400:
                        min_delay = datetime.timedelta(seconds=10)
                    else:
                        min_delay = datetime.timedelta(seconds=2)

                    now = datetime.datetime.utcnow()
                    server_data = get_field(spam_buffer, server_id)
                    if server_data == None:
                        server_data = {user_id: {"last_at": now, "points": 1}}
                        spam_buffer.update([(server_id, server_data)])
                    else:
                        user_data = get_field(server_data, user_id)
                        if user_data == None:
                            spam_buffer[server_id].update([(user_id, {
                                "last_at": now,
                                "points": 1
                            })])
                        else:
                            last_at = user_data["last_at"]
                            delta = now - last_at
                            if delta < min_delay:
                                if user_data["points"] >= 4:
                                    spam_buffer[server_id].pop(user_id)
                                    reached_critical_point = True
                                else:
                                    spam_buffer[server_id][user_id][
                                        "points"] += 1
                                    spam_buffer[server_id][user_id][
                                        "last_at"] = now
                            else:
                                if user_data["points"] < 1:
                                    spam_buffer[server_id].pop(user_id)
                                else:
                                    spam_buffer[server_id][user_id][
                                        "points"] -= 1
                                    spam_buffer[server_id][user_id][
                                        "last_at"] = now

                    if reached_critical_point:
                        log_emb = discord.Embed(
                            title="🔒 Наложен автоматический мут",
                            description=
                            (f"**Участник:** {message.author}\n"
                             f"**Длительность:** {visual_delta(datetime.timedelta(seconds=3600))}\n"
                             f"**Причина:** спам"),
                            color=col("do"))
                        await do_action.mute(message.author, message.guild.me,
                                             3600, "спам")
                        await post_log(message.guild, log_emb)

                        await delete_recent(self.client,
                                            message.author,
                                            60,
                                            start_channel=message.channel)

                        await try_send(message.author, embed=log_emb)
                        log_emb = await withdraw.mute(message.author)
                        if log_emb != None:
                            await post_log(message.guild, log_emb)