def get(self, track_id) :
track = Track.get_by_id(int(track_id))
if(track):
logging.info("Track found on Phonoblaster")
shortname = track.station.shortname
user_agent = self.request.headers["User-Agent"]
facebook_agent = "facebookexternalhit/1.1 (+http://www.facebook.com/externalhit_uatext.php)"
if(user_agent != facebook_agent):
# Redirect to live station
self.redirect("/" + shortname)
else:
# Facebook linter
self.station_proxy = StationApi(shortname)
template_values = {
"track": track,
}
self.render("station/facebook/track.html", template_values)
else:
# 404 error
self.render("station/404.html", None)
def delete_from_likes(self, track):
q = Like.all()
q.filter("listener", self.station.key())
q.filter("track", track.key())
like = q.get()
if like is None:
logging.info("This track has never been liked by this listener")
else:
like.delete()
logging.info("Like deleted from datastore")
self.decrement_likes_counter()
logging.info("Listener Likes counter decremented")
Track.decrement_likes_counter(track.key().id())
logging.info("Track likes counter decremented")
def tracks_query(self, offset):
q = Track.all()
q.filter("station", self.station.key())
q.filter("created <", offset)
q.order("-created")
tracks = q.fetch(10)
return tracks
def add_to_likes(self, track):
# Check if the like hasn't been stored yet
q = Like.all()
q.filter("listener", self.station.key())
q.filter("track", track.key())
existing_like = q.get()
if(existing_like):
logging.info("Track already liked by this listener")
else:
like = Like(
track = track.key(),
listener = self.station.key(),
)
like.put()
logging.info("Like saved into datastore")
self.increment_likes_counter()
logging.info("Listener likes counter incremented")
Track.increment_likes_counter(track.key().id())
logging.info("Track likes counter incremented")
def post(self):
content = json.loads(self.request.get("content"))
response = False;
if(content["track_id"]):
track = Track.get_by_id(int(content["track_id"]))
# Check if the track exists on Phonoblaster
if(track):
profile = self.user_proxy.profile
profile_proxy = StationApi(profile["shortname"])
profile_proxy.add_to_likes(track)
response = True
self.response.out.write(json.dumps({ "response": response }))
def get_extended_like(like, track, station):
extended_track = Track.get_extended_track(track)
extended_like = {
"created": timegm(like.created.utctimetuple()),
"type": extended_track["type"],
"id": extended_track["id"],
"title": extended_track["title"],
"duration": extended_track["duration"],
"thumbnail": extended_track["thumbnail"],
"preview": extended_track["preview"],
"track_id": extended_track["track_id"],
"track_created": extended_track["track_created"],
"track_submitter_key_name": station.key().name(),
"track_submitter_name": station.name,
"track_submitter_url": "/" + station.shortname,
}
return extended_like
def delete(self, id):
track = Track.get_by_id(int(id))
response = False
if(track):
# Queriying datastore for associated Like
query = Like.all()
query.filter("track", track)
query.filter("listener", self.user_proxy.user.profile)
like = query.get()
if like:
logging.info("Like associated to track_id %s and listener %s retrieved from datastore."%(id, self.user_proxy.profile["name"]))
like.delete()
response = True
logging.info("Like is now deleted from datstore")
else:
logging.info("Like associated to track_id %s and listener %s does not exist in datastore."%(id, self.user_proxy.profile["name"]))
self.response.out.write(json.dumps({ "response": response }))
def delete(self, id):
track = Track.get_by_id(int(id))
shortname = track.station.shortname
logging.info("Getting from datastore track with track_id = "+id+" for station : @"+shortname)
response = True
if(track):
# Station Proxy
station_proxy = StationApi(shortname)
# Deleting associated broadcasts and favorites
broadcasts_in_buffer = db.get(station_proxy.station.broadcasts)
# If track associated to broadcast in buffer, track will not be deleted.
# If not, a task queue will start to delete broadcast, favorites and the actual track
for b in broadcasts_in_buffer:
if b.track.key().id() == int(id):
logging.info("Track is being broadcast, will not proceed to deletion.")
response = False
break
if response:
logging.info("Starting taskqueue to delete broadcasts and likes associated to track.")
task = Task(
method = 'DELETE',
url = "/taskqueue/deletetrack",
params = {
"track_id": id,
"type": "broadcast",
},
)
task.add(queue_name="worker-queue")
else:
response = False
self.response.out.write(json.dumps({ "response": response }))
def get_tracks(self, offset): tracks = self.tracks_query(offset) extended_tracks = Track.get_extended_tracks(tracks) return extended_tracks
def add_track_to_buffer(self,incoming_track):
buffer = self.reorder_buffer(self.buffer)
new_broadcasts = buffer['broadcasts'][::] # Copy array and resting broadcasts
timestamp = buffer['timestamp']
room = self.room_in_buffer()
# Edge Case, if adding track to position 1 5 seconds before the live track ends, we reject the operation.
# This is due to the latency of Pubnub.
if(len(new_broadcasts) == 1):
# We need to check if the live track ends in the next 5 seconds
live_broadcast = new_broadcasts[0]
live_broadcast_duration = live_broadcast['duration']
start = timegm(datetime.utcnow().utctimetuple()) - timegm(timestamp.utctimetuple())
time_before_end = live_broadcast_duration-start
if(time_before_end< 5):
# Rejecting action
logging.info("Rejecting operation because of an edge case (adding)")
return None
# End of edge case
extended_broadcast = None
if(room > 0):
logging.info("Room in buffer")
track = Track.get_or_insert(incoming_track, self.station)
if track:
logging.info("Track found")
submitter_key = None
if(incoming_track["track_submitter_key_name"] != self.station.key().name()):
submitter_key_name = incoming_track["track_submitter_key_name"]
submitter_key = db.Key.from_path("Station", submitter_key_name)
if(track.youtube_id):
new_broadcast = Broadcast(
key_name = incoming_track["key_name"],
track = track.key(),
youtube_id = track.youtube_id,
youtube_title = track.youtube_title,
youtube_duration = track.youtube_duration,
station = self.station.key(),
submitter = submitter_key,
)
else:
new_broadcast = Broadcast(
key_name = incoming_track["key_name"],
track = track.key(),
soundcloud_id = track.soundcloud_id,
soundcloud_title = track.soundcloud_title,
soundcloud_duration = track.soundcloud_duration,
soundcloud_thumbnail = track.soundcloud_thumbnail,
station = self.station.key(),
submitter = submitter_key,
)
new_broadcast.put()
logging.info("New broadcast put in datastore")
extended_broadcast = Broadcast.get_extended_broadcasts([new_broadcast], self.station)[0]
# Injecting traks in buffer
new_broadcasts.append(extended_broadcast)
new_buffer = {
'broadcasts': new_broadcasts,
'timestamp': timestamp
}
# Save data
self.put_buffer(new_buffer)
else:
logging.info("Track not found")
else:
logging.info("There is no more room in the buffer.")
return extended_broadcast
def delete(self):
cursor = self.request.get("cursor")
track_id = self.request.get("track_id")
typeModel = self.request.get("type")
if(track_id):
track = Track.get_by_id(int(track_id))
logging.info("Getting from datastore track with track_id = " + track_id)
if(track):
logging.info("Track found")
if(typeModel == "broadcast"):
# Deleting broadcasts associated to track
query = Broadcast.all()
query.filter("track", track)
if(cursor):
logging.info("Cursor found")
query.with_cursor(start_cursor = cursor)
broadcasts = query.fetch(100)
logging.info("Fetched : %d Broadcast(s) from datastore."%(len(broadcasts)))
if(len(broadcasts)>0):
db.delete(broadcasts)
logging.info("Deleted : %d Broadcast(s) from datastore."%(len(broadcasts)))
task = Task(
method = 'DELETE',
url = "/taskqueue/deletetrack",
params = {
"cursor": cursor,
"track_id": track_id,
"type": typeModel,
}
)
task.add(queue_name="worker-queue")
else:
task = Task(
method = 'DELETE',
url = "/taskqueue/deletetrack",
params = {
"track_id": track_id,
"type": "like",
}
)
task.add(queue_name="worker-queue")
elif (typeModel == "like"):
# Deleting likes associated to track
query = Like.all()
query.filter("track", track)
if(cursor):
logging.info("Cursor found")
query.with_cursor(start_cursor = cursor)
like = query.get()
if like is None:
logging.info("No like for this track, deleting track.")
track.delete()
else:
try:
listener_proxy = StationApi(like.listener.shortname)
listener_proxy.decrement_likes_counter()
logging.info("Listener Like counter decremented")
except:
logging.info("User has not created a station (likes used to be linked to user to stations)")
Track.decrement_likes_counter(track.key().id())
logging.info("Track likes counter decremented")
like.delete()
logging.info("Like deleted from datastore")
cursor = query.cursor()
task = Task(
method = 'DELETE',
url = "/taskqueue/deletetrack",
params = {
"cursor": cursor,
"track_id": track_id,
"type": typeModel,
}
)
task.add(queue_name="worker-queue")
response = True
else:
response = False
self.response.out.write(json.dumps({ "response": response }))
