Пример #1
0
    def _screen_object_to_item(self, context, screen_object, show_format_title=False):
        screen_object_type = screen_object.get('type', '')
        if screen_object_type == '':
            raise kodion.KodimonException('Missing type for screenObject')

        fanart = self.get_fanart(context)
        format_id = screen_object.get('format_id', screen_object.get('id', '')).split(':')
        if len(format_id) == 2:
            channel_id = format_id[0]
            format_id = format_id[1]
            if channel_id == 'tvog':
                channel_id = 'pro7'
                pass
            data = self._load_format_content(context, channel_id, format_id, return_cached_only=True)
            fanart = data.get('fanart', self.get_fanart(context))
            pass

        if screen_object_type == 'video_item_date_no_label' or screen_object_type == 'video_item_date' \
                or screen_object_type == 'video_item_format_no_label' or screen_object_type == 'video_item_format':
            name = screen_object.get('title', screen_object['video_title'])
            if screen_object_type == 'video_item_format_no_label' or show_format_title:
                name = '%s - %s' % (screen_object['format_title'], name)
                pass
            video_item = VideoItem(name,
                                   context.create_uri(['play'], {'id': screen_object['id']}),
                                   image=screen_object.get('image_url', ''))
            video_item.set_fanart(fanart)
            video_item.set_duration_from_seconds(int(screen_object.get('duration', '60')))

            date_time = datetime_parser.parse(screen_object.get('start', '0000-00-00'))
            video_item.set_aired_from_datetime(date_time)
            video_item.set_premiered_from_datetime(date_time)
            video_item.set_year_from_datetime(date_time)
            try_set_season_and_episode(video_item)

            context_menu = [(context.localize(kodion.constants.localize.WATCH_LATER),
                             'RunPlugin(%s)' % context.create_uri([kodion.constants.paths.WATCH_LATER, 'add'],
                                                                  {'item': kodion.items.to_jsons(video_item)}))]
            video_item.set_context_menu(context_menu)
            return video_item
        elif screen_object_type == 'format_item_home' or screen_object_type == 'format_item':
            format_item = DirectoryItem(screen_object['title'],
                                        context.create_uri([channel_id, 'library', format_id]),
                                        image=screen_object['image_url'])
            format_item.set_fanart(fanart)
            context_menu = [(context.localize(kodion.constants.localize.FAVORITES_ADD),
                             'RunPlugin(%s)' % context.create_uri([kodion.constants.paths.FAVORITES, 'add'],
                                                                  {'item': kodion.items.to_jsons(format_item)}))]
            format_item.set_context_menu(context_menu)
            return format_item

        raise kodion.KodimonException("Unknown type '%s' for screen_object" % screen_object_type)
    def _videos_to_items(self, context, videos, channel_config):
        result = []

        show_only_free_videos = context.get_settings().get_bool('nowtv.videos.only_free', False)
        for video in videos:
            if show_only_free_videos and not video['free']:
                continue

            video_params = {'video_path': video['path'],
                            'video_id': str(video['id'])}

            title = video['title']
            if not video['free']:
                title = '[B][%s][/B] - %s' % (video['price'], title)
                video_params['free'] = '0'
                video_params['price'] = video['price']
                pass
            video_item = VideoItem(title, context.create_uri([channel_config['id'], 'play'], video_params))
            duration = datetime_parser.parse(video['duration'])
            video_item.set_duration(duration.hour, duration.minute, duration.second)

            published = datetime_parser.parse(video['published'])
            video_item.set_aired_from_datetime(published)
            video_item.set_date_from_datetime(published)
            video_item.set_year_from_datetime(published)

            video_item.set_studio(video['format'])
            video_item.add_artist(video['format'])
            video_item.set_episode(video['episode'])
            video_item.set_season(video['season'])
            video_item.set_plot(video['plot'])
            video_item.set_image(video['images']['thumb'])
            video_item.set_fanart(video['images']['fanart'])
            result.append(video_item)
            pass

        return result
