libreremo_telegram_bot/libreremo_bot.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from telegram.ext.updater import Updater
from telegram.update import Update
from telegram import InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext.callbackcontext import CallbackContext
from telegram.ext.commandhandler import CommandHandler
from telegram.ext.messagehandler import MessageHandler
from telegram.ext.conversationhandler import ConversationHandler
from telegram.ext.callbackqueryhandler import CallbackQueryHandler
from telegram.callbackquery import CallbackQuery
from telegram.ext.filters import Filters
from libreremo_conf import TOKEN, CALIBRE_DIR, MIN_QUERY_LENGTH
import glob
import database_lib as DB
import logging

logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
             level=logging.INFO)


updater = Updater(TOKEN, use_context=True, arbitrary_callback_data=True)
db = DB.Database(CALIBRE_DIR + "metadata.db")


def start(update: Update, context: CallbackContext):
    update.message.reply_text("""
    Ciao, questo è il nuovo Bot di libreremo :),
    al momento non funzionante e' attivo solo a scopo
    di testing, ma restate connessi per aggiornamenti!!
                               """)
#        qua puoi scaricare centinaia di testi
#        universitari; /help se vuoi v.edere i
#        comandi che puoi usare.""")


def help(update: Update, context: CallbackContext):
    update.message.reply_text("""Available Commands :
    /search
    /search_by_author
    /search_by_class
    /""")
  
        
def _ask_resource_type(update, context):
    keyboard = [[InlineKeyboardButton(text="Titolo", callback_data="titolo")],
                [InlineKeyboardButton(text="Autore", callback_data="autore")],
                [InlineKeyboardButton(text="Corso di studio", callback_data="cds")]]
    reply_markup = InlineKeyboardMarkup(keyboard)
    update.message.reply_text(
        text="In base a cosa vuoi cercare il tuo libro?", 
        reply_markup=reply_markup)
    return GET_RESOURCE_TYPE


def _get_resource_type(update, context):
    query = update.callback_query
    context.user_data["resource"] = query.data
    context.bot.send_message(
        chat_id = query.message.chat_id,
        text = "quale {} stai cercando?"
        .format(context.user_data["resource"]))
    return GET_RESOURCE


def _get_resource(update, context):
    resource = update.message.text
    result_list = [];
    if (len(resource) <= MIN_QUERY_LENGTH):
        update.message.reply_text("""
        scusa non ho capito cosa vuoi cercare, prova
        ad inserire il titolo del libro per esteso,
        cosa stai cercando?""")
        return GET_RESOURCE
    
    if (context.user_data["resource"] == "titolo"):
        result_list = db.select_books_by_title(resource)
        text = "Scegli uno di questi libri"
        handler = GET_BOOK
    
    elif (context.user_data["resource"] == "autore"):
        result_list = db.select_authors(resource)
        text = "Scegli uno di questi autori"
        handler = GET_AUTHOR

    elif (context.user_data["resource"] == "cds"):
#        result_list = db.select_class(resource)
        text = "Scegli uno di questi corsi di studio"
        handler = GET_CDS

    logging.info("asked resource {res}: {txt}"
        .format(res=context.user_data["resource"], txt=resource)) 

    if not result_list:
        logging.info("cannot found result for {}".format(resource))
        update.message.reply_text("""
            Mi dispiace non ho trovato niente, controlla....""")
        return ConversationHandler.END

    reply_markup = __format_reply_markup(result_list)

    update.message.reply_text(
        text=text, 
        reply_markup=reply_markup)
    return handler       
 

def _get_author(update: Update, context: CallbackContext):
    query = update.callback_query
    result_list = db.select_books_by_author(query.data)
    if not result_list:
        logging.info("cannot find books for requested author")
        context.bot.send_message(
            chat_id = query.message.chat_id,
            text = "Mi dispiace ma non riesco a trovare libri per questo autore")
        return ConversationHandler.END
    context.bot.send_message(
        chat_id = query.message.chat_id,
        text = "scegli uno di questi libri",
        reply_markup = __format_reply_markup(result_list))
    return GET_BOOK    


def _get_cds(update: Update, context: CallbackContext):
    query = update.callback_query
#    result_list = db.select_books_by_cds(query)
    context.bot.send_message(
        chat_id = query.message.chat_id,
        text = "scegli uno di questi libri",
        reply_markup = reply_markup)
    return GET_BOOK    


def _get_book(update: Update, context: CallbackContext):
    query = update.callback_query
    chat_id = query.message.chat_id
    query.message.reply_text(
        'perfetto ti invio immediatamente il file! :)')
    try:
        filepath = CALIBRE_DIR + query.data + "/*.pdf"
        for file in glob.glob(filepath):
            with open(file, 'rb') as doc_pdf: 
                context.bot.send_document(chat_id, doc_pdf)
                logging.info("Sharing {}".format(file))
    except FileNotFoundError:
        logging.info("cannot send {}".format(filepath))
        query.message.reply_text(
           "Mi dispiace non rieco a trovare il file, prova piu' tardi")
    return ConversationHandler.END


def _cnv_stop(update: Update, context: CallbackContext):
    update.message.reply_text("ciao")
    return ConversationHandler.END


def search_by_title(update: Update, context: CallbackContext):
    update.message.reply_text("che libro stai cercando?")
    context.user_data["resource"] = "titolo"
    return GET_RESOURCE

def search_by_title_default(update: Update, context: CallbackContext):
    context.user_data["resource"] = "titolo"
    return GET_RESOURCE

def search_by_author(update: Update, context: CallbackContext):
    update.message.reply_text("di quale autore stai cercando i libri?")
    context.user_data["resource"] = "autore"
    return GET_RESOURCE

def search_by_class(update: Update, context: CallbackContext):
    update.message.reply_text("di quale corso di studio stai cercando i libri?")
    context.user_data["resource"] = "cds"
    return GET_RESOURCE


def unknown(update: Update, context: CallbackContext):
    update.message.reply_text(
        "Sorry '%s' is not a valid command" % update.message.text)


def __format_reply_markup(list_of_res):
    return InlineKeyboardMarkup([
        [InlineKeyboardButton(
            text = res.format_text(),
            callback_data = res.format_data())] 
         for res in list_of_res])



GET_RESOURCE_TYPE, ASK_RESOURCE, GET_RESOURCE, GET_BOOK, GET_AUTHOR, GET_CDS = range(6)

cnv_handler = ConversationHandler(
    entry_points = [CommandHandler('search', _ask_resource_type),
                    CommandHandler('search_by_title', search_by_title),
                    CommandHandler('search_by_author', search_by_author),
                    CommandHandler('search_by_class', search_by_class),
                    MessageHandler(Filters.text, search_by_title_default)],
    states = {
        GET_RESOURCE_TYPE: [CallbackQueryHandler(_get_resource_type)],
        GET_RESOURCE: [MessageHandler(Filters.text, _get_resource)],
        GET_AUTHOR: [CallbackQueryHandler(_get_author)],
        GET_BOOK: [CallbackQueryHandler(_get_book)],
        GET_CDS: [CallbackQueryHandler(_get_cds)]
    },
    fallbacks=[CommandHandler('stop', _cnv_stop),
               MessageHandler(Filters.command, _cnv_stop)],
)


updater.dispatcher.add_handler(cnv_handler)
updater.dispatcher.add_handler(CommandHandler('start', start))
updater.dispatcher.add_handler(CommandHandler('help', help))
updater.dispatcher.add_handler(MessageHandler(Filters.text, unknown))
updater.dispatcher.add_handler(MessageHandler(Filters.command, unknown))  # Filters out unknown commands
  
updater.start_polling()
updater.idle()