async def changebackground(ctx, background: int = None):
if 0 <= background < 37:
user_sql = session.query(User).filter_by(id=str(ctx.author.id)).first()
if user_sql:
user_sql.background_image = background
session.commit()
await ctx.send(ctx.author.mention + " Card background changed!")
def to_choose_action_edit(update, context):
context.user_data['back_func'] = to_edit_limit
limit = session.query(Limit).get(context.user_data['id_limit_to_edit'])
update.message.reply_text(text=text_to_edit_limit(session, limit),
reply_markup=keyboard_choose_action_edit,
parse_mode=telegram.ParseMode.HTML)
return States.TO_CHOOSE_EDIT_ACTION
def handler_confirm_delete_limit(update, context):
if not update.message.text == Buttons.confirm:
return
limit = session.query(Limit).get(context.user_data['id_limit_to_delete'])
session.delete(limit)
session.commit()
update.message.reply_text(text=text_delete_success())
return to_main_menu(update, context)
def to_main_menu(update, context):
user = User.get_user_by_telegram_user_id(session,
update.message.from_user.id)
limits = session.query(Limit).filter(Limit.user_id == user.id).all()
update.message.reply_text(text=text_main_menu(session, limits,
datetime.datetime.now()),
reply_markup=get_keyboard_main_menu(limits),
parse_mode=telegram.ParseMode.HTML)
return States.TO_MAIN_MENU
async def rawdata(self, ctx):
"""Gives raw data from the database on the current guild."""
guild_query = session.query(Server).filter_by(id=ctx.guild.id).first()
if guild_query:
guild_data = guild_query.__dict__
guild_data.pop('_sa_instance_state')
await ctx.send(f"```{guild_data}```")
else:
add_server(ctx.guild.id)
def handler_choose_type_transaction(update: Update, context: CallbackContext):
text = update.message.text
user = session.query(User).filter(
User.telegram_user_id == update.message.from_user.id).first()
if text == Buttons.earning:
context.user_data['transaction_adder'] = EarningAdder(user)
return to_write_money(update, context)
elif text == Buttons.consumption:
context.user_data['transaction_adder'] = ConsumptionAdder(user)
return to_write_money(update, context)
def send_message_choose_limit(update, context):
user = User.get_user_by_telegram_user_id(session,
update.message.from_user.id)
limits = session.query(Limit).filter(Limit.user_id == user.id).all()
text, ids_limits = make_text_and_dict_limits(session, limits)
context.user_data['ids_limits'] = ids_limits
update.message.reply_text(
text=text,
reply_markup=make_keyboard_choose_limits(ids_limits),
parse_mode=telegram.ParseMode.HTML)
def handler_add_category(update: Update, context: CallbackContext):
user = session.query(User).filter(
User.telegram_user_id == update.message.from_user.id).first()
if update.message.text == text_button_general_category:
context.user_data['category_limit'] = None
return to_add_amount_money(update, context)
elif update.message.text in CategoryConsumption.get_all_categories_by_text(
session, user.id):
context.user_data['category_limit'] = update.message.text
return to_add_amount_money(update, context)
def edit_type_limit(update, context):
limit_to_edit = session.query(Limit).get(
context.user_data['id_limit_to_edit'])
old_type = TypeLimit.text_type(limit_to_edit.type_limit)
new_type = TypeLimit.text_type(context.user_data['new_type'].value)
limit_to_edit.type_limit = context.user_data['new_type'].value
session.commit()
update.message.reply_text(text=text_edit_type_success(old_type, new_type),
parse_mode=telegram.ParseMode.HTML)
return to_choose_action_edit(update, context)
async def on_guild_channel_update(b, a):
guild_query = session.query(Server).filter_by(id=a.guild.id).first()
if guild_query:
nsfw_chan = get_nsfw_channel(b.guild, guild_query)
if nsfw_chan:
if nsfw_chan.id == a.id or nsfw_chan.id == b.id:
if not a.is_nsfw():
guild_query.nsfw_chan = None
session.commit()
await a.send(":underage: **NSFW has been disabled**")
def to_edit_category(update, context):
context.user_data['back_func'] = to_choose_action_edit
user = User.get_user_by_telegram_user_id(session,
update.message.from_user.id)
categories = session.query(CategoryConsumption).filter(
CategoryConsumption.user_id == user.id).all()
update.message.reply_text(
text=text_choose_edit_category(),
reply_markup=get_keyboard_category_limit(categories))
return States.TO_EDIT_CATEGORY
def get_unique_short():
count = 0
done = False
while not done and count < 100:
x = "".join(
random.choice(string.ascii_uppercase + string.ascii_lowercase +
string.digits) for _ in range(8))
url_query = session.query(ShortUrl).filter_by(short=x).first()
if not url_query:
return x
count += 1
def entry_point_statistics(update: Update, context: CallbackContext):
user = session.query(User).filter(
User.telegram_user_id == update.message.from_user.id).first()
path_to_graph = make_default_graph(user)
graph_controller = GraphController(
path_to_graph, get_lifetime_user(user, now=datetime.datetime.now()),
TypeTransaction.CONSUMPTION)
context.user_data['statistics'] = graph_controller
bot.send_photo(chat_id=update.message.from_user.id,
photo=open(path_to_graph, 'rb'),
reply_markup=reply_main_keyboard)
async def settings(self, ctx, setting: str = None):
"""View and change the settings within a guild, requires Manage Server permission to operate."""
guild_query = session.query(Server).filter_by(id=ctx.guild.id).first()
if guild_query:
if not setting:
em = discord.Embed(title="Server Settings",
description=f"For {ctx.guild.name}",
color=ctx.message.author.color)
chan_q = get_commands_channel(ctx, guild_query=guild_query)
nsfwchan_q = get_nsfw_channel(ctx, guild_query=guild_query)
if chan_q:
chan_q = chan_q.mention
else:
chan_q = "`>settings commandschannel #channelname`"
if nsfwchan_q:
nsfwchan_q = nsfwchan_q.mention
else:
nsfwchan_q = "`>settings nsfwchannel #channelname`"
em.add_field(name=":robot: Commands Channel", value=chan_q)
em.add_field(name=":underage: NSFW Channel", value=nsfwchan_q)
await ctx.send(embed=em)
elif setting == "commandschannel":
if len(ctx.message.channel_mentions) > 0:
guild_query.commands_chan = ctx.message.channel_mentions[
0].id
session.commit()
chan_mention = ctx.message.channel_mentions[0].mention
await ctx.send(
f":white_check_mark: Commands channel set to {chan_mention}"
)
else:
await ctx.send(
f":x: {ctx.author.mention} You did not provide a channel :x:"
)
elif setting == "nsfwchannel":
if len(ctx.message.channel_mentions) > 0:
if ctx.message.channel_mentions[0].is_nsfw():
guild_query.nsfw_chan = ctx.message.channel_mentions[
0].id
session.commit()
chan_mention = ctx.message.channel_mentions[0].mention
await ctx.send(
f":white_check_mark: NSFW channel set to {chan_mention}"
)
else:
await ctx.send(
f":x: {ctx.author.mention} That channel is not NSFW :x:"
)
else:
await ctx.send(
f":x: {ctx.author.mention} You did not provide a channel :x:"
)
else:
await ctx.send(":thinking: Somthing went wrong `error code 1`")
def edit_amount_money(update, context):
limit_to_edit = session.query(Limit).get(
context.user_data['id_limit_to_edit'])
old_amount_money = limit_to_edit.amount_money
new_amount_money = context.user_data['amount_money']
limit_to_edit.amount_money = new_amount_money
session.commit()
update.message.reply_text(text=text_edit_amount_money_success(
old_amount_money, new_amount_money),
parse_mode=telegram.ParseMode.HTML)
return to_choose_action_edit(update, context)
async def buildguild(self, ctx):
"""Check whether the current guild is in the database, if not, add it."""
guild_query = session.query(Server).filter_by(id=ctx.guild.id).first()
if not guild_query:
add_server(ctx.guild.id)
await ctx.send(
f":white_check_mark: {ctx.message.author.mention} Guild added to the database"
)
else:
await ctx.send(
f":x: {ctx.message.author.mention} This guild is already in the database :x:"
)
def edit_category(update, context):
user = User.get_user_by_telegram_user_id(session,
update.message.from_user.id)
limit_to_edit = session.query(Limit).get(
context.user_data['id_limit_to_edit'])
old_category = get_text_limit_category(session, limit_to_edit)
new_category = 'Общий' if context.user_data[
'category_limit'] is None else context.user_data['category_limit']
if context.user_data['category_limit'] is None:
limit_to_edit.category_id = None
else:
category = session.query(CategoryConsumption).filter(
CategoryConsumption.user_id == user.id,
CategoryConsumption.category ==
context.user_data['category_limit']).first()
limit_to_edit.category_id = category.id
session.commit()
update.message.reply_text(text=text_edit_category_success(
old_category, new_category),
parse_mode=telegram.ParseMode.HTML)
return to_choose_action_edit(update, context)
def handler_export(update: Update, context: CallbackContext):
user = session.query(User).filter(
User.telegram_user_id == update.message.from_user.id).first()
xls_maker = XlsMaker(user)
xls = xls_maker.make_xlx_file()
with tempfile.TemporaryDirectory() as tmpdirname:
save_path = os.path.join(
tmpdirname,
"{}.xlsx".format(get_lifetime_user(user, datetime.datetime.now())))
xls.save(save_path)
bot.send_document(chat_id=update.message.from_user.id,
document=open(save_path, 'rb'))
def handler_statistics(update: Update, context: CallbackContext):
query = update.callback_query
request = query.data
user = session.query(User).filter(
User.telegram_user_id == update.effective_user.id).first()
graph_controller = context.user_data.get('statistics')
if not graph_controller:
graph_controller = GraphController(
make_default_graph(user),
get_lifetime_user(user, datetime.datetime.now()),
TypeTransaction.CONSUMPTION)
context.user_data['statistics'] = graph_controller
if request == '{}earnings'.format(prefix_query_statistics):
graph_controller.update_type_transactions(TypeTransaction.EARNING)
handler_button_choose_type_transactions(update, context, user)
elif request == '{}consumptions'.format(prefix_query_statistics):
graph_controller.update_type_transactions(TypeTransaction.CONSUMPTION)
handler_button_choose_type_transactions(update, context, user)
elif request == '{}time_period'.format(prefix_query_statistics):
media_object = InputMediaPhoto(
open(graph_controller.path_to_current_graph, 'rb'))
bot.edit_message_media(chat_id=query.message.chat_id,
message_id=query.message.message_id,
media=media_object,
reply_markup=reply_keyboard_choose_time_period)
elif request == '{}yesterday'.format(prefix_query_statistics):
graph_controller.update_time_period(
get_yesterday(datetime.datetime.now()))
handler_button_choose_time_period(update, context, user)
elif request == '{}today'.format(prefix_query_statistics):
graph_controller.update_time_period(get_today(datetime.datetime.now()))
handler_button_choose_time_period(update, context, user)
elif request == '{}current_week'.format(prefix_query_statistics):
graph_controller.update_time_period(
get_current_week(datetime.datetime.now()))
handler_button_choose_time_period(update, context, user)
elif request == '{}current_month'.format(prefix_query_statistics):
graph_controller.update_time_period(
get_current_month(datetime.datetime.now()))
handler_button_choose_time_period(update, context, user)
elif request == '{}all_time'.format(prefix_query_statistics):
graph_controller.update_time_period(
get_lifetime_user(user, datetime.datetime.now()))
handler_button_choose_time_period(update, context, user)
elif request == '{}back'.format(prefix_query_statistics):
media_object = InputMediaPhoto(
open(graph_controller.path_to_current_graph, 'rb'))
bot.edit_message_media(
chat_id=update.callback_query.message.chat_id,
message_id=update.callback_query.message.message_id,
media=media_object,
reply_markup=reply_main_keyboard)
def check_all_users():
constructed = 0
user_query = session.query(User)
for user in client.users:
if not user.bot:
get_user = user_query.filter_by(id=user.id).first()
if not get_user:
constructed += 1
add_user(user.id)
else:
print("In database")
print("Done")
return constructed
async def editprofile(self, ctx, stat: str, data: int, mode: str = "add"):
"""Change data for the targeted user like Balance, Level and XP"""
target = None
if len(ctx.message.mentions) > 0:
target = ctx.message.mentions[0]
else:
target = ctx.message.author
print("Set target")
user_query = session.query(User).filter_by(id=target.id).first()
if user_query:
print("Got user")
done = False
if mode == "add":
print("adding")
if stat == "level":
print("Level")
user_query.level += data
done = True
elif stat == "xp":
print("Xp")
user_query.xp += data
done = True
elif stat == "balance":
print("Balance")
user_query.balance += data
done = True
elif mode == "set":
print("Set")
if stat == "level":
print("Level")
user_query.level = data
done = True
elif stat == "xp":
print("Xp")
user_query.xp = data
done = True
elif stat == "balance":
print("Balance")
user_query.balance = data
done = True
if done:
print("Saving")
session.commit()
await ctx.send(
":white_check_mark: Operation was completed successfully")
else:
print("Not saving")
await ctx.send(":x: You did not submit valid data :x:")
else:
print("No user")
raise UserNotFound()
def get_nsfw_channel(ctx, guild_query=None):
if not guild_query:
guild_query = session.query(Server).filter(
Server.id == ctx.guild.id).first()
if guild_query:
if guild_query.nsfw_chan:
guild = None
if type(ctx) == discord.Guild:
guild = ctx
else:
guild = ctx.guild
for chan in guild.channels:
if int(chan.id) == int(guild_query.nsfw_chan):
return chan
return None
async def on_guild_channel_delete(channel):
guild_query = session.query(Server).filter_by(id=channel.guild.id).first()
if guild_query:
updated = False
if guild_query.nsfw_chan:
if int(guild_query.nsfw_chan) == int(channel.id):
guild_query.nsfw_chan = None
updated = True
if guild_query.commands_chan:
if int(guild_query.commands_chan) == int(channel.id):
guild_query.commands_chan = None
updated = True
if updated:
session.commit()
else:
add_server(channel.guild.id)
def _fill_earnings(self):
earnings = session.query(Earning, CategoryEarning.category).filter(
Consumption.user_id == self.user.id,
CategoryEarning.id == Earning.category_id).order_by(
Earning.time_creation.asc()).all()
for index, item in enumerate(earnings):
consumption, category = item
row_number = index + 3
self.ws.cell(row=row_number,
column=5,
value=self._process_time_creation(
consumption.time_creation))
self.ws.cell(row=row_number, column=6, value=category)
self.ws.cell(row=row_number,
column=7,
value=consumption.amount_money)
def _fill_consumptions(self):
consumptions = session.query(
Consumption, CategoryConsumption.category).filter(
Consumption.user_id == self.user.id,
CategoryConsumption.id == Consumption.category_id).order_by(
Consumption.time_creation.asc()).all()
for index, item in enumerate(consumptions):
consumption, category = item
row_number = index + 3
self.ws.cell(row=row_number,
column=1,
value=self._process_time_creation(
consumption.time_creation))
self.ws.cell(row=row_number, column=2, value=category)
self.ws.cell(row=row_number,
column=3,
value=consumption.amount_money)
async def on_guild_join(guild):
"""Checks, upon joining a guild, whether it's in the database. If not, add it."""
print("Joined guild")
guild_query = session.query(Server).filter(Server.id == guild.id).first()
recognised = False
if guild_query:
recognised = True
chan = None
for lchan in guild.channels:
if type(lchan) == discord.TextChannel and not chan:
print(f"Selected {lchan.name}")
chan = lchan
if recognised:
await chan.send("Guild recognised, loading config.")
else:
await chan.send("Hi im **OakBot**, thanks for adding me!")
add_server(guild.id)
def check_all_guilds(output=False):
ns = "```"
constructed = 0
guild_query = session.query(Server)
for guild in client.guilds:
ns += f"Checking for {guild.name}:{guild.id} in database\n"
guild_get = guild_query.filter_by(id=guild.id).first()
if guild_get:
ns += "- Is in database\n"
else:
constructed += 1
ns += "- Not in database, adding\n"
add_server(guild.id)
ns += "- Added\n"
ns += f"\nConstructed {constructed} / {len(client.guilds)}```"
if output:
return constructed, ns
return constructed
def handler_to_enter_time_period(update: Update, context: CallbackContext):
text = update.message.text
if text == Buttons.cancel:
return exit_point(update, context)
if not check_right_time_period(text):
update.message.reply_text(text=text_wrong_enter_time())
return States.TO_ENTER_TIME_PERIOD
graph_controller = context.user_data['statistics']
graph_controller.update_time_period(text)
user = session.query(User).filter(
User.telegram_user_id == update.message.from_user.id).first()
update.callback_query = context.user_data['temp_callback_query']
handler_button_choose_time_period(update, context, user)
context.user_data.pop('temp_callback_query')
bot.send_message(chat_id=update.message.from_user.id,
text=text_success_change_time_period(),
reply_markup=ReplyKeyboardRemove())
return ConversationHandler.END
def add_limit_to_database(update, context):
user = User.get_user_by_telegram_user_id(session,
update.message.from_user.id)
type_limit = context.user_data['type_limit']
if context.user_data['category_limit'] is None:
category_limit = None
else:
category = session.query(CategoryConsumption).filter(
CategoryConsumption.category ==
context.user_data['category_limit'],
CategoryConsumption.user_id == user.id).first()
category_limit = category.id
amount_money = context.user_data['amount_money']
Limit.add(session,
user_id=user.id,
type_limit=type_limit.value,
category_id=category_limit,
amount_money=amount_money)
update.message.reply_text(text=text_success_add_limit())
return to_main_menu(update, context)
async def profile(self, ctx):
"""Returns profile statistics for the target user like: Balance, Level and XP."""
target = ctx.message.author
if len(ctx.message.mentions) > 0:
if ctx.message.author.id == 172780337963728897:
target = ctx.message.mentions[0]
user_query = session.query(User).filter_by(id=target.id).first()
if user_query:
em = discord.Embed(title="Profile",
description=f"For {target.name}",
color=target.color)
xp_fraction = f"`{user_query.xp}/{max_xp(user_query.level+1)}`"
level_progress = math.floor(
(user_query.xp / max_xp(user_query.level + 1)) * 1000) / 10
ns = (f"Balance: `{user_query.balance:,}`:dollar:\n"
f"Level: `{user_query.level}`\n"
f"Level Progress: {xp_fraction} ({level_progress}%)")
em.add_field(name="**Stats**", value=ns)
await ctx.send(embed=em)
else:
add_user(ctx.message.author.id)
await ctx.send("You arent in the database")
raise UserNotFound()
