Slixfeed/slixfeed/sqlitehandler.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""

TODO

1) Table feeds:
    category
    type (atom, rdf, rss0.9. rss2 etc.)

2) Function mark_all_read for entries of given feed

3) Statistics

"""

from asyncio import Lock
from bs4 import BeautifulSoup
from datetime import date
# from slixfeed.confighandler import get_value_default
import confighandler as confighandler
# from slixfeed.datahandler import join_url
import datahandler as datahandler
from datetimehandler import current_time, rfc2822_to_iso8601
from sqlite3 import connect, Error

# from eliot import start_action, to_file
# # with start_action(action_type="list_feeds()", db=db_file):
# # with start_action(action_type="last_entries()", num=num):
# # with start_action(action_type="get_feeds()"):
# # with start_action(action_type="remove_entry()", source=source):
# # with start_action(action_type="search_entries()", query=query):
# # with start_action(action_type="check_entry()", link=link):

# aiosqlite
DBLOCK = Lock()

CURSORS = {}

def create_connection(db_file):
    """
    Create a database connection to the SQLite database
    specified by db_file.

    Parameters
    ----------
    db_file : str
        Path to database file.

    Returns
    -------
    conn : object
        Connection object or None.
    """
    conn = None
    try:
        conn = connect(db_file)
        return conn
    except Error as e:
        print(e)
    return conn


def create_tables(db_file):
    """
    Create SQLite tables.

    Parameters
    ----------
    db_file : str
        Path to database file.
    """
    with create_connection(db_file) as conn:
        feeds_table_sql =(
            "CREATE TABLE IF NOT EXISTS feeds ("
            "id INTEGER PRIMARY KEY,"
            "name TEXT,"
            "address TEXT NOT NULL,"
            "enabled INTEGER NOT NULL,"
            "scanned TEXT,"
            "updated TEXT,"
            "status INTEGER,"
            "valid INTEGER"
            ");"
            )
        entries_table_sql = (
            "CREATE TABLE IF NOT EXISTS entries ("
            "id INTEGER PRIMARY KEY,"
            "title TEXT NOT NULL,"
            "summary TEXT NOT NULL,"
            "link TEXT NOT NULL,"
            "entry_id TEXT,"
            "source TEXT NOT NULL,"
            "timestamp TEXT,"
            "read INTEGER"
            ");"
            )
        archive_table_sql = (
            "CREATE TABLE IF NOT EXISTS archive ("
            "id INTEGER PRIMARY KEY,"
            "title TEXT NOT NULL,"
            "summary TEXT NOT NULL,"
            "link TEXT NOT NULL,"
            "entry_id TEXT,"
            "source TEXT NOT NULL,"
            "timestamp TEXT,"
            "read INTEGER"
            ");"
            )
        # statistics_table_sql = (
        #     "CREATE TABLE IF NOT EXISTS statistics ("
        #     "id INTEGER PRIMARY KEY,"
        #     "title TEXT NOT NULL,"
        #     "number INTEGER"
        #     ");"
        #     )
        settings_table_sql = (
            "CREATE TABLE IF NOT EXISTS settings ("
            "id INTEGER PRIMARY KEY,"
            "key TEXT NOT NULL,"
            "value INTEGER"
            ");"
            )
        cur = conn.cursor()
        # cur = get_cursor(db_file)
        cur.execute(feeds_table_sql)
        cur.execute(entries_table_sql)
        cur.execute(archive_table_sql)
        # cur.execute(statistics_table_sql)
        cur.execute(settings_table_sql)


def get_cursor(db_file):
    """
    Allocate a cursor to connection per database.

    Parameters
    ----------
    db_file : str
        Path to database file.

    Returns
    -------
    CURSORS[db_file] : object
        Cursor.
    """
    if db_file in CURSORS:
        return CURSORS[db_file]
    else:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            CURSORS[db_file] = cur
    return CURSORS[db_file]


async def insert_feed(db_file, url, title=None, status=None):
    """
    Insert a new feed into the feeds table.

    Parameters
    ----------
    db_file : str
        Path to database file.
    url : str
        URL.
    title : str, optional
        Feed Title. The default is None.
    status : str, optional
        HTTP status code. The default is None.

    Returns
    -------
    msg : str
        Message.
    """
    #TODO consider async with DBLOCK
    #conn = create_connection(db_file)

    # with create_connection(db_file) as conn:
    #     #exist = await check_feed_exist(conn, url)
    #     exist = await check_feed_exist(db_file, url)

    # if not exist:
    #     status = await main.download_feed(url)
    # else:
    #     return "News source is already listed in the subscription list"

    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            # title = feed["feed"]["title"]
            feed = (title, url, 1, status, 1)
            sql = (
                "INSERT INTO feeds("
                "name, address, enabled, status, valid"
                ")"
                "VALUES(?, ?, ?, ?, ?) "
                )
            cur.execute(sql, feed)

    source = title if title else '<' + url + '>'
    msg = (
        "> {}\nNews source \"{}\" has been added "
        "to subscription list."
        ).format(url, source)
    return msg


async def remove_feed(db_file, ix):
    """
    Delete a feed by feed ID.

    Parameters
    ----------
    db_file : str
        Path to database file.
    ix : str
        Index of feed.

    Returns
    -------
    msg : str
        Message.
    """
    with create_connection(db_file) as conn:
        async with DBLOCK:
            cur = conn.cursor()
            try:
                sql = (
                    "SELECT address "
                    "FROM feeds "
                    "WHERE id = ?"
                    )
                # cur
                # for i in url:
                #     url = i[0]
                url = cur.execute(sql, (ix,)).fetchone()[0]
                sql = (
                    "SELECT name "
                    "FROM feeds "
                    "WHERE id = ?"
                    )
                name = cur.execute(sql, (ix,)).fetchone()[0]
                # NOTE Should we move DBLOCK to this line? 2022-12-23
                sql = (
                    "DELETE "
                    "FROM entries "
                    "WHERE source = ?"
                    )
                cur.execute(sql, (url,))
                sql = (
                    "DELETE "
                    "FROM archive "
                    "WHERE source = ?"
                    )
                cur.execute(sql, (url,))
                sql = (
                    "DELETE FROM feeds "
                    "WHERE id = ?"
                    )
                cur.execute(sql, (ix,))
                msg = (
                    "> {}\nNews source \"{}\" has been removed "
                    "from subscription list."
                    ).format(url, name)
            except:
                msg = (
                    "No news source with ID {}."
                    ).format(ix)
    return msg


async def check_feed_exist(db_file, url):
    """
    Check whether a feed exists.
    Query for feeds by given url.

    Parameters
    ----------
    db_file : str
        Path to database file.
    url : str
        URL.

    Returns
    -------
    result : list
        List of ID and Name of feed.
    """
    cur = get_cursor(db_file)
    sql = (
        "SELECT id, name "
        "FROM feeds "
        "WHERE address = ?"
        )
    result = cur.execute(sql, (url,)).fetchone()
    return result


async def get_number_of_items(db_file, table):
    """
    Return number of entries or feeds.

    Parameters
    ----------
    db_file : str
        Path to database file.
    table : str
        "entries" or "feeds".

    Returns
    -------
    count : ?
        Number of rows.
    """
    with create_connection(db_file) as conn:
        cur = conn.cursor()
        sql = (
            "SELECT count(id) "
            "FROM {}"
            ).format(table)
        count = cur.execute(sql).fetchone()[0]
        return count


async def get_number_of_feeds_active(db_file):
    """
    Return number of active feeds.

    Parameters
    ----------
    db_file : str
        Path to database file.

    Returns
    -------
    count : ?
        Number of rows.
    """
    with create_connection(db_file) as conn:
        cur = conn.cursor()
        sql = (
            "SELECT count(id) "
            "FROM feeds "
            "WHERE enabled = 1"
            )
        count = cur.execute(sql).fetchone()[0]
        return count


async def get_number_of_entries_unread(db_file):
    """
    Return number of unread items.

    Parameters
    ----------
    db_file : str
        Path to database file.

    Returns
    -------
    count : ?
        Number of rows.
    """
    with create_connection(db_file) as conn:
        cur = conn.cursor()
        sql = (
            "SELECT "
            "("
            "SELECT count(id) "
            "FROM entries "
            "WHERE read = 0"
            ") "
            "+ "
            "("
            "SELECT count(id) "
            "FROM archive"
            ") "
            "AS total_count"
            )
        count = cur.execute(sql).fetchone()[0]
        return count


# TODO Read from entries and archives
async def get_entry_unread(db_file, num=None):
    """
    Extract information from unread entries.

    Parameters
    ----------
    db_file : str
        Path to database file.
    num : str, optional
        Number. The default is None.

    Returns
    -------
    entry : str
        News item message.
    """
    if not num:
        num = await get_settings_value(db_file, "quantum")
    else:
        num = int(num)
    with create_connection(db_file) as conn:
        cur = conn.cursor()
        # sql = (
        #     "SELECT id "
        #     "FROM entries "
        #     "WHERE read = 0 "
        #     "LIMIT 1"
        #     )
        # sql = ("SELECT id "
        #        "FROM entries "
        #        "WHERE read = 0 "
        #        "ORDER BY timestamp DESC "
        #        "LIMIT 1"
        #        )
        # sql = (
        #     "SELECT id, title, summary, link "
        #     "FROM entries "
        #     "WHERE read = 0 "
        #     "ORDER BY timestamp "
        #     "DESC LIMIT :num"
        #     )
        sql = (
            "SELECT id, title, summary, link, source, timestamp "
            "FROM entries "
            "WHERE read = 0 "
            "UNION ALL "
            "SELECT id, title, summary, link, source, timestamp "
            "FROM archive "
            "ORDER BY timestamp "
            "DESC LIMIT :num"
            )
        results = cur.execute(sql, (num,))
        results = results.fetchall()
        
        # TODO Add filtering
        # TODO Do this when entry is added to list and mark it as read
        # DONE!
        # results = []
        # if get_settings_value(db_file, "filter-deny"):
        #     while len(results) < num:
        #         result = cur.execute(sql).fetchone()
        #         blacklist = await get_settings_value(db_file, "filter-deny").split(",")
        #         for i in blacklist:
        #             if i in result[1]:
        #                 continue
        #                 print("rejected:", result[1])
        #         print("accepted:", result[1])
        #         results.extend([result])

        # news_list = "You've got {} news items:\n".format(num)
        news_list = ""
        # NOTE Why doesn't this work without list?
        #      i.e. for result in results
        # for result in results.fetchall():
        for result in results:
            ix = result[0]
            title = result[1]
            summary = result[2]
            # Remove HTML tags
            summary = BeautifulSoup(summary, "lxml").text
            # TODO Limit text length
            summary = summary.replace("\n\n\n", "\n\n")
            length = await get_settings_value(db_file, "length")
            summary = summary[:length] + " […]"
            summary = summary.strip().split('\n')
            summary = ["> " + line for line in summary]
            summary = "\n".join(summary)
            link = result[3]
            sql = (
                "SELECT name "
                "FROM feeds "
                "WHERE address = :source "
                )
            source = result[4]
            feed = cur.execute(sql, (source,))
            feed = feed.fetchone()[0]
            if num > 1:
                news_list += (
                    "\n{}\n{}\n"
                    ).format(
                        str(title),
                        str(link)
                        )
            else:
                news_list = (
                    "{}\n\n{}\n\n{}\n{}"
                    ).format(
                        str(title),
                        str(summary),
                        str(link),
                        str(feed)
                        )
            # TODO While `async with DBLOCK` does work well from
            # outside of functions, it would be better practice
            # to place it within the functions.
            async with DBLOCK:
                # NOTE: We can use DBLOCK once for both
                # functions, because, due to exclusive
                # ID, only one can ever occur.
                await mark_entry_as_read(cur, ix)
                await delete_entry(cur, ix)
        return news_list


async def mark_entry_as_read(cur, ix):
    """
    Set read status of entry as read.

    Parameters
    ----------
    cur : object
        Cursor object.
    ix : str
        Index of entry.
    """
    sql = (
        "UPDATE entries "
        "SET summary = '', read = 1 "
        "WHERE id = ?"
        )
    cur.execute(sql, (ix,))


async def mark_source_as_read(db_file, source):
    """
    Set read status of entries of given source as read.

    Parameters
    ----------
    db_file : str
        Path to database file.
    source : str
        URL.
    """
    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            sql = (
                "UPDATE entries "
                "SET summary = '', read = 1 "
                "WHERE source = ?"
                )
            cur.execute(sql, (source,))


async def mark_all_as_read(db_file):
    """
    Set read status of all entries as read.

    Parameters
    ----------
    db_file : str
        Path to database file.
    """
    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            sql = (
                "UPDATE entries "
                "SET summary = '', read = 1 "
                )
            cur.execute(sql)
            sql = (
                "DELETE FROM archive"
                )
            cur.execute(sql)


async def delete_entry(cur, ix):
    """
    Delete entry from table archive.

    Parameters
    ----------
    db_file : str
        Path to database file.
    ix : str
        Index of entry.
    """
    sql = (
        "DELETE FROM archive "
        "WHERE id = ?"
        )
    cur.execute(sql, (ix,))


async def statistics(db_file):
    """
    Return table statistics.

    Parameters
    ----------
    db_file : str
        Path to database file.

    Returns
    -------
    msg : str
        Statistics as message.
    """
    feeds = await get_number_of_items(db_file, 'feeds')
    active_feeds = await get_number_of_feeds_active(db_file)
    entries = await get_number_of_items(db_file, 'entries')
    unread_entries = await get_number_of_entries_unread(db_file)
    # msg = """You have {} unread news items out of {} from {} news sources.
    #       """.format(unread_entries, entries, feeds)
    with create_connection(db_file) as conn:
        cur = conn.cursor()
        keys = []
        for key in ["enabled", "interval", "quantum"]:
            sql = (
            "SELECT value "
            "FROM settings "
            "WHERE key = ?"
            )
            keys.extend([cur.execute(sql, (key,)).fetchone()[0]])
        msg = (
            "```\n"
            "News items       : {} ({})\n"
            "News sources     : {} ({})\n"
            "Update interval  : {}\n"
            "Items per update : {}\n"
            "Operation status : {}\n"
            "```"
            ).format(
                unread_entries, entries,
                active_feeds, feeds,
                keys[1],
                keys[2],
                keys[0]
                )
    return msg


