Initial Push

This commit is contained in:
Qstick
2020-10-18 04:18:35 -04:00
parent 09ed2ab889
commit e1020f4107
1845 changed files with 1516 additions and 113975 deletions

View File

@@ -1,71 +0,0 @@
import { createAction } from 'redux-actions';
import createFetchHandler from 'Store/Actions/Creators/createFetchHandler';
import createRemoveItemHandler from 'Store/Actions/Creators/createRemoveItemHandler';
import createSaveProviderHandler from 'Store/Actions/Creators/createSaveProviderHandler';
import createSetSettingValueReducer from 'Store/Actions/Creators/Reducers/createSetSettingValueReducer';
import { createThunk } from 'Store/thunks';
//
// Variables
const section = 'settings.importExclusions';
//
// Actions Types
export const FETCH_IMPORT_EXCLUSIONS = 'settings/importExclusions/fetchImportExclusions';
export const SAVE_IMPORT_EXCLUSION = 'settings/importExclusions/saveImportExclusion';
export const DELETE_IMPORT_EXCLUSION = 'settings/importExclusions/deleteImportExclusion';
export const SET_IMPORT_EXCLUSION_VALUE = 'settings/importExclusions/setImportExclusionValue';
//
// Action Creators
export const fetchImportExclusions = createThunk(FETCH_IMPORT_EXCLUSIONS);
export const saveImportExclusion = createThunk(SAVE_IMPORT_EXCLUSION);
export const deleteImportExclusion = createThunk(DELETE_IMPORT_EXCLUSION);
export const setImportExclusionValue = createAction(SET_IMPORT_EXCLUSION_VALUE, (payload) => {
return {
section,
...payload
};
});
//
// Details
export default {
//
// State
defaultState: {
isFetching: false,
isPopulated: false,
error: null,
items: [],
isSaving: false,
saveError: null,
pendingChanges: {}
},
//
// Action Handlers
actionHandlers: {
[FETCH_IMPORT_EXCLUSIONS]: createFetchHandler(section, '/exclusions'),
[SAVE_IMPORT_EXCLUSION]: createSaveProviderHandler(section, '/exclusions'),
[DELETE_IMPORT_EXCLUSION]: createRemoveItemHandler(section, '/exclusions')
},
//
// Reducers
reducers: {
[SET_IMPORT_EXCLUSION_VALUE]: createSetSettingValueReducer(section)
}
};

View File

@@ -1,64 +0,0 @@
import { createAction } from 'redux-actions';
import createFetchHandler from 'Store/Actions/Creators/createFetchHandler';
import createSaveHandler from 'Store/Actions/Creators/createSaveHandler';
import createSetSettingValueReducer from 'Store/Actions/Creators/Reducers/createSetSettingValueReducer';
import { createThunk } from 'Store/thunks';
//
// Variables
const section = 'settings.importListOptions';
//
// Actions Types
export const FETCH_IMPORT_LIST_OPTIONS = 'settings/importListOptions/fetchImportListOptions';
export const SAVE_IMPORT_LIST_OPTIONS = 'settings/importListOptions/saveImportListOptions';
export const SET_IMPORT_LIST_OPTIONS_VALUE = 'settings/importListOptions/setImportListOptionsValue';
//
// Action Creators
export const fetchImportListOptions = createThunk(FETCH_IMPORT_LIST_OPTIONS);
export const saveImportListOptions = createThunk(SAVE_IMPORT_LIST_OPTIONS);
export const setImportListOptionsValue = createAction(SET_IMPORT_LIST_OPTIONS_VALUE, (payload) => {
return {
section,
...payload
};
});
//
// Details
export default {
//
// State
defaultState: {
isFetching: false,
isPopulated: false,
error: null,
pendingChanges: {},
isSaving: false,
saveError: null,
item: {}
},
//
// Action Handlers
actionHandlers: {
[FETCH_IMPORT_LIST_OPTIONS]: createFetchHandler(section, '/config/importlist'),
[SAVE_IMPORT_LIST_OPTIONS]: createSaveHandler(section, '/config/importlist')
},
//
// Reducers
reducers: {
[SET_IMPORT_LIST_OPTIONS_VALUE]: createSetSettingValueReducer(section)
}
};

View File

