Fixed: List Exclusions, List Processing Tweaks

frontend/src/Settings/NetImport/NetImportExclusions/EditNetImportExclusionModal.js

@@ -0,0 +1,27 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { sizes } from 'Helpers/Props';
+import Modal from 'Components/Modal/Modal';
+import EditNetImportExclusionModalContentConnector from './EditNetImportExclusionModalContentConnector';
+
+function EditNetImportExclusionModal({ isOpen, onModalClose, ...otherProps }) {
+  return (
+    <Modal
+      size={sizes.MEDIUM}
+      isOpen={isOpen}
+      onModalClose={onModalClose}
+    >
+      <EditNetImportExclusionModalContentConnector
+        {...otherProps}
+        onModalClose={onModalClose}
+      />
+    </Modal>
+  );
+}
+
+EditNetImportExclusionModal.propTypes = {
+  isOpen: PropTypes.bool.isRequired,
+  onModalClose: PropTypes.func.isRequired
+};
+
+export default EditNetImportExclusionModal;

frontend/src/Settings/NetImport/NetImportExclusions/EditNetImportExclusionModalConnector.js

@@ -0,0 +1,43 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import { connect } from 'react-redux';
+import { clearPendingChanges } from 'Store/Actions/baseActions';
+import EditNetImportExclusionModal from './EditNetImportExclusionModal';
+
+function mapStateToProps() {
+  return {};
+}
+
+const mapDispatchToProps = {
+  clearPendingChanges
+};
+
+class EditNetImportExclusionModalConnector extends Component {
+
+  //
+  // Listeners
+
+  onModalClose = () => {
+    this.props.clearPendingChanges({ section: 'settings.netImportExclusions' });
+    this.props.onModalClose();
+  }
+
+  //
+  // Render
+
+  render() {
+    return (
+      <EditNetImportExclusionModal
+        {...this.props}
+        onModalClose={this.onModalClose}
+      />
+    );
+  }
+}
+
+EditNetImportExclusionModalConnector.propTypes = {
+  onModalClose: PropTypes.func.isRequired,
+  clearPendingChanges: PropTypes.func.isRequired
+};
+
+export default connect(mapStateToProps, mapDispatchToProps)(EditNetImportExclusionModalConnector);

frontend/src/Settings/NetImport/NetImportExclusions/EditNetImportExclusionModalContent.css

@@ -0,0 +1,11 @@
+.body {
+  composes: modalBody from '~Components/Modal/ModalBody.css';
+
+  flex: 1 1 430px;
+}
+
+.deleteButton {
+  composes: button from '~Components/Link/Button.css';
+
+  margin-right: auto;
+}

frontend/src/Settings/NetImport/NetImportExclusions/EditNetImportExclusionModalContent.js