Пример #3
0
    def _screen_object_to_item(self,
                               context,
                               screen_object,
                               show_format_title=False):
        screen_object_type = screen_object.get('type', '')
        if screen_object_type == '':
            raise kodion.KodimonException('Missing type for screenObject')

        fanart = self.get_fanart(context)
        format_id = screen_object.get('format_id',
                                      screen_object.get('id', '')).split(':')
        if len(format_id) == 2:
            channel_id = format_id[0]
            format_id = format_id[1]
            if channel_id == 'tvog':
                channel_id = 'pro7'
                pass
            data = self._load_format_content(context,
                                             channel_id,
                                             format_id,
                                             return_cached_only=True)
            fanart = data.get('fanart', self.get_fanart(context))
            pass

        if screen_object_type == 'video_item_date_no_label' or screen_object_type == 'video_item_date' \
                or screen_object_type == 'video_item_format_no_label' or screen_object_type == 'video_item_format':
            name = screen_object.get('title', screen_object['video_title'])
            if screen_object_type == 'video_item_format_no_label' or show_format_title:
                name = '%s - %s' % (screen_object['format_title'], name)
                pass
            video_item = VideoItem(name,
                                   context.create_uri(
                                       ['play'], {'id': screen_object['id']}),
                                   image=screen_object.get('image_url', ''))
            video_item.set_fanart(fanart)
            video_item.set_duration_from_seconds(
                int(screen_object.get('duration', '60')))

            date_time = datetime_parser.parse(
                screen_object.get('start', '0000-00-00'))
            video_item.set_aired_from_datetime(date_time)
            video_item.set_premiered_from_datetime(date_time)
            video_item.set_year_from_datetime(date_time)
            try_set_season_and_episode(video_item)

            context_menu = [
                (context.localize(kodion.constants.localize.WATCH_LATER),
                 'RunPlugin(%s)' % context.create_uri(
                     [kodion.constants.paths.WATCH_LATER, 'add'],
                     {'item': kodion.items.to_jsons(video_item)}))
            ]
            video_item.set_context_menu(context_menu)
            return video_item
        elif screen_object_type == 'format_item_home' or screen_object_type == 'format_item':
            format_item = DirectoryItem(
                screen_object['title'],
                context.create_uri([channel_id, 'library', format_id]),
                image=screen_object['image_url'])
            format_item.set_fanart(fanart)
            context_menu = [
                (context.localize(kodion.constants.localize.FAVORITES_ADD),
                 'RunPlugin(%s)' % context.create_uri(
                     [kodion.constants.paths.FAVORITES, 'add'],
                     {'item': kodion.items.to_jsons(format_item)}))
            ]
            format_item.set_context_menu(context_menu)
            return format_item

        raise kodion.KodimonException("Unknown type '%s' for screen_object" %
                                      screen_object_type)
