class EntryResourceTest(ResourceTestCaseMixin, TestCase):
def setUp(self):
super(EntryResourceTest, self).setUp()
self.album1 = Album(title='test_title_1', order_num=1)
self.album1.save()
self.album2 = Album(title='test_title_2', order_num=1)
self.album2.save()
self.foto1 = Foto(album=self.album1,
title='foto1',
image='test_image_1.jpg')
self.foto2 = Foto(album=self.album1,
title='foto2',
image='test_image_2.jpg')
self.video1 = Video(album=self.album2,
title='video1',
video_link='test_video_link2')
self.video2 = Video(album=self.album2,
title='video2',
video_link='test_video_link2')
def test_get_albums(self):
resp = self.api_client.get('/api/v1/album/', format='json')
self.assertValidJSONResponse(resp)
self.assertEqual(len(self.deserialize(resp)['objects']), 2)
self.assertEqual(
self.deserialize(resp)['objects'][0], {
u'id': self.album1.pk,
u'title': u'{0}'.format(self.album1.title),
u'image': None,
u'order_num': self.album1.order_num,
u'resource_uri': u'/api/v1/album/{0}/'.format(self.album1.pk)
})
def test_get_foto_from_album_1(self):
resp = self.api_client.get('/api/v1/foto/?album_id__id=' +
str(self.album1.id),
format='json')
self.assertValidJSONResponse(resp)
self.assertEqual(len(self.deserialize(resp)), 2)
#self.assertEqual(self.deserialize(resp)['objects'][0], {
# u'id': self.album1.pk,
# u'title': u'{0}'.format(self.album1.title),
# u'image': None,
# u'order_num': self.album1.order_num,
# u'resource_uri': u'/api/v1/album/{0}/'.format(self.album1.pk)
#})
def test_get_VIDEO_from_album_1(self):
resp = self.api_client.get('/api/v1/video/?album_id__id=' +
str(self.album1.id),
format='json')
self.assertValidJSONResponse(resp)
self.assertEqual(len(self.deserialize(resp)), 2)
def test_get_many(server, artist, arguments, names):
with server.app_context():
db.session.add(Album('ab-1AB-12-12345', 'a', artist))
db.session.add(Album('ab-1AB-12-12346', 'b', artist))
db.session.add(Album('ab-1AB-12-12347', 'c', artist))
db.session.commit()
r = requests.get(server.url + "/albums?{}".format(urlencode(arguments)))
assert r.status_code == 200
items = r.json()
assert len(items) == len(names)
assert list(map(lambda x: x["name"], items)) == names
def _cache_albums_async(app, refresh_thumbnails=False, refresh_dates=False):
with app.app_context():
album_manager = GPhotosAlbum(service)
current_ids = list()
for a in album_manager.list():
album = Album.query.filter_by(gphotos_id=a.get("id")).first()
if not album:
album = Album()
album.gphotos_id = a.get("id")
if not album.end_date or refresh_dates:
start_date, end_date = _get_album_date_range(album.gphotos_id)
album.start_date = start_date
album.end_date = end_date
current_ids.append(a.get("id"))
album.title = a.get("title")
album.url_title = normalize_for_url(a.get("title"))
album.items_count = a.get("mediaItemsCount")
db.session.add(album)
thumbnail = os.path.join(app.config["ALBUM_THUMB_PATH"],
a.get("id") + ".jpg")
if not os.path.exists(thumbnail) or refresh_thumbnails:
urllib.request.urlretrieve(
a.get("coverPhotoBaseUrl") + "=w300-h200-c",
os.path.join(app.config["ALBUM_THUMB_PATH"],
a.get("id") + ".jpg"),
)
db.session.commit()
# delete from db albums no longer in google photos
stmt = delete(Album).where(
Album.gphotos_id.notin_(current_ids)).execution_options(
synchronize_session="fetch")
db.session.execute(stmt)
db.session.commit()
def test_show_up_lyric_by_artist(self):
a1 = Artist('ARTIST 1', self.user.get_id())
db.session.add(a1)
db.session.commit()
al1 = Album('album 1', datetime.now(), self.user.get_id(), a1.get_id())
db.session.add(al1)
db.session.commit()
l1 = Lyric('song 1', 'test 1', self.user.get_id(), al1.get_id())
db.session.add(l1)
db.session.commit()
response = self.client.get('/lyrics/artist1/1')
self.assertIn(b'Flask Lyric - song 1', response.data)
self.assertIn(b'ARTIST 1 LYRICS', response.data)
self.assertIn(b'test 1', response.data)
def add_tl_to_fav(id):
"""
Add an album from tolisten to favorites
"""
toadd = ToListen.query.get(id)
form = AlbumForm(request.form)
# the suggested rank should be the next available rank
# e.g. if there are 200 albums currently in the favorites list,
# the suggested rank should be 201
rank = db.session.query(func.max(Album.rank).label("rank")).scalar() + 1
if request.method == 'POST' and form.validate_on_submit():
album = Album()
album.rank = form.rank.data
album.title = form.title.data
album.artist = form.artist.data
album.year = form.year.data
album.last_played = datetime.strptime(form.last_played.data,
'%Y-%m-%d')
album.user_id = current_user.id
# make sure the added album's ranking is no lower than what makes sense
# e.g. if there are currently 200 albums in favorites,
# the lowest that makes sense is 201
if int(album.rank) > rank:
album.rank = rank
elif int(album.rank) < rank:
# get every album lower *numerically higher) in current ranking
# than the ranking we are trying to add to
# and increment ranking by 1
# e.g. there are 200 albums and we assign a ranking of 195 to new album
# album currently ranked 195 will become 196,
# album currently ranked 196 will becomes 197...
# ...album current ranked 200 will become 201
to_move = (Album.query.filter_by(user_id=current_user.id).filter(
Album.rank >= int(form.rank.data)).filter(
Album.rank < rank).order_by(Album.rank.desc()).all())
for a in to_move:
a.rank += 1
db.session.commit()
db.session.add(album)
title, artist = toadd.title, toadd.artist
ToListen.query.filter(ToListen.id == id).delete()
db.session.commit()
flash(f'Successfully added album {album.title} by {album.artist}')
flash(f'Deleted {title} by {artist} from albums to listen')
return redirect(url_for('favorites'))
# addt'l variables
curr_dt = datetime.now().strftime('%Y-%m-%d')
curr_dt = datetime.now().strftime('%Y-%m-%d')
return render_template('addalbum.html',
form=form,
last_played=curr_dt,
rank=rank,
toadd=toadd)
def albums(artist_id=None):
form = CreateAlbumForm()
# did we get an artist id?
if artist_id is not None:
# Get the artist
artist = (db.session.query(Artist).filter(
Artist.artist_id == artist_id).one_or_none())
form.artist.data = artist.name
# otherwise, no artist
else:
artist = None
# Is the form valid?
if form.validate_on_submit():
# Create new Album
album = Album(title=form.title.data)
artist.albums.append(album)
db.session.add(artist)
db.session.commit()
return redirect(url_for("albums_bp.albums", artist_id=artist_id))
# Start the query for albums
query = db.session.query(Album)
# Display the albums for the artist passed?
if artist_id is not None:
query = query.filter(Album.artist_id == artist_id)
albums = query.order_by(Album.title).all()
return render_template("albums.html",
artist=artist,
albums=albums,
form=form)
def put(self, album_id):
album = Album.select().where(Album.id == album_id).first()
if album:
status_code = 200
args = self.parser.parse_args()
classification = args.get('classification', [])
cl_json_list = []
""" Return album data without update if error classification data"""
if type(classification) == type([]) and len(classification) != 0:
cl_obj_list = Classification.select().where(
Classification.id << classification)
for item in cl_obj_list:
if item in album.classification:
continue
album.classification.add(item)
album.save()
for item in album.classification:
cl_json_list.append(model_to_dict(item))
album = model_to_dict(album)
album['classification'] = cl_json_list
resp = {'error_code': 0, 'data': album}
else:
status_code = 400
self.resource_fields['message'] = fields.String(
attribute='message')
resp = {'error_code': 40021, 'message': 'Album dose not exist.'}
return make_response(json.dumps(marshal(resp, self.resource_fields)),
status_code)
def admin_album():
if request.method == 'POST':
album_name = request.form.get('album_name')
album_state = request.form.get('album_state') or '1'
album_desc = request.form.get('album_desc')
if not album_name:
return make_response(jsonify({"code": 1, "message": "请填写相册名称！"}))
try:
db.session.add(Album(album_name=album_name, album_desc=album_desc))
db.session.commit()
except Exception:
db.rollback()
return make_response(
jsonify({
"code": 1,
"message": "新增失败，请联系管理员！"
}))
finally:
db.session.close()
return make_response(jsonify({"code": 0, "message": "新建成功！"}))
albums = db.session.query(
Album.album_id, Album.album_name,
Album.album_slt).filter(Album.album_status == '1').all()
return render_template('album/index.html', albums=albums)
def post(self):
album_id = request.values.get("album_id")
# not exit--new album
if not album_id:
al = Album.from_request(request)
db.session.add(al)
# get album id
db.session.flush()
else: # exist: update old one
al = Album.query.filter_by(id=album_id).first()
if not al or al.user_id != g.user.id:
return jsonify({'code': -1})
al.update_from_request(request)
db.session.add(al)
wl = json.loads(request.values.get("work_list")) #插入作品
list_dw = [(Designwork(work_url=i,
up_time=datetime.now(),
category=al.category,
album_id=al.id)) for i in wl]
al.designworks = list_dw
# db.session.bulk_save_objects(list_dw) # 这句需要去掉,否则重复添加(cascade:save-upadte)
# for i in wl:
# dw = Designwork(work_url=i,up_time=datetime.now(),album_id=al.id,user_id=al.user_id,category=al.category)
# db.session.add(dw)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
return jsonify({'code': -1})
return jsonify({'code': 0})
def _make_db_album(sp_album):
db_album = Album(id=sp_album['id'],
name=sp_album['name'],
total_tracks=sp_album['total_tracks'])
db.session.add(db_album)
_add_item_artists(db_album, sp_album['artists'])
_add_item_tracks(db_album, sp_album['tracks'])
return db_album
def test_show_up_artists_list_lyrics(self):
a1 = Artist('ARTIST 1', self.user.get_id())
db.session.add(a1)
db.session.commit()
al1 = Album('album 1', datetime.now(), self.user.get_id(), a1.get_id())
al2 = Album('album 2', datetime.now(), self.user.get_id(), a1.get_id())
db.session.add_all([al1, al2])
db.session.commit()
l1 = Lyric('song to test 1', '', self.user.get_id(), al1.get_id())
l2 = Lyric('song to test 2', '', self.user.get_id(), al2.get_id())
db.session.add_all([l1, l2])
db.session.commit()
response = self.client.get('/artist/artist1')
self.assertIn(b'Flask Lyrics - artist 1', response.data)
self.assertIn(b'album 1', response.data)
self.assertIn(b'album 2', response.data)
self.assertIn(b'song to test 1', response.data)
self.assertIn(b'song to test 2', response.data)
def populate_database(session):
artist = Artist()
artist.name = "Test Artist"
artist.spotify_uri = "spotify:artist:arn"
session.add(artist)
album = Album()
album.name = "Test Album"
album.artists.append(artist)
album.spotify_uri = "spotify:album:arn"
session.add(album)
media = Media()
media.tmdb_id = "TMDB_ID"
media.name = "Test media"
media.type = 1
session.add(media)
session.commit()
def on_created(self,event):
with self.app.app_context():
path = os.path.relpath(event.src_path,self.path)
if event.is_directory:
album = Album(path=path, title=os.path.basename(event.src_path))
album.parent = Album.query.filter_by(path=os.path.dirname(path)).first()
self.db.session.add(album)
else:
try:
im = Image.open(os.path.join(self.path,path))
photo = Photo(path=path)
parent = Album.query.filter_by(path=os.path.dirname(path)).first()
if parent:
parent.photos.append(photo)
self.db.session.add(photo)
self.db.session.add(parent)
except IOError:
pass
self.db.session.commit()
def add_favorite():
"""
Add an album to favorites
"""
form = AlbumForm(request.form)
rankrow = (Album.query.filter_by(user_id=current_user.id).order_by(
Album.rank.desc()).limit(1).all())
rank = rankrow[0].rank + 1
if request.method == 'POST' and form.validate_on_submit():
album = Album()
album.rank = form.rank.data
album.title = form.title.data
album.artist = form.artist.data
album.year = form.year.data
album.last_played = datetime.strptime(form.last_played.data,
'%Y-%m-%d')
album.user_id = current_user.id
# make sure the added album's ranking is no lower than what makes sense
# e.g. if there are currently 200 albums in favorites,
# the lowest that makes sense is 201
if int(album.rank) > rank:
album.rank = rank
elif int(album.rank) < rank:
# get every album lower *numerically higher) in current ranking
# than the ranking we are trying to add to
# and increment ranking by 1
# e.g. there are 200 albums and we assign a ranking of 195 to new album
# album currently ranked 195 will become 196,
# album currently ranked 196 will becomes 197...
# ...album current ranked 200 will become 201
to_move = (Album.query.filter_by(user_id=current_user.id).filter(
Album.rank >= int(form.rank.data)).filter(
Album.rank < rank).order_by(Album.rank.desc()).all())
for a in to_move:
a.rank += 1
db.session.commit()
db.session.add(album)
db.session.commit()
flash(f'Successfully added album {album.title} by {album.artist}')
return redirect(url_for('favorites'))
# addt'l variables
curr_dt = datetime.now().strftime('%Y-%m-%d')
return render_template('addalbum.html',
form=form,
last_played=curr_dt,
rank=rank,
toadd=None)
def test_get_one(server, artist):
with server.app_context():
album = Album('ab-1AB-12-12345', 'a', artist)
db.session.add(album)
db.session.commit()
assert Album.query.count() == 1
r = requests.get(server.url + "/album/{}".format(artist.id))
assert r.status_code == 200
assert r.json()['name'] == artist.name
def setUp(self):
super(EntryResourceTest, self).setUp()
self.album1 = Album(title='test_title_1', order_num=1)
self.album1.save()
self.album2 = Album(title='test_title_2', order_num=1)
self.album2.save()
self.foto1 = Foto(album=self.album1,
title='foto1',
image='test_image_1.jpg')
self.foto2 = Foto(album=self.album1,
title='foto2',
image='test_image_2.jpg')
self.video1 = Video(album=self.album2,
title='video1',
video_link='test_video_link2')
self.video2 = Video(album=self.album2,
title='video2',
video_link='test_video_link2')
def search_results(request):#searching album by tittle
if 'album' in request.GET and request.GET["album"]:
search_term = request.GET.get("album")#brings the album
searched_albums = Album.search_by_title(search_term)#brings the tittle in the brought album
message = f"{search_term}"
return render(request, 'search.html',{"message":message,"albums": searched_albums})
else:#define what happens if the album is not found
message = "You haven't searched for any term"
return render(request, 'search.html',{"message":message})
def post(self):
self.resource_fields['data'] = fields.Nested(self.album_fields)
args = self.parser.parse_args()
name = args.get('name', '')
artist = args.get('artist', '')
is_hot = args.get('is_hot', 0)
classification = args.get('classification', [])
cl_obj_list = Classification.select().where(
Classification.id << classification)
album = Album(name=name, artist=artist, is_hot=is_hot)
album.save()
cl_json_list = []
if cl_obj_list.exists():
for item in cl_obj_list:
album.classification.add(item)
cl_json_list.append(model_to_dict(item))
album.save()
album = model_to_dict(album)
album['classification'] = cl_json_list
resp = {'error_code': 0, 'data': album}
return make_response(json.dumps(marshal(resp, self.resource_fields)),
200)
def get(self):
self.parser.remove_argument('name')
self.parser.remove_argument('artist')
self.parser.remove_argument('is_hot')
self.parser.remove_argument('classification')
self.resource_fields['data'] = fields.List(
fields.Nested(self.album_fields))
args = self.parser.parse_args()
offset = args.get('offset')
limit = args.get('limit')
cl_id = args.get('classification_id')
album_list = (Album.select().join(AlbumClassificationThrough).join(
Classification).where(Classification.id == cl_id).paginate(
offset, limit)) if cl_id else (Album.select().paginate(
offset, limit))
data = [
model_to_dict(album, backrefs=True, manytomany=True)
for album in album_list
]
resp = {'error_code': 0, 'data': data}
return make_response(json.dumps(marshal(resp, self.resource_fields)),
200)
def test_delete(server, artist):
with server.app_context():
album = Album('ab-1AB-12-12345', 'a', artist)
db.session.add(album)
db.session.commit()
assert Album.query.count() == 1
r = requests.delete(server.url + "/album/{}".format(artist.id))
assert r.status_code == 204
with server.app_context():
assert Album.query.count() == 0
def setSongAlbum(song, album_name):
app.logger.info('setSongAlbum')
if not album_name:
raise Exception('Song has no album name given')
# update tag
app.logger.info('Updating album {} for song {}'.format(album_name, song))
if song.path_name.lower().endswith('mp3'):
tags = ID3(song.abs_path)
tags["TALB"] = TALB(encoding=3, text=u'{}'.format(album_name))
tags.save(song.abs_path)
elif song.path_name.lower().endswith('m4a'):
tags = MP4(song.abs_path)
raise Exception('Do song info for mp4')
# get track info
try:
trck = tags['TRCK'].text[0]
except KeyError:
trck = ''
if '/' in trck:
track_number, total_tracks = trck.split('/')
else:
track_number = trck
total_tracks = None
try:
total_tracks = int(total_tracks)
except (ValueError, TypeError):
total_tracks = None
disc_number = int(
tags['TPOS'].text[0].split('/')[0]) if 'TPOS' in tags else 1
total_discs = int(tags['TPOS'].text[0].split(
'/')[1]) if 'TPOS' in tags and '/' in tags['TPOS'].text[0] else 1
year = int(tags['TDRC'].text[0].year) if 'TDRC' in tags else None
# update model
album = Album.query.filter_by(name=album_name, artist=song.artist).first()
if not album:
album = Album(album_name, song.artist)
album.disc_number = disc_number
album.total_discs = total_discs
album.total_tracks = total_tracks
album.year = year
db.session.add(album)
db.session.commit()
app.logger.info('Created new album {} <= {}'.format(album, album_name))
song.album_id = album.id
album.count_songs = len(album.songs)
db.session.commit()
app.logger.info('Update song in db')
def create_album():
form = AlbumForm()
if form.validate_on_submit():
new_album = Album(name_album=form.name.data,
publish_date=form.publish_date.data,
songs=form.songs.data)
db.session.add(new_album)
db.session.commit()
flash('New author created successfully.')
return redirect(url_for('main.album_detail', album_id=new_album.id))
# if form was not valid, or was not submitted yet
return render_template('create_album.html', form=form)
def on_moved(self,event):
with self.app.app_context():
src_path = os.path.relpath(event.src_path,self.path)
dest_path = os.path.relpath(event.dest_path,self.path)
if event.is_directory:
album = Album.query.filter_by(path=src_path).first()
if album:
album.path = dest_path
else:
album = Album(path=dest_path)
album.parent = Album.query.filter_by(path=os.path.dirname(dest_path)).first()
self.db.session.add(album)
else:
photo = Photo.query.filter_by(path=src_path).first()
parent = Album.query.filter_by(path=os.path.dirname(dest_path)).first()
if photo:
if parent:
photo.path = dest_path
parent.photos.append(photo)
self.db.session.add(photo)
self.db.session.add(parent)
else:
self.db.session.delete(photo)
self.db.session.commit()
def get(self, album_id):
resp = {}
album = Album.select().where(Album.id == album_id).first()
if album:
cl_obj_list = album.classification
cl_json_list = []
if cl_obj_list.exists():
for item in cl_obj_list:
cl_json_list.append(model_to_dict(item))
album = model_to_dict(album)
album['classification'] = cl_json_list
resp = {'error_code': 0, 'data': album}
return make_response(json.dumps(marshal(resp, self.resource_fields)),
200)
def test_put_errors(server, artist, data, field):
with server.app_context():
db.session.add(artist)
album = Album('ab-1AB-12-12345', 'a', artist)
db.session.add(album)
db.session.commit()
album_id = album.id
with server.app_context():
assert Album.query.count() == 1
r = requests.put(server.url + "/album/{}".format(album_id), data=data)
assert r.status_code == 422
assert field in r.json()['message']
assert Album.query.count() == 1
def new_album(parent_id=None):
'''
New album
'''
form = NewAlbumForm()
if parent_id:
parent = Album.query.get_or_404(parent_id)
else:
parent = None
if form.validate_on_submit():
album = Album(title=form.title.data, description=form.description.data, author=current_user, parent=parent)
db.session.add(album)
db.session.commit()
flash(gettext('New album \'%(album)s\' added', album=album.title))
return redirect(url_for('.index'))
return render_template('new_album.html', form=form)
def api_albums_index():
if request.method == 'POST':
artist_name = request.form['album[artist_name]']
name = request.form['album[name]']
order = 0
new_album = Album(artist_name=artist_name, name=name, order=order)
db.session.add(new_album)
db.session.commit()
albums = Album.query.all()
album_dicts = []
for album in albums:
dict = album.__dict__
dict['category'] = ['Modern', 'Classical'][album.category - 1]
del dict['_sa_instance_state']
album_dicts.append(dict)
result = {}
result['albums'] = to_camel_case(album_dicts)
return result
def setSongAlbum(song, album_name):
app.logger.info('setSongAlbum')
if not album_name:
raise Exception('Song has no album name given')
# update tag
app.logger.info('Updating album {} for song {}'.format(album_name, song))
if song.path_name.lower().endswith('mp3'):
tags = ID3(song.abs_path)
tags["TALB"] = TALB(encoding=3, text=u'{}'.format(album_name))
tags.save(song.abs_path)
elif song.path_name.lower().endswith('m4a'):
tags = MP4(song.abs_path)
raise Exception('Do song info for mp4')
# get track info
try:
trck = tags['TRCK'].text[0]
except KeyError:
trck = ''
if '/' in trck:
track_number, total_tracks = trck.split('/')
else:
track_number = trck
total_tracks = None
try:
total_tracks = int(total_tracks)
except (ValueError, TypeError):
total_tracks = None
disc_number = int(tags['TPOS'].text[0].split('/')[0]) if 'TPOS' in tags else 1
total_discs = int(tags['TPOS'].text[0].split('/')[1]) if 'TPOS' in tags and '/' in tags['TPOS'].text[0] else 1
year = int(tags['TDRC'].text[0].year) if 'TDRC' in tags else None
# update model
album = Album.query.filter_by(name=album_name, artist=song.artist).first()
if not album:
album = Album(album_name, song.artist)
album.disc_number = disc_number
album.total_discs = total_discs
album.total_tracks = total_tracks
album.year = year
db.session.add(album)
db.session.commit()
app.logger.info('Created new album {} <= {}'.format(album, album_name))
song.album_id = album.id
album.count_songs = len(album.songs)
db.session.commit()
app.logger.info('Update song in db')
def test_put_same_isrc(server, artist):
with server.app_context():
db.session.add(artist)
album = Album('ab-1AB-12-12345', 'a', artist)
db.session.add(album)
db.session.commit()
album_id = album.id
assert Album.query.count() == 1
data = {"isrc": 'ab-1AB-12-12345'}
r = requests.put(server.url + "/album/{}".format(album_id), data=data)
assert r.status_code == 200
assert r.json()['isrc'] == data['isrc']
with server.app_context():
assert Album.query.count() == 1
album = Album.query.get(album_id)
assert album.isrc == data['isrc']
def album(artist_id):
form = AlbumForm()
album = Album.query.filter_by(artist_id=artist_id).all()
artist = Artist.query.filter_by(id=artist_id).first()
song = db.session.query(Album, Song).join(
Song, Album.id == Song.album_id).filter(Album.artist_id == artist_id)
youtube = Album.query.filter_by(artist_id=artist_id).first()
if form.validate_on_submit():
newalbum = Album(albumname=form.albumname.data,
albumlogo=form.albumlogo.data,
albumlink=form.albumlink.data,
artist_id=artist_id)
db.session.add(newalbum)
db.session.commit()
return redirect(url_for('music'))
return render_template('artist.html',
title='Artist',
album=album,
artist=artist,
youtube=youtube,
form=form,
song=song)
def create_new_track(path):
# Get ID3 metadata on mp3 file
full_path = os.path.join(SD_FOLDER, path)
id3_tags = get_tags(full_path)
title = id3_tags.get("title") # Retrieve title from ID3
artist_name = id3_tags.get("artist") # Retrieve artist from ID3
album_name = id3_tags.get("album") # Retrieve album from ID3
id3_genre = id3_tags.get("genre") # Retrieve genre from ID3
id3_release_date = id3_tags.get("date") # Retrieve release date from ID3
id3_cover = id3_tags.get("cover") # Retrieve cover art image data from ID3
# Construct track object
track = Track.get_or_create(path=path)
track.title = title
# Set Artist and Album objects
if artist_name is not None:
artist = Artist.get_or_create(name=artist_name)
track.artist = artist
if album_name is not None:
album = Album.get_or_create(name=album_name, artist_name=artist_name)
track.album = album
# Populate other ID3 columns
track.genre = id3_genre
track.release_date = id3_release_date
# If ID3 contained cover art, create image file
if id3_cover is not None:
image_path = path.replace("/", " > ") + ".jpg"
image_full_path = os.path.join(IMAGE_FOLDER, image_path)
with open(image_full_path, 'wb') as f:
f.write(id3_cover.data)
track.image_path = image_path
return track
def test_put(server, artist):
with server.app_context():
db.session.add(artist)
artist2 = Artist("b")
db.session.add(artist2)
db.session.commit()
album = Album('ab-1AB-12-12345', 'a', artist)
db.session.add(album)
db.session.commit()
artist_id2 = artist2.id
album_id = album.id
assert Album.query.count() == 1
data = {
"isrc": 'ab-1AB-12-12346',
"artist_id": artist_id2,
"name": "b",
"label": "label2",
"year": 2011,
}
r = requests.put(server.url + "/album/{}".format(album_id), data=data)
assert r.status_code == 200
response_data = r.json()
assert response_data['isrc'] == data['isrc']
assert response_data['artist']['id'] == data['artist_id']
assert response_data['name'] == data['name']
assert response_data['label'] == data['label']
assert response_data['year'] == data['year']
with server.app_context():
assert Album.query.count() == 1
album = Album.query.first()
assert album.isrc == data['isrc']
assert album.artist_id == data['artist_id']
assert album.name == data['name']
assert album.label == data['label']
assert album.year == data['year']
def test_post_errors_on_unique_isrc(server, artist):
with server.app_context():
db.session.add(artist)
db.session.commit()
artist_id = artist.id
with server.app_context():
album = Album('ab-1AB-12-12345', 'a', artist)
db.session.add(album)
db.session.commit()
assert Album.query.count() == 1
r = requests.post(server.url + "/albums", data={
"isrc": 'ab-1AB-12-12345',
"name": "b",
"artist_id": artist_id,
})
assert r.status_code == 422
assert 'isrc' in r.json()['message']
assert Artist.query.count() == 1
def post(self):
data = parser.parse_args()
required = ["name", "url", "year", "artist"]
if any(val is None for key, val in data.items() if key in required):
api.abort(400,
"Value of a required key is missing",
required=required)
#return {"error": "name, url, year and artist are required"}, 400
data = clean_data(data)
try:
album = Album(**data)
db.session.add(album)
db.session.commit()
except:
api.abort(409, "Album already exists")
#return {"error": f"Album {data['name']} already exists"}, 409
return api.marshal(album,
serializer,
skip_none=True,
mask="id,name,artist,year,url,genre"), 201
def albumsAdd():
form = AlbumForm()
# 提交
print(form.validate_on_submit())
print(form.errors)
if form.validate_on_submit():
data = form.data
print(data)
# 图片处理
images = request.values.get('images', '')
imagesdata = images.split(';')
imagesnew = ''
print(images)
print(imagesdata)
album = Album(title=data["title"],
picture=data["picture"].replace('/temp/', '/images/'),
like_num=int(data["like_num"]),
sort=int(data["sort"]),
pictures=[])
# if images:
for index in range(len(imagesdata)):
print(index)
print(imagesdata[index])
if imagesdata[index]:
move_file(imagesdata[index])
imagesnew = imagesdata[index].replace('/temp/', '/images/')
album.pictures.append(Picture(path=imagesnew, sort=int(index)))
db.session.add(album)
db.session.commit()
flash("success！", "ok")
return redirect(url_for('admin.albums'))
return render_template('admin/album/create.html', form=form)
def parseId3Tags():
app.logger.info('Parsing ID3 tags...')
songs = Song.query.filter(Song.id3_parsed.is_(False)).limit(50).all()
app.logger.info('{} songs found to parse...'.format(len(songs)))
# app.logger.info(EasyID3.valid_keys.keys())
# app.logger.info(EasyMP4Tags.List)
for song in songs:
# get tag info
info = {}
if song.path_name.lower().endswith('mp3'):
meta = MP3(song.abs_path)
# app.logger.debug(meta.tags)
try:
info['song_title'] = meta.tags['TIT2'].text[0]
except KeyError:
info['song_title'] = song.path_name
try:
trck = meta.tags['TRCK'].text[0]
if '/' in trck:
info['track_number'], info['total_tracks'] = trck.split('/')
else:
info['track_number'] = trck
info['total_tracks'] = None
except KeyError:
info['track_number'] = 1
info['total_tracks'] = 1
try:
info['track_number'] = int(info['track_number'])
except (ValueError, TypeError):
info['track_number'] = None
try:
info['total_tracks'] = int(info['total_tracks'])
except (ValueError, TypeError):
info['total_tracks'] = None
try:
info['artist_name'] = meta.tags['TPE1'].text[0]
except KeyError:
info['artist_name'] = 'unknown artist'
try:
info['album_name'] = meta.tags['TALB'].text[0]
except KeyError:
info['album_name'] = 'unknown album'
info['disc_number'] = int(meta.tags['TPOS'].text[0].split('/')[0]) if 'TPOS' in meta else 1
info['total_discs'] = int(meta.tags['TPOS'].text[0].split('/')[1]) if 'TPOS' in meta and '/' in meta.tags['TPOS'].text[0] else 1
info['year'] = int(meta.tags['TDRC'].text[0].year) if 'TDRC' in meta else None
elif song.path_name.lower().endswith('m4a'):
meta = MP4(song.abs_path)
info['song_title'] = meta[u'\xa9nam'][0]
info['track_number'] = int(meta[u'trkn'][0][0])
info['total_tracks'] = int(meta[u'trkn'][0][1])
info['artist_name'] = meta[u'\xa9ART'][0]
info['album_name'] = meta[u'\xa9alb'][0]
info['disc_number'] = int(meta[u'disk'][0][0]) if u'disk' in meta else 1
info['total_discs'] = int(meta[u'disk'][0][1]) if u'disk' in meta else 1
info['year'] = int(meta[u'\xa9day'][0]) if u'\xa9day' in meta else None
else:
raise Exception('Unknown extension {}'.format(song.path_name))
app.logger.debug(info)
# artist info
artist = Artist.query.filter_by(name_id=info['artist_name'].lower().strip()).first()
if not artist:
artist = Artist(info['artist_name'])
db.session.add(artist)
db.session.commit()
app.logger.info('{} <= {}'.format(artist, info['artist_name']))
song.artist_id = artist.id
# album info
album = Album.query.filter_by(name_id=info['album_name'].lower().strip(), artist=artist).first()
if not album:
album = Album(info['album_name'], artist)
album.disc_number = info['disc_number']
album.total_discs = info['total_discs']
album.total_tracks = info['total_tracks']
album.year = info['year']
db.session.add(album)
db.session.commit()
app.logger.info('{} <= {}'.format(album, info['album_name']))
song.album_id = album.id
# song info
song.name = info['song_title']
song.track_number = info['track_number']
song.id3_parsed = True
db.session.commit()
app.logger.info('Parsed {} ID3 tags...'.format(len(songs)))
return len(songs)