async def update_statistics(cur):
    """
    Update table statistics.

    Parameters
    ----------
    cur : object
        Cursor object.
    """
    stat_dict = {}
    stat_dict["feeds"] = await get_number_of_items(cur, 'feeds')
    stat_dict["entries"] = await get_number_of_items(cur, 'entries')
    stat_dict["unread"] = await get_number_of_entries_unread(cur=cur)
    for i in stat_dict:
        sql = (
            "SELECT id "
            "FROM statistics "
            "WHERE title = ?"
            )
        cur.execute(sql, (i,))
        if cur.fetchone():
            sql = (
                "UPDATE statistics "
                "SET number = :num "
                "WHERE title = :title"
                )
            cur.execute(sql, {
                "title": i,
                "num": stat_dict[i]
                })
        else:
            sql = (
                "SELECT count(id) "
                "FROM statistics"
                )
            count = cur.execute(sql).fetchone()[0]
            ix = count + 1
            sql = (
                "INSERT INTO statistics "
                "VALUES(?,?,?)"
                )
            cur.execute(sql, (ix, i, stat_dict[i]))


async def toggle_status(db_file, ix):
    """
    Toggle status of feed.

    Parameters
    ----------
    db_file : str
        Path to database file.
    ix : str
        Index of entry.

    Returns
    -------
    msg : str
        Message.
    """
    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            try:
                #cur = get_cursor(db_file)
                sql = (
                    "SELECT name "
                    "FROM feeds "
                    "WHERE id = :id"
                    )
                title = cur.execute(sql, (ix,)).fetchone()[0]
                sql = (
                    "SELECT enabled "
                    "FROM feeds "
                    "WHERE id = ?"
                    )
                # NOTE [0][1][2]
                status = cur.execute(sql, (ix,)).fetchone()[0]
                # FIXME always set to 1
                # NOTE Maybe because is not integer
                # TODO Reset feed table before further testing
                if status == 1:
                    status = 0
                    state =  "disabled"
                else:
                    status = 1
                    state = "enabled"
                sql = (
                    "UPDATE feeds "
                    "SET enabled = :status "
                    "WHERE id = :id"
                    )
                cur.execute(sql, {
                    "status": status,
                    "id": ix
                    })
                msg = (
                    "Updates from '{}' are now {}."
                       ).format(title, state)
            except:
                msg = (
                    "No news source with ID {}."
                       ).format(ix)
    return msg