@@ -1,116 +0,0 @@
import { createAction } from 'redux-actions';
import createFetchHandler from 'Store/Actions/Creators/createFetchHandler';
import createFetchSchemaHandler from 'Store/Actions/Creators/createFetchSchemaHandler';
import createRemoveItemHandler from 'Store/Actions/Creators/createRemoveItemHandler';
import createSaveProviderHandler, { createCancelSaveProviderHandler } from 'Store/Actions/Creators/createSaveProviderHandler';
import createTestAllProvidersHandler from 'Store/Actions/Creators/createTestAllProvidersHandler';
import createTestProviderHandler, { createCancelTestProviderHandler } from 'Store/Actions/Creators/createTestProviderHandler';
import createSetProviderFieldValueReducer from 'Store/Actions/Creators/Reducers/createSetProviderFieldValueReducer';
import createSetSettingValueReducer from 'Store/Actions/Creators/Reducers/createSetSettingValueReducer';
import { createThunk } from 'Store/thunks';
import selectProviderSchema from 'Utilities/State/selectProviderSchema';
//
// Variables
const section = 'settings.importLists';
//
// Actions Types
export const FETCH_IMPORT_LISTS = 'settings/importLists/fetchImportLists';
export const FETCH_IMPORT_LIST_SCHEMA = 'settings/importLists/fetchImportListSchema';
export const SELECT_IMPORT_LIST_SCHEMA = 'settings/importLists/selectImportListSchema';
export const SET_IMPORT_LIST_VALUE = 'settings/importLists/setImportListValue';
export const SET_IMPORT_LIST_FIELD_VALUE = 'settings/importLists/setImportListFieldValue';
export const SAVE_IMPORT_LIST = 'settings/importLists/saveImportList';
export const CANCEL_SAVE_IMPORT_LIST = 'settings/importLists/cancelSaveImportList';
export const DELETE_IMPORT_LIST = 'settings/importLists/deleteImportList';
export const TEST_IMPORT_LIST = 'settings/importLists/testImportList';
export const CANCEL_TEST_IMPORT_LIST = 'settings/importLists/cancelTestImportList';
export const TEST_ALL_IMPORT_LIST = 'settings/importLists/testAllImportList';
//
// Action Creators
export const fetchImportLists = createThunk(FETCH_IMPORT_LISTS);
export const fetchImportListSchema = createThunk(FETCH_IMPORT_LIST_SCHEMA);
export const selectImportListSchema = createAction(SELECT_IMPORT_LIST_SCHEMA);
export const saveImportList = createThunk(SAVE_IMPORT_LIST);
export const cancelSaveImportList = createThunk(CANCEL_SAVE_IMPORT_LIST);
export const deleteImportList = createThunk(DELETE_IMPORT_LIST);
export const testImportList = createThunk(TEST_IMPORT_LIST);
export const cancelTestImportList = createThunk(CANCEL_TEST_IMPORT_LIST);
export const testAllImportList = createThunk(TEST_ALL_IMPORT_LIST);
export const setImportListValue = createAction(SET_IMPORT_LIST_VALUE, (payload) => {
return {
section,
...payload
};
});
export const setImportListFieldValue = createAction(SET_IMPORT_LIST_FIELD_VALUE, (payload) => {
return {
section,
...payload
};
});
//
// Details
export default {
//
// State
defaultState: {
isFetching: false,
isPopulated: false,
error: null,
isSchemaFetching: false,
isSchemaPopulated: false,
schemaError: null,
schema: [],
selectedSchema: {},
isSaving: false,
saveError: null,
isTesting: false,
isTestingAll: false,
items: [],
pendingChanges: {}
},
//
// Action Handlers
actionHandlers: {
[FETCH_IMPORT_LISTS]: createFetchHandler(section, '/importlist'),
[FETCH_IMPORT_LIST_SCHEMA]: createFetchSchemaHandler(section, '/importlist/schema'),
[SAVE_IMPORT_LIST]: createSaveProviderHandler(section, '/importlist'),
[CANCEL_SAVE_IMPORT_LIST]: createCancelSaveProviderHandler(section),
[DELETE_IMPORT_LIST]: createRemoveItemHandler(section, '/importlist'),
[TEST_IMPORT_LIST]: createTestProviderHandler(section, '/importlist'),
[CANCEL_TEST_IMPORT_LIST]: createCancelTestProviderHandler(section),
[TEST_ALL_IMPORT_LIST]: createTestAllProvidersHandler(section, '/importlist')
},
//
// Reducers
reducers: {
[SET_IMPORT_LIST_VALUE]: createSetSettingValueReducer(section),
[SET_IMPORT_LIST_FIELD_VALUE]: createSetProviderFieldValueReducer(section),
[SELECT_IMPORT_LIST_SCHEMA]: (state, { payload }) => {
return selectProviderSchema(state, section, payload, (selectedSchema) => {
return selectedSchema;
});
}
}
};

View File

