ui v1

frontend/src/Components/Form/FormInputGroup.js

@@ -14,6 +14,7 @@ import PasswordInput from './PasswordInput';
 import PathInputConnector from './PathInputConnector';
 import QualityProfileSelectInputConnector from './QualityProfileSelectInputConnector';
 import LanguageProfileSelectInputConnector from './LanguageProfileSelectInputConnector';
+import IndexerSelectInputConnector from './IndexerSelectInputConnector';
 import RootFolderSelectInputConnector from './RootFolderSelectInputConnector';
 import SeriesTypeSelectInput from './SeriesTypeSelectInput';
 import EnhancedSelectInput from './EnhancedSelectInput';
@@ -61,6 +62,9 @@ function getComponent(type) {
     case inputTypes.LANGUAGE_PROFILE_SELECT:
       return LanguageProfileSelectInputConnector;
 
+    case inputTypes.INDEXER_SELECT:
+      return IndexerSelectInputConnector;
+
     case inputTypes.ROOT_FOLDER_SELECT:
       return RootFolderSelectInputConnector;
 

frontend/src/Components/Form/IndexerSelectInputConnector.js

@@ -0,0 +1,98 @@
+import _ from 'lodash';
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import { connect } from 'react-redux';
+import { createSelector } from 'reselect';
+import sortByName from 'Utilities/Array/sortByName';
+import SelectInput from './SelectInput';
+
+function createMapStateToProps() {
+  return createSelector(
+    (state) => state.settings.indexers,
+    (state, { includeNoChange }) => includeNoChange,
+    (state, { includeMixed }) => includeMixed,
+    (indexers, includeNoChange, includeMixed) => {
+      const values = _.map(indexers.items.sort(sortByName), (indexer) => {
+        return {
+          key: indexer.id,
+          value: indexer.name
+        };
+      });
+
+      if (includeNoChange) {
+        values.unshift({
+          key: 'noChange',
+          value: 'No Change',
+          disabled: true
+        });
+      }
+
+      if (includeMixed) {
+        values.unshift({
+          key: 'mixed',
+          value: '(Mixed)',
+          disabled: true
+        });
+      }
+
+      return {
+        values
+      };
+    }
+  );
+}
+
+class IndexerSelectInputConnector extends Component {
+
+  //
+  // Lifecycle
+
+  componentDidMount() {
+    const {
+      name,
+      value,
+      values
+    } = this.props;
+
+    if (!value || !_.some(values, (option) => parseInt(option.key) === value)) {
+      const firstValue = _.find(values, (option) => !isNaN(parseInt(option.key)));
+
+      if (firstValue) {
+        this.onChange({ name, value: firstValue.key });
+      }
+    }
+  }
+
+  //
+  // Listeners
+
+  onChange = ({ name, value }) => {
+    this.props.onChange({ name, value: parseInt(value) });
+  }
+
+  //
+  // Render
+
+  render() {
+    return (
+      <SelectInput
+        {...this.props}
+        onChange={this.onChange}
+      />
+    );
+  }
+}
+
+IndexerSelectInputConnector.propTypes = {
+  name: PropTypes.string.isRequired,
+  value: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  values: PropTypes.arrayOf(PropTypes.object).isRequired,
+  includeNoChange: PropTypes.bool.isRequired,
+  onChange: PropTypes.func.isRequired
+};
+
+IndexerSelectInputConnector.defaultProps = {
+  includeNoChange: false
+};
+
+export default connect(createMapStateToProps)(IndexerSelectInputConnector);

frontend/src/Helpers/Props/inputTypes.js

@@ -10,6 +10,7 @@ export const PASSWORD = 'password';
 export const PATH = 'path';
 export const QUALITY_PROFILE_SELECT = 'qualityProfileSelect';
 export const LANGUAGE_PROFILE_SELECT = 'languageProfileSelect';
+export const INDEXER_SELECT = 'indexerSelect';
 export const ROOT_FOLDER_SELECT = 'rootFolderSelect';
 export const SELECT = 'select';
 export const SERIES_TYPE_SELECT = 'seriesTypeSelect';
@@ -30,6 +31,7 @@ export const all = [
   PATH,
   QUALITY_PROFILE_SELECT,
   LANGUAGE_PROFILE_SELECT,
+  INDEXER_SELECT,
   ROOT_FOLDER_SELECT,
   SELECT,
   SERIES_TYPE_SELECT,

frontend/src/Settings/Profiles/Release/EditReleaseProfileModalContent.js

@@ -30,9 +30,11 @@ function EditReleaseProfileModalContent(props) {
 
   const {
     id,
+    enabled,
     required,
     ignored,
     preferred,
+    indexerId,
     includePreferredWhenRenaming,
     tags
   } = item;
@@ -45,6 +47,18 @@ function EditReleaseProfileModalContent(props) {
 
       <ModalBody>
         <Form {...otherProps}>
+          <FormGroup>
+            <FormLabel>Enable Profile</FormLabel>
+
+            <FormInputGroup
+              type={inputTypes.CHECK}
+              name="enabled"
+              helpText="Check to enable release profile"
+              {...enabled}
+              onChange={onInputChange}
+            />
+          </FormGroup>
+
           <FormGroup>
             <FormLabel>Must Contain</FormLabel>
 
@@ -105,6 +119,18 @@ function EditReleaseProfileModalContent(props) {
             />
           </FormGroup>
 
+          <FormGroup>
+            <FormLabel>Indexer</FormLabel>
+
+            <FormInputGroup
+              type={inputTypes.INDEXER_SELECT}
+              name="indexerId"
+              helpText="Specify what indexer the profile applies to"
+              {...indexerId}
+              onChange={onInputChange}
+            />
+          </FormGroup>
+
           <FormGroup>
             <FormLabel>Tags</FormLabel>
 

frontend/src/Settings/Profiles/Release/EditReleaseProfileModalContentConnector.js

@@ -8,10 +8,12 @@ import { setReleaseProfileValue, saveReleaseProfile } from 'Store/Actions/settin
 import EditReleaseProfileModalContent from './EditReleaseProfileModalContent';
 
 const newReleaseProfile = {
+  enabled: false,
   required: '',
   ignored: '',
   preferred: [],
   includePreferredWhenRenaming: false,
+  indexer: 0,
   tags: []
 };
 

frontend/src/Store/Selectors/createIndexerSelector.js

@@ -0,0 +1,15 @@
+import { createSelector } from 'reselect';
+
+function createIndexerSelector() {
+  return createSelector(
+    (state, { indexerId }) => indexerId,
+    (state) => state.settings.indexers.items,
+    (indexerId, indexers) => {
+      return indexers.find((profile) => {
+        return profile.id === indexerId;
+      });
+    }
+  );
+}
+
+export default createIndexerSelector;

src/NzbDrone.Core.Test/Profiles/Releases/PreferredWordService/CalculateFixture.cs

@@ -55,7 +55,7 @@ namespace NzbDrone.Core.Test.Profiles.Releases.PreferredWordService
                   .Setup(s => s.AllForTags(It.IsAny<HashSet<int>>()))
                   .Returns(new List<ReleaseProfile>());
 
-            Subject.Calculate(_series, _title).Should().Be(0);
+            Subject.Calculate(_series, _title, 0).Should().Be(0);
         }
 
         [Test]
@@ -63,7 +63,7 @@ namespace NzbDrone.Core.Test.Profiles.Releases.PreferredWordService
         {
             GivenMatchingTerms();
 
-            Subject.Calculate(_series, _title).Should().Be(0);
+            Subject.Calculate(_series, _title, 0).Should().Be(0);
         }
 
         [Test]
@@ -71,7 +71,7 @@ namespace NzbDrone.Core.Test.Profiles.Releases.PreferredWordService
         {
             GivenMatchingTerms("x264");
 
-            Subject.Calculate(_series, _title).Should().Be(5);
+            Subject.Calculate(_series, _title, 0).Should().Be(5);
         }
 
         [Test]
@@ -79,7 +79,7 @@ namespace NzbDrone.Core.Test.Profiles.Releases.PreferredWordService
         {
             GivenMatchingTerms("x265");
 
-            Subject.Calculate(_series, _title).Should().Be(-10);
+            Subject.Calculate(_series, _title, 0).Should().Be(-10);
         }
 
         [Test]
@@ -89,7 +89,7 @@ namespace NzbDrone.Core.Test.Profiles.Releases.PreferredWordService
 
             GivenMatchingTerms("x264");
 
-            Subject.Calculate(_series, _title).Should().Be(10);
+            Subject.Calculate(_series, _title, 0).Should().Be(10);
         }
     }
 }

src/NzbDrone.Core/Datastore/Migration/136_add_indexer_and_enabled_release_profiles.cs

@@ -0,0 +1,15 @@
+using FluentMigrator;
+using NzbDrone.Core.Datastore.Migration.Framework;
+
+namespace NzbDrone.Core.Datastore.Migration
+{
+    [Migration(136)]
+    public class add_indexer_and_enabled_to_release_profiles : NzbDroneMigrationBase
+    {
+        protected override void MainDbUpgrade()
+        {
+            Alter.Table("ReleaseProfiles").AddColumn("Enabled").AsBoolean().WithDefaultValue(true);
+            Alter.Table("ReleaseProfiles").AddColumn("IndexerId").AsInt32().WithDefaultValue(0);
+        }
+    }
+}

src/NzbDrone.Core/DecisionEngine/Specifications/CutoffSpecification.cs

@@ -41,7 +41,7 @@ namespace NzbDrone.Core.DecisionEngine.Specifications
                                                            languageProfile, 
                                                            file.Quality, 
                                                            file.Language,
-                                                           _preferredWordServiceCalculator.Calculate(subject.Series, file.GetSceneOrFileName()),
+                                                           _preferredWordServiceCalculator.Calculate(subject.Series, file.GetSceneOrFileName(), subject.Release.IndexerId),
                                                            subject.ParsedEpisodeInfo.Quality,
                                                            subject.PreferredWordScore))
                 {

src/NzbDrone.Core/DecisionEngine/Specifications/QueueSpecification.cs

@@ -53,7 +53,7 @@ namespace NzbDrone.Core.DecisionEngine.Specifications
                 }
 
                 _logger.Debug("Checking if existing release in queue meets cutoff. Queued: {0} - {1}", remoteEpisode.ParsedEpisodeInfo.Quality, remoteEpisode.ParsedEpisodeInfo.Language);