async def set_date(cur, url):
    """
    Set last update date of feed.

    Parameters
    ----------
    cur : object
        Cursor object.
    url : str
        URL.
    """
    today = date.today()
    sql = (
        "UPDATE feeds "
        "SET updated = :today "
        "WHERE address = :url"
        )
    # cur = conn.cursor()
    cur.execute(sql, {
        "today": today,
        "url": url
        })


async def add_entry_and_set_date(db_file, source, entry):
    """
    Add entry to table entries and set date of source in table feeds.

    Parameters
    ----------
    db_file : str
        Path to database file.
    source : str
        Feed URL.
    entry : list
        Entry properties.
    """
    # TODO While `async with DBLOCK` does work well from
    # outside of functions, it would be better practice
    # to place it within the functions.
    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            await add_entry(cur, entry)
            await set_date(cur, source)


async def update_source_status(db_file, status, source):
    """
    Set HTTP status of source in table feeds.

    Parameters
    ----------
    db_file : str
        Path to database file.
    source : str
        Feed URL.
    status : str
        Status ID or message.
    """
    sql = (
        "UPDATE feeds "
        "SET status = :status, scanned = :scanned "
        "WHERE address = :url"
        )
    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            cur.execute(sql, {
                "status"  : status,
                "scanned" : date.today(),
                "url"     : source
                })


