[UI Work] Interactive Import, More Artist Detail

frontend/src/InteractiveImport/Track/SelectTrackModal.js

@@ -0,0 +1,37 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import Modal from 'Components/Modal/Modal';
+import SelectTrackModalContentConnector from './SelectTrackModalContentConnector';
+
+class SelectTrackModal extends Component {
+
+  //
+  // Render
+
+  render() {
+    const {
+      isOpen,
+      onModalClose,
+      ...otherProps
+    } = this.props;
+
+    return (
+      <Modal
+        isOpen={isOpen}
+        onModalClose={onModalClose}
+      >
+        <SelectTrackModalContentConnector
+          {...otherProps}
+          onModalClose={onModalClose}
+        />
+      </Modal>
+    );
+  }
+}
+
+SelectTrackModal.propTypes = {
+  isOpen: PropTypes.bool.isRequired,
+  onModalClose: PropTypes.func.isRequired
+};
+
+export default SelectTrackModal;

frontend/src/InteractiveImport/Track/SelectTrackModalContent.js

@@ -0,0 +1,177 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import getSelectedIds from 'Utilities/Table/getSelectedIds';
+import selectAll from 'Utilities/Table/selectAll';
+import toggleSelected from 'Utilities/Table/toggleSelected';
+import { kinds } from 'Helpers/Props';
+import Button from 'Components/Link/Button';
+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 Table from 'Components/Table/Table';
+import TableBody from 'Components/Table/TableBody';
+import SelectTrackRow from './SelectTrackRow';
+
+const columns = [
+  {
+    name: 'trackNumber',
+    label: '#',
+    isSortable: true,
+    isVisible: true
+  },
+  {
+    name: 'title',
+    label: 'Title',
+    isVisible: true
+  }
+];
+
+class SelectTrackModalContent extends Component {
+
+  //
+  // Lifecycle
+
+  constructor(props, context) {
+    super(props, context);
+
+    this.state = {
+      allSelected: false,
+      allUnselected: false,
+      lastToggled: null,
+      selectedState: {}
+    };
+  }
+
+  //
+  // Control
+
+  getSelectedIds = () => {
+    return getSelectedIds(this.state.selectedState);
+  }
+
+  //
+  // Listeners
+
+  onSelectAllChange = ({ value }) => {
+    this.setState(selectAll(this.state.selectedState, value));
+  }
+
+  onSelectedChange = ({ id, value, shiftKey = false }) => {
+    this.setState((state) => {
+      return toggleSelected(state, this.props.items, id, value, shiftKey);
+    });
+  }
+
+  onTracksSelect = () => {
+    this.props.onTracksSelect(this.getSelectedIds());
+  }
+
+  //
+  // Render
+
+  render() {
+    const {
+      isFetching,
+      isPopulated,
+      error,
+      items,
+      sortKey,
+      sortDirection,
+      onSortPress,
+      onModalClose
+    } = this.props;
+
+    const {
+      allSelected,
+      allUnselected,
+      selectedState
+    } = this.state;
+
+    const errorMessage = error && error.message || 'Unable to load tracks';
+
+    return (
+      <ModalContent onModalClose={onModalClose}>
+        <ModalHeader>
+          Manual Import - Select Track(s)
+        </ModalHeader>
+
+        <ModalBody>
+          {
+            isFetching &&
+              <LoadingIndicator />
+          }
+
+          {
+            error &&
+              <div>{errorMessage}</div>
+          }
+
+          {
+            isPopulated && !!items.length &&
+              <Table
+                columns={columns}
+                selectAll={true}
+                allSelected={allSelected}
+                allUnselected={allUnselected}
+                sortKey={sortKey}
+                sortDirection={sortDirection}
+                onSortPress={onSortPress}
+                onSelectAllChange={this.onSelectAllChange}
+              >
+                <TableBody>
+                  {
+                    items.map((item) => {
+                      return (
+                        <SelectTrackRow
+                          key={item.id}
+                          id={item.id}
+                          trackNumber={item.trackNumber}
+                          title={item.title}
+                          isSelected={selectedState[item.id]}
+                          onSelectedChange={this.onSelectedChange}
+                        />
+                      );
+                    })
+                  }
+                </TableBody>
+              </Table>
+          }
+
+          {
+            isPopulated && !items.length &&
+              'No tracks were found for the selected album'
+          }
+        </ModalBody>
+
+        <ModalFooter>
+          <Button onPress={onModalClose}>
+            Cancel
+          </Button>
+
+          <Button
+            kind={kinds.SUCCESS}
+            onPress={this.onTracksSelect}
+          >
+            Select Tracks
+          </Button>
+        </ModalFooter>
+      </ModalContent>
+    );
+  }
+}
+
+SelectTrackModalContent.propTypes = {
+  isFetching: PropTypes.bool.isRequired,
+  isPopulated: PropTypes.bool.isRequired,
+  error: PropTypes.object,
+  items: PropTypes.arrayOf(PropTypes.object).isRequired,
+  sortKey: PropTypes.string,
+  sortDirection: PropTypes.string,
+  onSortPress: PropTypes.func.isRequired,
+  onTracksSelect: PropTypes.func.isRequired,
+  onModalClose: PropTypes.func.isRequired
+};
+
+export default SelectTrackModalContent;

