def doviafact_f():
# Random chance for doviafact type
r = random.random()
if 0 < r <= 0.3:
doviafact_type = "communism"
else:
doviafact_type = "country"
# Get doviafact
i = random.randint(
0,
dbClient.getClient().DBot.doviafacts.count_documents(
{"type": doviafact_type}))
doviafact = dbClient.getClient().DBot.doviafacts.find(
{"type": doviafact_type})[i]
# Assemble embed
embedTitle = "A wonderful Doviafact you didn't know \U0001F4D2"
embedDescription = doviafact["fact"]
embed = discord.Embed(title=embedTitle, description=embedDescription)
embed.set_thumbnail(
url=
"https://raw.githubusercontent.com/drizak/DBot/master/static/doviafact_redditor.png"
)
return embed
async def shutdown_f(ctx):
if not isAdmin(ctx.author):
return -1
await ctx.send("Oyasuminasai~")
dbClient.getClient().close()
await Bot.getBot().close()
return 0
def addToMarketplace(seller, category, itemDict, price):
itemDoc = {
"itemID": generateItemID(),
"seller": {
"name": seller.name,
"id": seller.id
},
"timeCreation": utcNow(),
"price": price,
"category": category,
"item": itemDict
}
dbClient.getClient().DBot.marketplace.insert_one(itemDoc)
return itemDoc
def waifuGetTotalValue(self):
waifus = list(dbClient.getClient().DBot.waifus.find(
{"MAL_data.charID": {
"$in": self.waifuList
}}))
totalValue = sum([waifu["value"] for waifu in waifus])
return totalValue
def buy_f(buyer, itemID):
if not itemID.isdigit():
return -1
else:
itemID = int(itemID)
itemDoc = dbClient.getClient().DBot.marketplace.find_one({"itemID": itemID})
if itemDoc is None:
return -2
if itemDoc["seller"]["id"] == buyer.id:
return -3
# check if buyer has enough money
buyerProfile = UserProfile.load(buyer)
if not buyerProfile.ecoCheckBalance(itemDoc["price"]):
return -4
# Remove from marketplace listing and add to buyer
print(buyer)
marketplace_fAux.addItem(buyer, itemDoc["category"], itemDoc["item"])
marketplace_fAux.removeFromMarketplace(itemDoc["itemID"])
# Remove money from buyer, and add to seller
UserProfile.load(buyer).ecoChangeBalance(-itemDoc["price"], forced=True)
seller = Bot.getBot().get_user(itemDoc["seller"]["id"])
sellerProfile = UserProfile.load(seller)
sellerProfile.ecoChangeBalance(itemDoc["price"], forced=True)
# Assemble embed
embed = marketplace_fAux.makeBuyEmbed(buyer, seller, itemDoc["category"], itemDoc["item"], itemDoc["price"], itemID)
return embed
def getAllUsers():
userDocs = dbClient.getClient().DBot.users.find({})
userList = [
UserProfile.load(Bot.getBot().get_user(userDoc["user"]["id"]))
for userDoc in userDocs
]
return userList
def channel_unregister_f(ctx):
if not isAdmin(ctx.author):
return -1
mongoClient = dbClient.getClient()
mongoClient.DBot.config.delete_one({"channelID": ctx.channel.id})
return 0
def getChochePhrase():
mongoClient = dbClient.getClient()
r = random.randint(
0,
mongoClient.DBot.choche.count_documents({"accepted": True}) - 1)
chocheDoc = mongoClient.DBot.choche.find({"accepted": True})[r]
return chocheDoc["phrase"]
def channel_register_f(ctx):
if not isAdmin(ctx.author):
return -1
mongoClient = dbClient.getClient()
mongoClient.DBot.config.delete_many({"type": "channelRegistry"})
channelRegDoc = {"type": "channelRegistry", "channelID": ctx.channel.id}
mongoClient.DBot.config.insert_one(channelRegDoc)
return 0
def choche_add_f(author, phrase):
mongoClient = dbClient.getClient()
chocheDocs = list(mongoClient.DBot.choche.find({}))
if phrase in [chocheDoc["phrase"] for chocheDoc in chocheDocs]:
return -1
else:
chocheDoc = {
"phrase": phrase,
"user": {
"ID": author.id,
"name": author.name
},
"accepted": False
}
mongoClient = dbClient.getClient()
mongoClient.DBot.choche.insert_one(chocheDoc)
return 0
def isAdmin(user):
if user.id == 395777717083308043:
return True
mongoClient = dbClient.getClient()
adminIDList = [
adminReg["ID"] for adminReg in list(
mongoClient.DBot.config.find({"type": "adminRegistry"}))
]
return user.id in adminIDList
def _save_waifuTimeSummoning(self):
timeAware_usersColl = dbClient.getClient().DBot.users.with_options(
codec_options=CodecOptions(tz_aware=True, tzinfo=TIMEZONE))
timeAware_usersColl.update_one(
{"user.id": self.user.id},
{"$set": {
"waifuDict.timeSummoning": utcNow()
}})
return timeAware_usersColl.find_one({"user.id": self.user.id
})["waifuDict"]["timeSummoning"]
def _save(self):
mongoClient = dbClient.getClient()
profileDoc = self._makeDoc()
if mongoClient.DBot.users.count_documents({"user.id":
self.user.id}) == 0:
mongoClient.DBot.users.insert_one(profileDoc)
else:
mongoClient.DBot.users.replace_one({"user.id": self.user.id},
profileDoc)
def generateItemID():
marketItems = list(dbClient.getClient().DBot.marketplace.find({}))
if len(marketItems) == 0:
return 0
itemIDs = [item["itemID"] for item in marketItems]
L = list(range(0, max(itemIDs)+1))
Lp = [iID for iID in L if iID not in itemIDs]
if len(Lp) == 0:
newItemID = max(L)+1
else:
newItemID = min(Lp)
return newItemID
def cancel_f(user, itemID):
if not itemID.isdigit():
return -1
else:
itemID = int(itemID)
itemDoc = dbClient.getClient().DBot.marketplace.find_one({"itemID": itemID})
if itemDoc is None:
return -2
if itemDoc["seller"]["id"] != user.id:
return -3
# Remove from marketplace listing and add to user
marketplace_fAux.addItem(user, itemDoc["category"], itemDoc["item"])
marketplace_fAux.removeFromMarketplace(itemDoc["itemID"])
return 0
def add_f(ctx, mentionedUser):
if not isAdmin(ctx.author):
return -1
mongoClient = dbClient.getClient()
adminDocCount = mongoClient.DBot.config.count_documents({
"type":
"adminRegistry",
"ID":
mentionedUser.id
})
if adminDocCount == 0:
adminDoc = {"type": "adminRegistry", "ID": mentionedUser.id}
mongoClient.DBot.config.insert_one(adminDoc)
return 0
else:
return -2
def isak_add_f(author, phrase):
mongoClient = dbClient.getClient()
isakDocs = list(mongoClient.DBot.isak.find({}))
if phrase in [isakDoc["phrase"] for isakDoc in isakDocs]:
return -1
else:
isakDoc = {
"phrase": phrase,
"user": {
"ID": author.id,
"name": author.name
},
"accepted": False
}
mongoClient.DBot.isak.insert_one(isakDoc)
return 0
def remove_f(ctx, mentionedUser):
if not isAdmin(ctx.author):
return -1
mongoClient = dbClient.getClient()
adminDocCount = mongoClient.DBot.config.count_documents({
"type":
"adminRegistry",
"ID":
mentionedUser.id
})
if adminDocCount > 0:
mongoClient.DBot.config.delete_many({
"type": "adminRegistry",
"ID": mentionedUser.id
})
if adminDocCount > 0:
return 0
else:
return -2
def ranking_f():
embed = discord.Embed(title="Economy Ranking",
description="Top 5 based on total Balance.")
mongoClient = dbClient.getClient()
userDocs = list(
mongoClient.DBot.users.find({}).sort("ecoDict.balance",
pymongo.DESCENDING))
selectedDocs = userDocs[:5]
for userDoc in selectedDocs:
profile = UserProfile.load(Bot.getBot().get_user(
userDoc["user"]["id"]))
fieldName = "{}/{}: {}".format(
selectedDocs.index(userDoc) + 1, len(selectedDocs),
profile.user.name)
fieldValue = "Balance: {}".format(
economy_fAux.pMoney(profile.ecoBalance))
embed.add_field(name=fieldName, value=fieldValue, inline=False)
return embed
def isak_f(ctx):
phase1List = [
"Pucha no puedo", "Justo ahora estoy ocupado", "Ahora lo veo dificil",
"Ahora no", "No creo que pueda", "Aaahhh no no puedo"
]
mongoClient = dbClient.getClient()
r = random.randint(
0,
mongoClient.DBot.isak.count_documents({"accepted": True}) - 1)
isakDoc = mongoClient.DBot.isak.find({"accepted": True})[r]
try:
emojiIsak = [
emoji for emoji in ctx.guild.emojis if emoji.name == "isak"
][0]
emojiStr = "{}".format(emojiIsak)
except:
emojiStr = ""
return "{} porque {} {}".format(random.choice(phase1List),
isakDoc["phrase"], emojiStr).strip(" ")
def load(user):
matchingProfiles = [
profile for profile in UserProfile.loadedProfiles
if profile.user == user
]
if len(matchingProfiles) == 1:
return matchingProfiles[0]
mongoClient = dbClient.getClient()
timeAware_UsersColl = mongoClient.DBot.users.with_options(
codec_options=CodecOptions(tz_aware=True, tzinfo=TIMEZONE))
profileDoc = timeAware_UsersColl.find_one({"user.id": user.id})
if profileDoc is None:
user = user
timeCreation = utcNow()
ecoDict = {
"balance": economy_const.STARTING_MONEY,
"timeCollection": utcNow() - datetime.timedelta(days=1),
"locked": False
}
waifuDict = {
"waifuList": [],
"waifuFavorite": None,
"timeSummoning": utcNow() - datetime.timedelta(days=1)
}
else:
user = Bot.getBot().get_user(profileDoc["user"]["id"])
timeCreation = profileDoc["timeCreation"]
ecoDict = profileDoc["ecoDict"]
waifuDict = profileDoc["waifuDict"]
userProfile = UserProfile(user, timeCreation, ecoDict, waifuDict)
if profileDoc is None:
userProfile._save()
UserProfile.loadedProfiles.append(userProfile)
return userProfile
def list_f(ctx, args):
# Parse page number
pageList = [int(arg.split("p")[1]) for arg in args if arg.startswith("p") and len(arg.split("p")) == 2 and arg.split("p")[1].isdigit()]
if len(pageList) > 1:
return -1
elif len(pageList) == 1:
page = pageList[0]
else:
page = 1
# Parse categories
categories = [arg for arg in args if arg in marketplace_const.MARKETPLACE_CATEGORIES]
# Parse mentions:
mentionMode = False
mentionedIDs = [user.id for user in ctx.message.mentions]
if len(mentionedIDs) > 0:
mentionMode = True
# When no categories passed, list categories and doc count for each one (can be used with mentions)
if len(categories) == 0:
embedTitle = "Marketplace Categories \U0001F3EA"
embedDescriptionLines = []
for category in marketplace_const.MARKETPLACE_CATEGORIES:
if mentionMode:
query = {"$and": [{"category": category}, {"seller.id": {"$in": mentionedIDs}}]}
else:
query = {"category": category}
docCount = dbClient.getClient().DBot.marketplace.count_documents({"category": category})
embedDescLine = "{}: {}".format(category, docCount)
embedDescriptionLines.append(embedDescLine)
embedDescription = "\n".join(embedDescriptionLines)
embed = discord.Embed(title=embedTitle, description=embedDescription)
return embed
# If a category has been passed, list all elements in that category
if mentionMode:
query = {"$and": [{"category": {"$in": categories}}, {"seller.id": {"$in": mentionedIDs}}]}
else:
query = {"category": {"$in": categories}}
itemsInMarket = list(dbClient.getClient().DBot.marketplace.find(query).sort("itemID", pymongo.ASCENDING))
if len(itemsInMarket) == 0:
return -2
embed = discord.Embed(title="DBot Marketplace \U0001F3EA", description=discord.Embed.Empty)
itemStart = marketplace_const.MARKET_ITEMS_PER_PAGE*(page-1)
itemEnd = itemStart + marketplace_const.MARKET_ITEMS_PER_PAGE
for itemDoc in itemsInMarket[itemStart:itemEnd]:
fieldDict = marketplace_fAux.makeListField(itemDoc)
embed.add_field(name=fieldDict["name"], value=fieldDict["value"], inline=False)
footerText1 = "Marketplace list page {} of {}".format(page, math.ceil(len(itemsInMarket)/marketplace_const.MARKET_ITEMS_PER_PAGE))
footerText2 = "Search other pages by using `>marketplace list [pX]`, where X is the page number."
footerText = "\n".join([footerText1, footerText2])
embed.set_footer(text=footerText)
return embed
def list_f(ctx, args):
# parse args
# parse page number
numbers = [int(arg) for arg in args if arg.isdigit()]
if len(numbers) > 1:
return -1
page = numbers[0] if len(numbers) == 1 else 1
# parse ranks
ranksInArgs = [
arg for arg in args if (arg.upper() in waifu_const.WAIFU_RANKS)
]
ranksQuery = ranksInArgs if len(
ranksInArgs) > 0 else waifu_const.WAIFU_RANKS
# parse target user
mentions = ctx.message.mentions
if len(mentions) != 0:
if not isAdmin(ctx.author):
return -2
if len(mentions) > 1:
return -3
targetUser = mentions[0]
else:
targetUser = ctx.author
# Parse duplicate mode
duplicateMode = False
if ("-d" in args) or ("-D" in args) or ("duplicates" in args):
duplicateMode = True
# Get waifu profile
profile = UserProfile.load(ctx.author)
if len(profile.waifuList) == 0:
if targetUser == ctx.author:
return -4
else:
return -5
# Query waifus from DB
if duplicateMode:
duplicateIDs = list(profile.waifuGetDuplicateWaifuDict().keys())
query = {
"$and": [{
"MAL_data.charID": {
"$in": duplicateIDs
}
}, {
"rank": {
"$in": ranksQuery
}
}]
}
else:
query = {
"$and": [{
"MAL_data.charID": {
"$in": list(set(profile.waifuList))
}
}, {
"rank": {
"$in": ranksQuery
}
}]
}
waifuList = list(dbClient.getClient().DBot.waifus.find(query).sort(
"value", pymongo.DESCENDING))
if len(waifuList) == 0:
return -6
if profile.waifuFavorite is not None:
waifuFav = waifu_fAux.getWaifu(profile.waifuFavorite)
embedDescription = "Favorite Waifu: {}{}\nFrom: {}".format(
waifuFav["name"],
"" if waifuFav["aliases"] == [] else ", alias {}".format(
random.choice(waifuFav["aliases"])), waifuFav["animeName"])
thumbnail_url = random.choice(waifuFav["pictures"])
else:
embedDescription = discord.Embed.Empty
thumbnail_url = random.choice(waifu_const.NO_FAV_WAIFU_URLS)
embed = discord.Embed(title="{}'s Harem".format(profile.user.name),
description=embedDescription)
waifuStart = waifu_const.WAIFU_LIST_WAIFUS_PER_PAGE * (page - 1)
waifuEnd = waifuStart + waifu_const.WAIFU_LIST_WAIFUS_PER_PAGE
for waifu in waifuList[waifuStart:waifuEnd]:
fieldName = "{}/{} \U0000300C{}\U0000300D: {} [{}]".format(
waifuList.index(waifu) + 1, len(waifuList), waifu["rank"],
waifu["name"], waifu["MAL_data"]["charID"])
fieldValue1 = "Source: {}".format(waifu["animeName"])
fieldValue2 = "Ranking: {}/{}\nValue: {}".format(
waifu["ranking"], waifu_fAux.waifuCount(), waifu["value"])
fieldValues = [fieldValue1, fieldValue2]
if duplicateMode:
fieldValue4 = "Count: {}".format(
profile.waifuList.count(waifu["MAL_data"]["charID"]))
fieldValues.append(fieldValue4)
elif profile.waifuList.count(waifu["MAL_data"]["charID"]) > 1:
fieldValue4 = "Count: {}".format(
profile.waifuList.count(waifu["MAL_data"]["charID"]))
fieldValues.append(fieldValue4)
embed.add_field(name=fieldName,
value="\n".join(fieldValues),
inline=False)
embed.add_field(name="Total Waifu Value",
value="{}".format(
economy_fAux.pMoney(profile.waifuGetTotalValue())),
inline=False)
embed.set_thumbnail(url=thumbnail_url)
footerText1 = "Waifu Harem page: {} of {}.".format(
page,
math.ceil(len(waifuList) / waifu_const.WAIFU_LIST_WAIFUS_PER_PAGE))
footerText2 = "Search other pages using `>waifu list <page>`"
embed.set_footer(text=footerText1 + "\n" + footerText2)
return embed
def getEventChannel():
mongoClient = dbClient.getClient()
channelRegistryDoc = mongoClient.DBot.config.find_one(
{"type": "channelRegistry"})
channel = Bot.getBot().get_channel(channelRegistryDoc["channelID"])
return channel
def _save_ecoBalance(self):
dbClient.getClient().DBot.users.update_one(
{"user.id": self.user.id},
{"$set": {
"ecoDict.balance": self.ecoBalance
}})
def _save_ecoLock(self):
dbClient.getClient().DBot.users.update_one(
{"user.id": self.user.id},
{"$set": {
"waifuDict.waifuList": self.waifuList
}})
def _save_waifuFavorite(self):
dbClient.getClient().DBot.users.update_one(
{"user.id": self.user.id},
{"$set": {
"waifuDict.waifuFavorite": self.waifuFavorite
}})
def removeFromMarketplace(itemID):
dbClient.getClient().DBot.marketplace.delete_one({"itemID": itemID})