-                var queuedItemPreferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Series, queueItem.Title);
+                var queuedItemPreferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Series, queueItem.Title, subject.Release.IndexerId);
 
                 if (!_upgradableSpecification.CutoffNotMet(qualityProfile,
                     languageProfile, 

src/NzbDrone.Core/DecisionEngine/Specifications/ReleaseRestrictionsSpecification.cs

@@ -1,6 +1,8 @@
 using System;
+using System.Reflection;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 using NLog;
 using NzbDrone.Common.Extensions;
 using NzbDrone.Core.IndexerSearch.Definitions;
@@ -15,6 +17,8 @@ namespace NzbDrone.Core.DecisionEngine.Specifications
         private readonly IReleaseProfileService _releaseProfileService;
         private readonly ITermMatcherService _termMatcherService;
 
+        private static readonly Regex keyValueRegex = new Regex(@"^([^:]+):([^:]+)$");
+
         public ReleaseRestrictionsSpecification(ITermMatcherService termMatcherService, IReleaseProfileService releaseProfileService, Logger logger)
         {
             _logger = logger;
@@ -30,16 +34,26 @@ namespace NzbDrone.Core.DecisionEngine.Specifications
             _logger.Debug("Checking if release meets restrictions: {0}", subject);
 
             var title = subject.Release.Title;
-            var restrictions = _releaseProfileService.AllForTags(subject.Series.Tags);
+            var releaseProfiles = _releaseProfileService.EnabledForTags(subject.Series.Tags, subject.Release.IndexerId);
 
-            var required = restrictions.Where(r => r.Required.IsNotNullOrWhiteSpace());
+            var required = releaseProfiles.Where(r => r.Required.IsNotNullOrWhiteSpace());
-            var ignored = restrictions.Where(r => r.Ignored.IsNotNullOrWhiteSpace());
+            var ignored = releaseProfiles.Where(r => r.Ignored.IsNotNullOrWhiteSpace());
 
             foreach (var r in required)
             {
                 var requiredTerms = r.Required.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
 
-                var foundTerms = ContainsAny(requiredTerms, title);
+                // separate key-value terms and normal terms
+                var reqKeyValues = requiredTerms.Where(kv => keyValueRegex.IsMatch(kv)).ToList();
+                var reqTitleTerms = requiredTerms.Where(t => !keyValueRegex.IsMatch(t)).ToList();
+
+                // check title terms
+                var foundTerms = ContainsAny(reqTitleTerms, title);
+
+                // check key-value terms
+                foundTerms.AddRange(ContainsAnyKeyValues(reqKeyValues, subject));
+
+
                 if (foundTerms.Empty())
                 {
                     var terms = string.Join(", ", requiredTerms);
@@ -48,11 +62,21 @@ namespace NzbDrone.Core.DecisionEngine.Specifications
                 }
             }
 
+
             foreach (var r in ignored)
             {
                 var ignoredTerms = r.Ignored.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
 
-                var foundTerms = ContainsAny(ignoredTerms, title);
+                // separate key-value terms and normal terms
+                var ignKeyValues = ignoredTerms.Where(kv => keyValueRegex.IsMatch(kv)).ToList();
+                var ignTitleTerms = ignoredTerms.Where(t => !keyValueRegex.IsMatch(t)).ToList();
+
+                // check title terms
+                var foundTerms = ContainsAny(ignTitleTerms, title);
+
+                // check key-value terms
+                foundTerms.AddRange(ContainsAnyKeyValues(ignKeyValues, subject));
+
                 if (foundTerms.Any())
                 {
                     var terms = string.Join(", ", foundTerms);
@@ -60,7 +84,6 @@ namespace NzbDrone.Core.DecisionEngine.Specifications
                     return Decision.Reject("Contains these ignored terms: {0}", terms);
                 }
             }
-
             _logger.Debug("[{0}] No restrictions apply, allowing", subject);
             return Decision.Accept();
         }
@@ -69,5 +92,34 @@ namespace NzbDrone.Core.DecisionEngine.Specifications
         {
             return terms.Where(t => _termMatcherService.IsMatch(t, title)).ToList();
         }
+
+        private List<string> ContainsAnyKeyValues(List<string> terms, RemoteEpisode subject)
+        {
+            var foundTerms = new List<string>(); 
+
+            foreach (var kv in terms)
+            {
+                var match = keyValueRegex.Match(kv);
+                var key = match.Groups[1].Value;
+                var value = match.Groups[2].Value;
+
+                try
+                {
+                    IReleaseFilter releaseFilter = Assembly.GetExecutingAssembly().
+                        CreateInstance("NzbDrone.Core.Profiles.Releases." + key + "ReleaseFilter", true) as IReleaseFilter;
+
+                    if (releaseFilter.Matches(value, subject))
+                    {
+                        foundTerms.Add(kv);
+                    }
+                }
+                catch (NullReferenceException)
+                {
+                    _logger.Debug("Unsupported key {0}", key);
+                }
+            }
+
+            return foundTerms;
+        }
     }
 }

