def add_to_db(audio_files):
    for audio_file in audio_files:
        audio_file_id3 = eyed3.load(audio_file)
        
        # If the artist, album or track doesn't exist in the database, create
        # table(s) for them.
        try:
            if not Artist.objects.filter(name=audio_file_id3.tag.artist).exists():
                artist = Artist(name=audio_file_id3.tag.artist)
                artist.save()
        
            if not Album.objects.filter(title=audio_file_id3.tag.album).exists():
                album = Album(title=audio_file_id3.tag.album, \
                              artist=artist)
                album.save()
            
            if not Track.objects.filter(title=audio_file_id3.tag.title).exists():
                track = Track(title=audio_file_id3.tag.title, \
                              album=album, \
                              artist=artist, \
                              fspath=audio_file, \
                              media_url=MEDIA_URL + audio_file.split(MEDIA_ROOT)[1])
                track.save()
                print 'Added to DB: ' + audio_file_id3.tag.title
        except Exception as e:
            print 'Error: ' + e
def add_movie_tastes(user_id, movie_id, taste):

        taste = float(taste)
        user = User.get_by_id(user_id)
        movie = Movie.get_by_id(movie_id)
        for actor in movie.actors:
            artist = Artist.get_by_id(actor.id())
            user.add_taste_artist(artist, ACTOR_WEIGHT * taste)

        for director in movie.directors:
            artist = Artist.get_by_id(director.id())
            user.add_taste_artist(artist, DIRECTOR_WEIGHT * taste)

        for writer in movie.writers:
            artist = Artist.get_by_id(writer.id())
            user.add_taste_artist(artist, WRITER_WEIGHT * taste)

        for genre in movie.genres:
            user.add_taste_genre(genre, GENRE_WEIGHT * taste)

        user.remove_proposal()
        user.put()
        taskqueue.add(url='/api/proposal/' + user.key.id(), method='GET')


        return 'OK'
def search_artist_from_name(artist_name, movie=None, director_name=None):
    """
    Retrieve artist info from IMDB by name of artist.
    :param artist_name: name of the actor to retrieve info
    :type artist_name: string
    :return: Actor's key
    :rtype: ndb.Key
    :raise RetrieverError: if there is an error from MYAPIFILMS
    """

    url = BASE_URL_MYAPIFILMS + 'imdb?name=' + artist_name + '&format=JSON&filmography=0&limit=1&lang=en-us&exactFilter=0&bornDied=0&starSign=0&uniqueName=0&actorActress=0&actorTrivia=0&token=307cccfe-d20b-4b69-b976-d6a024538864'
    json_page = get(url).encode('utf-8')
    json_data = json.loads(json_page)
    if type(json_data) is not list:  # If it is not a list there is a problem
        raise RetrieverError(json_data['code'], json_data['message'])

    try:
        photo = clear_url(json_data[0]['urlPhoto'])
    except Exception:
        logging.info("Photo not found")
        photo = "None"

    artist = Artist(id=json_data[0]['idIMDB'],
                    name=json_data[0]['name'],
                    photo=photo)

    if movie is not None:
        if director_name is not None:
            movie.add_director(artist)
        else:
            movie.add_actor(artist)

    return artist.put()
Exemple #4
0
def fetch(service, artist):
    if service not in services:
        return False

    try:
        metadata = utils.fetch(service, artist)
        db.connect('testing')
        artist_count = Artist.objects(name=artist, service=service).count()
        if not artist_count:
            mongo_artist = Artist(name=artist, service=service).save()
        else:
            mongo_artist = Artist.objects(name=artist, service=service).first()

        for track in metadata[artist]['tracks']:
            track_title = track
            track_album = metadata[artist]['tracks'][track_title]['album']
            track_encoding = metadata[artist]['tracks'][track_title]['encoding']
            track_url = metadata[artist]['tracks'][track_title]['url']
            track_folder = metadata[artist]['tracks'][track_title]['track_folder']
            track_filename = metadata[artist]['tracks'][track_title]['track_filename']

            media_count = Media.objects(artist=mongo_artist, title=track_title).count()
            if not media_count:
                data = open(track_folder + '/' + track_filename, 'rb')
                f = File(name=track_filename, data=data).save()
                media = Media(artist=mongo_artist, title=track_title, data=f).save()

        return True
    except:
        err = sys.exc_info()[0]
        return False
Exemple #5
0
def upload(request):
    context = {"status": "norm"}
    if request.method == "POST":
        rb = xlrd.open_workbook(settings.BASE_DIR + '/Orders/cat.xls', formatting_info=True)
        sheet = rb.sheet_by_index(0)
        base = {}
        for rownum in range(sheet.nrows):
            row = sheet.row_values(rownum)
            row[0] = int(row[0])
            if sheet.cell(rownum, 1).ctype == 3:
                row[1] = xlrd.xldate_as_tuple(row[1], 0)
                tmp = str(row[1][4])
                if tmp == "0":
                    tmp = "00"
                row[1] = str(row[1][3]) + ":" + tmp
            if sheet.cell(rownum, 1).ctype == 2:
                row[1] = int(row[1])

            b1 = Artist(name=row[2])
            try:
                b1.save()
            except:
                b1 = Artist.objects.filter(name=row[2])[0]

            s = Song(number=row[0], tittle=row[1], minus_quality=row[4], back_vocal=row[3], karaoke_system="test",
                     artist=b1)
            s.save()

        return render(request, 'Orders/upload.html', context)

    return render(request, 'Orders/upload.html', context)
def add_record(release):
    from models import Record, Artist, Track
    release_discogs_id = release.id
    try:
        # Check if we already have this album
        existing = Record.objects.get(discogs_id=release_discogs_id)
        return existing
    except Record.DoesNotExist:
        # Process record
        record_title = release.title
        if (len(record_title.split('- '))>1):
            record_title = record_title.split('- ')[1]
        record = Record(discogs_id = release_discogs_id, title = record_title, year = release.year, thumb = release.thumb, notes = release.notes)
        record.save()

        # Process artists
        for release_artist in release.artists:
            artist = Artist(discogs_id=release_artist.id, name=release_artist.name)
            artist.save()
            record.artists.add(artist)

        # Process tracklist
        for release_track in release.tracklist:
            track = Track()
            track.position = release_track.position
            track.title = release_track.title
            track.duration = release_track.duration
            track.save()
            record.tracklist.add(track)

        record.save()
        return record
 def artist_insert(self, request):
     if request.from_datastore:
         my_quote = request
     else:
         my_quote = Artist(fname=request.fname, lname=request.lname, website_url=request.website_url, description=request.description, image=request.image)
         
     my_quote.put()
     return my_quote
