bug

database_lib.py

@@ -6,7 +6,8 @@ import sqlite3 as sql3
 
 logger = logging.getLogger(__name__)
 
-class Database():
+
+class Database:
 
     def __init__(self, filename):
         self.filename = filename
@@ -31,31 +32,32 @@ class Database():
             return result_list
 
     def select_books_by_title(self, query):
-        query = self.__format_query(query)
+        query = format_query(query)
         sql = f"""
         SELECT title, author_sort, path FROM books
-        WHERE title LIKE '{query}';
+            WHERE title LIKE "{query}";
         """
         return self._execute(sql, res.book_factory)
 
     def select_books_by_author(self, query):
-        query = self.__format_query(query)
+        query = format_query(query)
         sql = f"""
         SELECT title, author_sort, path FROM books
         WHERE books.author_sort LIKE '%' || 
         (SELECT sort FROM authors 
-            WHERE sort = '{query}') || '%';
+            WHERE sort LIKE "{query}") || '%';
         """
         return self._execute(sql, res.book_factory)
 
     def select_authors(self, query):
-        query = self.__format_query(query)
+        query = format_query(query)
         sql = f"""
         SELECT name, sort FROM authors
-        WHERE name LIKE '{query}'; 
+        WHERE name LIKE "{query}"; 
         """
         return self._execute(sql, res.author_factory)
 
-    def __format_query(self, query):
+
+def format_query(query):
     formatted_query = "%" + query.replace(" ", "%") + "%"
     return formatted_query

libreremo_assets.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+INTRO = """
+Ciao, questo è il nuovo bot telegram di <b>Libreremo</b>, un progetto politico che da anni il collettivo universitario fiorentino porta avanti <b>distribuendo ogni anno centinaia di testi universitari GRATUITAMENTE</b> per contrastare la mercificazione della cultura e il carolibri.
+
+Il carolibri è da sempre, e soprattutto negli ultimi anni, un peso non indifferente per le tasche degli studenti e delle loro famiglie. Ma la nostra critica non è solo economica, pur costituendo già questa una difficoltà per tanti studenti costretti ad abbandonare gli studi. È anche politica, verso una concezione della cultura che vede quest’ultima come un bene acquistabile da chi può pagarselo, invece che un mezzo a disposizione di tutti e tutte per la propria crescita e quella della società nel suo complesso.
+Una concezione questa che, purtroppo, permea l’intero mondo dell’istruzione e si fa particolarmente pesante in università.
+
+Qua i nostri riferimenti social, stay tuned...
+<a href="https://www.facebook.com/collettivodateneofirenze">Facebook</a>
+<a href="https://www.instagram.com/collettivo_ateneo_firenze">Instagram</a>
+<a href="mailto:colpol@inventati.org">Mail ColPol</a>
+<a href="   mailto:collettivostumunifi@autistici.org">Mail Krisis</a>
+
+<b>Per cominciare a cercare</b> scrivi il titolo del libro oppure usa il menu comandi a fianco della chat o scrivi uno dei seguenti comandi:
+
+/search                           Per la ricerca generica
+/search_by_title             Per la ricerca per titolo
+/search_by_author       Per la ricerca per autore
+/help                               Se hai bisogno di aiuto
+"""
+
+HELP = """
+Ciao, questo è il nuovo bot telegram di <b>Libreremo</b>, un progetto politico che da anni il collettivo universitario fiorentino porta avanti <b>distribuendo ogni anno centinaia di testi universitari GRATUITAMENTE</b> per contrastare la mercificazione della cultura e il carolibri.
+<b>Per cominciare a cercare</b> scrivi il titolo del libro oppure usa il menu comandi a fianco della chat o scrivi uno dei seguenti comandi:
+
+/help                               Visualizza questo aiuto
+/search                           Per la ricerca generica
+/search_by_title             Per la ricerca per titolo
+/search_by_author       Per la ricerca per autore
+"""
+
+FILENOTFOUND = "Mi dispiace non ho trovato niente, prova a fare una ricerca più generica o a cercare per autore"
+
+SHORTQUERY = "Scusa non ho capito cosa vuoi cercare, prova ad inserire quello che stai cercando per esteso"