Пример #4
0
    def _list_films(self,
                    context,
                    re_match,
                    json_data,
                    show_format_title=False,
                    sort=True):
        context.get_ui().set_view_mode('videos')

        def _sort_newest(item):
            return item.get_aired()

        context.set_content_type(kodion.constants.content_type.EPISODES)
        context.add_sort_method(kodion.constants.sort_method.UNSORTED,
                                kodion.constants.sort_method.VIDEO_YEAR,
                                kodion.constants.sort_method.VIDEO_RUNTIME)

        result = []

        content = json_data.get('result', {}).get('content', {})
        max_page = int(content.get('maxpage', 1))
        page = int(content.get('page', 1))
        film_list = content.get('filmlist', {})

        result_films = []
        add_next_page_item = True
        keys = sorted(film_list.keys())
        for key in keys:
            film = film_list[key]

            # as soon as we find non-free episodes we don't provide pagination
            # the 'continue' should skip all non-free episodes
            free = str(film.get('free', '0'))
            if free == '0':
                add_next_page_item = False
                continue

            title = film['headlinelong']
            format_title = film['formatlong']
            if show_format_title:
                title = format_title + ' - ' + title
                pass

            film_item = VideoItem(
                title, context.create_uri(['play'], {'video_id': film['id']}))

            film_item.set_studio(format_title)
            film_item.add_artist(format_title)

            format_id = film['formatid']
            # set image
            image = self.get_client(context).get_config(
            )['images']['format-thumbnail-url'].replace(
                '%FORMAT_ID%', format_id)
            pictures = film.get('pictures', [])
            if pictures and isinstance(pictures, dict):
                image = film['pictures']['pic_0']
                image = self.get_client(context).get_config(
                )['images']['episode-thumbnail-url'].replace(
                    '%PIC_ID%', image)
                pass
            film_item.set_image(image)

            # set fanart
            fanart = self.get_client(
                context).get_config()['images']['format-fanart-url'].replace(
                    '%FORMAT_ID%', format_id)
            film_item.set_fanart(fanart)

            # season and episode
            film_item.set_season(film.get('season', '1'))
            film_item.set_episode(film.get('episode', '1'))

            # aired
            aired = datetime_parser.parse(film['sendestart'])
            film_item.set_aired_from_datetime(aired)
            film_item.set_date_from_datetime(aired)
            film_item.set_year_from_datetime(aired)

            # duration
            duration = datetime_parser.parse(film['duration'])
            film_item.set_duration(duration.hour, duration.minute,
                                   duration.second)

            # plot
            film_item.set_plot(film['articlelong'])

            context_menu = [(
                context.localize(self._local_map['now.watch_later']),
                'RunPlugin(%s)' %
                context.create_uri([kodion.constants.paths.WATCH_LATER, 'add'],
                                   {'item': kodion.items.to_jsons(film_item)}))
                            ]
            film_item.set_context_menu(context_menu)
            result_films.append(film_item)
            pass
        if sort:
            result_films = sorted(result_films, key=_sort_newest, reverse=True)
            pass
        result.extend(result_films)

        if add_next_page_item and page < max_page:
            new_params = {}
            new_params.update(context.get_params())
            new_params['page'] = page + 1
            next_page_item = kodion.items.NextPageItem(
                context, current_page=page, fanart=self.get_fanart(context))
            result.append(next_page_item)
            pass

        return result
Пример #5
0
    def _list_films(self, context, re_match, json_data, show_format_title=False, sort=True):
        context.get_ui().set_view_mode('videos')

        def _sort_newest(item):
            return item.get_aired()

        context.set_content_type(kodion.constants.content_type.EPISODES)
        context.add_sort_method(kodion.constants.sort_method.UNSORTED,
                                kodion.constants.sort_method.VIDEO_YEAR,
                                kodion.constants.sort_method.VIDEO_RUNTIME)

        result = []

        content = json_data.get('result', {}).get('content', {})
        max_page = int(content.get('maxpage', 1))
        page = int(content.get('page', 1))
        film_list = content.get('filmlist', {})

        result_films = []
        add_next_page_item = True
        keys = sorted(film_list.keys())
        for key in keys:
            film = film_list[key]

            # as soon as we find non-free episodes we don't provide pagination
            # the 'continue' should skip all non-free episodes
            free = str(film.get('free', '0'))
            if free == '0':
                add_next_page_item = False
                continue

            title = film['headlinelong']
            format_title = film['formatlong']
            if show_format_title:
                title = format_title + ' - ' + title
                pass

            film_item = VideoItem(title, context.create_uri(['play'], {'video_id': film['id']}))

            film_item.set_studio(format_title)
            film_item.add_artist(format_title)

            format_id = film['formatid']
            # set image
            image = self.get_client(context).get_config()['images']['format-thumbnail-url'].replace('%FORMAT_ID%',
                                                                                                    format_id)
            pictures = film.get('pictures', [])
            if pictures and isinstance(pictures, dict):
                image = film['pictures']['pic_0']
                image = self.get_client(context).get_config()['images']['episode-thumbnail-url'].replace('%PIC_ID%',
                                                                                                         image)
                pass
            film_item.set_image(image)

            # set fanart
            fanart = self.get_client(context).get_config()['images']['format-fanart-url'].replace('%FORMAT_ID%', format_id)
            film_item.set_fanart(fanart)

            # season and episode
            film_item.set_season(film.get('season', '1'))
            film_item.set_episode(film.get('episode', '1'))

            # aired
            aired = datetime_parser.parse(film['sendestart'])
            film_item.set_aired_from_datetime(aired)
            film_item.set_date_from_datetime(aired)
            film_item.set_year_from_datetime(aired)

            # duration
            duration = datetime_parser.parse(film['duration'])
            film_item.set_duration(duration.hour, duration.minute, duration.second)

            # plot
            film_item.set_plot(film['articlelong'])

            context_menu = [(context.localize(self._local_map['now.watch_later']),
                             'RunPlugin(%s)' % context.create_uri([kodion.constants.paths.WATCH_LATER, 'add'],
                                                                  {'item': kodion.items.to_jsons(film_item)}))]
            film_item.set_context_menu(context_menu)
            result_films.append(film_item)
            pass
        if sort:
            result_films = sorted(result_films, key=_sort_newest, reverse=True)
            pass
        result.extend(result_films)

        if add_next_page_item and page < max_page:
            new_params = {}
            new_params.update(context.get_params())
            new_params['page'] = page + 1
            next_page_item = kodion.items.NextPageItem(context, current_page=page, fanart=self.get_fanart(context))
            result.append(next_page_item)
            pass

        return result
