Fix issues and add remove function

app/__main__.py

@@ -4,6 +4,7 @@ from telegram.ext import CommandHandler
 
 from app import LOGGER, UPDATER, commands
 from app.conversations.add import ADD_CONV
+from app.conversations.remove import REMOVE_CONV
 
 
 def main():
@@ -18,6 +19,7 @@ def main():
 
     # conversations
     dispatcher.add_handler(ADD_CONV)
+    dispatcher.add_handler(REMOVE_CONV)
 
     UPDATER.start_polling()
     UPDATER.idle()

app/api.py

@@ -14,7 +14,6 @@ class PlayerNotFoundException(Exception):
         Exception.__init__(self, *args, **kwargs)
         LOGGER.warning('PlayerNotFoundException')
 
-
 def get_rr_player(player_id):
     """Get Rival Region player"""
     response = requests.get(
@@ -23,6 +22,7 @@ def get_rr_player(player_id):
     )
     soup = BeautifulSoup(response.text, 'html.parser')
     player = {
+        'id': player_id,
         'name': None,
         'region': None,
         'residency': None,

app/commands.py

@@ -13,17 +13,17 @@ def cmd_start(update, context):
             update.message.from_user.first_name
         )
     )
-    telegram_player = database.get_telegram_player(update.message.from_user.id)
-    if not telegram_player:
-        database.add_telegram_player(update)
-
+    telegram_account = database.get_telegram_account(update.message.from_user.id)
+    if not telegram_account:
+        database.add_telegram_account(update)
 
 def cmd_help(update, context):
     """Help command"""
     message_list = [
         '**Command list**',
-        '/add - add account to list',
-        '/accounts - list of accounts',
+        '/add - add verified account',
+        '/remove - remove verified account',
+        '/accounts - list of verified accounts',
     ]
     message = '\n'.join(message_list)
     update.message.reply_text(message, parse_mode=ParseMode.MARKDOWN)
@@ -31,9 +31,9 @@ def cmd_help(update, context):
 def cmd_accounts(update, context):
     """Return player list"""
     message_list = ['Accounts verified to this Telgeram account:']
-    telegram_player = database.get_telegram_player(update.message.from_user.id)
-    if telegram_player:
-        players = database.get_rr_players(telegram_player)
+    telegram_account = database.get_telegram_account(update.message.from_user.id)
+    if telegram_account:
+        players = database.get_rr_players(telegram_account)
     else:
         players = []
     if not players:

app/conversations/add.py

@@ -6,18 +6,20 @@ import string
 from telegram import ParseMode
 from telegram.ext import MessageHandler, CommandHandler, Filters, ConversationHandler
 
-from app import api, functions, database, HEADERS, BASE_URL, LOGGER
+from app import api, functions, database, commands, HEADERS, BASE_URL, LOGGER
 
 
 PLAYER_ID, CHOOSE, CONFIRM, VERIFICATION = range(4)
 
+def conv_start(update, context):
+    """Start conversation"""
+    LOGGER.info('"@%s" start add account conversation', update.message.from_user.username)
+    update.message.reply_text('Starting add account conversation, use /cancel to stop.')
+    return conv_ask_player_id(update, context)
+
 def conv_ask_player_id(update, context):
     """Ask player id"""
-    LOGGER.info('"@%s" start add account conversation', update.message.from_user.username)
-    update.message.reply_text(
-        'Starting add account conversation, use /cancel to stop.' +
-        ' Send me your Rival Regions account name or ID.'
-    )
+    update.message.reply_text('Send me your Rival Regions account name or ID.')
     return PLAYER_ID
 
 def conv_player_choose(update, context):
@@ -39,7 +41,7 @@ def conv_player_choose(update, context):
         player = players[0]
         player_id = player['id']
         if database.is_connected(update.message.from_user.id, player_id):
-            update.message.reply_text('Account already connected.')
+            update.message.reply_text('Account already connected, ending conversation.')
             context.user_data.clear()
             return ConversationHandler.END
         context.user_data['player_id'] = player_id
@@ -65,6 +67,8 @@ def conv_player_id_confirm(update, context):
     player_id = int(update.message.text)
     if player_id <= 25:
         player_index = player_id-1
+        if 'player_list' not in context.user_data:
+            return conv_ask_player_id(update, context)
         if player_index >= len(context.user_data['player_list']):
             update.message.reply_text('{} is not an option, try again.'.format(player_id),)
             return CHOOSE
@@ -100,12 +104,12 @@ def ask_confirmation(update, player):
     """Get account and ask for confirmation"""
     LOGGER.info(
         '"@%s" Ask for confirmation on RR player ID "%s"',
-        update.message.from_user.username, player.id
+        update.message.from_user.username, player['id']
     )
 
     message_list = [
         '*Player details*',
-        '*ID*: {}'.format(player.id),
+        '*ID*: {}'.format(player['id']),
         '*Name*: {}'.format(functions.escape_text(player['name'])),
         '*Region*: {}'.format(player['region']),
         '*Residency*: {}'.format(player['residency']),
@@ -118,7 +122,6 @@ def ask_confirmation(update, player):
     )
     update.message.reply_text('Please confirm this is your account by typing \'confirm\'.')
         