async def update_source_validity(db_file, source, valid):
    """
    Set validity status of source in table feeds.

    Parameters
    ----------
    db_file : str
        Path to database file.
    source : str
        Feed URL.
    valid : boolean
        0 or 1.
    """
    sql = (
        "UPDATE feeds "
        "SET valid = :validity "
        "WHERE address = :url"
        )
    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            cur.execute(sql, {
                "validity": valid,
                "url": source
                })

"""
TODO

Investigate why causes entry[6] (date) to be int 0

"""
async def add_entry(cur, entry):
    """
    Add a new entry row into the entries table.

    Parameters
    ----------
    cur : object
        Cursor object.
    entry : str
        Entry properties.
    """
    sql = (
        "INSERT "
        "INTO entries("
                "title, "
                "summary, "
                "link, "
                "entry_id, "
                "source, "
                "timestamp, "
                "read"
                ") "
        "VALUES(?, ?, ?, ?, ?, ?, ?)"
        )
    try:
        cur.execute(sql, entry)
    except:
        print(await current_time(), "COROUTINE OBJECT NOW")
        print(entry[6])
        print(type(entry[6]))
        print(entry)
        print(type(entry))
        print(await current_time(), "COROUTINE OBJECT NOW")
        # breakpoint()


# NOTE See remove_nonexistent_entries
# NOTE This function doesn't work as expected with bbs and docuwiki feeds
async def remove_entry(db_file, source, length):
    """
    Maintain list of entries equal to feed.
    Check the number returned by feed and delete
    existing entries up to the same returned amount.

    Parameters
    ----------
    db_file : str
        Path to database file.
    source : str
        Feed URL.
    length : str
        Number.
    """
    # FIXED
    # Dino empty titles are not counted https://dino.im/index.xml
    # SOLVED
    # Add text if is empty
    # title = '*** No title ***' if not entry.title else entry.title
    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            sql = (
                "SELECT count(id) "
                "FROM entries "
                "WHERE source = ?"
                )
            count = cur.execute(sql, (source,)).fetchone()[0]
            limit = count - length
            if limit:
                limit = limit;
                sql = (
                    "DELETE FROM entries "
                    "WHERE id "
                    "IN (SELECT id "
                    "FROM entries "
                    "WHERE source = :source "
                    "ORDER BY id "
                    "ASC LIMIT :limit)"
                    )
                cur.execute(sql, {
                    "source": source,
                    "limit": limit
                    })


