Add Advanced Option for Alternate Metadata Provider Source

frontend/src/Settings/Metadata/Metadata/Metadatas.js

@@ -14,7 +14,7 @@ function Metadatas(props) {
 
   return (
     <FieldSet
-      legend="Metadata"
+      legend="Metadata Consumers"
     >
       <PageSectionContent
         errorMessage="Unable to load Metadata"

frontend/src/Settings/Metadata/MetadataProvider/MetadataProvider.js

@@ -0,0 +1,75 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { inputTypes, sizes } from 'Helpers/Props';
+import LoadingIndicator from 'Components/Loading/LoadingIndicator';
+import FieldSet from 'Components/FieldSet';
+import Form from 'Components/Form/Form';
+import FormGroup from 'Components/Form/FormGroup';
+import FormLabel from 'Components/Form/FormLabel';
+import FormInputGroup from 'Components/Form/FormInputGroup';
+
+function MetadataProvider(props) {
+  const {
+    advancedSettings,
+    isFetching,
+    error,
+    settings,
+    hasSettings,
+    onInputChange
+  } = props;
+
+  return (
+
+    <div>
+      {
+        isFetching &&
+          <LoadingIndicator />
+      }
+
+      {
+        !isFetching && error &&
+          <div>Unable to load Metadata Provider settings</div>
+      }
+
+      {
+        hasSettings && !isFetching && !error &&
+          <Form>
+            {
+                advancedSettings &&
+                  <FieldSet
+                    legend="Metadata Provider Source"
+                  >
+                    <FormGroup
+                      advancedSettings={advancedSettings}
+                      isAdvanced={true}
+                    >
+                      <FormLabel>Metadata Source</FormLabel>
+
+                      <FormInputGroup
+                        type={inputTypes.TEXT}
+                        name="metadataSource"
+                        helpText="Alternative Metadata Source (Leave blank for default)"
+                        helpLink="https://github.com/Lidarr/Lidarr/wiki/Metadata-Source"
+                        onChange={onInputChange}
+                        {...settings.metadataSource}
+                      />
+                    </FormGroup>
+                  </FieldSet>
+            }
+          </Form>
+      }
+    </div>
+
+  );
+}
+
+MetadataProvider.propTypes = {
+  advancedSettings: PropTypes.bool.isRequired,
+  isFetching: PropTypes.bool.isRequired,
+  error: PropTypes.object,
+  settings: PropTypes.object.isRequired,
+  hasSettings: PropTypes.bool.isRequired,
+  onInputChange: PropTypes.func.isRequired
+};
+
+export default MetadataProvider;

frontend/src/Settings/Metadata/MetadataProvider/MetadataProviderConnector.js

@@ -0,0 +1,92 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import { createSelector } from 'reselect';
+import createSettingsSectionSelector from 'Store/Selectors/createSettingsSectionSelector';
+import { setMetadataProviderValue, saveMetadataProvider, fetchMetadataProvider } from 'Store/Actions/settingsActions';
+import { clearPendingChanges } from 'Store/Actions/baseActions';
+import connectSection from 'Store/connectSection';
+import MetadataProvider from './MetadataProvider';
+
+function createMapStateToProps() {
+  return createSelector(
+    (state) => state.settings.advancedSettings,
+    createSettingsSectionSelector(),
+    (advancedSettings, sectionSettings) => {
+      return {
+        advancedSettings,
+        ...sectionSettings
+      };
+    }
+  );
+}
+
+const mapDispatchToProps = {
+  setMetadataProviderValue,
+  saveMetadataProvider,
+  fetchMetadataProvider,
+  clearPendingChanges
+};
+
+class MetadataProviderConnector extends Component {
+
+  //
+  // Lifecycle
+
+  componentDidMount() {
+    this.props.fetchMetadataProvider();
+  }
+
+  componentDidUpdate(prevProps) {
+    if (this.props.hasPendingChanges !== prevProps.hasPendingChanges) {
+      this.props.onHasPendingChange(this.props.hasPendingChanges);
+    }
+  }
+
+  componentWillUnmount() {
+    this.props.clearPendingChanges({ section: this.props.section });
+  }
+
+  //
+  // Control
+
+  save = () => {
+    this.props.saveMetadataProvider();
+  }
+
+  //
+  // Listeners
+
+  onInputChange = ({ name, value }) => {
+    this.props.setMetadataProviderValue({ name, value });
+  }
+
+  //
+  // Render
+
+  render() {
+    return (
+      <MetadataProvider
+        onInputChange={this.onInputChange}
+        {...this.props}
+      />
+    );
+  }
+}
+
+MetadataProviderConnector.propTypes = {
+  section: PropTypes.string.isRequired,
+  hasPendingChanges: PropTypes.bool.isRequired,
+  setMetadataProviderValue: PropTypes.func.isRequired,
+  saveMetadataProvider: PropTypes.func.isRequired,
+  fetchMetadataProvider: PropTypes.func.isRequired,
+  clearPendingChanges: PropTypes.func.isRequired,
+  onHasPendingChange: PropTypes.func.isRequired
+};
+
+export default connectSection(
+                createMapStateToProps,
+                mapDispatchToProps,
+                undefined,
+                { withRef: true },
+                { section: 'metadataProvider' }
+               )(MetadataProviderConnector);

frontend/src/Settings/Metadata/MetadataSettings.js

@@ -1,21 +1,60 @@
-import React from 'react';
+import React, { Component } from 'react';
 import PageContent from 'Components/Page/PageContent';
 import PageContentBodyConnector from 'Components/Page/PageContentBodyConnector';
 import SettingsToolbarConnector from 'Settings/SettingsToolbarConnector';
 import MetadatasConnector from './Metadata/MetadatasConnector';
+import MetadataProviderConnector from './MetadataProvider/MetadataProviderConnector';
 
-function MetadataSettings() {
-  return (
-    <PageContent title="Metadata Settings">
-      <SettingsToolbarConnector
-        showSave={false}
-      />
+class MetadataSettings extends Component {
 
-      <PageContentBodyConnector>
-        <MetadatasConnector />
-      </PageContentBodyConnector>
-    </PageContent>
-  );
+  //
+  // Lifecycle
+
+  constructor(props, context) {
+    super(props, context);
+
+    this.state = {
+      hasPendingChanges: false
+    };
+  }
+
+  //
+  // Listeners
+
+  setMetadataProviderRef = (ref) => {
+    this._metadataProvider = ref;
+  }
+
+  onHasPendingChange = (hasPendingChanges) => {
+    this.setState({
+      hasPendingChanges
+    });
+  }
+
+  onSavePress = () => {
+    this._metadataProvider.getWrappedInstance().save();
+  }
+
+  //
+  // Render
+  render() {
+    return (
+      <PageContent title="Metadata Settings">
+        <SettingsToolbarConnector
+          hasPendingChanges={this.state.hasPendingChanges}
+          onSavePress={this.onSavePress}
+        />
+
+        <PageContentBodyConnector>
+          <MetadatasConnector />
+          <MetadataProviderConnector
+            ref={this.setMetadataProviderRef}
+            onHasPendingChange={this.onHasPendingChange}
+          />
+        </PageContentBodyConnector>
+      </PageContent>
+    );
+  }
 }
 
 export default MetadataSettings;

frontend/src/Store/Actions/actionTypes.js

@@ -297,6 +297,10 @@ export const SET_METADATA_VALUE = 'SET_METADATA_VALUE';
 export const SET_METADATA_FIELD_VALUE = 'SET_METADATA_FIELD_VALUE';
 export const SAVE_METADATA = 'SAVE_METADATA';
 
+export const FETCH_METADATA_PROVIDER = 'FETCH_METADATA_PROVIDER';
+export const SET_METADATA_PROVIDER_VALUE = 'SET_METADATA_PROVIDER_VALUE';
+export const SAVE_METADATA_PROVIDER = 'SAVE_METADATA_PROVIDER';
+
 //
 // System
 

frontend/src/Store/Actions/settingsActionHandlers.js

@@ -243,6 +243,9 @@ const settingsActionHandlers = {
                                                    '/metadata',
                                                    (state) => state.settings.metadata),
 
+  [types.FETCH_METADATA_PROVIDER]: createFetchHandler('metadataProvider', '/config/metadataProvider'),
+  [types.SAVE_METADATA_PROVIDER]: createSaveHandler('metadataProvider', '/config/metadataProvider', (state) => state.settings.metadataProvider),
+
   [types.FETCH_GENERAL_SETTINGS]: createFetchHandler('general', '/config/host'),
   [types.SAVE_GENERAL_SETTINGS]: createSaveHandler('general', '/config/host', (state) => state.settings.general)
 };

frontend/src/Store/Actions/settingsActions.js

@@ -203,6 +203,15 @@ export const setMetadataFieldValue = createAction(types.SET_METADATA_FIELD_VALUE
   };
 });
 