def untaste_movie(user_id, movie_id):
            movie = Movie.get_by_id(movie_id)
            user = User.get_by_id(user_id)

            for actor in movie.actors:
                artist = Artist.get_by_id(actor.id())
                taste_artist = TasteArtist.get_by_id(actor.id() + user.key.id())

                if taste_artist is not None:
                    taste_artist.update_taste(-ACTOR_WEIGHT)
                else:
                    user.add_taste_artist(artist, -ACTOR_WEIGHT)

                if taste_artist.taste == 0:
                    user.remove_taste_artist(artist)

            for director in movie.directors:
                artist = Artist.get_by_id(director.id())
                taste_artist = TasteArtist.get_by_id(director.id() + user.key.id())

                if taste_artist is not None:
                    taste_artist.update_taste(-DIRECTOR_WEIGHT)
                else:
                    user.add_taste_artist(artist, -DIRECTOR_WEIGHT)

                if taste_artist.taste == 0:
                    user.remove_taste_artist(artist)

            for writer in movie.writers:
                artist = Artist.get_by_id(writer.id())
                taste_artist = TasteArtist.get_by_id(writer.id() + user.key.id())

                if taste_artist is not None:
                    taste_artist.update_taste(-WRITER_WEIGHT)
                else:
                    user.add_taste_artist(artist, -WRITER_WEIGHT)

                if taste_artist.taste == 0:
                    user.remove_taste_artist(artist)

            for genre in movie.genres:
                taste_genre = TasteGenre.get_by_id(genre + user.key.id())

                if taste_genre is not None:
                    taste_genre.update_taste(-GENRE_WEIGHT)
                else:
                    user.add_taste_genre(genre, -GENRE_WEIGHT)

                if taste_genre.taste == 0:
                    user.remove_taste_genre(genre)

            user.remove_proposal()
            user.put()
            taskqueue.add(url='/api/proposal/' + user.key.id(), method='GET')

            return 'OK'
def retrieve_artists(movie, actors_list, directors_list, writers_list):
    """
    Retrieve all artist in a movie from actors, directors and writers lists.
    :param movie: Movie object in order to add actors, directors and writers
    :type movie: Movie
    :param actors_list: list of actors
    :type actors_list: list of dict
    :param directors_list: list of directors
    :type directors_list: list of dict
    :param writers_list: list of writers
    :type writers_list: list of dict
    """
    for json_data in actors_list:
        actor = Artist(id=json_data['actorId'],
                       name=json_data['actorName'],
                       photo=clear_url(json_data['urlPhoto']))
        actor.put()
        movie.add_actor(actor)

    for json_data in directors_list:
        director = Artist(id=json_data['nameId'],
                          name=json_data['name'])
        director.put()
        movie.add_director(director)

    for json_data in writers_list:
        writer = Artist(id=json_data['nameId'],
                        name=json_data['name'])
        writer.put()
        movie.add_writer(writer)
Exemple #10
0
def add_artists(request, data):
	dajax = Dajax()
	data = simplejson.loads(data)
	count = int(data['count'])

	for i in range(count):
		artistName = ("test_artist_%d") % (uuid.uuid4())
		artist = Artist(name=artistName)
		artist.save()

	successMessage = "Successfully added [%d] artists!" % count
	dajax.assign('#message', 'innerHTML', successMessage)

	return dajax.json()
Exemple #11
0
def test(request):
	access_token = ""
	# token_info = sp_oauth.get_cached_token()

	# if token_info:
	# 	print "Found cached token!"
	# 	access_token = token_info['access_token']
	# else:
	code = request.GET.get('code')
	if code:
		print "Found Spotify auth code in Request URL! Trying to get valid access token..."
		token_info = sp_oauth.get_access_token(code)
		access_token = token_info['access_token']

	if access_token:
		print "Access token available! Trying to get user information..."
		sp = spotipy.Spotify(access_token)
		current_user = sp.current_user()
		artists = sp.current_user_top_artists(limit=50)
		username = current_user['id']
		current_users = SpotifyUser.objects.filter(username=username)
		if current_users:
			print current_users
		else:
			new_user = SpotifyUser(username=username)
			new_user.save()

			i = 1
			for item in artists['items']:
				artist_id = item['id']
				print item['name'] + ": " + artist_id
				matching_artists = Artist.objects.filter(spotify_id=artist_id)
				if matching_artists:
					the_artist = matching_artists[0]
				else:
					the_artist = Artist(spotify_id=artist_id, name=item['name'])
					the_artist.save()
				user_artist = UserArtist(artist=the_artist, user=new_user, rank=i)
				user_artist.save()
				i = i + 1

		results_string = "<ol>"
		for item in artists['items']:
			results_string += "<li><img src='" + item['images'][1]['url'] + "'/>" + item['name'] + "</li>"
		results_string += "</ol>"
		return HttpResponse(results_string)

	else:
		return HttpResponse(htmlForLoginButton())
Exemple #12
0
def fetch_artist():
    '''Fetches live music archive page, scrapes artist info,
    and saves to db'''
    result = urlfetch.fetch(ARTISTS_URL)
    if result.status_code != 200:
        return
    soup = BeautifulSoup(result.content.decode('utf-8')) 
    artists_table = soup.find(id='browse')
    items = artists_table.findAll('a')
    for i in range(len(items)-1)[::2]:
        name = items[i].contents[0]
        identifier = items[i].get('href').split('/')[-1]
        shows = int(items[i+1].string.split(' ')[0].replace(',','').encode('utf-8'))
        artist = Artist(name=name, show_count=shows, identifier=identifier)
        artist.put_async()
Exemple #13
0
def update_artists(artist_ids):

    for artist in artist_ids:
    	payload = {'api_key': ECHONEST, 'id': 'songkick:artist:'+str(artist)+'',
        'format': 'json', 'bucket': ['genre', 'id:spotify-WW', 'familiarity',
        'discovery', 'hotttnesss', 'artist_location', 'years_active']}
    	url = 'http://developer.echonest.com/api/v4/artist/profile?'

    	r = requests.get(url, params=payload)
    	data = r.json()
        # retrieve the artist record from the db
        artist = Artist.get(artist_id=artist)

        try:
            results = data['response']['artist']
        except KeyError, error:
            print '%s: No data for artist %s %s' % (error, artist.name, artist.artist_id)
            continue

        try:
            echonest_response = results
            genres = results['genres']
            spotify_id = results['foreign_ids'][0]['foreign_id']
            familiarity = results['familiarity']
            hotttnesss = results['hotttnesss']
            years_active = results['years_active']
            location = results['artist_location']
            discovery = results['discovery']

        except KeyError, error:
            print 'An error has occured %s' % error
            pass
Exemple #14
0
def get_tastes_artists_list(user, page=0):
    """
    Get a readable taste artists list.
    :param user: user
    :type user: Models.User
    :return: list of tastes
        {"code": 0, "data": {"tastes": [{"idIMDB": id,"name": name, "photo": photo_url}],
        "type": type, "userId": user_id}
    :rtype: JSON
    """
    tastes_artists_id = user.tastes_artists  # Get all taste_artists' keys

    artists = []

    for taste_artist_id in tastes_artists_id:
        taste_artist = TasteArtist.get_by_id(taste_artist_id.id())  # Get taste

        if taste_artist.taste >= 1 and taste_artist.added:
            artist_id = taste_artist.artist.id()  # Get artist id from taste
            artist = Artist.get_by_id(artist_id)  # Get artist by id

            artists.append({"idIMDB": artist_id,
                            "name": artist.name.encode('utf-8') if artist.name is not None else None,
                            "tasted": 1,
                            "photo": artist.photo})

    return jsonify(code=0, data={"userId": user.key.id(), "type": "artist", "tastes": artists})