# TODO Move entries that don't exist into table archive.
# NOTE Entries that are read from archive are deleted.
# NOTE Unlike entries from table entries, entries from
#      table archive are not marked as read.
async def remove_nonexistent_entries(db_file, feed, source):
    """
    Remove entries that don't exist in a given parsed feed.
    Check the entries returned from feed and delete read non
    existing entries, otherwise move to table archive, if unread.

    Parameters
    ----------
    db_file : str
        Path to database file.
    feed : list
        Parsed feed document.
    source : str
        Feed URL. URL of associated feed.
    """
    with create_connection(db_file) as conn:
        cur = conn.cursor()
        sql = (
            "SELECT id, title, link, entry_id, timestamp, read "
            "FROM entries "
            "WHERE source = ?"
            )
        items = cur.execute(sql, (source,)).fetchall()
        entries = feed.entries
        # breakpoint()
        for item in items:
            valid = False
            for entry in entries:
                title = None
                link = None
                time = None
                # valid = False
                # TODO better check and don't repeat code
                if entry.has_key("id") and item[3]:
                    if entry.id == item[3]:
                        # print("compare1:", entry.id)
                        # print("compare2:", item[3])
                        # print("============")
                        valid = True
                        break
                else:
                    if entry.has_key("title"):
                        title = entry.title
                    else:
                        title = feed["feed"]["title"]
                    if entry.has_key("link"):
                        link = await datahandler.join_url(source, entry.link)
                    else:
                        link = source
                    if entry.has_key("published") and item[4]:
                        # print("compare11:", title, link, time)
                        # print("compare22:", item[1], item[2], item[4])
                        # print("============")
                        time = await rfc2822_to_iso8601(entry.published)
                        if (item[1] == title and
                            item[2] == link and
                            item[4] == time):
                            valid = True
                            break
                    else:
                        if (item[1] == title and
                            item[2] == link):
                            # print("compare111:", title, link)
                            # print("compare222:", item[1], item[2])
                            # print("============")
                            valid = True
                            break
                # TODO better check and don't repeat code
            if not valid:
                # print("id:        ", item[0])
                # if title:
                #     print("title:     ", title)
                #     print("item[1]:   ", item[1])
                # if link:
                #     print("link:      ", link)
                #     print("item[2]:   ", item[2])
                # if entry.id:
                #     print("last_entry:", entry.id)
                #     print("item[3]:   ", item[3])
                # if time:
                #     print("time:      ", time)
                #     print("item[4]:   ", item[4])
                # print("read:      ", item[5])
                # breakpoint()
                async with DBLOCK:
                    # TODO Send to table archive
                    # TODO Also make a regular/routine check for sources that
                    #      have been changed (though that can only happen when
                    #      manually editing)
                    ix = item[0]
                    # print(">>> SOURCE: ", source)
                    # print(">>> INVALID:", item[1])
                    # print("title:", item[1])
                    # print("link :", item[2])
                    # print("id   :", item[3])
                    if item[5] == 1:
                        # print(">>> DELETING:", item[1])
                        sql = (
                            "DELETE "
                            "FROM entries "
                            "WHERE id = :ix"
                            )
                        cur.execute(sql, (ix,))
                    else:
                        # print(">>> ARCHIVING:", item[1])
                        sql = (
                            "INSERT "
                            "INTO archive "
                            "SELECT * "
                            "FROM entries "
                            "WHERE entries.id = :ix"
                            )
                        try:
                            cur.execute(sql, (ix,))
                        except:
                            print(
                                "ERROR DB inset from entries "
                                "into archive at index", ix
                                )
                        sql = (
                            "DELETE "
                            "FROM entries "
                            "WHERE id = :ix"
                            )
                        try:
                            cur.execute(sql, (ix,))
                        except:
                            print(
                                "ERROR DB deleting entries "
                                "from entries at index", ix
                                )


