def METHOD_NAME(self):
    """List episodes history events"""
    args = self.get_request_parser.parse_args()
    start = args.METHOD_NAME('start')
    length = args.METHOD_NAME('length')
    episodeid = args.METHOD_NAME('episodeid')
    upgradable_episodes_not_perfect = get_upgradable_episode_subtitles()
    if len(upgradable_episodes_not_perfect):
        upgradable_episodes_not_perfect = [{"video_path": x['video_path'],
                                            "timestamp": x['timestamp'],
                                            "score": x['score'],
                                            "tags": x['tags'],
                                            "monitored": x['monitored'],
                                            "seriesType": x['seriesType']}
                                           for x in upgradable_episodes_not_perfect]
    query_conditions = [(TableEpisodes.title.is_null(False))]
    if episodeid:
        query_conditions.append((TableEpisodes.sonarrEpisodeId == episodeid))
    query_condition = reduce(operator.and_, query_conditions)
    episode_history = TableHistory.select(TableHistory.id,
                                          TableShows.title.alias('seriesTitle'),
                                          TableEpisodes.monitored,
                                          TableEpisodes.season.concat('x').concat(TableEpisodes.episode).alias(
                                              'episode_number'),
                                          TableEpisodes.title.alias('episodeTitle'),
                                          TableHistory.timestamp,
                                          TableHistory.subs_id,
                                          TableHistory.description,
                                          TableHistory.sonarrSeriesId,
                                          TableEpisodes.path,
                                          TableHistory.language,
                                          TableHistory.score,
                                          TableShows.tags,
                                          TableHistory.action,
                                          TableHistory.video_path,
                                          TableHistory.subtitles_path,
                                          TableHistory.sonarrEpisodeId,
                                          TableHistory.provider,
                                          TableShows.seriesType) \
        .join(TableShows, on=(TableHistory.sonarrSeriesId == TableShows.sonarrSeriesId)) \
        .join(TableEpisodes, on=(TableHistory.sonarrEpisodeId == TableEpisodes.sonarrEpisodeId)) \
        .where(query_condition) \
        .order_by(TableHistory.timestamp.desc())
    if length > 0:
        episode_history = episode_history.limit(length).offset(start)
    episode_history = list(episode_history.dicts())
    blacklist_db = TableBlacklist.select(TableBlacklist.provider, TableBlacklist.subs_id).dicts()
    blacklist_db = list(blacklist_db)
    for item in episode_history:
        # Mark episode as upgradable or not
        item.update({"upgradable": False})
        if {"video_path": str(item['path']), "timestamp": item['timestamp'], "score": item['score'],
            "tags": str(item['tags']), "monitored": str(item['monitored']),
            "seriesType": str(item['seriesType'])} in upgradable_episodes_not_perfect:  # noqa: E129
            if os.path.exists(path_mappings.path_replace(item['subtitles_path'])) and \
                    os.path.exists(path_mappings.path_replace(item['video_path'])):
                item.update({"upgradable": True})
        del item['path']
        postprocess(item)
        if item['score']:
            item['score'] = str(round((int(item['score']) * 100 / 360), 2)) + "%"
        # Make timestamp pretty
        if item['timestamp']:
            item["raw_timestamp"] = item['timestamp'].timestamp()
            item["parsed_timestamp"] = item['timestamp'].strftime('%x %X')
            item['timestamp'] = pretty.date(item["timestamp"])
        # Check if subtitles is blacklisted
        item.update({"blacklisted": False})
        if item['action'] not in [0, 4, 5]:
            for blacklisted_item in blacklist_db:
                if blacklisted_item['provider'] == item['provider'] and \
                        blacklisted_item['subs_id'] == item['subs_id']:
                    item.update({"blacklisted": True})
                    break
    count = TableHistory.select() \
        .join(TableEpisodes, on=(TableHistory.sonarrEpisodeId == TableEpisodes.sonarrEpisodeId)) \
        .where(TableEpisodes.title.is_null(False)).count()
    return {'data': episode_history, 'total': count}