def create_search_program_item(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param list[str]|dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) title = result_set["Title"] # Not used: uuid = result_set["Uuid"] abstract_key = result_set["AbstractKey"] url = "http://www.rtl.nl/system/s4m/vfd/version=1/d=pc/output=json/fun=getseasons/ak={}".format( abstract_key) item = MediaItem(title, url) time_stamp = result_set["LastBroadcastDate"] # =1546268400000 date_time = DateHelper.get_date_from_posix(int(time_stamp) / 1000) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) return item
def create_episode_item_json(self, result_set): """ Creates a new MediaItem for an episode. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. :param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'folder'. :rtype: MediaItem|None """ time_stamp = result_set["created"] if time_stamp <= 1420070400: # older items don't have videos for now return None url = "https://at5news.vinsontv.com/api/news?source=web&externalid={}".format( result_set["externalId"]) item = MediaItem(result_set["title"], url) item.complete = True item.description = result_set.get("text") date_time = DateHelper.get_date_from_posix(time_stamp) item.set_date(date_time.year, date_time.month, date_time.day) # noinspection PyTypeChecker image_data = result_set.get("media", []) for image in image_data: item.thumb = image.get("imageHigh", image["image"]) return item
def create_live_channel(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) item = MediaItem(result_set[0], result_set[1]) item.type = "video" item.isGeoLocked = result_set[3].lower() == "true" date_time = DateHelper.get_date_from_posix(int(result_set[2]) * 1 / 1000) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) thumb = result_set[4] if not thumb.startswith("http"): thumb = "%s%s" % (self.baseUrl, thumb) item.thumb = thumb return item
def create_video_item(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param dict[str,dict|None] result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) title = result_set["title"] if "subTitle" in result_set: title = "%s - %s" % (title, result_set["subTitle"]) mgid = result_set["id"].split(":")[-1] url = "http://feeds.mtvnservices.com/od/feed/intl-mrss-player-feed" \ "?mgid=mgid:arc:episode:mtvplay.com:%s" \ "&ep=%s" \ "&episodeType=segmented" \ "&imageEp=android.playplex.mtv.%s" \ "&arcEp=android.playplex.mtv.%s" \ % (mgid, self.__backgroundServiceEp, self.__region.lower(), self.__region.lower()) item = MediaItem(title, url) item.type = "video" item.description = result_set.get("description", None) item.isGeoLocked = True images = result_set.get("images", []) if images: # mgid:file:gsp:scenic:/international/mtv.nl/playplex/dutch-ridiculousness/Dutch_Ridiculousness_Landscape.png # http://playplex.mtvnimages.com/uri/mgid:file:gsp:scenic:/international/mtv.nl/playplex/dutch-ridiculousness/Dutch_Ridiculousness_Landscape.png for image in images: if image["width"] > 500: pass # no fanart here else: item.thumb = "http://playplex.mtvnimages.com/uri/%(url)s" % image date = result_set.get("originalAirDate", None) if not date: date = result_set.get("originalPublishDate", None) if date: time_stamp = date["timestamp"] date_time = DateHelper.get_date_from_posix(time_stamp) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) return item
def create_video_item(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param dict[str,str|dict] result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) is_serie_title = result_set["seriesTitle"] if not is_serie_title: return None if result_set["mediaType"] == "game": return None elif result_set["mediaType"] == "episode": title = "%(title)s (Episode)" % result_set else: title = result_set["title"] video_id = result_set["id"] url = "http://media.mtvnservices.com/pmt/e1/access/index.html?uri=mgid:%s:%s&configtype=edge" \ % (self.__mgid, video_id, ) item = MediaItem(title, url) item.description = result_set.get("description", None) item.type = "video" item.icon = self.icon item.fanart = self.fanart item.HttpHeaders = self.httpHeaders item.complete = False if "datePosted" in result_set: date = DateHelper.get_date_from_posix( float(result_set["datePosted"]["unixOffset"]) / 1000) item.set_date(date.year, date.month, date.day, date.hour, date.minute, date.second) if "images" in result_set: images = result_set.get("images", {}) thumbs = images.get("thumbnail", {}) item.thumb = thumbs.get("r16-9", self.noImage) return item
def create_api_episode_type(self, result_set): """ Creates a new MediaItem for an episode. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. :param dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'folder'. :rtype: MediaItem|None """ # This URL gives the URL that contains the show info with Season ID's url = "https://graph.kijk.nl/graphql-video" if not result_set.get("sources"): return None title = result_set["title"] season_number = result_set.get("seasonNumber") episode_number = result_set.get("tvSeasonEpisodeNumber") title_format = self.parentItem.metaData.get("title_format", "s{0:02d}e{1:02d} - {2}") if title is None: serie_title = result_set["series"]["title"] title = title_format.format(season_number, episode_number, serie_title) elif season_number is not None and episode_number is not None: title = title_format.format(season_number, episode_number, title) item = MediaItem(title, url, type="video") item.description = result_set.get("longDescription", result_set.get("description")) item.set_info_label("duration", int(result_set.get("duration", 0) or 0)) item.set_info_label("genre", result_set.get("displayGenre")) self.__get_artwork(item, result_set.get("imageMedia"), mode="thumb") updated = result_set["lastPubDate"] / 1000 date_time = DateHelper.get_date_from_posix(updated) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) # Find the media streams item.metaData["sources"] = result_set["sources"] item.metaData["subtitles"] = result_set.get("tracks", []) # DRM only no_drm_items = [src for src in result_set["sources"] if not src["drm"]] item.isDrmProtected = len(no_drm_items) == 0 return item
def create_api_movie_type(self, result_set): """ Creates a new MediaItem for an program. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. :param dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'folder'. :rtype: MediaItem|None """ title = result_set["title"] if title is None: return None url = self.__get_api_persisted_url( "programs", "b6f65688f7e1fbe22aae20816d24ca5dcea8c86c8e72d80b462a345b5b70fa41", variables={ "programTypes": "MOVIE", "guid": result_set["guid"] }) item = MediaItem(result_set["title"], url) item.description = result_set.get("description") item.type = "video" item.set_info_label("duration", int(result_set.get("duration", 0) or 0)) item.set_info_label("genre", result_set.get("displayGenre")) self.__get_artwork(item, result_set.get("imageMedia")) time_stamp = result_set["epgDate"] / 1000 date_stamp = DateHelper.get_date_from_posix(time_stamp, tz=self.__timezone_utc) date_stamp = date_stamp.astimezone(self.__timezone) if date_stamp > datetime.datetime.now(tz=self.__timezone): available = LanguageHelper.get_localized_string( LanguageHelper.AvailableFrom) item.name = "{} - [COLOR=gold]{} {:%Y-%m-%d}[/COLOR]".format( title, available, date_stamp) item.set_date(date_stamp.year, date_stamp.month, date_stamp.day) # In the main list we should set the fanart too if self.parentItem is None: item.fanart = item.thumb sources = result_set.get("sources") item.metaData["sources"] = sources subs = result_set.get("tracks") item.metaData["subtitles"] = subs return item
def create_video_item_json(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) # get the title title = result_set["title"] mgid = result_set["id"] url = "http://media.mtvnservices.com/pmt/e1/access/index.html" \ "?uri=mgid:arc:video:{}:{}&configtype=edge".format(self.__country_id, mgid) item = MediaItem(title, url) item.type = "video" item.description = result_set["description"] if "images" in result_set: item.thumb = result_set["images"]["url"] air_date = int(result_set["publishDate"]) date_stamp = DateHelper.get_date_from_posix(air_date, self.__timezone_utc) item.set_date(date_stamp.year, date_stamp.month, date_stamp.day) episode = result_set.get("episode") season = result_set.get("season") if season and episode: item.set_season_info(season, episode) duration = result_set.get("duration", "0:00") duration = duration.split(":") duration = int(duration[1]) + 60 * int(duration[0]) item.set_info_label("duration", duration) # store season info item.metaData["season_id"] = result_set.get("seasonId") item.isGeoLocked = True return item
def create_video_item(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param dict[str,str|dict] result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) title = result_set["title"] if title is None: Logger.warning("Found item with all <null> items. Skipping") return None if "subtitle" in result_set and result_set['subtitle'].lower( ) not in title.lower(): title = "%(title)s - %(subtitle)s" % result_set url = "http://m.schooltv.nl/api/v1/afleveringen/%(mid)s.json" % result_set item = MediaItem(title, url) item.description = result_set.get("description", "") age_groups = result_set.get('ageGroups', ['Onbekend']) item.description = "%s\n\nLeeftijden: %s" % (item.description, ", ".join(age_groups)) item.thumb = result_set.get("image", "") item.icon = self.icon item.type = 'video' item.fanart = self.fanart item.complete = False item.set_info_label("duration", result_set['duration']) if "publicationDate" in result_set: broadcast_date = DateHelper.get_date_from_posix( int(result_set['publicationDate'])) item.set_date(broadcast_date.year, broadcast_date.month, broadcast_date.day, broadcast_date.hour, broadcast_date.minute, broadcast_date.second) return item
def create_video_item_json(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) image_data = result_set.get("media", []) thumb = None url = None for image in image_data: thumb = image.get("imageHigh", image["image"]) url = image.get("url") item = MediaItem(result_set["title"], url) item.type = "video" item.icon = self.icon item.thumb = thumb or self.noImage item.complete = True item.description = result_set.get("text") part = item.create_new_empty_media_part() M3u8.update_part_with_m3u8_streams(part, url, proxy=self.proxy, channel=self) # Let's not do the time now time_stamp = result_set["created"] date_time = DateHelper.get_date_from_posix(time_stamp) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) return item
def create_episode_item_json(self, result_set): """ Creates a new MediaItem for an episode. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. :param list[str]|dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'folder'. :rtype: MediaItem|None """ Logger.trace(result_set) time_stamp = result_set["created"] if time_stamp <= 1420070400: # older items don't have videos for now return None url = "{}/api/article/{}".format(self.baseUrl, result_set["externalId"]) item = MediaItem(result_set["title"], url) item.description = HtmlHelper.to_text(result_set.get("text")) date_time = DateHelper.get_date_from_posix(time_stamp) item.set_date(date_time.year, date_time.month, date_time.day) # noinspection PyTypeChecker image_data = result_set.get("media", []) video_url = None for image in image_data: item.thumb = image.get("imageHigh", image.get("image")) video_url = image.get("url") # In some cases the main list only has videos if result_set.get("video", False): if video_url is None: return None item.type = "video" item.url = video_url return item
def create_clip_item_json(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) # get the title title = result_set["title"] mgid = result_set["id"] url = "https://media-utils.mtvnservices.com/services/MediaGenerator/" \ "mgid:arc:video:{}:{}" \ "?arcStage=live&format=json&acceptMethods=hls&clang=nl" \ "&https=true".format(self.__country_id, mgid) item = MediaItem(title, url) item.type = "video" if "images" in result_set: item.thumb = result_set["images"]["url"] if "airDate" not in result_set: return item air_date = int(result_set["airDate"]) date_stamp = DateHelper.get_date_from_posix(air_date, self.__timezone_utc) item.set_date(date_stamp.year, date_stamp.month, date_stamp.day) return item
def create_video_item(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ if self.__no_clips: return None item = chn_class.Channel.create_video_item(self, result_set) # All of vier.be video's seem GEO locked. item.isGeoLocked = True # Set the correct url # videoId = resultSet["videoid"] # item.url = "https://api.viervijfzes.be/content/%s" % (videoId, ) time_stamp = result_set.get("timestamp") if time_stamp: date_time = DateHelper.get_date_from_posix( int(result_set["timestamp"])) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) if not item.thumb and "thumburl2" in result_set and result_set[ "thumburl2"]: item.thumb = result_set["thumburl2"] if item.thumb and item.thumb != self.noImage: item.thumb = HtmlEntityHelper.strip_amp(item.thumb) return item
def __set_date(self, result_set, item): if "usageRights" in result_set and "availableFrom" in result_set["usageRights"] \ and result_set["usageRights"]["availableFrom"] is not None: Logger.trace("Using 'usageRights.availableFrom' for date") # availableFrom=/Date(1540612800000+0200)/ epoch_stamp = result_set["usageRights"]["availableFrom"][6:16] available_from = DateHelper.get_date_from_posix(int(epoch_stamp)) item.set_date(available_from.year, available_from.month, available_from.day) elif "episodeNumberOrDate" in result_set and result_set["episodeNumberOrDate"] is not None: Logger.trace("Using 'episodeNumberOrDate' for date") date_parts = result_set["episodeNumberOrDate"].split(".") if len(date_parts) == 3: item.set_date(date_parts[2], date_parts[1], date_parts[0]) elif "programUrlMetadata" in result_set and result_set["programUrlMetadata"] is not None: Logger.trace("Using 'programUrlMetadata' for date") date_parts = result_set["programUrlMetadata"].split("-") if len(date_parts) == 3: item.set_date(date_parts[2], date_parts[1], date_parts[0]) return
def create_video_item_api(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ # Could be: title = result_set['episodeTitle'] title = result_set['title'] url = "https://api.viervijfzes.be/content/{}".format( result_set['videoUuid']) item = MediaItem(title, url) item.type = "video" item.description = HtmlHelper.to_text( result_set.get("description").replace(">\r\n", ">")) item.thumb = result_set["image"] item.isGeoLocked = result_set.get("isProtected") date_time = DateHelper.get_date_from_posix(result_set["createdDate"]) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) item.set_info_label("duration", result_set["duration"]) if "epsiodeNumber" in result_set and "seasonNumber" in result_set: item.set_season_info(result_set["seasonNumber"], result_set["epsiodeNumber"]) return item
def create_episode_item(self, result_set): """ Creates a new MediaItem for an episode. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. :param list[str]|dict[str,str] result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'folder'. :rtype: MediaItem|None """ Logger.trace(result_set) title = result_set.get("title") if not title: return None link = result_set.get("feedLink") if not link.startswith("http"): link = parse.urljoin(self.baseUrl, link) item = MediaItem(title, link) item.thumb = result_set.get("image") item.description = result_set.get("text") if item.description is not None: item.description = item.description.replace("<br>", "\n") item.complete = True timestamp = result_set.get("timestamp") if timestamp is not None: date_time = DateHelper.get_date_from_posix(result_set["timestamp"]) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) return item
def create_video_item(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param list[str]|dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) title = result_set.get("title") media_link = result_set.get("video", result_set.get("ipadLink")) item = MediaItem(title, media_link) item.thumb = result_set.get("image", result_set.get("imageLink")) item.type = 'video' item.description = HtmlHelper.to_text(result_set.get("text")) posix = result_set.get("timestamp", None) if posix: broadcast_date = DateHelper.get_date_from_posix(int(posix)) item.set_date(broadcast_date.year, broadcast_date.month, broadcast_date.day, broadcast_date.hour, broadcast_date.minute, broadcast_date.second) item.set_info_label("duration", result_set.get("duration", 0)) return item
def create_video_item(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param list[str]|dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) media_link = result_set.get("ipadLink") title = result_set.get("title") # it seems overkill, but not all items have a contentLink and of we set # the url to self.baseUrl it will be a duplicate item if the titles are # equal url = result_set.get("contentLink") or media_link or self.baseUrl if not url.startswith("http"): url = parse.urljoin(self.baseUrl, url) item = MediaItem(title, url) if media_link: item.append_single_stream(media_link, self.channelBitrate) # get the thumbs from multiple locations thumb_urls = result_set.get("images", None) thumb_url = None if thumb_urls: # noinspection PyUnresolvedReferences thumb_url = \ thumb_urls[0].get("fullScreenLink", None) or \ thumb_urls[0].get("previewLink", None) or \ result_set.get("imageLink", None) if thumb_url and not thumb_url.startswith("http"): thumb_url = parse.urljoin(self.baseUrl, thumb_url) if thumb_url: item.thumb = thumb_url item.type = 'video' item.description = HtmlHelper.to_text(result_set.get("text")) posix = result_set.get("timestamp", None) if posix: broadcast_date = DateHelper.get_date_from_posix(int(posix)) item.set_date(broadcast_date.year, broadcast_date.month, broadcast_date.day, broadcast_date.hour, broadcast_date.minute, broadcast_date.second) item.complete = True return item
def create_video_item(self, result_set): """ Creates a MediaItem of type 'video' using the result_set from the regex. This method creates a new MediaItem from the Regular Expression or Json results <result_set>. The method should be implemented by derived classes and are specific to the channel. If the item is completely processed an no further data needs to be fetched the self.complete property should be set to True. If not set to True, the self.update_video_item method is called if the item is focussed or selected for playback. :param list[str]|dict result_set: The result_set of the self.episodeItemRegex :return: A new MediaItem of type 'video' or 'audio' (despite the method's name). :rtype: MediaItem|None """ Logger.trace(result_set) episode_key = result_set["episode_key"] if episode_key: episode_data = self.episodes.get(episode_key, None) if not episode_data: Logger.warning("Could not find episodes data for key: %s", episode_key) return None Logger.debug("Found Episode Data: %s", episode_data) else: Logger.debug("No Episode Data Found") episode_data = None title = result_set["title"] description = None if episode_data: if title: title = "%s - %s" % (episode_data["name"], title) else: title = episode_data["name"] description = episode_data.get("synopsis", None) # tarifs have datetimes # noinspection PyStatementEffect # """ # "ddr_timeframes": [{ # "start": 1382119200, # "stop": 1382378399, # "tariff": 149 # }, # { # "start": 1382378400, # "tariff": 0 # }], # # """ tariffs = result_set.get("ddr_timeframes") premium_item = False if tariffs: Logger.trace(tariffs) for tariff in tariffs: # type: dict if tariff["tariff"] > 0: start = tariff.get("start", 0) end = tariff.get("stop", 2147483647) start = DateHelper.get_date_from_posix(start) end = DateHelper.get_date_from_posix(end) now = datetime.datetime.now() if start < now < end: premium_item = True Logger.debug( "Found a tariff for this episode: %s - %s: %s", start, end, tariff["tariff"]) break uuid = result_set["uuid"] url = "http://www.rtl.nl/system/s4m/xldata/ux/%s?context=rtlxl&d=pc&fmt=adaptive&version=3" % ( uuid, ) # The JSON urls do not yet work # url = "http://www.rtl.nl/system/s4m/vfd/version=1/d=pc/output=json/fun=abstract/uuid=%s/fmt=smooth" % (uuid,) item = MediaItem(title.title(), url) item.type = "video" item.isPaid = premium_item item.description = description item.thumb = "%s%s" % ( self.posterBase, uuid, ) station = result_set.get("station", None) if station: icon = self.largeIconSet.get(station.lower(), None) if icon: Logger.trace("Setting icon to: %s", icon) item.icon = icon date_time = result_set.get("display_date", None) if date_time: date_time = DateHelper.get_date_from_posix(int(date_time)) item.set_date(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.minute, date_time.second) return item
def log_on(self): """ Logs on to a website, using an url. First checks if the channel requires log on. If so and it's not already logged on, it should handle the log on. That part should be implemented by the specific channel. More arguments can be passed on, but must be handled by custom code. After a successful log on the self.loggedOn property is set to True and True is returned. :return: indication if the login was successful. :rtype: bool """ api_key = "3_qhEcPa5JGFROVwu5SWKqJ4mVOIkwlFNMSKwzPDAh8QZOtHqu6L4nD5Q7lk0eXOOG" # Do we still have a valid short living token (1 hour)? If so, we have an active session. short_login_cookie = UriHandler.get_cookie("X-VRT-Token", ".vrt.be") if short_login_cookie is not None: # The old X-VRT-Token expired after 1 year. We don't want that old cookie short_login_cookie_can_live_too_long = \ DateHelper.get_date_from_posix(short_login_cookie.expires) > datetime.datetime.now() + datetime.timedelta(hours=4) if not short_login_cookie_can_live_too_long: Logger.debug("Using existing VRT.be session.") return True # Do we still have a valid long living token? If so, try to extend the session. We need the # original UIDSignature value for that. The 'vrtlogin-rt' and all other related cookies # are valid for a same period (1 year). long_login_cookie = UriHandler.get_cookie("vrtlogin-rt", ".vrt.be") if long_login_cookie is not None: # if we stored a valid user signature, we can use it, together with the 'gmid' and # 'ucid' cookies to extend the session and get new token data data = UriHandler.open("https://token.vrt.be/refreshtoken", proxy=self.proxy, no_cache=True) if "vrtnutoken" in data: Logger.debug("Refreshed the VRT.be session.") return True Logger.warning("Failed to extend the VRT.be session.") username = self._get_setting("username") if not username: Logger.warning("No username configured for VRT.nu") return None v = Vault() password = v.get_channel_setting(self.guid, "password") if not password: Logger.warning("Found empty password for VRT user") # Get a 'gmid' and 'ucid' cookie by logging in. Valid for 10 years Logger.debug("Using: %s / %s", username, "*" * len(password)) url = "https://accounts.vrt.be/accounts.login" data = { "loginID": username, "password": password, "sessionExpiration": "-1", "targetEnv": "jssdk", "include": "profile,data,emails,subscriptions,preferences,", "includeUserInfo": "true", "loginMode": "standard", "lang": "nl-inf", "APIKey": api_key, "source": "showScreenSet", "sdk": "js_latest", "authMode": "cookie", "format": "json" } logon_data = UriHandler.open(url, data=data, proxy=self.proxy, no_cache=True) user_id, signature, signature_time_stamp = self.__extract_session_data(logon_data) if user_id is None or signature is None or signature_time_stamp is None: return False # We need to initialize the token retrieval which will redirect to the actual token UriHandler.open("https://token.vrt.be/vrtnuinitlogin?provider=site&destination=https://www.vrt.be/vrtnu/", proxy=self.proxy, no_cache=True) # Now get the actual VRT tokens (X-VRT-Token....). Valid for 1 hour. So we call the actual # perform_login url which will redirect and get cookies. csrf = UriHandler.get_cookie("OIDCXSRF", "login.vrt.be") if csrf is None: csrf = UriHandler.get_cookie("XSRF-TOKEN", "login.vrt.be") token_data = { "UID": user_id, "UIDSignature": signature, "signatureTimestamp": signature_time_stamp, "client_id": "vrtnu-site", "submit": "submit", "_csrf": csrf.value } UriHandler.open("https://login.vrt.be/perform_login", proxy=self.proxy, data=token_data, no_cache=True) return True