async def get_feeds(db_file):
    """
    Query table feeds for Title, URL, Categories, Tags.

    Parameters
    ----------
    db_file : str
        Path to database file.

    Returns
    -------
    result : list
        Title, URL, Categories, Tags of feeds.
    """
    with create_connection(db_file) as conn:
        cur = conn.cursor()
        sql = (
            "SELECT name, address, type, categories, tags "
            "FROM feeds"
            )
        result = cur.execute(sql).fetchall()
        return result


async def get_feeds_url(db_file):
    """
    Query active feeds for URLs.

    Parameters
    ----------
    db_file : str
        Path to database file.

    Returns
    -------
    result : list
        URLs of active feeds.
    """
    with create_connection(db_file) as conn:
        cur = conn.cursor()
        sql = (
            "SELECT address "
            "FROM feeds "
            "WHERE enabled = 1"
            )
        result = cur.execute(sql).fetchall()
        return result


async def list_feeds(db_file):
    """
    Query table feeds and list items.

    Parameters
    ----------
    db_file : str
        Path to database file.

    Returns
    -------
    msg : str
        URLs of feeds as message.
    """
    cur = get_cursor(db_file)
    sql = (
        "SELECT name, address, updated, enabled, id "
        "FROM feeds"
        )
    results = cur.execute(sql)
    feeds_list = "\nList of subscriptions:\n```\n"
    counter = 0
    for result in results:
        counter += 1
        feeds_list += (
            "Name    : {}\n"
            "Address : {}\n"
            "Updated : {}\n"
            "Status  : {}\n"
            "ID      : {}\n"
            "\n"
            ).format(
                str(result[0]),
                str(result[1]),
                str(result[2]),
                str(result[3]),
                str(result[4])
                )
    if counter:
        return feeds_list + (
            "```\nTotal of {} subscriptions.\n"
            ).format(counter)
    else:
        msg = (
            "List of subscriptions is empty.\n"
            "To add feed, send a URL\n"
            "Try these:\n"
            # TODO Pick random from featured/recommended
            "https://reclaimthenet.org/feed/"
            )
        return msg


