|
import re
|
|
from urllib.request import urlopen
|
|
|
|
import sqlite3
|
|
|
|
|
|
DB_PATH = 'bookmarks.db'
|
|
|
|
SQL_SELECT_BOOKMARK = "SELECT * FROM bookmarks WHERE id=?"
|
|
SQL_INSERT_BOOKMARK = "INSERT INTO bookmarks VALUES (?,?,?,?,?,?,?,?)"
|
|
SQL_UPDATE_BOOKMARK = "UPDATE bookmarks SET {:s} WHERE id=?"
|
|
|
|
HTTP_OKAY = 200
|
|
|
|
class BookmarkNotFoundError(Exception):
|
|
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
def __str__(self, value):
|
|
return repr(self.value)
|
|
|
|
|
|
class DBConnectionError(Exception):
|
|
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
def __str__(self, value):
|
|
return repr(self.value)
|
|
|
|
|
|
class Bookmark(object):
|
|
|
|
def __init__(self, db_conn, id=None, url=None):
|
|
|
|
# Make sure the DB connection is valid before doing anything else
|
|
if not db_conn:
|
|
raise DBConnectionError('Invalid database connection object!')
|
|
|
|
# Setup internal parameters
|
|
self._db_conn = db_conn
|
|
self._content = None
|
|
|
|
# Setup defaut object data attributes
|
|
self.id = id
|
|
self.url = url
|
|
self.title = ''
|
|
self.description = ''
|
|
self.times_visited = 0
|
|
self.last_visited = 0
|
|
self.last_reachable = 0
|
|
self.deleted = False
|
|
self.category_tags = set()
|
|
self.description_tags = set()
|
|
|
|
# Retrieve an existing bookmark if an ID is passed in
|
|
if self.id:
|
|
db = self._db_conn.cursor()
|
|
db.execute(SQL_SELECT_BOOKMARK, (self.id,))
|
|
row = db.fetchone()
|
|
|
|
# Check to see if a record was found
|
|
if not row:
|
|
raise BookmarkNotFoundError(self.id)
|
|
|
|
# Assign data attributes
|
|
self.url = row[1]
|
|
self.title = row[2]
|
|
self.description = row[3]
|
|
self.times_visited = int(row[4])
|
|
self.last_visited = row[5]
|
|
self.last_reachable = row[6]
|
|
if int(row[7]) == 0:
|
|
self.deleted = False
|
|
else:
|
|
self.deleted = True
|
|
|
|
# This dict MUST appear *after* the data attributes, it is used to
|
|
# record which data attributes are dirty
|
|
self._dirty = {'url': False,
|
|
'title': False,
|
|
'description': False,
|
|
'times_visited': False,
|
|
'last_visited': False,
|
|
'last_reachable': False,
|
|
'deleted': False}
|
|
|
|
def __del__(self):
|
|
""" Automatically save any changes to a record before the object is
|
|
destroyed.
|
|
"""
|
|
self.save()
|
|
|
|
def save(self):
|
|
""" Save any changes to a bookmark record if it is dirty. """
|
|
# Check if the record is dirty
|
|
if self.record_dirty:
|
|
if self.id:
|
|
# Update existing bookmark record
|
|
self._db_update()
|
|
else:
|
|
# Insert new bookmark record
|
|
self._db_insert()
|
|
|
|
def __setattr__(self, name, value):
|
|
""" Customize setting data attributes so we can tell which ones
|
|
are dirty.
|
|
"""
|
|
|
|
# Check if the attr is a data attribute then check if the value has
|
|
# changed. If so, mark the attribute as dirty
|
|
if hasattr(self, '_dirty'):
|
|
if name in self._dirty and getattr(self, name) != value:
|
|
self._dirty[name] = True
|
|
|
|
# Set the attribute value using the super class's __setattr__ to avoid
|
|
# infinite recursion (recursion joke here)
|
|
super(Bookmark, self).__setattr__(name, value)
|
|
|
|
def _db_insert(self):
|
|
""" Insert a new bookmark record into the database. """
|
|
db = self._db_conn.cursor()
|
|
values = (0, self.url, self.title, self.description,
|
|
self.times_visited, self.last_visited, self.last_reachable,
|
|
self.deleted and '1' or '0')
|
|
db.execute(SQL_INSERT_BOOKMARK, values)
|
|
self._db_conn.commit()
|
|
|
|
# Reset dirty flags
|
|
for key in self._dirty.keys():
|
|
self._dirty[key] = False
|
|
|
|
def _db_update(self):
|
|
""" Update an exisitng bookmark record in the database. """
|
|
values = []
|
|
sets = []
|
|
|
|
# Find dirty data attributes for updating
|
|
for key in self._dirty.keys():
|
|
if self._dirty[key] == True:
|
|
sets.append('{:s}=?'.format(key))
|
|
values.append(getattr(self, key))
|
|
|
|
if not values or not sets:
|
|
return
|
|
|
|
# Add the record id as the last value
|
|
values.append(self.id)
|
|
|
|
# Build full SQL statement then execute it
|
|
sql = SQL_UPDATE_BOOKMARK.format(','.join(sets))
|
|
db = self._db_conn.cursor()
|
|
db.execute(sql, values)
|
|
self._db_conn.commit()
|
|
|
|
# Reset dirty flags
|
|
for key in self._dirty.keys():
|
|
self._dirty[key] = False
|
|
|
|
@property
|
|
def record_dirty(self):
|
|
""" Check if any data attributes are dirty, which indicates the record
|
|
is dirty.
|
|
"""
|
|
return any([val for key, val in self._dirty.items()])
|
|
|
|
def _get_content(self):
|
|
""" Read the page and get its raw page HTML content. """
|
|
if self.url:
|
|
response = urlopen(self.url)
|
|
if response.getcode() == HTTP_OKAY:
|
|
self._content = response.read().decode('utf-8')
|
|
|
|
def suggest_title(self):
|
|
""" Return the contents of the page's <title> tag as a title suggestion
|
|
"""
|
|
if self.url and not self._content:
|
|
self._get_content()
|
|
|
|
try:
|
|
title = re.search('<title>(.+)</title>', self._content).group(1)
|
|
except IndexError:
|
|
title = None
|
|
return title
|
|
|
|
def is_reachable(self):
|
|
""" Check if the page is reachable. """
|
|
if self.url:
|
|
response = urlopen(self.url)
|
|
if response.getcode() == HTTP_OKAY:
|
|
return True
|
|
return False
|
|
|
|
|