@@ -0,0 +1,143 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { inputTypes, kinds } from 'Helpers/Props';
+import Button from 'Components/Link/Button';
+import SpinnerErrorButton from 'Components/Link/SpinnerErrorButton';
+import LoadingIndicator from 'Components/Loading/LoadingIndicator';
+import ModalContent from 'Components/Modal/ModalContent';
+import ModalHeader from 'Components/Modal/ModalHeader';
+import ModalBody from 'Components/Modal/ModalBody';
+import ModalFooter from 'Components/Modal/ModalFooter';
+import Form from 'Components/Form/Form';
+import FormGroup from 'Components/Form/FormGroup';
+import FormLabel from 'Components/Form/FormLabel';
+import FormInputGroup from 'Components/Form/FormInputGroup';
+import styles from './EditNetImportExclusionModalContent.css';
+
+function EditNetImportExclusionModalContent(props) {
+  const {
+    id,
+    isFetching,
+    error,
+    isSaving,
+    saveError,
+    item,
+    onInputChange,
+    onSavePress,
+    onModalClose,
+    onDeleteNetImportExclusionPress,
+    ...otherProps
+  } = props;
+
+  const {
+    movieTitle = '',
+    tmdbId,
+    movieYear
+  } = item;
+
+  return (
+    <ModalContent onModalClose={onModalClose}>
+      <ModalHeader>
+        {id ? 'Edit List Exclusion' : 'Add List Exclusion'}
+      </ModalHeader>
+
+      <ModalBody className={styles.body}>
+        {
+          isFetching &&
+            <LoadingIndicator />
+        }
+
+        {
+          !isFetching && !!error &&
+            <div>Unable to add a new list exclusion, please try again.</div>
+        }
+
+        {
+          !isFetching && !error &&
+            <Form
+              {...otherProps}
+            >
+              <FormGroup>
+                <FormLabel>TMDB Id</FormLabel>
+
+                <FormInputGroup
+                  type={inputTypes.NUMBER}
+                  name="tmdbId"
+                  helpText="The TMDB Id of the movie to exclude"
+                  {...tmdbId}
+                  onChange={onInputChange}
+                />
+              </FormGroup>
+
+              <FormGroup>
+                <FormLabel>Movie Title</FormLabel>
+
+                <FormInputGroup
+                  type={inputTypes.TEXT}
+                  name="movieTitle"
+                  helpText="The title of the movie to exclude (can be anything meaningful)"
+                  {...movieTitle}
+                  onChange={onInputChange}
+                />
+              </FormGroup>
+
+              <FormGroup>
+                <FormLabel>Movie Year</FormLabel>
+
+                <FormInputGroup
+                  type={inputTypes.NUMBER}
+                  name="movieYear"
+                  helpText="The year of the movie to exclude"
+                  {...movieYear}
+                  onChange={onInputChange}
+                />
+              </FormGroup>
+
+            </Form>
+        }
+      </ModalBody>
+
+      <ModalFooter>
+        {
+          id &&
+            <Button
+              className={styles.deleteButton}
+              kind={kinds.DANGER}
+              onPress={onDeleteNetImportExclusionPress}
+            >
+              Delete
+            </Button>
+        }
+
+        <Button
+          onPress={onModalClose}
+        >
+          Cancel
+        </Button>
+
+        <SpinnerErrorButton
+          isSpinning={isSaving}
+          error={saveError}
+          onPress={onSavePress}
+        >
+          Save
+        </SpinnerErrorButton>
+      </ModalFooter>
+    </ModalContent>
+  );
+}
+
+EditNetImportExclusionModalContent.propTypes = {
+  id: PropTypes.number,
+  isFetching: PropTypes.bool.isRequired,
+  error: PropTypes.object,
+  isSaving: PropTypes.bool.isRequired,
+  saveError: PropTypes.object,
+  item: PropTypes.object.isRequired,
+  onInputChange: PropTypes.func.isRequired,
+  onSavePress: PropTypes.func.isRequired,
+  onModalClose: PropTypes.func.isRequired,
+  onDeleteNetImportExclusionPress: PropTypes.func
+};
+
+export default EditNetImportExclusionModalContent;

frontend/src/Settings/NetImport/NetImportExclusions/EditNetImportExclusionModalContentConnector.js