@@ -31,7 +31,7 @@ export const defaultState = {
messages: {
items: []
},
version: window.Radarr.version,
version: window.Prowlarr.version,
isUpdated: false,
isConnected: true,
isReconnecting: false,

View File

@@ -1,389 +0,0 @@
import _ from 'lodash';
import moment from 'moment';
import { createAction } from 'redux-actions';
import { batchActions } from 'redux-batched-actions';
import * as calendarViews from 'Calendar/calendarViews';
import * as commandNames from 'Commands/commandNames';
import { filterTypes } from 'Helpers/Props';
import { createThunk, handleThunks } from 'Store/thunks';
import createAjaxRequest from 'Utilities/createAjaxRequest';
import translate from 'Utilities/String/translate';
import { set, update } from './baseActions';
import { executeCommandHelper } from './commandActions';
import createHandleActions from './Creators/createHandleActions';
import createClearReducer from './Creators/Reducers/createClearReducer';
//
// Variables
export const section = 'calendar';
const viewRanges = {
[calendarViews.DAY]: 'day',
[calendarViews.WEEK]: 'week',
[calendarViews.MONTH]: 'month',
[calendarViews.FORECAST]: 'day'
};
//
// State
export const defaultState = {
isFetching: false,
isPopulated: false,
start: null,
end: null,
dates: [],
dayCount: 7,
view: window.innerWidth > 768 ? 'month' : 'day',
error: null,
items: [],
searchMissingCommandId: null,
options: {
showMovieInformation: true,
showCutoffUnmetIcon: false
},
selectedFilterKey: 'monitored',
filters: [
{
key: 'all',
label: translate('All'),
filters: [
{
key: 'monitored',
value: false,
type: filterTypes.EQUAL
}
]
},
{
key: 'monitored',
label: translate('MonitoredOnly'),
filters: [
{
key: 'monitored',
value: true,
type: filterTypes.EQUAL
}
]
}
]
};
export const persistState = [
'calendar.view',
'calendar.selectedFilterKey',
'calendar.options'
];
//
// Actions Types
export const FETCH_CALENDAR = 'calendar/fetchCalendar';
export const SET_CALENDAR_DAYS_COUNT = 'calendar/setCalendarDaysCount';
export const SET_CALENDAR_FILTER = 'calendar/setCalendarFilter';
export const SET_CALENDAR_VIEW = 'calendar/setCalendarView';
export const GOTO_CALENDAR_TODAY = 'calendar/gotoCalendarToday';
export const GOTO_CALENDAR_NEXT_RANGE = 'calendar/gotoCalendarNextRange';
export const CLEAR_CALENDAR = 'calendar/clearCalendar';
export const SET_CALENDAR_OPTION = 'calendar/setCalendarOption';
export const SEARCH_MISSING = 'calendar/searchMissing';
export const GOTO_CALENDAR_PREVIOUS_RANGE = 'calendar/gotoCalendarPreviousRange';
//
// Helpers
function getDays(start, end) {
const startTime = moment(start);
const endTime = moment(end);
const difference = endTime.diff(startTime, 'days');
// Difference is one less than the number of days we need to account for.
return _.times(difference + 1, (i) => {
return startTime.clone().add(i, 'days').toISOString();
});
}
function getDates(time, view, firstDayOfWeek, dayCount) {
const weekName = firstDayOfWeek === 0 ? 'week' : 'isoWeek';
let start = time.clone().startOf('day');
let end = time.clone().endOf('day');
if (view === calendarViews.WEEK) {
start = time.clone().startOf(weekName);
end = time.clone().endOf(weekName);
}
if (view === calendarViews.FORECAST) {
start = time.clone().subtract(1, 'day').startOf('day');
end = time.clone().add(dayCount - 2, 'days').endOf('day');
}
if (view === calendarViews.MONTH) {
start = time.clone().startOf('month').startOf(weekName);
end = time.clone().endOf('month').endOf(weekName);
}
if (view === calendarViews.AGENDA) {
start = time.clone().subtract(1, 'day').startOf('day');
end = time.clone().add(1, 'month').endOf('day');
}
return {
start: start.toISOString(),
end: end.toISOString(),
time: time.toISOString(),
dates: getDays(start, end)
};
}
function getPopulatableRange(startDate, endDate, view) {
switch (view) {
case calendarViews.DAY:
return {
start: moment(startDate).subtract(1, 'day').toISOString(),
end: moment(endDate).add(1, 'day').toISOString()
};
case calendarViews.WEEK:
case calendarViews.FORECAST:
return {
start: moment(startDate).subtract(1, 'week').toISOString(),
end: moment(endDate).add(1, 'week').toISOString()
};
default:
return {
start: startDate,
end: endDate
};
}
}
function isRangePopulated(start, end, state) {
const {
start: currentStart,
end: currentEnd,
view: currentView
} = state;
if (!currentStart || !currentEnd) {
return false;
}
const {
start: currentPopulatedStart,
end: currentPopulatedEnd
} = getPopulatableRange(currentStart, currentEnd, currentView);
if (
moment(start).isAfter(currentPopulatedStart) &&
moment(start).isBefore(currentPopulatedEnd)
) {
return true;
}
return false;
}
//
// Action Creators
export const fetchCalendar = createThunk(FETCH_CALENDAR);
export const setCalendarDaysCount = createThunk(SET_CALENDAR_DAYS_COUNT);
export const setCalendarFilter = createThunk(SET_CALENDAR_FILTER);
export const setCalendarView = createThunk(SET_CALENDAR_VIEW);
export const gotoCalendarToday = createThunk(GOTO_CALENDAR_TODAY);
export const gotoCalendarPreviousRange = createThunk(GOTO_CALENDAR_PREVIOUS_RANGE);
export const gotoCalendarNextRange = createThunk(GOTO_CALENDAR_NEXT_RANGE);
export const clearCalendar = createAction(CLEAR_CALENDAR);
export const setCalendarOption = createAction(SET_CALENDAR_OPTION);
export const searchMissing = createThunk(SEARCH_MISSING);
//
// Action Handlers
export const actionHandlers = handleThunks({
[FETCH_CALENDAR]: function(getState, payload, dispatch) {
const state = getState();
const calendar = state.calendar;
const unmonitored = calendar.selectedFilterKey === 'all';
const {
time = calendar.time,
view = calendar.view
} = payload;
const dayCount = state.calendar.dayCount;
const dates = getDates(moment(time), view, state.settings.ui.item.firstDayOfWeek, dayCount);
const { start, end } = getPopulatableRange(dates.start, dates.end, view);
const isPrePopulated = isRangePopulated(start, end, state.calendar);
const basesAttrs = {
section,
isFetching: true
};
const attrs = isPrePopulated ?
{
view,
...basesAttrs,
...dates
} :
basesAttrs;
dispatch(set(attrs));
const promise = createAjaxRequest({
url: '/calendar',
data: {
unmonitored,
start,
end
}
}).request;
promise.done((data) => {
dispatch(batchActions([
update({ section, data }),
set({
section,
view,
...dates,
isFetching: false,
isPopulated: true,
error: null
})
]));
});
promise.fail((xhr) => {
dispatch(set({
section,
isFetching: false,
isPopulated: false,
error: xhr
}));
});
},
[SET_CALENDAR_DAYS_COUNT]: function(getState, payload, dispatch) {
if (payload.dayCount === getState().calendar.dayCount) {
return;
}
dispatch(set({
section,
dayCount: payload.dayCount
}));
const state = getState();
const { time, view } = state.calendar;
dispatch(fetchCalendar({ time, view }));
},
[SET_CALENDAR_FILTER]: function(getState, payload, dispatch) {
dispatch(set({
section,
selectedFilterKey: payload.selectedFilterKey
}));
const state = getState();
const { time, view } = state.calendar;
dispatch(fetchCalendar({ time, view }));
},
[SET_CALENDAR_VIEW]: function(getState, payload, dispatch) {
const state = getState();
const view = payload.view;
const time = view === calendarViews.FORECAST || calendarViews.AGENDA ?
moment() :
state.calendar.time;
dispatch(fetchCalendar({ time, view }));
},
[GOTO_CALENDAR_TODAY]: function(getState, payload, dispatch) {
const state = getState();
const view = state.calendar.view;
const time = moment();
dispatch(fetchCalendar({ time, view }));
},
[GOTO_CALENDAR_PREVIOUS_RANGE]: function(getState, payload, dispatch) {
const state = getState();
const {
view,
dayCount
} = state.calendar;
const amount = view === calendarViews.FORECAST ? dayCount : 1;
const time = moment(state.calendar.time).subtract(amount, viewRanges[view]);
dispatch(fetchCalendar({ time, view }));
},
[GOTO_CALENDAR_NEXT_RANGE]: function(getState, payload, dispatch) {
const state = getState();
const {
view,
dayCount
} = state.calendar;
const amount = view === calendarViews.FORECAST ? dayCount : 1;
const time = moment(state.calendar.time).add(amount, viewRanges[view]);
dispatch(fetchCalendar({ time, view }));
},
[SEARCH_MISSING]: function(getState, payload, dispatch) {
const { movieIds } = payload;
const commandPayload = {
name: commandNames.MOVIE_SEARCH,
movieIds
};
executeCommandHelper(commandPayload, dispatch).then((data) => {
dispatch(set({
section,
searchMissingCommandId: data.id
}));
});
}
});
//
// Reducers
export const reducers = createHandleActions({
[CLEAR_CALENDAR]: createClearReducer(section, {
isFetching: false,
isPopulated: false,
error: null,
items: []
}),
[SET_CALENDAR_OPTION]: function(state, { payload }) {
const options = state.options;
return {
...state,
options: {
...options,
...payload
}
};
}
}, defaultState, section);

View File

@@ -1,688 +0,0 @@
import _ from 'lodash';
import { createAction } from 'redux-actions';
import { batchActions } from 'redux-batched-actions';
import { filterBuilderTypes, filterBuilderValueTypes, filterTypes, sortDirections } from 'Helpers/Props';
import { createThunk, handleThunks } from 'Store/thunks';
import sortByName from 'Utilities/Array/sortByName';
import createAjaxRequest from 'Utilities/createAjaxRequest';
import getNewMovie from 'Utilities/Movie/getNewMovie';
import getSectionState from 'Utilities/State/getSectionState';
import updateSectionState from 'Utilities/State/updateSectionState';
import translate from 'Utilities/String/translate';
import { removeItem, set, updateItem } from './baseActions';
import createHandleActions from './Creators/createHandleActions';
import createClearReducer from './Creators/Reducers/createClearReducer';
import createSetClientSideCollectionFilterReducer from './Creators/Reducers/createSetClientSideCollectionFilterReducer';
import createSetClientSideCollectionSortReducer from './Creators/Reducers/createSetClientSideCollectionSortReducer';
import createSetSettingValueReducer from './Creators/Reducers/createSetSettingValueReducer';
import createSetTableOptionReducer from './Creators/Reducers/createSetTableOptionReducer';
import { filterPredicates } from './movieActions';
//
// Variables
export const section = 'discoverMovie';
//
// State
export const defaultState = {
isFetching: false,
isPopulated: false,
error: null,
isAdding: false,
isAdded: false,
addError: null,
items: [],
sortKey: 'sortTitle',
sortDirection: sortDirections.ASCENDING,
secondarySortKey: 'sortTitle',
secondarySortDirection: sortDirections.ASCENDING,
view: 'overview',
options: {
includeRecommendations: true
},
defaults: {
rootFolderPath: '',
monitor: 'true',
qualityProfileId: 0,
minimumAvailability: 'announced',
tags: [],
searchForMovie: false
},
posterOptions: {
size: 'large',
showTitle: false
},
overviewOptions: {
detailedProgressBar: false,
size: 'medium',
showStudio: true,
showRatings: true,
showYear: true,
showCertification: true,
showGenres: true
},
tableOptions: {
// showSearchAction: false
},
columns: [
{
name: 'status',
columnLabel: translate('Status'),
isSortable: true,
isVisible: true,
isModifiable: false
},
{
name: 'isRecommendation',
columnLabel: 'Recommedation',
isSortable: true,
isVisible: true,
isModifiable: false
},
{
name: 'sortTitle',
label: translate('MovieTitle'),
isSortable: true,
isVisible: true,
isModifiable: false
},
{
name: 'collection',
label: translate('Collection'),
isSortable: true,
isVisible: false
},
{
name: 'studio',
label: translate('Studio'),
isSortable: true,
isVisible: true
},
{
name: 'inCinemas',
label: translate('InCinemas'),
isSortable: true,
isVisible: true
},
{
name: 'physicalRelease',
label: translate('PhysicalRelease'),
isSortable: true,
isVisible: false
},
{
name: 'digitalRelease',
label: translate('DigitalRelease'),
isSortable: true,
isVisible: false
},
{
name: 'runtime',
label: translate('Runtime'),
isSortable: true,
isVisible: false
},
{
name: 'genres',
label: translate('Genres'),
isSortable: false,
isVisible: false
},
{
name: 'ratings',
label: translate('Ratings'),
isSortable: true,
isVisible: false
},
{
name: 'certification',
label: translate('Certification'),
isSortable: true,
isVisible: false
},
{
name: 'lists',
label: 'Lists',
isSortable: false,
isVisible: false
},
{
name: 'actions',
columnLabel: translate('Actions'),
isVisible: true,
isModifiable: false
}
],
sortPredicates: {
status: function(item) {
let result = 0;
if (item.isExcluded) {
result += 4;
}
if (item.status === 'announced') {
result++;
}
if (item.status === 'inCinemas') {
result += 2;
}
if (item.status === 'released') {
result += 3;
}
return result;
},
collection: function(item) {
const { collection ={} } = item;
return collection.name;
},
studio: function(item) {
const studio = item.studio;
return studio ? studio.toLowerCase() : '';
},
ratings: function(item) {
const { ratings = {} } = item;
return ratings.value;
}
},
selectedFilterKey: 'newNotExcluded',
filters: [
{
key: 'all',
label: translate('All'),
filters: []
},
{
key: 'newNotExcluded',
label: 'New Non-Excluded',
filters: [
{
key: 'isExisting',
value: false,
type: filterTypes.EQUAL
},
{
key: 'isExcluded',
value: false,
type: filterTypes.EQUAL
}
]
}
],
filterPredicates,
filterBuilderProps: [
{
name: 'status',
label: 'Status',
type: filterBuilderTypes.EXACT,
valueType: filterBuilderValueTypes.MOVIE_STATUS
},
{
name: 'studio',
label: 'Studio',
type: filterBuilderTypes.ARRAY,
optionsSelector: function(items) {
const tagList = items.reduce((acc, movie) => {
acc.push({
id: movie.studio,
name: movie.studio
});
return acc;
}, []);
return tagList.sort(sortByName);
}
},
{
name: 'collection',
label: translate('Collection'),
type: filterBuilderTypes.ARRAY,
optionsSelector: function(items) {
const collectionList = items.reduce((acc, movie) => {
if (movie.collection) {
acc.push({
id: movie.collection.name,
name: movie.collection.name
});
}
return acc;
}, []);
return collectionList.sort(sortByName);
}
},
{
name: 'inCinemas',
label: 'In Cinemas',
type: filterBuilderTypes.DATE,
valueType: filterBuilderValueTypes.DATE
},
{
name: 'physicalRelease',
label: 'Physical Release',
type: filterBuilderTypes.DATE,
valueType: filterBuilderValueTypes.DATE
},
{
name: 'digitalRelease',
label: 'Digital Release',
type: filterBuilderTypes.DATE,
valueType: filterBuilderValueTypes.DATE
},
{
name: 'runtime',
label: translate('Runtime'),
type: filterBuilderTypes.NUMBER
},
{
name: 'genres',
label: 'Genres',
type: filterBuilderTypes.ARRAY,
optionsSelector: function(items) {
const tagList = items.reduce((acc, movie) => {
movie.genres.forEach((genre) => {
acc.push({
id: genre,
name: genre
});
});
return acc;
}, []);
return tagList.sort(sortByName);
}
},
{
name: 'ratings',
label: 'Rating',
type: filterBuilderTypes.NUMBER
},
{
name: 'certification',
label: 'Certification',
type: filterBuilderTypes.EXACT
},
{
name: 'lists',
label: 'Lists',
type: filterBuilderTypes.ARRAY,
valueType: filterBuilderValueTypes.IMPORTLIST
},
{
name: 'isExcluded',
label: 'On Excluded List',
type: filterBuilderTypes.EXACT,
valueType: filterBuilderValueTypes.BOOL
},
{
name: 'isExisting',
label: 'Exists in Library',
type: filterBuilderTypes.EXACT,
valueType: filterBuilderValueTypes.BOOL
},
{
name: 'isRecommendation',
label: 'Recommended',
type: filterBuilderTypes.EXACT,
valueType: filterBuilderValueTypes.BOOL
}
]
};
export const persistState = [
'discoverMovie.defaults',
'discoverMovie.sortKey',
'discoverMovie.sortDirection',
'discoverMovie.selectedFilterKey',
'discoverMovie.customFilters',
'discoverMovie.view',
'discoverMovie.columns',
'discoverMovie.options',
'discoverMovie.posterOptions',
'discoverMovie.overviewOptions',
'discoverMovie.tableOptions'
];
//
// Actions Types
export const ADD_MOVIE = 'discoverMovie/addMovie';
export const ADD_MOVIES = 'discoverMovie/addMovies';
export const SET_ADD_MOVIE_VALUE = 'discoverMovie/setAddMovieValue';
export const CLEAR_ADD_MOVIE = 'discoverMovie/clearAddMovie';
export const SET_ADD_MOVIE_DEFAULT = 'discoverMovie/setAddMovieDefault';
export const FETCH_DISCOVER_MOVIES = 'discoverMovie/fetchDiscoverMovies';
export const SET_LIST_MOVIE_SORT = 'discoverMovie/setListMovieSort';
export const SET_LIST_MOVIE_FILTER = 'discoverMovie/setListMovieFilter';
export const SET_LIST_MOVIE_VIEW = 'discoverMovie/setListMovieView';
export const SET_LIST_MOVIE_OPTION = 'discoverMovie/setListMovieMovieOption';
export const SET_LIST_MOVIE_TABLE_OPTION = 'discoverMovie/setListMovieTableOption';
export const SET_LIST_MOVIE_POSTER_OPTION = 'discoverMovie/setListMoviePosterOption';
export const SET_LIST_MOVIE_OVERVIEW_OPTION = 'discoverMovie/setListMovieOverviewOption';
export const ADD_IMPORT_EXCLUSIONS = 'discoverMovie/addImportExclusions';
//
// Action Creators
export const addMovie = createThunk(ADD_MOVIE);
export const addMovies = createThunk(ADD_MOVIES);
export const clearAddMovie = createAction(CLEAR_ADD_MOVIE);
export const setAddMovieDefault = createAction(SET_ADD_MOVIE_DEFAULT);
export const fetchDiscoverMovies = createThunk(FETCH_DISCOVER_MOVIES);
export const setListMovieSort = createAction(SET_LIST_MOVIE_SORT);
export const setListMovieFilter = createAction(SET_LIST_MOVIE_FILTER);
export const setListMovieView = createAction(SET_LIST_MOVIE_VIEW);
export const setListMovieOption = createAction(SET_LIST_MOVIE_OPTION);
export const setListMovieTableOption = createAction(SET_LIST_MOVIE_TABLE_OPTION);
export const setListMoviePosterOption = createAction(SET_LIST_MOVIE_POSTER_OPTION);
export const setListMovieOverviewOption = createAction(SET_LIST_MOVIE_OVERVIEW_OPTION);
export const addImportExclusions = createThunk(ADD_IMPORT_EXCLUSIONS);
export const setAddMovieValue = createAction(SET_ADD_MOVIE_VALUE, (payload) => {
return {
section,
...payload
};
});
//
// Action Handlers
export const actionHandlers = handleThunks({
[FETCH_DISCOVER_MOVIES]: function(getState, payload, dispatch) {
dispatch(set({ section, isFetching: true }));
const {
id,
...otherPayload
} = payload;
const includeRecommendations = getState().discoverMovie.options.includeRecommendations;
const promise = createAjaxRequest({
url: `/importlist/movie?includeRecommendations=${includeRecommendations}`,
data: otherPayload,
traditional: true
}).request;
promise.done((data) => {
// set an Id so the selectors and updaters done blow up.
data = data.map((movie) => ({ ...movie, id: movie.tmdbId }));
dispatch(batchActions([
...data.map((movie) => updateItem({ section, ...movie })),
set({
section,
isFetching: false,
isPopulated: true,
error: null
})
]));
});
promise.fail((xhr) => {
dispatch(set({
section,
isFetching: false,
isPopulated: false,
error: xhr.aborted ? null : xhr
}));
});
},
[ADD_MOVIE]: function(getState, payload, dispatch) {
dispatch(set({ section, isAdding: true }));
const tmdbId = payload.tmdbId;
const items = getState().discoverMovie.items;
const itemToUpdate = _.find(items, { tmdbId });
const newMovie = getNewMovie(_.cloneDeep(itemToUpdate), payload);
newMovie.id = 0;
const promise = createAjaxRequest({
url: '/movie',
method: 'POST',
contentType: 'application/json',
data: JSON.stringify(newMovie)
}).request;
promise.done((data) => {
dispatch(batchActions([
updateItem({ section: 'movies', ...data }),
itemToUpdate.lists.length === 0 ? removeItem({ section: 'discoverMovie', ...itemToUpdate }) :
updateItem({ section: 'discoverMovie', ...itemToUpdate, isExisting: true }),
set({
section,
isAdding: false,
isAdded: true,
addError: null
})
]));
});
promise.fail((xhr) => {
dispatch(set({
section,
isAdding: false,
isAdded: false,
addError: xhr
}));
});
},
[ADD_MOVIES]: function(getState, payload, dispatch) {
dispatch(set({ section, isAdding: true }));
const ids = payload.ids;
const addOptions = payload.addOptions;
const items = getState().discoverMovie.items;
const addedIds = [];
const allNewMovies = ids.reduce((acc, id) => {
const item = items.find((i) => i.id === id);
const selectedMovie = item;
// Make sure we have a selected movie and
// the same movie hasn't been added yet.
if (selectedMovie && !acc.some((a) => a.tmdbId === selectedMovie.tmdbId)) {
if (!selectedMovie.isExisting) {
const newMovie = getNewMovie(_.cloneDeep(selectedMovie), addOptions);
newMovie.id = 0;
addedIds.push(id);
acc.push(newMovie);
}
}
return acc;
}, []);
const promise = createAjaxRequest({
url: '/movie/import',
method: 'POST',
contentType: 'application/json',
data: JSON.stringify(allNewMovies)
}).request;
promise.done((data) => {
dispatch(batchActions([
set({
section,
isAdding: false,
isAdded: true
}),
...data.map((movie) => updateItem({ section: 'movies', ...movie })),
...addedIds.map((id) => (items.find((i) => i.id === id).lists.length === 0 ? removeItem({ section, id }) : updateItem({ section, id, isExisting: true })))
]));
});
promise.fail((xhr) => {
dispatch(
set({
section,
isAdding: false,
isAdded: true
})
);
});
},
[ADD_IMPORT_EXCLUSIONS]: function(getState, payload, dispatch) {
const ids = payload.ids;
const items = getState().discoverMovie.items;
const exclusions = ids.reduce((acc, id) => {
const item = items.find((i) => i.tmdbId === id);
const newExclusion = {
tmdbId: id,
movieTitle: item.title,
movieYear: item.year
};
acc.push(newExclusion);
return acc;
}, []);
const promise = createAjaxRequest({
url: '/exclusions/bulk',
method: 'POST',
data: JSON.stringify(exclusions)
}).request;
promise.done((data) => {
dispatch(batchActions([
...data.map((item) => updateItem({ section: 'settings.importExclusions', ...item })),
...data.map((item) => updateItem({ section, id: item.tmdbId, isExcluded: true })),
set({
section,
isSaving: false,
saveError: null
})
]));
});
promise.fail((xhr) => {
dispatch(set({
section,
isSaving: false,
saveError: xhr
}));
});
}
});
//
// Reducers
export const reducers = createHandleActions({
[SET_ADD_MOVIE_VALUE]: createSetSettingValueReducer(section),
[SET_ADD_MOVIE_DEFAULT]: function(state, { payload }) {
const newState = getSectionState(state, section);
newState.defaults = {
...newState.defaults,
...payload
};
return updateSectionState(state, section, newState);
},
[SET_LIST_MOVIE_SORT]: createSetClientSideCollectionSortReducer(section),
[SET_LIST_MOVIE_FILTER]: createSetClientSideCollectionFilterReducer(section),
[SET_LIST_MOVIE_VIEW]: function(state, { payload }) {
return Object.assign({}, state, { view: payload.view });
},
[SET_LIST_MOVIE_OPTION]: function(state, { payload }) {
const discoveryMovieOptions = state.options;
return {
...state,
options: {
...discoveryMovieOptions,
...payload
}
};
},
[SET_LIST_MOVIE_TABLE_OPTION]: createSetTableOptionReducer(section),
[SET_LIST_MOVIE_POSTER_OPTION]: function(state, { payload }) {
const posterOptions = state.posterOptions;
return {
...state,
posterOptions: {
...posterOptions,
...payload
}
};
},
[SET_LIST_MOVIE_OVERVIEW_OPTION]: function(state, { payload }) {
const overviewOptions = state.overviewOptions;
return {
...state,
overviewOptions: {
...overviewOptions,
...payload
}
};
},
[CLEAR_ADD_MOVIE]: createClearReducer(section, {
isFetching: false,
isPopulated: false,
error: null,
items: []
})
}, defaultState, section);

View File

@@ -1,11 +1,9 @@
import * as addMovie from './addMovieActions';
import * as app from './appActions';
import * as blacklist from './blacklistActions';
import * as calendar from './calendarActions';
import * as captcha from './captchaActions';
import * as commands from './commandActions';
import * as customFilters from './customFilterActions';
import * as discoverMovie from './discoverMovieActions';
import * as extraFiles from './extraFileActions';
import * as history from './historyActions';
import * as importMovie from './importMovieActions';
@@ -31,11 +29,9 @@ export default [
addMovie,
app,
blacklist,
calendar,
captcha,
commands,
customFilters,
discoverMovie,
movieFiles,
extraFiles,
history,

View File

@@ -14,7 +14,7 @@ import createHandleActions from './Creators/createHandleActions';
// Variables
export const section = 'oAuth';
const callbackUrl = `${window.location.origin}${window.Radarr.urlBase}/oauth.html`;
const callbackUrl = `${window.location.origin}${window.Prowlarr.urlBase}/oauth.html`;
//
// State

View File

@@ -7,9 +7,6 @@ import delayProfiles from './Settings/delayProfiles';
import downloadClientOptions from './Settings/downloadClientOptions';
import downloadClients from './Settings/downloadClients';
import general from './Settings/general';
import importExclusions from './Settings/importExclusions';
import importListOptions from './Settings/importListOptions';
import importLists from './Settings/importLists';
import indexerFlags from './Settings/indexerFlags';
import indexerOptions from './Settings/indexerOptions';
import indexers from './Settings/indexers';
@@ -36,9 +33,6 @@ export * from './Settings/indexerFlags';
export * from './Settings/indexerOptions';
export * from './Settings/indexers';
export * from './Settings/languages';
export * from './Settings/importExclusions';
export * from './Settings/importListOptions';
export * from './Settings/importLists';
export * from './Settings/mediaManagement';
export * from './Settings/metadata';
export * from './Settings/metadataOptions';
@@ -72,9 +66,6 @@ export const defaultState = {
indexerOptions: indexerOptions.defaultState,
indexers: indexers.defaultState,
languages: languages.defaultState,
importExclusions: importExclusions.defaultState,
importListOptions: importListOptions.defaultState,
importLists: importLists.defaultState,
mediaManagement: mediaManagement.defaultState,
metadata: metadata.defaultState,
metadataOptions: metadataOptions.defaultState,
@@ -116,9 +107,6 @@ export const actionHandlers = handleThunks({
...indexerOptions.actionHandlers,
...indexers.actionHandlers,
...languages.actionHandlers,
...importExclusions.actionHandlers,
...importListOptions.actionHandlers,
...importLists.actionHandlers,
...mediaManagement.actionHandlers,
...metadata.actionHandlers,
...metadataOptions.actionHandlers,
@@ -151,9 +139,6 @@ export const reducers = createHandleActions({
...indexerOptions.reducers,
...indexers.reducers,
...languages.reducers,
...importExclusions.reducers,
...importListOptions.reducers,
...importLists.reducers,
...mediaManagement.reducers,
...metadata.reducers,
...metadataOptions.reducers,