Fix some directory names

1 files changed, 0 insertions, 985 deletions

diff --git a/pyload/database/File.py b/pyload/database/File.py
deleted file mode 100644
index f28535ffa..000000000
--- a/pyload/database/File.py
+++ /dev/null
@@ -1,985 +0,0 @@
-# -*- coding: utf-8 -*-
-# @author: RaNaN, mkaay
-
-import threading
-
-from pyload.Datatype import PyFile, PyPackage
-from pyload.Database import DatabaseBackend, style
-from pyload.manager.Event import InsertEvent, ReloadAllEvent, RemoveEvent, UpdateEvent
-from pyload.utils import formatSize, lock
-
-try:
-    from pysqlite2 import dbapi2 as sqlite3
-except Exception:
-    import sqlite3
-
-
-class FileHandler(object):
-    """Handles all request made to obtain information,
-    modify status or other request for links or packages"""
-
-    def __init__(self, core):
-        """Constructor"""
-        self.core = core
-
-        # translations
-        self.statusMsg = [_("finished"), _("offline"), _("online"), _("queued"), _("skipped"), _("waiting"),
-                          _("temp. offline"), _("starting"), _("failed"), _("aborted"), _("decrypting"), _("custom"),
-                          _("downloading"), _("processing"), _("unknown")]
-
-        self.cache = {}  #: holds instances for files
-        self.packageCache = {}  #: same for packages
-        #@TODO: purge the cache
-
-        self.jobCache = {}
-
-        self.lock = threading.RLock()  #@TODO: should be a Lock w/o R
-        # self.lock._Verbose__verbose = True
-
-        self.filecount = -1  #: if an invalid value is set get current value from db
-        self.queuecount = -1  #: number of package to be loaded
-        self.unchanged = False  #: determines if any changes was made since last call
-
-        self.db = self.core.db
-
-
-    def change(func):
-
-
-        def new(*args):
-            args[0].unchanged = False
-            args[0].filecount = -1
-            args[0].queuecount = -1
-            args[0].jobCache = {}
-            return func(*args)
-
-        return new
-
-
-    #--------------------------------------------------------------------------
-
-    def save(self):
-        """saves all data to backend"""
-        self.db.commit()
-
-
-    #--------------------------------------------------------------------------
-
-    def syncSave(self):
-        """saves all data to backend and waits until all data are written"""
-        pyfiles = self.cache.values()
-        for pyfile in pyfiles:
-            pyfile.sync()
-
-        pypacks = self.packageCache.values()
-        for pypack in pypacks:
-            pypack.sync()
-
-        self.db.syncSave()
-
-
-    @lock
-    def getCompleteData(self, queue=1):
-        """gets a complete data representation"""
-
-        data = self.db.getAllLinks(queue)
-        packs = self.db.getAllPackages(queue)
-
-        data.update([(x.id, x.toDbDict()[x.id]) for x in self.cache.values()])
-
-        for x in self.packageCache.itervalues():
-            if x.queue != queue or x.id not in packs:
-                continue
-            packs[x.id].update(x.toDict()[x.id])
-
-        for key, value in data.iteritems():
-            if value['package'] in packs:
-                packs[value['package']]['links'][key] = value
-
-        return packs
-
-
-    @lock
-    def getInfoData(self, queue=1):
-        """gets a data representation without links"""
-
-        packs = self.db.getAllPackages(queue)
-        for x in self.packageCache.itervalues():
-            if x.queue != queue or x.id not in packs:
-                continue
-            packs[x.id].update(x.toDict()[x.id])
-
-        return packs
-
-
-    @lock
-    @change
-    def addLinks(self, urls, package):
-        """adds links"""
-
-        self.core.addonManager.dispatchEvent("links-added", urls, package)
-
-        data = self.core.pluginManager.parseUrls(urls)
-
-        self.db.addLinks(data, package)
-        self.core.threadManager.createInfoThread(data, package)
-
-        #@TODO: change from reloadAll event to package update event
-        self.core.pullManager.addEvent(ReloadAllEvent("collector"))
-
-
-    #--------------------------------------------------------------------------
-
-    @lock
-    @change
-    def addPackage(self, name, folder, queue=0):
-        """adds a package, default to link collector"""
-        lastID = self.db.addPackage(name, folder, queue)
-        p = self.db.getPackage(lastID)
-        e = InsertEvent("pack", lastID, p.order, "collector" if not queue else "queue")
-        self.core.pullManager.addEvent(e)
-        return lastID
-
-
-    #--------------------------------------------------------------------------
-
-    @lock
-    @change
-    def deletePackage(self, id):
-        """delete package and all contained links"""
-
-        p = self.getPackage(id)
-        if not p:
-            if id in self.packageCache:
-                del self.packageCache[id]
-            return
-
-        oldorder = p.order
-        queue = p.queue
-
-        e = RemoveEvent("pack", id, "collector" if not p.queue else "queue")
-
-        pyfiles = self.cache.values()
-
-        for pyfile in pyfiles:
-            if pyfile.packageid == id:
-                pyfile.abortDownload()
-                pyfile.release()
-
-        self.db.deletePackage(p)
-        self.core.pullManager.addEvent(e)
-        self.core.addonManager.dispatchEvent("package-deleted", id)
-
-        if id in self.packageCache:
-            del self.packageCache[id]
-
-        packs = self.packageCache.values()
-        for pack in packs:
-            if pack.queue == queue and pack.order > oldorder:
-                pack.order -= 1
-                pack.notifyChange()
-
-
-    #--------------------------------------------------------------------------
-
-    @lock
-    @change
-    def deleteLink(self, id):
-        """deletes links"""
-
-        f = self.getFile(id)
-        if not f:
-            return None
-
-        pid = f.packageid
-        e = RemoveEvent("file", id, "collector" if not f.package().queue else "queue")
-
-        oldorder = f.order
-
-        if id in self.core.threadManager.processingIds():
-            self.cache[id].abortDownload()
-
-        if id in self.cache:
-            del self.cache[id]
-
-        self.db.deleteLink(f)
-
-        self.core.pullManager.addEvent(e)
-
-        p = self.getPackage(pid)
-        if not len(p.getChildren()):
-            p.delete()
-
-        pyfiles = self.cache.values()
-        for pyfile in pyfiles:
-            if pyfile.packageid == pid and pyfile.order > oldorder:
-                pyfile.order -= 1
-                pyfile.notifyChange()
-
-
-    #--------------------------------------------------------------------------
-
-    def releaseLink(self, id):
-        """removes pyfile from cache"""
-        if id in self.cache:
-            del self.cache[id]
-
-
-    #--------------------------------------------------------------------------
-
-    def releasePackage(self, id):
-        """removes package from cache"""
-        if id in self.packageCache:
-            del self.packageCache[id]
-
-
-    #--------------------------------------------------------------------------
-
-    def updateLink(self, pyfile):
-        """updates link"""
-        self.db.updateLink(pyfile)
-
-        e = UpdateEvent("file", pyfile.id, "collector" if not pyfile.package().queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-
-    #--------------------------------------------------------------------------
-
-    def updatePackage(self, pypack):
-        """updates a package"""
-        self.db.updatePackage(pypack)
-
-        e = UpdateEvent("pack", pypack.id, "collector" if not pypack.queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-
-    #--------------------------------------------------------------------------
-
-    def getPackage(self, id):
-        """return package instance"""
-
-        if id in self.packageCache:
-            return self.packageCache[id]
-        else:
-            return self.db.getPackage(id)
-
-
-    #--------------------------------------------------------------------------
-
-    def getPackageData(self, id):
-        """returns dict with package information"""
-        pack = self.getPackage(id)
-
-        if not pack:
-            return None
-
-        pack = pack.toDict()[id]
-
-        data = self.db.getPackageData(id)
-
-        tmplist = []
-
-        cache = self.cache.values()
-        for x in cache:
-            if int(x.toDbDict()[x.id]['package']) == int(id):
-                tmplist.append((x.id, x.toDbDict()[x.id]))
-        data.update(tmplist)
-
-        pack['links'] = data
-
-        return pack
-
-
-    #--------------------------------------------------------------------------
-
-    def getFileData(self, id):
-        """returns dict with file information"""
-        if id in self.cache:
-            return self.cache[id].toDbDict()
-
-        return self.db.getLinkData(id)
-
-
-    #--------------------------------------------------------------------------
-
-    def getFile(self, id):
-        """returns pyfile instance"""
-        if id in self.cache:
-            return self.cache[id]
-        else:
-            return self.db.getFile(id)
-
-
-    #--------------------------------------------------------------------------
-
-    @lock
-    def getJob(self, occ):
-        """get suitable job"""
-
-        #@TODO: clean mess
-        #@TODO: improve selection of valid jobs
-
-        if occ in self.jobCache:
-            if self.jobCache[occ]:
-                id = self.jobCache[occ].pop()
-                if id == "empty":
-                    pyfile = None
-                    self.jobCache[occ].append("empty")
-                else:
-                    pyfile = self.getFile(id)
-            else:
-                jobs = self.db.getJob(occ)
-                jobs.reverse()
-                if not jobs:
-                    self.jobCache[occ].append("empty")
-                    pyfile = None
-                else:
-                    self.jobCache[occ].extend(jobs)
-                    pyfile = self.getFile(self.jobCache[occ].pop())
-
-        else:
-            self.jobCache = {}  #: better not caching to much
-            jobs = self.db.getJob(occ)
-            jobs.reverse()
-            self.jobCache[occ] = jobs
-
-            if not jobs:
-                self.jobCache[occ].append("empty")
-                pyfile = None
-            else:
-                pyfile = self.getFile(self.jobCache[occ].pop())
-
-            #@TODO: maybe the new job has to be approved...
-
-        # pyfile = self.getFile(self.jobCache[occ].pop())
-        return pyfile
-
-
-    @lock
-    def getDecryptJob(self):
-        """return job for decrypting"""
-        if "decrypt" in self.jobCache:
-            return None
-
-        plugins = self.core.pluginManager.crypterPlugins.keys() + self.core.pluginManager.containerPlugins.keys()
-        plugins = str(tuple(plugins))
-
-        jobs = self.db.getPluginJob(plugins)
-        if jobs:
-            return self.getFile(jobs[0])
-        else:
-            self.jobCache['decrypt'] = "empty"
-            return None
-
-
-    def getFileCount(self):
-        """returns number of files"""
-
-        if self.filecount == -1:
-            self.filecount = self.db.filecount(1)
-
-        return self.filecount
-
-
-    def getQueueCount(self, force=False):
-        """number of files that have to be processed"""
-        if self.queuecount == -1 or force:
-            self.queuecount = self.db.queuecount(1)
-
-        return self.queuecount
-
-
-    def checkAllLinksFinished(self):
-        """checks if all files are finished and dispatch event"""
-
-        if not self.getQueueCount(True):
-            self.core.addonManager.dispatchEvent("all_downloads-finished")
-            self.core.log.debug("All downloads finished")
-            return True
-
-        return False
-
-
-    def checkAllLinksProcessed(self, fid):
-        """checks if all files was processed and pyload would idle now, needs fid which will be ignored when counting"""
-
-        # reset count so statistic will update (this is called when dl was processed)
-        self.resetCount()
-
-        if not self.db.processcount(1, fid):
-            self.core.addonManager.dispatchEvent("all_downloads-processed")
-            self.core.log.debug("All downloads processed")
-            return True
-
-        return False
-
-
-    def resetCount(self):
-        self.queuecount = -1
-
-
-    @lock
-    @change
-    def restartPackage(self, id):
-        """restart package"""
-        pyfiles = self.cache.values()
-        for pyfile in pyfiles:
-            if pyfile.packageid == id:
-                self.restartFile(pyfile.id)
-
-        self.db.restartPackage(id)
-
-        if id in self.packageCache:
-            self.packageCache[id].setFinished = False
-
-        e = UpdateEvent("pack", id, "collector" if not self.getPackage(id).queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-
-    @lock
-    @change
-    def restartFile(self, id):
-        """ restart file"""
-        if id in self.cache:
-            self.cache[id].status = 3
-            self.cache[id].name = self.cache[id].url
-            self.cache[id].error = ""
-            self.cache[id].abortDownload()
-
-        self.db.restartFile(id)
-
-        e = UpdateEvent("file", id, "collector" if not self.getFile(id).package().queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-
-    @lock
-    @change
-    def setPackageLocation(self, id, queue):
-        """push package to queue"""
-
-        p = self.db.getPackage(id)
-        oldorder = p.order
-
-        e = RemoveEvent("pack", id, "collector" if not p.queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-        self.db.clearPackageOrder(p)
-
-        p = self.db.getPackage(id)
-
-        p.queue = queue
-        self.db.updatePackage(p)
-
-        self.db.reorderPackage(p, -1, True)
-
-        packs = self.packageCache.values()
-        for pack in packs:
-            if pack.queue != queue and pack.order > oldorder:
-                pack.order -= 1
-                pack.notifyChange()
-
-        self.db.commit()
-        self.releasePackage(id)
-        p = self.getPackage(id)
-
-        e = InsertEvent("pack", id, p.order, "collector" if not p.queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-
-    @lock
-    @change
-    def reorderPackage(self, id, position):
-        p = self.getPackage(id)
-
-        e = RemoveEvent("pack", id, "collector" if not p.queue else "queue")
-        self.core.pullManager.addEvent(e)
-        self.db.reorderPackage(p, position)
-
-        packs = self.packageCache.values()
-        for pack in packs:
-            if pack.queue != p.queue or pack.order < 0 or pack == p:
-                continue
-            if p.order > position:
-                if position <= pack.order < p.order:
-                    pack.order += 1
-                    pack.notifyChange()
-            elif p.order < position:
-                if position >= pack.order > p.order:
-                    pack.order -= 1
-                    pack.notifyChange()
-
-        p.order = position
-        self.db.commit()
-
-        e = InsertEvent("pack", id, position, "collector" if not p.queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-
-    @lock
-    @change
-    def reorderFile(self, id, position):
-        f = self.getFileData(id)
-        f = f[id]
-
-        e = RemoveEvent("file", id, "collector" if not self.getPackage(f['package']).queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-        self.db.reorderLink(f, position)
-
-        pyfiles = self.cache.values()
-        for pyfile in pyfiles:
-            if pyfile.packageid != f['package'] or pyfile.order < 0:
-                continue
-            if f['order'] > position:
-                if position <= pyfile.order < f['order']:
-                    pyfile.order += 1
-                    pyfile.notifyChange()
-            elif f['order'] < position:
-                if position >= pyfile.order > f['order']:
-                    pyfile.order -= 1
-                    pyfile.notifyChange()
-
-        if id in self.cache:
-            self.cache[id].order = position
-
-        self.db.commit()
-
-        e = InsertEvent("file", id, position, "collector" if not self.getPackage(f['package']).queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-
-    @change
-    def updateFileInfo(self, data, pid):
-        """ updates file info (name, size, status, url)"""
-        ids = self.db.updateLinkInfo(data)
-        e = UpdateEvent("pack", pid, "collector" if not self.getPackage(pid).queue else "queue")
-        self.core.pullManager.addEvent(e)
-
-
-    def checkPackageFinished(self, pyfile):
-        """ checks if package is finished and calls AddonManager """
-
-        ids = self.db.getUnfinished(pyfile.packageid)
-        if not ids or (pyfile.id in ids and len(ids) == 1):
-            if not pyfile.package().setFinished:
-                self.core.log.info(_("Package finished: %s") % pyfile.package().name)
-                self.core.addonManager.packageFinished(pyfile.package())
-                pyfile.package().setFinished = True
-
-
-    def reCheckPackage(self, pid):
-        """ recheck links in package """
-        data = self.db.getPackageData(pid)
-
-        urls = []
-
-        for pyfile in data.itervalues():
-            if pyfile['status'] not in (0, 12, 13):
-                urls.append((pyfile['url'], pyfile['plugin']))
-
-        self.core.threadManager.createInfoThread(urls, pid)
-
-
-    @lock
-    @change
-    def deleteFinishedLinks(self):
-        """ deletes finished links and packages, return deleted packages """
-
-        old_packs = self.getInfoData(0)
-        old_packs.update(self.getInfoData(1))
-
-        self.db.deleteFinished()
-
-        new_packs = self.db.getAllPackages(0)
-        new_packs.update(self.db.getAllPackages(1))
-        # get new packages only from db
-
-        deleted = [id for id in old_packs.iterkeys() if id not in new_packs]
-        for id_deleted in deleted:
-            self.deletePackage(int(id_deleted))
-
-        return deleted
-
-
-    @lock
-    @change
-    def restartFailed(self):
-        """ restart all failed links """
-        self.db.restartFailed()
-
-
-class FileMethods(object):
-
-
-    @style.queue
-    def filecount(self, queue):
-        """returns number of files in queue"""
-        self.c.execute("SELECT COUNT(*) FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE p.queue=?",
-                       (queue,))
-        return self.c.fetchone()[0]
-
-
-    @style.queue
-    def queuecount(self, queue):
-        """ number of files in queue not finished yet"""
-        self.c.execute(
-            "SELECT COUNT(*) FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE p.queue=? AND l.status NOT IN (0, 4)",
-            (queue,))
-        return self.c.fetchone()[0]
-
-
-    @style.queue
-    def processcount(self, queue, fid):
-        """ number of files which have to be proccessed """
-        self.c.execute(
-            "SELECT COUNT(*) FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE p.queue=? AND l.status IN (2, 3, 5, 7, 12) AND l.id != ?",
-            (queue, str(fid)))
-        return self.c.fetchone()[0]
-
-
-    @style.inner
-    def _nextPackageOrder(self, queue=0):
-        self.c.execute('SELECT MAX(packageorder) FROM packages WHERE queue=?', (queue,))
-        max = self.c.fetchone()[0]
-        if max is not None:
-            return max + 1
-        else:
-            return 0
-
-
-    @style.inner
-    def _nextFileOrder(self, package):
-        self.c.execute('SELECT MAX(linkorder) FROM links WHERE package=?', (package,))
-        max = self.c.fetchone()[0]
-        if max is not None:
-            return max + 1
-        else:
-            return 0
-
-
-    @style.queue
-    def addLink(self, url, name, plugin, package):
-        order = self._nextFileOrder(package)
-        self.c.execute('INSERT INTO links(url, name, plugin, package, linkorder) VALUES(?,?,?,?,?)',
-                       (url, name, ".".join(plugintype, pluginname), package, order))
-        return self.c.lastrowid
-
-
-    @style.queue
-    def addLinks(self, links, package):
-        """ links is a list of tupels (url, plugin)"""
-        order = self._nextFileOrder(package)
-        orders = [order + x for x in xrange(len(links))]
-        links = [(x[0], x[0], ".".join((x[1], x[2])), package, o) for x, o in zip(links, orders)]
-        self.c.executemany('INSERT INTO links(url, name, plugin, package, linkorder) VALUES(?,?,?,?,?)', links)
-
-
-    @style.queue
-    def addPackage(self, name, folder, queue):
-        order = self._nextPackageOrder(queue)
-        self.c.execute('INSERT INTO packages(name, folder, queue, packageorder) VALUES(?,?,?,?)',
-                       (name, folder, queue, order))
-        return self.c.lastrowid
-
-
-    @style.queue
-    def deletePackage(self, p):
-        self.c.execute('DELETE FROM links WHERE package=?', (str(p.id),))
-        self.c.execute('DELETE FROM packages WHERE id=?', (str(p.id),))
-        self.c.execute('UPDATE packages SET packageorder=packageorder-1 WHERE packageorder > ? AND queue=?',
-                       (p.order, p.queue))
-
-
-    @style.queue
-    def deleteLink(self, f):
-        self.c.execute('DELETE FROM links WHERE id=?', (str(f.id),))
-        self.c.execute('UPDATE links SET linkorder=linkorder-1 WHERE linkorder > ? AND package=?',
-                       (f.order, str(f.packageid)))
-
-
-    @style.queue
-    def getAllLinks(self, q):
-        """return information about all links in queue q
-
-        q0 queue
-        q1 collector
-
-        format:
-
-        {
-            id: {'name': name, ... 'package': id }, ...
-        }
-
-        """
-        self.c.execute(
-            'SELECT l.id, l.url, l.name, l.size, l.status, l.error, l.plugin, l.package, l.linkorder FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE p.queue=? ORDER BY l.linkorder',
-            (q,))
-        data = {}
-        for r in self.c:
-            data[r[0]] = {
-                'id': r[0],
-                'url': r[1],
-                'name': r[2],
-                'size': r[3],
-                'format_size': formatSize(r[3]),
-                'status': r[4],
-                'statusmsg': self.manager.statusMsg[r[4]],
-                'error': r[5],
-                'plugin': tuple(r[6].split('.')),
-                'package': r[7],
-                'order': r[8],
-            }
-
-        return data
-
-
-    @style.queue
-    def getAllPackages(self, q):
-        """return information about packages in queue q
-        (only useful in get all data)
-
-        q0 queue
-        q1 collector
-
-        format:
-
-        {
-            id: {'name': name ... 'links': {}}, ...
-        }
-        """
-        self.c.execute('SELECT p.id, p.name, p.folder, p.site, p.password, p.queue, p.packageorder, s.sizetotal, s.sizedone, s.linksdone, s.linkstotal \
-            FROM packages p JOIN pstats s ON p.id = s.id \
-            WHERE p.queue=? ORDER BY p.packageorder', str(q))
-
-        data = {}
-        for r in self.c:
-            data[r[0]] = {
-                'id': r[0],
-                'name': r[1],
-                'folder': r[2],
-                'site': r[3],
-                'password': r[4],
-                'queue': r[5],
-                'order': r[6],
-                'sizetotal': int(r[7]),
-                'sizedone': r[8] if r[8] else 0,  #: these can be None
-                'linksdone': r[9] if r[9] else 0,
-                'linkstotal': r[10],
-                'links': {}
-            }
-
-        return data
-
-
-    @style.queue
-    def getLinkData(self, id):
-        """get link information as dict"""
-        self.c.execute('SELECT id, url, name, size, status, error, plugin, package, linkorder FROM links WHERE id=?',
-                       (str(id),))
-        data = {}
-        r = self.c.fetchone()
-        if not r:
-            return None
-        data[r[0]] = {
-            'id': r[0],
-            'url': r[1],
-            'name': r[2],
-            'size': r[3],
-            'format_size': formatSize(r[3]),
-            'status': r[4],
-            'statusmsg': self.manager.statusMsg[r[4]],
-            'error': r[5],
-            'plugin': tuple(r[6].split('.')),
-            'package': r[7],
-            'order': r[8],
-        }
-
-        return data
-
-
-    @style.queue
-    def getPackageData(self, id):
-        """get data about links for a package"""
-        self.c.execute(
-            'SELECT id, url, name, size, status, error, plugin, package, linkorder FROM links WHERE package=? ORDER BY linkorder',
-            (str(id),))
-
-        data = {}
-        for r in self.c:
-            data[r[0]] = {
-                'id': r[0],
-                'url': r[1],
-                'name': r[2],
-                'size': r[3],
-                'format_size': formatSize(r[3]),
-                'status': r[4],
-                'statusmsg': self.manager.statusMsg[r[4]],
-                'error': r[5],
-                'plugin': tuple(r[6].split('.')),
-                'package': r[7],
-                'order': r[8],
-            }
-
-        return data
-
-
-    @style.async
-    def updateLink(self, f):
-        self.c.execute('UPDATE links SET url=?, name=?, size=?, status=?, error=?, package=? WHERE id=?',
-                       (f.url, f.name, f.size, f.status, str(f.error), str(f.packageid), str(f.id)))
-
-
-    @style.queue
-    def updatePackage(self, p):
-        self.c.execute('UPDATE packages SET name=?, folder=?, site=?, password=?, queue=? WHERE id=?',
-                       (p.name, p.folder, p.site, p.password, p.queue, str(p.id)))
-
-    @style.queue
-    def updateLinkInfo(self, data):
-        """ data is list of tupels (name, size, status, url) """
-        self.c.executemany('UPDATE links SET name=?, size=?, status=? WHERE url=? AND status IN (1, 2, 3, 14)', data)
-        ids = []
-        self.c.execute('SELECT id FROM links WHERE url IN (\'%s\')' % "','".join([x[3] for x in data]))
-        for r in self.c:
-            ids.append(int(r[0]))
-        return ids
-
-
-    @style.queue
-    def reorderPackage(self, p, position, noMove=False):
-        if position == -1:
-            position = self._nextPackageOrder(p.queue)
-        if not noMove:
-            if p.order > position:
-                self.c.execute(
-                    'UPDATE packages SET packageorder=packageorder+1 WHERE packageorder >= ? AND packageorder < ? AND queue=? AND packageorder >= 0',
-                    (position, p.order, p.queue))
-            elif p.order < position:
-                self.c.execute(
-                    'UPDATE packages SET packageorder=packageorder-1 WHERE packageorder <= ? AND packageorder > ? AND queue=? AND packageorder >= 0',
-                    (position, p.order, p.queue))
-
-        self.c.execute('UPDATE packages SET packageorder=? WHERE id=?', (position, str(p.id)))
-
-
-    @style.queue
-    def reorderLink(self, f, position):
-        """ reorder link with f as dict for pyfile  """
-        if f['order'] > position:
-            self.c.execute('UPDATE links SET linkorder=linkorder+1 WHERE linkorder >= ? AND linkorder < ? AND package=?',
-                           (position, f['order'], f['package']))
-        elif f['order'] < position:
-            self.c.execute('UPDATE links SET linkorder=linkorder-1 WHERE linkorder <= ? AND linkorder > ? AND package=?',
-                           (position, f['order'], f['package']))
-
-        self.c.execute('UPDATE links SET linkorder=? WHERE id=?', (position, f['id']))
-
-
-    @style.queue
-    def clearPackageOrder(self, p):
-        self.c.execute('UPDATE packages SET packageorder=? WHERE id=?', (-1, str(p.id)))
-        self.c.execute('UPDATE packages SET packageorder=packageorder-1 WHERE packageorder > ? AND queue=? AND id != ?',
-                       (p.order, p.queue, str(p.id)))
-
-
-    @style.async
-    def restartFile(self, id):
-        self.c.execute('UPDATE links SET status=3, error="" WHERE id=?', (str(id),))
-
-
-    @style.async
-    def restartPackage(self, id):
-        self.c.execute('UPDATE links SET status=3 WHERE package=?', (str(id),))
-
-
-    @style.queue
-    def getPackage(self, id):
-        """return package instance from id"""
-        self.c.execute("SELECT name, folder, site, password, queue, packageorder FROM packages WHERE id=?", (str(id),))
-        r = self.c.fetchone()
-        if not r:
-            return None
-        return PyPackage(self.manager, id, *r)
-
-
-    #--------------------------------------------------------------------------
-
-    @style.queue
-    def getFile(self, id):
-        """return link instance from id"""
-        self.c.execute("SELECT url, name, size, status, error, plugin, package, linkorder FROM links WHERE id=?",
-                       (str(id),))
-        r = self.c.fetchone()
-        if not r:
-            return None
-        r = list(r)
-        r[5] = tuple(r[5].split('.'))
-        return PyFile(self.manager, id, *r)
-
-
-    @style.queue
-    def getJob(self, occ):
-        """return pyfile ids, which are suitable for download and dont use a occupied plugin"""
-
-        #@TODO: improve this hardcoded method
-        pre = "('CCF', 'DLC', 'LinkList', 'RSDF', 'TXT')"  #: plugins which are processed in collector
-
-        cmd = "("
-        for i, item in enumerate(occ):
-            if i: cmd += ", "
-            cmd += "'%s'" % item
-
-        cmd += ")"
-
-        cmd = "SELECT l.id FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE ((p.queue=1 AND l.plugin NOT IN %s) OR l.plugin IN %s) AND l.status IN (2, 3, 14) ORDER BY p.packageorder ASC, l.linkorder ASC LIMIT 5" % (cmd, pre)
-
-        self.c.execute(cmd)  #: very bad!
-
-        return [x[0] for x in self.c]
-
-
-    @style.queue
-    def getPluginJob(self, plugins):
-        """returns pyfile ids with suited plugins"""
-        cmd = "SELECT l.id FROM links as l INNER JOIN packages as p ON l.package=p.id WHERE l.plugin IN %s AND l.status IN (2, 3, 14) ORDER BY p.packageorder ASC, l.linkorder ASC LIMIT 5" % plugins
-
-        self.c.execute(cmd)  #: very bad!
-
-        return [x[0] for x in self.c]
-
-
-    @style.queue
-    def getUnfinished(self, pid):
-        """return list of max length 3 ids with pyfiles in package not finished or processed"""
-
-        self.c.execute("SELECT id FROM links WHERE package=? AND status NOT IN (0, 4, 13) LIMIT 3", (str(pid),))
-        return [r[0] for r in self.c]
-
-
-    @style.queue
-    def deleteFinished(self):
-        self.c.execute("DELETE FROM links WHERE status IN (0, 4)")
-        self.c.execute("DELETE FROM packages WHERE NOT EXISTS(SELECT 1 FROM links WHERE packages.id=links.package)")
-
-
-    @style.queue
-    def restartFailed(self):
-        self.c.execute("UPDATE links SET status=3, error='' WHERE status IN (6, 8, 9)")
-
-
-    @style.queue
-    def findDuplicates(self, id, folder, filename):
-        """ checks if filename exists with different id and same package """
-        self.c.execute(
-            "SELECT l.plugin FROM links as l INNER JOIN packages as p ON l.package=p.id AND p.folder=? WHERE l.id!=? AND l.status=0 AND l.name=?",
-            (folder, id, filename))
-        return self.c.fetchone()
-
-
-    @style.queue
-    def purgeLinks(self):
-        self.c.execute("DELETE FROM links;")
-        self.c.execute("DELETE FROM packages;")
-
-
-DatabaseBackend.registerSub(FileMethods)