From 72b6fd62a0d0d2065f5d1038b07694ed726ac17e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Louis=20V=C3=A9zina?= <5130500+morpheus65535@users.noreply.github.com> Date: Mon, 13 Jul 2020 10:57:43 -0400 Subject: [PATCH] Added filter to exclude episodes based on series type as defined in Sonarr. --- bazarr/api.py | 33 +- bazarr/config.py | 3 +- bazarr/database.py | 19 +- bazarr/get_series.py | 8 +- bazarr/get_subtitle.py | 29 +- static/css/tagsinput.css | 103 ++++++ static/js/tagsinput.js | 691 ++++++++++++++++++++++++++++++++++++++ views/episodes.html | 2 + views/settingssonarr.html | 25 +- 9 files changed, 876 insertions(+), 37 deletions(-) create mode 100644 static/css/tagsinput.css create mode 100644 static/js/tagsinput.js diff --git a/bazarr/api.py b/bazarr/api.py index b9050e82a..ef765ceef 100644 --- a/bazarr/api.py +++ b/bazarr/api.py @@ -78,9 +78,9 @@ class Restart(Resource): class Badges(Resource): @authenticate def get(self): - missing_episodes = database.execute("SELECT table_shows.tags, table_episodes.monitored FROM table_episodes " - "INNER JOIN table_shows on table_shows.sonarrSeriesId = " - "table_episodes.sonarrSeriesId WHERE missing_subtitles is not null AND " + missing_episodes = database.execute("SELECT table_shows.tags, table_episodes.monitored, table_shows.seriesType " + "FROM table_episodes INNER JOIN table_shows on table_shows.sonarrSeriesId =" + " table_episodes.sonarrSeriesId WHERE missing_subtitles is not null AND " "missing_subtitles != '[]'") missing_episodes = filter_exclusions(missing_episodes, 'series') missing_episodes = len(missing_episodes) @@ -293,6 +293,9 @@ class Series(Resource): # Parse tags item.update({"tags": ast.literal_eval(item['tags'])}) + # Parse seriesType + item.update({"seriesType": item['seriesType'].capitalize()}) + # Provide mapped path mapped_path = path_mappings.path_replace(item['path']) item.update({"mapped_path": mapped_path}) @@ -301,9 +304,9 @@ class Series(Resource): item.update({"exist": os.path.isdir(mapped_path)}) # Add missing subtitles episode count - episodeMissingCount = database.execute("SELECT table_shows.tags, table_episodes.monitored FROM " - "table_episodes INNER JOIN table_shows on " - "table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId " + episodeMissingCount = database.execute("SELECT table_shows.tags, table_episodes.monitored, " + "table_shows.seriesType FROM table_episodes INNER JOIN table_shows " + "on table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId " "WHERE table_episodes.sonarrSeriesId=? AND missing_subtitles is not " "null AND missing_subtitles != '[]'", (item['sonarrSeriesId'],)) episodeMissingCount = filter_exclusions(episodeMissingCount, 'series') @@ -311,10 +314,10 @@ class Series(Resource): item.update({"episodeMissingCount": episodeMissingCount}) # Add episode count - episodeFileCount = database.execute("SELECT table_shows.tags, table_episodes.monitored FROM table_episodes " - "INNER JOIN table_shows on table_shows.sonarrSeriesId = " - "table_episodes.sonarrSeriesId WHERE table_episodes.sonarrSeriesId=?", - (item['sonarrSeriesId'],)) + episodeFileCount = database.execute("SELECT table_shows.tags, table_episodes.monitored, " + "table_shows.seriesType FROM table_episodes INNER JOIN table_shows on " + "table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId WHERE " + "table_episodes.sonarrSeriesId=?", (item['sonarrSeriesId'],)) episodeFileCount = filter_exclusions(episodeFileCount, 'series') episodeFileCount = len(episodeFileCount) item.update({"episodeFileCount": episodeFileCount}) @@ -1122,9 +1125,9 @@ class HistorySeries(Resource): query_actions = [1, 3] upgradable_episodes = database.execute( - "SELECT video_path, MAX(timestamp) as timestamp, score, table_shows.tags, table_episodes.monitored FROM " - "table_history INNER JOIN table_episodes on table_episodes.sonarrEpisodeId = " - "table_history.sonarrEpisodeId INNER JOIN table_shows on table_shows.sonarrSeriesId = " + "SELECT video_path, MAX(timestamp) as timestamp, score, table_shows.tags, table_episodes.monitored, " + "table_shows.seriesType FROM table_history INNER JOIN table_episodes on table_episodes.sonarrEpisodeId " + "= table_history.sonarrEpisodeId INNER JOIN table_shows on table_shows.sonarrSeriesId = " "table_episodes.sonarrSeriesId WHERE action IN (" + ','.join(map(str, query_actions)) + ") AND timestamp > ? AND " "score is not null GROUP BY table_history.video_path, table_history.language", @@ -1326,8 +1329,8 @@ class WantedSeries(Resource): "table_episodes.title as episodeTitle, table_episodes.missing_subtitles, " "table_episodes.sonarrSeriesId, table_episodes.path, table_shows.hearing_impaired, " "table_episodes.sonarrEpisodeId, table_episodes.scene_name, table_shows.tags, " - "table_episodes.failedAttempts FROM table_episodes INNER JOIN table_shows on " - "table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId WHERE " + "table_episodes.failedAttempts, table_shows.seriesType FROM table_episodes INNER JOIN " + "table_shows on table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId WHERE " "table_episodes.missing_subtitles != '[]' ORDER BY table_episodes._rowid_ DESC LIMIT ? " "OFFSET ?", (length, start)) data = filter_exclusions(data, 'series') diff --git a/bazarr/config.py b/bazarr/config.py index deea1d1db..bf325c9bd 100644 --- a/bazarr/config.py +++ b/bazarr/config.py @@ -76,7 +76,8 @@ defaults = { 'only_monitored': 'False', 'series_sync': '1', 'episodes_sync': '5', - 'excluded_tags': '[]' + 'excluded_tags': '[]', + 'excluded_series_types': '[]' }, 'radarr': { 'ip': '127.0.0.1', diff --git a/bazarr/database.py b/bazarr/database.py index 968d86351..0125d779f 100644 --- a/bazarr/database.py +++ b/bazarr/database.py @@ -93,6 +93,7 @@ def db_upgrade(): ['table_shows', 'alternateTitles', 'text'], ['table_shows', 'forced', 'text', 'False'], ['table_shows', 'tags', 'text', '[]'], + ['table_shows', 'seriesType', 'text', ''], ['table_episodes', 'format', 'text'], ['table_episodes', 'resolution', 'text'], ['table_episodes', 'video_codec', 'text'], @@ -144,9 +145,21 @@ def filter_exclusions(dicts_list, type): else: tagsList = ast.literal_eval(settings.radarr.excluded_tags) monitoredOnly = settings.radarr.getboolean('only_monitored') + + # Filter tags dictsList_tags_filtered = [item for item in dicts_list if set(tagsList).isdisjoint(ast.literal_eval(item['tags']))] + + # Filter monitored if monitoredOnly: - dictsList_tags_monitored = [item for item in dictsList_tags_filtered if item['monitored'] == 'True'] + dictsList_monitored_filtered = [item for item in dictsList_tags_filtered if item['monitored'] == 'True'] + else: + dictsList_monitored_filtered = dictsList_tags_filtered + + # Filter series type + if type == 'series': + dictsList_types_filtered = [item for item in dictsList_monitored_filtered if item['seriesType'] not in + ast.literal_eval(settings.sonarr.excluded_series_types)] else: - dictsList_tags_monitored = dictsList_tags_filtered - return dictsList_tags_monitored + dictsList_types_filtered = dictsList_monitored_filtered + + return dictsList_types_filtered diff --git a/bazarr/get_series.py b/bazarr/get_series.py index 29367346b..fb263ff8f 100644 --- a/bazarr/get_series.py +++ b/bazarr/get_series.py @@ -98,7 +98,8 @@ def update_series(): 'sortTitle': show['sortTitle'], 'year': str(show['year']), 'alternateTitles': alternate_titles, - 'tags': str(tags)}) + 'tags': str(tags), + 'seriesType': show['seriesType']}) else: series_to_add.append({'title': show["title"], 'path': show["path"], @@ -114,7 +115,8 @@ def update_series(): 'year': str(show['year']), 'alternateTitles': alternate_titles, 'forced': serie_default_forced, - 'tags': str(tags)}) + 'tags': str(tags), + 'seriesType': show['seriesType']}) # Remove old series from DB removed_series = list(set(current_shows_db_list) - set(current_shows_sonarr)) @@ -126,7 +128,7 @@ def update_series(): # Update existing series in DB series_in_db_list = [] series_in_db = database.execute("SELECT title, path, tvdbId, sonarrSeriesId, overview, poster, fanart, " - "audio_language, sortTitle, year, alternateTitles, tags FROM table_shows") + "audio_language, sortTitle, year, alternateTitles, tags, seriesType FROM table_shows") for item in series_in_db: series_in_db_list.append(item) diff --git a/bazarr/get_subtitle.py b/bazarr/get_subtitle.py index 9bbfcbeda..7d7112b89 100644 --- a/bazarr/get_subtitle.py +++ b/bazarr/get_subtitle.py @@ -631,10 +631,10 @@ def manual_upload_subtitle(path, language, forced, title, scene_name, media_type def series_download_subtitles(no): episodes_details = database.execute("SELECT table_episodes.path, table_episodes.missing_subtitles, monitored, " - "table_episodes.sonarrEpisodeId, table_episodes.scene_name, table_shows.tags " - "FROM table_episodes INNER JOIN table_shows on table_shows.sonarrSeriesId = " - "table_episodes.sonarrSeriesId WHERE table_episodes.sonarrSeriesId=? and " - "missing_subtitles!='[]'", (no,)) + "table_episodes.sonarrEpisodeId, table_episodes.scene_name, table_shows.tags, " + "table_shows.seriesType FROM table_episodes INNER JOIN table_shows on " + "table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId WHERE " + "table_episodes.sonarrSeriesId=? and missing_subtitles!='[]'", (no,)) episodes_details = filter_exclusions(episodes_details, 'series') if not episodes_details: logging.debug("BAZARR no episode for that sonarrSeriesId can be found in database:", str(no)) @@ -685,9 +685,9 @@ def episode_download_subtitles(no): episodes_details = database.execute("SELECT table_episodes.path, table_episodes.missing_subtitles, monitored, " "table_episodes.sonarrEpisodeId, table_episodes.scene_name, table_shows.tags, " "table_shows.hearing_impaired, table_shows.title, table_shows.sonarrSeriesId, " - "table_shows.forced, table_shows.audio_language FROM table_episodes LEFT JOIN " - "table_shows on table_episodes.sonarrSeriesId = table_shows.sonarrSeriesId " - "WHERE sonarrEpisodeId=?", (no,)) + "table_shows.forced, table_shows.audio_language, table_shows.seriesType FROM " + "table_episodes LEFT JOIN table_shows on table_episodes.sonarrSeriesId = " + "table_shows.sonarrSeriesId WHERE sonarrEpisodeId=?", (no,)) episodes_details = filter_exclusions(episodes_details, 'series') if not episodes_details: logging.debug("BAZARR no episode with that sonarrEpisodeId can be found in database:", str(no)) @@ -887,9 +887,10 @@ def wanted_download_subtitles_movie(path, l, count_movies): def wanted_search_missing_subtitles_series(): - episodes = database.execute("SELECT table_episodes.path, table_shows.tags, table_episodes.monitored FROM " - "table_episodes INNER JOIN table_shows on table_shows.sonarrSeriesId = " - "table_episodes.sonarrSeriesId WHERE missing_subtitles != '[]'") + episodes = database.execute("SELECT table_episodes.path, table_shows.tags, table_episodes.monitored, " + "table_shows.seriesType FROM table_episodes INNER JOIN table_shows on " + "table_shows.sonarrSeriesId = table_episodes.sonarrSeriesId WHERE missing_subtitles != " + "'[]'") episodes = filter_exclusions(episodes, 'series') # path_replace dict_mapper.path_replace(episodes) @@ -1048,12 +1049,12 @@ def upgrade_subtitles(): if settings.general.getboolean('use_sonarr'): upgradable_episodes = database.execute("SELECT table_history.video_path, table_history.language, " - "table_history.score, table_shows.hearing_impaired, table_shows.audio_language, " - "table_episodes.scene_name, table_episodes.title," + "table_history.score, table_shows.hearing_impaired, " + "table_shows.audio_language, table_episodes.scene_name, table_episodes.title," "table_episodes.sonarrSeriesId, table_episodes.sonarrEpisodeId," "MAX(table_history.timestamp) as timestamp, table_episodes.monitored, " - "table_shows.languages, table_shows.forced, table_shows.tags " - "FROM table_history INNER JOIN table_shows on " + "table_shows.languages, table_shows.forced, table_shows.tags, " + "table_shows.seriesType FROM table_history INNER JOIN table_shows on " "table_shows.sonarrSeriesId = table_history.sonarrSeriesId INNER JOIN " "table_episodes on table_episodes.sonarrEpisodeId = " "table_history.sonarrEpisodeId WHERE action IN " diff --git a/static/css/tagsinput.css b/static/css/tagsinput.css new file mode 100644 index 000000000..c2e6e3526 --- /dev/null +++ b/static/css/tagsinput.css @@ -0,0 +1,103 @@ +/* + * bootstrap-tagsinput v0.8.0 + * + */ + +.bootstrap-tagsinput { + background-color: #fff; + border: 1px solid #ccc; + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + display: inline-block; + padding: 4px 6px; + color: #555; + vertical-align: middle; + border-radius: 4px; + width: 100%; + line-height: 22px; + cursor: text; +} +.bootstrap-tagsinput input { + border: none; + box-shadow: none; + outline: none; + background-color: transparent; + padding: 0 6px; + margin: 0; + width: auto; + max-width: inherit; +} +.bootstrap-tagsinput.form-control input::-moz-placeholder { + color: #777; + opacity: 1; +} +.bootstrap-tagsinput.form-control input:-ms-input-placeholder { + color: #777; +} +.bootstrap-tagsinput.form-control input::-webkit-input-placeholder { + color: #777; +} +.bootstrap-tagsinput input:focus { + border: none; + box-shadow: none; +} +.bootstrap-tagsinput .badge { + margin: 2px 0; + padding:5px 8px; +} +.bootstrap-tagsinput .badge [data-role="remove"] { + margin-left: 8px; + cursor: pointer; +} +.bootstrap-tagsinput .badge [data-role="remove"]:after { + content: "×"; + padding: 0px 4px; + background-color:rgba(0, 0, 0, 0.1); + border-radius:50%; + font-size:13px +} +.bootstrap-tagsinput .badge [data-role="remove"]:hover:after { + + background-color:rgba(0, 0, 0, 0.62);} +.bootstrap-tagsinput .badge [data-role="remove"]:hover:active { + box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125); +} + +.tt-menu { + position: absolute; + top: 100%; + left: 0; + z-index: 1000; + display: none; + float: left; + min-width: 160px; + padding: 5px 0; + margin: 2px 0 0; + list-style: none; + font-size: 14px; + background-color: #ffffff; + border: 1px solid #cccccc; + border: 1px solid rgba(0, 0, 0, 0.15); + border-radius: 4px; + -webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175); + box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175); + background-clip: padding-box; + cursor: pointer; +} + +.tt-suggestion { + display: block; + padding: 3px 20px; + clear: both; + font-weight: normal; + line-height: 1.428571429; + color: #333333; + white-space: nowrap; +} + +.tt-suggestion:hover, +.tt-suggestion:focus { + color: #ffffff; + text-decoration: none; + outline: 0; + background-color: #428bca; +} diff --git a/static/js/tagsinput.js b/static/js/tagsinput.js new file mode 100644 index 000000000..7afb3c928 --- /dev/null +++ b/static/js/tagsinput.js @@ -0,0 +1,691 @@ +/* + * bootstrap-tagsinput v0.8.0 + * + */ + +(function ($) { + "use strict"; + + var defaultOptions = { + tagClass: function(item) { + return 'badge badge-info'; + }, + focusClass: 'focus', + itemValue: function(item) { + return item ? item.toString() : item; + }, + itemText: function(item) { + return this.itemValue(item); + }, + itemTitle: function(item) { + return null; + }, + freeInput: true, + addOnBlur: true, + maxTags: undefined, + maxChars: undefined, + confirmKeys: [13, 44], + delimiter: ',', + delimiterRegex: null, + cancelConfirmKeysOnEmpty: false, + onTagExists: function(item, $tag) { + $tag.hide().fadeIn(); + }, + trimValue: false, + allowDuplicates: false, + triggerChange: true, + editOnBackspace: false + }; + + /** + * Constructor function + */ + function TagsInput(element, options) { + this.isInit = true; + this.itemsArray = []; + + this.$element = $(element); + this.$element.addClass('sr-only'); + + this.isSelect = (element.tagName === 'SELECT'); + this.multiple = (this.isSelect && element.hasAttribute('multiple')); + this.objectItems = options && options.itemValue; + this.placeholderText = element.hasAttribute('placeholder') ? this.$element.attr('placeholder') : ''; + this.inputSize = Math.max(1, this.placeholderText.length); + + this.$container = $('
'); + this.$input = $('').appendTo(this.$container); + + this.$element.before(this.$container); + + this.build(options); + this.isInit = false; + } + + TagsInput.prototype = { + constructor: TagsInput, + + /** + * Adds the given item as a new tag. Pass true to dontPushVal to prevent + * updating the elements val() + */ + add: function(item, dontPushVal, options) { + var self = this; + + if (self.options.maxTags && self.itemsArray.length >= self.options.maxTags) + return; + + // Ignore falsey values, except false + if (item !== false && !item) + return; + + // Trim value + if (typeof item === "string" && self.options.trimValue) { + item = $.trim(item); + } + + // Throw an error when trying to add an object while the itemValue option was not set + if (typeof item === "object" && !self.objectItems) + throw("Can't add objects when itemValue option is not set"); + + // Ignore strings only containg whitespace + if (item.toString().match(/^\s*$/)) + return; + + // If SELECT but not multiple, remove current tag + if (self.isSelect && !self.multiple && self.itemsArray.length > 0) + self.remove(self.itemsArray[0]); + + if (typeof item === "string" && this.$element[0].tagName === 'INPUT') { + var delimiter = (self.options.delimiterRegex) ? self.options.delimiterRegex : self.options.delimiter; + var items = item.split(delimiter); + if (items.length > 1) { + for (var i = 0; i < items.length; i++) { + this.add(items[i], true); + } + + if (!dontPushVal) + self.pushVal(self.options.triggerChange); + return; + } + } + + var itemValue = self.options.itemValue(item), + itemText = self.options.itemText(item), + tagClass = self.options.tagClass(item), + itemTitle = self.options.itemTitle(item); + + // Ignore items allready added + var existing = $.grep(self.itemsArray, function(item) { return self.options.itemValue(item) === itemValue; } )[0]; + if (existing && !self.options.allowDuplicates) { + // Invoke onTagExists + if (self.options.onTagExists) { + var $existingTag = $(".badge", self.$container).filter(function() { return $(this).data("item") === existing; }); + self.options.onTagExists(item, $existingTag); + } + return; + } + + // if length greater than limit + if (self.items().toString().length + item.length + 1 > self.options.maxInputLength) + return; + + // raise beforeItemAdd arg + var beforeItemAddEvent = $.Event('beforeItemAdd', { item: item, cancel: false, options: options}); + self.$element.trigger(beforeItemAddEvent); + if (beforeItemAddEvent.cancel) + return; + + // register item in internal array and map + self.itemsArray.push(item); + + // add a tag element + + var $tag = $('' + htmlEncode(itemText) + ''); + $tag.data('item', item); + self.findInputWrapper().before($tag); + + // Check to see if the tag exists in its raw or uri-encoded form + var optionExists = ( + $('option[value="' + encodeURIComponent(itemValue).replace(/"/g, '\\"') + '"]', self.$element).length || + $('option[value="' + htmlEncode(itemValue).replace(/"/g, '\\"') + '"]', self.$element).length + ); + + // add if item represents a value not present in one of the 's options + if (self.isSelect && !optionExists) { + var $option = $(''); + $option.data('item', item); + $option.attr('value', itemValue); + self.$element.append($option); + } + + if (!dontPushVal) + self.pushVal(self.options.triggerChange); + + // Add class when reached maxTags + if (self.options.maxTags === self.itemsArray.length || self.items().toString().length === self.options.maxInputLength) + self.$container.addClass('bootstrap-tagsinput-max'); + + // If using typeahead, once the tag has been added, clear the typeahead value so it does not stick around in the input. + if ($('.typeahead, .twitter-typeahead', self.$container).length) { + self.$input.typeahead('val', ''); + } + + if (this.isInit) { + self.$element.trigger($.Event('itemAddedOnInit', { item: item, options: options })); + } else { + self.$element.trigger($.Event('itemAdded', { item: item, options: options })); + } + }, + + /** + * Removes the given item. Pass true to dontPushVal to prevent updating the + * elements val() + */ + remove: function(item, dontPushVal, options) { + var self = this; + + if (self.objectItems) { + if (typeof item === "object") + item = $.grep(self.itemsArray, function(other) { return self.options.itemValue(other) == self.options.itemValue(item); } ); + else + item = $.grep(self.itemsArray, function(other) { return self.options.itemValue(other) == item; } ); + + item = item[item.length-1]; + } + + if (item) { + var beforeItemRemoveEvent = $.Event('beforeItemRemove', { item: item, cancel: false, options: options }); + self.$element.trigger(beforeItemRemoveEvent); + if (beforeItemRemoveEvent.cancel) + return; + + $('.badge', self.$container).filter(function() { return $(this).data('item') === item; }).remove(); + $('option', self.$element).filter(function() { return $(this).data('item') === item; }).remove(); + if($.inArray(item, self.itemsArray) !== -1) + self.itemsArray.splice($.inArray(item, self.itemsArray), 1); + } + + if (!dontPushVal) + self.pushVal(self.options.triggerChange); + + // Remove class when reached maxTags + if (self.options.maxTags > self.itemsArray.length) + self.$container.removeClass('bootstrap-tagsinput-max'); + + self.$element.trigger($.Event('itemRemoved', { item: item, options: options })); + }, + + /** + * Removes all items + */ + removeAll: function() { + var self = this; + + $('.badge', self.$container).remove(); + $('option', self.$element).remove(); + + while(self.itemsArray.length > 0) + self.itemsArray.pop(); + + self.pushVal(self.options.triggerChange); + }, + + /** + * Refreshes the tags so they match the text/value of their corresponding + * item. + */ + refresh: function() { + var self = this; + $('.badge', self.$container).each(function() { + var $tag = $(this), + item = $tag.data('item'), + itemValue = self.options.itemValue(item), + itemText = self.options.itemText(item), + tagClass = self.options.tagClass(item); + + // Update tag's class and inner text + $tag.attr('class', null); + $tag.addClass('badge ' + htmlEncode(tagClass)); + $tag.contents().filter(function() { + return this.nodeType == 3; + })[0].nodeValue = htmlEncode(itemText); + + if (self.isSelect) { + var option = $('option', self.$element).filter(function() { return $(this).data('item') === item; }); + option.attr('value', itemValue); + } + }); + }, + + /** + * Returns the items added as tags + */ + items: function() { + return this.itemsArray; + }, + + /** + * Assembly value by retrieving the value of each item, and set it on the + * element. + */ + pushVal: function() { + var self = this, + val = $.map(self.items(), function(item) { + return self.options.itemValue(item).toString(); + }); + + self.$element.val( val.join(self.options.delimiter) ); + + if (self.options.triggerChange) + self.$element.trigger('change'); + }, + + /** + * Initializes the tags input behaviour on the element + */ + build: function(options) { + var self = this; + + self.options = $.extend({}, defaultOptions, options); + // When itemValue is set, freeInput should always be false + if (self.objectItems) + self.options.freeInput = false; + + makeOptionItemFunction(self.options, 'itemValue'); + makeOptionItemFunction(self.options, 'itemText'); + makeOptionFunction(self.options, 'tagClass'); + + // Typeahead Bootstrap version 2.3.2 + if (self.options.typeahead) { + var typeahead = self.options.typeahead || {}; + + makeOptionFunction(typeahead, 'source'); + + self.$input.typeahead($.extend({}, typeahead, { + source: function (query, process) { + function processItems(items) { + var texts = []; + + for (var i = 0; i < items.length; i++) { + var text = self.options.itemText(items[i]); + map[text] = items[i]; + texts.push(text); + } + process(texts); + } + + this.map = {}; + var map = this.map, + data = typeahead.source(query); + + if ($.isFunction(data.success)) { + // support for Angular callbacks + data.success(processItems); + } else if ($.isFunction(data.then)) { + // support for Angular promises + data.then(processItems); + } else { + // support for functions and jquery promises + $.when(data) + .then(processItems); + } + }, + updater: function (text) { + self.add(this.map[text]); + return this.map[text]; + }, + matcher: function (text) { + return (text.toLowerCase().indexOf(this.query.trim().toLowerCase()) !== -1); + }, + sorter: function (texts) { + return texts.sort(); + }, + highlighter: function (text) { + var regex = new RegExp( '(' + this.query + ')', 'gi' ); + return text.replace( regex, "$1" ); + } + })); + } + + // typeahead.js + if (self.options.typeaheadjs) { + // Determine if main configurations were passed or simply a dataset + var typeaheadjs = self.options.typeaheadjs; + if (!$.isArray(typeaheadjs)) { + typeaheadjs = [null, typeaheadjs]; + } + + $.fn.typeahead.apply(self.$input, typeaheadjs).on('typeahead:selected', $.proxy(function (obj, datum, name) { + var index = 0; + typeaheadjs.some(function(dataset, _index) { + if (dataset.name === name) { + index = _index; + return true; + } + return false; + }); + + // @TODO Dep: https://github.com/corejavascript/typeahead.js/issues/89 + if (typeaheadjs[index].valueKey) { + self.add(datum[typeaheadjs[index].valueKey]); + } else { + self.add(datum); + } + + self.$input.typeahead('val', ''); + }, self)); + } + + self.$container.on('click', $.proxy(function(event) { + if (! self.$element.attr('disabled')) { + self.$input.removeAttr('disabled'); + } + self.$input.focus(); + }, self)); + + if (self.options.addOnBlur && self.options.freeInput) { + self.$input.on('focusout', $.proxy(function(event) { + // HACK: only process on focusout when no typeahead opened, to + // avoid adding the typeahead text as tag + if ($('.typeahead, .twitter-typeahead', self.$container).length === 0) { + self.add(self.$input.val()); + self.$input.val(''); + } + }, self)); + } + + // Toggle the 'focus' css class on the container when it has focus + self.$container.on({ + focusin: function() { + self.$container.addClass(self.options.focusClass); + }, + focusout: function() { + self.$container.removeClass(self.options.focusClass); + }, + }); + + self.$container.on('keydown', 'input', $.proxy(function(event) { + var $input = $(event.target), + $inputWrapper = self.findInputWrapper(); + + if (self.$element.attr('disabled')) { + self.$input.attr('disabled', 'disabled'); + return; + } + + switch (event.which) { + // BACKSPACE + case 8: + if (doGetCaretPosition($input[0]) === 0) { + var prev = $inputWrapper.prev(); + if (prev.length) { + if (self.options.editOnBackspace === true) { + $input.val(prev.data('item')); + } + self.remove(prev.data('item')); + } + } + break; + + // DELETE + case 46: + if (doGetCaretPosition($input[0]) === 0) { + var next = $inputWrapper.next(); + if (next.length) { + self.remove(next.data('item')); + } + } + break; + + // LEFT ARROW + case 37: + // Try to move the input before the previous tag + var $prevTag = $inputWrapper.prev(); + if ($input.val().length === 0 && $prevTag[0]) { + $prevTag.before($inputWrapper); + $input.focus(); + } + break; + // RIGHT ARROW + case 39: + // Try to move the input after the next tag + var $nextTag = $inputWrapper.next(); + if ($input.val().length === 0 && $nextTag[0]) { + $nextTag.after($inputWrapper); + $input.focus(); + } + break; + default: + // ignore + } + + // Reset internal input's size + var textLength = $input.val().length, + wordSpace = Math.ceil(textLength / 5), + size = textLength + wordSpace + 1; + $input.attr('size', Math.max(this.inputSize, size)); + }, self)); + + self.$container.on('keypress', 'input', $.proxy(function(event) { + var $input = $(event.target); + + if (self.$element.attr('disabled')) { + self.$input.attr('disabled', 'disabled'); + return; + } + + var text = $input.val(), + maxLengthReached = self.options.maxChars && text.length >= self.options.maxChars; + if (self.options.freeInput && (keyCombinationInList(event, self.options.confirmKeys) || maxLengthReached)) { + // Only attempt to add a tag if there is data in the field + if (text.length !== 0) { + self.add(maxLengthReached ? text.substr(0, self.options.maxChars) : text); + $input.val(''); + } + + // If the field is empty, let the event triggered fire as usual + if (self.options.cancelConfirmKeysOnEmpty === false) { + event.preventDefault(); + } + } + + // Reset internal input's size + var textLength = $input.val().length, + wordSpace = Math.ceil(textLength / 5), + size = textLength + wordSpace + 1; + $input.attr('size', Math.max(this.inputSize, size)); + }, self)); + + // Remove icon clicked + self.$container.on('click', '[data-role=remove]', $.proxy(function(event) { + if (self.$element.attr('disabled')) { + return; + } + self.remove($(event.target).closest('.badge').data('item')); + }, self)); + + // Only add existing value as tags when using strings as tags + if (self.options.itemValue === defaultOptions.itemValue) { + if (self.$element[0].tagName === 'INPUT') { + self.add(self.$element.val()); + } else { + $('option', self.$element).each(function() { + self.add($(this).attr('value'), true); + }); + } + } + }, + + /** + * Removes all tagsinput behaviour and unregsiter all event handlers + */ + destroy: function() { + var self = this; + + // Unbind events + self.$container.off('keypress', 'input'); + self.$container.off('click', '[role=remove]'); + + self.$container.remove(); + self.$element.removeData('tagsinput'); + self.$element.show(); + }, + + /** + * Sets focus on the tagsinput + */ + focus: function() { + this.$input.focus(); + }, + + /** + * Returns the internal input element + */ + input: function() { + return this.$input; + }, + + /** + * Returns the element which is wrapped around the internal input. This + * is normally the $container, but typeahead.js moves the $input element. + */ + findInputWrapper: function() { + var elt = this.$input[0], + container = this.$container[0]; + while(elt && elt.parentNode !== container) + elt = elt.parentNode; + + return $(elt); + } + }; + + /** + * Register JQuery plugin + */ + $.fn.tagsinput = function(arg1, arg2, arg3) { + var results = []; + + this.each(function() { + var tagsinput = $(this).data('tagsinput'); + // Initialize a new tags input + if (!tagsinput) { + tagsinput = new TagsInput(this, arg1); + $(this).data('tagsinput', tagsinput); + results.push(tagsinput); + + if (this.tagName === 'SELECT') { + $('option', $(this)).attr('selected', 'selected'); + } + + // Init tags from $(this).val() + $(this).val($(this).val()); + } else if (!arg1 && !arg2) { + // tagsinput already exists + // no function, trying to init + results.push(tagsinput); + } else if(tagsinput[arg1] !== undefined) { + // Invoke function on existing tags input + if(tagsinput[arg1].length === 3 && arg3 !== undefined){ + var retVal = tagsinput[arg1](arg2, null, arg3); + }else{ + var retVal = tagsinput[arg1](arg2); + } + if (retVal !== undefined) + results.push(retVal); + } + }); + + if ( typeof arg1 == 'string') { + // Return the results from the invoked function calls + return results.length > 1 ? results : results[0]; + } else { + return results; + } + }; + + $.fn.tagsinput.Constructor = TagsInput; + + /** + * Most options support both a string or number as well as a function as + * option value. This function makes sure that the option with the given + * key in the given options is wrapped in a function + */ + function makeOptionItemFunction(options, key) { + if (typeof options[key] !== 'function') { + var propertyName = options[key]; + options[key] = function(item) { return item[propertyName]; }; + } + } + function makeOptionFunction(options, key) { + if (typeof options[key] !== 'function') { + var value = options[key]; + options[key] = function() { return value; }; + } + } + /** + * HtmlEncodes the given value + */ + var htmlEncodeContainer = $(''); + function htmlEncode(value) { + if (value) { + return htmlEncodeContainer.text(value).html(); + } else { + return ''; + } + } + + /** + * Returns the position of the caret in the given input field + * http://flightschool.acylt.com/devnotes/caret-position-woes/ + */ + function doGetCaretPosition(oField) { + var iCaretPos = 0; + if (document.selection) { + oField.focus (); + var oSel = document.selection.createRange(); + oSel.moveStart ('character', -oField.value.length); + iCaretPos = oSel.text.length; + } else if (oField.selectionStart || oField.selectionStart == '0') { + iCaretPos = oField.selectionStart; + } + return (iCaretPos); + } + + /** + * Returns boolean indicates whether user has pressed an expected key combination. + * @param object keyPressEvent: JavaScript event object, refer + * http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html + * @param object lookupList: expected key combinations, as in: + * [13, {which: 188, shiftKey: true}] + */ + function keyCombinationInList(keyPressEvent, lookupList) { + var found = false; + $.each(lookupList, function (index, keyCombination) { + if (typeof (keyCombination) === 'number' && keyPressEvent.which === keyCombination) { + found = true; + return false; + } + + if (keyPressEvent.which === keyCombination.which) { + var alt = !keyCombination.hasOwnProperty('altKey') || keyPressEvent.altKey === keyCombination.altKey, + shift = !keyCombination.hasOwnProperty('shiftKey') || keyPressEvent.shiftKey === keyCombination.shiftKey, + ctrl = !keyCombination.hasOwnProperty('ctrlKey') || keyPressEvent.ctrlKey === keyCombination.ctrlKey; + if (alt && shift && ctrl) { + found = true; + return false; + } + } + }); + + return found; + } + + /** + * Initialize tagsinput behaviour on inputs and selects which have + * data-role=tagsinput + */ + $(function() { + $("input[data-role=tagsinput], select[multiple][data-role=tagsinput]").tagsinput(); + }); +})(window.jQuery); diff --git a/views/episodes.html b/views/episodes.html index f07fef6d9..c338b2201 100644 --- a/views/episodes.html +++ b/views/episodes.html @@ -82,6 +82,7 @@