Пример #6
0
    def _videos_to_items(self, context, videos, prepend_format_title=False):
        result = []

        # show only free videos if not logged in or or the setting is enabled
        show_only_free_videos = not self.is_logged_in() or context.get_settings().get_bool('nowtv.videos.only_free',
                                                                                           False)
        for video in videos:
            if show_only_free_videos and not video['free'] and not video['payed']:
                continue

            video_params = {'video_path': video['path'],
                            'video_id': str(video['id'])}

            title = video['title']
            if prepend_format_title:
                title = '%s - %s' % (video['format'], title)
                pass
            if not video['free'] and not video['payed']:
                title = '[B][%s][/B] - %s' % (video['price'], title)
                video_params['free'] = '0'
                video_params['price'] = video['price']
                pass
            video_item = VideoItem(title, context.create_uri([video['channel'], 'play'], video_params))
            duration = datetime_parser.parse(video['duration'])
            video_item.set_duration(duration.hour, duration.minute, duration.second)

            published = datetime_parser.parse(video['published'])
            video_item.set_aired_from_datetime(published)
            video_item.set_date_from_datetime(published)
            video_item.set_year_from_datetime(published)

            video_item.set_studio(video['format'])
            video_item.add_artist(video['format'])
            video_item.set_episode(video['episode'])
            video_item.set_season(video['season'])
            video_item.set_plot(video['plot'])
            video_item.set_image(video['images']['thumb'])
            video_item.set_fanart(video['images']['fanart'])

            context_menu = []
            if self.is_logged_in():
                if context.get_path() == '/nowtv/watch_later/list/':
                    context_menu = [(context.localize(self._local_map['nowtv.remove_from_watch_later']),
                                     'RunPlugin(%s)' % context.create_uri(['nowtv', 'watch_later', 'delete'],
                                                                          {'video_id': video['id']}))]
                    pass
                else:
                    context_menu = [(context.localize(self._local_map['nowtv.add_to_watch_later']),
                                     'RunPlugin(%s)' % context.create_uri(['nowtv', 'watch_later', 'add'],
                                                                          {'video_id': video['id']}))]
                    pass
            else:
                context_menu = [(context.localize(self._local_map['nowtv.add_to_watch_later']),
                                 'RunPlugin(%s)' % context.create_uri([kodion.constants.paths.WATCH_LATER, 'add'],
                                                                      {'item': kodion.items.to_jsons(video_item)}))]
                pass

            if context_menu:
                video_item.set_context_menu(context_menu)
                pass

            result.append(video_item)
            pass

        return result
