async def set_guild_announcements(guild, channel, setting):
if setting == "enable":
setting = True
else:
setting = False
if guild is not None:
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
item = {
"announce": setting,
"announcechannel": channel.id,
"announcechannelname": channel.name
}
if len(results) > 0:
guildDB.update(item, ideal_guild.id == guild.id)
else:
item["id"] = guild.id
guildDB.insert(item)
return True
return False
async def set_guild_votd_time(guild, channel, time):
if len(time) != 5:
return False
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
if len(results) > 0:
if time != "clear":
guildDB.update(
{
"time": time,
"channel": channel.id,
"channel_name": channel.name
}, ideal_guild.id == guild.id)
else:
guildDB.update(aiotinydb.operations.delete("time"),
ideal_guild.id == guild.id)
guildDB.update(aiotinydb.operations.delete("channel"),
ideal_guild.id == guild.id)
guildDB.update(aiotinydb.operations.delete("channel_name"),
ideal_guild.id == guild.id)
else:
guildDB.insert({
"id": guild.id,
"time": time,
"channel": channel.id,
"channel_name": channel.name
})
return True
async def get_versions_by_acronym():
async with aiotinydb.AIOTinyDB(central.versionDB_path) as versionDB:
results = versionDB.all()
versions = []
for result in results:
versions.append(result["abbv"])
return sorted(versions)
async def is_optout(entryid):
ideal_entry = tinydb.Query()
async with aiotinydb.AIOTinyDB(optoutDB_path) as optoutDB:
result = optoutDB.search(ideal_entry.id == entryid)
if len(result) > 0:
return True
else:
return False
async def get_version(user):
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
if len(results) > 0:
if "version" in results[0]:
return results[0]["version"]
return None
async def get_guild_language(guild):
if guild is not None:
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
if len(results) > 0:
if "language" in results[0]:
return results[0]["language"]
return "english"
async def get_guild_votd_time(guild):
if guild is not None:
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
if len(results) > 0:
if "channel_name" in results[0] and "time" in results[0]:
return results[0]["channel_name"], results[0]["time"]
return None
async def get_guild_brackets(guild):
if guild is not None:
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
if len(results) > 0:
if "brackets" in results[0]:
return results[0]["brackets"]
return central.brackets
async def get_verse_numbers(user):
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
if len(results) > 0:
if "verseNumbers" in results[0]:
return results[0]["verseNumbers"]
else:
return "enable"
else:
return "enable"
async def set_version(user, version):
version = version.upper()
ideal_version = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.versionDB_path) as versionDB:
version_results = versionDB.search(ideal_version.abbv == version)
if len(version_results) > 0:
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
if len(results) > 0:
db.update({"version": version}, ideal_user.id == user.id)
else:
db.insert({"id": user.id, "version": version})
return True
return False
async def add_optout(entryid):
ideal_entry = tinydb.Query()
async with aiotinydb.AIOTinyDB(optoutDB_path) as optoutDB:
result = optoutDB.search(ideal_entry.id == entryid)
if len(result) > 0:
return False
else:
db.remove(ideal_entry.id == entryid)
guildDB.remove(ideal_entry.id == entryid)
optoutDB.insert({"id": entryid})
return True
async def set_guild_version(guild, version):
version = version.upper()
ideal_version = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.versionDB_path) as versionDB:
version_results = versionDB.search(ideal_version.abbv == version)
if len(version_results) > 0:
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
if len(results) > 0:
guildDB.update({"version": version},
ideal_guild.id == guild.id)
else:
guildDB.insert({"id": guild.id, "version": version})
return True
return False
async def run_timed_votds(bot):
await bot.wait_until_ready()
current_time = datetime.datetime.utcnow().strftime("%H:%M")
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = [
x for x in guildDB.all()
if "channel" in x and x["time"] == current_time
]
count = 0
for item in results:
if "channel" in item and "time" in item:
channel = bot.get_channel(item["channel"])
try:
version = await versions.get_guild_version(channel.guild)
lang = await languages.get_guild_language(channel.guild)
except AttributeError:
version = "RSV"
lang = "english"
if not version:
version = "RSV"
if not lang:
lang = "english"
lang = central.get_raw_language(lang)
if channel:
reference = await bibleutils.get_votd()
result = await utils.get_bible_verse(
reference, "embed", version, "enable", "enable")
if result:
try:
await channel.send(lang["votd"])
await channel.send(embed=result["embed"])
except discord.errors.Forbidden:
pass
count += 1
if count > 0:
central.log_message(
"info", 0, "votd_sched", "global",
f"Sending {str(count)} VOTDs at {current_time}...")
async def get_mode(user):
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
if len(results) > 0:
if "mode" in results[0]:
if results[0]["mode"] == "default":
return "embed"
else:
return results[0]["mode"]
else:
return "embed"
else:
return "embed"
async def set_language(user, language):
# noinspection PyBroadException
try:
if getattr(central.languages, language) is not None:
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
if len(results) > 0:
db.update({"language": language}, ideal_user.id == user.id)
else:
db.insert({"id": user.id, "language": language})
return True
except Exception:
return False
async def set_verse_numbers(user, verse_numbers):
verse_numbers = verse_numbers.lower()
if verse_numbers != "enable" and verse_numbers != "disable":
return False
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
if len(results) > 0:
db.update({"verseNumbers": verse_numbers}, ideal_user.id == user.id)
else:
db.insert({"id": user.id, "verseNumbers": verse_numbers})
return True
async def set_headings(user, headings):
headings = headings.lower()
if headings != "enable" and headings != "disable":
return False
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
if len(results) > 0:
db.update({"headings": headings}, ideal_user.id == user.id)
else:
db.insert({"id": user.id, "headings": headings})
return True
async def get_guild_announcements(guild, notice):
if guild is not None:
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
if len(results) > 0:
if "announce" in results[0]:
if not notice:
return results[0]["announcechannel"], results[0][
"announce"]
else:
return results[0]["announcechannelname"], results[0][
"announce"]
return None
async def set_mode(user, mode):
mode = mode.lower()
modes = ["default", "embed", "blockquote", "code"]
if mode not in modes:
return False
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
if len(results) > 0:
db.update({"mode": mode}, ideal_user.id == user.id)
else:
db.insert({"id": user.id, "mode": mode})
return True
async def set_guild_language(guild, language):
# noinspection PyBroadException
try:
if getattr(central.languages, language) is not None:
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
if len(results) > 0:
guildDB.update({"language": language},
ideal_guild.id == guild.id)
else:
guildDB.insert({"id": guild.id, "language": language})
return True
except Exception:
return False
async def get_language(user):
ideal_user = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.db_path) as db:
results = db.search(ideal_user.id == user.id)
languages = get_languages()
if len(results) > 0:
if "language" in results[0]:
for item in languages:
if item["object_name"] == results[0]["language"]:
if results[0]["language"] in [
"english_us", "english_uk"
]:
return "english"
return results[0]["language"]
return None
async def set_guild_brackets(guild, brackets):
if len(brackets) != 2:
return False
if brackets not in ["<>", "()", "{}", "[]"]:
return False
ideal_guild = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.guildDB_path) as guildDB:
results = guildDB.search(ideal_guild.id == guild.id)
item = {
"first": brackets[0],
"second": brackets[1]
}
if len(results) > 0:
guildDB.update({"brackets": item}, ideal_guild.id == guild.id)
else:
guildDB.insert({"id": guild.id, "brackets": item})
return True
async def run_command(ctx, command, remainder):
lang = ctx["language"]
user = ctx["author"]
guild = ctx["guild"]
channel = ctx["channel"]
args = remainder.split(" ")
if command == "biblebot":
pages = biblebot.create_biblebot_embeds(lang)
return {"level": "info", "paged": True, "pages": pages}
elif command == "search":
version = await utils.get_version(user, guild)
return await paged_commands.search(version, remainder, lang)
elif command == "versions":
return paged_commands.get_versions(lang)
elif command == "setversion":
if await versions.set_version(user, args[0]):
embed = utils.create_embed(lang["commands"]["setversion"],
lang["setversionsuccess"])
return {"level": "info", "message": embed}
else:
embed = utils.create_embed(lang["commands"]["setversion"],
lang["setversionfail"].replace(
"<versions>",
lang["commands"]["versions"]),
error=True)
return {"level": "err", "message": embed}
elif command == "setguildversion":
perms = user.guild_permissions
if not perms:
embed = utils.create_embed(lang["commands"]["setguildversion"],
lang["setguildversionnoperm"],
error=True)
return {"level": "err", "message": embed}
if str(user.id) != central.config["BibleBot"]["owner"]:
if not perms.manage_guild:
embed = utils.create_embed(lang["commands"]["setguildversion"],
lang["setguildversionnoperm"],
error=True)
return {"level": "err", "message": embed}
if await versions.set_guild_version(guild, args[0]):
embed = utils.create_embed(lang["commands"]["setguildversion"],
lang["setguildversionsuccess"])
return {"level": "info", "message": embed}
else:
embed = utils.create_embed(lang["commands"]["setguildversion"],
lang["setguildversionfail"].replace(
"<versions>",
lang["commands"]["versions"]),
error=True)
return {"level": "err", "message": embed}
elif command == "version":
version = await versions.get_version(user)
if version is not None:
response = lang["versionused"]
response = response.replace("<version>", version)
response = response.replace("<setversion>",
lang["commands"]["setversion"])
embed = utils.create_embed(lang["commands"]["version"], response)
return {"level": "info", "message": embed}
else:
response = lang["noversionused"]
response = response.replace("<setversion>",
lang["commands"]["setversion"])
embed = utils.create_embed(lang["commands"]["version"],
response,
error=True)
return {"level": "err", "message": embed}
elif command == "guildversion":
version = await versions.get_guild_version(guild)
if version is not None:
response = lang["guildversionused"]
response = response.replace("<version>", version)
response = response.replace("<setguildversion>",
lang["commands"]["setguildversion"])
embed = utils.create_embed(lang["commands"]["guildversion"],
response)
return {"level": "info", "message": embed}
else:
response = lang["noguildversionused"]
response = response.replace("<setguildversion>",
lang["commands"]["setguildversion"])
embed = utils.create_embed(lang["commands"]["guildversion"],
response,
error=True)
return {"level": "err", "message": embed}
elif command == "versioninfo":
ideal_version = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.versionDB_path) as versionDB:
results = versionDB.search(ideal_version["abbv"] == args[0])
if len(results) > 0:
response = lang["versioninfo"]
response = response.replace("<versionname>",
results[0]["name"])
def check_validity(section):
if results[0]["has" + section]:
return lang["arguments"]["yes"]
else:
return lang["arguments"]["no"]
for category in ["OT", "NT", "DEU"]:
response = response.replace(f"<has{category}>",
check_validity(category))
embed = utils.create_embed(lang["commands"]["versioninfo"],
response)
return {"level": "info", "message": embed}
else:
embed = utils.create_embed(lang["commands"]["versioninfo"],
lang["versioninfofailed"],
error=True)
return {"level": "err", "message": embed}
elif command == "setlanguage":
if await languages.set_language(user, args[0]):
embed = utils.create_embed(lang["commands"]["setlanguage"],
lang["setlanguagesuccess"])
return {"level": "info", "message": embed}
else:
embed = utils.create_embed(lang["commands"]["setlanguage"],
lang["setlanguagefail"].replace(
"<languages>",
lang["commands"]["languages"]),
error=True)
return {"level": "err", "message": embed}
elif command == "setguildlanguage":
perms = user.guild_permissions
if not perms:
embed = utils.create_embed(lang["commands"]["setguildlanguage"],
lang["setguildlanguagenoperm"],
error=True)
return {"level": "err", "message": embed}
if str(user.id) != central.config["BibleBot"]["owner"]:
if not perms.manage_guild:
embed = utils.create_embed(
lang["commands"]["setguildlanguage"],
lang["setguildlanguagenoperm"],
error=True)
return {"level": "err", "message": embed}
if await languages.set_guild_language(guild, args[0]):
embed = utils.create_embed(lang["commands"]["setguildlanguage"],
lang["setguildlanguagesuccess"])
return {"level": "info", "message": embed}
else:
description = lang["setguildlanguagefail"].replace(
"<languages>", lang["commands"]["languages"])
embed = utils.create_embed(lang["commands"]["setguildlanguage"],
description,
error=True)
return {"level": "err", "message": embed}
elif command == "language":
response = lang["languageused"]
response = response.replace("<setlanguage>",
lang["commands"]["setlanguage"])
embed = utils.create_embed(lang["commands"]["language"], response)
return {"level": "info", "message": embed}
elif command == "guildlanguage":
glang = await languages.get_guild_language(guild)
glang = central.get_raw_language(glang)
response = glang["guildlanguageused"]
response = response.replace("<setguildlanguage>",
glang["commands"]["setguildlanguage"])
embed = utils.create_embed(glang["commands"]["guildlanguage"],
response)
return {"level": "info", "message": embed}
elif command == "languages":
available_languages = await languages.get_languages()
string = ""
for item in available_languages:
if item["object_name"] != "default":
string += item["name"] + " [`" + item["object_name"] + "`]\n"
embed = utils.create_embed(lang["commands"]["languages"], string)
return {"level": "info", "message": embed}
elif command == "setguildbrackets":
perms = user.guild_permissions
if not perms:
embed = utils.create_embed(lang["commands"]["setguildbrackets"],
lang["setguildbracketsnoperm"],
error=True)
return {"level": "err", "message": embed}
if str(user.id) != central.config["BibleBot"]["owner"]:
if not perms.manage_guild:
embed = utils.create_embed(
lang["commands"]["setguildbrackets"],
lang["setguildbracketsnoperm"],
error=True)
return {"level": "err", "message": embed}
if await formatting.set_guild_brackets(guild, args[0]):
embed = utils.create_embed(lang["commands"]["setguildbrackets"],
lang["setguildbracketssuccess"])
return {"level": "info", "message": embed}
else:
embed = utils.create_embed(lang["commands"]["setguildbrackets"],
lang["setguildbracketsfail"],
error=True)
return {"level": "err", "message": embed}
elif command == "guildbrackets":
brackets_dict = await formatting.get_guild_brackets(guild)
brackets = brackets_dict["first"] + brackets_dict["second"]
response = lang["guildbracketsused"]
response = response.replace("<brackets>", brackets)
response = response.replace("<setguildbrackets>",
lang["commands"]["setguildbrackets"])
embed = utils.create_embed(lang["commands"]["guildbrackets"], response)
return {"level": "info", "message": embed}
elif command == "setvotdtime":
perms = user.guild_permissions
if not perms:
embed = utils.create_embed(lang["commands"]["setvotdtime"],
lang["setvotdtimenoperm"],
error=True)
return {"level": "err", "message": embed}
if str(user.id) != central.config["BibleBot"]["owner"]:
if not perms.manage_guild:
embed = utils.create_embed(lang["commands"]["setvotdtime"],
lang["setvotdtimenoperm"],
error=True)
return {"level": "err", "message": embed}
if await misc.set_guild_votd_time(guild, channel, args[0]):
embed = utils.create_embed(lang["commands"]["setvotdtime"],
lang["setvotdtimesuccess"])
return {"level": "info", "message": embed}
else:
embed = utils.create_embed(lang["commands"]["setvotdtime"],
lang["setvotdtimefail"],
error=True)
return {"level": "err", "message": embed}
elif command == "clearvotdtime":
perms = user.guild_permissions
if not perms:
embed = utils.create_embed(lang["commands"]["clearvotdtime"],
lang["clearvotdtimenoperm"],
error=True)
return {"level": "err", "message": embed}
if str(user.id) != central.config["BibleBot"]["owner"]:
if not perms.manage_guild:
embed = utils.create_embed(lang["commands"]["clearvotdtime"],
lang["clearvotdtimenoperm"],
error=True)
return {"level": "err", "message": embed}
if await misc.set_guild_votd_time(guild, channel, "clear"):
embed = utils.create_embed(lang["commands"]["clearvotdtime"],
lang["clearvotdtimesuccess"])
return {"level": "info", "message": embed}
elif command == "votdtime":
time_tuple = await misc.get_guild_votd_time(guild)
if time_tuple is not None:
channel, time = time_tuple
response = lang["votdtimeused"]
response = response.replace("<time>", time + " UTC")
response = response.replace("<channel>", channel)
response = response.replace("<setvotdtime>",
lang["commands"]["setvotdtime"])
response = response.replace("<clearvotdtime>",
lang["commands"]["clearvotdtime"])
embed = utils.create_embed(lang["commands"]["votdtime"], response)
return {"level": "info", "message": embed}
else:
response = lang["novotdtimeused"]
response = response.replace("<setvotdtime>",
lang["commands"]["setvotdtime"])
embed = utils.create_embed(lang["commands"]["votdtime"],
response,
error=True)
return {"level": "err", "message": embed}
elif command in ["votd", "verseoftheday"]:
verse = await bibleutils.get_votd()
mode = await formatting.get_mode(user)
version = await utils.get_version(user, guild)
headings = await formatting.get_headings(user)
verse_numbers = await formatting.get_verse_numbers(user)
return await utils.get_bible_verse(verse, mode, version, headings,
verse_numbers)
elif command == "random":
verse = await bibleutils.get_random_verse()
mode = await formatting.get_mode(user)
version = await utils.get_version(user, guild)
headings = await formatting.get_headings(user)
verse_numbers = await formatting.get_verse_numbers(user)
return await utils.get_bible_verse(verse, mode, version, headings,
verse_numbers)
elif command == "setheadings":
if await formatting.set_headings(user, args[0]):
embed = utils.create_embed(lang["commands"]["setheadings"],
lang["headingssuccess"])
return {"level": "info", "message": embed}
else:
response = lang["headingsfail"]
response = response.replace("<setheadings>",
lang["commands"]["setheadings"])
response = response.replace("<enable>",
lang["arguments"]["enable"])
response = response.replace("<disable>",
lang["arguments"]["disable"])
embed = utils.create_embed(lang["commands"]["setheadings"],
response,
error=True)
return {"level": "err", "message": embed}
elif command == "headings":
headings = await formatting.get_headings(user)
if headings == "enable":
response = lang["headings"].replace("<enabled/disabled>",
lang["enabled"])
response = response.replace("<setheadings>",
lang["commands"]["setheadings"])
embed = utils.create_embed(lang["commands"]["headings"], response)
return {"level": "info", "message": embed}
else:
response = lang["headings"].replace("<enabled/disabled>",
lang["disabled"])
response = response.replace("<setheadings>",
lang["commands"]["setheadings"])
embed = utils.create_embed(lang["commands"]["headings"], response)
return {"level": "info", "message": embed}
elif command == "setmode":
if await formatting.set_mode(user, args[0]):
embed = utils.create_embed(lang["commands"]["setmode"],
lang["modesuccess"])
return {"level": "info", "message": embed}
else:
response = lang["modefail"]
response = response.replace("<setmode>",
lang["commands"]["setmode"])
embed = utils.create_embed(lang["commands"]["setmode"],
response,
error=True)
return {"level": "err", "message": embed}
elif command == "mode":
mode = await formatting.get_mode(user)
modes = ["default", "embed", "blockquote", "code"]
if mode in modes:
response = lang["mode"].replace("<value>", mode)
response = response.replace("<setmode>",
lang["commands"]["setmode"])
embed = utils.create_embed(lang["commands"]["mode"], response)
return {"level": "info", "message": embed}
elif command == "setversenumbers":
if await formatting.set_verse_numbers(user, args[0]):
embed = utils.create_embed(lang["commands"]["setversenumbers"],
lang["versenumberssuccess"])
return {"level": "info", "message": embed}
else:
response = lang["versenumbersfail"].replace(
"<setversenumbers>", lang["commands"]["setversenumbers"])
response = response.replace("<enable>",
lang["arguments"]["enable"])
response = response.replace("<disable>",
lang["arguments"]["disable"])
embed = utils.create_embed(lang["commands"]["setversenumbers"],
response,
error=True)
return {"level": "err", "message": embed}
elif command == "versenumbers":
verse_numbers = await formatting.get_verse_numbers(user)
response = lang["versenumbers"].replace(
"<setversenumbers>", lang["commands"]["setversenumbers"])
if verse_numbers == "enable":
response = response.replace("<enabled/disabled>", lang["enabled"])
else:
response = response.replace("<enabled/disabled>", lang["disabled"])
embed = utils.create_embed(lang["commands"]["versenumbers"], response)
return {"level": "info", "message": embed}
elif command == "setannouncements":
perms = user.guild_permissions
if not perms:
embed = utils.create_embed(lang["commands"]["setannouncements"],
lang["setannouncementsnoperm"],
error=True)
return {"level": "err", "message": embed}
if not perms.manage_guild:
embed = utils.create_embed(lang["commands"]["setannouncements"],
lang["setannouncementsnoperm"],
error=True)
return {"level": "err", "message": embed}
if await misc.set_guild_announcements(guild, channel, args[0]):
embed = utils.create_embed(lang["commands"]["setannouncements"],
lang["setannouncementssuccess"])
return {"level": "info", "message": embed}
else:
response = lang["setannouncementsfail"]
response = response.replace("<setannouncements>",
lang["commands"]["setannouncements"])
response = response.replace("<enable>",
lang["arguments"]["enable"])
response = response.replace("<disable>",
lang["arguments"]["disable"])
embed = utils.create_embed(lang["commands"]["setannouncements"],
response,
error=True)
return {"level": "err", "message": embed}
elif command == "announcements":
announce_tuple = await misc.get_guild_announcements(guild, True)
if announce_tuple is not None:
channel, setting = announce_tuple
if setting:
response = lang["announcementsenabled"]
else:
response = lang["announcementsdisabled"]
response = response.replace("<channel>", channel)
response = response.replace("<setannouncements>",
lang["commands"]["setannouncements"])
embed = utils.create_embed(lang["commands"]["announcements"],
response)
return {"level": "info", "message": embed}
else:
response = lang["noannouncements"]
response = response.replace("<setannouncements>",
lang["commands"]["setannouncements"])
embed = utils.create_embed(lang["commands"]["announcements"],
response,
error=True)
return {"level": "err", "message": embed}
elif command == "users":
processed = len(ctx["self"].users)
embed = utils.create_embed(lang["commands"]["users"],
lang["users"] + ": " + str(processed))
return {"level": "info", "message": embed}
elif command == "servers":
processed = len(ctx["self"].guilds)
embed = utils.create_embed(
lang["commands"]["servers"],
lang["servers"].replace("<count>", str(processed)))
return {"level": "info", "message": embed}
elif command == "jepekula":
version = await utils.get_version(user, guild)
mode = await formatting.get_mode(user)
headings = await formatting.get_headings(user)
verse_numbers = await formatting.get_verse_numbers(user)
return await utils.get_bible_verse("Mark 9:23-24", mode, version,
headings, verse_numbers)
elif command in special.cm_commands:
return special.get_custom_message(command)
elif command == "supporters":
return special.get_supporters(lang)
elif command == "creeds":
return creeds.get_creeds(lang)
elif command in creeds.creeds:
return creeds.get_creed(command, lang)
elif command == "catechisms":
return catechisms.get_catechisms(lang)
elif command == "invite":
bot_id = ctx["self"].user.id
return {
"level":
"info",
"text":
True,
"message":
f"https://discordapp.com/oauth2/authorize?client_id={bot_id}&scope=bot&permissions=93248"
}
async def process_raw_message(cls, raw_message, sender, lang, guild):
available_versions = versions.get_versions_by_acronym()
brackets = formatting.get_guild_brackets(guild)
msg = raw_message.content
msg = " ".join(msg.splitlines())
if brackets is None:
brackets = central.brackets
if " " in msg:
verses = []
msg = utils.purify(msg.title())
results = utils.get_books(msg)
results.sort(key=lambda item: item[
1]) # sort the results based on the index that they were found
for book, index in results:
verse = utils.create_verse_object(book, index, msg,
available_versions, brackets)
if verse != "invalid" and verse is not None:
skip = False
for key, val in verse.items():
if key is "book" or key is "chapter":
if val is None or val == "None":
skip = True
if not skip:
verses.append(verse)
if len(verses) > 6:
responses = [
"spamming me, really?", "no spam pls", "be nice to me",
"such verses, many spam", "＼(º □ º l|l)/ SO MANY VERSES",
"don't spam me, i'm a good bot",
"hey buddy, get your own bot to spam",
"i'm a little robot, short and stout\n"
"stop spamming me or i'll claw your eyes out!"
]
random_index = int(math.floor(random.random() *
len(responses)))
return [{"spam": responses[random_index]}]
references = []
for _, verse in enumerate(verses):
reference = utils.create_reference_string(verse)
if reference is not None:
references.append(reference)
return_list = []
for reference in references:
version = versions.get_version(sender)
mode = formatting.get_mode(sender)
headings = formatting.get_headings(sender)
verse_numbers = formatting.get_verse_numbers(sender)
ref_split = reference.split(" | v: ")
if len(ref_split) == 2:
reference = ref_split[0]
version = ref_split[1]
if version is None or version == "REV":
version = versions.get_guild_version(guild)
if version is None or version == "REV":
version = "RSV"
ideal_version = tinydb.Query()
async with aiotinydb.AIOTinyDB(
central.versionDB_path) as versionDB:
results = versionDB.search(ideal_version.abbv == version)
if len(results) > 0:
for verse in verses:
for section in ["ot", "nt", "deu"]:
support = utils.check_section_support(
results[0], verse, reference, section,
lang)
if "ok" not in support.keys():
return [support]
biblehub_versions = ["BSB", "NHEB", "WBT"]
# bibleserver_versions = ["LUT", "LXX", "SLT", "EU"]
apibible_versions = ["KJVA"]
non_bible_gateway = biblehub_versions + apibible_versions # + bibleserver_versions
if version not in non_bible_gateway:
result = await biblegateway.get_result(
reference, version, headings, verse_numbers)
return_list.append(
utils.process_result(result, mode, reference,
version, lang))
elif version in apibible_versions:
result = await apibible.get_result(
reference, version, headings, verse_numbers)
return_list.append(
utils.process_result(result, mode, reference,
version, lang))
elif version in biblehub_versions:
result = await biblehub.get_result(
reference, version, verse_numbers)
return_list.append(
utils.process_result(result, mode, reference,
version, lang))
# elif version in bibleserver_versions:
# result = await bibleserver.get_result(reference, version, verse_numbers)
# return_list.append(utils.process_result(result, mode, reference, version, lang))
return return_list
async def run_owner_command(ctx, command, remainder):
embed = discord.Embed()
bot = ctx["self"]
lang = ctx["language"]
guild = ctx["guild"]
channel = ctx["channel"]
args = remainder.split(" ")
if command == "puppet":
message = ""
for item in args:
message += f"{item} "
if message == " " or message == "":
return
try:
await ctx["raw"].delete()
except (discord.errors.Forbidden, discord.errors.HTTPException):
pass
await channel.send(message[0:-1])
return None
elif command == "eval":
cmd = " ".join(args)
fn_name = "_eval_expr"
cmd = cmd.strip("` ")
# add a layer of indentation
cmd = "\n".join(f" {i}" for i in cmd.splitlines())
# wrap in def body
body = f"async def {fn_name}():\n{cmd}"
parsed = ast.parse(body)
body = parsed.body[0].body
utils.insert_returns(body)
env = {
'bot': ctx["self"],
'discord': discord,
'__import__': __import__,
'channel': channel,
'central': central
}
exec(compile(parsed, filename="<ast>", mode="exec"), env)
result = (await eval(f"{fn_name}()", env))
return {"level": "info", "text": True, "message": result}
elif command == "announce":
message = ""
for item in args:
message += f"{item} "
embed = utils.create_embed("Announcement",
message[0:-1],
custom_title=True)
return {"level": "info", "announcement": True, "message": embed}
elif command == "addversion":
argc = len(args)
name = ""
for i in range(0, (argc - 4)):
name += f"{args[i]} "
name = name[0:-1]
abbv = args[argc - 4]
has_ot = False
has_nt = False
has_deu = False
if args[argc - 3] == "yes":
has_ot = True
if args[argc - 2] == "yes":
has_nt = True
if args[argc - 1] == "yes":
has_deu = True
new_version = Version(name, abbv, has_ot, has_nt, has_deu)
async with aiotinydb.AIOTinyDB(central.versionDB_path) as versionDB:
versionDB.insert(new_version.to_object())
embed = utils.create_embed(lang["commands"]["addversion"],
lang["addversionsuccess"])
return {"level": "info", "message": embed}
elif command == "rmversion":
query = tinydb.Query()
async with aiotinydb.AIOTinyDB(central.versionDB_path) as versionDB:
result = versionDB.remove(query.abbv == args[0])
if result:
return {
"level": "info",
"text": True,
"message": f"Removed {result}."
}
else:
return {
"level": "err",
"text": True,
"message": f"No version available to remove."
}
elif command == "userid":
arg = ""
for item in args:
arg += f"{item} "
split = arg[0:-1].split("#")
results = "IDs matching: "
if len(split) == 2:
users = [
x for x in ctx["bot"].users
if x.name == split[0] and x.discriminator == split[1]
]
for item in users:
results += f"{str(item.id)}, "
results = results[0:-2]
else:
results += "None"
return {"level": "info", "text": True, "message": results}
elif command == "optout":
if central.is_snowflake(args[0]):
if await central.add_optout(args[0]):
return {
"level": "info",
"text": True,
"message": f"Opt out {args[0]}."
}
else:
return {
"level": "err",
"text": True,
"message": f"{args[0]} is already opt out."
}
else:
return {
"level": "err",
"text": True,
"message": "This is not an ID."
}
elif command == "unoptout":
if central.is_snowflake(args[0]):
if await central.remove_optout(args[0]):
return {
"level": "info",
"text": True,
"message": f"Unoptout {args[0]}."
}
else:
return {
"level": "err",
"text": True,
"message": f"{args[0]} is not opt out."
}
else:
return {
"level": "err",
"text": True,
"message": "This is not an ID."
}
elif command == "leave":
if len(args) > 0:
server_name = ""
for arg in args:
server_name += arg + " "
for item in ctx["bot"].guilds:
if item.name == server_name[0:-1]:
await item.leave()
return {"level": "info", "leave": True}
await channel.send("Server does not exist.")
return None
else:
await guild.leave()
return None
elif command == "quit":
await channel.send("Good night...")
try:
await bot.logout()
except:
pass
