def album_list():
ltype = request.values["type"]
size, offset = map(request.values.get, ("size", "offset"))
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = select(t.folder for t in Track)
if ltype == "random":
return request.formatter(
"albumList",
{
"album": [
a.as_subsonic_child(request.user)
for a in distinct(query.random(size))
]
},
)
elif ltype == "newest":
query = query.sort_by(desc(Folder.created)).distinct()
elif ltype == "highest":
query = query.sort_by(lambda f: desc(avg(f.ratings.rating)))
elif ltype == "frequent":
query = query.sort_by(lambda f: desc(avg(f.tracks.play_count)))
elif ltype == "recent":
query = select(t.folder for t in Track
if max(t.folder.tracks.last_play) is not None).sort_by(
lambda f: desc(max(f.tracks.last_play)))
elif ltype == "starred":
query = select(
s.starred for s in StarredFolder
if s.user.id == request.user.id and count(s.starred.tracks) > 0)
elif ltype == "alphabeticalByName":
query = query.sort_by(Folder.name).distinct()
elif ltype == "alphabeticalByArtist":
query = query.sort_by(lambda f: f.parent.name + f.name)
elif ltype == "byYear":
startyear = int(request.values["fromYear"])
endyear = int(request.values["toYear"])
query = query.where(lambda t: between(t.year, min(startyear, endyear),
max(startyear, endyear)))
if endyear < startyear:
query = query.sort_by(lambda f: desc(min(f.tracks.year)))
else:
query = query.sort_by(lambda f: min(f.tracks.year))
elif ltype == "byGenre":
genre = request.values["genre"]
query = query.where(lambda t: t.genre == genre)
else:
raise GenericError("Unknown search type")
return request.formatter(
"albumList",
{
"album": [
f.as_subsonic_child(request.user)
for f in query.limit(size, offset)
]
},
)
def as_subsonic_album(self, user): # "AlbumID3" type in XSD
info = {
"id": str(self.id),
"name": self.name,
"artist": self.artist.name,
"artistId": str(self.artist.id),
"songCount": self.tracks.count(),
"duration": sum(self.tracks.duration),
"created": min(self.tracks.created).isoformat(),
}
track_with_cover = self.tracks.select(
lambda t: t.folder.cover_art is not None).first()
if track_with_cover is not None:
info["coverArt"] = str(track_with_cover.folder.id)
else:
track_with_cover = self.tracks.select(lambda t: t.has_art).first()
if track_with_cover is not None:
info["coverArt"] = str(track_with_cover.id)
if count(self.tracks.year) > 0:
info["year"] = min(self.tracks.year)
genre = ", ".join(self.tracks.genre.distinct())
if genre:
info["genre"] = genre
try:
starred = StarredAlbum[user.id, self.id]
info["starred"] = starred.date.isoformat()
except ObjectNotFound:
pass
return info
def album_list_id3():
ltype = request.values["type"]
size, offset = map(request.values.get, ("size", "offset"))
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = Album.select()
if ltype == "random":
return request.formatter(
"albumList2",
{
"album": [
a.as_subsonic_album(request.user)
for a in query.random(size)
]
},
)
elif ltype == "newest":
query = query.order_by(lambda a: desc(min(a.tracks.created)))
elif ltype == "frequent":
query = query.order_by(lambda a: desc(avg(a.tracks.play_count)))
elif ltype == "recent":
query = Album.select(
lambda a: max(a.tracks.last_play) is not None).order_by(
lambda a: desc(max(a.tracks.last_play)))
elif ltype == "starred":
query = select(s.starred for s in StarredAlbum
if s.user.id == request.user.id)
elif ltype == "alphabeticalByName":
query = query.order_by(Album.name)
elif ltype == "alphabeticalByArtist":
query = query.order_by(lambda a: a.artist.name + a.name)
elif ltype == "byYear":
startyear = int(request.values["fromYear"])
endyear = int(request.values["toYear"])
query = query.where(lambda a: between(min(
a.tracks.year), min(startyear, endyear), max(startyear, endyear)))
if endyear < startyear:
query = query.order_by(lambda a: desc(min(a.tracks.year)))
else:
query = query.order_by(lambda a: min(a.tracks.year))
elif ltype == "byGenre":
genre = request.values["genre"]
query = query.where(lambda a: genre in a.tracks.genre)
else:
raise GenericError("Unknown search type")
return request.formatter(
"albumList2",
{
"album": [
f.as_subsonic_album(request.user)
for f in query.limit(size, offset)
]
},
)
def as_subsonic_album(self, user):
info = dict(
id=str(self.id),
name=self.name,
artist=self.artist.name,
artistId=str(self.artist.id),
songCount=self.tracks.count(),
duration=sum(self.tracks.duration),
created=min(self.tracks.created).isoformat(),
)
track_with_cover = self.tracks.select(
lambda t: t.folder.cover_art is not None).first()
if track_with_cover is not None:
info["coverArt"] = str(track_with_cover.folder.id)
else:
track_with_cover = self.tracks.select(lambda t: t.has_art).first()
if track_with_cover is not None:
info["coverArt"] = str(track_with_cover.id)
try:
starred = StarredAlbum[user.id, self.id]
info["starred"] = starred.date.isoformat()
except ObjectNotFound:
pass
return info
def as_subsonic_album(self, user):
info = dict(
id = str(self.id),
name = self.name,
artist = self.artist.name,
artistId = str(self.artist.id),
songCount = self.tracks.count(),
duration = sum(self.tracks.duration),
created = min(self.tracks.created).isoformat()
)
track_with_cover = self.tracks.select(lambda t: t.folder.cover_art is not None).first()
if track_with_cover is not None:
info['coverArt'] = str(track_with_cover.folder.id)
else:
track_with_cover = self.tracks.select(lambda t: t.has_art).first()
if track_with_cover is not None:
info['coverArt'] = str(track_with_cover.id)
try:
starred = StarredAlbum[user.id, self.id]
info['starred'] = starred.date.isoformat()
except ObjectNotFound: pass
return info
def album_list_id3():
ltype = request.values['type']
size, offset = map(request.values.get, [ 'size', 'offset' ])
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = Album.select()
if ltype == 'random':
return request.formatter('albumList2', dict(
album = [ a.as_subsonic_album(request.user) for a in query.random(size) ]
))
elif ltype == 'newest':
query = query.order_by(lambda a: desc(min(a.tracks.created)))
elif ltype == 'frequent':
query = query.order_by(lambda a: desc(avg(a.tracks.play_count)))
elif ltype == 'recent':
query = Album.select(lambda a: max(a.tracks.last_play) is not None).order_by(lambda a: desc(max(a.tracks.last_play)))
elif ltype == 'starred':
query = select(s.starred for s in StarredAlbum if s.user.id == request.user.id)
elif ltype == 'alphabeticalByName':
query = query.order_by(Album.name)
elif ltype == 'alphabeticalByArtist':
query = query.order_by(lambda a: a.artist.name + a.name)
else:
raise GenericError('Unknown search type')
return request.formatter('albumList2', dict(
album = [ f.as_subsonic_album(request.user) for f in query.limit(size, offset) ]
))
def checknewscomments(news):
orm.sql_debug(False)
if not news:
with orm.db_session:
first_newsitem = orm.select(orm.min(x.id) for x in NewsItem).first()
last_newsitem = orm.select(orm.max(x.id) for x in NewsItem).first()
newsitem_id = first_newsitem
else:
i = 0
while True:
with orm.db_session:
if not news:
newsitem = NewsItem.select(lambda x: x.id >= newsitem_id and x.id <= last_newsitem).first()
if not newsitem:
break
else:
if i >= len(news):
break
if news[i].isdigit():
newsitem = NewsItem.get(id=int(news[i]))
else:
newsitem = NewsItem.get(name=news[i])
i += 1
if not newsitem:
print('News item {} not found'.format(news[i - 1]))
continue
print('News item {} ({})'.format(newsitem.id, newsitem.name))
comments_list = newsitem.bl.select_comments().order_by('c.date, c.id')
check_comments_for(newsitem, comments_list)
newsitem_id = newsitem.id + 1
def checkstoryvoting(story_ids):
orm.sql_debug(False)
if not current_app.story_voting:
print('Story voting is disabled.')
return
if not story_ids:
with orm.db_session:
first_story = orm.select(orm.min(x.id) for x in Story).first()
last_story = orm.select(orm.max(x.id) for x in Story).first()
story_id = first_story
else:
story_ids_queue = story_ids[::-1] # reversed
while True:
with orm.db_session:
if not story_ids:
stories = Story.select(lambda x: x.id >= story_id and x.id <= last_story).order_by(Story.id)[:50]
if not stories:
break
else:
if not story_ids_queue:
break
stories = list(Story.select(lambda x: x.id in story_ids_queue[-50:]).order_by(Story.id))
story_ids_queue = story_ids_queue[:-50]
if not stories:
continue
changed_stories = []
for story in stories:
print('Story {}:'.format(story.id), end=' ', flush=True)
old_count = story.vote_total # TODO: rename to story.vote_count
old_value = story.vote_value
old_extra = story.vote_extra
current_app.story_voting.update_rating(story)
new_count = story.vote_total
new_value = story.vote_value
new_extra = story.vote_extra
print('{} -> {}'.format(old_value, new_value), end='', flush=True)
if old_count != new_count or old_value != new_value or json.loads(old_extra) != json.loads(new_extra):
print(' (changed)')
changed_stories.append(story)
else:
print('')
print('Saving...', end=' ', flush=True)
for story in changed_stories:
story.bl.search_update(update_fields={'vote_total', 'vote_value'})
orm.commit()
print('Done.', flush=True)
if not story_ids:
story_id = stories[-1].id + 1
def checkstorycomments(story_ids):
orm.sql_debug(False)
if not story_ids:
with orm.db_session:
first_story = orm.select(orm.min(x.id) for x in Story).first()
last_story = orm.select(orm.max(x.id) for x in Story).first()
story_id = first_story
else:
i = 0
while True:
with orm.db_session:
if not story_ids:
story = Story.select(
lambda x: x.id >= story_id and x.id <= last_story).first()
if not story:
break
else:
if i >= len(story_ids):
break
story = Story.get(id=story_ids[i])
i += 1
if not story:
print('Story {} not found'.format(story_ids[i - 1]))
continue
print('Story {}'.format(story.id))
comments_list = story.bl.select_comments().order_by('c.date, c.id')
# Проверка story_published
pub = story.published
for c in comments_list:
if c.story_published != pub:
print(' -{}: pub {} -> {}'.format(c.id, c.story_published,
pub))
c.story_published = pub
c.flush()
# Всё остальное здесь
check_comments_for(story, comments_list)
story_id = story.id + 1
def checkstorylocalcomments(story_ids):
orm.sql_debug(False)
if not story_ids:
with orm.db_session:
first_local = orm.select(orm.min(x.id)
for x in StoryLocalThread).first()
last_local = orm.select(orm.max(x.id)
for x in StoryLocalThread).first()
local_id = first_local
else:
i = 0
while True:
with orm.db_session:
if not story_ids:
local = StoryLocalThread.select(
lambda x: x.id >= local_id and x.id <= last_local).first()
if not local:
break
else:
if i >= len(story_ids):
break
story = Story.get(id=story_ids[i])
i += 1
if not story:
print('Story {} not found'.format(story_ids[i - 1]))
continue
if not story.local:
print('Story {} has no StoryLocalThread'.format(
story_ids[i - 1]))
continue
local = story.local
print('Story {} / StoryLocalThread {}'.format(
local.story.id, local.id))
comments_list = local.bl.select_comments().order_by('c.date, c.id')
# Всё остальное здесь
check_comments_for(local, comments_list)
local_id = local.id + 1
def checkwordscount(story_ids):
orm.sql_debug(False)
if story_ids:
for story_id in story_ids:
with orm.db_session:
story_check_words_count(int(story_id))
return
with orm.db_session:
first_story = orm.select(orm.min(x.id) for x in Story).first()
story_id = first_story
while True:
with orm.db_session:
story = Story.select(lambda x: x.id >= story_id).first()
if not story:
break
story_check_words_count(story)
story_id = story.id + 1
def checkstorycomments(story_ids):
orm.sql_debug(False)
if not story_ids:
with orm.db_session:
first_story = orm.select(orm.min(x.id) for x in Story).first()
last_story = orm.select(orm.max(x.id) for x in Story).first()
story_id = first_story
else:
i = 0
while True:
with orm.db_session:
if not story_ids:
story = Story.select(lambda x: x.id >= story_id and x.id <= last_story).first()
if not story:
break
else:
if i >= len(story_ids):
break
story = Story.get(id=story_ids[i])
i += 1
if not story:
print('Story {} not found'.format(story_ids[i - 1]))
continue
print('Story {}'.format(story.id))
comments_list = story.bl.select_comments().order_by('c.date, c.id')
# Проверка story_published
pub = story.published
for c in comments_list:
if c.story_published != pub:
print(' -{}: pub {} -> {}'.format(c.id, c.story_published, pub))
c.story_published = pub
c.flush()
# Всё остальное здесь
check_comments_for(story, comments_list)
story_id = story.id + 1
def album_list_id3():
ltype = request.values["type"]
size, offset = map(request.values.get, ["size", "offset"])
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = Album.select()
if ltype == "random":
return request.formatter(
"albumList2",
dict(album=[
a.as_subsonic_album(request.user) for a in query.random(size)
]),
)
elif ltype == "newest":
query = query.order_by(lambda a: desc(min(a.tracks.created)))
elif ltype == "frequent":
query = query.order_by(lambda a: desc(avg(a.tracks.play_count)))
elif ltype == "recent":
query = Album.select(
lambda a: max(a.tracks.last_play) is not None).order_by(
lambda a: desc(max(a.tracks.last_play)))
elif ltype == "starred":
query = select(s.starred for s in StarredAlbum
if s.user.id == request.user.id)
elif ltype == "alphabeticalByName":
query = query.order_by(Album.name)
elif ltype == "alphabeticalByArtist":
query = query.order_by(lambda a: a.artist.name + a.name)
else:
raise GenericError("Unknown search type")
return request.formatter(
"albumList2",
dict(album=[
f.as_subsonic_album(request.user)
for f in query.limit(size, offset)
]),
)
def album_list_id3():
ltype = request.values['type']
size, offset = map(request.values.get, ['size', 'offset'])
size = int(size) if size else 10
offset = int(offset) if offset else 0
query = Album.select()
if ltype == 'random':
return request.formatter(
'albumList2',
dict(album=[
a.as_subsonic_album(request.user) for a in query.random(size)
]))
elif ltype == 'newest':
query = query.order_by(lambda a: desc(min(a.tracks.created)))
elif ltype == 'frequent':
query = query.order_by(lambda a: desc(avg(a.tracks.play_count)))
elif ltype == 'recent':
query = Album.select(
lambda a: max(a.tracks.last_play) is not None).order_by(
lambda a: desc(max(a.tracks.last_play)))
elif ltype == 'starred':
query = select(s.starred for s in StarredAlbum
if s.user.id == request.user.id)
elif ltype == 'alphabeticalByName':
query = query.order_by(Album.name)
elif ltype == 'alphabeticalByArtist':
query = query.order_by(lambda a: a.artist.name + a.name)
else:
raise GenericError('Unknown search type')
return request.formatter(
'albumList2',
dict(album=[
f.as_subsonic_album(request.user)
for f in query.limit(size, offset)
]))
def checknewscomments(news):
orm.sql_debug(False)
if not news:
with orm.db_session:
first_newsitem = orm.select(orm.min(x.id)
for x in NewsItem).first()
last_newsitem = orm.select(orm.max(x.id) for x in NewsItem).first()
newsitem_id = first_newsitem
else:
i = 0
while True:
with orm.db_session:
if not news:
newsitem = NewsItem.select(lambda x: x.id >= newsitem_id and x.
id <= last_newsitem).first()
if not newsitem:
break
else:
if i >= len(news):
break
if news[i].isdigit():
newsitem = NewsItem.get(id=int(news[i]))
else:
newsitem = NewsItem.get(name=news[i])
i += 1
if not newsitem:
print('News item {} not found'.format(news[i - 1]))
continue
print('News item {} ({})'.format(newsitem.id, newsitem.name))
comments_list = newsitem.bl.select_comments().order_by(
'c.date, c.id')
check_comments_for(newsitem, comments_list)
newsitem_id = newsitem.id + 1
def checkstorylocalcomments(story_ids):
orm.sql_debug(False)
if not story_ids:
with orm.db_session:
first_local = orm.select(orm.min(x.id) for x in StoryLocalThread).first()
last_local = orm.select(orm.max(x.id) for x in StoryLocalThread).first()
local_id = first_local
else:
i = 0
while True:
with orm.db_session:
if not story_ids:
local = StoryLocalThread.select(lambda x: x.id >= local_id and x.id <= last_local).first()
if not local:
break
else:
if i >= len(story_ids):
break
story = Story.get(id=story_ids[i])
i += 1
if not story:
print('Story {} not found'.format(story_ids[i - 1]))
continue
if not story.local:
print('Story {} has no StoryLocalThread'.format(story_ids[i - 1]))
continue
local = story.local
print('Story {} / StoryLocalThread {}'.format(local.story.id, local.id))
comments_list = local.bl.select_comments().order_by('c.date, c.id')
# Всё остальное здесь
check_comments_for(local, comments_list)
local_id = local.id + 1
def _get_next_wakeup(self):
return orm.min(a.expiry_time for a in world.Aura)
def sort_key(self):
year = min(map(lambda t: t.year if t.year else 9999, self.tracks))
return '%i%s' % (year, self.name.lower())
def checkstoryvoting(story_ids):
orm.sql_debug(False)
if not current_app.story_voting:
print('Story voting is disabled.')
return
if not story_ids:
with orm.db_session:
first_story = orm.select(orm.min(x.id) for x in Story).first()
last_story = orm.select(orm.max(x.id) for x in Story).first()
story_id = first_story
else:
story_ids_queue = story_ids[::-1] # reversed
while True:
with orm.db_session:
if not story_ids:
stories = Story.select(lambda x: x.id >= story_id and x.id <=
last_story).order_by(Story.id)[:50]
if not stories:
break
else:
if not story_ids_queue:
break
stories = list(
Story.select(
lambda x: x.id in story_ids_queue[-50:]).order_by(
Story.id))
story_ids_queue = story_ids_queue[:-50]
if not stories:
continue
changed_stories = []
for story in stories:
print('Story {}:'.format(story.id), end=' ', flush=True)
old_count = story.vote_total # TODO: rename to story.vote_count
old_value = story.vote_value
old_extra = story.vote_extra
current_app.story_voting.update_rating(story)
new_count = story.vote_total
new_value = story.vote_value
new_extra = story.vote_extra
print('{} -> {}'.format(old_value, new_value),
end='',
flush=True)
if old_count != new_count or old_value != new_value or json.loads(
old_extra) != json.loads(new_extra):
print(' (changed)')
changed_stories.append(story)
else:
print('')
print('Saving...', end=' ', flush=True)
for story in changed_stories:
story.bl.search_update(
update_fields={'vote_total', 'vote_value'})
orm.commit()
print('Done.', flush=True)
if not story_ids:
story_id = stories[-1].id + 1
def sort_key(self):
year = min(map(lambda t: t.year if t.year else 9999, self.tracks))
return "%i%s" % (year, self.name.lower())
def sort_key(self):
year = min(t.year if t.year else 9999 for t in self.tracks)
return f"{year}{self.name.lower()}"
