Exemplo n.º 1
0
    def remove(self, book):
        """
        Remove all tracks of the given book from the cache.
        """
        #self._stop_processing()
        tracks = get_tracks(book)
        ids = [t.id for t in tracks]
        offline_elements = OfflineCacheModel.select().where(
            OfflineCacheModel.track << ids)

        for element in offline_elements:
            file_path = os.path.join(self.cache_dir, element.file)
            if file_path == self.cache_dir:
                continue

            file = Gio.File.new_for_path(file_path)
            if file.query_exists():
                file.delete()

            for item in self.queue:
                if self.current and item.id == self.current.id:
                    self.filecopy_cancel.cancel()

        OfflineCacheModel.delete().where(
            OfflineCacheModel.track in ids).execute()

        if len(self.queue) > 0:
            self._start_processing()
Exemplo n.º 2
0
 def update_cache(self, paths):
     """
     Update the cached version of the given files.
     """
     if OfflineCacheModel.select().count() > 0:
         OfflineCacheModel.update(copied=False).where(
             OfflineCacheModel.track.file in paths).execute()
         self._fill_queue_from_db()
Exemplo n.º 3
0
    def remove_all_for_storage(self, storage_path):
        """
        """
        for element in OfflineCacheModel.select().join(Track).where(
                storage_path in Track.file):
            file_path = os.path.join(self.cache_dir, element.file)
            if file_path == self.cache_dir:
                continue

            file = Gio.File.new_for_path(file_path)
            if file.query_exists():
                file.delete()

            if element.track.book.offline == True:
                element.track.book.update(offline=False,
                                          downloaded=False).execute()

        OfflineCacheModel.delete().where(
            storage_path in OfflineCacheModel.track.file).execute()
Exemplo n.º 4
0
 def get_cached_path(self, track):
     """
     """
     query = OfflineCacheModel.select().where(
         OfflineCacheModel.track == track.id,
         OfflineCacheModel.copied == True)
     if query.count() > 0:
         return os.path.join(self.cache_dir, query.get().file)
     else:
         return None
Exemplo n.º 5
0
    def add(self, book):
        """
        Add all tracks of a book to the offline cache and start copying.
        """
        tracks = []
        for track in get_tracks(book):
            file = str(uuid.uuid4())
            tracks.append((track, file))
        chunks = [tracks[x:x + 500] for x in range(0, len(tracks), 500)]
        for chunk in chunks:
            query = OfflineCacheModel.insert_many(
                chunk,
                fields=[OfflineCacheModel.track, OfflineCacheModel.file])
            self.total_batch_count += len(chunk)
            query.execute()

        self._start_processing()
Exemplo n.º 6
0
    def update_book_download_status(self, book):
        """
        Updates the downloaded status of a book.
        """
        downloaded = True
        tracks = get_tracks(book)
        offline_tracks = OfflineCacheModel.select().where(
            OfflineCacheModel.track in tracks)

        if offline_tracks.count() < 1:
            downloaded = False
        else:
            for track in offline_tracks:
                if not track.copied:
                    downloaded = False

        Book.update(downloaded=downloaded).where(Book.id == book.id).execute()
        if downloaded:
            self.emit_event("book-offline", book)
        else:
            self.emit_event("book-offline-removed", book)
Exemplo n.º 7
0
 def _fill_queue_from_db(self):
     for item in OfflineCacheModel.select().where(
             OfflineCacheModel.copied == False):
         if not any(item.id == queued.id for queued in self.queue):
             self.queue.append(item)
             self.total_batch_count += 1
Exemplo n.º 8
0
    def _process_queue(self):
        log.info("Startet processing queue")
        self.filecopy_cancel = Gio.Cancellable()

        self._fill_queue_from_db()
        self.total_batch_count = len(self.queue)
        self.current_batch_count = 0
        if len(self.queue) > 0:
            self.current_book_processing = self.queue[0].track.book.id

        while len(self.queue) > 0:
            log.info("Processing item")
            self.current_batch_count += 1
            item = self.queue[0]
            if self.thread.stopped():
                break

            new_item = OfflineCacheModel.get(OfflineCacheModel.id == item.id)

            if self.current_book_processing != new_item.track.book.id:
                self.update_book_download_status(
                    Book.get(Book.id == self.current_book_processing))
                self.current_book_processing = new_item.track.book.id

            if not new_item.copied and os.path.exists(new_item.track.file):
                log.info("Copying item")
                Gdk.threads_add_idle(
                    GLib.PRIORITY_DEFAULT_IDLE, self.ui.switch_to_working,
                    _("Copying") + " " +
                    tools.shorten_string(new_item.track.book.name, 30), False,
                    False)
                self.current = new_item

                destination = Gio.File.new_for_path(
                    os.path.join(self.cache_dir, new_item.file))
                source = Gio.File.new_for_path(new_item.track.file)
                flags = Gio.FileCopyFlags.OVERWRITE
                try:
                    copied = source.copy(destination, flags,
                                         self.filecopy_cancel,
                                         self.__update_copy_status, None)
                except Exception as e:
                    if e.code == Gio.IOErrorEnum.CANCELLED:
                        log.info("Download of book was cancelled.")
                        self.thread.stop()
                        break
                    log.error("Could not copy file to offline cache: " +
                              new_item.track.file)
                    log.error(e)
                    self.queue.remove(item)
                    continue

                if copied:
                    OfflineCacheModel.update(copied=True).where(
                        OfflineCacheModel.id == new_item.id).execute()

            self.queue.remove(item)

        if self.current_book_processing:
            self.update_book_download_status(
                Book.get(Book.id == self.current_book_processing))

        self.current = None
        Gdk.threads_add_idle(GLib.PRIORITY_DEFAULT_IDLE,
                             self.ui.switch_to_playing)