frontend/src/InteractiveImport/Track/SelectTrackModalContentConnector.js

@@ -0,0 +1,103 @@
+import _ from 'lodash';
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import { createSelector } from 'reselect';
+import connectSection from 'Store/connectSection';
+import { fetchEpisodes, setEpisodesSort, clearEpisodes } from 'Store/Actions/episodeActions';
+import { updateInteractiveImportItem } from 'Store/Actions/interactiveImportActions';
+import createClientSideCollectionSelector from 'Store/Selectors/createClientSideCollectionSelector';
+import SelectTrackModalContent from './SelectTrackModalContent';
+
+function createMapStateToProps() {
+  return createSelector(
+    createClientSideCollectionSelector(),
+    (episodes) => {
+      return episodes;
+    }
+  );
+}
+
+const mapDispatchToProps = {
+  fetchEpisodes,
+  setEpisodesSort,
+  clearEpisodes,
+  updateInteractiveImportItem
+};
+
+class SelectTrackModalContentConnector extends Component {
+
+  //
+  // Lifecycle
+
+  componentDidMount() {
+    const {
+      artistId,
+      albumId
+    } = this.props;
+
+    this.props.fetchEpisodes({ artistId, albumId });
+  }
+
+  componentWillUnmount() {
+    // This clears the episodes for the queue and hides the queue
+    // We'll need another place to store episodes for manual import
+    this.props.clearEpisodes();
+  }
+
+  //
+  // Listeners
+
+  onSortPress = (sortKey, sortDirection) => {
+    this.props.setEpisodesSort({ sortKey, sortDirection });
+  }
+
+  onTracksSelect = (episodeIds) => {
+    const tracks = _.reduce(this.props.items, (acc, item) => {
+      if (episodeIds.indexOf(item.id) > -1) {
+        acc.push(item);
+      }
+
+      return acc;
+    }, []);
+
+    this.props.updateInteractiveImportItem({
+      id: this.props.id,
+      tracks: _.sortBy(tracks, 'trackNumber')
+    });
+
+    this.props.onModalClose(true);
+  }
+
+  //
+  // Render
+
+  render() {
+    return (
+      <SelectTrackModalContent
+        {...this.props}
+        onSortPress={this.onSortPress}
+        onTracksSelect={this.onTracksSelect}
+      />
+    );
+  }
+}
+
+SelectTrackModalContentConnector.propTypes = {
+  id: PropTypes.number.isRequired,
+  artistId: PropTypes.number.isRequired,
+  albumId: PropTypes.number.isRequired,
+  items: PropTypes.arrayOf(PropTypes.object).isRequired,
+  fetchEpisodes: PropTypes.func.isRequired,
+  setEpisodesSort: PropTypes.func.isRequired,
+  clearEpisodes: PropTypes.func.isRequired,
+  updateInteractiveImportItem: PropTypes.func.isRequired,
+  onModalClose: PropTypes.func.isRequired
+};
+
+export default connectSection(
+                createMapStateToProps,
+                mapDispatchToProps,
+                undefined,
+                undefined,
+                { section: 'episodes' }
+               )(SelectTrackModalContentConnector);

frontend/src/InteractiveImport/Track/SelectTrackRow.js

@@ -0,0 +1,62 @@
+import PropTypes from 'prop-types';
+import React, { Component } from 'react';
+import TableRowButton from 'Components/Table/TableRowButton';
+import TableRowCell from 'Components/Table/Cells/TableRowCell';
+import TableSelectCell from 'Components/Table/Cells/TableSelectCell';
+
+class SelectTrackRow extends Component {
+
+  //
+  // Listeners
+
+  onPress = () => {
+    const {
+      id,
+      isSelected
+    } = this.props;
+
+    this.props.onSelectedChange({ id, value: !isSelected });
+  }
+
+  //
+  // Render
+
+  render() {
+    const {
+      id,
+      trackNumber,
+      title,
+      isSelected,
+      onSelectedChange
+    } = this.props;
+
+    return (
+      <TableRowButton onPress={this.onPress}>
+        <TableSelectCell
+          id={id}
+          isSelected={isSelected}
+          onSelectedChange={onSelectedChange}
+        />
+
+        <TableRowCell>
+          {trackNumber}
+        </TableRowCell>
+
+        <TableRowCell>
+          {title}
+        </TableRowCell>
+
+      </TableRowButton>
+    );
+  }
+}
+
+SelectTrackRow.propTypes = {
+  id: PropTypes.number.isRequired,
+  trackNumber: PropTypes.number.isRequired,
+  title: PropTypes.string.isRequired,
+  isSelected: PropTypes.bool,
+  onSelectedChange: PropTypes.func.isRequired
+};
+
+export default SelectTrackRow;