375 lines
14 KiB
Python
375 lines
14 KiB
Python
from configparser import ConfigParser
|
|
from psycopg2.pool import ThreadedConnectionPool
|
|
from psycopg2.extras import RealDictCursor
|
|
from contextlib import contextmanager
|
|
from os import access, W_OK, makedirs, chmod, system
|
|
from os.path import isfile, join, basename
|
|
from shutil import move
|
|
from magic import Magic
|
|
from preview_generator.manager import PreviewManager
|
|
|
|
conf = None
|
|
|
|
mage = None
|
|
previewer = None
|
|
|
|
db_pool = None
|
|
|
|
DEFAULT_SORTING = {
|
|
"files": {
|
|
"key": "created",
|
|
"asc": False
|
|
},
|
|
"tags": {
|
|
"key": "created",
|
|
"asc": False
|
|
},
|
|
"categories": {
|
|
"key": "created",
|
|
"asc": False
|
|
},
|
|
"pools": {
|
|
"key": "created",
|
|
"asc": False
|
|
},
|
|
}
|
|
|
|
|
|
def Initialize(conf_path="/etc/tfm/tfm.conf"):
|
|
global mage, previewer
|
|
load_config(conf_path)
|
|
mage = Magic(mime=True)
|
|
previewer = PreviewManager(conf["Paths"]["Thumbs"])
|
|
db_connect(conf["DB.limits"]["MinimumConnections"], conf["DB.limits"]["MaximumConnections"], **conf["DB.params"])
|
|
|
|
|
|
def load_config(path):
|
|
global conf
|
|
conf = ConfigParser()
|
|
conf.read(path)
|
|
|
|
|
|
def db_connect(minconn, maxconn, **kwargs):
|
|
global db_pool
|
|
db_pool = ThreadedConnectionPool(minconn, maxconn, **kwargs)
|
|
|
|
|
|
@contextmanager
|
|
def _db_cursor():
|
|
global db_pool
|
|
try:
|
|
conn = db_pool.getconn()
|
|
except:
|
|
raise RuntimeError("Database not connected")
|
|
try:
|
|
with conn.cursor(cursor_factory=RealDictCursor) as cur:
|
|
yield cur
|
|
conn.commit()
|
|
except:
|
|
conn.rollback()
|
|
raise
|
|
finally:
|
|
db_pool.putconn(conn)
|
|
|
|
|
|
def _validate_column_name(cur, table, column):
|
|
cur.execute("SELECT get_column_names(%s) AS name", (table,))
|
|
if all([column!=col["name"] for col in cur.fetchall()]):
|
|
raise RuntimeError("Invalid column name")
|
|
|
|
|
|
def authorize(username, password, useragent):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_session_request(tfm_user_auth(%s, %s), %s) AS sid", (username, password, useragent))
|
|
sid = cur.fetchone()["sid"]
|
|
return TSession(sid)
|
|
|
|
|
|
class TSession:
|
|
sid = None
|
|
|
|
def __init__(self, sid):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_session_validate(%s) IS NOT NULL AS valid", (sid,))
|
|
if not cur.fetchone()["valid"]:
|
|
raise RuntimeError("Invalid sid")
|
|
self.sid = sid
|
|
|
|
def terminate(self):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_session_terminate(%s)", (self.sid,))
|
|
del self
|
|
|
|
@property
|
|
def username(self):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_session_username(%s) AS name", (self.sid,))
|
|
return cur.fetchone()["name"]
|
|
|
|
@property
|
|
def is_admin(self):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT * FROM tfm_user_get_info(%s)", (self.sid,))
|
|
return cur.fetchone()["can_edit"]
|
|
|
|
def get_files(self, order_key=DEFAULT_SORTING["files"]["key"], order_asc=DEFAULT_SORTING["files"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_files", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_files(%%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid,))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_files_by_filter(self, philter=None, order_key=DEFAULT_SORTING["files"]["key"], order_asc=DEFAULT_SORTING["files"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_files", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_files_by_filter(%%s, %%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid, philter))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_tags(self, order_key=DEFAULT_SORTING["tags"]["key"], order_asc=DEFAULT_SORTING["tags"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_tags", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_tags(%%s) ORDER BY %s %s, name ASC OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid,))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_categories(self, order_key=DEFAULT_SORTING["categories"]["key"], order_asc=DEFAULT_SORTING["categories"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_categories", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_categories(%%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid,))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_pools(self, order_key=DEFAULT_SORTING["pools"]["key"], order_asc=DEFAULT_SORTING["pools"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_pools", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_pools(%%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid,))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_autotags(self, order_key="child_id", order_asc=True, offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_autotags", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_autotags(%%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid,))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_my_sessions(self, order_key="started", order_asc=False, offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_sessions", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_my_sessions(%%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid,))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_tags_by_file(self, file_id, order_key=DEFAULT_SORTING["tags"]["key"], order_asc=DEFAULT_SORTING["tags"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_tags", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_tags_by_file(%%s, %%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid, file_id))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_files_by_tag(self, tag_id, order_key=DEFAULT_SORTING["files"]["key"], order_asc=DEFAULT_SORTING["files"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_files", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_files_by_tag(%%s, %%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid, tag_id))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_files_by_pool(self, pool_id, order_key=DEFAULT_SORTING["files"]["key"], order_asc=DEFAULT_SORTING["files"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_files", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_files_by_pool(%%s, %%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid, pool_id))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_parent_tags(self, tag_id, order_key=DEFAULT_SORTING["tags"]["key"], order_asc=DEFAULT_SORTING["tags"]["asc"], offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_tags", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_parent_tags(%%s, %%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid, tag_id))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_my_file_views(self, file_id=None, order_key="datetime", order_asc=False, offset=0, limit=None):
|
|
with _db_cursor() as cur:
|
|
_validate_column_name(cur, "v_files", order_key)
|
|
cur.execute("SELECT * FROM tfm_get_my_file_views(%%s, %%s) ORDER BY %s %s OFFSET %s LIMIT %s" % (
|
|
order_key,
|
|
"ASC" if order_asc else "DESC",
|
|
int(offset),
|
|
int(limit) if limit is not None else "ALL"
|
|
), (self.sid, file_id))
|
|
return list(map(dict, cur.fetchall()))
|
|
|
|
def get_file(self, file_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT * FROM tfm_get_files(%s) WHERE id=%s", (self.sid, file_id))
|
|
return cur.fetchone()
|
|
|
|
def get_tag(self, tag_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT * FROM tfm_get_tags(%s) WHERE id=%s", (self.sid, tag_id))
|
|
return cur.fetchone()
|
|
|
|
def get_category(self, category_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT * FROM tfm_get_categories(%s) WHERE id=%s", (self.sid, category_id))
|
|
return cur.fetchone()
|
|
|
|
def view_file(self, file_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_view_file(%s, %s)", (self.sid, file_id))
|
|
|
|
def add_file(self, path, datetime=None, notes=None, is_private=None, orig_name=True):
|
|
if not isfile(path):
|
|
raise FileNotFoundError("No such file '%s'" % path)
|
|
if not access(conf["Paths"]["Files"], W_OK) or not access(conf["Paths"]["Thumbs"], W_OK):
|
|
raise PermissionError("Invalid directories for files and thumbs")
|
|
mime = mage.from_file(path)
|
|
if orig_name == True:
|
|
orig_name = basename(path)
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT * FROM tfm_add_file(%s, %s, %s, %s, %s, %s)", (self.sid, mime, datetime, notes, is_private, orig_name))
|
|
res = cur.fetchone()
|
|
file_id = res["f_id"]
|
|
ext = res["ext"]
|
|
file_path = join(conf["Paths"]["Files"], "%s.%s" % (file_id, ext))
|
|
move(path, file_path)
|
|
thumb_path = previewer.get_jpeg_preview(file_path, height=160, width=160)
|
|
preview_path = previewer.get_jpeg_preview(file_path, height=1080, width=1920)
|
|
chmod(file_path, 0o664)
|
|
chmod(thumb_path, 0o664)
|
|
chmod(preview_path, 0o664)
|
|
return file_id, ext
|
|
|
|
def add_tag(self, name, notes=None, color=None, category_id=None, is_private=None):
|
|
if color is not None:
|
|
color = color.replace('#', '')
|
|
if not category_id:
|
|
category_id = None
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_add_tag(%s, %s, %s, %s, %s, %s) AS id", (self.sid, name, notes, color, category_id, is_private))
|
|
return cur.fetchone()["id"]
|
|
|
|
def add_category(self, name, notes=None, color=None, is_private=None):
|
|
if color is not None:
|
|
color = color.replace('#', '')
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_add_category(%s, %s, %s, %s, %s) AS id", (self.sid, name, notes, color, is_private))
|
|
return cur.fetchone()["id"]
|
|
|
|
def add_pool(self, name, notes=None, parent_id=None, is_private=None):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_add_pool(%s, %s, %s, %s, %s) AS id", (self.sid, name, notes, parent_id, is_private))
|
|
return cur.fetchone()["id"]
|
|
|
|
def add_autotag(self, child_id, parent_id, is_active=None, apply_to_existing=None):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_add_autotag(%s, %s, %s, %s, %s) AS added", (self.sid, child_id, parent_id, is_active, apply_to_existing))
|
|
return cur.fetchone()["added"]
|
|
|
|
def add_file_to_tag(self, file_id, tag_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_add_file_to_tag(%s, %s, %s) AS id", (self.sid, file_id, tag_id))
|
|
return list(map(lambda t: t["id"], cur.fetchall()))
|
|
|
|
def add_file_to_pool(self, file_id, pool_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("SELECT tfm_add_file_to_pool(%s, %s, %s) AS added", (self.sid, file_id, pool_id))
|
|
return cur.fetchone()["added"]
|
|
|
|
def edit_file(self, file_id, mime=None, datetime=None, notes=None, is_private=None):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_edit_file(%s, %s, %s, %s, %s, %s)", (self.sid, file_id, mime, datetime, notes, is_private))
|
|
|
|
def edit_tag(self, tag_id, name=None, notes=None, color=None, category_id=None, is_private=None):
|
|
if color is not None:
|
|
color = color.replace('#', '')
|
|
if not category_id:
|
|
category_id = None
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_edit_tag(%s, %s, %s, %s, %s, %s, %s)", (self.sid, tag_id, name, notes, color, category_id, is_private))
|
|
|
|
def edit_category(self, category_id, name=None, notes=None, color=None, is_private=None):
|
|
if color is not None:
|
|
color = color.replace('#', '')
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_edit_category(%s, %s, %s, %s, %s, %s)", (self.sid, category_id, name, notes, color, is_private))
|
|
|
|
def edit_pool(self, pool_id, name=None, notes=None, parent_id=None, is_private=None):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_edit_pool(%s, %s, %s, %s, %s, %s)", (self.sid, pool_id, name, notes, parent_id, is_private))
|
|
|
|
def remove_file(self, file_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_remove_file(%s, %s)", (self.sid, file_id))
|
|
if system("rm %s/%s*" % (conf["Paths"]["Files"], file_id)):
|
|
raise RuntimeError("Failed to remove file '%s'" % file_id)
|
|
|
|
def remove_tag(self, tag_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_remove_tag(%s, %s)", (self.sid, tag_id))
|
|
|
|
def remove_category(self, category_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_remove_category(%s, %s)", (self.sid, category_id))
|
|
|
|
def remove_pool(self, pool_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_remove_pool(%s, %s)", (self.sid, pool_id))
|
|
|
|
def remove_autotag(self, child_id, parent_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_remove_autotag(%s, %s, %s)", (self.sid, child_id, parent_id))
|
|
|
|
def remove_file_to_tag(self, file_id, tag_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_remove_file_to_tag(%s, %s, %s)", (self.sid, file_id, tag_id))
|
|
|
|
def remove_file_to_pool(self, file_id, pool_id):
|
|
with _db_cursor() as cur:
|
|
cur.execute("CALL tfm_remove_file_to_pool(%s, %s, %s)", (self.sid, file_id, pool_id))
|