libreremo_bot.py

@@ -1,51 +1,45 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from telegram.ext.updater import Updater
-from telegram.update import Update
+import glob
+import logging
+import os.path
+
+import urllib3
+
 from telegram import InlineKeyboardButton, InlineKeyboardMarkup
+from telegram import ParseMode
 from telegram.ext.callbackcontext import CallbackContext
+from telegram.ext.callbackqueryhandler import CallbackQueryHandler
 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
+from telegram.ext.messagehandler import MessageHandler
+from telegram.ext.updater import Updater
+from telegram.update import Update
 
-logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-             level=logging.INFO)
+import database_lib as DB
+import libreremo_assets as txt
+from libreremo_conf import TOKEN, CALIBRE_DIR, MIN_QUERY_LENGTH
 
+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.""")
+    update.message.reply_text(txt.INTRO, parse_mode=ParseMode.HTML)
 
 
-def help(update: Update, context: CallbackContext):
-    update.message.reply_text("""Available Commands :
-    /search
-    /search_by_author
-    /search_by_class
-    /""")
+def show_help(update: Update, context: CallbackContext):
+    update.message.reply_text(txt.HELP, parse_mode=ParseMode.HTML)
 
 
 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")]]
+                [InlineKeyboardButton(text="\u274C Annulla \u274C", callback_data="stop")]]
     reply_markup = InlineKeyboardMarkup(keyboard)
     update.message.reply_text(
         text="In base a cosa vuoi cercare il tuo libro?",
@@ -55,46 +49,42 @@ def _ask_resource_type(update, context):
 
 def _get_resource_type(update, context):
     query = update.callback_query
+    query.answer()
+    if query.data == "stop":
+        query.edit_message_text("Ricerca annullata", None)
+        return ConversationHandler.END
     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"]))
+    query.edit_message_text(
+        text="quale <b>{}</b> stai cercando?".format(query.data),
+        parse_mode=ParseMode.HTML
+    )
     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?""")
+    result_list = []
+    if len(resource) <= MIN_QUERY_LENGTH:
+        update.message.reply_text(txt.SHORTQUERY)
+        update.message.reply_text("Cosa stai cercando?")
         return GET_RESOURCE
 