Exemple #15
0
 def rawGet(self, ballotID, voteID):
     vote = self.getVote(ballotID, voteID)
     if not vote:
         self.response.out.write('No such vote: ' + ballotID + '/' + voteID)
         return
     render = dict(v=vote)
     title = self.request.get('title', default_value=vote.title)
     render['title'] = title
     mbArtistid = self.request.get('artist.mbid', default_value=None)
     artistid = self.request.get('artist.id', default_value=None)
     name = self.request.get('name', default_value=vote.artist)
     artist = None
     if artistid:
         artist = Artist.get_by_id(int(artistid))
     elif mbArtistid:
         artist = Artist.gql('WHERE mbid = :1', mbArtistid).get()
     if artist:
         if artist.mbid:
             mbArtistid = artist.mbid
         name = artist.name
         render['artist'] = artist
         render['releases'] = [r for r in artist.release_set
                               if not vote.release or
                               r.key() != vote.release.key()]
     else:
         if mbArtistid:
             artist = mb.Artist(mbArtistid)
             render['mbArtist'] = artist
         render['artists'] = [a for a in Artist.gql('WHERE name = :1', name)]
         render['releases'] = [r for r in
                               Release.gql('WHERE title = :1', title)
                               if not vote.release or
                               r.key() != vote.release.key()]
     render['name'] = name
     search = dict(title=title)
     if mbArtistid:
         search['artistid'] = mbArtistid
     else:
         search['artist'] = name
     rgs = mb.ReleaseGroup.search(**search)
     if rgs:
         render['rgs'] = rgs
     elif mbArtistid:
         render['rgs'] = mb.ReleaseGroup.search(artistid=mbArtistid)
     else:
         render['mbArtists'] = mb.Artist.search(name=name)
     self.render('canon.html', **render)
Exemple #16
0
def new_song(request):
    if request.method == "POST":
        form = SongForm(request.POST)
        if form.is_valid():
            data = analyze(form.cleaned_data['lyrics'])
            try :
                artist = Artist.objects.all().filter(name=form.cleaned_data['artist-name'])
            except:
                artist = Artist(name=form.cleaned_data['artist_name'])
                artist.save()
            song = Song(name=form.cleaned_data['song_name'], lyrics = form.cleaned_data['lyrics'], artist=artist,
                        number_of_words= data['total_words'], number_unique_words=data['unique_words'],
                        unique_word_percent=data['percentage'], repeated_rhymes=data['repeated_rhymes'],
                        bad_words=data['bad_words'], thug_rating=data['thug_rating'], avg_syllables=data['thug_rating'])
            song.save()
            return redirect("/")
    form = SongForm()
    return render(request, 'lyrics/new_song.html', { 'form': form })
Exemple #17
0
 def post(self):
     if self.request.get("entityKey"):
         artist_key = ndb.Key(urlsafe=self.request.get("entityKey"))
         artist = artist_key.get()       
         artist.fname = self.request.get("fname")
         artist.lname = self.request.get("lname")
         artist.image = self.request.get("image")
         artist.website_url = self.request.get("website_url")
         artist.description = self.request.get("description")
         artist.put()
     else: 
         new_artist = Artist(fname = self.request.get("fname"),
                               lname = self.request.get("lname"),
                               image = self.request.get("image"),
                               website_url = self.request.get("website_url"),
                               description = self.request.get("description"))
         new_artist.put()
     self.redirect(self.request.referer)
Exemple #18
0
def update_events(venue_ids):

    for identifier in venue_ids:
    	payload = {'apikey': SONGKICK, 'per_page': 50, 'page': 1}
    	url = 'http://api.songkick.com/api/3.0/venues/'+str(identifier)+'/calendar.json?'

    	r = requests.get(url, params=payload)
    	r.raise_for_status()
    	data = r.json()

    	venue = Venue.get(venue_id=identifier)
    	#venue.save()

    	try:
    		results = data['resultsPage']['results']['event']
    	except KeyError, error:
    		print 'An error occured: %s: There are no upcoming events for this venue: %s' % (error, venue.name)
    		continue

    	for item in results:
            try:
                event_id = item['id']
                name = item['displayName']
                type = item['type']
                status = item['status']
                datetime = item['start']['datetime']
                url = item['uri']
                popularity = item['popularity']
            except KeyError, error:
                print 'An error occured: %s: There is limited data for event: %s' % (error, event_id)
                pass

            event, _created = Event.get_or_create(event_id=event_id, venue=venue)
            event.name = name
            event.type = type
            event.status = status
            event.datetime = datetime
            event.url = url
            event.popularity = popularity
            print event.name
            event.save()

            for artist in item['performance']:
                try:
                    artist_id = artist['artist']['id']
                    name = artist['artist']['displayName']
                    performer, _created = Artist.get_or_create(artist_id=artist_id, name=name)
                    billing = artist['billing']
                    billing_index = artist['billingIndex']
                    p, _created = Performance.get_or_create(artist=performer, event=event)
                    p.billing = billing
                    p.billing_index = billing_index
                    p.save()

                except KeyError, error:
                    print 'An error occured %s' % error
                    pass
Exemple #19
0
def get_terms():

    genres = []
    artist = Artist.select()
    genre_list = [a.genres for a in artist if a.genres]
    for l in genre_list:
        for i in l:
            genres.append(i['name'])
    term_count = Counter(genres)
    return term_count
Exemple #20
0
Fichier : views.py Projet : 6/GeoDJ
def videos_by_genre(request, genre):
    videos = None
    artists = list(Artist.by_genre(genre))
    random.shuffle(artists)
    for artist in artists:
        videos = artist.youtube_videos()
        if len(videos['results']) > 0:
            videos['country'] = artist.country.name
            break
    return HttpResponse(simplejson.dumps(videos), mimetype='application/json')
Exemple #21
0
def get_or_retrieve_by_id(id_imdb):
    """
    This function check if the id is a valid IMDb id and in this case get or retrieve the correct entity.
    :param id_imdb: a valid IMDb id
    :type id_imdb: string
    :return: A model instance
    :rtype Artist or Movie model
    """

    artist = re.compile('nm\d{7}$')
    movie = re.compile('tt\d{7}$')

    if artist.match(id_imdb):  # It is an artist's id
        artist = Artist.get_by_id(id_imdb)  # Find artist by id
        if artist is None:

            try:
                artist_key = retrieve_artist_from_id(id_imdb)  # Retrieve if is not in the datastore
            except RetrieverError as retriever_error:
                raise InternalServerError(retriever_error)

            artist = Artist.get_by_id(artist_key.id())  # Get artist by id

        return artist
    elif movie.match(id_imdb):  # It is a movie's id
        movie = Movie.get_by_id(id_imdb)  # Find movie by id
        if movie is None:

            try:
                movie_key = retrieve_movie_from_id(id_imdb)  # Retrieve if is not in the datastore
            except RetrieverError as retriever_error:
                raise InternalServerError(retriever_error)

            movie = Movie.get_by_id(movie_key.id())  # Get movie by id

        return movie
    else:
        new_movie = Movie().get_by_id(id_imdb)
        if new_movie != None:
            return new_movie
        else:
            raise InternalServerError(id_imdb + " is not a valid IMDb id or film.TV id")