-
 def conv_verification(update, context):
     """Sending announcement"""
     update.message.reply_text(
@@ -137,7 +140,7 @@ def conv_verification(update, context):
     'Telegram user @{} tried to add this account. '.format(
         update.message.from_user.username
     ) + \
-    'Please don\'t share this code except with @rr_verification_bot on Telegram.'
+    'Don\'t share this code with anyone except @rr_verification_bot on Telegram.'
     api.send_personal_message(context.user_data['player_id'], message)
     context.user_data['verification_code'] = verification_code
     return VERIFICATION
@@ -177,10 +180,8 @@ def conv_finish(update, context):
         player_id,
     )
     database.verify_rr_player(update.message.from_user.id, player_id)
-    update.message.reply_text(
-        'Verificated your Rival Region player to Telegram. Type /accounts to see your accounts',
-        parse_mode=ParseMode.MARKDOWN
-    )
+    update.message.reply_text('Verificated your Rival Region player to Telegram')
+    commands.cmd_accounts(update, context)
     context.user_data.clear()
     return ConversationHandler.END
 
@@ -202,7 +203,7 @@ def conv_cancel(update, context):
 
 # announcement conversation
 ADD_CONV = ConversationHandler(
-    entry_points=[CommandHandler('add', conv_ask_player_id)],
+    entry_points=[CommandHandler('add', conv_start)],
     states={
         PLAYER_ID: [
             MessageHandler(Filters.regex(r'^\d*$'), conv_player_id_confirm),

app/conversations/remove.py

@@ -0,0 +1,110 @@
+"""Add player conversation"""
+
+import random
+import string
+
+from telegram import ParseMode
+from telegram.ext import MessageHandler, CommandHandler, Filters, ConversationHandler
+
+from app import api, functions, database, HEADERS, BASE_URL, LOGGER
+
+
+PLAYER_NUMBER, CHOOSE, CONFIRM, VERIFICATION = range(4)
+
+def conv_start(update, context):
+    """Start conversion"""
+    LOGGER.info('"@%s" start remove account conversation', update.message.from_user.username)
+    update.message.reply_text('Starting removal conversation, use /cancel to stop.')
+    return conv_ask_player(update, context)
+
+def conv_ask_player(update, context):
+    """Ask player id"""
+    message_list = ['Send the number of account you would like to remove:']
+    telegram_account = database.get_telegram_account(update.message.from_user.id)
+    if not telegram_account:
+        update.message.reply_text('No accounts found')
+        return ConversationHandler.END
+    players = database.get_rr_players(telegram_account)
+    if not players:
+        update.message.reply_text('No accounts found')
+        return ConversationHandler.END
+
+    context.user_data['player_list'] = players
+    if not players:
+        message_list.append('• none')
+    index = 1
+    for player in players:
+        desktop_link = '[desktop](https://rivalregions.com/#slide/profile/{})'.format(player.id)
+        mobile_link = '[mobile](https://m.rivalregions.com/#slide/profile/{})'.format(player.id)
+        message_list.append(
+            '{}: {} {} - {}'.format(
+                index,
+                functions.escape_text(player.name),
+                desktop_link,
+                mobile_link,
+            )
+        )
+        index += 1
+    message = '\n'.join(message_list)
+    update.message.reply_text(message, parse_mode=ParseMode.MARKDOWN)
+    return PLAYER_NUMBER
+
+def conv_choose_player(update, context):
+    """Ask max resource"""
+    index = int(update.message.text)
+    try:
+        player = context.user_data['player_list'][index - 1]
+    except IndexError:
+        update.message.reply_text(
+            'Number {} not found, give me another number.'.format(index)
+        )
+        return PLAYER_NUMBER
+    update.message.reply_text(
+        'Send `confirm` to remove {} from verified accounts.'.format(
+            functions.escape_text(player.name)
+        ),
+        parse_mode=ParseMode.MARKDOWN
+    )
+    context.user_data['player'] = player
+    return CONFIRM
+
+def get_player(player_id):
+    """Get player by ID"""
+    try:
+        return api.get_rr_player(player_id)
+    except api.PlayerNotFoundException:
+        return False
+
+def conv_player_confirm(update, context):
+    """Sending announcement"""
+    player = context.user_data['player']
+    LOGGER.info('"@%s" remove verified account %s', update.message.from_user.username, player.name)
+    update.message.reply_text(
+        'Removing verified account.',
+        parse_mode=ParseMode.MARKDOWN
+    )
+    database.remove_verified_player(update.message.from_user.id, player.id)
+    context.user_data.clear()
+    return ConversationHandler.END
+
+def conv_cancel(update, context):
+    """Cancel announcement"""
+    update.message.reply_text('Canceled action.')
+    context.user_data.clear()
+    return ConversationHandler.END
+
+# announcement conversation
+REMOVE_CONV = ConversationHandler(
+    entry_points=[CommandHandler('remove', conv_start)],
+    states={
+        PLAYER_NUMBER: [
+            MessageHandler(Filters.regex(r'^\d*$'), conv_choose_player),
+            MessageHandler(Filters.text, conv_ask_player),
+        ],
+        CONFIRM: [
+            MessageHandler(Filters.regex('(?i)confirm'), conv_player_confirm),
+            MessageHandler(Filters.text, conv_cancel),
+        ],
+    },
+    fallbacks=[CommandHandler('cancel', conv_cancel)]
+)

app/database.py

@@ -6,40 +6,38 @@ from app import SESSION, LOGGER
 from app.models import Player, TelegramAccount, TelegramHandle, PlayerTelegram
 
 
-def add_telegram_player(update):
-    """Add new Telegram player"""
+def add_telegram_account(update):
+    """Add new Telegram account"""
     session = SESSION()
-    telegram_player = TelegramAccount()
-    telegram_player.id = update.message.from_user.id
-    telegram_player.name = update.message.from_user.name
-    telegram_player.registration_date = datetime.now()
-    session.add(telegram_player)
+    telegram_account = TelegramAccount()
+    telegram_account.id = update.message.from_user.id
+    telegram_account.name = update.message.from_user.name
+    telegram_account.registration_date = datetime.now()
+    session.add(telegram_account)
     session.commit()
     session.close()
-    return telegram_player
+    return telegram_account
 
-def get_telegram_player(telegram_id):
-    """Get Telegram player"""
+def get_telegram_account(telegram_id):
+    """Get Telegram account"""
     session = SESSION()
-    telegram_player = _get_telegram_player(session, telegram_id)
+    telegram_account = _get_telegram_account(session, telegram_id)
     session.close()
-    return telegram_player
+    return telegram_account
 
-def get_rr_players(telegram_player):
+def get_rr_players(telegram_account):
     """Get Rival Region players associated with Telegram player"""
-    LOGGER.info(
-        '"%s" get RR players',
-        telegram_player.id,
-    )
+    LOGGER.info('"%s" get RR accounts', telegram_account.id,)
     session = SESSION()
-    players = _get_rr_players(session, telegram_player.id)
+    players = _get_rr_players(session, telegram_account.id)
+    LOGGER.info('"%s" found %s RR accounts', telegram_account.id, len(players))
     session.close()
     return players
 
 def verify_rr_player(telegram_id, player_id):
     """Verify RR player in database"""
     session = SESSION()
-    telegram_player = _get_telegram_player(session, telegram_id)
+    telegram_account = _get_telegram_account(session, telegram_id)
     players = _get_rr_players(session, telegram_id)
     for player in players:
         if player.id == player_id:
@@ -69,13 +67,26 @@ def verify_rr_player(telegram_id, player_id):
         player_id
     )
     player_telegram = PlayerTelegram()
-    player_telegram.telegram_id = telegram_player.id
+    player_telegram.telegram_id = telegram_account.id
     player_telegram.player_id = player_id
     player_telegram.from_date_time = datetime.now()
     session.add(player_telegram)
     session.commit()
     session.close()
 
+def remove_verified_player(telegram_account_id, player_id):
+    """Remove Telegram player"""
+    session = SESSION()
+    player_telegram = session.query(PlayerTelegram) \
+        .filter(PlayerTelegram.telegram_id == telegram_account_id) \
+        .filter(PlayerTelegram.player_id == player_id) \
+        .filter(PlayerTelegram.until_date_time == None) \
+        .first()
+    if player_telegram:
+        player_telegram.until_date_time = datetime.now()
+        session.commit()
+        return True
+    return False
 
 def is_connected(telegram_id, player_id):
     """Check if account is already"""
@@ -88,15 +99,14 @@ def is_connected(telegram_id, player_id):
     session.close()
     return bool(player_telegram)
 
-
-def _get_telegram_player(session, telegram_id):
-    """Return telegram_player"""
+def _get_telegram_account(session, telegram_id):
+    """Return telegram_account"""
     return session.query(TelegramAccount).get(telegram_id)
 
-def _get_rr_players(session, telegram_player_id):
+def _get_rr_players(session, telegram_account_id):
     """Get Rival Region players associated with Telegram player"""
     return session.query(Player) \
         .join(Player.player_telegram) \
-        .filter(PlayerTelegram.telegram_id == telegram_player_id) \
+        .filter(PlayerTelegram.telegram_id == telegram_account_id) \
         .filter(PlayerTelegram.until_date_time == None) \
         .all()

app/models.py

@@ -16,6 +16,7 @@ class Player(Base):
     nation = Column(String)
     registration_date = Column(Date)
 
+
 class TelegramAccount(Base):
     """Model for Telegram account"""
     __tablename__ = 'telegram_account'
@@ -23,6 +24,7 @@ class TelegramAccount(Base):
     name = Column(String)
     registration_date = Column(DateTime)
 
+
 class TelegramHandle(Base):
     """Model for Telegram handle"""
     __tablename__ = 'telegram_handle'
@@ -36,6 +38,7 @@ class TelegramHandle(Base):
         backref=backref('account_handles', lazy='dynamic')
     )
 
+
 class PlayerTelegram(Base):
     """Model for belongs to"""
     __tablename__ = 'player_telegram'