290 lines
8.3 KiB
Python
290 lines
8.3 KiB
Python
import sys
|
|
import sqlite3
|
|
|
|
import permissions
|
|
|
|
dbFile = 'sqLibrary.db'
|
|
bookTable = 'books'
|
|
bookCategoryTable='book_categories'
|
|
categoryTable = 'categories'
|
|
|
|
|
|
bookTableCreation = '''
|
|
CREATE TABLE IF NOT EXISTS books
|
|
(id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
isbn, lccn, title, subtitle, authors, edition,
|
|
publisher, publish_year, publish_month, publish_location,
|
|
pages, pagination, weight,
|
|
last_updated DATETIME DEFAULT current_timestamp,
|
|
deleted BOOLEAN DEFAULT 0);
|
|
|
|
CREATE TABLE IF NOT EXISTS categories
|
|
(cat_id INTEGER PRIMARY KEY, category STRING UNIQUE ON CONFLICT IGNORE);
|
|
|
|
CREATE TABLE IF NOT EXISTS book_categories
|
|
(id INTEGER, cat_id INTEGER);
|
|
'''
|
|
|
|
columns = ['id', 'isbn', 'lccn',
|
|
'title', 'subtitle', 'authors', 'edition',
|
|
'publisher', 'publish year', 'publish month', 'publish location',
|
|
'pages', 'pagination', 'weight', 'last updated', 'deleted']
|
|
|
|
bookTriggerCreation = '''
|
|
|
|
CREATE TRIGGER IF NOT EXISTS update_books_time AFTER UPDATE ON books
|
|
BEGIN
|
|
UPDATE books SET last_updated = DATETIME('NOW') WHERE rowid = new.rowid;
|
|
END;
|
|
|
|
CREATE TRIGGER IF NOT EXISTS delete_book AFTER DELETE ON books
|
|
BEGIN
|
|
DELETE FROM book_categories WHERE id = old.rowid;
|
|
END;
|
|
|
|
CREATE TRIGGER IF NOT EXISTS delete_category AFTER DELETE ON categories
|
|
BEGIN
|
|
DELETE FROM book_categories WHERE cat_id = old.cat_id;
|
|
END;
|
|
|
|
CREATE TRIGGER IF NOT EXISTS insert_book_category_time AFTER INSERT
|
|
ON book_categories
|
|
BEGIN
|
|
UPDATE books SET last_updated = DATETIME('NOW') WHERE id = new.id;
|
|
END;
|
|
'''
|
|
|
|
################################3
|
|
# character escaping, etc for sql queries
|
|
#################################
|
|
def _colify(s):
|
|
return s.replace(" ","_").lower()
|
|
|
|
def _stringify(v):
|
|
return '"' + str(v).strip().replace('"','""') + '"'
|
|
|
|
###################################
|
|
# book functions
|
|
##################################
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def addBook(book):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
cols = []
|
|
vals = []
|
|
for k,v in book.items():
|
|
if v!="":
|
|
cols.append(_colify(k))
|
|
vals.append(_stringify(v))
|
|
|
|
query = ("INSERT INTO "+bookTable+" ("+", ".join(cols)+") VALUES ("+
|
|
", ".join(vals)+");")
|
|
c.execute(query)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def updateBook(book, bookID):
|
|
'''
|
|
Takes book attribute dictionary and a string representating the book ID
|
|
number, and returns updates the book accordingly
|
|
'''
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
updates=[]
|
|
for k,v in book.items():
|
|
updates.append(_colify(k)+"="+_stringify(v))
|
|
query = ("UPDATE "+bookTable+" SET " + ", ".join(updates)+" WHERE id = " +
|
|
str(bookID)+";")
|
|
c.execute(query)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
def getBooks():
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = "SELECT * FROM "+bookTable+" WHERE deleted=0;"
|
|
c.execute(query)
|
|
books = [_query_to_book(b) for b in c]
|
|
c.close()
|
|
return books
|
|
|
|
def getBooksByCategory(cat):
|
|
'''
|
|
Takes a string representating the category ID number, and returns
|
|
non-deleted books in that category
|
|
'''
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = ("SELECT "+",".join(map(_colify,columns))+" FROM "+bookTable+
|
|
" JOIN "+bookCategoryTable+
|
|
" USING (id) WHERE cat_id = :id AND deleted=0;")
|
|
c.execute(query,cat)
|
|
books = [_query_to_book(b) for b in c]
|
|
c.close()
|
|
return books
|
|
|
|
def getRemovedBooks():
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = "SELECT * FROM "+bookTable+" WHERE DELETED=1;"
|
|
c.execute(query)
|
|
books = [_query_to_book(b) for b in c]
|
|
c.close()
|
|
return books
|
|
|
|
def getBookByID(bookid):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = "SELECT * FROM "+bookTable+" WHERE id = "+str(bookid)+";"
|
|
c.execute(query)
|
|
book = _query_to_book(c.fetchone())
|
|
c.close()
|
|
return book
|
|
|
|
# removes book from catalogue
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def removeBook(bookid):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = "UPDATE " +bookTable+ " SET deleted=1 WHERE id = "+str(bookid)+";"
|
|
c.execute(query)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def removeBooks(books):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query1 = "UPDATE " +bookTable+ " SET deleted=1 WHERE id = :id;"
|
|
for book in books:
|
|
c.execute(query1, book)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
# restores trashed books
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def restoreBooks(books):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query1 = "UPDATE " +bookTable+ " SET deleted=0 WHERE id = :id;"
|
|
for book in books:
|
|
c.execute(query1,book)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
# fully deletes book from books table
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def deleteBook(bookid):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = "DELETE FROM " +bookTable+ " WHERE id = "+str(bookid)+";"
|
|
c.execute(query)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def deleteBooks(books):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = "DELETE FROM " +bookTable+ " WHERE id = :id;"
|
|
for book in books:
|
|
c.execute(query, book)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
def _query_to_book(book_query):
|
|
# Make a dict out of column name and query results.
|
|
# Empty entries return None, which are removed from the dict.
|
|
return dict(filter(lambda t:t[1], zip(columns,book_query)))
|
|
|
|
#########################################
|
|
# Category related functions
|
|
########################################
|
|
def getBookCategories(book):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = ("SELECT id,cat_id,category FROM "+bookCategoryTable+" JOIN "+
|
|
categoryTable+" USING (cat_id) WHERE id = :id ;")
|
|
c.execute(query,book)
|
|
cats = []
|
|
for book_id,cat_id,cat_name in c:
|
|
cats.append({'id':book_id, 'cat_id':cat_id, 'category':cat_name})
|
|
c.close()
|
|
return cats
|
|
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def categorizeBook(book, cats):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = ("INSERT OR IGNORE INTO "+bookCategoryTable+
|
|
" (id,cat_id) VALUES (?, ?);")
|
|
for cat in cats:
|
|
args = (book['id'],cat['id'])
|
|
c.execute(query,args)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def uncategorizeBook(book, cats):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = "DELETE FROM "+bookCategoryTable+" WHERE (id = ? AND cat_id = ?);"
|
|
for cat in cats:
|
|
args = (book['id'],cat['id'])
|
|
c.execute(query,args)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
def getCategories():
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = "SELECT cat_id, category FROM "+categoryTable+";"
|
|
c.execute(query)
|
|
cats = []
|
|
for cat_id,cat in c:
|
|
cats.append({'id':cat_id, 'category':cat})
|
|
c.close()
|
|
return cats
|
|
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def addCategory(cat):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query = ("INSERT OR IGNORE INTO "+categoryTable+" (category) VALUES ("
|
|
+_stringify(cat)+");")
|
|
c.execute(query)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
@permissions.check_permissions(permissions.PERMISSION_LIBCOM)
|
|
def deleteCategories(cats):
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
query1 = "DELETE FROM " +categoryTable+ " WHERE cat_id = :id;"
|
|
for cat in cats:
|
|
c.execute(query1, cat)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
#########################################
|
|
# Database initialization
|
|
#########################################
|
|
def _createBooksTable():
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
c.executescript(bookTableCreation)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
def _createTriggers():
|
|
conn = sqlite3.connect(dbFile)
|
|
c = conn.cursor()
|
|
c.executescript(bookTriggerCreation)
|
|
conn.commit()
|
|
c.close()
|
|
|
|
def initializeDatabase():
|
|
_createBooksTable()
|
|
_createTriggers()
|