Пример #7
0
    def _videos_to_items(self, context, videos, prepend_format_title=False):
        result = []

        # show only free videos if not logged in or or the setting is enabled
        show_only_free_videos = not self.is_logged_in(
        ) and context.get_settings().get_bool('nowtv.videos.only_free', False)
        for video in videos:
            if show_only_free_videos and not video['free'] and not video[
                    'payed']:
                continue

            video_params = {
                'video_path': video['path'],
                'video_id': str(video['id'])
            }

            title = video['title']
            if prepend_format_title:
                title = '%s - %s' % (video['format'], title)
                pass
            if not video['free'] and not video['payed']:
                title = '[B][%s][/B] - %s' % (video['price'], title)
                video_params['free'] = '0'
                video_params['price'] = video['price']
                pass
            video_item = VideoItem(
                title,
                context.create_uri([video['channel'], 'play'], video_params))
            duration = datetime_parser.parse(video['duration'])
            video_item.set_duration(duration.hour, duration.minute,
                                    duration.second)

            published = datetime_parser.parse(video['published'])
            video_item.set_aired_from_datetime(published)
            video_item.set_date_from_datetime(published)
            video_item.set_year_from_datetime(published)

            video_item.set_studio(video['format'])
            video_item.add_artist(video['format'])
            video_item.set_episode(video['episode'])
            video_item.set_season(video['season'])
            video_item.set_plot(video['plot'])
            video_item.set_image(video['images']['thumb'])
            video_item.set_fanart(video['images']['fanart'])

            context_menu = []
            if self.is_logged_in():
                if context.get_path() == '/nowtv/watch_later/list/':
                    context_menu = [
                        (context.localize(
                            self._local_map['nowtv.remove_from_watch_later']),
                         'RunPlugin(%s)' %
                         context.create_uri(['nowtv', 'watch_later', 'delete'],
                                            {'video_id': video['id']}))
                    ]
                    pass
                else:
                    context_menu = [
                        (context.localize(
                            self._local_map['nowtv.add_to_watch_later']),
                         'RunPlugin(%s)' %
                         context.create_uri(['nowtv', 'watch_later', 'add'],
                                            {'video_id': video['id']}))
                    ]
                    pass
            else:
                context_menu = [
                    (context.localize(
                        self._local_map['nowtv.add_to_watch_later']),
                     'RunPlugin(%s)' % context.create_uri(
                         [kodion.constants.paths.WATCH_LATER, 'add'],
                         {'item': kodion.items.to_jsons(video_item)}))
                ]
                pass

            if context_menu:
                video_item.set_context_menu(context_menu)
                pass

            result.append(video_item)
            pass

        return result
Пример #8
0
    def _create_video_item_from_post(self, post, context):
        def _read_custom_fields(_post, field_name):
            custom_fields = post.get('custom_fields', {})
            field = custom_fields.get(field_name, [])
            if len(field) >= 1:
                return field[0]
            return u''

        slug = post['slug']
        title = self._html_parser.unescape(post['title'])
        movie_item = VideoItem(title,
                               context.create_uri('play', {'slug': slug}),
                               image=post.get('thumbnail', ''))

        # stars
        stars = _read_custom_fields(post, 'Stars')
        if stars:
            stars = stars.split(',')
            for star in stars:
                movie_item.add_cast(star.strip())
                pass
            pass

        # director
        director = _read_custom_fields(post, 'Regisseur')
        if director:
            movie_item.set_director(director.strip())
            pass

        # imdb
        imdb = _read_custom_fields(post, 'IMDb-Link')
        if imdb:
            movie_item.set_imdb_id(imdb)
            pass

        # rating
        rating = _read_custom_fields(post, 'IMDb-Bewertung')
        if rating:
            rating = rating.replace(',', '.')
            movie_item.set_rating(rating)
            pass

        # year
        year = _read_custom_fields(post, 'Jahr')
        if year:
            # There was one case with '2006/2012' as a result. Therefore we split every year.
            year = year.split('/')[0]
            movie_item.set_year(year)
            pass

        # fanart
        fanart = _read_custom_fields(post, 'featured_img_all')
        if not fanart:
            fanart = self.get_fanart(context)
            pass
        movie_item.set_fanart(fanart)

        # plot
        plot = self._html_parser.unescape(post['content'])
        plot = kodion.utils.strip_html_from_text(plot)
        movie_item.set_plot(plot)

        # date added - in this case date modified (why?!?!)
        date = datetime_parser.parse(post['modified'])
        movie_item.set_date_from_datetime(date)

        # context menu
        ctx_menu = [
            (context.localize(constants.localize.WATCH_LATER_ADD),
             'RunPlugin(%s)' %
             context.create_uri([constants.paths.WATCH_LATER, 'add'],
                                {'item': kodion.items.to_jsons(movie_item)}))
        ]
        movie_item.set_context_menu(ctx_menu)
        return movie_item