+export const fetchMetadataProvider = settingsActionHandlers[types.FETCH_METADATA_PROVIDER];
+export const saveMetadataProvider = settingsActionHandlers[types.SAVE_METADATA_PROVIDER];
+export const setMetadataProviderValue = createAction(types.SET_METADATA_PROVIDER_VALUE, (payload) => {
+  return {
+    section: 'metadataProvider',
+    ...payload
+  };
+});
+
 export const fetchGeneralSettings = settingsActionHandlers[types.FETCH_GENERAL_SETTINGS];
 export const saveGeneralSettings = settingsActionHandlers[types.SAVE_GENERAL_SETTINGS];
 export const setGeneralSettingsValue = createAction(types.SET_GENERAL_SETTINGS_VALUE, (payload) => {

frontend/src/Store/Reducers/settingsReducers.js

@@ -201,6 +201,16 @@ export const defaultState = {
     pendingChanges: {}
   },
 
+  metadataProvider: {
+    isFetching: false,
+    isPopulated: false,
+    error: null,
+    pendingChanges: {},
+    isSaving: false,
+    saveError: null,
+    item: {}
+  },
+
   general: {
     isFetching: false,
     isPopulated: false,
@@ -226,7 +236,8 @@ const propertyNames = [
   'qualityDefinitions',
   'indexerOptions',
   'downloadClientOptions',
-  'general'
+  'general',
+  'metadataProvider'
 ];
 
 const providerPropertyNames = [
@@ -330,6 +341,8 @@ const settingsReducers = handleActions({
   [types.SET_METADATA_VALUE]: createSetSettingValueReducer('metadata'),
   [types.SET_METADATA_FIELD_VALUE]: createSetProviderFieldValueReducer('metadata'),
 
+  [types.SET_METADATA_PROVIDER_VALUE]: createSetSettingValueReducer('metadataProvider'),
+
   [types.SET_GENERAL_SETTINGS_VALUE]: createSetSettingValueReducer('general')
 
 }, defaultState);