@@ -0,0 +1,118 @@
+import _ from 'lodash';
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import { connect } from 'react-redux';
+import { createSelector } from 'reselect';
+import selectSettings from 'Store/Selectors/selectSettings';
+import { setNetImportExclusionValue, saveNetImportExclusion } from 'Store/Actions/settingsActions';
+import EditNetImportExclusionModalContent from './EditNetImportExclusionModalContent';
+
+const newNetImportExclusion = {
+  artistName: '',
+  foreignId: ''
+};
+
+function createNetImportExclusionSelector() {
+  return createSelector(
+    (state, { id }) => id,
+    (state) => state.settings.netImportExclusions,
+    (id, netImportExclusions) => {
+      const {
+        isFetching,
+        error,
+        isSaving,
+        saveError,
+        pendingChanges,
+        items
+      } = netImportExclusions;
+
+      const mapping = id ? _.find(items, { id }) : newNetImportExclusion;
+      const settings = selectSettings(mapping, pendingChanges, saveError);
+
+      return {
+        id,
+        isFetching,
+        error,
+        isSaving,
+        saveError,
+        item: settings.settings,
+        ...settings
+      };
+    }
+  );
+}
+
+function createMapStateToProps() {
+  return createSelector(
+    createNetImportExclusionSelector(),
+    (netImportExclusion) => {
+      return {
+        ...netImportExclusion
+      };
+    }
+  );
+}
+
+const mapDispatchToProps = {
+  setNetImportExclusionValue,
+  saveNetImportExclusion
+};
+
+class EditNetImportExclusionModalContentConnector extends Component {
+
+  //
+  // Lifecycle
+
+  componentDidMount() {
+    if (!this.props.id) {
+      Object.keys(newNetImportExclusion).forEach((name) => {
+        this.props.setNetImportExclusionValue({
+          name,
+          value: newNetImportExclusion[name]
+        });
+      });
+    }
+  }
+
+  componentDidUpdate(prevProps, prevState) {
+    if (prevProps.isSaving && !this.props.isSaving && !this.props.saveError) {
+      this.props.onModalClose();
+    }
+  }
+
+  //
+  // Listeners
+
+  onInputChange = ({ name, value }) => {
+    this.props.setNetImportExclusionValue({ name, value });
+  }
+
+  onSavePress = () => {
+    this.props.saveNetImportExclusion({ id: this.props.id });
+  }
+
+  //
+  // Render
+
+  render() {
+    return (
+      <EditNetImportExclusionModalContent
+        {...this.props}
+        onSavePress={this.onSavePress}
+        onInputChange={this.onInputChange}
+      />
+    );
+  }
+}
+
+EditNetImportExclusionModalContentConnector.propTypes = {
+  id: PropTypes.number,
+  isSaving: PropTypes.bool.isRequired,
+  saveError: PropTypes.object,
+  item: PropTypes.object.isRequired,
+  setNetImportExclusionValue: PropTypes.func.isRequired,
+  saveNetImportExclusion: PropTypes.func.isRequired,
+  onModalClose: PropTypes.func.isRequired
+};
+
+export default connect(createMapStateToProps, mapDispatchToProps)(EditNetImportExclusionModalContentConnector);

frontend/src/Settings/NetImport/NetImportExclusions/NetImportExclusion.css

@@ -0,0 +1,24 @@
+.netImportExclusion {
+  display: flex;
+  align-items: stretch;
+  margin-bottom: 10px;
+  height: 30px;
+  border-bottom: 1px solid $borderColor;
+  line-height: 30px;
+}
+
+.movieTitle {
+  flex: 0 0 400px;
+}
+
+.tmdbId,
+.movieYear {
+  flex: 0 0 200px;
+}
+
+.actions {
+  display: flex;
+  justify-content: flex-end;
+  flex: 1 0 auto;
+  padding-right: 10px;
+}

frontend/src/Settings/NetImport/NetImportExclusions/NetImportExclusion.js

