3061 lines
78 KiB
Python
3061 lines
78 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
|
|
TODO
|
|
|
|
1) Function to open connection (receive db_file).
|
|
Function to close connection.
|
|
All other functions to receive cursor.
|
|
|
|
2) Merge function add_metadata into function import_feeds.
|
|
|
|
3) SQL prepared statements.
|
|
|
|
4) Support categories;
|
|
|
|
"""
|
|
|
|
from asyncio import Lock
|
|
# from slixfeed.data import join_url
|
|
from slixfeed.log import Logger
|
|
from sqlite3 import connect, Error, IntegrityError
|
|
import sys
|
|
import time
|
|
|
|
# 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):
|
|
|
|
CURSORS = {}
|
|
|
|
# aiosqlite
|
|
DBLOCK = Lock()
|
|
|
|
logger = Logger(__name__)
|
|
|
|
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.
|
|
"""
|
|
time_begin = time.time()
|
|
function_name = sys._getframe().f_code.co_name
|
|
message_log = '{}'
|
|
logger.debug(message_log.format(function_name))
|
|
conn = None
|
|
try:
|
|
conn = connect(db_file)
|
|
conn.execute("PRAGMA foreign_keys = ON")
|
|
# return conn
|
|
except Error as e:
|
|
print(e)
|
|
time_end = time.time()
|
|
difference = time_end - time_begin
|
|
if difference > 1: logger.warning('{} (time: {})'.format(function_name,
|
|
difference))
|
|
return conn
|
|
|
|
|
|
def create_tables(db_file):
|
|
"""
|
|
Create SQLite tables.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
archive_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS archive (
|
|
id INTEGER NOT NULL,
|
|
title TEXT NOT NULL,
|
|
link TEXT NOT NULL,
|
|
summary TEXT,
|
|
enclosure TEXT,
|
|
entry_id TEXT NOT NULL,
|
|
feed_id INTEGER NOT NULL,
|
|
timestamp TEXT,
|
|
read INTEGER NOT NULL DEFAULT 0,
|
|
reject INTEGER NOT NULL DEFAULT 0,
|
|
FOREIGN KEY ("feed_id") REFERENCES "feeds" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
entries_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS entries (
|
|
id INTEGER NOT NULL,
|
|
title TEXT NOT NULL,
|
|
link TEXT NOT NULL,
|
|
summary TEXT,
|
|
enclosure TEXT,
|
|
entry_id TEXT NOT NULL,
|
|
feed_id INTEGER NOT NULL,
|
|
timestamp TEXT,
|
|
read INTEGER NOT NULL DEFAULT 0,
|
|
reject INTEGER NOT NULL DEFAULT 0,
|
|
FOREIGN KEY ("feed_id") REFERENCES "feeds" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
feeds_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS feeds (
|
|
id INTEGER NOT NULL,
|
|
name TEXT,
|
|
url TEXT NOT NULL UNIQUE,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
# TODO Rethink!
|
|
# Albeit, probably, more expensive, we might want to have feed_id
|
|
# as foreign key, as it is with feeds_properties and feeds_state
|
|
feeds_categories_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS feeds_categories (
|
|
id INTEGER NOT NULL,
|
|
category_id INTEGER NOT NULL UNIQUE,
|
|
feed_id INTEGER,
|
|
FOREIGN KEY ("category_id") REFERENCES "categories" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
PRIMARY KEY (id)
|
|
);
|
|
"""
|
|
)
|
|
feeds_properties_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS feeds_properties (
|
|
id INTEGER NOT NULL,
|
|
feed_id INTEGER NOT NULL UNIQUE,
|
|
type TEXT,
|
|
encoding TEXT,
|
|
language TEXT,
|
|
entries INTEGER,
|
|
FOREIGN KEY ("feed_id") REFERENCES "feeds" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
PRIMARY KEY (id)
|
|
);
|
|
"""
|
|
)
|
|
feeds_rules_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS feeds_rules (
|
|
id INTEGER NOT NULL,
|
|
feed_id INTEGER NOT NULL UNIQUE,
|
|
type TEXT NOT NULL,
|
|
base TEXT NOT NULL,
|
|
title TEXT NOT NULL,
|
|
link TEXT NOT NULL,
|
|
enclosure TEXT,
|
|
summary TEXT,
|
|
FOREIGN KEY ("feed_id") REFERENCES "feeds" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
PRIMARY KEY (id)
|
|
);
|
|
"""
|
|
)
|
|
feeds_state_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS feeds_state (
|
|
id INTEGER NOT NULL,
|
|
feed_id INTEGER NOT NULL UNIQUE,
|
|
enabled INTEGER NOT NULL DEFAULT 1,
|
|
updated TEXT,
|
|
scanned TEXT,
|
|
renewed TEXT,
|
|
status_code INTEGER,
|
|
valid INTEGER,
|
|
filter INTEGER NOT NULL DEFAULT 1,
|
|
priority INTEGER,
|
|
FOREIGN KEY ("feed_id") REFERENCES "feeds" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
feeds_statistics_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS statistics (
|
|
id INTEGER NOT NULL,
|
|
feed_id INTEGER NOT NULL UNIQUE,
|
|
offline INTEGER,
|
|
entries INTEGER,
|
|
entries INTEGER,
|
|
FOREIGN KEY ("feed_id") REFERENCES "feeds" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
feeds_tags_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS feeds_tags (
|
|
id INTEGER NOT NULL,
|
|
feed_id INTEGER NOT NULL,
|
|
tag_id INTEGER NOT NULL,
|
|
FOREIGN KEY ("feed_id") REFERENCES "feeds" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
FOREIGN KEY ("tag_id") REFERENCES "tags" ("id")
|
|
ON UPDATE CASCADE
|
|
ON DELETE CASCADE,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
# TODO
|
|
# Consider parameter unique:
|
|
# entry_id TEXT NOT NULL UNIQUE,
|
|
# Will eliminate function:
|
|
# check_entry_exist
|
|
filters_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS filters (
|
|
id INTEGER NOT NULL,
|
|
key TEXT NOT NULL,
|
|
value TEXT,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
settings_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS settings (
|
|
id INTEGER NOT NULL,
|
|
key TEXT NOT NULL,
|
|
value INTEGER,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
status_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS status (
|
|
id INTEGER NOT NULL,
|
|
key TEXT NOT NULL,
|
|
value INTEGER,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
tags_table_sql = (
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS tags (
|
|
id INTEGER NOT NULL,
|
|
tag TEXT NOT NULL UNIQUE,
|
|
PRIMARY KEY ("id")
|
|
);
|
|
"""
|
|
)
|
|
cur = conn.cursor()
|
|
# cur = get_cursor(db_file)
|
|
cur.execute(archive_table_sql)
|
|
cur.execute(entries_table_sql)
|
|
cur.execute(feeds_table_sql)
|
|
cur.execute(feeds_state_table_sql)
|
|
cur.execute(feeds_properties_table_sql)
|
|
cur.execute(feeds_rules_table_sql)
|
|
cur.execute(feeds_tags_table_sql)
|
|
cur.execute(filters_table_sql)
|
|
# cur.execute(statistics_table_sql)
|
|
cur.execute(settings_table_sql)
|
|
cur.execute(status_table_sql)
|
|
cur.execute(tags_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.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
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 import_feeds(db_file, feeds):
|
|
"""
|
|
Insert a new feed into the feeds table.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feeds : list
|
|
Set of feeds (Title and URL).
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
for feed in feeds:
|
|
logger.debug('{}: feed: {}'
|
|
.format(function_name, feed))
|
|
url = feed[0]
|
|
title = feed[1]
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO feeds(
|
|
name, url)
|
|
VALUES(
|
|
?, ?)
|
|
"""
|
|
)
|
|
par = (
|
|
title, url
|
|
)
|
|
try:
|
|
cur.execute(sql, par)
|
|
except IntegrityError as e:
|
|
logger.warning("Skipping: " + str(url))
|
|
logger.error(e)
|
|
|
|
|
|
async def add_metadata(db_file):
|
|
"""
|
|
Insert a new feed into the feeds table.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT id
|
|
FROM feeds
|
|
ORDER BY id ASC
|
|
"""
|
|
)
|
|
ixs = cur.execute(sql).fetchall()
|
|
for ix in ixs:
|
|
feed_id = ix[0]
|
|
insert_feed_status(cur, feed_id)
|
|
insert_feed_properties(cur, feed_id)
|
|
|
|
|
|
def insert_feed_status(cur, feed_id):
|
|
"""
|
|
Set feed status.
|
|
|
|
Parameters
|
|
----------
|
|
cur : object
|
|
Cursor object.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: feed_id: {}'
|
|
.format(function_name, feed_id))
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO feeds_state(
|
|
feed_id)
|
|
VALUES(
|
|
?)
|
|
"""
|
|
)
|
|
par = (feed_id,)
|
|
try:
|
|
cur.execute(sql, par)
|
|
except IntegrityError as e:
|
|
logger.warning(
|
|
"Skipping feed_id {} for table feeds_state".format(feed_id))
|
|
logger.error(e)
|
|
|
|
|
|
def insert_feed_properties(cur, feed_id):
|
|
"""
|
|
Set feed properties.
|
|
|
|
Parameters
|
|
----------
|
|
cur : object
|
|
Cursor object.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: feed_id: {}'
|
|
.format(function_name, feed_id))
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO feeds_properties(
|
|
feed_id)
|
|
VALUES(
|
|
?)
|
|
"""
|
|
)
|
|
par = (feed_id,)
|
|
try:
|
|
cur.execute(sql, par)
|
|
except IntegrityError as e:
|
|
logger.warning(
|
|
"Skipping feed_id {} for table feeds_properties".format(feed_id))
|
|
logger.error(e)
|
|
|
|
|
|
async def insert_feed(db_file, url, title=None, entries=None, version=None,
|
|
encoding=None, language=None, status_code=None,
|
|
updated=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.
|
|
entries : int, optional
|
|
Number of entries. The default is None.
|
|
version : str, optional
|
|
Type of feed. The default is None.
|
|
encoding : str, optional
|
|
Encoding of feed. The default is None.
|
|
language : str, optional
|
|
Language code of feed. The default is None.
|
|
status : str, optional
|
|
HTTP status code. The default is None.
|
|
updated : ???, optional
|
|
Date feed was last updated. The default is None.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} url: {}'
|
|
.format(function_name, db_file, url))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO feeds(
|
|
name, url)
|
|
VALUES(
|
|
?, ?)
|
|
"""
|
|
)
|
|
par = (
|
|
title, url
|
|
)
|
|
cur.execute(sql, par)
|
|
sql = (
|
|
"""
|
|
SELECT id
|
|
FROM feeds
|
|
WHERE url = :url
|
|
"""
|
|
)
|
|
par = (url,)
|
|
feed_id = cur.execute(sql, par).fetchone()[0]
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO feeds_state(
|
|
feed_id, enabled, updated, status_code, valid)
|
|
VALUES(
|
|
?, ?, ?, ?, ?)
|
|
"""
|
|
)
|
|
par = (
|
|
feed_id, 1, updated, status_code, 1
|
|
)
|
|
cur.execute(sql, par)
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO feeds_properties(
|
|
feed_id, entries, type, encoding, language)
|
|
VALUES(
|
|
?, ?, ?, ?, ?)
|
|
"""
|
|
)
|
|
par = (
|
|
feed_id, entries, version, encoding, language
|
|
)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def insert_feed_(db_file, url, title=None, entries=None, version=None,
|
|
encoding=None, language=None, status_code=None,
|
|
updated=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.
|
|
entries : int, optional
|
|
Number of entries. The default is None.
|
|
version : str, optional
|
|
Type of feed. The default is None.
|
|
encoding : str, optional
|
|
Encoding of feed. The default is None.
|
|
language : str, optional
|
|
Language code of feed. The default is None.
|
|
status : str, optional
|
|
HTTP status code. The default is None.
|
|
updated : ???, optional
|
|
Date feed was last updated. The default is None.
|
|
status : str, optional
|
|
HTTP status code. The default is None.
|
|
updated : ???, optional
|
|
Date feed was last updated. The default is None.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} url: {}'
|
|
.format(function_name, db_file, url))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO feeds(
|
|
name, url)
|
|
VALUES(
|
|
?, ?)
|
|
"""
|
|
)
|
|
par = (
|
|
title, url
|
|
)
|
|
cur.execute(sql, par)
|
|
sql = (
|
|
"""
|
|
SELECT id
|
|
FROM feeds
|
|
WHERE url = :url
|
|
"""
|
|
)
|
|
par = (url,)
|
|
feed_id = cur.execute(sql, par).fetchone()[0]
|
|
insert_feed_properties(
|
|
cur, feed_id, entries=None,
|
|
version=None, encoding=None, language=None)
|
|
insert_feed_status(
|
|
cur, feed_id, status_code=None, updated=None)
|
|
|
|
|
|
async def remove_feed_by_url(db_file, url):
|
|
"""
|
|
Delete a feed by feed URL.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
url : str
|
|
URL of feed.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} url: {}'
|
|
.format(function_name, db_file, url))
|
|
with create_connection(db_file) as conn:
|
|
async with DBLOCK:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM feeds
|
|
WHERE url = ?
|
|
"""
|
|
)
|
|
par = (url,)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def remove_feed_by_index(db_file, ix):
|
|
"""
|
|
Delete a feed by feed ID.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
ix : str
|
|
Index of feed.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
with create_connection(db_file) as conn:
|
|
async with DBLOCK:
|
|
cur = conn.cursor()
|
|
# # NOTE Should we move DBLOCK to this line? 2022-12-23
|
|
# sql = (
|
|
# "DELETE "
|
|
# "FROM entries "
|
|
# "WHERE feed_id = ?"
|
|
# )
|
|
# par = (url,)
|
|
# cur.execute(sql, par) # Error? 2024-01-05
|
|
# sql = (
|
|
# "DELETE "
|
|
# "FROM archive "
|
|
# "WHERE feed_id = ?"
|
|
# )
|
|
# par = (url,)
|
|
# cur.execute(sql, par)
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM feeds
|
|
WHERE id = ?
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
def get_feeds_by_tag_id(db_file, tag_id):
|
|
"""
|
|
Get feeds of given tag.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
tag_id : str
|
|
Tag ID.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
List of tags.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} tag_id: {}'
|
|
.format(function_name, db_file, tag_id))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT feeds.*
|
|
FROM feeds
|
|
INNER JOIN feeds_tags ON feeds.id = feeds_tags.feed_id
|
|
INNER JOIN tags ON tags.id = feeds_tags.tag_id
|
|
WHERE tags.id = ?;
|
|
"""
|
|
)
|
|
par = (tag_id,)
|
|
result = cur.execute(sql, par).fetchall()
|
|
return result
|
|
|
|
|
|
def get_tags_by_feed_id(db_file, feed_id):
|
|
"""
|
|
Get tags of given feed.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Feed ID.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
List of tags.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT tags.tag
|
|
FROM tags
|
|
INNER JOIN feeds_tags ON tags.id = feeds_tags.tag_id
|
|
INNER JOIN feeds ON feeds.id = feeds_tags.feed_id
|
|
WHERE feeds.id = ?;
|
|
"""
|
|
)
|
|
par = (feed_id,)
|
|
result = cur.execute(sql, par).fetchall()
|
|
return result
|
|
|
|
|
|
async def set_feed_id_and_tag_id(db_file, feed_id, tag_id):
|
|
"""
|
|
Set Feed ID and Tag ID.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Feed ID
|
|
tag_id : str
|
|
Tag ID
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {} tag_id: {}'
|
|
.format(function_name, db_file, feed_id, tag_id))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO feeds_tags(
|
|
feed_id, tag_id)
|
|
VALUES(
|
|
:feed_id, :tag_id)
|
|
"""
|
|
)
|
|
par = {
|
|
"feed_id": feed_id,
|
|
"tag_id": tag_id
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
def get_tag_id(db_file, tag_name):
|
|
"""
|
|
Get ID of given tag. Check whether tag exist.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
tag_name : str
|
|
Tag name.
|
|
|
|
Returns
|
|
-------
|
|
ix : str
|
|
Tag ID.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} tag_name: {}'
|
|
.format(function_name, db_file, tag_name))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT id
|
|
FROM tags
|
|
WHERE tag = ?
|
|
"""
|
|
)
|
|
par = (tag_name,)
|
|
ix = cur.execute(sql, par).fetchone()
|
|
return ix
|
|
|
|
|
|
def get_tag_name(db_file, ix):
|
|
"""
|
|
Get name of given tag. Check whether tag exist.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
ix : str
|
|
Tag ID.
|
|
|
|
Returns
|
|
-------
|
|
tag_name : str
|
|
Tag name.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT tag
|
|
FROM tags
|
|
WHERE id = ?
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
tag_name = cur.execute(sql, par).fetchone()
|
|
return tag_name
|
|
|
|
|
|
def is_tag_id_associated(db_file, tag_id):
|
|
"""
|
|
Check whether tag_id is associated with any feed.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
tag_id : str
|
|
Tag ID.
|
|
|
|
Returns
|
|
-------
|
|
tag_id : str
|
|
Tag ID.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} tag_id: {}'
|
|
.format(function_name, db_file, tag_id))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT tag_id
|
|
FROM feeds_tags
|
|
WHERE tag_id = :tag_id
|
|
"""
|
|
)
|
|
par = {
|
|
"tag_id": tag_id
|
|
}
|
|
tag_id = cur.execute(sql, par).fetchone()
|
|
return tag_id
|
|
|
|
|
|
async def delete_tag_by_index(db_file, ix):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM tags
|
|
WHERE id = :id
|
|
"""
|
|
)
|
|
par = {
|
|
"id": ix
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
def is_tag_id_of_feed_id(db_file, tag_id, feed_id):
|
|
"""
|
|
Check whether given tag is related with given feed.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Feed ID.
|
|
tag_id : str
|
|
Tag ID.
|
|
|
|
Returns
|
|
-------
|
|
tag_id : str
|
|
Tag ID.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} tag_id: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id, tag_id))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT tag_id
|
|
FROM feeds_tags
|
|
WHERE tag_id = :tag_id AND feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"tag_id": tag_id,
|
|
"feed_id": feed_id
|
|
}
|
|
tag_id = cur.execute(sql, par).fetchone()
|
|
return tag_id
|
|
|
|
|
|
async def delete_feed_id_tag_id(db_file, feed_id, tag_id):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} tag_id: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id, tag_id))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM feeds_tags
|
|
WHERE tag_id = :tag_id AND feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"tag_id": tag_id,
|
|
"feed_id": feed_id
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def set_new_tag(db_file, tag):
|
|
"""
|
|
Set new Tag
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
tag : str
|
|
Tag
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} tag: {}'
|
|
.format(function_name, db_file, tag))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO tags(
|
|
tag)
|
|
VALUES(
|
|
:tag)
|
|
"""
|
|
)
|
|
par = {
|
|
"tag": tag
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def get_feed_id_and_name(db_file, url):
|
|
"""
|
|
Get Id and Name of feed.
|
|
Check whether a feed exists.
|
|
Query for feeds by given url.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
url : str
|
|
URL.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
List of ID and Name of feed.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} url: {}'
|
|
.format(function_name, db_file, url))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT id, name
|
|
FROM feeds
|
|
WHERE url = ?
|
|
"""
|
|
)
|
|
par = (url,)
|
|
result = cur.execute(sql, par).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.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} table: {}'
|
|
.format(function_name, db_file, table))
|
|
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 : str
|
|
Number of rows.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT count(id)
|
|
FROM feeds_state
|
|
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.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
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
|
|
|
|
|
|
async def get_unread_entries(db_file, num):
|
|
"""
|
|
Extract information from unread entries.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
num : str, optional
|
|
Number. The default is None.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
News items.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} num: {}'
|
|
.format(function_name, db_file, num))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT id, title, link, summary, enclosure, feed_id, timestamp
|
|
FROM entries
|
|
WHERE read = 0
|
|
UNION ALL
|
|
SELECT id, title, link, summary, enclosure, feed_id, timestamp
|
|
FROM archive
|
|
ORDER BY timestamp DESC
|
|
LIMIT :num
|
|
"""
|
|
)
|
|
par = (num,)
|
|
result = cur.execute(sql, par).fetchall()
|
|
return result
|
|
|
|
|
|
def get_feed_id_by_entry_index(db_file, ix):
|
|
"""
|
|
Get feed id by entry index.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
ix : str
|
|
Index.
|
|
|
|
Returns
|
|
-------
|
|
feed_id : str
|
|
Feed index.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT feed_id
|
|
FROM entries
|
|
WHERE id = :ix
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
feed_id = cur.execute(sql, par).fetchone()
|
|
return feed_id
|
|
|
|
|
|
async def get_feed_id(db_file, url):
|
|
"""
|
|
Get index of given feed.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
url : str
|
|
URL.
|
|
|
|
Returns
|
|
-------
|
|
feed_id : str
|
|
Feed index.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} url: {}'
|
|
.format(function_name, db_file, url))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT id
|
|
FROM feeds
|
|
WHERE url = :url
|
|
"""
|
|
)
|
|
par = (url,)
|
|
feed_id = cur.execute(sql, par).fetchone()
|
|
return feed_id
|
|
|
|
|
|
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.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: ix: {}'
|
|
.format(function_name, ix))
|
|
sql = (
|
|
"""
|
|
UPDATE entries
|
|
SET read = 1
|
|
WHERE id = ?
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
def get_number_of_unread_entries_by_feed(db_file, feed_id):
|
|
"""
|
|
Count entries of given feed.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Feed Id.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT count(id)
|
|
FROM entries
|
|
WHERE read = 0 AND feed_id = ?
|
|
"""
|
|
)
|
|
par = (feed_id,)
|
|
count = cur.execute(sql, par).fetchone()
|
|
return count
|
|
|
|
|
|
async def mark_feed_as_read(db_file, feed_id):
|
|
"""
|
|
Set read status of entries of given feed as read.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Feed Id.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE entries
|
|
SET read = 1
|
|
WHERE feed_id = ?
|
|
"""
|
|
)
|
|
par = (feed_id,)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def delete_entry_by_id(db_file, ix):
|
|
"""
|
|
Delete entry by Id.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
ix : str
|
|
Index.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM entries
|
|
WHERE id = :ix
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def archive_entry(db_file, ix):
|
|
"""
|
|
Insert entry to archive and delete entry.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
ix : str
|
|
Index.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO archive
|
|
SELECT *
|
|
FROM entries
|
|
WHERE entries.id = :ix
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
try:
|
|
cur.execute(sql, par)
|
|
except Exception as e:
|
|
print('ERROR DB insert from entries into archive at index {} '
|
|
'for {}. Reason: {}'.format(ix, db_file, e))
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM entries
|
|
WHERE id = :ix
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
try:
|
|
cur.execute(sql, par)
|
|
except:
|
|
print('ERROR DB deleting items from table entries at index {} '
|
|
'for DB {}', ix, db_file)
|
|
|
|
|
|
def get_feed_title(db_file, ix):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT name
|
|
FROM feeds
|
|
WHERE id = :ix
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
title = cur.execute(sql, par).fetchone()
|
|
return title
|
|
|
|
|
|
async def set_feed_title(db_file, feed_id, name):
|
|
"""
|
|
Set new name for feed.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Index of feed.
|
|
name : str
|
|
New name.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {} name: {}'
|
|
.format(function_name, db_file, feed_id, name))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE feeds
|
|
SET name = :name
|
|
WHERE id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"name": name,
|
|
"feed_id": feed_id
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
def get_entry_title(db_file, ix):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = ( # TODO Handletable archive too
|
|
"""
|
|
SELECT title
|
|
FROM entries
|
|
WHERE id = :ix
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
title = cur.execute(sql, par).fetchone()
|
|
return title
|
|
|
|
|
|
def get_entry_url(db_file, ix):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = ( # TODO Handletable archive too
|
|
"""
|
|
SELECT link
|
|
FROM entries
|
|
WHERE id = :ix
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
url = cur.execute(sql, par).fetchone()
|
|
return url
|
|
|
|
|
|
def get_feed_url(db_file, ix):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT url
|
|
FROM feeds
|
|
WHERE id = :ix
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
url = cur.execute(sql, par).fetchone()
|
|
return url
|
|
|
|
|
|
async def mark_as_read(db_file, ix):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} ix: {}'
|
|
.format(function_name, db_file, ix))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
# TODO While `async with DBLOCK` does work well from
|
|
# outside of functions, it would be better practice
|
|
# to place it within the functions.
|
|
# 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_archived_entry(cur, ix)
|
|
|
|
|
|
async def mark_all_as_read(db_file):
|
|
"""
|
|
Set read status of all entries as read.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE entries
|
|
SET read = 1
|
|
"""
|
|
)
|
|
cur.execute(sql)
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM archive
|
|
"""
|
|
)
|
|
cur.execute(sql)
|
|
|
|
|
|
async def delete_archived_entry(cur, ix):
|
|
"""
|
|
Delete entry from table archive.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
ix : str
|
|
Index of entry.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: ix: {}'
|
|
.format(function_name, ix))
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM archive
|
|
WHERE id = ?
|
|
"""
|
|
)
|
|
par = (ix,)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def update_statistics(cur):
|
|
"""
|
|
Update table statistics.
|
|
|
|
Parameters
|
|
----------
|
|
cur : object
|
|
Cursor object.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}'.format(function_name))
|
|
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 = ?"
|
|
)
|
|
par = (i,)
|
|
cur.execute(sql, par)
|
|
if cur.fetchone():
|
|
sql = (
|
|
"UPDATE statistics "
|
|
"SET number = :num "
|
|
"WHERE title = :title"
|
|
)
|
|
par = {
|
|
"title": i,
|
|
"num": stat_dict[i]
|
|
}
|
|
cur.execute(sql, par)
|
|
else:
|
|
sql = (
|
|
"SELECT count(id) "
|
|
"FROM statistics"
|
|
)
|
|
count = cur.execute(sql).fetchone()[0]
|
|
ix = count + 1
|
|
sql = (
|
|
"INSERT INTO statistics "
|
|
"VALUES(?,?,?)"
|
|
)
|
|
par = (ix, i, stat_dict[i])
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def set_enabled_status(db_file, feed_id, status):
|
|
"""
|
|
Set status of feed to enabled or not enabled (i.e. disabled).
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Index of feed.
|
|
status : int
|
|
0 or 1.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {} status: {}'
|
|
.format(function_name, db_file, feed_id, status))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE feeds_state
|
|
SET enabled = :status
|
|
WHERE feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"status": status,
|
|
"feed_id": feed_id
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
"""
|
|
TODO
|
|
|
|
Investigate what causes date to be int 0
|
|
|
|
NOTE
|
|
|
|
When time functions of slixfeed.timedate
|
|
were async, there were errors of coroutines
|
|
|
|
"""
|
|
async def add_entry(db_file, title, link, entry_id, feed_id, date,
|
|
read_status):
|
|
"""
|
|
Add a new entry row into the entries table.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
title : str
|
|
Title.
|
|
link : str
|
|
Link.
|
|
entry_id : str
|
|
Entry index.
|
|
feed_id : str
|
|
Feed Id.
|
|
date : str
|
|
Date.
|
|
read_status : str
|
|
0 or 1.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} title: {} link: {} entry_id: {} feed_id: {} date: {} read_status: {}'
|
|
.format(function_name, db_file, title, link, entry_id, feed_id, date, read_status))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO entries(
|
|
title, link, entry_id, feed_id, timestamp, read)
|
|
VALUES(
|
|
:title, :link, :entry_id, :feed_id, :timestamp, :read)
|
|
"""
|
|
)
|
|
par = {
|
|
"title": title,
|
|
"link": link,
|
|
"entry_id": entry_id,
|
|
"feed_id": feed_id,
|
|
"timestamp": date,
|
|
"read": read_status
|
|
}
|
|
cur.execute(sql, par)
|
|
# try:
|
|
# cur.execute(sql, entry)
|
|
# except:
|
|
# # None
|
|
# print("Unknown error for sqlite.add_entry")
|
|
# print(entry)
|
|
# #
|
|
# # print(current_time(), "COROUTINE OBJECT NOW")
|
|
# # for i in entry:
|
|
# # print(type(i))
|
|
# # print(i)
|
|
# # print(type(entry))
|
|
# # print(entry)
|
|
# # print(current_time(), "COROUTINE OBJECT NOW")
|
|
# # breakpoint()
|
|
|
|
|
|
async def add_entries_and_update_timestamp(db_file, feed_id, new_entries):
|
|
"""
|
|
Add new entries.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
new_entries : tuple
|
|
Set of entries as dict.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
for entry in new_entries:
|
|
logger.debug('{}: db_file: {} feed_id: {} entry: {}'
|
|
.format(function_name, db_file, feed_id, entry["title"]))
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO entries(
|
|
title, link, summary, enclosure, entry_id, feed_id, timestamp, read)
|
|
VALUES(
|
|
:title, :link, :summary, :enclosure, :entry_id, :feed_id, :timestamp, :read)
|
|
"""
|
|
)
|
|
par = {
|
|
"title": entry["title"],
|
|
"link": entry["link"],
|
|
"summary": entry["summary"],
|
|
"enclosure": entry["enclosure"],
|
|
"entry_id": entry["entry_id"],
|
|
"feed_id": feed_id,
|
|
"timestamp": entry["date"],
|
|
"read": entry["read_status"]
|
|
}
|
|
cur.execute(sql, par)
|
|
sql = (
|
|
"""
|
|
UPDATE feeds_state
|
|
SET renewed = :renewed
|
|
WHERE feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"renewed": time.time(),
|
|
"feed_id": feed_id
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def set_date(db_file, feed_id):
|
|
"""
|
|
Set renewed date of given feed.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Feed Id.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE feeds_state
|
|
SET renewed = :renewed
|
|
WHERE feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"renewed": time.time(),
|
|
"feed_id": feed_id
|
|
}
|
|
# cur = conn.cursor()
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def update_feed_status(db_file, feed_id, status_code):
|
|
"""
|
|
Set status_code of feed_id in table status.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
url : str
|
|
Feed URL.
|
|
status : str
|
|
Status ID or message.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
print('{}: db_file: {} feed_id: {} status_code: {}'
|
|
.format(function_name, db_file, feed_id, status_code))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE feeds_state
|
|
SET status_code = :status_code, scanned = :scanned
|
|
WHERE feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"status_code": status_code,
|
|
"scanned": time.time(),
|
|
"feed_id": feed_id
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def update_feed_validity(db_file, feed_id, valid):
|
|
"""
|
|
Set validity status of feed_id in table status.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
url : str
|
|
Feed URL.
|
|
valid : boolean
|
|
0 or 1.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {} valid: {}'
|
|
.format(function_name, db_file, feed_id, valid))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE feeds_state
|
|
SET valid = :valid
|
|
WHERE feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"valid": valid,
|
|
"feed_id": feed_id
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def update_feed_properties(db_file, feed_id, entries, updated):
|
|
"""
|
|
Update properties of url in table feeds.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
url : str
|
|
Feed URL.
|
|
entries : int
|
|
Number of entries.
|
|
updated : ???
|
|
Date feed was last updated.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {} entries: {} updated: {}'
|
|
.format(function_name, db_file, feed_id, entries, updated))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE feeds_properties
|
|
SET entries = :entries
|
|
WHERE feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"entries" : entries,
|
|
"feed_id": feed_id
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def maintain_archive(db_file, limit):
|
|
"""
|
|
Maintain list of archived entries equal to specified number of items.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
limit : str
|
|
Number of maximum entries to store.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} limit: {}'
|
|
.format(function_name, db_file, limit))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT count(id)
|
|
FROM archive
|
|
"""
|
|
)
|
|
count = cur.execute(sql).fetchone()[0]
|
|
# FIXME Upon first time joining to a groupchat
|
|
# and then adding a URL, variable "limit"
|
|
# becomes a string in one of the iterations.
|
|
# if isinstance(limit,str):
|
|
# print("STOP")
|
|
# breakpoint()
|
|
difference = count - int(limit)
|
|
if difference > 0:
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM archive
|
|
WHERE id
|
|
IN (
|
|
SELECT id
|
|
FROM archive
|
|
ORDER BY timestamp ASC
|
|
LIMIT :difference
|
|
)
|
|
"""
|
|
)
|
|
par = {
|
|
"difference": difference
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
# 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 get_entries_of_feed(db_file, feed_id):
|
|
"""
|
|
Get entries of given feed.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
feed_id : str
|
|
Feed Id.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{} db_file: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT id, title, link, entry_id, timestamp, read
|
|
FROM entries
|
|
WHERE feed_id = ?
|
|
ORDER BY timestamp DESC
|
|
"""
|
|
)
|
|
par = (feed_id,)
|
|
items = cur.execute(sql, par).fetchall()
|
|
return items
|
|
|
|
|
|
# TODO What is this function for? 2024-01-02
|
|
# async def get_feeds(db_file):
|
|
# """
|
|
# Query table feeds for Title, URL, Categories, Tags.
|
|
|
|
# Parameters
|
|
# ----------
|
|
# db_file : str
|
|
# Path to database file.
|
|
|
|
# Returns
|
|
# -------
|
|
# result : tuple
|
|
# 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
|
|
|
|
# TODO select by "feed_id" (of table "status") from
|
|
# "feed" urls that are enabled in table "status"
|
|
async def get_feeds_url(db_file):
|
|
"""
|
|
Query table feeds for URLs.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
URLs of active feeds.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{} db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT url
|
|
FROM feeds
|
|
"""
|
|
)
|
|
result = cur.execute(sql).fetchall()
|
|
return result
|
|
|
|
|
|
def get_feeds_by_enabled_state(db_file, enabled_state):
|
|
"""
|
|
Query table feeds by enabled state.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
enabled_state : boolean
|
|
False or True.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
List of URLs.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} enabled_state: {}'
|
|
.format(function_name, db_file, enabled_state))
|
|
if enabled_state:
|
|
enabled_state = 1
|
|
else:
|
|
enabled_state = 0
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT feeds.*
|
|
FROM feeds
|
|
INNER JOIN feeds_state ON feeds.id = feeds_state.feed_id
|
|
WHERE feeds_state.enabled = ?
|
|
"""
|
|
)
|
|
par = (enabled_state,)
|
|
result = cur.execute(sql, par).fetchall()
|
|
return result
|
|
|
|
|
|
async def get_active_feeds_url(db_file):
|
|
"""
|
|
Query table feeds for active URLs.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
URLs of active feeds.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT feeds.url
|
|
FROM feeds
|
|
INNER JOIN feeds_state ON feeds.id = feeds_state.feed_id
|
|
WHERE feeds_state.enabled = 1
|
|
"""
|
|
)
|
|
result = cur.execute(sql).fetchall()
|
|
return result
|
|
|
|
|
|
def get_tags(db_file):
|
|
"""
|
|
Query table tags and list items.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
List of tags.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT tag, id
|
|
FROM tags
|
|
"""
|
|
)
|
|
result = cur.execute(sql).fetchall()
|
|
return result
|
|
|
|
|
|
async def get_feeds(db_file):
|
|
"""
|
|
Query table feeds and list items.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
URLs of feeds.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
# TODO
|
|
# 1) Select id from table feeds
|
|
# Select name, url (feeds) updated, enabled, feed_id (status)
|
|
# 2) Sort feeds by id. Sort status by feed_id
|
|
# result += cur.execute(sql).fetchall()
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT name, url, id
|
|
FROM feeds
|
|
"""
|
|
)
|
|
result = cur.execute(sql).fetchall()
|
|
return result
|
|
|
|
|
|
async def last_entries(db_file, num):
|
|
"""
|
|
Query entries.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
num : str
|
|
Number.
|
|
|
|
Returns
|
|
-------
|
|
titles_list : tuple
|
|
List of recent N entries as message.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} num: {}'
|
|
.format(function_name, db_file, num))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
# sql = (
|
|
# "SELECT title, link "
|
|
# "FROM entries "
|
|
# "ORDER BY ROWID DESC "
|
|
# "LIMIT :num"
|
|
# )
|
|
sql = (
|
|
"""
|
|
SELECT title, link, timestamp
|
|
FROM entries
|
|
WHERE read = 0
|
|
UNION ALL
|
|
SELECT title, link, timestamp
|
|
FROM archive
|
|
WHERE read = 0
|
|
ORDER BY timestamp DESC
|
|
LIMIT :num
|
|
"""
|
|
)
|
|
par = (num,)
|
|
result = cur.execute(sql, par).fetchall()
|
|
return result
|
|
|
|
|
|
def search_feeds(db_file, query):
|
|
"""
|
|
Query feeds.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
query : str
|
|
Search query.
|
|
|
|
Returns
|
|
-------
|
|
result : tuple
|
|
Feeds of specified keywords as message.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} query: {}'
|
|
.format(function_name, db_file, query))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT name, id, url
|
|
FROM feeds
|
|
WHERE name LIKE ?
|
|
OR url LIKE ?
|
|
LIMIT 50
|
|
"""
|
|
)
|
|
par = [f'%{query}%', f'%{query}%']
|
|
result = cur.execute(sql, par).fetchall()
|
|
return result
|
|
|
|
|
|
async def search_entries(db_file, query):
|
|
"""
|
|
Query entries.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
query : str
|
|
Search query.
|
|
|
|
Returns
|
|
-------
|
|
titles_list : tuple
|
|
Entries of specified keywords as message.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} query: {}'
|
|
.format(function_name, db_file, query))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT title, link
|
|
FROM entries
|
|
WHERE title LIKE ?
|
|
UNION ALL
|
|
SELECT title, link
|
|
FROM archive
|
|
WHERE title LIKE ?
|
|
LIMIT 50
|
|
"""
|
|
)
|
|
par = (f'%{query}%', f'%{query}%')
|
|
result = cur.execute(sql, par).fetchall()
|
|
return result
|
|
|
|
|
|
"""
|
|
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
|
|
|
|
"""
|
|
def check_entry_exist(db_file, feed_id, entry_id=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.
|
|
feed_id : str
|
|
Feed Id.
|
|
entry_id : 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.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} feed_id: {}'
|
|
.format(function_name, db_file, feed_id))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
exist = False
|
|
if entry_id:
|
|
sql = (
|
|
"""
|
|
SELECT id
|
|
FROM entries
|
|
WHERE entry_id = :entry_id and feed_id = :feed_id
|
|
"""
|
|
)
|
|
par = {
|
|
"entry_id": entry_id,
|
|
"feed_id": feed_id
|
|
}
|
|
result = cur.execute(sql, par).fetchone()
|
|
if result: exist = True
|
|
elif date:
|
|
sql = (
|
|
"""
|
|
SELECT id
|
|
FROM entries
|
|
WHERE title = :title AND link = :link AND timestamp = :date
|
|
"""
|
|
)
|
|
par = {
|
|
"title": title,
|
|
"link": link,
|
|
"date": date
|
|
}
|
|
try:
|
|
result = cur.execute(sql, par).fetchone()
|
|
if result: exist = True
|
|
except:
|
|
logger.error("source =", feed_id)
|
|
logger.error("date =", date)
|
|
else:
|
|
sql = (
|
|
"""
|
|
SELECT id
|
|
FROM entries
|
|
WHERE title = :title AND link = :link
|
|
"""
|
|
)
|
|
par = {
|
|
"title": title,
|
|
"link": link
|
|
}
|
|
result = cur.execute(sql, par).fetchone()
|
|
if result: exist = True
|
|
# try:
|
|
# if result:
|
|
# return True
|
|
# else:
|
|
# return None
|
|
# except:
|
|
# print(current_time(), "ERROR DATE: result =", url)
|
|
return exist
|
|
|
|
|
|
async def set_setting_value(db_file, key_value):
|
|
"""
|
|
Set setting value.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
key_value : list
|
|
key : str
|
|
enabled, interval, masters, quantum, random.
|
|
value : int
|
|
Numeric value.
|
|
"""
|
|
key = key_value[0]
|
|
val = key_value[1]
|
|
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {} val: {}'
|
|
.format(function_name, db_file, key, val))
|
|
|
|
if not val:
|
|
logger.error('Missing value for key "{}" ({}).'.format(key, db_file))
|
|
return
|
|
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO settings(
|
|
key, value)
|
|
VALUES(
|
|
:key, :val)
|
|
"""
|
|
)
|
|
par = {
|
|
"key": key,
|
|
"val": val
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def update_setting_value(db_file, key_value):
|
|
"""
|
|
Update setting value.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
key_value : list
|
|
key : str
|
|
enabled, 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]
|
|
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {} val: {}'
|
|
.format(function_name, db_file, key, val))
|
|
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE settings
|
|
SET value = :val
|
|
WHERE key = :key
|
|
"""
|
|
)
|
|
par = {
|
|
"key": key,
|
|
"val": val
|
|
}
|
|
cur.execute(sql, par)
|
|
# except:
|
|
# logging.debug(
|
|
# "No specific value set for key {}.".format(key)
|
|
# )
|
|
|
|
|
|
async def delete_filter(db_file, key):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {}'
|
|
.format(function_name, db_file, key))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM filters
|
|
WHERE key = ?
|
|
"""
|
|
)
|
|
par = (key,)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def delete_setting(db_file, key):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {}'
|
|
.format(function_name, db_file, key))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM settings
|
|
WHERE key = ?
|
|
"""
|
|
)
|
|
par = (key,)
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def delete_settings(db_file):
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
DELETE
|
|
FROM settings
|
|
"""
|
|
)
|
|
cur.execute(sql)
|
|
|
|
|
|
def get_setting_value(db_file, key):
|
|
"""
|
|
Get settings value.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
key : str
|
|
Key: archive, enabled, filter-allow, filter-deny,
|
|
interval, length, old, quantum, random.
|
|
|
|
Returns
|
|
-------
|
|
val : str
|
|
Numeric value.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {}'
|
|
.format(function_name, db_file, key))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT value
|
|
FROM settings
|
|
WHERE key = ?
|
|
"""
|
|
)
|
|
par = (key,)
|
|
value = cur.execute(sql, par).fetchone()
|
|
return value
|
|
|
|
|
|
def is_setting_key(db_file, key):
|
|
"""
|
|
Check whether setting key exist.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
key : str
|
|
Key: allow, deny.
|
|
|
|
Returns
|
|
-------
|
|
key : str
|
|
Key.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {}'
|
|
.format(function_name, db_file, key))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT key
|
|
FROM settings
|
|
WHERE key = ?
|
|
"""
|
|
)
|
|
par = (key,)
|
|
key = cur.execute(sql, par).fetchone()
|
|
return key
|
|
|
|
|
|
async def set_filter_value(db_file, key_value):
|
|
"""
|
|
Set settings value.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
key_value : list
|
|
key : str
|
|
allow, deny, replace.
|
|
value : int
|
|
Numeric value.
|
|
"""
|
|
key = key_value[0]
|
|
val = key_value[1]
|
|
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {} val: {}'
|
|
.format(function_name, db_file, key, val))
|
|
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO filters(
|
|
key, value)
|
|
VALUES(
|
|
:key, :val)
|
|
"""
|
|
)
|
|
par = {
|
|
"key": key,
|
|
"val": val
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def update_filter_value(db_file, key_value):
|
|
"""
|
|
Update settings value.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
key_value : list
|
|
key : str
|
|
allow, deny, replace.
|
|
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]
|
|
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {} val: {}'
|
|
.format(function_name, db_file, key, val))
|
|
|
|
async with DBLOCK:
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE filters
|
|
SET value = :value
|
|
WHERE key = :key
|
|
"""
|
|
)
|
|
par = {
|
|
"key": key,
|
|
"value": val
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
def is_filter_key(db_file, key):
|
|
"""
|
|
Check whether filter key exist.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
key : str
|
|
Key: allow, deny.
|
|
|
|
Returns
|
|
-------
|
|
key : str
|
|
Key.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {}'
|
|
.format(function_name, db_file, key))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT key
|
|
FROM filters
|
|
WHERE key = ?
|
|
"""
|
|
)
|
|
par = (key,)
|
|
key = cur.execute(sql, par).fetchone()
|
|
return key
|
|
|
|
|
|
def get_filter_value(db_file, key):
|
|
"""
|
|
Get filter value.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
key : str
|
|
Key: allow, deny.
|
|
|
|
Returns
|
|
-------
|
|
value : str
|
|
List of strings.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} key: {}'
|
|
.format(function_name, db_file, key))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT value
|
|
FROM filters
|
|
WHERE key = ?
|
|
"""
|
|
)
|
|
par = (key,)
|
|
value = cur.execute(sql, par).fetchone()
|
|
return value
|
|
|
|
|
|
async def set_last_update_time(db_file):
|
|
"""
|
|
Set value of last_update.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
None.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
INSERT
|
|
INTO status(
|
|
key, value)
|
|
VALUES(
|
|
:key, :value)
|
|
"""
|
|
)
|
|
par = {
|
|
"key": "last_update",
|
|
"value": time.time()
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
|
|
async def get_last_update_time(db_file):
|
|
"""
|
|
Get value of last_update.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
val : str
|
|
Time.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
try:
|
|
sql = (
|
|
"""
|
|
SELECT value
|
|
FROM status
|
|
WHERE key = "last_update"
|
|
"""
|
|
)
|
|
value = cur.execute(sql).fetchone()[0]
|
|
value = str(value)
|
|
except:
|
|
value = None
|
|
logger.debug(
|
|
"No specific value set for key last_update.")
|
|
return value
|
|
|
|
|
|
async def update_last_update_time(db_file):
|
|
"""
|
|
Update value of last_update.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
None.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
UPDATE status
|
|
SET value = :value
|
|
WHERE key = "last_update"
|
|
"""
|
|
)
|
|
par = {
|
|
"value": time.time()
|
|
}
|
|
cur.execute(sql, par)
|
|
|
|
########################################
|
|
|
|
######### EXPERIMENTAL TABLE ###########
|
|
|
|
########################################
|
|
|
|
def get_categories(db_file):
|
|
"""
|
|
Get list of categories.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : tuple
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
categories : str
|
|
List of categories.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT DISTINCT category
|
|
FROM entries
|
|
ORDER BY category ASC
|
|
"""
|
|
)
|
|
categories = cur.execute(sql).fetchall()
|
|
return categories
|
|
|
|
|
|
def get_locales(db_file):
|
|
"""
|
|
Get list of locales.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
locales : tuple
|
|
List of locales.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT DISTINCT locale
|
|
FROM entries
|
|
ORDER BY locale ASC
|
|
"""
|
|
)
|
|
locales = cur.execute(sql).fetchall()
|
|
return locales
|
|
|
|
|
|
def get_nations(db_file):
|
|
"""
|
|
Get list of nations.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
nations : tuple
|
|
List of nations.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT DISTINCT nation
|
|
FROM entries
|
|
ORDER BY nation ASC
|
|
"""
|
|
)
|
|
locales = cur.execute(sql).fetchall()
|
|
return locales
|
|
|
|
|
|
# def get_tags(db_file):
|
|
# """
|
|
# Get list of title and urls.
|
|
|
|
# Parameters
|
|
# ----------
|
|
# db_file : str
|
|
# Path to database file.
|
|
|
|
# Returns
|
|
# -------
|
|
# titles_urls : tuple
|
|
# List of titles and urls.
|
|
# """
|
|
# with create_connection(db_file) as conn:
|
|
# cur = conn.cursor()
|
|
# sql = (
|
|
# """
|
|
# SELECT tags
|
|
# FROM entries
|
|
# ORDER BY tags ASC
|
|
# """
|
|
# )
|
|
# titles_urls = cur.execute(sql).fetchall()
|
|
# return titles_urls
|
|
|
|
|
|
def get_titles_tags_urls(db_file):
|
|
"""
|
|
Get list of title and urls.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
titles_urls : tuple
|
|
List of titles and urls.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {}'
|
|
.format(function_name, db_file))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT title, tags, url
|
|
FROM entries
|
|
ORDER BY title ASC
|
|
LIMIT 800
|
|
"""
|
|
)
|
|
titles_tags_urls = cur.execute(sql).fetchall()
|
|
return titles_tags_urls
|
|
|
|
|
|
def get_titles_tags_urls_by_category(db_file, category):
|
|
"""
|
|
Get list of title and urls of given category.
|
|
|
|
Parameters
|
|
----------
|
|
db_file : str
|
|
Path to database file.
|
|
|
|
Returns
|
|
-------
|
|
titles_urls : tuple
|
|
List of titles and urls.
|
|
"""
|
|
function_name = sys._getframe().f_code.co_name
|
|
logger.debug('{}: db_file: {} category: {}'
|
|
.format(function_name, db_file, category))
|
|
with create_connection(db_file) as conn:
|
|
cur = conn.cursor()
|
|
sql = (
|
|
"""
|
|
SELECT title, tags, url
|
|
FROM entries
|
|
WHERE category = :category
|
|
ORDER BY title ASC
|
|
"""
|
|
)
|
|
par = {
|
|
"category": category
|
|
}
|
|
titles_tags_urls = cur.execute(sql, par).fetchall()
|
|
return titles_tags_urls
|