Пример #9
0
    def _create_video_item_from_post(self, post, context):
        def _read_custom_fields(_post, field_name):
            custom_fields = post.get("custom_fields", {})
            field = custom_fields.get(field_name, [])
            if len(field) >= 1:
                return field[0]
            return u""

        slug = post["slug"]
        title = self._html_parser.unescape(post["title"])
        movie_item = VideoItem(title, context.create_uri("play", {"slug": slug}), image=post.get("thumbnail", ""))

        # stars
        stars = _read_custom_fields(post, "Stars")
        if stars:
            stars = stars.split(",")
            for star in stars:
                movie_item.add_cast(star.strip())
                pass
            pass

        # director
        director = _read_custom_fields(post, "Regisseur")
        if director:
            movie_item.set_director(director.strip())
            pass

        # imdb
        imdb = _read_custom_fields(post, "IMDb-Link")
        if imdb:
            movie_item.set_imdb_id(imdb)
            pass

        # rating
        rating = _read_custom_fields(post, "IMDb-Bewertung")
        if rating:
            rating = rating.replace(",", ".")
            movie_item.set_rating(rating)
            pass

        # year
        year = _read_custom_fields(post, "Jahr")
        if year:
            # There was one case with '2006/2012' as a result. Therefore we split every year.
            year = year.split("/")[0]
            movie_item.set_year(year)
            pass

        # fanart
        fanart = _read_custom_fields(post, "featured_img_all")
        if not fanart:
            fanart = self.get_fanart(context)
            pass
        movie_item.set_fanart(fanart)

        # plot
        plot = self._html_parser.unescape(post["content"])
        plot = kodion.utils.strip_html_from_text(plot)
        movie_item.set_plot(plot)

        # date added - in this case date modified (why?!?!)
        date = datetime_parser.parse(post["modified"])
        movie_item.set_date_from_datetime(date)

        # context menu
        ctx_menu = [
            (
                context.localize(constants.localize.WATCH_LATER_ADD),
                "RunPlugin(%s)"
                % context.create_uri([constants.paths.WATCH_LATER, "add"], {"item": kodion.items.to_jsons(movie_item)}),
            )
        ]
        movie_item.set_context_menu(ctx_menu)
        return movie_item