@@ -0,0 +1,114 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import classNames from 'classnames';
+import { icons, kinds } from 'Helpers/Props';
+import Icon from 'Components/Icon';
+import Link from 'Components/Link/Link';
+import ConfirmModal from 'Components/Modal/ConfirmModal';
+import EditNetImportExclusionModalConnector from './EditNetImportExclusionModalConnector';
+import styles from './NetImportExclusion.css';
+
+class NetImportExclusion extends Component {
+
+  //
+  // Lifecycle
+
+  constructor(props, context) {
+    super(props, context);
+
+    this.state = {
+      isEditNetImportExclusionModalOpen: false,
+      isDeleteNetImportExclusionModalOpen: false
+    };
+  }
+
+  //
+  // Listeners
+
+  onEditNetImportExclusionPress = () => {
+    this.setState({ isEditNetImportExclusionModalOpen: true });
+  }
+
+  onEditNetImportExclusionModalClose = () => {
+    this.setState({ isEditNetImportExclusionModalOpen: false });
+  }
+
+  onDeleteNetImportExclusionPress = () => {
+    this.setState({
+      isEditNetImportExclusionModalOpen: false,
+      isDeleteNetImportExclusionModalOpen: true
+    });
+  }
+
+  onDeleteNetImportExclusionModalClose = () => {
+    this.setState({ isDeleteNetImportExclusionModalOpen: false });
+  }
+
+  onConfirmDeleteNetImportExclusion = () => {
+    this.props.onConfirmDeleteNetImportExclusion(this.props.id);
+  }
+
+  //
+  // Render
+
+  render() {
+    const {
+      id,
+      movieTitle,
+      tmdbId,
+      movieYear
+    } = this.props;
+
+    return (
+      <div
+        className={classNames(
+          styles.netImportExclusion,
+        )}
+      >
+        <div className={styles.tmdbId}>{tmdbId}</div>
+        <div className={styles.movieTitle}>{movieTitle}</div>
+        <div className={styles.movieYear}>{movieYear}</div>
+
+        <div className={styles.actions}>
+          <Link
+            onPress={this.onEditNetImportExclusionPress}
+          >
+            <Icon name={icons.EDIT} />
+          </Link>
+        </div>
+
+        <EditNetImportExclusionModalConnector
+          id={id}
+          isOpen={this.state.isEditNetImportExclusionModalOpen}
+          onModalClose={this.onEditNetImportExclusionModalClose}
+          onDeleteNetImportExclusionPress={this.onDeleteNetImportExclusionPress}
+        />
+
+        <ConfirmModal
+          isOpen={this.state.isDeleteNetImportExclusionModalOpen}
+          kind={kinds.DANGER}
+          title="Delete Import List Exclusion"
+          message="Are you sure you want to delete this import list exclusion?"
+          confirmLabel="Delete"
+          onConfirm={this.onConfirmDeleteNetImportExclusion}
+          onCancel={this.onDeleteNetImportExclusionModalClose}
+        />
+      </div>
+    );
+  }
+}
+
+NetImportExclusion.propTypes = {
+  id: PropTypes.number.isRequired,
+  movieTitle: PropTypes.string.isRequired,
+  tmdbId: PropTypes.number.isRequired,
+  movieYear: PropTypes.number.isRequired,
+  onConfirmDeleteNetImportExclusion: PropTypes.func.isRequired
+};
+
+NetImportExclusion.defaultProps = {
+  // The drag preview will not connect the drag handle.
+  connectDragSource: (node) => node
+};
+
+export default NetImportExclusion;

frontend/src/Settings/NetImport/NetImportExclusions/NetImportExclusions.css

@@ -0,0 +1,24 @@
+.netImportExclusionsHeader {
+  display: flex;
+  margin-bottom: 10px;
+  font-weight: bold;
+}
+
+.title {
+  flex: 0 0 400px;
+}
+
+.tmdbId,
+.movieYear {
+  flex: 0 0 200px;
+}
+
+.addNetImportExclusion {
+  display: flex;
+  justify-content: flex-end;
+  padding-right: 10px;
+}
+
+.addButton {
+  text-align: center;
+}

frontend/src/Settings/NetImport/NetImportExclusions/NetImportExclusions.js