src/NzbDrone.Core/DecisionEngine/Specifications/RssSync/HistorySpecification.cs

@@ -60,7 +60,7 @@ namespace NzbDrone.Core.DecisionEngine.Specifications.RssSync
 
                     // The series will be the same as the one in history since it's the same episode.
                     // Instead of fetching the series from the DB reuse the known series.
-                    var preferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Series, mostRecent.SourceTitle);
+                    var preferredWordScore = _preferredWordServiceCalculator.Calculate(subject.Series, mostRecent.SourceTitle, subject.Release.IndexerId);
 
                     var cutoffUnmet = _upgradableSpecification.CutoffNotMet(
                         subject.Series.QualityProfile,

src/NzbDrone.Core/DecisionEngine/Specifications/UpgradeDiskSpecification.cs

@@ -38,7 +38,7 @@ namespace NzbDrone.Core.DecisionEngine.Specifications
                                                            subject.Series.LanguageProfile, 
                                                            file.Quality, 
                                                            file.Language,
-                                                           _preferredWordServiceCalculator.Calculate(subject.Series, file.GetSceneOrFileName()),
+                                                           _preferredWordServiceCalculator.Calculate(subject.Series, file.GetSceneOrFileName(), subject.Release.IndexerId),
                                                            subject.ParsedEpisodeInfo.Quality, 
                                                            subject.ParsedEpisodeInfo.Language,
                                                            subject.PreferredWordScore))