def retrieve_artist_from_id(artist_id):
    """
    Retrieve artist info from IMDB by id of artist.
    :param artist_id: id of the artist to retrieve info
    :type artist_id: string
    :return: Artist's key
    :rtype: ndb.Key
    :raise RetrieverError: if there is an error from MYAPIFILMS
    """
    logging.info('Retrieving %s', artist_id)

    url = BASE_URL_MYAPIFILMS + 'imdb?idName=' + artist_id + '&format=JSON&filmography=0&lang=en-us&bornDied=0&starSign=0&uniqueName=0&actorActress=0&actorTrivia=0&actorPhotos=N&actorVideos=N&salary=0&spouses=0&tradeMark=0&personalQuotes=0&token=307cccfe-d20b-4b69-b976-d6a024538864'
    json_page = get(url).encode('utf-8')
    json_data = json.loads(json_page)

    artist = Artist(id=json_data["idIMDB"],
                    name=json_data["name"],
                    photo=clear_url(json_data["urlPhoto"]) if ('urlPhoto' in json_data and json_data['urlPhoto'] != "") else None)

    return artist.put()
Exemple #23
0
def fetch(service, artist):
    if service in services:
        artist_count = Artist.objects(name=artist).count()
        if not artist_count:
            a = Artist(name=artist, service=service).save()

        q = Queue(connection=Redis())
        fetch_job = q.enqueue(tap.fetch, service, artist)
        return render_template('fetch.html', user=login.current_user)
    else:
        return "<p>No support for the '{0}' service, or service is not discoverable.</p>".format(service)
def addArtist(id3_artist_name, path):
  musicbrainz_artist = musicbrainz.getBestArtistMatch(id3_artist_name)

  if musicbrainz_artist is None:
    unique_name = id3_artist_name
    artist_mb_id = None
  else:
    unique_name = musicbrainz_artist.getUniqueName()
    artist_mb_id = utils.extractUuid(musicbrainz_artist.id)

  try:
    artist = Artist.get(peewee.Q(musicbrainz_id=artist_mb_id) | peewee.Q(unique_name=unique_name))
  except peewee.DoesNotExist:
    artist = Artist.create(
        name = id3_artist_name,
        unique_name = unique_name,
        location = path,
        state = 'wanted',
        musicbrainz_id = artist_mb_id)

  return artist
Exemple #25
0
 def rawPost(self, ballotID, voteID):
     vote = self.getVote(ballotID, voteID)
     id = self.request.get('release.id', default_value=None)
     mbid = self.request.get('release.mbid', default_value=None)
     if id:
         vote.release = db.Key.from_path(Release.kind(), int(id))
     elif mbid:
         vote.release = Release.get(mbid)
     else:
         id = self.request.get('artist.id', default_value=None)
         mbid = self.request.get('artist.mbid', default_value=None)
         if id:
             artist = db.Key.from_path(Artist.kind(), int(id))
         elif mbid:
             artist = Artist.get(mbid)
         else:
             artist = Artist(name=self.request.get('artist'),
                             sortname=self.request.get('sortname'))
             artisturl = self.request.get('artisturl', default_value=None)
             if artisturl:
                 artist.url = artisturl
             artist.put()
         release = Release(artist=artist, title=self.request.get('title'))
         releaseurl = self.request.get('releaseurl', default_value=None)
         if releaseurl:
             release.url = releaseurl
         release.put()
         vote.release = release
     vote.put()
     next = Vote.gql('WHERE release = :1 ORDER BY artist', None).get()
     if next:
         key = next.key()
         self.redirect('../%d/%d' % (key.parent().id(), key.id()))
     else:
         self.redirect('../..')
Exemple #26
0
def parser_artist(artist_id):
    create_app()
    process = Process.get_or_create(id=artist_id)
    if process.is_success:
        return

    print 'Starting fetch artist: {}'.format(artist_id)
    start = time.time()
    process = Process.get_or_create(id=artist_id)

    tree = get_tree(ARTIST_URL.format(artist_id))

    artist = Artist.objects.filter(id=artist_id)
    if not artist:
        artist_name = tree.xpath('//h2[@id="artist-name"]/text()')[0]
        picture = tree.xpath(
            '//div[contains(@class, "n-artist")]//img/@src')[0]
        artist = Artist(id=artist_id, name=artist_name, picture=picture)
        artist.save()
    else:
        artist = artist[0]
    song_items = tree.xpath('//div[@id="artist-top50"]//ul/li/a/@href')
    songs = []
    for item in song_items:
        song_id = item.split('=')[1]
        song = parser_song(song_id, artist)
        if song is not None:
            songs.append(song)
    artist.songs = songs
    artist.save()
    process.make_succeed()
    print 'Finished fetch artist: {} Cost: {}'.format(
        artist_id, time.time() - start)
Exemple #27
0
def index(request):
    #"""
    print "purging"
    for e in Event.objects.all():
        e.delete()

    for v in Venue.objects.all():
        v.delete()

    for a in Artist.objects.all():
        a.delete()
    print "purged"

    artists_names = ['Usher', 'Cage the Elephant', 'Knife Party', 'Steve Aoki', 'The Weeknd', 'Rihanna']
    # artists_names = ['Rihanna']

    for name in artists_names:
        Artist.find(name)
    #"""

    start = timezone.now() - timedelta(days=7)
    end = timezone.now() + timedelta(days=0)

    for artist in Artist.objects.all():
        events = artist.get_events_by_dates_range(start.date(), end.date())
        for event in events:
            lat = event.venue.latitude
            lng = event.venue.longitude
            recommended_events = artist.get_recommended_events_by_location_and_radius(str(lat) + "," + str(lng), 100)
            if recommended_events:
                print "Recommended event for ", event
                for e in recommended_events:
                    print e

    # TODO: save recommended events in a proper way

    return HttpResponse("Hi, you are in BITdataCollector.")
Exemple #28
0
def update_term():

    term_counts = get_terms()
    artist = Artist.select()
    for a in artist:
        temp_terms = {}
        if a.genres:
            for g in a.genres:
                if g['name'] in term_counts:
                    temp_terms[g['name']] = term_counts[g['name']]
                    #temp_terms.append({g['name']: term_counts[g['name']]})
                    #print g['name'], term_counts[g['name']]
            top_term = max(temp_terms.iterkeys(), key = (lambda k: temp_terms[k]))
            a.term1 = top_term
            a.save()
Exemple #29
0
 def artists(self, request):
     '''API endpoint to query for artists'''
     next_page = request.next_page or 'first_artists_page'
     cache = memcache.get(next_page)
     if cache:
         return ArtistsResponse(artists=cache[0], next_page=cache[1])
     query = Artist.query()
     if next_page is 'first_artists_page':
         artists, cursor, more = query.fetch_page(300) 
     else:
         artists, cursor, more = query.fetch_page(300, 
                 start_cursor=Cursor.from_websafe_string(next_page))
     artists = [artist.to_message() for artist in artists]
     memcache.add(next_page, (artists, cursor.to_websafe_string()))
     return ArtistsResponse(artists=artists, next_page=cursor.to_websafe_string())
Exemple #30
0
def artist_application(request):
    latest_news = NewsItem.objects.all()[0]
    if request.method == 'POST':
        form = ArtistApplication(request.POST)
        if form.is_valid():
            artist = Artist(name = form.cleaned_data['name'],
                            description = form.cleaned_data['description'],
                            phone = form.cleaned_data['phone'],
                            website = form.cleaned_data['website'],
                            soundcloud = form.cleaned_data['soundcloud'],
                            facebook = form.cleaned_data['facebook'],
                            myspace = form.cleaned_data['myspace'],
                            lastfm = form.cleaned_data['lastfm'],
                            twitter = form.cleaned_data['twitter'],
                            youtube = form.cleaned_data['youtube'],
                            resident_advisor = form.cleaned_data['resident_advisor'])
            artist.save()
            return redirect('/artists/application-successful/')
    else:
        form = ArtistApplication()
    return render_to_response('artist_application.html',
                              {'form': form,
                               'latest_news': latest_news},
                               context_instance=RequestContext(request))
