def del_from_db(self, uri, backup):
"""
Delete track from db
@param uri as str
@param backup as bool
@return (popularity, ltime, mtime,
loved album, album_popularity)
"""
try:
track_id = App().tracks.get_id_by_uri(uri)
duration = App().tracks.get_duration(track_id)
album_id = App().tracks.get_album_id(track_id)
album_artist_ids = App().albums.get_artist_ids(album_id)
artist_ids = App().tracks.get_artist_ids(track_id)
track_pop = App().tracks.get_popularity(track_id)
track_rate = App().tracks.get_rate(track_id)
track_ltime = App().tracks.get_ltime(track_id)
album_mtime = App().tracks.get_mtime(track_id)
track_loved = App().tracks.get_loved(track_id)
album_pop = App().albums.get_popularity(album_id)
album_rate = App().albums.get_rate(album_id)
album_loved = App().albums.get_loved(album_id)
album_synced = App().albums.get_synced(album_id)
if backup:
f = Gio.File.new_for_uri(uri)
name = f.get_basename()
self.__history.add(name, duration, track_pop, track_rate,
track_ltime, album_mtime, track_loved,
album_loved, album_pop, album_rate,
album_synced)
App().tracks.remove(track_id)
genre_ids = App().tracks.get_genre_ids(track_id)
App().albums.clean()
App().genres.clean()
App().artists.clean()
App().cache.clear_durations(album_id)
SqlCursor.commit(App().db)
item = CollectionItem(album_id=album_id)
if not App().albums.get_name(album_id):
item.artist_ids = []
for artist_id in album_artist_ids + artist_ids:
if not App().artists.get_name(artist_id):
item.artist_ids.append(artist_id)
item.genre_ids = []
for genre_id in genre_ids:
if not App().genres.get_name(genre_id):
item.genre_ids.append(genre_id)
emit_signal(self, "updated", item, ScanUpdate.REMOVED)
else:
# Force genre for album
genre_ids = App().tracks.get_album_genre_ids(album_id)
App().albums.set_genre_ids(album_id, genre_ids)
emit_signal(self, "updated", item, ScanUpdate.MODIFIED)
return (track_pop, track_rate, track_ltime, album_mtime,
track_loved, album_loved, album_pop, album_rate)
except Exception as e:
Logger.error("CollectionScanner::del_from_db: %s" % e)
def collection_item(self):
"""
Get collection item related to album
@return CollectionItem
"""
item = CollectionItem(album_id=self.id,
album_name=self.name,
artist_ids=self.artist_ids,
lp_album_id=self.lp_album_id)
return item
def __save(self, save):
"""
Save album to collection.
@param save as bool
"""
# Save album by updating storage type
if save:
self.db.set_storage_type(self.id, StorageType.SAVED)
else:
self.db.set_storage_type(self.id, StorageType.EPHEMERAL)
self.reset("mtime")
if save:
item = CollectionItem(artist_ids=self.artist_ids, album_id=self.id)
emit_signal(App().scanner, "updated", item, ScanUpdate.ADDED)
else:
removed_artist_ids = []
for artist_id in self.artist_ids:
if not App().artists.get_name(artist_id):
removed_artist_ids.append(artist_id)
item = CollectionItem(artist_ids=removed_artist_ids,
album_id=self.id)
emit_signal(App().scanner, "updated", item, ScanUpdate.REMOVED)
def __scan_files(self, files, db_mtimes, scan_type):
"""
Scan music collection for new audio files
@param files as [str]
@param db_mtimes as {}
@param scan_type as ScanType
@thread safe
"""
discoverer = Discoverer()
try:
# Scan new files
for (mtime, uri) in files:
# Handle a stop request
if self.__thread is None and scan_type != ScanType.EXTERNAL:
raise Exception("cancelled")
try:
if not self.__scan_to_handle(uri):
self.__progress_count += 2
continue
db_mtime = db_mtimes.get(uri, 0)
if mtime > db_mtime:
# Do not use mtime if not intial scan
if db_mtimes:
mtime = int(time())
self.__tags[uri] = self.__get_tags(
discoverer, uri, mtime)
self.__progress_count += 1
self.__update_progress(self.__progress_count,
self.__progress_total, 0.001)
else:
# We want to play files, so put them in items
if scan_type == ScanType.EXTERNAL:
track_id = App().tracks.get_id_by_uri(uri)
item = CollectionItem(track_id=track_id)
self.__items.append(item)
self.__progress_count += 2
self.__update_progress(self.__progress_count,
self.__progress_total, 0.1)
except Exception as e:
Logger.error("Scanning file: %s, %s" % (uri, e))
except Exception as e:
Logger.warning("CollectionScanner::__scan_files(): % s" % e)
def __save_album(self, payload, storage_type):
"""
Save album payload to DB
@param payload as {}
@param storage_type as StorageType
@return CollectionItem
"""
(timestamp, year) = self.__get_date_from_payload(payload)
item = CollectionItem(uri=payload["uri"],
album_artists=payload["artists"],
album_name=payload["name"],
album_mtime=int(time()),
year=year,
timestamp=timestamp,
mb_album_id=payload["mbid"],
album_synced=payload["track-count"],
storage_type=storage_type)
Logger.debug("SaveWebHelper::save_album(): %s - %s",
item.album_artists, item.album_name)
App().scanner.save_album(item)
App().albums.add_genre(item.album_id, Type.WEB)
return item
def __add2db(self,
uri,
name,
artists,
genres,
a_sortnames,
aa_sortnames,
album_artists,
album_name,
discname,
album_loved,
album_mtime,
album_synced,
album_rate,
album_pop,
discnumber,
year,
timestamp,
mb_album_id,
mb_track_id,
mb_artist_id,
mb_album_artist_id,
tracknumber,
track_pop,
track_rate,
bpm,
track_mtime,
track_ltime,
track_loved,
duration,
storage_type=StorageType.COLLECTION):
"""
Add new file to DB
@param uri as str
@param tags as *()
@param storage_type as StorageType
@return CollectionItem
"""
item = CollectionItem(uri=uri,
track_name=name,
artists=artists,
genres=genres,
a_sortnames=a_sortnames,
aa_sortnames=aa_sortnames,
album_artists=album_artists,
album_name=album_name,
discname=discname,
album_loved=album_loved,
album_mtime=album_mtime,
album_synced=album_synced,
album_rate=album_rate,
album_pop=album_pop,
discnumber=discnumber,
year=year,
timestamp=timestamp,
mb_album_id=mb_album_id,
mb_track_id=mb_track_id,
mb_artist_id=mb_artist_id,
mb_album_artist_id=mb_album_artist_id,
tracknumber=tracknumber,
track_pop=track_pop,
track_rate=track_rate,
bpm=bpm,
track_mtime=track_mtime,
track_ltime=track_ltime,
track_loved=track_loved,
duration=duration,
storage_type=storage_type)
self.save_album(item)
self.save_track(item)
return item