src/NzbDrone.Core/Download/Aggregation/Aggregators/AggregatePreferredWordScore.cs

@@ -14,7 +14,7 @@ namespace NzbDrone.Core.Download.Aggregation.Aggregators
 
         public RemoteEpisode Aggregate(RemoteEpisode remoteEpisode)
         {
-            remoteEpisode.PreferredWordScore = _preferredWordServiceCalculator.Calculate(remoteEpisode.Series, remoteEpisode.Release.Title);
+            remoteEpisode.PreferredWordScore = _preferredWordServiceCalculator.Calculate(remoteEpisode.Series, remoteEpisode.Release.Title, remoteEpisode.Release.IndexerId);
 
             return remoteEpisode;
         }

src/NzbDrone.Core/Profiles/Releases/PreferredWordService.cs

@@ -8,7 +8,7 @@ namespace NzbDrone.Core.Profiles.Releases
 {
     public interface IPreferredWordService
     {
-        int Calculate(Series series, string title);
+        int Calculate(Series series, string title, int indexerId);
         List<string> GetMatchingPreferredWords(Series series, string title);
     }
 
@@ -25,11 +25,11 @@ namespace NzbDrone.Core.Profiles.Releases
             _logger = logger;
         }
 
-        public int Calculate(Series series, string title)
+        public int Calculate(Series series, string title, int indexerId)
         {
             _logger.Trace("Calculating preferred word score for '{0}'", title);
 
-            var releaseProfiles = _releaseProfileService.AllForTags(series.Tags);
+            var releaseProfiles = _releaseProfileService.EnabledForTags(series.Tags, indexerId);
             var matchingPairs = new List<KeyValuePair<string, int>>();
 
             foreach (var releaseProfile in releaseProfiles)
@@ -54,7 +54,7 @@ namespace NzbDrone.Core.Profiles.Releases
 
         public List<string> GetMatchingPreferredWords(Series series, string title)
         {
-            var releaseProfiles = _releaseProfileService.AllForTags(series.Tags);
+            var releaseProfiles = _releaseProfileService.EnabledForTags(series.Tags, 0);
             var matchingPairs = new List<KeyValuePair<string, int>>();
 
             _logger.Trace("Calculating preferred word score for '{0}'", title);

src/NzbDrone.Core/Profiles/Releases/ReleaseFilters/IReleaseFilter.cs

@@ -0,0 +1,11 @@
+using NzbDrone.Core.Parser.Model;
+
+namespace NzbDrone.Core.Profiles.Releases
+{
+    public interface IReleaseFilter
+    {
+        string Key { get; }
+        bool Matches(string filterValue, RemoteEpisode subject);
+        //List<string> SuggestAutoComplete(string filterValue, int indexerId);
+    }
+}

src/NzbDrone.Core/Profiles/Releases/ReleaseFilters/OriginReleaseFilter.cs

@@ -0,0 +1,15 @@
+using System;
+using NzbDrone.Core.Parser.Model;
+
+namespace NzbDrone.Core.Profiles.Releases
+{
+    public class OriginReleaseFilter : IReleaseFilter
+    {
+        public string Key => "Origin";
+
+        public bool Matches(string filterValue, RemoteEpisode subject)
+        {
+            return filterValue.Equals(subject.Release.Origin, StringComparison.InvariantCultureIgnoreCase);
+        }
+    }
+}

src/NzbDrone.Core/Profiles/Releases/ReleaseProfile.cs

@@ -5,17 +5,21 @@ namespace NzbDrone.Core.Profiles.Releases
 {
     public class ReleaseProfile : ModelBase
     {
+        public bool Enabled { get; set; }
         public string Required { get; set; }
         public string Ignored { get; set; }
         public List<KeyValuePair<string, int>> Preferred { get; set; }
         public bool IncludePreferredWhenRenaming { get; set; }
+        public int IndexerId { get; set; }
         public HashSet<int> Tags { get; set; }
 
         public ReleaseProfile()
         {
+            Enabled = true;
             Preferred = new List<KeyValuePair<string, int>>();
             IncludePreferredWhenRenaming = true;
             Tags = new HashSet<int>();
+            IndexerId = 0;
         }
     }
 

src/NzbDrone.Core/Profiles/Releases/ReleaseProfileService.cs

@@ -10,6 +10,7 @@ namespace NzbDrone.Core.Profiles.Releases
         List<ReleaseProfile> All();
         List<ReleaseProfile> AllForTag(int tagId);
         List<ReleaseProfile> AllForTags(HashSet<int> tagIds);
+        List<ReleaseProfile> EnabledForTags(HashSet<int> tagIds, int indexerId);
         ReleaseProfile Get(int id);
         void Delete(int id);
         ReleaseProfile Add(ReleaseProfile restriction);
@@ -48,6 +49,13 @@ namespace NzbDrone.Core.Profiles.Releases
             return _repo.All().Where(r => r.Tags.Intersect(tagIds).Any() || r.Tags.Empty()).ToList();
         }
 
+        public List<ReleaseProfile> EnabledForTags(HashSet<int> tagIds, int indexerId)
+        {
+            return (List<ReleaseProfile>)AllForTags(tagIds)
+                .Where(r => r.Enabled)
+                .Where(r => r.IndexerId == indexerId || r.IndexerId == 0).ToList();
+        }
+
         public ReleaseProfile Get(int id)
         {
             return _repo.Get(id);

src/Sonarr.Api.V3/Profiles/Release/ReleaseProfileResource.cs

@@ -7,10 +7,12 @@ namespace Sonarr.Api.V3.Profiles.Release
 {
     public class ReleaseProfileResource : RestResource
     {
+        public bool Enabled { get; set; }
         public string Required { get; set; }
         public string Ignored { get; set; }
         public List<KeyValuePair<string, int>> Preferred { get; set; }
         public bool IncludePreferredWhenRenaming { get; set; }
+        public int IndexerId { get; set; }
         public HashSet<int> Tags { get; set; }
 
         public ReleaseProfileResource()
@@ -29,10 +31,12 @@ namespace Sonarr.Api.V3.Profiles.Release
             {
                 Id = model.Id,
 
+                Enabled = model.Enabled,
                 Required = model.Required,
                 Ignored = model.Ignored,
                 Preferred = model.Preferred,
                 IncludePreferredWhenRenaming = model.IncludePreferredWhenRenaming,
+                IndexerId = model.IndexerId,
                 Tags = new HashSet<int>(model.Tags)
             };
         }
@@ -45,10 +49,12 @@ namespace Sonarr.Api.V3.Profiles.Release
             {
                 Id = resource.Id,
 
+                Enabled = resource.Enabled,
                 Required = resource.Required,
                 Ignored = resource.Ignored,
                 Preferred = resource.Preferred,
                 IncludePreferredWhenRenaming = resource.IncludePreferredWhenRenaming,
+                IndexerId = resource.IndexerId,
                 Tags = new HashSet<int>(resource.Tags)
             };
         }