Exemple #31
0
def edit_artist(artist_id):
    """Define Edit-Artist Retrieval."""
    form = ArtistForm()
    artist_query = Artist.query.get(artist_id)
    artist_details = Artist.details(artist_query)
    form.name.data = artist_details["name"]
    form.genres.data = artist_details["genres"]
    form.city.data = artist_details["city"]
    form.state.data = artist_details["state"]
    form.phone.data = artist_details["phone"]
    form.website.data = artist_details["website"]
    form.facebook_link.data = artist_details["facebook_link"]
    form.seeking_venue.data = artist_details["seeking_venue"]
    form.seeking_description.data = artist_details["seeking_description"]
    form.image_link.data = artist_details["image_link"]
    return render_template('forms/edit_artist.html',
                           form=form,
                           artist=artist_details)
Exemple #32
0
def edit_artist(artist_id):
    form = ArtistForm()
    data = request.form

    artist_query = Artist.query.get(artist_id)

    if artist_query:
        artist_details = Artist.details(artist_query)
        form.name.data = artist_details["name"]
        form.genres.data = artist_details["genres"]
        form.city.data = artist_details["city"]
        form.state.data = artist_details["state"]
        form.phone.data = artist_details["phone"]
        form.facebook_link.data = artist_details["facebook_link"]
        return render_template('forms/edit_artist.html',
                               form=form,
                               artist=artist_details)
    return render_template('errors/404.html')
Exemple #33
0
def show_artist(artist_id):
    """Establish Individiual Artist Page."""
    artist_query = Artist.query.get(artist_id)
    artist_details = Artist.details(artist_query)
    current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    new_shows_query = Show.query.options(db.joinedload(
        Show.Artist)).filter(Show.artist_id == artist_id).filter(
            Show.start_time > current_time).all()
    new_shows_list = list(map(Show.venue_details, new_shows_query))
    artist_details["upcoming_shows"] = new_shows_list
    artist_details["upcoming_shows_count"] = len(new_shows_list)
    past_shows_query = Show.query.options(db.joinedload(
        Show.Artist)).filter(Show.artist_id == artist_id).filter(
            Show.start_time <= current_time).all()
    past_shows_list = list(map(Show.venue_details, past_shows_query))
    artist_details["past_shows"] = past_shows_list
    artist_details["past_shows_count"] = len(past_shows_list)
    return render_template('pages/show_artist.html', artist=artist_details)
Exemple #34
0
 def test_relationship_1(self):
     newartist = Artist(artist_name='someone', artist_id='00009')
     db.session.add(newartist)
     db.session.commit()
     newartwork = Artwork(title='defgh',
                          artwork_id='00010',
                          painter=newartist)
     db.session.add(newartwork)
     db.session.commit()
     findartwork = db.session.query(Artwork).filter_by(
         artwork_id='00010').first()
     self.assertEqual(findartwork.artist_id, '00009')
     db.session.delete(findartwork)
     db.session.commit()
     findartist = db.session.query(Artist).filter_by(
         artist_id='00009').first()
     db.session.delete(findartist)
     db.session.commit()
Exemple #35
0
def get_artist_by_name(_name:str):
    query = Artist.select().where(Artist.name == _name)
    try:
        _artist = {
            'id':query[0].id,
            'name':query[0].name,
            'genre':query[0].genre,
            'image_link':query[0].image_link,
            'bio':query[0].bio}
        return _artist
    except:
        _artist = {
            'id':0,
            'name':'not found',
            'genre':'not found',
            'image_link':'not found',
            'bio':'not found'}
        return _artist
Exemple #36
0
def create_artist_submission():
    form = ArtistForm()
    if form.validate():
        try:
            name = request.form.get('name')
            city = request.form.get('city')
            state = request.form.get('state')
            phone = request.form.get('phone')
            facebook_link = request.form.get('facebook_link')
            genres = request.form.getlist('genres')
            genres = ','.join(genres)
            image_link = request.form.get('image_link')
            website = request.form.get('website')
            if request.form.get('seeking_venue') is None:
                seeking_venue = False
            else:
                seeking_venue = True
            seeking_description = request.form.get('seeking_description')

            artist = Artist(name=name,
                            city=city,
                            state=state,
                            phone=phone,
                            facebook_link=facebook_link,
                            genres=genres,
                            image_link=image_link,
                            website=website,
                            seeking_venue=seeking_venue,
                            seeking_description=seeking_description)

            db.session.add(artist)
            db.session.commit()

            flash('Artist ' + artist.name + ' was successfully listed!')

        except:
            db.session.rollback()
            flash('An error occurred. Artist ' + artist.name +
                  ' could not be listed.')

        finally:
            return render_template('pages/home.html')
    else:
        return redirect(url_for('create_artist_form'))
Exemple #37
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    # TODO: insert form data as a new Venue record in the db, instead
    # TODO: modify data to be the data object returned from db insertion
    try:
        exists = db.session.query(
            db.exists().where(Artist.name == request.form['name'])).scalar()

        if exists:
            flash('This artist is already exist')
            return render_template('pages/artists.html')
        artist = Artist()
        for field in request.form:
            if field == 'genres':
                setattr(artist, field, request.form.getlist(field))
            elif field == 'seeking_venue':
                setattr(
                    artist, field,
                    True if request.form.get(field) in ('y', True, 't',
                                                        'True') else False)
            else:
                setattr(artist, field, request.form.get(field))
        try:
            db.session.add(artist)
            db.session.commit()
            flash('Artist ' + request.form['name'] +
                  ' was successfully listed!')
        except:
            db.session.rollback()
            flash('An error occurred. Artist ' + artist.name +
                  ' could not be listed.')

            return render_template('errors/500.html'), 500
        finally:
            db.session.close()

    except:
        return render_template('errors/500.html'), 500

    # on successful db insert, flash success
    # flash('Artist ' + request.form['name'] + ' was successfully listed!')
    # TODO: on unsuccessful db insert, flash an error instead.
    # e.g., flash('An error occurred. Artist ' + data.name + ' could not be listed.')
    return render_template('pages/home.html')
Exemple #38
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    # TODO: insert form data as a new Venue record in the db, instead
    # TODO: modify data to be the data object returned from db insertion

    # on successful db insert, flash success
    # flash('Artist ' + request.form['name'] + ' was successfully listed!')
    # TODO: on unsuccessful db insert, flash an error instead.
    # e.g., flash('An error occurred. Artist ' + data.name + ' could not be listed.')
    #return render_template('pages/home.html')
    try:
        seeking_venue = False
        seeking_description = ''
        if 'seeking_venue' in request.form:
            seeking_venue = request.form['seeking_venue'] == 'y'
        if 'seeking_description' in request.form:
            seeking_description = request.form['seeking_description']
        new_artist = Artist(
            name=request.form['name'],
            genres=request.form['genres'],
            city=request.form['city'],
            state=request.form['state'],
            phone=request.form['phone'],
            website=request.form['website'],
            image_link=request.form['image_link'],
            facebook_link=request.form['facebook_link'],
            seeking_venue=seeking_venue,
            seeking_description=seeking_description,
        )
        print("print(artist_detail(new_artist))")
        print(artist_detail(new_artist))
        db.session.add(new_artist)
        db.session.commit()
        # on successful db insert, flash success
        flash('Artist ' + request.form['name'] + ' was successfully listed!')
    except SQLAlchemyError as e:
        print(e)
        # TODO: on unsuccessful db insert, flash an error instead.
        # e.g., flash('An error occurred. Artist ' + data.name + ' could not be listed.')
        flash('An error occurred. Artist ' + request.form['name'] +
              'could not be listed. ')
    finally:
        db.session.close()
    return render_template('pages/home.html')