Пример #10
0
    def _create_video_item_from_post(self, post, context):
        def _read_custom_fields(_post, field_name):
            custom_fields = post.get('custom_fields', {})
            field = custom_fields.get(field_name, [])
            if len(field) >= 1:
                return field[0]
            return u''

        slug = post['slug']
        title = self._html_parser.unescape(post['title'])
        movie_item = VideoItem(title,
                               context.create_uri('play', {'slug': slug}),
                               image=post.get('thumbnail', ''))

        # stars
        stars = _read_custom_fields(post, 'Stars')
        if stars:
            stars = stars.split(',')
            for star in stars:
                movie_item.add_cast(star.strip())
                pass
            pass

        # director
        director = _read_custom_fields(post, 'Regisseur')
        if director:
            movie_item.set_director(director.strip())
            pass

        # imdb
        imdb = _read_custom_fields(post, 'IMDb-Link')
        if imdb:
            movie_item.set_imdb_id(imdb)
            pass

        # rating
        rating = _read_custom_fields(post, 'IMDb-Bewertung')
        if rating:
            rating = rating.replace(',', '.')
            movie_item.set_rating(rating)
            pass

        # year
        year = _read_custom_fields(post, 'Jahr')
        if year:
            # There was one case with '2006/2012' as a result. Therefore we split every year.
            year = year.split('/')[0]
            movie_item.set_year(year)
            pass

        # fanart
        fanart = _read_custom_fields(post, 'featured_img_all')
        if not fanart:
            fanart = self.get_fanart(context)
            pass
        movie_item.set_fanart(fanart)

        # plot
        plot = self._html_parser.unescape(post['content'])
        plot = kodion.utils.strip_html_from_text(plot)
        movie_item.set_plot(plot)

        # date added - in this case date modified (why?!?!)
        date = datetime_parser.parse(post['modified'])
        movie_item.set_date_from_datetime(date)

        # context menu
        ctx_menu = [(context.localize(constants.localize.WATCH_LATER_ADD),
                     'RunPlugin(%s)' % context.create_uri([constants.paths.WATCH_LATER, 'add'],
                                                          {'item': kodion.items.to_jsons(movie_item)}))]
        movie_item.set_context_menu(ctx_menu)
        return movie_item
Пример #11
0
    def _videos_to_items(self, context, videos, prepend_format_title=False):
        result = []

        # show only free videos if not logged in or or the setting is enabled
        show_only_free_videos = not self.is_logged_in() and context.get_settings().get_bool(
            "nowtv.videos.only_free", False
        )
        for video in videos:
            if show_only_free_videos and not video["free"] and not video["payed"]:
                continue

            video_params = {"video_path": video["path"], "video_id": str(video["id"])}

            title = video["title"]
            if prepend_format_title:
                title = "%s - %s" % (video["format"], title)
                pass
            if not video["free"] and not video["payed"]:
                title = "[B][%s][/B] - %s" % (video["price"], title)
                video_params["free"] = "0"
                video_params["price"] = video["price"]
                pass
            video_item = VideoItem(title, context.create_uri([video["channel"], "play"], video_params))
            duration = datetime_parser.parse(video["duration"])
            video_item.set_duration(duration.hour, duration.minute, duration.second)

            published = datetime_parser.parse(video["published"])
            video_item.set_aired_from_datetime(published)
            video_item.set_date_from_datetime(published)
            video_item.set_year_from_datetime(published)

            video_item.set_studio(video["format"])
            video_item.add_artist(video["format"])
            video_item.set_episode(video["episode"])
            video_item.set_season(video["season"])
            video_item.set_plot(video["plot"])
            video_item.set_image(video["images"]["thumb"])
            video_item.set_fanart(video["images"]["fanart"])

            context_menu = []
            if self.is_logged_in():
                if context.get_path() == "/nowtv/watch_later/list/":
                    context_menu = [
                        (
                            context.localize(self._local_map["nowtv.remove_from_watch_later"]),
                            "RunPlugin(%s)"
                            % context.create_uri(["nowtv", "watch_later", "delete"], {"video_id": video["id"]}),
                        )
                    ]
                    pass
                else:
                    context_menu = [
                        (
                            context.localize(self._local_map["nowtv.add_to_watch_later"]),
                            "RunPlugin(%s)"
                            % context.create_uri(["nowtv", "watch_later", "add"], {"video_id": video["id"]}),
                        )
                    ]
                    pass
            else:
                context_menu = [
                    (
                        context.localize(self._local_map["nowtv.add_to_watch_later"]),
                        "RunPlugin(%s)"
                        % context.create_uri(
                            [kodion.constants.paths.WATCH_LATER, "add"], {"item": kodion.items.to_jsons(video_item)}
                        ),
                    )
                ]
                pass

            if context_menu:
                video_item.set_context_menu(context_menu)
                pass

            result.append(video_item)
            pass

        return result