async def last_entries(db_file, num):
    """
    Query entries

    Parameters
    ----------
    db_file : str
        Path to database file.
    num : str
        Number.

    Returns
    -------
    titles_list : str
        List of recent N entries as message.
    """
    num = int(num)
    if num > 50:
        num = 50
    elif num < 1:
        num = 1
    cur = get_cursor(db_file)
    # sql = (
    #     "SELECT title, link "
    #     "FROM entries "
    #     "ORDER BY ROWID DESC "
    #     "LIMIT :num"
    #     )
    sql = (
        "SELECT title, link "
        "FROM entries "
        "WHERE read = 0 "
        "ORDER BY timestamp DESC "
        "LIMIT :num "
        )
    results = cur.execute(sql, (num,))
    titles_list = "Recent {} titles:\n```".format(num)
    counter = 0
    for result in results:
        counter += 1
        titles_list += (
            "\n{}\n{}\n"
            ).format(
                str(result[0]),
                str(result[1])
                )
    if counter:
        titles_list += "```\n"
        return titles_list
    else:
        return "There are no news at the moment."


async def search_feeds(db_file, query):
    """
    Query feeds.

    Parameters
    ----------
    db_file : str
        Path to database file.
    query : str
        Search query.

    Returns
    -------
    titles_list : str
        Feeds of specified keywords as message.
    """
    cur = get_cursor(db_file)
    sql = (
        "SELECT name, address, id, enabled "
        "FROM feeds "
        "WHERE name LIKE ? "
        "OR address LIKE ? "
        "LIMIT 50"
        )
    results = cur.execute(sql, [f'%{query}%', f'%{query}%'])
    results_list = (
        "Feeds containing '{}':\n```"
        ).format(query)
    counter = 0
    for result in results:
        counter += 1
        results_list += (
            "\nName  : {}"
            "\nURL   : {}"
            "\nIndex : {}"
            "\nMode  : {}"
            "\n"
            ).format(
                str(result[0]),
                str(result[1]),
                str(result[2]),
                str(result[3])
                )
    if counter:
        return results_list + "\n```\nTotal of {} feeds".format(counter)
    else:
        return "No feeds were found for: {}".format(query)


async def search_entries(db_file, query):
    """
    Query entries.

    Parameters
    ----------
    db_file : str
        Path to database file.
    query : str
        Search query.

    Returns
    -------
    titles_list : str
        Entries of specified keywords as message.
    """
    cur = get_cursor(db_file)
    sql = (
        "SELECT title, link "
        "FROM entries "
        "WHERE title LIKE ? "
        "UNION ALL "
        "SELECT title, link "
        "FROM archive "
        "WHERE title LIKE ? "
        "LIMIT 50"
        )
    results = cur.execute(sql, (
        f'%{query}%',
        f'%{query}%'
        ))
    results_list = (
        "Search results for '{}':\n```"
        ).format(query)
    counter = 0
    for result in results:
        counter += 1
        results_list += (
            "\n{}\n{}\n"
            ).format(
                str(result[0]),
                str(result[1])
                )
    if counter:
        return results_list + "```\nTotal of {} results".format(counter)
    else:
        return "No results were found for: {}".format(query)