Exemple #39
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    # TODO: insert form data as a new Venue record in the db, instead
    # TODO: modify data to be the data object returned from db insertion

    form = ArtistForm(request.form)
    if (form.validate()):
        error = False
        try:
            artist = Artist(
                name=request.form['name'],
                city=request.form['city'],
                state=request.form['state'],
                phone=request.form['phone'],
                genres=str(request.form.getlist('genres')),
                facebook_link=request.form['facebook_link'],
                image_link=request.form['image_link'],
                seeking_venue=str_to_bool(request.form['seeking_venue']),
                seeking_description=request.form['seeking_description'],
                website=request.form['website'])

            db.session.add(artist)
            db.session.commit()
        except:
            error = True
            db.session.rollback()
            print(sys.exc_info())
        finally:
            db.session.close()

        if not error:
            # on successful db insert, flash success
            flash('Artist ' + request.form['name'] +
                  ' was successfully listed!')
            # TODO: on unsuccessful db insert, flash an error instead.
            # e.g., flash('An error occurred. Artist ' + data.name + ' could not be listed.')
        else:
            flash('An error occurred. Artist ' + request.form['name'] +
                  ' could not be created.')
        return render_template('pages/home.html')
    else:
        print(form.data)
        flash(form.errors)
        return redirect(url_for('create_artist_form'))
Exemple #40
0
def create_artist_submission():
    error = False
    try:
        name = request.form['name']
        city = request.form['city']
        state = request.form['state']
        phone = request.form['phone']
        genres = request.form['genres']
        facebook_link = request.form['facebook_link']
        image_link = request.form['image_link']
        website_link = request.form['website_link']
        seeking_venue = request.form.get('seeking_venue')
        seeking_description = request.form['seeking_description']

        if seeking_venue == 'y':
            seeking_venue = True
        else:
            seeking_venue = False

        artist = Artist(name=name,
                        city=city,
                        state=state,
                        phone=phone,
                        genres=genres,
                        facebook_link=facebook_link,
                        image_link=image_link,
                        website_link=website_link,
                        seeking_venue=seeking_venue,
                        seeking_description=seeking_description)

        db.session.add(artist)
        db.session.commit()
    except ():
        db.session.rollback()
        error = True
        flash('An error occurred. Artist ' + request.form['name'] +
              ' could not be listed.')
    finally:
        db.session.close()
    if error:
        abort(500)
    else:
        flash('Artist ' + request.form['name'] + ' was successfully listed!')
        return render_template('pages/home.html')
Exemple #41
0
def parse_artist(entry):
    name = entry.getText()
    print(name)
    wiki = entry.find('a').get('href').split('/')[4:]
    page = reddit.subreddit('AnimeThemes').wiki['/'.join(wiki)].content_html
    body = BeautifulSoup(page, 'html.parser')
    mal_url = body.find('h2').find('a').get('href')
    if 'myanimelist' not in mal_url:
        mal_id = None
    else:
        mal_id = body.find('h2').find('a').get('href').split('/')[-1]
        if not mal_id:
            mal_id = body.find('h2').find('a').get('href').split('/')[-2]
        mal_id = int("".join(filter(str.isdigit, mal_id)))
    if name == 'OxT':
        mal_id = 12596
    if name == 'Spira*Spica':
        mal_id = 51708
    return Artist.create(mal_id, name, get_cover(mal_id), parse_themes(body))
Exemple #42
0
def show_artist(artist_id):
    artist_query = Artist.query.get(artist_id)
    if artist_query:
        artist_details = Artist.details(artist_query)
        current_time = datetime.now()
        new_shows_query = Show.query.options(db.joinedload(
            Show.Artist)).filter(Show.artist_id == artist_id).filter(
                Show.start_time > current_time).all()
        new_shows_list = list(map(Show.venue_details, new_shows_query))
        artist_details["upcoming_shows"] = new_shows_list
        artist_details["upcoming_shows_count"] = len(new_shows_list)
        past_shows_query = Show.query.options(db.joinedload(
            Show.Artist)).filter(Show.artist_id == artist_id).filter(
                Show.start_time <= current_time).all()
        past_shows_list = list(map(Show.venue_details, past_shows_query))
        artist_details["past_shows"] = past_shows_list
        artist_details["past_shows_count"] = len(past_shows_list)
        return render_template('pages/show_artist.html', artist=artist_details)
    return render_template('errors/404.html')
Exemple #43
0
def edit_artist(artist_id):
    form = ArtistForm(request.form)
    artist_data = Artist.query.get(artist_id)
    if artist_data:
        artist_details = Artist.details(artist_data)
        form.name.data = artist_details["name"]
        form.genres.data = artist_details["genres"]
        form.city.data = artist_details["city"]
        form.state.data = artist_details["state"]
        form.phone.data = artist_details["phone"]
        form.website.data = artist_details["website"]
        form.facebook_link.data = artist_details["facebook_link"]
        form.seeking_venue.data = artist_details["seeking_venue"]
        form.seeking_description.data = artist_details["seeking_description"]
        form.image_link.data = artist_details["image_link"]
        return render_template('forms/edit_artist.html',
                               form=form,
                               artist=artist_details)
    return render_template('errors/404.html')
Exemple #44
0
def create_artist_submission():
    error = False
    form = ArtistForm(request.form)
    try:
        artist = Artist()
        form.populate_obj(artist)
        db.session.add(artist)
        db.session.commit()
    except:
        error = True
        db.session.rollback()
    finally:
        db.session.close()
    if error:
        flash('An error occured. Artist ' + request.form['name'] +
              ' could not be listed.')
    else:
        flash('Artist ' + request.form['name'] + ' was successfully listed!')
    return redirect(url_for('index'))
Exemple #45
0
def create_artist_submission():
    error = False
    print("CREATE ARTIST")
    try:
        name = request.form['name']
        city = request.form['city']
        state = request.form['state']
        phone = request.form['phone']
        website = request.form['website']
        image_link = request.form['image_link']
        genres = request.form.getlist('genres')
        facebook_link = request.form['facebook_link']
        if 'seeking_venue' in request.form:
            seeking_venue = request.form['seeking_venue'] == 'y'
        else:
            seeking_venue = False
        seeking_description = request.form['seeking_description']

        artist = Artist(name=name,
                        city=city,
                        state=state,
                        phone=phone,
                        website=website,
                        image_link=image_link,
                        genres=genres,
                        facebook_link=facebook_link,
                        seeking_venue=seeking_venue,
                        seeking_description=seeking_description)
        db.session.add(artist)
        db.session.commit()
    except:
        error = True
        db.session.rollback()
        print("FAILURE")
    finally:
        db.session.close()

    if error:
        flash('An error has occured, failed to create artist ' + name, 'error')
    else:
        flash('Artist ' + name + ' was successfully listed!')

    return render_template('pages/home.html')
