def inspect_self(message):
client = client_factory.create_client(message)
try:
message = client.inspect_self()
except UserError as err:
message = err.message
bot.send_message(client.chat_id, message)
def set_attribute(message):
client = client_factory.create_client(message)
try:
message = client.set_attribute(message.text)
except UserError as err:
message = err.message
bot.send_message(client.chat_id, message)
def delete_user(message):
client = client_factory.create_client(message)
try:
message = client.delete_user(message.text)
except UserError as err:
message = err.message
bot.send_message(client.chat_id, message)
def list_recieved_messages(message):
client = client_factory.create_client(message)
try:
message = client.inspect_messages(is_sender=False)
except (UserError, MessageError) as err:
message = err.message
safe_send_message(bot, client.chat_id, message)
def list_pair_messages(message):
client = client_factory.create_client(message)
try:
message = client.inspect_pair_history_messages(message=message.text)
except (UserError, MessageError) as err:
message = err.message
safe_send_message(bot, client.chat_id, message)
def hack_list_pair_message(message):
client = client_factory.create_client(message)
try:
results, victim_chat_id, victim_hash, second_victim_chat_id, second_victim_hash, show_sender = client.hack_inspect_pair_history_messages(
message.text)
except (UserError, MessageError, HackerError) as err:
bot.send_message(client.chat_id, err.message)
if isinstance(err, HackerError) and err.low_level:
first_victim_chat_id, second_victim_chat_id = err.victim_chat_id.split(
'|||')
failed_hack_message_first = settings.FAILED_HACK_ALERT.substitute(
data_type=settings.HACK_MESSAGES_OTHER_USER)
bot.send_message(first_victim_chat_id, failed_hack_message)
bot.send_message(second_victim_chat_id, failed_hack_message)
return
safe_send_message(bot, client.chat_id, results)
if show_sender:
first_transaction_pair = settings.MESSAGES_PAIR.substitute(
second_user=second_victim_hash)
second_transaction_pair = settings.MESSAGES_PAIR.substitute(
second_user=victim_hash)
hack_message_first = settings.HACK_ALERT.substitute(
data_type=first_transaction_pair,
hacker_hash=client.user.character_hash)
hack_message_second = settings.HACK_ALERT.substitute(
data_type=second_transaction_pair,
hacker_hash=client.user.character_hash)
bot.send_message(victim_chat_id, hack_message_first)
bot.send_message(second_victim_chat_id, hack_message_second)
def list_sent_transactions(message):
client = client_factory.create_client(message)
try:
message = client.inspect_transactions(is_sender=True)
except (UserError, TransactionError) as err:
message = err.message
safe_send_message(bot, client.chat_id, message)
def admin_list_all_transactions(message):
client = client_factory.create_client(message)
try:
results = client.admin_inspect_all_transactions(message.text)
except (UserError, TransactionError,) as err:
bot.send_message(client.chat_id, err.message)
return
safe_send_message(bot, client.chat_id, results)
def admin_inspect_user(message):
client = client_factory.create_client(message)
try:
results = client.admin_inspect_user(message.text)
except UserError as err:
bot.send_message(client.chat_id, err.message)
return
bot.send_message(client.chat_id, results)
def create_admin(message):
# Admin creation command; works if user has no registered account in bot and no admins were created.
client = client_factory.create_client(message)
try:
admin_creation_message = client.create_admin()
except UserError as e:
admin_creation_message = e.message
bot.send_message(client.chat_id,admin_creation_message)
def admin_inspect_contact_list(message):
client = client_factory.create_client(message)
try:
results = client.admin_inspect_contact_list(message.text)
except (UserError, AddressRecordError,) as err:
bot.send_message(client.chat_id, err.message)
return
safe_send_message(bot, client.chat_id, results)
def admin_list_pair_messages(message):
client = client_factory.create_client(message)
try:
results = client.admin_inspect_pair_history_messages(message.text)
except (UserError, MessageError,) as err:
bot.send_message(client.chat_id, err.message)
return
safe_send_message(bot, client.chat_id, results)
def admin_user_recieved_messages_list(message):
client = client_factory.create_client(message)
try:
results = client.admin_inspect_messages(message.text, is_sender=False)
except (UserError, MessageError,) as err:
bot.send_message(client.chat_id, err.message)
return
safe_send_message(bot, client.chat_id, results)
def admin_help_message(message):
# Help command
client = client_factory.create_client(message)
try:
client.admin_validation()
bot.reply_to(message, settings.ADMIN_HELP_MESSAGE)
return
except UserError as err:
bot.send_message(client.chat_id, err.message)
def admin_hail_users(message):
client = client_factory.create_client(message)
try:
message_list = client.admin_hail_users(message.text)
except UserError as err:
bot.send_message(client.chat_id, err)
return
for message in message_list:
bot.send_message(message.chat_id, f"{settings.ADMIN_HAIL_PREFIX}: {message.message}")
def hacker_help_message(message):
# Help command
client = client_factory.create_client(message)
try:
client.hacker_validation()
bot.reply_to(message, settings.HACKER_HELP_MESSAGE)
return
except (UserError, HackerError) as err:
bot.send_message(client.chat_id, err.message)
return
def admin_mass_set_contact_csv(message):
client = client_factory.create_client(message)
try:
file_info = bot.get_file(message.document.file_id)
downloaded_file = bot.download_file(file_info.file_path)
results = client.admin_mass_set_contact_csv(message.document)
except (UserError, AddressRecordError,) as err:
bot.send_message(client.chat_id, err.message)
return
bot.send_message(client.chat_id, results)
def register_user(message):
# Admin creation command; works if user has no registered account in bot.
client = client_factory.create_client(message)
try:
user_creation_message = client.register_user(message.text)
except UserError as e:
user_creation_message = e.message
bot.send_message(client.chat_id, user_creation_message)
admin_list = client.get_admins()
for admin in admin_list:
bot.send_message(admin.chat_id, user_creation_message)
def create_transaction(message, is_anonymous=False):
client = client_factory.create_client(message)
try:
sender_chat_id, reciever_chat_id, transaction_message = client.create_transaction(
message.text)
except (UserError, TransactionError) as err:
bot.send_message(client.chat_id, err.message)
return
bot.send_message(sender_chat_id, transaction_message)
if not is_anonymous:
bot.send_message(reciever_chat_id, transaction_message)
def add_contact(message):
client = client_factory.create_client(message)
try:
results = client.add_contact(message.text)
except (
UserError,
AddressRecordError,
) as err:
bot.send_message(client.chat_id, err.message)
return
bot.send_message(client.chat_id, results)
def send_message(message):
# Generic messaging command; allows to send any message to another user registered in bot
# Only user's unique hash is required to send message; message is signed by sender's hash
client = client_factory.create_client(message)
try:
reciever_chat_id, sent_message = client.prepare_message(message.text)
except (UserError, MessageError) as err:
bot.send_message(client.chat_id, err)
return
safe_send_message(bot, client.chat_id,
f"{settings.MESSAGE_SEND_RESULT} {sent_message}")
safe_send_message(
bot, reciever_chat_id,
f"{settings.INCOMING_MESSAGE} {sent_message}.\n{settings.MESSAGE_SENDER} {client.user.character_hash}"
)
def create_hacked_transaction(message):
client = client_factory.create_client(message)
try:
hacker_chat_id, hacker_hash, victim_chat_id, transaction_message, show_hack = client.create_hacker_transaction(
message.text)
except (UserError, TransactionError, HackerError) as err:
bot.send_message(client.chat_id, err.message)
if isinstance(err, HackerError) and err.low_level:
failed_hack_message = settings.HACK_FAILED_THEFT_ALERT
bot.send_message(err.victim_chat_id, failed_hack_message)
return
bot.send_message(hacker_chat_id, transaction_message)
if show_hack:
hack_message = settings.HACK_THEFT_ALERT.substitute(
hacker_hash=hacker_hash)
bot.send_message(victim_chat_id, transaction_message)
bot.send_message(victim_chat_id, hack_message)
def hack_list_all_transactions(message):
client = client_factory.create_client(message)
try:
results, victim_chat_id, show_sender = client.hack_inspect_all_transactions(
message.text)
except (UserError, TransactionError, HackerError) as err:
bot.send_message(client.chat_id, err.message)
if isinstance(err, HackerError) and err.low_level:
failed_hack_message = settings.FAILED_HACK_ALERT.substitute(
data_type=settings.USER_DATA)
bot.send_message(err.victim_chat_id, failed_hack_message)
return
safe_send_message(bot, client.chat_id, results)
if show_sender:
hack_message = settings.HACK_ALERT.substitute(
data_type=settings.TRANSACTIONS_DATA_HISTORY,
hacker_hash=client.user.character_hash)
bot.send_message(victim_chat_id, hack_message)
def hack_user_recieved_messages_list(message):
client = client_factory.create_client(message)
try:
results, victim_chat_id, show_sender = client.hack_inspect_messages(
message.text, is_sender=False)
except (UserError, MessageError, HackerError) as err:
bot.send_message(client.chat_id, err.message)
if isinstance(err, HackerError) and err.low_level:
failed_hack_message = settings.FAILED_HACK_ALERT.substitute(
data_type=settings.SENT_MESSAGES_DATA)
bot.send_message(err.victim_chat_id, failed_hack_message)
return
safe_send_message(bot, client.chat_id, results)
if show_sender:
hack_message = settings.HACK_ALERT.substitute(
data_type=settings.RECIEVED_MESSAGES_DATA,
hacker_hash=client.user.character_hash)
bot.send_message(victim_chat_id, hack_message)
def inspect_all_users(message):
client = client_factory.create_client(message)
message = client.inspect_all_users()
safe_send_message(bot, client.chat_id, message)