-    if (context.user_data["resource"] == "titolo"):
+    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"):
+    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....""")
+        update.message.reply_text(txt.FILENOTFOUND, parse_mode=ParseMode.HTML)
         return ConversationHandler.END
 
     reply_markup = __format_reply_markup(result_list)
@@ -107,50 +97,63 @@ def _get_resource(update, context):
 
 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")
+    query.answer()
+    if query.data == "stop":
+        query.edit_message_text("Ricerca annullata", None)
         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)
+    book_list = db.select_books_by_author(query.data)
+    if not book_list:
+        logging.info(f"cannot find books for author: {query.data}")
+        query.edit_message_text(
+            text="Mi dispiace ma non riesco a trovare libri per questo autore")
+        return ConversationHandler.END
+    query.edit_message_text(
+        text="Questi sono i libri che abbiamo per <b>{}</b>".format(
+            "".join(query.data.split(",")[::-1])),
+        reply_markup=__format_reply_markup(book_list),
+        parse_mode=ParseMode.HTML
+    )
     return GET_BOOK
 
 
 def _get_book(update: Update, context: CallbackContext):
     query = update.callback_query
+    query.answer()
+    if query.data == "stop":
+        query.edit_message_text("Ricerca annulata", None)
+        return ConversationHandler.END
     chat_id = query.message.chat_id
+    query.edit_message_reply_markup()
     query.message.reply_text(
-        'perfetto ti invio immediatamente il file! :)')
+        "Hai scelto: <b>{}</b>".format("(".join(
+            query.data.split("/", 1)[1]
+                .split("(")[:-1])),
+        parse_mode=ParseMode.HTML
+    )
+    query.message.reply_text(
+        'Stiamo caricando il file, sii paziente se il tuo libro non arriva subito')
+    filepath = CALIBRE_DIR + query.data
+    if os.path.isdir(filepath + "/splitted"):
+        filepath = filepath + "/splitted"
     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)
+        for file in glob.glob(filepath + "/*.pdf"):
+            with open(file, 'rb') as doc:
+                context.bot.send_document(chat_id, doc, timeout=120)
                 logging.info("Sharing {}".format(file))
-    except FileNotFoundError:
+    except urllib3.exceptions.HTTPError as e:  # cannot handle exception
+        logging.error(e)
+        query.message.reply_text(
+            "Abbiamo qualche problema di connessione, ritenta più tardi")
+    except Exception as e:
         logging.info("cannot send {}".format(filepath))
+        logging.error(e)
         query.message.reply_text(
-           "Mi dispiace non rieco a trovare il file, prova piu' tardi")
+            "Non riesco a mandarti il file, riprova più tardi")
     return ConversationHandler.END
 
 
 def _cnv_stop(update: Update, context: CallbackContext):
-    update.message.reply_text("ciao")
+    #   context.bot.edit_message_reply_markup()
     return ConversationHandler.END
 
 
@@ -159,60 +162,71 @@ def search_by_title(update: Update, context: CallbackContext):
     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
+    return _get_resource(update, context)
+
 
 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)
+        "{} non è un comando valido, prova con /help".format(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])
+    inline_keyboard = [[InlineKeyboardButton(
+        text=res.format_text(), callback_data=res.format_data())]
+        for res in list_of_res]
+    inline_keyboard.append([InlineKeyboardButton(
+        text="\u274C Annulla \u274C", callback_data="stop")])
+    return InlineKeyboardMarkup(inline_keyboard)
 
 
+def handle_error(update: Update, context: CallbackContext):
+    context.bot.send_message(
+        chat_id=update.callback_query.message.chat_id,
+        text="Oh no, qualcosa è andato storto, riprova più tardi...")
+    logging.error(context.error)
+    return ConversationHandler.END
 
-GET_RESOURCE_TYPE, ASK_RESOURCE, GET_RESOURCE, GET_BOOK, GET_AUTHOR, GET_CDS = range(6)
+
+GET_RESOURCE_TYPE, ASK_RESOURCE, GET_RESOURCE, GET_BOOK, GET_AUTHOR = range(5)
 
 cnv_handler = ConversationHandler(
-    entry_points = [CommandHandler('search', _ask_resource_type),
+    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)],
+    states={
+        GET_RESOURCE_TYPE: [CallbackQueryHandler(_get_resource_type), MessageHandler(Filters.text, _cnv_stop)],
         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
+def main():
+    updater = Updater(TOKEN, use_context=True, arbitrary_callback_data=True)
+
+    updater.dispatcher.add_handler(CommandHandler('start', start))
+    updater.dispatcher.add_handler(CommandHandler('help', show_help))
+    updater.dispatcher.add_handler(cnv_handler)
+    updater.dispatcher.add_handler(MessageHandler(Filters.command, unknown))  # Filters out unknown commands
+
+    updater.dispatcher.add_error_handler(handle_error)
+
+    updater.start_polling()
+    updater.idle()
+
 
-updater.start_polling()
-updater.idle()
+if __name__ == '__main__':
+    main()

libreremo_res.py

@@ -10,6 +10,7 @@ class ResourceInterface:
                 callable(subclass.format_data) or
                 NotImplemented)
 
+
 class Author(ResourceInterface):
 
     def __init__(self, author, sort):
@@ -22,6 +23,7 @@ class Author(ResourceInterface):
     def format_data(self):
         return self.sort
 
+
 class Book(ResourceInterface):
 
     def __init__(self, title, author, file):
@@ -35,6 +37,7 @@ class Book(ResourceInterface):
     def format_data(self):
         return self.file
 
+
 class CorsoDiStudio(ResourceInterface):
 
     def __init__(self, cds):
@@ -50,9 +53,9 @@ class CorsoDiStudio(ResourceInterface):
 def book_factory(cursor, row):
     return Book(row[0], row[1], row[2])
 
+
 def author_factory(cursor, row):
     return Author(row[0], row[1])
 
-#def cds_factory(cursor, row):
+# def cds_factory(cursor, row):
 #    pass
-