Exemple #46
0
def create_artist_submission():
    """
    Controller to handle artist creation.
    """
    try:
        request_data = {**request.form}
        request_data['seeking_venue'] = request_data.get(
            'seeking_venue') == 'y'
        artist = Artist()
        db.session.add(artist)
        db.session.commit()
        flash(f'Artist `{request_data.get("name")}` was successfully listed.')
    except Exception as ex:
        db.session.rollback()
        print(ex)
        flash(f'Artist `{request_data.get("name")}` couldn\'t be listed.')
    finally:
        db.session.close()
    return render_template('pages/home.html')
Exemple #47
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    # TODO: insert form data as a new Artist record in the db, instead
    # TODO: modify data to be the data object returned from db insertion
    error = False

    form = ArtistForm()

    if not form.validate():
        flash(form.errors)
        return redirect(url_for('create_artist_submission', form=form))

    try:
        # create new Artist object with recived values
        new_artist_row = Artist(
            name=request.form.get('name'),
            city=request.form.get('city'),
            state=request.form.get('state'),
            phone=request.form.get('phone'),
            genres=request.form.getlist('genres'),
            facebook_link=request.form.get('facebook_link'),
            website=request.form.get('website'),
            image_link=request.form.get('image_link'))
        db.session.add(new_artist_row)
        db.session.commit()
    except:
        db.session.rollback()
        error = True
        print(sys.exc_info())
    finally:
        db.session.close()

    if error:
        # on unsuccessful db insert, flash an error instead.
        flash('An error occurred. Artist ' + request.form.get('name') +
              ' could not be listed.')
    else:
        # on successful db insert, flash success
        flash('Artist ' + request.form.get('name') +
              ' was successfully listed!')

    return redirect(url_for('artists'))
Exemple #48
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    form_data = ArtistForm()

    genres = ",".join(form_data.genres.data)
    new_artist = Artist(
        name=form_data.name.data,
        city=form_data.city.data,
        state=form_data.state.data,
        phone=form_data.phone.data,
        image_link=form_data.image_link.data,
        facebook_link=form_data.facebook_link.data,
        genres=genres,
        website=form_data.website_link.data,
        seeking_venue=form_data.seeking_venue.data,
        seeking_description=form_data.seeking_description.data,
    )

    try:
        db.session.add(new_artist)
        db.session.flush()
        availabilities = [
            ArtistAvailability(artist_id=new_artist.id,
                               time_from=d.get('time_from'),
                               day=d.get('day'),
                               time_to=d.get('time_to'))
            for d in form_data.availabilities.data
            if d.get('day') and d.get('time_from') and d.get('time_to')
        ]

        db.session.add_all(availabilities)
    except Exception as e:
        db.rollback()
        flash("An error occurred. Artist " + form_data.name.data +
              " could not be listed.")
    else:
        db.session.commit()
        flash('Artist ' + new_artist.name + ' was successfully listed!')
    finally:
        db.session.close()

    return render_template('pages/home.html')
Exemple #49
0
def update_artist_orm(artist_id: int, form: FlaskForm, availability: Availability) -> (bool, str):
    """
    Update an artist in ORM mode
    :param artist_id:       id of the artist to update
    :param form:            form to populate from
    :param availability:    artist availability
    """
    commit_change = False

    artist = Artist.query.filter(Artist.id == artist_id).first_or_404()
    artist_name = artist.name

    updated_artist = populate_artist_orm(Artist(), form)
    if not updated_artist.equal(artist, IGNORE_ID):
        # change has occurred update artist
        populate_artist_orm(artist, form)
        artist_name = artist.name
        commit_change = True

    new_availability = populate_availability_orm(Availability(), form)
    new_availability.artist_id = artist_id

    try:
        if is_available(availability) != is_available(new_availability) or \
                not availability.equal(new_availability, IGNORE_ID_DATE):
            # availability has changed, add new setting
            db.session.add(new_availability)
            commit_change = True

        if commit_change:
            db.session.commit()
            success = True
        else:
            success = None
    except:
        db.session.rollback()
        print_exc_info()
        success = False
    finally:
        db.session.close()

    return success, artist_name
Exemple #50
0
def create_artist_submission():
    form = ArtistForm()
    try:
        new_artist = Artist(name=form.name.data,
                            city=form.city.data,
                            state=form.state.data,
                            phone=form.phone.data,
                            image_link=form.image_link.data,
                            seeking_description=form.seeking_description.data,
                            facebook_link=form.facebook_link.data,
                            website=form.website.data,
                            genres=form.genres.data
                            )
        db.session.add(new_artist)
        db.session.commit()
        flash('Artist ' + request.form['name'] + ' was successfully listed.')
    except:
        flash('Something went wrong. Artist ' +
              request.form['name'] + ' could not be listed.')
    return render_template('pages/home.html')
Exemple #51
0
def create_artist_submission():
  try:
    new_artist = Artist(
      name = request.form.get('name'),
      city = request.form.get('city'),
      state = request.form.get('state'),
      phone = request.form.get('phone'),
      facebook_link = request.form.get('facebook_link'),
      genres = request.form.get('genres')
    )
    db.session.add(new_artist)
    db.session.commit()
    flash('Artist ' + request.form['name'] + ' was successfully listed!')
  except:
    flash('An error occurred. Artist ' + request.form['name'] + ' could not be listed.')
    db.session.rollback()
  finally:
    db.session.close()

  return render_template('pages/home.html')
Exemple #52
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    try:
        # on successful db insert, flash success
        formData = request.form.to_dict()
        form = NewArtistForm()
        # used here because formData generes cannot take multiple values
        formData['genres'] = form.genres.data
        formData['seeking_venue'] = bool(formData['seeking_venue'])
        db.session.add(Artist(**formData))
        db.session.commit()
        flash(f"Artist: {formData['name']} was added successfully!")
        return render_template('pages/home.html')
    except Exception as e:
        db.session.close()
        print(e)
        flash(f'Error...Artist: {formData["name"]} cannot get added!')
        return render_template('pages/home.html')
    finally:
        db.session.close()
Exemple #53
0
def show_artist(artist_id):
    # shows the venue page with the given venue_id
    # TODO: replace with real venue data from the venues table, using venue_id
    current_artist = db.session.query(Artist).get(artist_id)
    data = Artist.info(current_artist)
    current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    new_shows = db.session.query(Show).options(db.joinedload(
        Show.Artist)).filter(Show.artist_id == artist_id).filter(
            Show.start_time > current_time).all()
    new_shows_list = list(map(Show.venue_info, new_shows))
    data["upcoming_shows"] = new_shows_list
    data["upcoming_shows_count"] = len(new_shows_list)
    past_shows = db.session.query(Show).options(db.joinedload(
        Show.Artist)).filter(Show.artist_id == artist_id).filter(
            Show.start_time <= current_time).all()
    past_shows_list = list(map(Show.venue_info, past_shows))
    data["past_shows"] = past_shows_list
    data["past_shows_count"] = len(past_shows_list)

    return render_template('pages/show_artist.html', artist=data)
Exemple #54
0
def create_artist_submission():
    try:
        artist = Artist(name=request.form['name'],
                        city=request.form['city'],
                        state=request.form['state'],
                        phone=request.form['phone'],
                        genres=request.form['genres'],
                        facebook_link=request.form['facebook_link'])
        db.session.add(artist)
        db.session.commit()
        # on successful db insert, flash success
        flash('Artist ' + request.form['name'] + ' was successfully listed!')
    except:
        db.session.rollback()
        print(sys.exc_info())
        # On unsuccessful db insert, flash an error instead.
        flash('There was an issue listing your artist.')
    finally:
        db.session.close()
    return render_template('pages/home.html')
