def pizza(bot, update):
num = getAmountHelper(update.message, "pizza")
if num > 0:
user = getOrCreateUser(update.message.from_user)
createTransaction(user, -200 * num, "pizza x{}".format(num))
update.message.reply_text("Buon appetito! {}".format(num * '🍕'),
disable_notification=True)
def ice(bot, update):
num = getAmountHelper(update.message, "ice")
if num > 0:
user = getOrCreateUser(update.message.from_user)
createTransaction(user, -50 * num, "ice x{}".format(num))
update.message.reply_text("Have a sweet one! {}".format(num * '🚅'),
disable_notification=True)
def drink(bot, update):
num = getAmountHelper(update.message, "drink")
if num > 0:
user = getOrCreateUser(update.message.from_user)
createTransaction(user, -100 * num, "drink x{}".format(num))
update.message.reply_text("OK, enjoy your {}!".format(num * '🍹'),
disable_notification=True)
def payQuery(bot, update):
sender = getOrCreateUser(update.callback_query.from_user)
split = update.callback_query.data.split(" ")
if len(split) != 3:
print(split)
raise Exception("invalid callback query")
elif split[1] not in pays:
print(split)
raise Exception("invalid ID")
pay = pays[split[1]]
approved = pay.approved
disapproved = pay.disapproved
changed = False
if sender == pay.creator:
if split[2] == "disapprove":
del pays[split[1]]
pay.message.edit_text(
"Pay canceled (the creator disapproves himself).")
return
elif split[2] == "approve":
if sender not in approved:
approved.append(sender)
changed = True
if sender in disapproved:
disapproved.remove(sender)
elif split[2] == "disapprove":
if sender in approved:
approved.remove(sender)
if sender not in disapproved:
disapproved.append(sender)
changed = True
def checkList(users):
if len(users) < config['pay-min-users']:
return False
hasMember = False
for user in users:
if user['id'] in config['members']:
hasMember = True
break
return hasMember
if checkList(pay.disapproved):
del pays[split[1]]
pay.message.edit_text("DISAPPROVED\n" + str(pay))
elif checkList(pay.approved):
del pays[split[1]]
createTransaction(pay.creator, pay.amount, "pay for {}, approved by {}" \
.format(pay.reason, userListToString(pay.approved)))
pay.message.edit_text("APPROVED\n" + str(pay))
elif changed:
pay.message.edit_text(str(pay), reply_markup=pay.message_markup)
else:
update.callback_query.answer()
def water(bot, update):
num = getAmountHelper(update.message, "water")
if num > 0:
user = getOrCreateUser(update.message.from_user)
createTransaction(user, -50 * num, "water x{}".format(num))
answer = random.choice(hydrationMessages)
update.message.reply_text(answer[0].format(num * answer[1]),
disable_notification=True)
def communism(bot, update):
amount, reason = parseArgs(update.message, [ARG_AMOUNT, ARG_REST],
[None, ""],
"\nUsage: /communism <amount> [reason ...]")
sender = getOrCreateUser(update.message.from_user)
id = str(sender['id'])
if id in communisms:
update.message.reply_text("You already have a communism in progress")
return
communism = Communism(sender, amount, reason)
communism.message = update.message.reply_text(
str(communism), reply_markup=communism.message_markup)
communisms[id] = communism
def pay(bot, update):
amount, reason = parseArgs(update.message, [ARG_AMOUNT, ARG_REST],
[None, ""],
"\nUsage: /pay <amount> [reason ...]")
sender = getOrCreateUser(update.message.from_user)
id = str(sender['id'])
if id in pays:
update.message.reply_text("You already have a pay in progress")
return
pay = Pay(sender, amount, reason)
pay.message = update.message.reply_text(str(pay),
reply_markup=pay.message_markup)
pays[id] = pay
def send(bot, update):
args = parseArgs(update.message, [ARG_AMOUNT, ARG_USER], [None, None],
"\nUsage: /send <amount> <user>")
sender = getOrCreateUser(update.message.from_user)
receiver = args[1]
amount = args[0]
if sender == receiver:
update.message.reply_text("You cannot send money to yourself")
return
createTransaction(sender, -amount, "sent to {}".format(receiver['name']))
createTransaction(receiver, amount,
"received from {}".format(sender['name']))
update.message.reply_text("OK, you sent {}€ to {}" \
.format(amount / float(100), receiver['name']))
def history(bot, update):
offset, count = parseArgs(update.message, [ARG_INT, ARG_INT], [0, 10],
"\nUsage: /history [offset = 0] [count = 10]")
user = getOrCreateUser(update.message.from_user)
entries = []
with open("transactions.log", "r") as fd:
for line in fd.readlines():
entry = json.loads(line)
if entry['user'] == user['id']:
entries.insert(0, entry)
texts = []
for entry in entries[offset:offset + count]:
time = datetime.datetime.fromtimestamp(
entry['timestamp']).strftime("%Y-%m-%d %H:%M")
texts.append("{} {:.2f}€ {}".format(time, entry['diff'] / float(100),
entry['reason']))
msg = "Transaction history for {}\n{}".format(user['name'],
"\n".join(texts))
update.message.reply_text(msg, disable_notification=True)
def balance(bot, update):
user = getOrCreateUser(update.message.from_user)
balance = float(user['balance']) / 100
update.message.reply_text("Your balance is: {:.2f}€".format(balance))
def communismQuery(bot, update):
sender = getOrCreateUser(update.callback_query.from_user)
split = update.callback_query.data.split(" ")
if len(split) != 3:
print(split)
raise Exception("invalid callback query")
elif split[1] not in communisms:
print(split)
raise Exception("invalid ID")
communism = communisms[split[1]]
members = communism.members
isAdmin = sender == communism.creator
if split[2] == "join/leave":
if sender in members:
members.remove(sender)
else:
members.append(sender)
if len(members) == 0:
del communisms[split[1]]
communism.message.edit_text("Everyone left, the communism died")
else:
communism.updateText()
elif isAdmin and split[2] == "ok":
count = len(members) + communism.externs
amount = communism.amount // count
# if the amount can't be split equally eveyone pays 1 cent more
if communism.amount % count != 0:
amount = amount + 1
reason = "communism by " + communism.creator['name']
for member in members:
createTransaction(member, -amount, reason)
payout = communism.amount - communism.externs * amount
createTransaction(communism.creator, payout, reason)
del communisms[split[1]]
creator = communism.creator['name']
amountf = amount / float(100)
text = "Communism by {}\n{} paid {}\n{} received {}\n{} has to be collected from {} externs\nDescription: {}" \
.format(creator, userListToString(communism.members), amountf,
creator, payout / float(100), amountf, communism.externs, communism.reason)
communism.message.edit_text(text)
elif isAdmin and split[2] == "cancel":
del communisms[split[1]]
communism.message.edit_text("Communism canceled")
elif isAdmin and split[2] == "extern-":
if communism.externs > 0:
communism.externs -= 1
communism.updateText()
else:
update.message.reply_text("Cannot reduce externs below zero")
elif isAdmin and split[2] == "extern+":
communism.externs += 1
communism.updateText()
def parseArgs(msg, argDef, defaults, usage=""):
split = msg.text.split(" ")
result = []
error = None
offset = len(split[0]) + 1
split = split[1:]
for i, expected in enumerate(argDef):
if i < len(split):
arg = split[i]
elif i < len(defaults) and defaults[i] is not None:
result.append(defaults[i])
continue
else:
error = "Argument {} not specified".format(i)
break
if expected == ARG_TEXT:
result.append(arg)
elif expected == ARG_INT:
try:
val = int(arg)
result.append(val)
except:
error = "Argument {} should be an int but is '{}'".format(
i, arg)
break
elif expected == ARG_AMOUNT:
val, error = parseAmount(arg)
if val is None:
error = "Argument {} should be an amount but is {}".format(
i, error)
break
result.append(val)
elif expected == ARG_USER:
user = None
for entity in msg.entities:
if entity.offset == offset:
if entity.type == "mention":
user = findUserByNick(arg[1:])
break
elif entity.type == "text_mention":
user = getOrCreateUser(entity.user)
break
if user is None:
error = "Argument {} should be an user but is '{}'".format(
i, arg)
break
result.append(user)
elif expected == ARG_REST:
result.append(" ".join(split[i:]))
break
offset = offset + len(arg) + 1
if error is None:
return result
else:
error = error + usage
msg.reply_text(error)
raise Exception(error)
def drink(bot, update):
user = getOrCreateUser(update.message.from_user)
createTransaction(user, -100, "drink")
update.message.reply_text("OK, enjoy your 🍹!", disable_notification=True)
def ice(bot, update):
user = getOrCreateUser(update.message.from_user)
createTransaction(user, -50, "ice")
update.message.reply_text("Have a sweet one! 🚅", disable_notification=True)
def pizza(bot, update):
user = getOrCreateUser(update.message.from_user)
createTransaction(user, -200, "pizza")
update.message.reply_text("Buon appetito! 🍕", disable_notification=True)
def water(bot, update):
user = getOrCreateUser(update.message.from_user)
createTransaction(user, -50, "water")
update.message.reply_text(random.choice(hydrationMessages),
disable_notification=True)
