def GET(self):
rdio, currentUser, user_id = get_rdio_and_current_user()
if rdio and currentUser:
if user_id in config.ADMIN_USERS:
input = get_input()
if 'button' in input.keys():
action = input['button']
db = get_db()
if action == 'doitnow_go_on_killme':
if user_id in config.ADMIN_USERS:
db.delete(USER_TABLE, where="rdio_user_id=%i" % user_id)
raise web.seeother('/')
elif action == 'clear_preferences':
if user_id in config.ADMIN_USERS:
db.update(USER_TABLE, where="rdio_user_id=%i" % user_id, prefs=BSONPostgresSerializer.from_dict({}))
raise web.seeother('/admin')
else:
admin=get_admin_content()
return render.admin(env_message=get_environment_message(), admin=admin)
raise web.seeother('/')
def GET(self):
rdio, current_user, user_id = get_rdio_and_current_user()
if rdio and current_user:
if user_id in config.ADMIN_USERS:
form_input = get_input()
if 'button' in form_input.keys():
action = form_input['button']
db = get_db()
if action == 'doitnow_go_on_killme':
if user_id in config.ADMIN_USERS:
db.delete(USER_TABLE, where="rdio_user_id=%i" % user_id)
raise web.seeother('/')
elif action == 'clear_preferences':
if user_id in config.ADMIN_USERS:
db.update(USER_TABLE, where="rdio_user_id=%i" % user_id, prefs=BSONPostgresSerializer.from_dict({}))
raise web.seeother('/admin')
else:
content=get_admin_content()
db = get_db()
users = db.select(USER_TABLE, what='rdio_user_id, last_use')
users = dict([('s%s' % u['rdio_user_id'], u['last_use']) for u in users])
rdio_users = rdio.call('get', {'keys': ','.join(users.keys()), 'extras': '-*,username,url'})['result']
user_list = [(u['username'], u['url'], users[uid]) for uid, u in rdio_users.items()]
user_list.sort(key=lambda x: x[2], reverse=True)
return render.admin(env_message=get_environment_message(), admin=content, users=user_list)
raise web.seeother('/')
def GET(self):
rdio, currentUser = get_rdio_and_current_user()
if rdio and currentUser:
user_id = int(currentUser['key'][1:])
myPlaylists = rdio.call('getPlaylists')['result']['owned']
db = get_db()
result = list(db.select('discoversong_user', what='address, playlist', where="rdio_user_id=%i" % user_id))
if len(result) == 0:
access_token = web.cookies().get('at')
access_token_secret = web.cookies().get('ats')
db.insert('discoversong_user', rdio_user_id=user_id, address=make_unique_email(currentUser), token=access_token, secret=access_token_secret, playlist='new')
result = list(db.select('discoversong_user', what='address, playlist', where="rdio_user_id=%i" % user_id))[0]
else:
result = result[0]
message = ''
if 'saved' in get_input():
message = ' Saved your selections.'
return render.loggedin(name=currentUser['firstName'],
message=message,
to_address=result['address'],
editform=editform(myPlaylists, result['playlist'])
)
else:
return render.loggedout()
def GET(self):
form_input = get_input()
action = form_input['button']
svc, current_user, user_id = get_rdio_and_current_user()
db = get_db()
where_to_next = '/'
if action == 'new_email':
new_email = make_unique_email()
db.update(USER_TABLE, where="rdio_user_id=%i" % user_id, address=new_email)
where_to_next += 'config?saved=True'
elif action == 'save':
where_to_next += 'config?saved=True'
preferences = get_db_prefs(user_id, db=db)
new_preferences = get_preferences_from_input(form_input)
preferences.update(new_preferences)
db.update(USER_TABLE, where="rdio_user_id=%i" % user_id, prefs=BSONPostgresSerializer.from_dict(preferences))
# circular import
from discoversong.sources import SourceAppsManager
for source_app in SourceAppsManager.ALL:
for capability in source_app.capabilities:
for configurable_thing in capability.config_options():
if isinstance(configurable_thing, ConfigStoredValue):
new_value = configurable_thing.read_from_input(form_input)
if not configurable_thing.store_as_db_field:
preferences = get_db_prefs(user_id, db=db)
preferences[configurable_thing.name] = new_value
db.update(USER_TABLE, where="rdio_user_id=%i" % user_id, prefs=BSONPostgresSerializer.from_dict(preferences))
else:
db.update(USER_TABLE, where="rdio_user_id=%i" % user_id, **{configurable_thing.name: new_value})
raise web.seeother(where_to_next)
def POST(self):
db = get_db()
form_input = get_input()
envelope = json.loads(form_input['envelope'])
to_addresses = envelope['to']
for to_address in to_addresses:
lookup = db.select(USER_TABLE, where="address='%s'" % to_address)
if len(lookup) == 1:
result = lookup[0]
access_token = str(result['token'])
access_token_secret = str(result['secret'])
rdio, current_user, user_id = get_rdio_and_current_user(access_token=access_token, access_token_secret=access_token_secret)
stats.got_email(user_id)
subject = form_input['subject']
body = form_input['text']
try:
title, artist = parse(subject, body)
except Exception as e:
logging.exception(e.message)
return None
search_results = well_formed_search(rdio, user_id, artist, title)
return_results(rdio, user_id, search_results)
return None
def GET(self):
rdio, current_user, user_id = get_rdio_and_current_user()
disco_user, prefs = get_discoversong_user(user_id)
# circular import
from discoversong.sources import SourceAppsManager
return render.config(params=Params(user=disco_user, preferences=prefs, message="", environment_message=get_environment_message()),
capabilities=SourceAppsManager.all_capabilities(),
editform=editform(playlists=rdio.call('getPlaylists')['result']['owned'], prefs=get_db_prefs(user_id)))
def GET(self):
svc, current_user, user_id = get_rdio_and_current_user()
if svc and current_user:
if user_id in config.ADMIN_USERS:
db = get_db()
db_users = db.select(USER_TABLE, what='*')
return render.admin_users(env_message=get_environment_message(), users=db_users)
raise web.seeother('/')
def GET(self):
rdio, currentUser, user_id = get_rdio_and_current_user()
disco_user, message = get_discoversong_user(user_id)
prefs = BSONPostgresSerializer.to_dict(disco_user['prefs'])
# circular import
from discoversong.sources import SourceAppsManager
return render.config(user=disco_user,
prefs=prefs,
capabilities=SourceAppsManager.all_capabilities(),
editform=editform(playlists=rdio.call('getPlaylists')['result']['owned'], prefs=get_db_prefs(user_id)),
env_message=get_environment_message(),
message=message)
def GET(self):
input = get_input()
action = input['button']
rdio, currentUser = get_rdio_and_current_user()
user_id = int(currentUser['key'][1:])
db = get_db()
if action == 'save':
db.update('discoversong_user', where="rdio_user_id=%i" % user_id, playlist=input['playlist'])
raise web.seeother('/?saved=True')
def GET(self):
rdio, current_user, user_id = get_rdio_and_current_user()
disco_user, prefs = get_discoversong_user(user_id)
programs_page = etree.parse("http://www.kpfa.org/programs/music", etree.HTMLParser())
divs = try_get(programs_page, '//div[@class="node"][.//a[starts-with(@href, "/playlists/show/")]]')
shows = []
for div in divs:
title = try_get(div, './/h2/a[@title]/@title')
playlists_link = try_get(div, './/a[starts-with(@href, "/playlists/show/")]/@href')
show_num = int(playlists_link[len("/playlists/show/"):])
shows.append(show(title=title, number=show_num))
return render.list_shows(params=Params(user=disco_user, preferences=prefs, message="", environment_message=get_environment_message()),
shows=shows)
def GET(self):
rdio, currentUser, user_id = get_rdio_and_current_user()
if rdio and currentUser:
if not_allowed(user_id):
raise web.seeother('/logout')
disco_user, message = get_discoversong_user(user_id)
stats.visited(user_id)
# circular import
from discoversong.sources import SourceAppsManager
return render.loggedin(name=currentUser['firstName'],
message=message,
sourceapps=SourceAppsManager.ALL,
env_message=get_environment_message())
else:
return render.loggedout(env_message=get_environment_message())
def GET(self):
svc, current_user, user_id = get_rdio_and_current_user()
if svc and current_user:
if not_allowed(user_id):
raise web.seeother('/logout')
disco_user, prefs = get_discoversong_user(user_id)
stats.visited(user_id)
# circular import
from discoversong.sources import SourceAppsManager
return render.loggedin(params=Params(user=disco_user,
preferences=prefs,
message="",
environment_message=get_environment_message()),
name=current_user['firstName'],
sourceapps=SourceAppsManager.ALL)
else:
return render.loggedout(env_message=get_environment_message())
def GET(self, show_number, episode_number):
episode_url = "http://www.kpfa.org/playlist/id/%i" % int(episode_number)
playlist_page = etree.parse(episode_url, etree.HTMLParser())
show_title = try_get(playlist_page, '//div[@class="field-item"]/a/text()')
episode_title = try_get(playlist_page, '//div[@class="orangeheader"]/text()', xform=get_episode_title)
songs = EpisodeImporter().scrape_songs(episode_number)
rdio, current_user, user_id = get_rdio_and_current_user()
disco_user, prefs = get_discoversong_user(user_id)
return render.import_episode(params=Params(user=disco_user, preferences=prefs, message="", environment_message=get_environment_message()),
search=search,
importing=[],
show_title=show_title,
show_number=show_number,
episode_title=episode_title,
episode_number=episode_number,
show_url="/import/" + show_number,
songs=songs)
def GET(self, show_number):
inputs = web.input()
p_url = inputs.get('p')
rdio, current_user, user_id = get_rdio_and_current_user()
disco_user, prefs = get_discoversong_user(user_id)
show_url = "http://www.kpfa.org/playlists/show/" + show_number
episodes_page = etree.parse(show_url, etree.HTMLParser())
show_title = try_get(episodes_page, '//div[@class="orangeheader"]/text()')
show_title = show_title[:show_title.index(": Playlists")]
episode_links = try_get(episodes_page, '//a[starts-with(@href, "/playlist/id/")]')
episodes = []
for episode_link in episode_links:
title = try_get(episode_link, 'text()', xform=get_episode_title)
url = try_get(episode_link, '@href')
number = int(url[len("/playlist/id/"):])
episodes.append(episode(title=title, number=number))
return render.list_episodes(params=Params(user=disco_user, preferences=prefs, message="", playlist_url=p_url, environment_message=get_environment_message()),
show=show(title=show_title, number=show_number),
episodes=episodes)
def POST(self, show_number, episode_number):
inputs = web.input()
rdio, current_user, user_id = get_rdio_and_current_user()
disco_user, prefs = get_discoversong_user(user_id)
songs = EpisodeImporter().scrape_songs(episode_number)
importing = []
for song in songs:
new_query = inputs.get('query_%s' % song.hash())
if new_query != song.query:
song.query = new_query
for r in search(song):
new_import = inputs.get('import_keys_%i_%s' % (song.hash(), r.key))
if new_import:
if r.key not in importing:
importing.append(r.key)
action = inputs.get('submit')
if action.startswith('Retry'):
return render.import_episode(params=Params(user=disco_user, preferences=prefs, message="", environment_message=get_environment_message()),
search=search,
importing=importing,
show_title=inputs['show_title'],
show_number=show_number,
episode_title=inputs['episode_title'],
episode_number=episode_number,
show_url="/import/" + show_number,
songs=songs)
else:
p = rdio.call('createPlaylist', {'name': inputs['pname'],
'description': 'Imported by discoversong on %s' % datetime.datetime.now().strftime('%x'),
'tracks': ','.join(importing),
'isPublished': False})['result']
return web.seeother("/import/%s?p=%s" % (show_number, p['shortUrl']))
#!/usr/bin/env python
from discoversong.parse import parse_twitter
from discoversong.rdio import get_discoversong_user_by_twitter, get_rdio_and_current_user
from discoversong.twitter import get_mentions
from discoversong.stats import read_to_mention
from discoversong.well_formed_search import well_formed_search, return_results
mentions = get_mentions()
for mention in mentions:
disco_user_row = get_discoversong_user_by_twitter(mention["user"]["screen_name"])
if disco_user_row is None:
continue
try:
title, artist = parse_twitter(mention["text"])
except:
continue
token, secret = str(disco_user_row['token']), str(disco_user_row['secret'])
rdio, current_user, user_id = get_rdio_and_current_user(access_token=token, access_token_secret=secret)
search_results = well_formed_search(rdio, user_id, artist, title)
return_results(rdio, user_id, search_results, from_tweet_id=mention["id"])
read_to_mention(mention["id"])
def search(song): svc, current_user, user_id = get_rdio_and_current_user() return rdio_songs_matching_scrape(svc, song, text_renderer=lambda result: render.compared_song(song, result))
def POST(self):
db = get_db()
input = get_input()
envelope = json.loads(input['envelope'])
to_addresses = envelope['to']
print 'received email to', to_addresses
for to_address in to_addresses:
lookup = db.select('discoversong_user', what='rdio_user_id, playlist, token, secret', where="address='%s'" % to_address)
if len(lookup) == 1:
result = lookup[0]
access_token = str(result['token'])
access_token_secret = str(result['secret'])
rdio, current_user = get_rdio_and_current_user(access_token=access_token, access_token_secret=access_token_secret)
print 'found user', current_user['username']
subject = input['subject']
title, artist = parse(subject)
print 'parsed artist', artist, 'title', title
search_result = rdio.call('search', {'query': ' '.join([title, artist]), 'types': 'Track'})
track_keys = []
name_artist_pairs_found = {}
for possible_hit in search_result['result']['results']:
if possible_hit['canStream']:
name = possible_hit['name']
artist_name = possible_hit['artist']
if name_artist_pairs_found.has_key((name, artist_name)):
continue
name_artist_pairs_found[(name, artist_name)] = True
track_key = possible_hit['key']
track_keys.append(track_key)
print 'found tracks', track_keys
playlist_key = result['playlist']
if playlist_key in ['new', 'alwaysnew']:
p_names = [playlist['name'] for playlist in rdio.call('getPlaylists')['result']['owned']]
new_name = generate_playlist_name(p_names)
print 'creating new playlist', new_name
result = rdio.call('createPlaylist', {'name': new_name,
'description': 'Songs found by discoversong on %s.' % datetime.datetime.now().strftime('%A, %d %b %Y %H:%M'),
'tracks': ', '.join(track_keys)})
new_key = result['result']['key']
if playlist_key == 'new':
print 'setting', new_key, 'as the playlist to use next time'
user_id = int(current_user['key'][1:])
db.update('discoversong_user', where="rdio_user_id=%i" % user_id, playlist=new_key)
# else leave 'alwaysnew' to repeat this behavior every time
else:
rdio.call('addToPlaylist', {'playlist': playlist_key, 'tracks': ', '.join(track_keys)})
return None