Exemple #55
0
def edit_artist(artist_id):
    form = ArtistForm()
    # TODO: populate form with fields from artist with ID <artist_id>
    aq = Artist.query.get(artist_id)
    if aq:
        artist_details = Artist.details(aq)
        form.name.data = artist_details["name"]
        form.genres.data = artist_details["genres"]
        form.city.data = artist_details["city"]
        form.state.data = artist_details["state"]
        form.phone.data = artist_details["phone"]
        form.website.data = artist_details["website"]
        form.facebook_link.data = artist_details["facebook_link"]
        form.seeking_venue.data = artist_details["seeking_venue"]
        form.seeking_description.data = artist_details["seeking_description"]
        form.image_link.data = artist_details["image_link"]
        return render_template('forms/edit_artist.html',
                               form=form,
                               artist=artist_details)
    return render_template('errors/404.html')
Exemple #56
0
def create_artist_submission():
  # called upon submitting the new artist listing form
  # TODO: insert form data as a new Venue record in the db, instead
  # TODO: modify data to be the data object returned from db insertion
  error = False
  artist_info = ArtistForm(request.form, meta={'csrf': False})
  if artist_info.validate():
    try:
      name = artist_info['name'].data
      genres = artist_info['genres'].data
      city = artist_info['city'].data
      state = artist_info['state'].data
      phone = artist_info['phone'].data
      website = artist_info['website'].data
      facebook = artist_info['facebook_link'].data
      if artist_info['seeking_venue'].data == 'True':
        seeking_venue = True
      else:
        seeking_venue = False
      seeking_description = artist_info['seeking_description'].data
      image = artist_info['image_link'].data
      artist = Artist(name=name, genres=genres, city=city, state=state, phone=phone, website=website, facebook_link=facebook, seeking_venue=seeking_venue, seeking_description=seeking_description, image_link=image)
      db.session.add(artist)
      db.session.commit()
    except:
      db.session.rollback()
      error = True
      print(sys.exc_info())
    finally:
      db.session.close()
  else:
    error = True

  if error==False:
    # on successful db insert, flash success
    flash('Artist ' + request.form['name'] + ' was successfully listed!')
  else:
    # TODO: on unsuccessful db insert, flash an error instead.
    # e.g., flash('An error occurred. Artist ' + data.name + ' could not be listed.')
    flash('An error occurred. Artist ' + artist.name + ' could not be listed.')
  return render_template('pages/home.html')
Exemple #57
0
def artist_decoder(art, album):
    assert art != None
    assert (art['type'] == "artist")
    # need to get from simplified to full album objects
    r = requests.get(art['href'])
    full = json.loads(r.text)
    r2 = requests.get(
        "http://api.musicgraph.com/api/v2/artist/search?api_key=7f2f846f462aa5434858477e5957113f&name="
        + full['name'])
    mg = json.loads(r2.text)

    # need to get image url from array of image objects
    # need to get country/decade from another api
    mg_data = mg['data']
    country = None
    decade = None
    image = None

    # Grab genre for album from the aritst in music graph
    try:
        genre = mg_data[0]['main_genre']
    except:
        genre = "Unavailable"
    album.genre = genre

    try:
        country = mg_data[0]['country_of_origin']
    except:
        country = "Unavailable"

    try:
        decade = mg_data[0]['decade']
    except:
        decade = "Unavailable"

    try:
        image = full['images'][0]['url']
    except:
        image = None
    artist = Artist(full['name'], image, country, decade, genre)
    return artist
Exemple #58
0
def create_artist_submission():
    data = request.form
    form = ArtistForm()

    # validate input data
    if not form.validate_on_submit():
        flash('invalid input fields')
        return redirect(url_for('index'))

    error = False
    try:
        artist = Artist(
            name=data['name'],
            city=data['city'],
            state=data['state'],
            phone=data['phone'],
            facebook_link=data['facebook_link'],
            image_link=data['image_link'],
            website=data['website'],
            seeking_venue=True if 'seeking_venue' in data.keys() else False,
            seeking_description=data['seeking_description'])
        # insert multiple genres
        for genre_name in form.genres.data:
            genre = ArtistGenre(name=genre_name)
            artist.genres.append(genre)
        db.session.add(artist)
        db.session.commit()
    except:
        error = True
        db.session.rollback()
        print(sys.exc_info())
    finally:
        db.session.close()
    if error:
        # on unsuccessful db insert, flash an error instead.
        flash('An error occurred. Artist ' + data['name'] +
              ' could not be listed.')
    else:
        # on successful db insert, flash success
        flash('Artist ' + request.form['name'] + ' was successfully listed!')
    return render_template('pages/home.html')
Exemple #59
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    # TODO: insert form data as a new Venue record in the db, instead
    # TODO: modify data to be the data object returned from db insertion

    error = False
    body = {}
    try:
        # print(request.form.getlist('genres'))
        # print(request.form)
        new_artist = Artist(
            name=request.form.get('name'),
            city=request.form.get('city'),
            state=request.form.get('state'),
            phone=request.form.get('phone'),
            image_link=request.form.get('image_link'),
            facebook_link=request.form.get('facebook_link'),
            website=request.form.get('website'),
            genres=request.form.getlist('genres'),
            seeking_venue=request.form.get('seeking_venue'),
            seeking_description=request.form.get('seeking_description'))
        db.session.add(new_artist)
        db.session.commit()

        # on successful db insert, flash success
        flash('Artist ' + request.form.get('name') +
              ' was successfully listed!')
    except ():
        # TODO: on unsuccessful db insert, flash an error instead.
        db.session.rollback()
        error = True
        print(sys.exc_info)
        flash('An error occurred. Artist ' + request.form.get('name') +
              ' could not be listed.')

    finally:
        db.session.close()
    if error:
        abort(500)
    else:
        return render_template('pages/home.html')
Exemple #60
0
def create_artist_submission():
    # called upon submitting the new artist listing form
    # TODO: insert form data as a new Venue record in the db, instead
    # TODO: modify data to be the data object returned from db insertion
    message = ''
    try:
        form = ArtistForm(request.form)

        genres = form.genres.data
        genres = ','.join([str(genre) for genre in genres])
        # convert genres to string
        artist = Artist(
            name=form.name.data,
            city=form.city.data,
            state=form.state.data,
            genres=genres,
            facebook_link=form.facebook_link.data,
            website=form.website.data,
            seeking_venue=bool(form.seeking_venue.data),
            seeking_description=form.seeking_description.data,
            image_link=form.image_link.data
        )

        db.session.add(artist)
        db.session.commit()
        message = 'Artist ' + form.name.data + ' was successfully listed!'
    except:
        db.session.rollback()
        print(sys.exc_info())
        message = 'An error occurred. Artist ' + \
            request.form.get('name') + ' could not be listed.'
    finally:
        db.session.close()

    # on successful db insert, flash success
    flash(message)

    # TODO: on unsuccessful db insert, flash an error instead.
    # e.g., flash('An error occurred. Artist ' +
    # data.name + ' could not be listed.')
    return render_template('pages/home.html')