def getUpdate(self):
service_time = self.oConfig.getSetting('service_time')
VSlog("getUpdate")
#Si pas d'heure indique = premiere install
if not (service_time):
#On memorise la date d'aujourdhui
self.oConfig.setSetting('service_time',
str(datetime.datetime.now()))
#Mais on force la maj avec une date a la con
service_time = '2000-09-23 10:59:50.877000'
if (service_time):
#delay mise a jour
time_sleep = datetime.timedelta(minutes=1)
time_now = datetime.datetime.now()
time_service = self.__strptime(service_time,
"%Y-%m-%d %H:%M:%S.%f")
if (time_now - time_service > time_sleep):
self.checkupdate()
else:
VSlog('Prochaine verification de MAJ le : ' +
str(time_sleep + time_service))
#Pas besoin de memoriser la date, a cause du cache kodi > pas fiable.
return
def createTables(self):
# self.dropTables()
try:
self.lockDB()
''' Create table '''
sql_create = "CREATE TABLE IF NOT EXISTS history ("" addon_id integer PRIMARY KEY AUTOINCREMENT, ""sItemUrl TEXT, ""mainUrl TEST, ""rawtitle TEXT, ""title TEXT, ""icon TEXT, ""type TEXT, ""quality TEXT, ""UNIQUE(rawtitle)"");"
self.dbcur.execute(sql_create)
sql_create = "CREATE TABLE IF NOT EXISTS resume ("" addon_id integer PRIMARY KEY AUTOINCREMENT, ""title TEXT, ""timepoint TEXT, ""UNIQUE(title)"");"
self.dbcur.execute(sql_create)
sql_create = "CREATE TABLE IF NOT EXISTS watched ("" addon_id integer PRIMARY KEY AUTOINCREMENT, ""title TEXT, ""site TEXT, ""UNIQUE(title, site)"");"
self.dbcur.execute(sql_create)
sql_create = "CREATE TABLE IF NOT EXISTS favorite ("" addon_id integer PRIMARY KEY AUTOINCREMENT, ""title TEXT, ""siteurl TEXT, ""site TEXT, ""fav TEXT, ""cat TEXT, ""icon TEXT, ""fanart TEXT, ""UNIQUE(title, site)"");"
self.dbcur.execute(sql_create)
sql_create = "CREATE TABLE IF NOT EXISTS downloaded ("" addon_id integer PRIMARY KEY AUTOINCREMENT, ""title TEXT, ""path TEXT, ""icon TEXT, ""status TEXT, ""mainUrl TEXT, ""UNIQUE(title)"");"
self.dbcur.execute(sql_create)
sql_create = "CREATE TABLE IF NOT EXISTS valide ("" addon_id integer PRIMARY KEY AUTOINCREMENT, ""url TEXT, ""ok TEXT, ""UNIQUE(url)"");"
self.dbcur.execute(sql_create)
VSlog('Table initialized')
self.unlockDB()
except Exception, e:
VSlog('cDb ERROR in createTables: ' + str(e.message))
if "database disk image is malformed" in str(e.message):
os.remove(self.DB)
self.db = sqlite.connect(self.DB)
self.dbcur = self.db.cursor()
self.createTables()
cFtpManager().sendDb()
def checkupdate(self):
VSlog("checkupdate")
version = self.oConfig.getAddonVersion()
try:
sRequest = '?client_id=' + self.client_id + '&client_secret=' + self.client_secret
sUrl = 'https://raw.githubusercontent.com/tvwatch-kodi/TvWatch/master/source/changelog.txt'
oRequest = urllib2.Request(sUrl + sRequest)
oResponse = urllib2.urlopen(oRequest)
sContent = oResponse.read()
if "Current Version" in sContent:
sContent = sContent[sContent.find("Current Version"):]
if " - " in sContent:
sContent = sContent[:sContent.find(" - ")]
sContent = sContent.replace("Current Version","")
sContent = sContent.replace(" ","")
sContent = sContent.replace(".","")
newVersion = int(sContent)
currentVersion = int(version.replace(".",""))
VSlog("checkupdate New Version: " + str(newVersion))
VSlog("checkupdate Current Version: " + str(currentVersion))
self.oConfig.setSetting('service_time', str(datetime.datetime.now()))
if newVersion > currentVersion:
WriteSingleDatabase('home_update', "true")
dialog = self.oConfig.showInfo("TvWatch", VSlang(30418))
VSupdate()
return True
else:
#self.oConfig.showInfo('TvWatch', 'Fichier a jour')
WriteSingleDatabase('home_update', "false")
except Exception, e:
self.oConfig.error(self.oConfig.getlanguage(30205))
VSlog("checkupdate ERROR: " + e.message)
def StartDownloadOneFile(self, meta=[]):
VSlog('StartDownloadOneFile')
self.__oConfig.showInfo("TvWatch", VSlang(30514), 5)
if ReadSingleDatabase('download_status') == "InProgress":
self.__oConfig.showInfo('TvWatch', VSlang(30509))
return
oInputParameterHandler = cInputParameterHandler()
meta = {}
meta['sMovieTitle'] = oInputParameterHandler.getValue('sMovieTitle')
meta['sMainUrl'] = oInputParameterHandler.getValue('sMainUrl')
meta['sItemUrl'] = oInputParameterHandler.getValue('sItemUrl')
meta['sThumbnail'] = oInputParameterHandler.getValue('sThumbnail')
meta['sNextUrl'] = oInputParameterHandler.getValue('sNextUrl')
meta['sType'] = oInputParameterHandler.getValue('sType')
meta['sQual'] = oInputParameterHandler.getValue('sQual')
meta['refresh'] = oInputParameterHandler.getValue('refresh')
meta['sEncodeUrl'] = oInputParameterHandler.getValue('sEncodeUrl')
meta['sBaseUrl'] = oInputParameterHandler.getValue('sBaseUrl')
needShowHosters = oInputParameterHandler.getValue('needShowHosters')
if needShowHosters == 'True':
try:
from resources.sites.server import showHosters
params = showHosters(meta, False)
except Exception, e:
VSlog("StartDownloadOneFile showHosters ERROR: " + e.message)
def __getMediaLinkForGuest(self):
api_call = ''
id = self.__getIdFromUrl()
self.__sUrl = 'http://hqq.tv/player/embed_player.php?vid=' + id + '&autoplay=no'
headers = {'User-Agent': UA ,
#'Host' : 'hqq.tv',
'Referer': 'http://hqq.tv/',
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
#'Accept-Encoding':'gzip, deflate, br',
#'Content-Type': 'text/html; charset=utf-8'
}
player_url = self.__sUrl
req = urllib2.Request(player_url, None, headers)
try:
response = urllib2.urlopen(req)
html = response.read()
response.close()
except urllib2.URLError, e:
VSlog(e.read())
VSlog(e.reason)
html = e.read()
def insert_download(self, meta):
mainUrl = meta['sMainUrl']
title = meta['title']
path = meta['path']
sIcon = meta['icon']
status = meta['status']
# sRawtitle = title
title = self.str_conv(title)
path = self.str_conv(path)
# if sType == 'tvshow' and 'Saison' in sRawtitle:
# sRawtitle = sRawtitle[:sRawtitle.find('Saison')]
# sRawtitle = self.str_conv(sRawtitle)
try:
self.lockDB()
ex = "INSERT INTO downloaded (title, path, icon, status, mainUrl) VALUES (?, ?, ?, ?, ?)"
self.dbcur.execute(ex, (title, path, sIcon, status, mainUrl))
self.db.commit()
VSlog('SQL INSERT downloaded Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR INSERT downloaded: ' + str(e.message))
if 'UNIQUE constraint failed' in str(e.message):
self.update_download(meta)
elif 'malformed' in str(e.message).lower():
self.dropTables()
def insert_history(self, meta):
title = meta['title']
sItemUrl = meta['sItemUrl']
sMainUrl = meta['mainUrl']
sIcon = meta['icon']
sType = meta['type']
sQuality = meta['quality']
sRawtitle = title
title = self.str_conv(title)
if sType == 'tvshow' and 'Saison' in sRawtitle:
sRawtitle = sRawtitle[:sRawtitle.find('Saison')]
sRawtitle = self.str_conv(sRawtitle)
try:
self.lockDB()
ex = "INSERT INTO history (title, sItemUrl, mainUrl, icon, type, rawtitle, quality) VALUES (?, ?, ?, ?, ?, ?, ?)"
self.dbcur.execute(ex, (title, sItemUrl, sMainUrl, sIcon, sType, sRawtitle, sQuality))
self.db.commit()
VSlog('SQL INSERT history Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR INSERT history: ' + str(e.message))
if 'UNIQUE constraint failed' in str(e.message):
self.update_history(meta)
elif 'malformed' in str(e.message).lower():
self.dropTables()
def __getMediaLinkForGuest(self):
oRequest = cRequestHandler(self.__sUrl)
oRequest.addHeaderEntry(
'User-Agent',
'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:55.0) Gecko/20100101 Firefox/55.0'
)
sHtmlContent = oRequest.request()
oParser = cParser()
aResult = re.search('(ﾟωﾟ.+?\(\'_\'\);)', sHtmlContent,
re.DOTALL | re.UNICODE)
if (aResult):
VSlog('AA encryption')
sHtmlContent = AADecoder(aResult.group(1)).decode()
#recuperation de l'url
Url = re.findall('href *= *["\'](.+?)["\']', sHtmlContent)[0]
if not 'speedvid' in Url:
Url = 'http://www.speedvid.net/' + Url
if not 'http' in Url:
if Url.startswith('//'):
Url = 'http:' + Url
else:
Url = 'http://' + Url
VSlog("Connexion: " + Url)
oRequest = cRequestHandler(Url)
oRequest.addHeaderEntry(
'User-Agent',
'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:55.0) Gecko/20100101 Firefox/55.0'
)
oRequest.addHeaderEntry('Referer', self.__sUrl)
sHtmlContent = oRequest.request()
api_call = ''
sPattern = '(eval\(function\(p,a,c,k,e(?:.|\s)+?\)\))<'
aResult = oParser.parse(sHtmlContent, sPattern)
if (aResult[0] == True):
for packed in aResult[1]:
sHtmlContent = cPacker().unpack(packed)
sHtmlContent = sHtmlContent.replace('\\', '')
sPattern2 = "{file:.([^']+.mp4)"
aResult2 = oParser.parse(sHtmlContent, sPattern2)
if (aResult2[0] == True):
# tris des faux liens
if not 'speedvid' in aResult2[1][0]:
api_call = aResult2[1][0]
if (api_call):
api_call = api_call + '|User-Agent=Mozilla/5.0 (Windows NT 6.1; WOW64; rv:55.0) Gecko/20100101 Firefox/55.0'
return True, api_call
return False, False
def updateXFSS(self, xfss, oldXfss):
if xfss:
try:
ex = """UPDATE serverTable
SET xfss = %s
WHERE xfss = %s"""
self.dbcur.execute(ex, (xfss, oldXfss))
self.db.commit()
VSlog('SQL UPDATE table Successfully: xfss with ' + xfss)
except Exception, e:
VSlog('SQL ERROR UPDATE table xfss: ' + e.message)
def updateIP(self, ip, clientID):
if ip:
try:
ex = """UPDATE mainTable
SET ip = %s
WHERE id = %s"""
self.dbcur.execute(ex, (ip, clientID))
self.db.commit()
VSlog('SQL UPDATE table Successfully: ip with ' + ip)
except Exception, e:
VSlog('SQL ERROR UPDATE table ip: ' + e.message)
def download(self,
sDBUrl,
sTitle,
sDownloadPath,
sThumbnail,
sMainUrl,
FastMode=True):
VSlog("Telechargement " + str(sDBUrl))
# if self.isDownloading():
# self.__oConfig.showInfo('TvWatch', VSlang(30509))
# return False
#resolve url
oHoster = cHosterGui().checkHoster(sDBUrl)
oHoster.setUrl(sDBUrl)
aLink = oHoster.getMediaLink()
if (aLink[0] == True):
sUrl = aLink[1]
else:
VSlog('Lien non resolvable')
self.__oConfig.showInfo('TvWatch', VSlang(30510))
return False
if (not sUrl.startswith('http')
) or sUrl.split('|')[0].endswith('.m3u8'):
return False
try:
if '.' in sUrl:
a = sUrl.rfind('.')
sDownloadPath += sUrl[a:]
#background download task
if FastMode:
cDownloadProgressBar(title=sTitle,
url=sUrl,
Dpath=sDownloadPath,
icon=sThumbnail,
mainUrl=sMainUrl,
FastMode=True).start()
else:
cDownloadProgressBar(title=sTitle,
url=sUrl,
Dpath=sDownloadPath,
icon=sThumbnail,
mainUrl=sMainUrl).start()
VSlog("Telechargement ok")
except Exception, e:
VSlog("Telechargement impossible " + e.message)
self.__oConfig.showInfo('TvWatch', VSlang(30508))
return False
def __del__(self):
''' Cleanup db when object destroyed '''
try:
self.dbcur.close()
self.db.close()
if self.enableFtp:
self.lockDB()
VSlog("sendDb to server")
cFtpManager().sendDb()
self.unlockDB()
except Exception, e:
VSlog('cDb ERROR in Destructor: ' + str(e.message))
def updateIP(self, isPlaying, clientID):
if isPlaying:
try:
ex = """UPDATE mainTable
SET isPlaying = %s
WHERE id = %s"""
self.dbcur.execute(ex, (isPlaying, clientID))
self.db.commit()
VSlog('SQL UPDATE table Successfully: isPlaying with ' +
isPlaying)
except Exception, e:
VSlog('SQL ERROR UPDATE table isPlaying: ' + e.message)
def del_downloadByStatus(self, status):
sql_delete = "DELETE FROM downloaded WHERE status = '%s'" % (status)
try:
self.lockDB()
self.dbcur.execute(sql_delete)
self.db.commit()
VSlog('SQL DELETE downloaded Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR DELETE downloaded: ' + str(e.message))
if 'malformed' in str(e.message).lower():
self.dropTables()
def del_valide(self):
sql_delete = "DELETE FROM valide"
try:
self.lockDB()
self.dbcur.execute(sql_delete)
self.db.commit()
VSlog('SQL DELETE valide Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR valide history: ' + str(e.message))
if 'malformed' in str(e.message).lower():
self.dropTables()
def dropTables(self):
try:
self.lockDB()
self.dbcur.execute("DROP TABLE IF EXISTS %s" %('history'))
self.dbcur.execute("DROP TABLE IF EXISTS %s" %('resume'))
self.dbcur.execute("DROP TABLE IF EXISTS %s" %('watched'))
self.dbcur.execute("DROP TABLE IF EXISTS %s" %('favorite'))
self.dbcur.execute("DROP TABLE IF EXISTS %s" %('downloaded'))
self.dbcur.execute("DROP TABLE IF EXISTS %s" %('valide'))
VSlog('Tables dropped successfully')
self.unlockDB()
except:
VSlog("deleteTable FAIL")
def del_resume(self, title):
title = self.str_conv(title)
sql_delete = "DELETE FROM resume WHERE title = '%s'" % (title)
try:
self.lockDB()
self.dbcur.execute(sql_delete)
self.db.commit()
VSlog('SQL DELETE resume Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR DELETE resume: ' + str(e.message))
if 'malformed' in str(e.message).lower():
self.dropTables()
def __init__(self, ftp = True):
self.oConfig = cConfig()
self.enableFtp = ftp
try:
if self.enableFtp:
self.lockDB()
VSlog("Retrieve DB from server")
cFtpManager().getDb()
self.unlockDB()
self.DB = self.oConfig.getFileDB()
self.db = sqlite.connect(self.DB)
self.dbcur = self.db.cursor()
except Exception, e:
VSlog('cDb ERROR in Constructor: ' + str(e.message))
def insert_watched(self, meta):
title = self.str_conv(meta['title'])
site = urllib.quote_plus(meta['site'])
ex = "INSERT INTO watched (title, site) VALUES (?, ?)"
try:
self.lockDB()
self.dbcur.execute(ex, (title,site))
self.db.commit()
VSlog('SQL INSERT watched Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR INSERT watched: ' + str(e.message))
if 'malformed' in str(e.message).lower():
self.dropTables()
def update_resume(self, meta):
title = self.str_conv(meta['title'])
timepoint = meta['timepoint']
try:
self.lockDB()
ex = "UPDATE resume SET timepoint = '%s' WHERE title = '%s'" % (timepoint, title)
self.dbcur.execute(ex)
self.db.commit()
VSlog('SQL UPDATE resume Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR UPDATE resume: ' + str(e.message))
if 'malformed' in str(e.message).lower():
self.dropTables()
def createTable(self):
sql_create = """CREATE TABLE IF NOT EXISTS mainTable (
id INT PRIMARY KEY AUTO_INCREMENT,
prenom VARCHAR(50) NOT NULL,
nom VARCHAR(50) NOT NULL,
code VARCHAR(73) NOT NULL UNIQUE,
expDate VARCHAR(10) NOT NULL,
isPlaying VARCHAR(5) NOT NULL
);"""
try:
self.dbcur.execute(sql_create)
VSlog('Table mainTable MySQL initialized')
except Exception, e:
VSlog('MySQL ERROR _create_tables mainTable: ' + e.message)
def enable_addon(self, addon):
#import json
#sCheck = {'jsonrpc': '2.0','id': 1,'method': 'Addons.GetAddonDetails','params': {'addonid':'inputstream.adaptive','properties': ['enabled']}}
#response = xbmc.executeJSONRPC(json.dumps(sCheck))
#data = json.loads(response)
#if not 'error' in data.keys():
#if data['result']['addon']['enabled'] == False:
if xbmc.getCondVisibility(
'System.HasAddon(inputstream.adaptive)') == 0:
do_json = '{"jsonrpc":"2.0","id":1,"method":"Addons.SetAddonEnabled","params":{"addonid":"inputstream.adaptive","enabled":true}}'
query = xbmc.executeJSONRPC(do_json)
VSlog("Activation d'inputstream.adaptive")
else:
VSlog('inputstream.adaptive déjà activé')
def ConnectWithXFSS(self, xfss):
# url = 'https://uptobox.com/?op=login&referer=homepage/'
url = 'https://uptobox.com'
req = urllib2.Request(url, None, headers)
cookie = "xfss=%s;" % (xfss)
req.add_header('cookie', cookie)
req.add_header('dnt', '1')
req.add_header('upgrade-insecure-requests', '1')
try:
response = urllib2.urlopen(req)
except urllib2.URLError, e:
VSlog("debug ConnectWithXFSS " + str(getattr(e, "code", None)))
VSlog("debug ConnectWithXFSS " + str(getattr(e, "reason", None)))
return False
def del_download(self, title):
# sRawtitle = title
# if 'Saison' in title:
# sRawtitle = title[:title.find('Saison')]
title = self.str_conv(title)
sql_delete = "DELETE FROM downloaded WHERE title = '%s'" % (title)
try:
self.lockDB()
self.dbcur.execute(sql_delete)
self.db.commit()
VSlog('SQL DELETE downloaded Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR DELETE downloaded: ' + str(e.message))
if 'malformed' in str(e.message).lower():
self.dropTables()
def insert_resume(self, meta):
title = self.str_conv(meta['title'])
timepoint = meta['timepoint']
try:
self.lockDB()
ex = "INSERT INTO resume (title, timepoint) VALUES (?, ?)"
self.dbcur.execute(ex, (title, timepoint))
self.db.commit()
VSlog('SQL INSERT resume Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR INSERT resume: ' + str(e.message))
if 'UNIQUE constraint failed' in str(e.message):
self.update_resume(meta)
elif 'malformed' in str(e.message).lower():
self.dropTables()
def setWatched(self, sId, sTitle):
VSlog("setWatched")
try:
watched = {}
#sTitle = self.getTitle()
#sId = self.getSiteName()
watched_db = os.path.join(cConfig().getSettingCache(),
"watched.db").decode("utf-8")
if not os.path.exists(watched_db):
file(watched_db, "w").write("%r" % watched)
if os.path.exists(watched_db):
watched = eval(open(watched_db).read())
watched[sId] = watched.get(sId) or []
#add to watched
if sTitle not in watched[sId]:
watched[sId].append(sTitle)
else:
del watched[sId][watched[sId].index(sTitle)]
file(watched_db, "w").write("%r" % watched)
watched_db.close()
except:
return
def addToPlaylist(self):
cConfig().log('addToPlaylist')
oGui = cGui()
oInputParameterHandler = cInputParameterHandler()
sHosterIdentifier = oInputParameterHandler.getValue('sHosterIdentifier')
sMediaUrl = oInputParameterHandler.getValue('sMediaUrl')
bGetRedirectUrl = oInputParameterHandler.getValue('bGetRedirectUrl')
sFileName = oInputParameterHandler.getValue('sFileName')
if (bGetRedirectUrl == 'True'):
sMediaUrl = self.__getRedirectUrl(sMediaUrl)
VSlog("Hoster - play " + sMediaUrl)
oHoster = self.getHoster(sHosterIdentifier)
oHoster.setFileName(sFileName)
oHoster.setUrl(sMediaUrl)
aLink = oHoster.getMediaLink()
if (aLink[0] == True):
oGuiElement = cGuiElement()
oGuiElement.setSiteName(self.SITE_NAME)
oGuiElement.setMediaUrl(aLink[1])
oGuiElement.setTitle(oHoster.getFileName())
oPlayer = cPlayer()
oPlayer.addItemToPlaylist(oGuiElement)
oGui.showInfo('Playlist', str(oHoster.getFileName()), 5)
return
oGui.setEndOfDirectory()
def getDb(self):
fileDb = self.oConfig.getFileDB()
fileDbServer = 'db_' + self.oConfig.getSetting('clientID') + '.db'
try:
do = False
if ((os.path.exists(fileDb))
and (fileDbServer in self.ftp.nlst())):
timestamp_s = self.ftp.voidcmd('MDTM /htdocs/db/' +
fileDbServer)[4:].strip()
timestamp_l = self.getmTimeLocalDB(fileDb)
if int(timestamp_l) < int(timestamp_s):
do = True
else:
do = True
if do:
command = 'RETR ' + fileDbServer
f = open(fileDb, 'wb')
self.ftp.cwd('/htdocs/db/')
self.ftp.retrbinary(command, f.write)
f.close()
self.ftp.quit()
except Exception, e:
VSlog("FtpManager getDb ERROR: " + e.message)
self.ftp.quit()
def del_favorite(self):
oInputParameterHandler = cInputParameterHandler()
if (oInputParameterHandler.exist('sCat')):
sql_delete = "DELETE FROM favorite WHERE cat = '%s'" % (oInputParameterHandler.getValue('sCat'))
if(oInputParameterHandler.exist('sMovieTitle')):
siteUrl = oInputParameterHandler.getValue('siteUrl')
sMovieTitle = oInputParameterHandler.getValue('sMovieTitle')
siteUrl = urllib.quote_plus(siteUrl)
title = self.str_conv(sMovieTitle)
title = title.replace("'", r"''")
sql_delete = "DELETE FROM favorite WHERE siteurl = '%s' AND title = '%s'" % (siteUrl,title)
if(oInputParameterHandler.exist('sAll')):
sql_delete = "DELETE FROM favorite;"
try:
self.lockDB()
self.dbcur.execute(sql_delete)
self.db.commit()
self.oConfig.showInfo('TvWatch', 'Favoris supprimé')
self.unlockDB()
return False, False
except Exception, e:
VSlog('SQL ERROR EXECUTE favorite: ' + str(e.message))
if 'malformed' in str(e.message).lower():
self.dropTables()
return False, False
def del_history(self, title):
sRawtitle = title
if 'Saison' in title:
sRawtitle = title[:title.find('Saison')]
sRawtitle = self.str_conv(sRawtitle)
sql_delete = "DELETE FROM history WHERE rawtitle = '%s'" % (sRawtitle)
try:
self.lockDB()
self.dbcur.execute(sql_delete)
self.db.commit()
VSlog('SQL DELETE history Successfully')
self.unlockDB()
except Exception, e:
VSlog('SQL ERROR DELETE history: ' + str(e.message))
if 'malformed' in str(e.message).lower():
self.dropTables()