"""
FIXME

Error due to missing date, but it appears that date is present:
ERROR DATE: source = https://blog.heckel.io/feed/
ERROR DATE: date = 2008-05-13T13:51:50+00:00
ERROR DATE: result = https://blog.heckel.io/feed/

19:32:05 ERROR DATE: source = https://mwl.io/feed
19:32:05 ERROR DATE: date = 2023-11-30T10:56:39+00:00
19:32:05 ERROR DATE: result = https://mwl.io/feed
19:32:05 ERROR DATE: source = https://mwl.io/feed
19:32:05 ERROR DATE: date = 2023-11-22T16:59:08+00:00
19:32:05 ERROR DATE: result = https://mwl.io/feed
19:32:06 ERROR DATE: source = https://mwl.io/feed
19:32:06 ERROR DATE: date = 2023-11-16T10:33:57+00:00
19:32:06 ERROR DATE: result = https://mwl.io/feed
19:32:06 ERROR DATE: source = https://mwl.io/feed
19:32:06 ERROR DATE: date = 2023-11-09T07:37:57+00:00
19:32:06 ERROR DATE: result = https://mwl.io/feed

"""
async def check_entry_exist(db_file, source, eid=None,
                            title=None, link=None, date=None):
    """
    Check whether an entry exists.
    If entry has an ID, check by ID.
    If entry has timestamp, check by title, link and date.
    Otherwise, check by title and link.

    Parameters
    ----------
    db_file : str
        Path to database file.
    source : str
        Feed URL. URL of associated feed.
    eid : str, optional
        Entry ID. The default is None.
    title : str, optional
        Entry title. The default is None.
    link : str, optional
        Entry URL. The default is None.
    date : str, optional
        Entry Timestamp. The default is None.

    Returns
    -------
    bool
        True or None.
    """
    cur = get_cursor(db_file)
    if eid:
        sql = (
            "SELECT id "
            "FROM entries "
            "WHERE entry_id = :eid and source = :source"
            )
        result = cur.execute(sql, {
            "eid": eid,
            "source": source
            }).fetchone()
    elif date:
        sql = (
            "SELECT id "
            "FROM entries "
            "WHERE "
            "title = :title and "
            "link = :link and "
            "timestamp = :date"
            )
        try:
            result = cur.execute(sql, {
                "title": title,
                "link": link,
                "timestamp": date
                }).fetchone()
        except:
            print(await current_time(), "ERROR DATE: source =", source)
            print(await current_time(), "ERROR DATE: date =", date)
    else:
        sql = (
            "SELECT id "
            "FROM entries "
            "WHERE title = :title and link = :link"
            )
        result = cur.execute(sql, {
            "title": title,
            "link": link
            }).fetchone()
    try:
        if result:
            return True
        else:
            None
    except:
        print(await current_time(), "ERROR DATE: result =", source)


async def set_settings_value(db_file, key_value):
    """
    Set settings value.

    Parameters
    ----------
    db_file : str
        Path to database file.
    key_value : list
         key : str
               enabled, filter-allow, filter-deny,
               interval, masters, quantum, random.
         value : int
               Numeric value.
    """
    # if isinstance(key_value, list):
    #     key = key_value[0]
    #     val = key_value[1]
    # elif key_value == "enable":
    #     key = "enabled"
    #     val = 1
    # else:
    #     key = "enabled"
    #     val = 0
    key = key_value[0]
    val = key_value[1]
    async with DBLOCK:
        with create_connection(db_file) as conn:
            cur = conn.cursor()
            await set_settings_value_default(cur, key)
            sql = (
                "UPDATE settings "
                "SET value = :value "
                "WHERE key = :key"
                )
            cur.execute(sql, {
                "key": key, 
                "value": val
                })


# TODO Place settings also in a file
async def set_settings_value_default(cur, key):
    """
    Set default settings value, if no value found.

    Parameters
    ----------
    cur : object
        Cursor object.
    key : str
        Key: enabled, interval, master, quantum, random.

    Returns
    -------
    val : str
        Numeric value.
    """
# async def set_settings_value_default(cur):
#     keys = ["enabled", "interval", "quantum"]
#     for i in keys:
#         sql = "SELECT id FROM settings WHERE key = ?"
#         cur.execute(sql, (i,))
#         if not cur.fetchone():
#             val = await settings.get_value_default(i)
#             sql = "INSERT INTO settings(key,value) VALUES(?,?)"
#             cur.execute(sql, (i, val))
    sql = (
        "SELECT id "
        "FROM settings "
        "WHERE key = ?"
        )
    cur.execute(sql, (key,))
    if not cur.fetchone():
        val = await confighandler.get_value_default(key)
        sql = (
            "INSERT "
            "INTO settings(key,value) "
            "VALUES(?,?)"
            )
        cur.execute(sql, (key, val))
        return val


async def get_settings_value(db_file, key):
    """
    Get settings value.

    Parameters
    ----------
    db_file : str
        Path to database file.
    key : str
        Key: "enabled", "interval", "master", "quantum", "random".

    Returns
    -------
    val : str
        Numeric value.
    """
    # try:
    #     with create_connection(db_file) as conn:
    #         cur = conn.cursor()
    #         sql = "SELECT value FROM settings WHERE key = ?"
    #         cur.execute(sql, (key,))
    #         result = cur.fetchone()
    # except:
    #     result = await settings.get_value_default(key)
    # if not result:
    #     result = await settings.get_value_default(key)
    # return result
    with create_connection(db_file) as conn:
        try:
            cur = conn.cursor()
            sql = (
                "SELECT value "
                "FROM settings "
                "WHERE key = ?"
                )
            val = cur.execute(sql, (key,)).fetchone()[0]
        except:
            val = await set_settings_value_default(cur, key)
        if not val:
            val = await set_settings_value_default(cur, key)
        return val