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)