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 }))