@@ -0,0 +1,101 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import { icons } from 'Helpers/Props';
+import FieldSet from 'Components/FieldSet';
+import Icon from 'Components/Icon';
+import Link from 'Components/Link/Link';
+import PageSectionContent from 'Components/Page/PageSectionContent';
+import NetImportExclusion from './NetImportExclusion';
+import EditNetImportExclusionModalConnector from './EditNetImportExclusionModalConnector';
+import styles from './NetImportExclusions.css';
+
+class NetImportExclusions extends Component {
+
+  //
+  // Lifecycle
+
+  constructor(props, context) {
+    super(props, context);
+
+    this.state = {
+      isAddNetImportExclusionModalOpen: false
+    };
+  }
+
+  //
+  // Listeners
+
+  onAddNetImportExclusionPress = () => {
+    this.setState({ isAddNetImportExclusionModalOpen: true });
+  }
+
+  onModalClose = () => {
+    this.setState({ isAddNetImportExclusionModalOpen: false });
+  }
+
+  //
+  // Render
+
+  render() {
+    const {
+      items,
+      onConfirmDeleteNetImportExclusion,
+      ...otherProps
+    } = this.props;
+
+    return (
+      <FieldSet legend="List Exclusions">
+        <PageSectionContent
+          errorMessage="Unable to load List Exclusions"
+          {...otherProps}
+        >
+          <div className={styles.netImportExclusionsHeader}>
+            <div className={styles.tmdbId}>TMDB Id</div>
+            <div className={styles.title}>Title</div>
+            <div className={styles.movieYear}>Year</div>
+          </div>
+
+          <div>
+            {
+              items.map((item, index) => {
+                return (
+                  <NetImportExclusion
+                    key={item.id}
+                    {...item}
+                    {...otherProps}
+                    index={index}
+                    onConfirmDeleteNetImportExclusion={onConfirmDeleteNetImportExclusion}
+                  />
+                );
+              })
+            }
+          </div>
+
+          <div className={styles.addNetImportExclusion}>
+            <Link
+              className={styles.addButton}
+              onPress={this.onAddNetImportExclusionPress}
+            >
+              <Icon name={icons.ADD} />
+            </Link>
+          </div>
+
+          <EditNetImportExclusionModalConnector
+            isOpen={this.state.isAddNetImportExclusionModalOpen}
+            onModalClose={this.onModalClose}
+          />
+
+        </PageSectionContent>
+      </FieldSet>
+    );
+  }
+}
+
+NetImportExclusions.propTypes = {
+  isFetching: PropTypes.bool.isRequired,
+  error: PropTypes.object,
+  items: PropTypes.arrayOf(PropTypes.object).isRequired,
+  onConfirmDeleteNetImportExclusion: PropTypes.func.isRequired
+};
+
+export default NetImportExclusions;

frontend/src/Settings/NetImport/NetImportExclusions/NetImportExclusionsConnector.js

@@ -0,0 +1,59 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import { connect } from 'react-redux';
+import { createSelector } from 'reselect';
+import { fetchNetImportExclusions, deleteNetImportExclusion } from 'Store/Actions/settingsActions';
+import NetImportExclusions from './NetImportExclusions';
+
+function createMapStateToProps() {
+  return createSelector(
+    (state) => state.settings.netImportExclusions,
+    (netImportExclusions) => {
+      return {
+        ...netImportExclusions
+      };
+    }
+  );
+}
+
+const mapDispatchToProps = {
+  fetchNetImportExclusions,
+  deleteNetImportExclusion
+};
+
+class NetImportExclusionsConnector extends Component {
+
+  //
+  // Lifecycle
+
+  componentDidMount() {
+    this.props.fetchNetImportExclusions();
+  }
+
+  //
+  // Listeners
+
+  onConfirmDeleteNetImportExclusion = (id) => {
+    this.props.deleteNetImportExclusion({ id });
+  }
+
+  //
+  // Render
+
+  render() {
+    return (
+      <NetImportExclusions
+        {...this.state}
+        {...this.props}
+        onConfirmDeleteNetImportExclusion={this.onConfirmDeleteNetImportExclusion}
+      />
+    );
+  }
+}
+
+NetImportExclusionsConnector.propTypes = {
+  fetchNetImportExclusions: PropTypes.func.isRequired,
+  deleteNetImportExclusion: PropTypes.func.isRequired
+};
+
+export default connect(createMapStateToProps, mapDispatchToProps)(NetImportExclusionsConnector);

frontend/src/Settings/NetImport/NetImportSettings.js

@@ -8,7 +8,7 @@ import PageToolbarSeparator from 'Components/Page/Toolbar/PageToolbarSeparator';
 import SettingsToolbarConnector from 'Settings/SettingsToolbarConnector';
 import NetImportsConnector from './NetImport/NetImportsConnector';
 import NetImportOptionsConnector from './Options/NetImportOptionsConnector';
-// import ImportExclusionsConnector from './ImportExclusions/ImportExclusionsConnector';
+import NetImportExclusionsConnector from './NetImportExclusions/NetImportExclusionsConnector';
 
 class NetImportSettings extends Component {
 
@@ -85,6 +85,8 @@ class NetImportSettings extends Component {
             onChildStateChange={this.onChildStateChange}
           />
 
+          <NetImportExclusionsConnector />
+
         </PageContentBodyConnector>
       </PageContent>
     );