def api(self, type, query):
if type == "artist":
entities = search.query_artist(query)
elif type == "album":
entities = search.query_album(query)
elif type == "track":
entities = search.query_track(query)
else:
raise cherrypy.NotFound()
return [{"name": entity.name} for entity in entities]
def albums(self, view=None, sort=None, filter=None, filter_value=None, page=None):
if view is None:
view = "covers"
if sort is None:
sort = "created"
if filter is None:
filter = "none"
if filter_value is None:
filter_value = ""
if page is None:
page = 1
page = int(page)
page_size = 24
offset = page_size * (page - 1)
query = (get_database()
.query(Album)
.join(Track, Album.id == Track.album_id)
.filter(Track.scanned)
.group_by(Album.id))
albums = []
if filter == "yours":
remotes_user = remotes.get_user(cherrypy.request.user)
album_ids = []
if remotes_user is not None and remotes_user['lastfm'] is not None:
for album in remotes_user['lastfm']['top_albums_overall']:
album_results = search.query_album(album['name'], exact=True)
if len(album_results) > 0:
album_ids.append(album_results[0].id)
query = query.filter(Album.id.in_(album_ids))
elif filter == "1year":
now = datetime.datetime.utcnow()
query = query.filter(Album.created > now - datetime.timedelta(days=365))
elif filter == "va":
query = (query.join(Artist, Artist.id == Track.artist_id)
.having(func.count(distinct(Artist.id)) > 1))
elif filter == "invalid":
query = query.filter("invalid is not null")
elif filter == "tag":
album_ids = []
if filter_value != "":
remotes.update_tag(filter_value)
remotes_tag = remotes.get_tag(filter_value)
if remotes_tag is not None and remotes_tag['lastfm'] is not None:
for album in remotes_tag['lastfm']['albums']:
album_results = search.query_album(album['name'], exact=True)
if len(album_results) > 0:
album_ids.append(album_results[0].id)
query = query.filter(Album.id.in_(album_ids))
# count before adding order_by() for performance reasons..
total = query.count()
pages = math.ceil(total / page_size)
if sort == "created":
query = query.order_by(Album.created.desc())
elif sort == "updated":
query = query.order_by(Album.updated.desc())
elif sort == "seen":
query = (query.outerjoin(UserAndAlbum, and_(Album.id == UserAndAlbum.album_id,
UserAndAlbum.user_id == cherrypy.request.user.id))
.order_by(UserAndAlbum.seen.desc())
.order_by(Album.updated.desc()))
elif sort == "date":
query = (query
.order_by(Album.date.desc())
.order_by(Album.updated.desc()))
elif sort == "random":
query = query.order_by(func.rand())
page = None
albums = query.limit(page_size).offset(offset).all()
for album in albums:
remotes.update_album(album)
for artist in album.artists:
remotes.update_artist(artist)
return {
'albums': albums,
'page': page,
'page_size': page_size,
'total': total,
'sort': sort,
'filter': filter,
'filter_value': filter_value,
'pages': pages,
"view": view
}
def default(self, query=None, type=None):
artists = []
albums = []
tracks = []
track_ids = []
hierarchy = None
album_track_ids = set()
recent_searches = []
if query is not None:
albums = None
tracks = None
# only search for artists
if type == 'artist':
artists = search.query_artist(query, exact=True)
albums = []
tracks = []
else:
artists = search.query_artist(query)
if albums is None:
albums = search.query_album(query)
if tracks is None:
tracks = search.query_track(query)
for artist in artists:
remotes.update_artist(artist)
for album in albums:
remotes.update_album(album)
for track in tracks:
track_ids.append(track.id)
remotes.update_track(track)
entities = artists + albums + tracks
if len(entities) == 1:
for artist in artists:
raise HTTPRedirect('/%s' % artist.slug)
for album in albums:
raise HTTPRedirect('/%s/%s' % (album.artists[0].slug, album.slug))
for track in tracks:
raise HTTPRedirect('/library/track/%s' % track.slug)
if cache.has(Search.CACHE_RECENT_KEY):
recent_searches = cache.get(Search.CACHE_RECENT_KEY)
else:
cache.set(Search.CACHE_RECENT_KEY, recent_searches)
if type is None and len(entities) > 0:
if len(recent_searches) == 0 or query != recent_searches[0][0]:
recent_searches.insert(0, (query, datetime.datetime.now(), cherrypy.request.user.login))
if len(recent_searches) > Search.MAX_RECENT:
recent_searches.pop()
entities = sorted(entities, key=lambda entity: entity._SEARCH_SCORE, reverse=True)
hierarchy = Library._produce_track_hierarchy(entities)
for key, result_artist in hierarchy['artists'].items():
for key, result_album in result_artist['albums'].items():
for track_id in library_dao.get_track_ids_by_album_id(result_album['entity'].id):
album_track_ids.add(track_id)
return {
'query': query,
'hierarchy': hierarchy,
'tracks': tracks,
'albums': albums,
'artists': artists,
'track_ids': track_ids,
'album_track_ids': list(album_track_ids),
'recent_searches': recent_searches
}
