secstate/Iris
Public Access
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Auto eslint fix

Browse Source
This commit is contained in:
James Barnsley
2019-09-05 15:36:11 +12:00
parent 4513a0d109
commit e4d53a2d35
126 changed files with 23283 additions and 23573 deletions
Download Patch File Download Diff File Expand all files Collapse all files

570
src/js/services/core/actions.js
View File

@ -1,101 +1,102 @@
import * as helpers from '../../helpers'
var spotifyActions = require('../../services/spotify/actions')
var mopidyActions = require('../../services/mopidy/actions')
import * as helpers from '../../helpers';
export function getBroadcasts(){
return (dispatch, getState) => {
var config = {
method: 'GET',
timeout: 15000
}
const spotifyActions = require('../../services/spotify/actions');
const mopidyActions = require('../../services/mopidy/actions');
// Fetch the "iris_broadcasts.json" file from Gist (or "_test" for test mode)
if (getState().ui.test_mode){
config.url = 'https://gist.githubusercontent.com/jaedb/cb3a5ee6909632abb2e0fe66d4c8c311/raw'
} else {
config.url = 'https://gist.githubusercontent.com/jaedb/b677dccf80daf3ccb2ef12e96e495677/raw'
}
export function getBroadcasts() {
return (dispatch, getState) => {
const config = {
method: 'GET',
timeout: 15000,
};
$.ajax(config).then(
response => {
dispatch({
type: 'BROADCASTS_LOADED',
broadcasts: JSON.parse(response)
})
},
(xhr, status, error) => {
dispatch(
handleException(
'Could not fetch broadcasts from GitHub',
{
config: config,
xhr: xhr,
status: status,
error: error
},
null,
false
)
);
}
)
// Fetch the "iris_broadcasts.json" file from Gist (or "_test" for test mode)
if (getState().ui.test_mode) {
config.url = 'https://gist.githubusercontent.com/jaedb/cb3a5ee6909632abb2e0fe66d4c8c311/raw';
} else {
config.url = 'https://gist.githubusercontent.com/jaedb/b677dccf80daf3ccb2ef12e96e495677/raw';
}
$.ajax(config).then(
(response) => {
dispatch({
type: 'BROADCASTS_LOADED',
broadcasts: JSON.parse(response),
});
},
(xhr, status, error) => {
dispatch(
handleException(
'Could not fetch broadcasts from GitHub',
{
config,
xhr,
status,
error,
},
null,
false,
),
);
},
);
};
}
export function startSearch(search_type, query, only_mopidy = false){
return {
type: 'SEARCH_STARTED',
search_type: search_type,
query: query,
only_mopidy: only_mopidy
}
export function startSearch(search_type, query, only_mopidy = false) {
return {
type: 'SEARCH_STARTED',
search_type,
query,
only_mopidy,
};
}
export function handleException(message, data = {}, description = null, show_notification = true){
if (!message && data.message){
message = data.message;
} else if (!message && data.error.message){
message = data.error.message;
}
if (!description && data.description){
description = data.description;
} else if (!description && data.error && data.error.description){
description = data.error.description;
}
return {
type: 'HANDLE_EXCEPTION',
message: message,
description: description,
data: data,
show_notification: show_notification
}
export function handleException(message, data = {}, description = null, show_notification = true) {
if (!message && data.message) {
message = data.message;
} else if (!message && data.error.message) {
message = data.error.message;
}
if (!description && data.description) {
description = data.description;
} else if (!description && data.error && data.error.description) {
description = data.error.description;
}
return {
type: 'HANDLE_EXCEPTION',
message,
description,
data,
show_notification,
};
}
export function debugResponse(response){
return {
type: 'DEBUG',
response: response
}
export function debugResponse(response) {
return {
type: 'DEBUG',
response,
};
}
export function set(data){
return {
type: 'CORE_SET',
data: data
}
export function set(data) {
return {
type: 'CORE_SET',
data,
};
}
export function clearCurrentTrack(){
return {
type: 'CLEAR_CURRENT_TRACK'
}
export function clearCurrentTrack() {
return {
type: 'CLEAR_CURRENT_TRACK',
};
}
export function cachebustHttpStream(){
return {
type: 'CACHEBUST_HTTP_STREAM'
}
export function cachebustHttpStream() {
return {
type: 'CACHEBUST_HTTP_STREAM',
};
}
/**
@ -104,54 +105,54 @@ export function cachebustHttpStream(){
* Calling this through the common core enables us to detect whether we've already
* got the record in the state or persistent storage. Failing that, we pass off to the
* relevant service to load the record - all from one neat package.
**/
* */
export function loadTrack(uri, force_reload = false){
return {
type: 'LOAD_TRACK',
uri: uri,
force_reload: force_reload
}
export function loadTrack(uri, force_reload = false) {
return {
type: 'LOAD_TRACK',
uri,
force_reload,
};
}
export function loadAlbum(uri, force_reload = false){
return {
type: 'LOAD_ALBUM',
uri: uri,
force_reload: force_reload
}
export function loadAlbum(uri, force_reload = false) {
return {
type: 'LOAD_ALBUM',
uri,
force_reload,
};
}
export function loadArtist(uri, force_reload = false){
return {
type: 'LOAD_ARTIST',
uri: uri,
force_reload: force_reload
}
export function loadArtist(uri, force_reload = false) {
return {
type: 'LOAD_ARTIST',
uri,
force_reload,
};
}
export function loadPlaylist(uri, force_reload = false){
return {
type: 'LOAD_PLAYLIST',
uri: uri,
force_reload: force_reload
}
export function loadPlaylist(uri, force_reload = false) {
return {
type: 'LOAD_PLAYLIST',
uri,
force_reload,
};
}
export function loadUser(uri, force_reload = false){
return {
type: 'LOAD_USER',
uri: uri,
force_reload: force_reload
}
export function loadUser(uri, force_reload = false) {
return {
type: 'LOAD_USER',
uri,
force_reload,
};
}
export function loadUserPlaylists(uri, force_reload = false){
return {
type: 'LOAD_USER_PLAYLISTS',
uri: uri,
force_reload: force_reload
}
export function loadUserPlaylists(uri, force_reload = false) {
return {
type: 'LOAD_USER_PLAYLISTS',
uri,
force_reload,
};
}
@ -159,225 +160,218 @@ export function loadUserPlaylists(uri, force_reload = false){
* Record loaders
*
* We've got a loaded record, now we just need to plug it in to our state and stores.
**/
* */
export function trackLoaded(track){
return tracksLoaded([track]);
export function trackLoaded(track) {
return tracksLoaded([track]);
}
export function tracksLoaded(tracks){
return {
type: 'TRACKS_LOADED',
tracks: tracks
}
export function tracksLoaded(tracks) {
return {
type: 'TRACKS_LOADED',
tracks,
};
}
export function artistLoaded(artist){
return artistsLoaded([artist]);
export function artistLoaded(artist) {
return artistsLoaded([artist]);
}
export function artistsLoaded(artists){
return {
type: 'ARTISTS_LOADED',
artists: artists
}
export function artistsLoaded(artists) {
return {
type: 'ARTISTS_LOADED',
artists,
};
}
export function albumLoaded(album){
return albumsLoaded([album]);
export function albumLoaded(album) {
return albumsLoaded([album]);
}
export function albumsLoaded(albums){
return {
type: 'ALBUMS_LOADED',
albums: albums
}
export function albumsLoaded(albums) {
return {
type: 'ALBUMS_LOADED',
albums,
};
}
export function playlistLoaded(playlist){
return playlistsLoaded([playlist]);
export function playlistLoaded(playlist) {
return playlistsLoaded([playlist]);
}
export function playlistsLoaded(playlists){
return {
type: 'PLAYLISTS_LOADED',
playlists: playlists
}
export function playlistsLoaded(playlists) {
return {
type: 'PLAYLISTS_LOADED',
playlists,
};
}
export function userLoaded(user){
return usersLoaded([user]);
export function userLoaded(user) {
return usersLoaded([user]);
}
export function usersLoaded(users){
return {
type: 'USERS_LOADED',
users: users
}
export function usersLoaded(users) {
return {
type: 'USERS_LOADED',
users,
};
}
export function userPlaylistsLoaded(uri, playlists, more = null, total = null){
return {
type: 'USER_PLAYLISTS_LOADED',
uri: uri,
playlists: playlists,
more: more,
total: total
}
export function userPlaylistsLoaded(uri, playlists, more = null, total = null) {
return {
type: 'USER_PLAYLISTS_LOADED',
uri,
playlists,
more,
total,
};
}
export function loadedMore(parent_type, parent_key, records_type, records_data){
return {
type: 'LOADED_MORE',
parent_type: parent_type,
parent_key: parent_key,
records_type: records_type,
records_data: records_data
}
export function loadedMore(parent_type, parent_key, records_type, records_data) {
return {
type: 'LOADED_MORE',
parent_type,
parent_key,
records_type,
records_data,
};
}
export function removeFromIndex(index_name, key, new_key = null){
return {
type: 'REMOVE_FROM_INDEX',
index_name: index_name,
key: key,
new_key: new_key
}
export function removeFromIndex(index_name, key, new_key = null) {
return {
type: 'REMOVE_FROM_INDEX',
index_name,
key,
new_key,
};
}
/**
* Playlist manipulation
**/
* */
export function reorderPlaylistTracks(uri, indexes, insert_before, snapshot_id = false){
var range = helpers.createRange(indexes);
switch(helpers.uriSource(uri)){
export function reorderPlaylistTracks(uri, indexes, insert_before, snapshot_id = false) {
const range = helpers.createRange(indexes);
switch (helpers.uriSource(uri)) {
case 'spotify':
return {
type: 'SPOTIFY_REORDER_PLAYLIST_TRACKS',
key: uri,
range_start: range.start,
range_length: range.length,
insert_before,
snapshot_id,
};
case 'spotify':
return {
type: 'SPOTIFY_REORDER_PLAYLIST_TRACKS',
key: uri,
range_start: range.start,
range_length: range.length,
insert_before: insert_before,
snapshot_id: snapshot_id
}
case 'm3u':
return {
type: 'MOPIDY_REORDER_PLAYLIST_TRACKS',
key: uri,
range_start: range.start,
range_length: range.length,
insert_before: insert_before
}
}
case 'm3u':
return {
type: 'MOPIDY_REORDER_PLAYLIST_TRACKS',
key: uri,
range_start: range.start,
range_length: range.length,
insert_before,
};
}
}
export function savePlaylist(uri, name, description = '', is_public = false, is_collaborative = false, image = null){
switch (helpers.uriSource(uri)){
export function savePlaylist(uri, name, description = '', is_public = false, is_collaborative = false, image = null) {
switch (helpers.uriSource(uri)) {
case 'spotify':
return {
type: 'SPOTIFY_SAVE_PLAYLIST',
key: uri,
name,
description: (description == '' ? null : description),
image,
is_public,
is_collaborative,
};
case 'spotify':
return {
type: 'SPOTIFY_SAVE_PLAYLIST',
key: uri,
name: name,
description: (description == '' ? null : description),
image: image,
is_public: is_public,
is_collaborative: is_collaborative
}
case 'm3u':
return {
type: 'MOPIDY_SAVE_PLAYLIST',
key: uri,
name: name
}
}
return false
case 'm3u':
return {
type: 'MOPIDY_SAVE_PLAYLIST',
key: uri,
name,
};
}
return false;
}
export function createPlaylist(scheme, name, description = '', is_public = false, is_collaborative = false){
switch (scheme){
export function createPlaylist(scheme, name, description = '', is_public = false, is_collaborative = false) {
switch (scheme) {
case 'spotify':
if (description == '') {
description = null;
}
return spotifyActions.createPlaylist(name, description, is_public, is_collaborative);
case 'spotify':
if (description == ''){
description = null
}
return spotifyActions.createPlaylist(name, description, is_public, is_collaborative )
default:
return mopidyActions.createPlaylist(name, scheme)
}
return false
default:
return mopidyActions.createPlaylist(name, scheme);
}
return false;
}
export function deletePlaylist(uri){
switch (helpers.uriSource(uri)){
export function deletePlaylist(uri) {
switch (helpers.uriSource(uri)) {
case 'spotify':
return spotifyActions.following(uri, 'DELETE');
case 'spotify':
return spotifyActions.following(uri, 'DELETE')
default:
return mopidyActions.deletePlaylist(uri)
}
return false
default:
return mopidyActions.deletePlaylist(uri);
}
return false;
}
export function removeTracksFromPlaylist(uri, tracks_indexes){
switch(helpers.uriSource(uri )){
export function removeTracksFromPlaylist(uri, tracks_indexes) {
switch (helpers.uriSource(uri)) {
case 'spotify':
return {
type: 'SPOTIFY_REMOVE_PLAYLIST_TRACKS',
key: uri,
tracks_indexes,
};
case 'spotify':
return {
type: 'SPOTIFY_REMOVE_PLAYLIST_TRACKS',
key: uri,
tracks_indexes: tracks_indexes
}
case 'm3u':
return {
type: 'MOPIDY_REMOVE_PLAYLIST_TRACKS',
key: uri,
tracks_indexes: tracks_indexes
}
}
case 'm3u':
return {
type: 'MOPIDY_REMOVE_PLAYLIST_TRACKS',
key: uri,
tracks_indexes,
};
}
}
export function addTracksToPlaylist(uri, tracks_uris){
switch(helpers.uriSource(uri )){
export function addTracksToPlaylist(uri, tracks_uris) {
switch (helpers.uriSource(uri)) {
case 'spotify':
return {
type: 'SPOTIFY_ADD_PLAYLIST_TRACKS',
key: uri,
tracks_uris,
};
case 'spotify':
return {
type: 'SPOTIFY_ADD_PLAYLIST_TRACKS',
key: uri,
tracks_uris: tracks_uris
}
case 'm3u':
return {
type: 'MOPIDY_ADD_PLAYLIST_TRACKS',
key: uri,
tracks_uris: tracks_uris
}
}
case 'm3u':
return {
type: 'MOPIDY_ADD_PLAYLIST_TRACKS',
key: uri,
tracks_uris,
};
}
}
/**
* Asset libraries
**/
* */
export function getLibraryPlaylists(){
return {
type: 'GET_LIBRARY_PLAYLISTS'
}
export function getLibraryPlaylists() {
return {
type: 'GET_LIBRARY_PLAYLISTS',
};
}
export function getLibraryAlbums(){
return {
type: 'GET_LIBRARY_ALBUMS'
}
export function getLibraryAlbums() {
return {
type: 'GET_LIBRARY_ALBUMS',
};
}
export function getLibraryArtists(){
return {
type: 'GET_LIBRARY_ARTISTS'
}
export function getLibraryArtists() {
return {
type: 'GET_LIBRARY_ARTISTS',
};
}

1224
src/js/services/core/middleware.js
View File

File diff suppressed because it is too large Load Diff

451
src/js/services/core/reducer.js
View File

@ -1,306 +1,291 @@
import * as helpers from '../../helpers'
import * as helpers from '../../helpers';
export default function reducer(core = {}, action){
switch (action.type){
export default function reducer(core = {}, action) {
switch (action.type) {
case 'CORE_SET':
return { ...core, ...action.data };
case 'CORE_SET':
return Object.assign({}, core, action.data)
case 'CACHEBUST_HTTP_STREAM':
return { ...core, http_streaming_cachebuster: new Date().getTime() };
case 'CACHEBUST_HTTP_STREAM':
return Object.assign({}, core, {http_streaming_cachebuster: new Date().getTime()})
/**
/**
* Current track and tracklist
**/
* */
case 'CURRENT_TRACK_LOADED':
return Object.assign({}, core, {
current_track: action.track,
current_track_uri: action.uri
});
case 'CURRENT_TRACK_LOADED':
return {
...core,
current_track: action.track,
current_track_uri: action.uri,
};
case 'CLEAR_CURRENT_TRACK':
return Object.assign({}, core, {
current_track: null,
current_track_uri: null
});
case 'CLEAR_CURRENT_TRACK':
return {
...core,
current_track: null,
current_track_uri: null,
};
case 'NEXT_TRACK_LOADED':
return Object.assign({}, core, {
next_track_uri: action.uri
});
case 'NEXT_TRACK_LOADED':
return { ...core, next_track_uri: action.uri };
case 'QUEUE_LOADED':
return Object.assign({}, core, {
queue: action.tracks
});
case 'QUEUE_LOADED':
return { ...core, queue: action.tracks };
case 'PUSHER_QUEUE_METADATA':
case 'PUSHER_QUEUE_METADATA_CHANGED':
var tracklist = Object.assign([], core.current_tracklist)
for(var i = 0; i < tracklist.length; i++){
case 'PUSHER_QUEUE_METADATA':
case 'PUSHER_QUEUE_METADATA_CHANGED':
var tracklist = Object.assign([], core.current_tracklist);
for (let i = 0; i < tracklist.length; i++) {
// load our metadata (if we have any for that tlid)
if (action.queue_metadata[`tlid_${tracklist[i].tlid}`] !== undefined) {
tracklist[i] = {
// load our metadata (if we have any for that tlid)
if (action.queue_metadata['tlid_'+tracklist[i].tlid] !== undefined){
tracklist[i] = Object.assign(
{},
tracklist[i],
action.queue_metadata['tlid_'+tracklist[i].tlid],
)
}
}
return Object.assign({}, core, { current_tracklist: tracklist, queue_metadata: action.queue_metadata });
...tracklist[i],
...action.queue_metadata[`tlid_${tracklist[i].tlid}`],
};
}
}
return { ...core, current_tracklist: tracklist, queue_metadata: action.queue_metadata };
case 'PUSHER_RADIO_LOADED':
case 'PUSHER_RADIO_STARTED':
case 'PUSHER_RADIO_CHANGED':
case 'PUSHER_RADIO_STOPPED':
return Object.assign({}, core, { seeds_resolved: false }, { radio: action.radio })
case 'PUSHER_RADIO_LOADED':
case 'PUSHER_RADIO_STARTED':
case 'PUSHER_RADIO_CHANGED':
case 'PUSHER_RADIO_STOPPED':
return { ...core, seeds_resolved: false, radio: action.radio };
case 'RADIO_SEEDS_RESOLVED':
var radio = Object.assign({}, core.radio, { resolved_seeds: action.resolved_seeds })
return Object.assign({}, core, { radio: radio })
case 'RADIO_SEEDS_RESOLVED':
var radio = { ...core.radio, resolved_seeds: action.resolved_seeds };
return { ...core, radio };
/**
/**
* Index updates
* These actions are only ever called by middleware after we've digested one more many assets
* and appended to their relevant index.
**/
* */
case 'TRACKS_LOADED':
var tracks = Object.assign({}, core.tracks);
for (var track of action.tracks){
tracks[track.uri] = track;
}
return Object.assign({}, core, { tracks: tracks });
case 'TRACKS_LOADED':
var tracks = { ...core.tracks };
for (const track of action.tracks) {
tracks[track.uri] = track;
}
return { ...core, tracks };
case 'ALBUMS_LOADED':
var albums = Object.assign({}, core.albums);
for (var album of action.albums){
albums[album.uri] = album;
}
return Object.assign({}, core, { albums: albums });
case 'ALBUMS_LOADED':
var albums = { ...core.albums };
for (const album of action.albums) {
albums[album.uri] = album;
}
return { ...core, albums };
case 'ARTISTS_LOADED':
var artists = Object.assign({}, core.artists);
for (var artist of action.artists){
artists[artist.uri] = artist;
}
return Object.assign({}, core, { artists: artists });
case 'ARTISTS_LOADED':
var artists = { ...core.artists };
for (var artist of action.artists) {
artists[artist.uri] = artist;
}
return { ...core, artists };
case 'PLAYLISTS_LOADED':
var playlists = Object.assign({}, core.playlists);
for (var playlist of action.playlists){
playlists[playlist.uri] = playlist;
}
return Object.assign({}, core, { playlists: playlists });
case 'PLAYLISTS_LOADED':
var playlists = { ...core.playlists };
for (var playlist of action.playlists) {
playlists[playlist.uri] = playlist;
}
return { ...core, playlists };
case 'USERS_LOADED':
var users = Object.assign({}, core.users);
for (var user of action.users){
users[user.uri] = user;
}
return Object.assign({}, core, { users: users });
case 'USERS_LOADED':
var users = { ...core.users };
for (var user of action.users) {
users[user.uri] = user;
}
return { ...core, users };
case 'ARTIST_ALBUMS_LOADED':
var artists = Object.assign({}, core.artists)
var albums_uris = [];
if (artists[action.artist_uri].albums_uris){
albums_uris = artists[action.artist_uri].albums_uris;
}
case 'ARTIST_ALBUMS_LOADED':
var artists = { ...core.artists };
var albums_uris = [];
if (artists[action.artist_uri].albums_uris) {
albums_uris = artists[action.artist_uri].albums_uris;
}
var artist = Object.assign(
{},
artists[action.artist_uri],
{
albums_uris: [...albums_uris, ...action.albums_uris],
albums_more: action.more,
albums_total: action.total
}
)
artists[action.artist_uri] = artist
return Object.assign({}, core, { artists: artists });
var artist = {
...artists[action.artist_uri],
albums_uris: [...albums_uris, ...action.albums_uris],
albums_more: action.more,
albums_total: action.total,
};
artists[action.artist_uri] = artist;
return { ...core, artists };
case 'USER_PLAYLISTS_LOADED':
var users = Object.assign({}, core.users)
var existing_playlists_uris = [];
if (users[action.uri] && users[action.uri].playlists_uris){
case 'USER_PLAYLISTS_LOADED':
var users = { ...core.users };
var existing_playlists_uris = [];
if (users[action.uri] && users[action.uri].playlists_uris) {
existing_playlists_uris = users[action.uri].playlists_uris;
}
}
var playlists_uris = [...existing_playlists_uris, ...helpers.arrayOf('uri',action.playlists)]
var playlists_uris = [...existing_playlists_uris, ...helpers.arrayOf('uri', action.playlists)];
var user = Object.assign(
{},
users[action.uri],
{
playlists_uris: playlists_uris,
playlists_more: action.more,
playlists_total: action.total
}
)
users[action.uri] = user;
return Object.assign({}, core, { users: users });
var user = {
...users[action.uri],
playlists_uris,
playlists_more: action.more,
playlists_total: action.total,
};
users[action.uri] = user;
return { ...core, users };
/**
/**
* Remove an item from an index
**/
* */
case 'REMOVE_FROM_INDEX':
var index = Object.assign({}, core[action.index_name]);
case 'REMOVE_FROM_INDEX':
var index = { ...core[action.index_name] };
// We have a new key to redirect to
if (action.new_key){
// We have a new key to redirect to
if (action.new_key) {
index[action.key] = {
moved_to: action.new_key
}
moved_to: action.new_key,
};
// No redirection, so just a clean delete
} else {
// No redirection, so just a clean delete
} else {
delete index[action.key];
}
}
var updated_core = {};
updated_core[action.index_name] = index;
var updated_core = {};
updated_core[action.index_name] = index;
return Object.assign({}, core, updated_core);
return { ...core, ...updated_core };
/**
/**
* Playlists
**/
* */
case 'PLAYLIST_TRACKS':
var playlists = Object.assign({}, core.playlists)
var playlist = Object.assign({}, playlists[action.key], { tracks_uris: action.tracks_uris })
case 'PLAYLIST_TRACKS':
var playlists = { ...core.playlists };
var playlist = { ...playlists[action.key], tracks_uris: action.tracks_uris };
playlists[action.key] = playlist
return Object.assign({}, core, { playlists: playlists });
playlists[action.key] = playlist;
return { ...core, playlists };
case 'LIBRARY_PLAYLISTS_LOADED':
if (core.library_playlists){
var library_playlists = [...core.library_playlists, ...action.uris]
} else {
var library_playlists = action.uris
}
case 'LIBRARY_PLAYLISTS_LOADED':
if (core.library_playlists) {
var library_playlists = [...core.library_playlists, ...action.uris];
} else {
var library_playlists = action.uris;
}
library_playlists = helpers.removeDuplicates(library_playlists)
library_playlists = helpers.removeDuplicates(library_playlists);
return Object.assign({}, core, {
library_playlists: library_playlists,
library_playlists_started: true
});
return {
...core,
library_playlists,
library_playlists_started: true,
};
/**
/**
* Genres
**/
* */
case 'SPOTIFY_GENRES_LOADED':
return Object.assign({}, core, {genres: action.genres})
case 'SPOTIFY_GENRES_LOADED':
return { ...core, genres: action.genres };
/**
/**
* Search results
**/
* */
case 'SEARCH_STARTED':
return Object.assign({}, core, {
search_results: {
artists_uris: [],
albums_uris: [],
playlists_uris: [],
tracks: [],
}
});
case 'SEARCH_STARTED':
return {
...core,
search_results: {
artists_uris: [],
albums_uris: [],
playlists_uris: [],
tracks: [],
},
};
case 'SEARCH_RESULTS_LOADED':
case 'SEARCH_RESULTS_LOADED':
// artists
if (core.search_results && core.search_results.artists_uris){
var artists_uris = core.search_results.artists_uris
} else {
var artists_uris = []
}
if (action.artists_uris) artists_uris = [...artists_uris, ...action.artists_uris]
// artists
if (core.search_results && core.search_results.artists_uris) {
var { artists_uris } = core.search_results;
} else {
var artists_uris = [];
}
if (action.artists_uris) artists_uris = [...artists_uris, ...action.artists_uris];
// more tracks
if (typeof(action.artists_more) !== 'undefined') var artists_more = action.artists_more
else if (core.search_results && core.search_results.artists_more) var artists_more = core.search_results.artists_more
else var artists_more = null
// more tracks
if (typeof (action.artists_more) !== 'undefined') var { artists_more } = action;
else if (core.search_results && core.search_results.artists_more) var { artists_more } = core.search_results;
else var artists_more = null;
// albums
if (core.search_results && core.search_results.albums_uris){
var albums_uris = core.search_results.albums_uris
} else {
var albums_uris = []
}
if (action.albums_uris) albums_uris = [...albums_uris, ...action.albums_uris]
// albums
if (core.search_results && core.search_results.albums_uris) {
var { albums_uris } = core.search_results;
} else {
var albums_uris = [];
}
if (action.albums_uris) albums_uris = [...albums_uris, ...action.albums_uris];
// more tracks
if (typeof(action.albums_more) !== 'undefined') var albums_more = action.albums_more
else if (core.search_results && core.search_results.albums_more) var albums_more = core.search_results.albums_more
else var albums_more = null
// more tracks
if (typeof (action.albums_more) !== 'undefined') var { albums_more } = action;
else if (core.search_results && core.search_results.albums_more) var { albums_more } = core.search_results;
else var albums_more = null;
// playlists
if (core.search_results && core.search_results.playlists_uris){
var playlists_uris = core.search_results.playlists_uris
} else {
var playlists_uris = []
}
if (action.playlists_uris) playlists_uris = [...playlists_uris, ...action.playlists_uris]
// playlists
if (core.search_results && core.search_results.playlists_uris) {
var { playlists_uris } = core.search_results;
} else {
var playlists_uris = [];
}
if (action.playlists_uris) playlists_uris = [...playlists_uris, ...action.playlists_uris];
// more tracks
if (typeof(action.playlists_more) !== 'undefined') var playlists_more = action.playlists_more
else if (core.search_results && core.search_results.playlists_more) var playlists_more = core.search_results.playlists_more
else var playlists_more = null
// more tracks
if (typeof (action.playlists_more) !== 'undefined') var { playlists_more } = action;
else if (core.search_results && core.search_results.playlists_more) var { playlists_more } = core.search_results;
else var playlists_more = null;
// tracks
if (core.search_results && core.search_results.tracks){
var tracks = core.search_results.tracks
} else {
var tracks = []
}
if (action.tracks) tracks = [...tracks, ...helpers.formatTracks(action.tracks)]
// tracks
if (core.search_results && core.search_results.tracks) {
var { tracks } = core.search_results;
} else {
var tracks = [];
}
if (action.tracks) tracks = [...tracks, ...helpers.formatTracks(action.tracks)];
// more tracks
if (typeof(action.tracks_more) !== 'undefined') var tracks_more = action.tracks_more
else if (core.search_results && core.search_results.tracks_more) var tracks_more = core.search_results.tracks_more
else var tracks_more = null
// more tracks
if (typeof (action.tracks_more) !== 'undefined') var { tracks_more } = action;
else if (core.search_results && core.search_results.tracks_more) var { tracks_more } = core.search_results;
else var tracks_more = null;
return Object.assign({}, core, {
search_results: {
artists_more: artists_more,
artists_uris: helpers.removeDuplicates(artists_uris),
albums_more: albums_more,
albums_uris: helpers.removeDuplicates(albums_uris),
playlists_more: playlists_more,
playlists_uris: helpers.removeDuplicates(playlists_uris),
tracks: tracks,
tracks_more: tracks_more
}
});
return {
...core,
search_results: {
artists_more,
artists_uris: helpers.removeDuplicates(artists_uris),
albums_more,
albums_uris: helpers.removeDuplicates(albums_uris),
playlists_more,
playlists_uris: helpers.removeDuplicates(playlists_uris),
tracks,
tracks_more,
},
};
default:
return core
}
default:
return core;
}
}

180
src/js/services/discogs/actions.js
View File

@ -1,7 +1,7 @@
var coreActions = require('../core/actions');
var uiActions = require('../ui/actions');
var helpers = require('../../helpers');
const coreActions = require('../core/actions');
const uiActions = require('../ui/actions');
const helpers = require('../../helpers');
/**
* Send an ajax request to the LastFM API
@ -9,100 +9,96 @@ var helpers = require('../../helpers');
* @param dispatch = obj
* @param endpoint = String
* @param params = String
**/
var sendRequest = (dispatch, endpoint, params) => {
return new Promise((resolve, reject) => {
const loader_key = helpers.generateGuid();
* */
const sendRequest = (dispatch, endpoint, params) => new Promise((resolve, reject) => {
const loader_key = helpers.generateGuid();
dispatch(uiActions.startLoading(loader_key, ',discogs_'+endpoint));
dispatch(uiActions.startLoading(loader_key, `,discogs_${endpoint}`));
let key = 'CXIwsVMAjrXIVitBWgqd';
let secret = 'KiEUfwKpebxRnEHlKoXnYIftJxeuqjTK';
const key = 'CXIwsVMAjrXIVitBWgqd';
const secret = 'KiEUfwKpebxRnEHlKoXnYIftJxeuqjTK';
var config = {
method: 'GET',
cache: true,
timeout: 30000,
url: `https://api.discogs.com/${endpoint}?key=${key}&secret=${secret}&${params}`,
headers: {
'user-agent': 'Iris/1.0',
},
const config = {
method: 'GET',
cache: true,
timeout: 30000,
url: `https://api.discogs.com/${endpoint}?key=${key}&secret=${secret}&${params}`,
headers: {
'user-agent': 'Iris/1.0',
},
};
$.ajax(config).then(
(response) => {
dispatch(uiActions.stopLoading(loader_key));
if (response.error) {
reject({
config,
error: response,
});
} else {
resolve(response);
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
// Snatch a more meaningful error
let description = null;
if (xhr && xhr.responseJSON && xhr.responseJSON.message) {
description = xhr.responseJSON.message;
}
reject({
config,
error,
description,
status,
xhr,
});
},
);
});
export function findArtist(name) {
return sendRequest(dispatch, `artists/${artist.mbid}`, 'inc=url-rels')
.then(
(response) => {
if (response) {
const image_relations = response.relations.filter((rel) => rel.type == 'image');
if (image_relations) {
const updated_artist = {
uri,
images: image_relations.map((relation) => relation.url.resource.replace('File:', 'Special:FilePath/')),
};
dispatch(coreActions.artistLoaded(updated_artist));
}
}
$.ajax(config).then(
response => {
dispatch(uiActions.stopLoading(loader_key));
if (response.error){
reject({
config: config,
error: response
});
} else {
resolve(response);
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
// Snatch a more meaningful error
var description = null;
if (xhr && xhr.responseJSON && xhr.responseJSON.message){
description = xhr.responseJSON.message;
}
reject({
config: config,
error: error,
description: description,
status: status,
xhr: xhr
});
}
)
})
},
(error) => {
console.log(`Musicbrainz: No results for ${artist.mbid}`);
},
);
}
export function findArtist(name){
return sendRequest(dispatch, 'artists/'+artist.mbid, 'inc=url-rels')
.then(
response => {
if (response){
const image_relations = response.relations.filter(rel => rel.type == "image");
if (image_relations) {
const updated_artist = {
uri: uri,
images: image_relations.map(relation =>
relation.url.resource.replace("File:","Special:FilePath/")
),
}
dispatch(coreActions.artistLoaded(updated_artist));
}
}
},
error => {
console.log(`Musicbrainz: No results for ${artist.mbid}`)
export function getArtistImages(uri, artist) {
return (dispatch, getState) => {
sendRequest(dispatch, 'database/search', `query=${artist.name}`)
.then(
(response) => {
if (response) {
if (response.results && response.results[0].cover_image) {
const updated_artist = {
uri,
images: [response.results[0].cover_image],
};
dispatch(coreActions.artistLoaded(updated_artist));
}
)
}
export function getArtistImages(uri, artist){
return (dispatch, getState) => {
sendRequest(dispatch, 'database/search', `query=${artist.name}`)
.then(
response => {
if (response){
if (response.results && response.results[0].cover_image) {
const updated_artist = {
uri: uri,
images: [response.results[0].cover_image],
}
dispatch(coreActions.artistLoaded(updated_artist));
}
}
},
error => {
console.log(`Discogs: No results for ${artist.name}`)
}
)
}
}
},
(error) => {
console.log(`Discogs: No results for ${artist.name}`);
},
);
};
}

357
src/js/services/genius/actions.js
View File

@ -1,13 +1,13 @@
var coreActions = require('../core/actions');
var uiActions = require('../ui/actions');
var helpers = require('../../helpers');
const coreActions = require('../core/actions');
const uiActions = require('../ui/actions');
const helpers = require('../../helpers');
export function set(data){
return {
type: 'GENIUS_SET',
data: data
}
export function set(data) {
return {
type: 'GENIUS_SET',
data,
};
}
/**
@ -19,115 +19,112 @@ export function set(data){
* @param method string
* @param data mixed = request payload
* @return Promise
**/
var sendRequest = (dispatch, getState, endpoint, method = 'GET', data = false) => {
return new Promise((resolve, reject) => {
* */
const sendRequest = (dispatch, getState, endpoint, method = 'GET', data = false) => new Promise((resolve, reject) => {
if (endpoint.startsWith('https://') || endpoint.startsWith('http://')) {
var url = endpoint;
} else {
var url = `https://api.genius.com/${endpoint}`;
if (getState().genius.access_token) {
url += `?access_token=${getState().genius.access_token}`;
}
}
if (endpoint.startsWith('https://') || endpoint.startsWith('http://')){
var url = endpoint;
} else {
var url = 'https://api.genius.com/'+endpoint;
if (getState().genius.access_token){
url += '?access_token='+getState().genius.access_token;
}
}
// create our ajax request config
const config = {
method,
url,
timeout: 30000,
crossDomain: true,
};
// create our ajax request config
var config = {
method: method,
url: url,
timeout: 30000,
crossDomain: true
}
// only if we've got data do we add it to the request (this prevents appending of "&false" to the URL)
if (data) {
if (typeof (data) === 'string') {
config.data = data;
} else {
config.data = JSON.stringify(data);
}
}
// only if we've got data do we add it to the request (this prevents appending of "&false" to the URL)
if (data){
if (typeof(data) === 'string'){
config.data = data
} else {
config.data = JSON.stringify(data)
}
}
// add reference to loader queue
const loader_key = helpers.generateGuid();
dispatch(uiActions.startLoading(loader_key, `genius_${endpoint}`));
// add reference to loader queue
var loader_key = helpers.generateGuid();
dispatch(uiActions.startLoading(loader_key, 'genius_'+endpoint));
$.ajax(config).then(
(response) => {
dispatch(uiActions.stopLoading(loader_key));
$.ajax(config).then(
response => {
dispatch(uiActions.stopLoading(loader_key));
if (response.meta && response.meta.status >= 200 && response.meta.status < 300 && response.response){
resolve(response.response);
} else {
reject({
config: config,
xhr: xhr,
status: status,
error: error
});
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
reject({
config: config,
xhr: xhr,
status: status,
error: error
});
}
)
});
}
if (response.meta && response.meta.status >= 200 && response.meta.status < 300 && response.response) {
resolve(response.response);
} else {
reject({
config,
xhr,
status,
error,
});
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
reject({
config,
xhr,
status,
error,
});
},
);
});
/**
* Handle authorization process
**/
* */
export function authorizationGranted(data){
return {
type: 'GENIUS_AUTHORIZATION_GRANTED',
data: data
}
export function authorizationGranted(data) {
return {
type: 'GENIUS_AUTHORIZATION_GRANTED',
data,
};
}
export function revokeAuthorization(){
return {
type: 'GENIUS_AUTHORIZATION_REVOKED'
}
export function revokeAuthorization() {
return {
type: 'GENIUS_AUTHORIZATION_REVOKED',
};
}
export function importAuthorization(authorization){
return {
type: 'GENIUS_IMPORT_AUTHORIZATION',
authorization: authorization
}
export function importAuthorization(authorization) {
return {
type: 'GENIUS_IMPORT_AUTHORIZATION',
authorization,
};
}
/**
* Get current user
**/
export function getMe(){
return (dispatch, getState) => {
sendRequest(dispatch, getState, 'account')
.then(
response => {
dispatch({
type: 'GENIUS_ME_LOADED',
me: response.user
});
},
error => {
dispatch(coreActions.handleException(
'Could not load your Genius profile',
error
));
}
);
}
* */
export function getMe() {
return (dispatch, getState) => {
sendRequest(dispatch, getState, 'account')
.then(
(response) => {
dispatch({
type: 'GENIUS_ME_LOADED',
me: response.user,
});
},
(error) => {
dispatch(coreActions.handleException(
'Could not load your Genius profile',
error,
));
},
);
};
}
/**
@ -136,108 +133,104 @@ export function getMe(){
*
* @param uri = track uri
* @param path = String, the relative API path for the HTML lyrics
**/
export function getTrackLyrics(uri, path){
return (dispatch, getState) => {
* */
export function getTrackLyrics(uri, path) {
return (dispatch, getState) => {
dispatch(coreActions.trackLoaded({
uri,
lyrics: null,
lyrics_path: null,
}));
dispatch(coreActions.trackLoaded({
uri: uri,
lyrics: null,
lyrics_path: null
}));
const config = {
method: 'GET',
url: `//${getState().mopidy.host}:${getState().mopidy.port}/iris/http/get_lyrics?path=${path}&connection_id=${getState().pusher.connection_id}`,
timeout: 10000,
};
var config = {
method: 'GET',
url: '//'+getState().mopidy.host+':'+getState().mopidy.port+'/iris/http/get_lyrics?path='+path+'&connection_id='+getState().pusher.connection_id,
timeout: 10000
}
// add reference to loader queue
const loader_key = helpers.generateGuid();
dispatch(uiActions.startLoading(loader_key, 'genius_get_lyrics'));
// add reference to loader queue
var loader_key = helpers.generateGuid();
dispatch(uiActions.startLoading(loader_key, 'genius_get_lyrics'));
$.ajax(config)
.then(
(response, status, xhr) => {
dispatch(uiActions.stopLoading(loader_key));
if (response && response.result){
var html = $(response.result);
var lyrics = html.find('.lyrics');
if (lyrics.length > 0){
$.ajax(config)
.then(
(response, status, xhr) => {
dispatch(uiActions.stopLoading(loader_key));
if (response && response.result) {
const html = $(response.result);
let lyrics = html.find('.lyrics');
if (lyrics.length > 0) {
lyrics = lyrics.first();
lyrics.find('a').replaceWith(function(){
lyrics.find('a').replaceWith(function () {
return this.innerHTML;
});
var lyrics_html = lyrics.html();
let lyrics_html = lyrics.html();
lyrics_html = lyrics_html.replace(/(\[)/g, '<span class="mid_grey-text">[');
lyrics_html = lyrics_html.replace(/(\])/g, ']</span>');
dispatch(coreActions.trackLoaded({
uri: uri,
lyrics: lyrics_html,
lyrics_path: path
}));
uri,
lyrics: lyrics_html,
lyrics_path: path,
}));
}
} else {
} else {
dispatch(coreActions.handleException(
'Could not get track lyrics',
response.error
response.error,
));
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
dispatch(coreActions.handleException(
'Could not get track lyrics',
error
));
}
);
}
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
dispatch(coreActions.handleException(
'Could not get track lyrics',
error,
));
},
);
};
}
export function findTrackLyrics(track){
return (dispatch, getState) => {
var query = '';
query += track.artists[0].name+' ';
query += track.name;
query = query.toLowerCase();
query = query.replace(/\([^)]*\) */g, ''); // anything in circle-braces
query = query.replace(/\([^[]*\] */g, ''); // anything in square-braces
export function findTrackLyrics(track) {
return (dispatch, getState) => {
let query = '';
query += `${track.artists[0].name} `;
query += track.name;
query = query.toLowerCase();
query = query.replace(/\([^)]*\) */g, ''); // anything in circle-braces
query = query.replace(/\([^[]*\] */g, ''); // anything in square-braces
sendRequest(dispatch, getState, 'search', 'GET', 'q='+encodeURIComponent(query))
.then(
response => {
if (response.hits && response.hits.length > 0){
var lyrics_results = [];
for (var i = 0; i < response.hits.length; i++){
lyrics_results.push({
title: response.hits[i].result.full_title,
url: response.hits[i].result.url,
path: response.hits[i].result.path
});
}
dispatch(coreActions.trackLoaded({
uri: track.uri,
lyrics_results: lyrics_results
}));
sendRequest(dispatch, getState, 'search', 'GET', `q=${encodeURIComponent(query)}`)
.then(
(response) => {
if (response.hits && response.hits.length > 0) {
const lyrics_results = [];
for (let i = 0; i < response.hits.length; i++) {
lyrics_results.push({
title: response.hits[i].result.full_title,
url: response.hits[i].result.url,
path: response.hits[i].result.path,
});
}
dispatch(coreActions.trackLoaded({
uri: track.uri,
lyrics_results,
}));
// Immediately go and get the first result's lyrics
var lyrics_result = lyrics_results[0];
dispatch(getTrackLyrics(track.uri, lyrics_result.path));
}
},
error => {
dispatch(coreActions.handleException(
'Could not search for track lyrics',
error
));
}
);
}
// Immediately go and get the first result's lyrics
const lyrics_result = lyrics_results[0];
dispatch(getTrackLyrics(track.uri, lyrics_result.path));
}
},
(error) => {
dispatch(coreActions.handleException(
'Could not search for track lyrics',
error,
));
},
);
};
}

83
src/js/services/genius/middleware.js
View File

@ -1,59 +1,58 @@
var helpers = require('./../../helpers');
var coreActions = require('../core/actions');
var geniusActions = require('./actions');
const helpers = require('./../../helpers');
const coreActions = require('../core/actions');
const geniusActions = require('./actions');
const GeniusMiddleware = (function(){
return store => next => action => {
var state = store.getState();
const GeniusMiddleware = (function () {
return (store) => (next) => (action) => {
const state = store.getState();
switch(action.type){
case 'GENIUS_ME_LOADED':
var me = helpers.formatUser(action.me);
Object.assign(
me,
{
uri: "genius:user:"+me.id
}
);
switch (action.type) {
case 'GENIUS_ME_LOADED':
var me = helpers.formatUser(action.me);
Object.assign(
me,
{
uri: `genius:user:${me.id}`,
},
);
store.dispatch({
type: 'GENIUS_USER_LOADED',
user: action.me
user: action.me,
});
action.me = me;
action.me = me;
next(action);
break;
case 'GENIUS_USER_LOADED':
var user = helpers.formatUser(action.user);
Object.assign(
user,
{
uri: "genius:user:"+user.id
}
);
store.dispatch(coreActions.userLoaded(user));
action.user = user;
next(action);
break;
case 'GENIUS_USER_LOADED':
var user = helpers.formatUser(action.user);
Object.assign(
user,
{
uri: `genius:user:${user.id}`,
},
);
store.dispatch(coreActions.userLoaded(user));
action.user = user;
next(action);
break;
case 'GENIUS_IMPORT_AUTHORIZATION':
case 'GENIUS_IMPORT_AUTHORIZATION':
// Wait a few moments before we fetch, allowing the import to complete first
// TODO: Use callbacks for better code accuracy
setTimeout(() => {store.dispatch(geniusActions.getMe())}, 100);
// Wait a few moments before we fetch, allowing the import to complete first
// TODO: Use callbacks for better code accuracy
setTimeout(() => { store.dispatch(geniusActions.getMe()); }, 100);
next(action);
break;
next(action);
break;
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
}
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
}
})();
};
}());
export default GeniusMiddleware
export default GeniusMiddleware;

70
src/js/services/genius/reducer.js
View File

@ -1,42 +1,42 @@
export default function reducer(genius = {}, action){
switch (action.type){
export default function reducer(genius = {}, action) {
switch (action.type) {
case 'GENIUS_SET':
return { ...genius, ...action.data };
case 'GENIUS_SET':
return Object.assign({}, genius, action.data)
case 'GENIUS_ME_LOADED':
return { ...genius, me: action.me };
case 'GENIUS_ME_LOADED':
return Object.assign({}, genius, {
me: action.me
})
case 'GENIUS_AUTHORIZATION_GRANTED':
return {
...genius,
authorizing: false,
authorization: action.data,
authorization_code: action.data.authorization_code,
access_token: action.data.access_token,
};
case 'GENIUS_AUTHORIZATION_GRANTED':
return Object.assign({}, genius, {
authorizing: false,
authorization: action.data,
authorization_code: action.data.authorization_code,
access_token: action.data.access_token
})
case 'GENIUS_AUTHORIZATION_REVOKED':
return {
...genius,
authorizing: false,
authorization: null,
authorization_code: null,
access_token: null,
me: null,
};
case 'GENIUS_AUTHORIZATION_REVOKED':
return Object.assign({}, genius, {
authorizing: false,
authorization: null,
authorization_code: null,
access_token: null,
me: null
});
case 'GENIUS_IMPORT_AUTHORIZATION':
return {
...genius,
authorizing: false,
authorization: action.authorization,
authorization_code: action.authorization.authorization_code,
access_token: action.authorization.access_token,
me: null,
};
case 'GENIUS_IMPORT_AUTHORIZATION':
return Object.assign({}, genius, {
authorizing: false,
authorization: action.authorization,
authorization_code: action.authorization.authorization_code,
access_token: action.authorization.access_token,
me: null
})
default:
return genius
}
default:
return genius;
}
}

44
src/js/services/google/actions.js
View File

@ -1,31 +1,31 @@
export function set(data){
return {
type: 'GOOGLE_SET',
data: data
}
export function set(data) {
return {
type: 'GOOGLE_SET',
data,
};
}
export function getLibraryArtists(){
return {
type: 'GOOGLE_GET_LIBRARY_ARTISTS'
}
export function getLibraryArtists() {
return {
type: 'GOOGLE_GET_LIBRARY_ARTISTS',
};
}
export function clearLibraryArtists(){
return {
type: 'GOOGLE_CLEAR_LIBRARY_ARTISTS'
}
export function clearLibraryArtists() {
return {
type: 'GOOGLE_CLEAR_LIBRARY_ARTISTS',
};
}
export function getLibraryAlbums(){
return {
'type': 'GOOGLE_GET_LIBRARY_ALBUMS'
}
export function getLibraryAlbums() {
return {
type: 'GOOGLE_GET_LIBRARY_ALBUMS',
};
}
export function clearLibraryAlbums(){
return {
type: 'GOOGLE_CLEAR_LIBRARY_ALBUMS'
}
}
export function clearLibraryAlbums() {
return {
type: 'GOOGLE_CLEAR_LIBRARY_ALBUMS',
};
}

255
src/js/services/google/middleware.js
View File

@ -1,145 +1,140 @@
import ReactGA from 'react-ga'
import ReactGA from 'react-ga';
var helpers = require('../../helpers');
var coreActions = require('../core/actions');
var mopidyActions = require('../mopidy/actions');
var uiActions = require('../ui/actions');
const helpers = require('../../helpers');
const coreActions = require('../core/actions');
const mopidyActions = require('../mopidy/actions');
const uiActions = require('../ui/actions');
const GoogleMiddleware = (function(){
// A Google request is an alias of the Mopidy request
const request = (store, method, params = null, response_callback = null, error_callback = null) => {
store.dispatch(
const GoogleMiddleware = (function () {
// A Google request is an alias of the Mopidy request
const request = (store, method, params = null, response_callback = null, error_callback = null) => {
store.dispatch(
mopidyActions.request(
method,
params,
response_callback,
error_callback
)
);
return;
}
error_callback,
),
);
};
return store => next => action => {
var google = store.getState().google;
return (store) => (next) => (action) => {
const { google } = store.getState();
switch(action.type){
case 'GOOGLE_GET_LIBRARY_ALBUMS':
var last_run = store.getState().ui.processes.GOOGLE_LIBRARY_ALBUMS_PROCESSOR
switch (action.type) {
case 'GOOGLE_GET_LIBRARY_ALBUMS':
var last_run = store.getState().ui.processes.GOOGLE_LIBRARY_ALBUMS_PROCESSOR;
if (!last_run){
request(
store,
'library.browse',
{
uri: 'gmusic:album'
},
response => {
if (response.length <= 0){
return;
}
if (!last_run) {
request(
store,
'library.browse',
{
uri: 'gmusic:album',
},
(response) => {
if (response.length <= 0) {
return;
}
var uris = helpers.arrayOf('uri',response);
store.dispatch({
type: 'GOOGLE_LIBRARY_ALBUMS_LOADED',
uris: uris
});
const uris = helpers.arrayOf('uri', response);
store.dispatch({
type: 'GOOGLE_LIBRARY_ALBUMS_LOADED',
uris,
});
// Start our process to load the full album objects
store.dispatch(uiActions.startProcess(
'GOOGLE_LIBRARY_ALBUMS_PROCESSOR',
'Loading '+uris.length+' Google albums',
{
uris: uris,
total: uris.length,
remaining: uris.length
}
));
}
);
} else if (last_run.status == 'cancelled'){
store.dispatch(uiActions.resumeProcess('GOOGLE_LIBRARY_ALBUMS_PROCESSOR'))
} else if (last_run.status == 'finished'){
// TODO: do we want to force a refresh?
}
break;
case 'GOOGLE_LIBRARY_ALBUMS_PROCESSOR':
if (store.getState().ui.processes['GOOGLE_LIBRARY_ALBUMS_PROCESSOR'] !== undefined){
var processor = store.getState().ui.processes['GOOGLE_LIBRARY_ALBUMS_PROCESSOR']
if (processor.status == 'cancelling'){
store.dispatch(uiActions.processCancelled('GOOGLE_LIBRARY_ALBUMS_PROCESSOR'))
return false
}
}
var uris = Object.assign([], action.data.uris);
var uris_to_load = uris.splice(0,50);
if (uris_to_load.length > 0){
store.dispatch(uiActions.updateProcess(
'GOOGLE_LIBRARY_ALBUMS_PROCESSOR',
'Loading '+uris.length+' Google albums',
{
uris: uris,
remaining: uris.length
}
));
store.dispatch(mopidyActions.getAlbums(uris_to_load, {name: 'GOOGLE_LIBRARY_ALBUMS_PROCESSOR', data: {uris: uris}}))
} else {
store.dispatch(uiActions.processFinishing('GOOGLE_LIBRARY_ALBUMS_PROCESSOR'));
}
break
case 'GOOGLE_GET_LIBRARY_ARTISTS':
request(
store,
'library.browse',
{
uri: 'gmusic:artist'
},
response => {
if (response.length <= 0){
return
}
var uris = [];
for (var i = 0; i < response.length; i++){
// Convert local URI to actual artist URI
// See https://github.com/mopidy/mopidy-local-sqlite/issues/39
response[i].uri = response[i].uri.replace('local:directory?albumartist=','');
uris.push(response[i].uri);
}
store.dispatch(coreActions.artistsLoaded(response));
store.dispatch({
type: 'GOOGLE_LIBRARY_ARTISTS_LOADED',
uris: uris
});
},
error => {
store.dispatch(coreActions.handleException(
'Could not load Google artists',
error
));
}
);
break;
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
// Start our process to load the full album objects
store.dispatch(uiActions.startProcess(
'GOOGLE_LIBRARY_ALBUMS_PROCESSOR',
`Loading ${uris.length} Google albums`,
{
uris,
total: uris.length,
remaining: uris.length,
},
));
},
);
} else if (last_run.status == 'cancelled') {
store.dispatch(uiActions.resumeProcess('GOOGLE_LIBRARY_ALBUMS_PROCESSOR'));
} else if (last_run.status == 'finished') {
// TODO: do we want to force a refresh?
}
break;
case 'GOOGLE_LIBRARY_ALBUMS_PROCESSOR':
if (store.getState().ui.processes.GOOGLE_LIBRARY_ALBUMS_PROCESSOR !== undefined) {
const processor = store.getState().ui.processes.GOOGLE_LIBRARY_ALBUMS_PROCESSOR;
if (processor.status == 'cancelling') {
store.dispatch(uiActions.processCancelled('GOOGLE_LIBRARY_ALBUMS_PROCESSOR'));
return false;
}
}
var uris = Object.assign([], action.data.uris);
var uris_to_load = uris.splice(0, 50);
if (uris_to_load.length > 0) {
store.dispatch(uiActions.updateProcess(
'GOOGLE_LIBRARY_ALBUMS_PROCESSOR',
`Loading ${uris.length} Google albums`,
{
uris,
remaining: uris.length,
},
));
store.dispatch(mopidyActions.getAlbums(uris_to_load, { name: 'GOOGLE_LIBRARY_ALBUMS_PROCESSOR', data: { uris } }));
} else {
store.dispatch(uiActions.processFinishing('GOOGLE_LIBRARY_ALBUMS_PROCESSOR'));
}
break;
case 'GOOGLE_GET_LIBRARY_ARTISTS':
request(
store,
'library.browse',
{
uri: 'gmusic:artist',
},
(response) => {
if (response.length <= 0) {
return;
}
const uris = [];
for (let i = 0; i < response.length; i++) {
// Convert local URI to actual artist URI
// See https://github.com/mopidy/mopidy-local-sqlite/issues/39
response[i].uri = response[i].uri.replace('local:directory?albumartist=', '');
uris.push(response[i].uri);
}
store.dispatch(coreActions.artistsLoaded(response));
store.dispatch({
type: 'GOOGLE_LIBRARY_ARTISTS_LOADED',
uris,
});
},
(error) => {
store.dispatch(coreActions.handleException(
'Could not load Google artists',
error,
));
},
);
break;
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
}
};
}());
})();
export default GoogleMiddleware
export default GoogleMiddleware;

54
src/js/services/google/reducer.js
View File

@ -1,38 +1,34 @@
import * as helpers from '../../helpers';
export default function reducer(google = {}, action){
switch (action.type){
export default function reducer(google = {}, action) {
switch (action.type) {
case 'GOOGLE_SET':
return { ...google, ...action.data };
case 'GOOGLE_SET':
return Object.assign({}, google, action.data);
case 'GOOGLE_LIBRARY_ARTISTS_LOADED':
if (google.library_artists) {
var uris = [...google.library_artists, ...action.uris];
} else {
var { uris } = action;
}
return { ...google, library_artists: helpers.removeDuplicates(uris) };
case 'GOOGLE_LIBRARY_ARTISTS_LOADED':
if (google.library_artists){
var uris = [...google.library_artists,...action.uris];
} else {
var uris = action.uris;
}
return Object.assign({}, google, { library_artists: helpers.removeDuplicates(uris) });
case 'GOOGLE_CLEAR_LIBRARY_ARTISTS':
return { ...google, library_artists: null };
case 'GOOGLE_CLEAR_LIBRARY_ARTISTS':
return Object.assign({}, google, { library_artists: null });
case 'GOOGLE_LIBRARY_ALBUMS_LOADED':
if (google.library_albums) {
var uris = [...google.library_albums, ...action.uris];
} else {
var { uris } = action;
}
return { ...google, library_albums: helpers.removeDuplicates(uris) };
case 'GOOGLE_LIBRARY_ALBUMS_LOADED':
if (google.library_albums){
var uris = [...google.library_albums,...action.uris];
} else {
var uris = action.uris;
}
return Object.assign({}, google, { library_albums: helpers.removeDuplicates(uris) });
case 'GOOGLE_CLEAR_LIBRARY_ALBUMS':
return { ...google, library_albums: null };
case 'GOOGLE_CLEAR_LIBRARY_ALBUMS':
return Object.assign({}, google, { library_albums: null });
default:
return google
}
default:
return google;
}
}

826
src/js/services/lastfm/actions.js
View File

@ -1,13 +1,13 @@
var coreActions = require('../core/actions');
var uiActions = require('../ui/actions');
var helpers = require('../../helpers');
const coreActions = require('../core/actions');
const uiActions = require('../ui/actions');
const helpers = require('../../helpers');
export function set(data){
return {
type: 'LASTFM_SET',
data: data
}
export function set(data) {
return {
type: 'LASTFM_SET',
data,
};
}
/**
@ -17,62 +17,59 @@ export function set(data){
* @param getState = obj
* @param params = string, the url params to send
* @params signed = boolean, whether we've got a signed request with baked-in api_key
**/
var sendRequest = (dispatch, getState, params, signed = false) => {
return new Promise((resolve, reject) => {
* */
const sendRequest = (dispatch, getState, params, signed = false) => new Promise((resolve, reject) => {
const loader_key = helpers.generateGuid();
let method = params.substring(params.indexOf('method=') + 7, params.length);
method = method.substring(0, method.indexOf('&'));
var loader_key = helpers.generateGuid();
var method = params.substring(params.indexOf("method=")+7, params.length);
method = method.substring(0, method.indexOf("&"));
dispatch(uiActions.startLoading(loader_key, `lastfm_${method}`));
dispatch(uiActions.startLoading(loader_key, 'lastfm_'+method));
const config = {
method: 'GET',
cache: true,
timeout: 30000,
url: `https://ws.audioscrobbler.com/2.0/?format=json&${params}`,
};
var config = {
method: 'GET',
cache: true,
timeout: 30000,
url: 'https://ws.audioscrobbler.com/2.0/?format=json&'+params
}
// Signed requests don't need our api_key as the proxy has it's own
if (!signed) {
config.url += '&api_key=4320a3ef51c9b3d69de552ac083c55e3';
} else {
config.method = 'POST';
}
// Signed requests don't need our api_key as the proxy has it's own
if (!signed){
config.url += '&api_key=4320a3ef51c9b3d69de552ac083c55e3';
} else {
config.method = 'POST';
}
$.ajax(config).then(
(response) => {
dispatch(uiActions.stopLoading(loader_key));
if (response.error) {
reject({
config,
error: response,
});
} else {
resolve(response);
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
$.ajax(config).then(
response => {
dispatch(uiActions.stopLoading(loader_key));
if (response.error){
reject({
config: config,
error: response
});
} else {
resolve(response);
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
// Snatch a more meaningful error
let description = null;
if (xhr && xhr.responseJSON && xhr.responseJSON.message) {
description = xhr.responseJSON.message;
}
// Snatch a more meaningful error
var description = null;
if (xhr && xhr.responseJSON && xhr.responseJSON.message){
description = xhr.responseJSON.message;
}
reject({
config: config,
error: error,
description: description,
status: status,
xhr: xhr
});
}
)
})
}
reject({
config,
error,
description,
status,
xhr,
});
},
);
});
/**
* Send a SIGNED ajax request to the LastFM API
@ -81,419 +78,400 @@ var sendRequest = (dispatch, getState, params, signed = false) => {
* @param getState = obj
* @param params = string, the url params to send
* @param signed = boolean
**/
const sendSignedRequest = (dispatch, getState, params) => {
return new Promise((resolve, reject) => {
* */
const sendSignedRequest = (dispatch, getState, params) => new Promise((resolve, reject) => {
// Not authorized
if (!getState().lastfm.authorization) {
reject({
params,
error: 'No active LastFM authorization (session)',
});
}
// Not authorized
if (!getState().lastfm.authorization){
reject({
params: params,
error: "No active LastFM authorization (session)"
});
}
const loader_key = helpers.generateGuid();
let method = params.substring(params.indexOf('method=') + 7, params.length);
method = method.substring(0, method.indexOf('&'));
var loader_key = helpers.generateGuid();
var method = params.substring(params.indexOf("method=")+7, params.length);
method = method.substring(0, method.indexOf("&"));
dispatch(uiActions.startLoading(loader_key, `lastfm_${method}`));
dispatch(uiActions.startLoading(loader_key, 'lastfm_'+method));
params += `&sk=${getState().lastfm.authorization.key}`;
params += "&sk="+getState().lastfm.authorization.key;
const config = {
method: 'GET',
cache: false,
timeout: 30000,
url: `${getState().lastfm.authorization_url}?action=sign_request&${params}`,
};
var config = {
method: 'GET',
cache: false,
timeout: 30000,
url: getState().lastfm.authorization_url+"?action=sign_request&"+params
}
// Get our server proxy to sign our request
$.ajax(config).then(
(response) => {
dispatch(uiActions.stopLoading(loader_key));
// Get our server proxy to sign our request
$.ajax(config).then(
response => {
dispatch(uiActions.stopLoading(loader_key));
// Now we have signed params, we can make the actual request
sendRequest(dispatch, getState, response.params, true)
.then(
response => {
resolve(response);
},
error => {
reject(error);
}
);
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
reject(error)
}
// Now we have signed params, we can make the actual request
sendRequest(dispatch, getState, response.params, true)
.then(
(response) => {
resolve(response);
},
(error) => {
reject(error);
},
);
})
}
},
(xhr, status, error) => {
dispatch(uiActions.stopLoading(loader_key));
reject(error);
},
);
});
/**
* Handle authorization process
**/
* */
export function authorizationGranted(data){
data.session.expiry = new Date().getTime() + 3600;
return {
type: 'LASTFM_AUTHORIZATION_GRANTED',
data: data
}
export function authorizationGranted(data) {
data.session.expiry = new Date().getTime() + 3600;
return {
type: 'LASTFM_AUTHORIZATION_GRANTED',
data,
};
}
export function revokeAuthorization(){
return {
type: 'LASTFM_AUTHORIZATION_REVOKED'
}
export function revokeAuthorization() {
return {
type: 'LASTFM_AUTHORIZATION_REVOKED',
};
}
export function importAuthorization(authorization){
return {
type: 'LASTFM_IMPORT_AUTHORIZATION',
authorization: authorization
}
export function importAuthorization(authorization) {
return {
type: 'LASTFM_IMPORT_AUTHORIZATION',
authorization,
};
}
/**
* Non-signed requests
**/
* */
export function getMe(){
return (dispatch, getState) => {
var params = 'method=user.getInfo&user='+getState().lastfm.authorization.name
sendRequest(dispatch, getState, params)
.then(
response => {
if (response.user){
dispatch({
type: 'LASTFM_ME_LOADED',
me: response.user
});
}
},
error => {
dispatch(coreActions.handleException(
"Could not get your LastFM profile",
error
));
}
)
}
export function getMe() {
return (dispatch, getState) => {
const params = `method=user.getInfo&user=${getState().lastfm.authorization.name}`;
sendRequest(dispatch, getState, params)
.then(
(response) => {
if (response.user) {
dispatch({
type: 'LASTFM_ME_LOADED',
me: response.user,
});
}
},
(error) => {
dispatch(coreActions.handleException(
'Could not get your LastFM profile',
error,
));
},
);
};
}
export function getTrack(uri){
return (dispatch, getState) => {
if (getState().core.tracks[uri] !== undefined){
var track = getState().core.tracks[uri];
if (!track.artists){
dispatch(coreActions.handleException(
"Could not get LastFM track",
{},
"Track has no artists"
));
return;
export function getTrack(uri) {
return (dispatch, getState) => {
if (getState().core.tracks[uri] !== undefined) {
var track = getState().core.tracks[uri];
if (!track.artists) {
dispatch(coreActions.handleException(
'Could not get LastFM track',
{},
'Track has no artists',
));
return;
}
} else {
dispatch(coreActions.handleException(
'Could not get LastFM track',
{},
'Could not find track in index',
));
return;
}
const track_name = track.name;
const artist_name = encodeURIComponent(track.artists[0].name);
let params = `method=track.getInfo&track=${track_name}&artist=${artist_name}`;
if (getState().lastfm.authorization) {
params += `&username=${getState().lastfm.authorization.name}`;
}
sendRequest(dispatch, getState, params)
.then(
(response) => {
if (response.track) {
const merged_track = {
uri: track.uri,
...response.track,
...track,
};
dispatch(coreActions.trackLoaded(merged_track));
}
},
(error) => {
console.info(`LastFM: No results for track '${track_name}' by '${artist_name}'`);
},
);
};
}
export function getArtist(uri, artist, mbid = false) {
return (dispatch, getState) => {
if (mbid) {
var params = `method=artist.getInfo&mbid=${mbid}`;
} else {
artist = artist.replace('&', 'and');
artist = encodeURIComponent(artist);
var params = `method=artist.getInfo&artist=${artist}`;
}
sendRequest(dispatch, getState, params)
.then(
(response) => {
if (response.artist) {
const artist = {
uri,
mbid: response.artist.mbid,
biography: response.artist.bio.content,
biography_publish_date: response.artist.bio.published,
biography_link: response.artist.bio.links.link.href,
listeners: parseInt(response.artist.stats.listeners),
};
dispatch(coreActions.artistLoaded(artist));
}
},
(error) => {
console.info(`LastFM: No results for artist '${artist}'`);
},
);
};
}
export function getAlbum(uri, artist, album, mbid = false) {
return (dispatch, getState) => {
if (mbid) {
var params = `method=album.getInfo&mbid=${mbid}`;
} else {
artist = encodeURIComponent(artist);
album = encodeURIComponent(album);
var params = `method=album.getInfo&album=${album}&artist=${artist}`;
}
sendRequest(dispatch, getState, params)
.then(
(response) => {
if (response.album) {
const existing_album = getState().core.albums[uri];
const album = {
uri,
images: response.album.image,
listeners: parseInt(response.album.listeners),
play_count: parseInt(response.album.playcount),
mbid: response.album.mbid,
wiki: (response.album.wiki ? response.album.wiki.content : null),
wiki_publish_date: (response.album.wiki ? response.album.wiki.published : null),
};
// If we've already got some of this album and it has images aready, don't use our ones.
// In *most* cases this existing image will be perfectly suffice. This prevents an ugly
// flicker when the existing image is replaced by the LastFM one
if (existing_album && existing_album.images) {
delete album.images;
}
} else {
dispatch(coreActions.handleException(
"Could not get LastFM track",
{},
"Could not find track in index"
));
return;
}
var track_name = track.name;
var artist_name = encodeURIComponent(track.artists[0].name);
var params = 'method=track.getInfo&track='+track_name+'&artist='+artist_name;
if (getState().lastfm.authorization){
params += '&username='+getState().lastfm.authorization.name;
}
sendRequest(dispatch, getState, params)
.then(
response => {
if (response.track){
var merged_track = Object.assign(
{},
{
uri: track.uri
},
response.track,
track
);
dispatch(coreActions.trackLoaded(merged_track));
}
dispatch(coreActions.albumLoaded(album));
}
},
(error) => {
console.info(`LastFM: No results for album '${album}'`);
},
);
};
}
export function getImages(context, uri) {
return (dispatch, getState) => {
let record = getState().core[context][uri];
if (record) {
switch (context) {
case 'tracks':
if (record.mbid) {
var params = `method=album.getInfo&mbid=${record.mbid}`;
} else if (record.artists && record.artists.length > 0 && record.album) {
var artist = encodeURIComponent(record.artists[0].name);
var album = encodeURIComponent(record.album.name);
var params = `method=album.getInfo&album=${album}&artist=${artist}`;
}
if (params) {
sendRequest(dispatch, getState, params)
.then(
(response) => {
if (response.album) {
const images = helpers.formatImages(response.album.image);
dispatch(coreActions.trackLoaded({ uri, images }));
}
},
error => {
console.info("LastFM: No results for track '"+track_name+"' by '"+artist_name+"'");
}
)
}
}
);
}
break;
export function getArtist(uri, artist, mbid = false){
case 'albums':
return (dispatch, getState) => {
if (mbid){
var params = 'method=artist.getInfo&mbid='+mbid
} else {
artist = artist.replace("&","and");
artist = encodeURIComponent(artist);
var params = 'method=artist.getInfo&artist='+artist
}
sendRequest(dispatch, getState, params)
.then(
response => {
if (response.artist){
var artist = {
uri: uri,
mbid: response.artist.mbid,
biography: response.artist.bio.content,
biography_publish_date: response.artist.bio.published,
biography_link: response.artist.bio.links.link.href,
listeners: parseInt(response.artist.stats.listeners)
};
if (record.mbid) {
var params = `method=album.getInfo&mbid=${record.mbid}`;
} else if (record.artists && record.artists.length > 0) {
var artist = encodeURIComponent(record.artists[0].name);
var album = encodeURIComponent(record.name);
var params = `method=album.getInfo&album=${album}&artist=${artist}`;
}
dispatch(coreActions.artistLoaded(artist));
}
if (params) {
sendRequest(dispatch, getState, params)
.then(
(response) => {
if (response.album) {
record = { ...record, images: response.album.image };
dispatch(coreActions.albumLoaded(record));
}
},
error => {
console.info("LastFM: No results for artist '"+artist+"'");
}
)
);
}
break;
}
}
};
}
export function getAlbum(uri, artist, album, mbid = false){
return (dispatch, getState) => {
if (mbid){
var params = 'method=album.getInfo&mbid='+mbid;
} else {
artist = encodeURIComponent(artist);
album = encodeURIComponent(album);
var params = 'method=album.getInfo&album='+album+'&artist='+artist;
}
sendRequest(dispatch, getState, params)
.then(
response => {
if (response.album){
var existing_album = getState().core.albums[uri];
var album = {
uri: uri,
images: response.album.image,
listeners: parseInt(response.album.listeners),
play_count: parseInt(response.album.playcount),
mbid: response.album.mbid,
wiki: (response.album.wiki ? response.album.wiki.content : null),
wiki_publish_date: (response.album.wiki ? response.album.wiki.published : null),
};
// If we've already got some of this album and it has images aready, don't use our ones.
// In *most* cases this existing image will be perfectly suffice. This prevents an ugly
// flicker when the existing image is replaced by the LastFM one
if (existing_album && existing_album.images){
delete album.images;
}
dispatch(coreActions.albumLoaded(album));
}
},
error => {
console.info("LastFM: No results for album '"+album+"'");
}
);
}
}
export function getImages(context, uri){
return (dispatch, getState) => {
var record = getState().core[context][uri];
if (record){
switch (context){
case "tracks":
if (record.mbid){
var params = 'method=album.getInfo&mbid='+record.mbid;
} else if (record.artists && record.artists.length > 0 && record.album){
var artist = encodeURIComponent(record.artists[0].name);
var album = encodeURIComponent(record.album.name);
var params = 'method=album.getInfo&album='+album+'&artist='+artist;
}
if (params){
sendRequest(dispatch, getState, params)
.then(
response => {
if (response.album){
let images = helpers.formatImages(response.album.image);
dispatch(coreActions.trackLoaded({uri: uri, images: images}));
}
}
);
}
break;
case "albums":
if (record.mbid){
var params = 'method=album.getInfo&mbid='+record.mbid;
} else if (record.artists && record.artists.length > 0){
var artist = encodeURIComponent(record.artists[0].name);
var album = encodeURIComponent(record.name);
var params = 'method=album.getInfo&album='+album+'&artist='+artist;
}
if (params){
sendRequest(dispatch, getState, params)
.then(
response => {
if (response.album){
record = Object.assign({}, record, {images: response.album.image});
dispatch(coreActions.albumLoaded(record));
}
}
);
}
break;
}
}
}
}
/**
* Signed requests
**/
* */
export function loveTrack(uri){
return (dispatch, getState) => {
if (getState().core.tracks[uri] !== undefined){
var track = getState().core.tracks[uri];
if (!track.artists){
dispatch(coreActions.handleException(
"Could not love LastFM track",
track,
"Track has no artists"
));
return;
}
} else {
dispatch(coreActions.handleException(
"Could not love LastFM track",
track,
"Could not find track in index"
));
return;
}
var artist = encodeURIComponent(track.artists[0].name);
var params = 'method=track.love&track='+track.name+'&artist='+artist;
sendSignedRequest(dispatch, getState, params)
.then(
response => {
track = Object.assign(
{},
track,
{
userloved: true
}
);
dispatch({
type: 'TRACKS_LOADED',
tracks: [track]
});
}
);
export function loveTrack(uri) {
return (dispatch, getState) => {
if (getState().core.tracks[uri] !== undefined) {
var track = getState().core.tracks[uri];
if (!track.artists) {
dispatch(coreActions.handleException(
'Could not love LastFM track',
track,
'Track has no artists',
));
return;
}
} else {
dispatch(coreActions.handleException(
'Could not love LastFM track',
track,
'Could not find track in index',
));
return;
}
const artist = encodeURIComponent(track.artists[0].name);
const params = `method=track.love&track=${track.name}&artist=${artist}`;
sendSignedRequest(dispatch, getState, params)
.then(
(response) => {
track = {
...track,
userloved: true,
};
dispatch({
type: 'TRACKS_LOADED',
tracks: [track],
});
},
);
};
}
export function unloveTrack(uri){
return (dispatch, getState) => {
if (getState().core.tracks[uri] !== undefined){
var track = getState().core.tracks[uri];
if (!track.artists){
dispatch(coreActions.handleException(
"Could not unlove LastFM track",
track,
"Track has no artists"
));
return;
}
} else {
dispatch(coreActions.handleException(
"Could not unlove LastFM track",
track,
"Could not find track in index"
));
return;
}
var artist = encodeURIComponent(track.artists[0].name);
var params = 'method=track.unlove&track='+track.name+'&artist='+artist;
sendSignedRequest(dispatch, getState, params)
.then(
response => {
track = Object.assign(
{},
track,
{
userloved: false
}
);
dispatch({
type: 'TRACKS_LOADED',
tracks: [track]
});
}
);
export function unloveTrack(uri) {
return (dispatch, getState) => {
if (getState().core.tracks[uri] !== undefined) {
var track = getState().core.tracks[uri];
if (!track.artists) {
dispatch(coreActions.handleException(
'Could not unlove LastFM track',
track,
'Track has no artists',
));
return;
}
} else {
dispatch(coreActions.handleException(
'Could not unlove LastFM track',
track,
'Could not find track in index',
));
return;
}
const artist = encodeURIComponent(track.artists[0].name);
const params = `method=track.unlove&track=${track.name}&artist=${artist}`;
sendSignedRequest(dispatch, getState, params)
.then(
(response) => {
track = {
...track,
userloved: false,
};
dispatch({
type: 'TRACKS_LOADED',
tracks: [track],
});
},
);
};
}
/**
* TODO: Currently scrobbling client-side would result in duplicated scrobbles
* if the user was authorized across multiple connections. Ideally this would
* be handled server-side. Mopidy-Scrobbler currently achieves this.
**/
export function scrobble(track){
return (dispatch, getState) => {
var track_name = track.name;
var artist_name = "Unknown";
if (track.artists){
artist_name = track.artists[0].name;
}
var artist_name = encodeURIComponent(artist_name);
var params = 'method=track.scrobble';
params += '&track='+track_name+'&artist='+artist_name;
params += '&timestamp='+Math.floor(Date.now() / 1000);
sendSignedRequest(dispatch, getState, params)
.then(
response => {
console.log("Scrobbled", response);
},
error => {
dispatch(coreActions.handleException(
'Could not scrobble LastFM track',
error,
(error.description ? error.description : null)
));
}
)
* */
export function scrobble(track) {
return (dispatch, getState) => {
const track_name = track.name;
var artist_name = 'Unknown';
if (track.artists) {
artist_name = track.artists[0].name;
}
var artist_name = encodeURIComponent(artist_name);
let params = 'method=track.scrobble';
params += `&track=${track_name}&artist=${artist_name}`;
params += `&timestamp=${Math.floor(Date.now() / 1000)}`;
sendSignedRequest(dispatch, getState, params)
.then(
(response) => {
console.log('Scrobbled', response);
},
(error) => {
dispatch(coreActions.handleException(
'Could not scrobble LastFM track',
error,
(error.description ? error.description : null),
));
},
);
};
}

60
src/js/services/lastfm/middleware.js
View File

@ -1,39 +1,37 @@
var helpers = require('./../../helpers');
var coreActions = require('../core/actions');
var lastfmActions = require('./actions');
const helpers = require('./../../helpers');
const coreActions = require('../core/actions');
const lastfmActions = require('./actions');
const LastfmMiddleware = (function(){
const LastfmMiddleware = (function () {
return (store) => (next) => (action) => {
switch (action.type) {
case 'LASTFM_ME_LOADED':
var me = helpers.formatUser(action.me);
Object.assign(
me,
{
uri: `lastfm:user:${me.name}`,
},
);
store.dispatch(coreActions.userLoaded(me));
action.me = me;
next(action);
break;
return store => next => action => {
switch(action.type){
case 'LASTFM_IMPORT_AUTHORIZATION':
case 'LASTFM_ME_LOADED':
var me = helpers.formatUser(action.me);
Object.assign(
me,
{
uri: "lastfm:user:"+me.name
}
);
store.dispatch(coreActions.userLoaded(me));
action.me = me;
next(action);
break;
// Wait a few moments before we fetch, allowing the import to complete first
// TODO: Use callbacks for better code accuracy
setTimeout(() => { store.dispatch(lastfmActions.getMe()); }, 100);
case 'LASTFM_IMPORT_AUTHORIZATION':
next(action);
break;
// Wait a few moments before we fetch, allowing the import to complete first
// TODO: Use callbacks for better code accuracy
setTimeout(() => {store.dispatch(lastfmActions.getMe())}, 100);
next(action);
break;
default:
return next(action);
}
default:
return next(action);
}
})();
};
}());
export default LastfmMiddleware
export default LastfmMiddleware;

71
src/js/services/lastfm/reducer.js
View File

@ -1,46 +1,43 @@
export default function reducer(lastfm = {}, action){
switch (action.type){
export default function reducer(lastfm = {}, action) {
switch (action.type) {
case 'LASTFM_CONNECT':
case 'LASTFM_CONNECTING':
return { ...lastfm, connected: false, connecting: true };
case 'LASTFM_CONNECT':
case 'LASTFM_CONNECTING':
return Object.assign({}, lastfm, { connected: false, connecting: true });
case 'LASTFM_CONNECTED':
return { ...lastfm, connected: true, connecting: false };
case 'LASTFM_CONNECTED':
return Object.assign({}, lastfm, { connected: true, connecting: false });
case 'LASTFM_SET':
return { ...lastfm, ...action.data };
case 'LASTFM_SET':
return Object.assign({}, lastfm, action.data)
case 'LASTFM_ME_LOADED':
return { ...lastfm, me: action.me };
case 'LASTFM_ME_LOADED':
return Object.assign({}, lastfm, {
me: action.me
})
case 'LASTFM_AUTHORIZATION_GRANTED':
return {
...lastfm,
authorizing: false,
authorization: action.data.session,
};
case 'LASTFM_AUTHORIZATION_GRANTED':
return Object.assign({}, lastfm, {
authorizing: false,
authorization: action.data.session
})
case 'LASTFM_AUTHORIZATION_REVOKED':
return {
...lastfm,
authorizing: false,
authorization: false,
me: null,
};
case 'LASTFM_AUTHORIZATION_REVOKED':
return Object.assign({}, lastfm, {
authorizing: false,
authorization: false,
me: null
});
case 'LASTFM_IMPORT_AUTHORIZATION':
return {
...lastfm,
authorizing: false,
authorization: action.authorization,
me: null,
};
case 'LASTFM_IMPORT_AUTHORIZATION':
return Object.assign({}, lastfm, {
authorizing: false,
authorization: action.authorization,
me: null
});
default:
return lastfm
}
default:
return lastfm;
}
}

517
src/js/services/localstorage/middleware.js
View File

@ -1,271 +1,267 @@
var helpers = require('../../helpers.js')
const helpers = require('../../helpers.js');
const localstorageMiddleware = (function(){
/**
const localstorageMiddleware = (function () {
/**
* The actual middleware inteceptor
**/
return store => next => action => {
* */
return (store) => (next) => (action) => {
// proceed as normal first
// this way, any reducers and middleware do their thing BEFORE we store our new state
next(action);
// proceed as normal first
// this way, any reducers and middleware do their thing BEFORE we store our new state
next(action);
// append our state to a global variable. This gives us access to debug the store at any point
window._store = store;
// append our state to a global variable. This gives us access to debug the store at any point
window._store = store
// if debug enabled
if (store.getState().ui.log_actions) {
const ignored_actions = [
'START_LOADING',
'STOP_LOADING',
];
// if debug enabled
if (store.getState().ui.log_actions){
// Show non-ignored actions
if (!ignored_actions.includes(action.type)) {
console.log(action);
}
}
var ignored_actions = [
'START_LOADING',
'STOP_LOADING'
]
switch (action.type) {
case 'PUSHER_CONNECTED':
helpers.setStorage(
'pusher',
{
connection_id: action.connection_id,
},
);
break;
// Show non-ignored actions
if (!ignored_actions.includes(action.type)){
console.log(action)
}
case 'PUSHER_SET_PORT':
helpers.setStorage(
'pusher',
{
port: action.port,
},
);
break;
case 'PUSHER_SET_USERNAME':
helpers.setStorage(
'pusher',
{
username: action.username,
},
);
break;
case 'MOPIDY_URISCHEMES_FILTERED':
helpers.setStorage(
'mopidy',
{
uri_schemes: action.data,
},
);
break;
case 'SPOTIFY_AUTHORIZATION_GRANTED':
if (action.authorization !== undefined) {
var { authorization } = action;
} else if (action.data) {
var authorization = action.data;
}
helpers.setStorage(
'spotify',
{
authorization,
access_token: authorization.access_token,
refresh_token: authorization.refresh_token,
token_expiry: authorization.token_expiry,
},
);
break;
case 'SPOTIFY_IMPORT_AUTHORIZATION':
helpers.setStorage(
'spotify',
{
authorization: action.authorization,
access_token: action.authorization.access_token,
refresh_token: action.authorization.refresh_token,
token_expiry: action.authorization.token_expiry,
me: null,
},
);
break;
case 'SPOTIFY_AUTHORIZATION_REVOKED':
helpers.setStorage(
'spotify',
{
authorization: null,
access_token: null,
refresh_token: null,
token_expiry: null,
me: null,
},
);
break;
case 'SPOTIFY_TOKEN_REFRESHED':
helpers.setStorage(
'spotify',
{
access_token: action.data.access_token,
token_expiry: action.data.token_expiry,
provider: action.provider,
},
);
break;
case 'SPOTIFY_ME_LOADED':
helpers.setStorage(
'spotify',
{
me: action.me,
},
);
break;
case 'LASTFM_ME_LOADED':
helpers.setStorage(
'lastfm',
{
me: action.me,
},
);
break;
case 'LASTFM_AUTHORIZATION_GRANTED':
helpers.setStorage(
'lastfm',
{
authorization: action.data.session,
},
);
break;
case 'LASTFM_AUTHORIZATION_REVOKED':
helpers.setStorage(
'lastfm',
{
authorization: null,
me: null,
},
);
break;
case 'LASTFM_IMPORT_AUTHORIZATION':
helpers.setStorage(
'lastfm',
{
authorization: action.authorization,
me: null,
},
);
break;
case 'GENIUS_ME_LOADED':
helpers.setStorage(
'genius',
{
me: action.me,
},
);
break;
case 'GENIUS_AUTHORIZATION_GRANTED':
helpers.setStorage(
'genius',
{
authorization: action.data,
authorization_code: action.data.authorization_code,
access_token: action.data.access_token,
},
);
break;
case 'GENIUS_AUTHORIZATION_REVOKED':
helpers.setStorage(
'genius',
{
me: null,
authorization: null,
authorization_code: null,
access_token: null,
},
);
break;
case 'GENIUS_IMPORT_AUTHORIZATION':
helpers.setStorage(
'genius',
{
authorization: action.authorization,
authorization_code: action.authorization.authorization_code,
access_token: action.authorization.access_token,
me: null,
},
);
break;
case 'CORE_SET':
helpers.setStorage(
'core',
action.data,
);
break;
case 'UI_SET':
helpers.setStorage(
'ui',
action.data,
);
break;
case 'MOPIDY_SET':
helpers.setStorage(
'mopidy',
action.data,
);
break;
case 'SPOTIFY_SET':
helpers.setStorage(
'spotify',
action.data,
);
break;
case 'SNAPCAST_COMMANDS_UPDATED':
helpers.setStorage(
'snapcast',
{
commands: action.commands,
},
);
break;
case 'SUPPRESS_BROADCAST':
var ui = helpers.getStorage('ui');
if (ui.suppressed_broadcasts !== undefined) {
var { suppressed_broadcasts } = ui;
} else {
var suppressed_broadcasts = [];
}
switch(action.type){
suppressed_broadcasts.push(action.key);
case 'PUSHER_CONNECTED':
helpers.setStorage(
'pusher',
{
connection_id: action.connection_id
}
);
break;
case 'PUSHER_SET_PORT':
helpers.setStorage(
'pusher',
{
port: action.port
}
);
break;
case 'PUSHER_SET_USERNAME':
helpers.setStorage(
'pusher',
{
username: action.username
}
);
break;
case 'MOPIDY_URISCHEMES_FILTERED':
helpers.setStorage(
'mopidy',
{
uri_schemes: action.data
}
);
break;
case 'SPOTIFY_AUTHORIZATION_GRANTED':
if (action.authorization !== undefined){
var authorization = action.authorization;
} else if (action.data){
var authorization = action.data;
}
helpers.setStorage(
'spotify',
{
authorization: authorization,
access_token: authorization.access_token,
refresh_token: authorization.refresh_token,
token_expiry: authorization.token_expiry
}
);
break;
case 'SPOTIFY_IMPORT_AUTHORIZATION':
helpers.setStorage(
'spotify',
{
authorization: action.authorization,
access_token: action.authorization.access_token,
refresh_token: action.authorization.refresh_token,
token_expiry: action.authorization.token_expiry,
me: null
}
);
break;
case 'SPOTIFY_AUTHORIZATION_REVOKED':
helpers.setStorage(
'spotify',
{
authorization: null,
access_token: null,
refresh_token: null,
token_expiry: null,
me: null
}
);
break;
case 'SPOTIFY_TOKEN_REFRESHED':
helpers.setStorage(
'spotify',
{
access_token: action.data.access_token,
token_expiry: action.data.token_expiry,
provider: action.provider
}
);
break;
case 'SPOTIFY_ME_LOADED':
helpers.setStorage(
'spotify',
{
me: action.me
}
);
break;
case 'LASTFM_ME_LOADED':
helpers.setStorage(
'lastfm',
{
me: action.me
}
);
break;
case 'LASTFM_AUTHORIZATION_GRANTED':
helpers.setStorage(
'lastfm',
{
authorization: action.data.session
}
);
break;
case 'LASTFM_AUTHORIZATION_REVOKED':
helpers.setStorage(
'lastfm',
{
authorization: null,
me: null
}
);
break;
case 'LASTFM_IMPORT_AUTHORIZATION':
helpers.setStorage(
'lastfm',
{
authorization: action.authorization,
me: null
}
);
break;
case 'GENIUS_ME_LOADED':
helpers.setStorage(
'genius',
{
me: action.me
}
);
break;
case 'GENIUS_AUTHORIZATION_GRANTED':
helpers.setStorage(
'genius',
{
authorization: action.data,
authorization_code: action.data.authorization_code,
access_token: action.data.access_token
}
);
break;
case 'GENIUS_AUTHORIZATION_REVOKED':
helpers.setStorage(
'genius',
{
me: null,
authorization: null,
authorization_code: null,
access_token: null
}
);
break;
case 'GENIUS_IMPORT_AUTHORIZATION':
helpers.setStorage(
'genius',
{
authorization: action.authorization,
authorization_code: action.authorization.authorization_code,
access_token: action.authorization.access_token,
me: null
}
);
break;
case 'CORE_SET':
helpers.setStorage(
'core',
action.data
);
break
case 'UI_SET':
helpers.setStorage(
'ui',
action.data
);
break
case 'MOPIDY_SET':
helpers.setStorage(
'mopidy',
action.data
);
break;
case 'SPOTIFY_SET':
helpers.setStorage(
'spotify',
action.data
);
break;
case 'SNAPCAST_COMMANDS_UPDATED':
helpers.setStorage(
'snapcast',
{
commands: action.commands
}
);
break;
case 'SUPPRESS_BROADCAST':
var ui = helpers.getStorage('ui');
if (ui.suppressed_broadcasts !== undefined){
var suppressed_broadcasts = ui.suppressed_broadcasts;
} else {
var suppressed_broadcasts = [];
}
suppressed_broadcasts.push(action.key);
helpers.setStorage(
'ui',
{
suppressed_broadcasts: suppressed_broadcasts
}
);
break
helpers.setStorage(
'ui',
{
suppressed_broadcasts,
},
);
break;
/**
* Experimental saving of stores to localStorage
@ -293,9 +289,8 @@ const localstorageMiddleware = (function(){
next(action);
break;
*/
}
}
};
}());
})();
export default localstorageMiddleware
export default localstorageMiddleware;

685
src/js/services/mopidy/actions.js
View File

@ -1,509 +1,506 @@
import * as helpers from '../../helpers'
import * as helpers from '../../helpers';
export function set(data){
return {
type: 'MOPIDY_SET',
data: data
}
export function set(data) {
return {
type: 'MOPIDY_SET',
data,
};
}
export function request(method, params = {}, response_callback = null, error_callback = null){
return {
type: 'MOPIDY_REQUEST',
method: method,
params: params,
response_callback: response_callback,
error_callback: error_callback
}
export function request(method, params = {}, response_callback = null, error_callback = null) {
return {
type: 'MOPIDY_REQUEST',
method,
params,
response_callback,
error_callback,
};
}
export function connect(){
return {
type: 'MOPIDY_CONNECT'
}
export function connect() {
return {
type: 'MOPIDY_CONNECT',
};
}
export function connecting(){
return {
type: 'MOPIDY_CONNECTING'
}
export function connecting() {
return {
type: 'MOPIDY_CONNECTING',
};
}
export function disconnect(){
return {
type: 'MOPIDY_DISCONNECT'
}
export function disconnect() {
return {
type: 'MOPIDY_DISCONNECT',
};
}
export function debug(call, value){
return {
type: 'MOPIDY_DEBUG',
call: call,
value: value
}
export function debug(call, value) {
return {
type: 'MOPIDY_DEBUG',
call,
value,
};
}
export function restartStarted(){
return {
type: 'MOPIDY_RESTART_STARTED'
}
export function restartStarted() {
return {
type: 'MOPIDY_RESTART_STARTED',
};
}
export function restartFinished(){
return {
type: 'MOPIDY_RESTART_FINISHED'
}
export function restartFinished() {
return {
type: 'MOPIDY_RESTART_FINISHED',
};
}
export function upgradeStarted(){
return {
type: 'MOPIDY_UPGRADE_STARTED'
}
export function upgradeStarted() {
return {
type: 'MOPIDY_UPGRADE_STARTED',
};
}
export function upgradeFinished(){
return {
type: 'MOPIDY_UPGRADE_FINISHED'
}
export function upgradeFinished() {
return {
type: 'MOPIDY_UPGRADE_FINISHED',
};
}
export function localScanStarted(){
return {
type: 'MOPIDY_LOCAL_SCAN_STARTED'
}
export function localScanStarted() {
return {
type: 'MOPIDY_LOCAL_SCAN_STARTED',
};
}
export function localScanFinished(){
return {
type: 'MOPIDY_LOCAL_SCAN_FINISHED'
}
export function localScanFinished() {
return {
type: 'MOPIDY_LOCAL_SCAN_FINISHED',
};
}
/**
* Core play actions
**/
* */
export function getPlayState(){
return {
type: 'MOPIDY_GET_PLAY_STATE'
}
export function getPlayState() {
return {
type: 'MOPIDY_GET_PLAY_STATE',
};
}
export function play(){
return {
type: 'MOPIDY_PLAY'
}
export function play() {
return {
type: 'MOPIDY_PLAY',
};
}
export function pause(){
return {
type: 'MOPIDY_PAUSE'
}
export function pause() {
return {
type: 'MOPIDY_PAUSE',
};
}
export function stop(){
return {
type: 'MOPIDY_STOP'
}
export function stop() {
return {
type: 'MOPIDY_STOP',
};
}
export function next(){
return {
type: 'MOPIDY_NEXT'
}
export function next() {
return {
type: 'MOPIDY_NEXT',
};
}
export function previous(){
return {
type: 'MOPIDY_PREVIOUS'
}
export function previous() {
return {
type: 'MOPIDY_PREVIOUS',
};
}
export function getMute(){
return {
type: 'MOPIDY_GET_MUTE'
}
export function getMute() {
return {
type: 'MOPIDY_GET_MUTE',
};
}
export function setMute(mute){
return {
type: 'MOPIDY_SET_MUTE',
mute: mute
}
export function setMute(mute) {
return {
type: 'MOPIDY_SET_MUTE',
mute,
};
}
export function getVolume(){
return {
type: 'MOPIDY_GET_VOLUME'
}
export function getVolume() {
return {
type: 'MOPIDY_GET_VOLUME',
};
}
export function setVolume(volume){
return {
type: 'MOPIDY_SET_VOLUME',
volume: volume
}
export function setVolume(volume) {
return {
type: 'MOPIDY_SET_VOLUME',
volume,
};
}
export function getConsume(){
return {
type: 'MOPIDY_GET_CONSUME'
}
export function getConsume() {
return {
type: 'MOPIDY_GET_CONSUME',
};
}
export function setConsume(consume){
return {
type: 'MOPIDY_SET_CONSUME',
consume: consume
}
export function setConsume(consume) {
return {
type: 'MOPIDY_SET_CONSUME',
consume,
};
}
export function getRepeat(){
return {
type: 'MOPIDY_GET_REPEAT'
}
export function getRepeat() {
return {
type: 'MOPIDY_GET_REPEAT',
};
}
export function setRepeat(repeat){
return {
type: 'MOPIDY_SET_REPEAT',
repeat: repeat
}
export function setRepeat(repeat) {
return {
type: 'MOPIDY_SET_REPEAT',
repeat,
};
}
export function getRandom(){
return {
type: 'MOPIDY_GET_RANDOM'
}
export function getRandom() {
return {
type: 'MOPIDY_GET_RANDOM',
};
}
export function setRandom(random){
return {
type: 'MOPIDY_SET_RANDOM',
random: random
}
export function setRandom(random) {
return {
type: 'MOPIDY_SET_RANDOM',
random,
};
}
export function getTimePosition(){
return {
type: 'MOPIDY_GET_TIME_POSITION'
}
export function getTimePosition() {
return {
type: 'MOPIDY_GET_TIME_POSITION',
};
}
export function setTimePosition(time_position){
return {
type: 'MOPIDY_SET_TIME_POSITION',
time_position: parseInt(time_position)
}
export function setTimePosition(time_position) {
return {
type: 'MOPIDY_SET_TIME_POSITION',
time_position: parseInt(time_position),
};
}
export function timePosition(time_position){
return {
type: 'MOPIDY_TIME_POSITION',
time_position: parseInt(time_position)
}
export function timePosition(time_position) {
return {
type: 'MOPIDY_TIME_POSITION',
time_position: parseInt(time_position),
};
}
export function getUriSchemes(){
return {
type: 'MOPIDY_GET_URI_SCHEMES'
}
export function getUriSchemes() {
return {
type: 'MOPIDY_GET_URI_SCHEMES',
};
}
/**
* Advanced playback actions
**/
* */
export function getCurrentTrack(){
return {
type: 'MOPIDY_GET_CURRENT_TRACK'
}
export function getCurrentTrack() {
return {
type: 'MOPIDY_GET_CURRENT_TRACK',
};
}
export function currentTrackLoaded(tl_track){
return {
type: 'MOPIDY_CURRENT_TRACK_LOADED',
tl_track: tl_track
}
export function currentTrackLoaded(tl_track) {
return {
type: 'MOPIDY_CURRENT_TRACK_LOADED',
tl_track,
};
}
export function getNextTrack(){
return {
type: 'MOPIDY_GET_NEXT_TRACK'
}
export function getNextTrack() {
return {
type: 'MOPIDY_GET_NEXT_TRACK',
};
}
export function clearCurrentTrack(){
return {
type: 'CLEAR_CURRENT_TRACK'
}
export function clearCurrentTrack() {
return {
type: 'CLEAR_CURRENT_TRACK',
};
}
export function getQueue(){
return {
type: 'MOPIDY_GET_QUEUE'
}
export function getQueue() {
return {
type: 'MOPIDY_GET_QUEUE',
};
}
export function changeTrack(tlid){
return {
type: 'MOPIDY_CHANGE_TRACK',
tlid: tlid
}
export function changeTrack(tlid) {
return {
type: 'MOPIDY_CHANGE_TRACK',
tlid,
};
}
/**
* Playing assets
**/
* */
export function playURIs(uris = [], from_uri = null, shuffle = false){
return {
type: 'MOPIDY_PLAY_URIS',
uris: uris,
from_uri: from_uri
}
export function playURIs(uris = [], from_uri = null, shuffle = false) {
return {
type: 'MOPIDY_PLAY_URIS',
uris,
from_uri,
};
}
export function playAlbum(uri){
return {
type: 'MOPIDY_PLAY_ALBUM',
uri: uri
}
export function playAlbum(uri) {
return {
type: 'MOPIDY_PLAY_ALBUM',
uri,
};
}
export function playPlaylist(uri, shuffle = false){
return {
type: 'MOPIDY_PLAY_PLAYLIST',
uri: uri,
shuffle: shuffle
}
export function playPlaylist(uri, shuffle = false) {
return {
type: 'MOPIDY_PLAY_PLAYLIST',
uri,
shuffle,
};
}
export function enqueueURIs(uris = [], from_uri = null, play_next = false, at_position = null, offset = 0){
return {
type: 'MOPIDY_ENQUEUE_URIS',
uris: uris,
from_uri: from_uri,
at_position: at_position,
play_next: play_next,
offset: offset
}
export function enqueueURIs(uris = [], from_uri = null, play_next = false, at_position = null, offset = 0) {
return {
type: 'MOPIDY_ENQUEUE_URIS',
uris,
from_uri,
at_position,
play_next,
offset,
};
}
export function enqueueAlbum(uri, next = false, at_position = null){
return {
type: 'MOPIDY_ENQUEUE_ALBUM',
uri: uri,
next: next,
at_position: at_position
}
export function enqueueAlbum(uri, next = false, at_position = null) {
return {
type: 'MOPIDY_ENQUEUE_ALBUM',
uri,
next,
at_position,
};
}
export function enqueuePlaylist(uri, play_next = false, at_position = null){
return {
type: 'MOPIDY_ENQUEUE_PLAYLIST',
uri: uri,
play_next: play_next,
at_position: at_position
}
export function enqueuePlaylist(uri, play_next = false, at_position = null) {
return {
type: 'MOPIDY_ENQUEUE_PLAYLIST',
uri,
play_next,
at_position,
};
}
export function enqueueURIsBatchDone(){
return {
type: 'MOPIDY_ENQUEUE_URIS_BATCH_DONE'
}
export function enqueueURIsBatchDone() {
return {
type: 'MOPIDY_ENQUEUE_URIS_BATCH_DONE',
};
}
/**
* Playlist maniopulation
**/
* */
export function removeTracks(tlids){
return {
type: 'MOPIDY_REMOVE_TRACKS',
tlids: tlids
}
export function removeTracks(tlids) {
return {
type: 'MOPIDY_REMOVE_TRACKS',
tlids,
};
}
export function reorderTracklist(indexes, insert_before){
var range = helpers.createRange(indexes );
if (insert_before > range.start ) insert_before = insert_before - range.length
return {
type: 'MOPIDY_REORDER_TRACKLIST',
range_start: range.start,
range_length: range.length,
insert_before: insert_before
}
export function reorderTracklist(indexes, insert_before) {
const range = helpers.createRange(indexes);
if (insert_before > range.start) insert_before -= range.length;
return {
type: 'MOPIDY_REORDER_TRACKLIST',
range_start: range.start,
range_length: range.length,
insert_before,
};
}
export function clearTracklist(){
return {
type: 'MOPIDY_CLEAR_TRACKLIST'
}
export function clearTracklist() {
return {
type: 'MOPIDY_CLEAR_TRACKLIST',
};
}
/**
* Asset-oriented actions
**/
* */
export function getImages(context, uris){
return {
type: 'MOPIDY_GET_IMAGES',
context: context,
uris: uris
}
export function getImages(context, uris) {
return {
type: 'MOPIDY_GET_IMAGES',
context,
uris,
};
}
export function createPlaylist(name, scheme){
return {
type: 'MOPIDY_CREATE_PLAYLIST',
name: name,
scheme: scheme
}
export function createPlaylist(name, scheme) {
return {
type: 'MOPIDY_CREATE_PLAYLIST',
name,
scheme,
};
}
export function deletePlaylist(uri){
return {
type: 'MOPIDY_DELETE_PLAYLIST',
uri: uri
}
export function deletePlaylist(uri) {
return {
type: 'MOPIDY_DELETE_PLAYLIST',
uri,
};
}
export function getLibraryPlaylists(){
return { type: 'MOPIDY_GET_LIBRARY_PLAYLISTS' }
export function getLibraryPlaylists() {
return { type: 'MOPIDY_GET_LIBRARY_PLAYLISTS' };
}
export function getPlaylist(uri){
return {
type: 'MOPIDY_GET_PLAYLIST',
data: { uri: uri }
}
export function getPlaylist(uri) {
return {
type: 'MOPIDY_GET_PLAYLIST',
data: { uri },
};
}
export function getPlaylists(uris, processor = null){
return {
type: 'MOPIDY_GET_PLAYLISTS',
uris: uris,
processor: processor
}
export function getPlaylists(uris, processor = null) {
return {
type: 'MOPIDY_GET_PLAYLISTS',
uris,
processor,
};
}
export function getDirectory(uri){
return {
type: 'MOPIDY_GET_DIRECTORY',
data: { uri: uri }
}
export function getDirectory(uri) {
return {
type: 'MOPIDY_GET_DIRECTORY',
data: { uri },
};
}
export function getTrack(uri){
return {
type: 'MOPIDY_GET_TRACK',
data: { uri: uri }
}
export function getTrack(uri) {
return {
type: 'MOPIDY_GET_TRACK',
data: { uri },
};
}
export function getLibraryArtists(uri = null){
return {
type: 'MOPIDY_GET_LIBRARY_ARTISTS',
uri: uri
}
export function getLibraryArtists(uri = null) {
return {
type: 'MOPIDY_GET_LIBRARY_ARTISTS',
uri,
};
}
export function clearLibraryArtists(){
return {
type: 'MOPIDY_CLEAR_LIBRARY_ARTISTS'
}
export function clearLibraryArtists() {
return {
type: 'MOPIDY_CLEAR_LIBRARY_ARTISTS',
};
}
export function getArtist(uri){
return {
type: 'MOPIDY_GET_ARTIST',
data: { uri: uri }
}
export function getArtist(uri) {
return {
type: 'MOPIDY_GET_ARTIST',
data: { uri },
};
}
export function getArtists(uris, processor = null){
return {
type: 'MOPIDY_GET_ARTISTS',
uris: uris,
processor: processor
}
export function getArtists(uris, processor = null) {
return {
type: 'MOPIDY_GET_ARTISTS',
uris,
processor,
};
}
export function getAlbum(uri){
return {
type: 'MOPIDY_GET_ALBUM',
data: { uri: uri }
}
export function getAlbum(uri) {
return {
type: 'MOPIDY_GET_ALBUM',
data: { uri },
};
}
export function getAlbums(uris, processor = null){
return {
type: 'MOPIDY_GET_ALBUMS',
uris: uris,
processor: processor
}
export function getAlbums(uris, processor = null) {
return {
type: 'MOPIDY_GET_ALBUMS',
uris,
processor,
};
}
export function getLibraryAlbums(uri = null){
return {
type: 'MOPIDY_GET_LIBRARY_ALBUMS',
uri: uri
}
export function getLibraryAlbums(uri = null) {
return {
type: 'MOPIDY_GET_LIBRARY_ALBUMS',
uri,
};
}
export function clearLibraryAlbums(){
return {
type: 'MOPIDY_CLEAR_LIBRARY_ALBUMS'
}
export function clearLibraryAlbums() {
return {
type: 'MOPIDY_CLEAR_LIBRARY_ALBUMS',
};
}
export function runProcessor(processor){
return {
type: processor
}
export function runProcessor(processor) {
return {
type: processor,
};
}
export function cancelProcessor(processor){
return {
type: processor+'_CANCEL'
}
export function cancelProcessor(processor) {
return {
type: `${processor}_CANCEL`,
};
}
/**
* Searching
**/
* */
export function clearSearchResults(){
return {
type: 'MOPIDY_CLEAR_SEARCH_RESULTS'
}
export function clearSearchResults() {
return {
type: 'MOPIDY_CLEAR_SEARCH_RESULTS',
};
}
export function getSearchResults(context, query, limit = 100){
return {
type: 'MOPIDY_GET_SEARCH_RESULTS',
context: context,
query: query,
limit: limit
}
export function getSearchResults(context, query, limit = 100) {
return {
type: 'MOPIDY_GET_SEARCH_RESULTS',
context,
query,
limit,
};
}
/**
* Other general actions
**/
* */
export function getQueueHistory(){
return {
type: 'MOPIDY_GET_QUEUE_HISTORY'
}
export function getQueueHistory() {
return {
type: 'MOPIDY_GET_QUEUE_HISTORY',
};
}

4066
src/js/services/mopidy/middleware.js
View File

File diff suppressed because it is too large Load Diff

299
src/js/services/mopidy/reducer.js
View File

@ -1,217 +1,190 @@
import * as helpers from '../../helpers';
export default function reducer(mopidy = {}, action){
switch (action.type){
export default function reducer(mopidy = {}, action) {
switch (action.type) {
case 'MOPIDY_SET':
return { ...mopidy, ...action.data };
case 'MOPIDY_SET':
return Object.assign({}, mopidy, action.data);
case 'MOPIDY_CONNECT':
case 'MOPIDY_CONNECTING':
return {
...mopidy,
connected: false,
connecting: true,
};
case 'MOPIDY_CONNECT':
case 'MOPIDY_CONNECTING':
return Object.assign({}, mopidy, {
connected: false,
connecting: true
});
case 'MOPIDY_CONNECTED':
return Object.assign({}, mopidy, {
connected: true,
case 'MOPIDY_CONNECTED':
return {
...mopidy,
connected: true,
connecting: false,
restart_running: false,
upgrade_running: false
});
upgrade_running: false,
};
case 'MOPIDY_DISCONNECTED':
return Object.assign({}, mopidy, {
connected: false,
connecting: false
});
case 'MOPIDY_DISCONNECTED':
return {
...mopidy,
connected: false,
connecting: false,
};
case 'MOPIDY_CHANGE_TRACK':
return Object.assign({}, mopidy, {
tlid: action.tlid
});
case 'MOPIDY_CHANGE_TRACK':
return { ...mopidy, tlid: action.tlid };
case 'MOPIDY_URI_SCHEMES':
return Object.assign({}, mopidy, {
uri_schemes: action.uri_schemes
});
case 'MOPIDY_URI_SCHEMES':
return { ...mopidy, uri_schemes: action.uri_schemes };
case 'MOPIDY_RESTART_STARTED':
return Object.assign({}, mopidy, { restart_running: true });
case 'MOPIDY_RESTART_STARTED':
return { ...mopidy, restart_running: true };
case 'MOPIDY_RESTART_FINISHED':
return Object.assign({}, mopidy, { restart_running: false });
case 'MOPIDY_RESTART_FINISHED':
return { ...mopidy, restart_running: false };
case 'MOPIDY_UPGRADE_STARTED':
return Object.assign({}, mopidy, { upgrade_running: true });
case 'MOPIDY_UPGRADE_STARTED':
return { ...mopidy, upgrade_running: true };
case 'MOPIDY_UPGRADE_FINISHED':
return Object.assign({}, mopidy, { upgrade_running: false });
case 'MOPIDY_UPGRADE_FINISHED':
return { ...mopidy, upgrade_running: false };
case 'MOPIDY_LOCAL_SCAN_STARTED':
return Object.assign({}, mopidy, { local_scan_running: true });
case 'MOPIDY_LOCAL_SCAN_STARTED':
return { ...mopidy, local_scan_running: true };
case 'MOPIDY_LOCAL_SCAN_FINISHED':
return Object.assign({}, mopidy, { local_scan_running: false });
case 'MOPIDY_LOCAL_SCAN_FINISHED':
return { ...mopidy, local_scan_running: false };
/**
/**
* State-oriented actions
**/
case 'MOPIDY_PLAY_STATE':
return Object.assign({}, mopidy, {
play_state: action.play_state
});
* */
case 'MOPIDY_PLAY_STATE':
return { ...mopidy, play_state: action.play_state };
case 'MOPIDY_CONSUME':
return Object.assign({}, mopidy, {
consume: action.consume
});
case 'MOPIDY_CONSUME':
return { ...mopidy, consume: action.consume };
case 'MOPIDY_RANDOM':
return Object.assign({}, mopidy, {
random: action.random
});
case 'MOPIDY_RANDOM':
return { ...mopidy, random: action.random };
case 'MOPIDY_REPEAT':
return Object.assign({}, mopidy, {
repeat: action.repeat
});
case 'MOPIDY_REPEAT':
return { ...mopidy, repeat: action.repeat };
case 'MOPIDY_VOLUME':
return Object.assign({}, mopidy, {
volume: action.volume
});
case 'MOPIDY_VOLUME':
return { ...mopidy, volume: action.volume };
case 'MOPIDY_MUTE':
return Object.assign({}, mopidy, {
mute: action.mute
});
case 'MOPIDY_MUTE':
return { ...mopidy, mute: action.mute };
case 'MOPIDY_TIME_POSITION':
return Object.assign({}, mopidy, {
time_position: action.time_position
});
case 'MOPIDY_TIME_POSITION':
return { ...mopidy, time_position: action.time_position };
case 'MOPIDY_QUEUE_HISTORY':
var history = [];
for (var i = 0; i < action.tracks.length; i++){
history.push(Object.assign(
{},
action.tracks[i][1],
{
played_at: action.tracks[i][0],
type: 'history'
}
))
}
return Object.assign({}, mopidy, {
queue_history: history
});
case 'MOPIDY_QUEUE_HISTORY':
var history = [];
for (let i = 0; i < action.tracks.length; i++) {
history.push({
...action.tracks[i][1],
played_at: action.tracks[i][0],
type: 'history',
});
}
return { ...mopidy, queue_history: history };
/**
/**
* Directories
* This also facilitates all backend-only music providers (SoundCloud, Dirble, etc)
**/
* */
case 'MOPIDY_DIRECTORY_FLUSH':
return Object.assign({}, mopidy, {
directory: null
});
case 'MOPIDY_DIRECTORY_FLUSH':
return { ...mopidy, directory: null };
case 'MOPIDY_DIRECTORY_LOADED':
return Object.assign({}, mopidy, {
directory: action.directory
});
case 'MOPIDY_DIRECTORY_LOADED':
return { ...mopidy, directory: action.directory };
/**
/**
* Library
**/
* */
case 'MOPIDY_LIBRARY_PLAYLISTS_LOADED':
if (mopidy.library_playlists){
var uris = [...mopidy.library_playlists,...action.uris]
} else {
var uris = action.uris
}
return Object.assign({}, mopidy, { library_playlists: helpers.removeDuplicates(uris) })
case 'MOPIDY_LIBRARY_PLAYLISTS_LOADED':
if (mopidy.library_playlists) {
var uris = [...mopidy.library_playlists, ...action.uris];
} else {
var { uris } = action;
}
return { ...mopidy, library_playlists: helpers.removeDuplicates(uris) };
case 'MOPIDY_LIBRARY_PLAYLISTS_LOADED_ALL':
return Object.assign({}, mopidy, { library_playlists_loaded_all: true })
case 'MOPIDY_LIBRARY_PLAYLISTS_LOADED_ALL':
return { ...mopidy, library_playlists_loaded_all: true };
case 'MOPIDY_LIBRARY_PLAYLIST_CREATED':
var library_playlists = [];
if (mopidy.library_playlists){
library_playlists = Object.assign([], mopidy.library_playlists);
}
library_playlists.push(action.key);
return Object.assign({}, mopidy, { library_playlists: library_playlists })
case 'MOPIDY_LIBRARY_PLAYLIST_CREATED':
var library_playlists = [];
if (mopidy.library_playlists) {
library_playlists = Object.assign([], mopidy.library_playlists);
}
library_playlists.push(action.key);
return { ...mopidy, library_playlists };
case 'MOPIDY_LIBRARY_PLAYLIST_DELETED':
var library_playlists = []
if (mopidy.library_playlists){
library_playlists = Object.assign([], mopidy.library_playlists);
library_playlists.splice(library_playlists.indexOf(action.uri), 1);
}
return Object.assign({}, mopidy, { library_playlists: library_playlists })
case 'MOPIDY_LIBRARY_PLAYLIST_DELETED':
var library_playlists = [];
if (mopidy.library_playlists) {
library_playlists = Object.assign([], mopidy.library_playlists);
library_playlists.splice(library_playlists.indexOf(action.uri), 1);
}
return { ...mopidy, library_playlists };
case 'MOPIDY_LIBRARY_ARTISTS_LOADED':
if (mopidy.library_artists){
var uris = [...mopidy.library_artists,...action.uris]
} else {
var uris = action.uris
}
return Object.assign({}, mopidy, { library_artists: helpers.removeDuplicates(uris) })
case 'MOPIDY_LIBRARY_ARTISTS_LOADED':
if (mopidy.library_artists) {
var uris = [...mopidy.library_artists, ...action.uris];
} else {
var { uris } = action;
}
return { ...mopidy, library_artists: helpers.removeDuplicates(uris) };
case 'MOPIDY_CLEAR_LIBRARY_ARTISTS':
return Object.assign({}, mopidy, { library_artists: null })
case 'MOPIDY_CLEAR_LIBRARY_ARTISTS':
return { ...mopidy, library_artists: null };
case 'MOPIDY_LIBRARY_ALBUMS_LOADED':
if (mopidy.library_albums){
var uris = [...mopidy.library_albums,...action.uris]
} else {
var uris = action.uris
}
return Object.assign({}, mopidy, { library_albums: helpers.removeDuplicates(uris) })
case 'MOPIDY_LIBRARY_ALBUMS_LOADED':
if (mopidy.library_albums) {
var uris = [...mopidy.library_albums, ...action.uris];
} else {
var { uris } = action;
}
return { ...mopidy, library_albums: helpers.removeDuplicates(uris) };
case 'MOPIDY_CLEAR_LIBRARY_ALBUMS':
return Object.assign({}, mopidy, { library_albums: null })
case 'MOPIDY_CLEAR_LIBRARY_ALBUMS':
return { ...mopidy, library_albums: null };
/**
/**
* Searching
**/
* */
case 'MOPIDY_CLEAR_SEARCH_RESULTS':
return Object.assign({}, mopidy, { search_results: {} });
case 'MOPIDY_CLEAR_SEARCH_RESULTS':
return { ...mopidy, search_results: {} };
case 'MOPIDY_SEARCH_RESULTS_LOADED':
case 'MOPIDY_SEARCH_RESULTS_LOADED':
// Fetch or create our container
if (mopidy.search_results){
var search_results = Object.assign({}, mopidy.search_results);
} else {
var search_results = {};
}
// Fetch or create our container
if (mopidy.search_results) {
var search_results = { ...mopidy.search_results };
} else {
var search_results = {};
}
search_results.query = action.query;
search_results.query = action.query;
if (search_results[action.context]){
search_results[action.context] = [...search_results[action.context], ...action.results];
} else {
search_results[action.context] = action.results;
}
if (search_results[action.context]) {
search_results[action.context] = [...search_results[action.context], ...action.results];
} else {
search_results[action.context] = action.results;
}
return Object.assign({}, mopidy, { search_results: search_results });
return { ...mopidy, search_results };
default:
return mopidy
}
default:
return mopidy;
}
}

352
src/js/services/pusher/actions.js
View File

@ -1,249 +1,249 @@
export function setPort(port){
return {
type: 'PUSHER_SET_PORT',
port: port
}
export function setPort(port) {
return {
type: 'PUSHER_SET_PORT',
port,
};
}
export function setUsername(username, force = false){
return {
type: 'PUSHER_SET_USERNAME',
username: username.replace(/[\W_]+/g,''),
force: force
}
export function setUsername(username, force = false) {
return {
type: 'PUSHER_SET_USERNAME',
username: username.replace(/[\W_]+/g, ''),
force,
};
}
export function connect(){
return {
type: 'PUSHER_CONNECT'
}
export function connect() {
return {
type: 'PUSHER_CONNECT',
};
}
export function disconnect(){
return {
type: 'PUSHER_DISCONNECT'
}
export function disconnect() {
return {
type: 'PUSHER_DISCONNECT',
};
}
export function upgrade(){
return {
type: 'PUSHER_UPGRADE'
}
export function upgrade() {
return {
type: 'PUSHER_UPGRADE',
};
}
export function reload(){
return {
type: 'PUSHER_RELOAD'
}
export function reload() {
return {
type: 'PUSHER_RELOAD',
};
}
export function restart(){
return {
type: 'PUSHER_RESTART'
}
export function restart() {
return {
type: 'PUSHER_RESTART',
};
}
export function localScan(){
return {
type: 'PUSHER_LOCAL_SCAN'
}
export function localScan() {
return {
type: 'PUSHER_LOCAL_SCAN',
};
}
export function getConnections(){
return {
type: 'PUSHER_GET_CONNECTIONS'
}
export function getConnections() {
return {
type: 'PUSHER_GET_CONNECTIONS',
};
}
export function connectionAdded(connection){
return {
type: 'PUSHER_CONNECTION_ADDED',
connection: connection
}
export function connectionAdded(connection) {
return {
type: 'PUSHER_CONNECTION_ADDED',
connection,
};
}
export function updateConnection(connection){
return {
type: 'PUSHER_UPDATE_CONNECTION',
connection: connection
}
export function updateConnection(connection) {
return {
type: 'PUSHER_UPDATE_CONNECTION',
connection,
};
}
export function connectionChanged(connection){
return {
type: 'PUSHER_CONNECTION_CHANGED',
connection: connection
}
export function connectionChanged(connection) {
return {
type: 'PUSHER_CONNECTION_CHANGED',
connection,
};
}
export function connectionRemoved(connection){
return {
type: 'PUSHER_CONNECTION_REMOVED',
connection: connection
}
export function connectionRemoved(connection) {
return {
type: 'PUSHER_CONNECTION_REMOVED',
connection,
};
}
export function request(method, params = null, response_callback = null, error_callback = null){
return {
type: 'PUSHER_REQUEST',
method: method,
params: params,
response_callback: response_callback,
error_callback: error_callback
}
export function request(method, params = null, response_callback = null, error_callback = null) {
return {
type: 'PUSHER_REQUEST',
method,
params,
response_callback,
error_callback,
};
}
export function getConfig(){
return {
type: 'PUSHER_GET_CONFIG'
}
export function getConfig() {
return {
type: 'PUSHER_GET_CONFIG',
};
}
export function getVersion(){
return {
type: 'PUSHER_GET_VERSION'
}
export function getVersion() {
return {
type: 'PUSHER_GET_VERSION',
};
}
export function deliverBroadcast(method, params){
return {
type: 'PUSHER_DELIVER_BROADCAST',
data: {
method: method,
params: params
}
}
export function deliverBroadcast(method, params) {
return {
type: 'PUSHER_DELIVER_BROADCAST',
data: {
method,
params,
},
};
}
export function deliverMessage(recipient, method, params){
return {
type: 'PUSHER_DELIVER_MESSAGE',
data: {
recipient: recipient,
method: method,
params: params
}
}
export function deliverMessage(recipient, method, params) {
return {
type: 'PUSHER_DELIVER_MESSAGE',
data: {
recipient,
method,
params,
},
};
}
export function getRadio(){
return {
type: 'PUSHER_GET_RADIO'
}
export function getRadio() {
return {
type: 'PUSHER_GET_RADIO',
};
}
export function startRadio(uris){
return {
type: 'PUSHER_START_RADIO',
uris: uris
}
export function startRadio(uris) {
return {
type: 'PUSHER_START_RADIO',
uris,
};
}
export function updateRadio(uris){
return {
type: 'PUSHER_UPDATE_RADIO',
uris: uris
}
export function updateRadio(uris) {
return {
type: 'PUSHER_UPDATE_RADIO',
uris,
};
}
export function stopRadio(){
return {
type: 'PUSHER_STOP_RADIO'
}
export function stopRadio() {
return {
type: 'PUSHER_STOP_RADIO',
};
}
export function radioStarted(radio){
return {
type: 'PUSHER_RADIO_STARTED',
radio: radio
}
export function radioStarted(radio) {
return {
type: 'PUSHER_RADIO_STARTED',
radio,
};
}
export function radioChanged(radio){
return {
type: 'PUSHER_RADIO_CHANGED',
radio: radio
}
export function radioChanged(radio) {
return {
type: 'PUSHER_RADIO_CHANGED',
radio,
};
}
export function radioStopped(){
return {
type: 'PUSHER_RADIO_STOPPED'
}
export function radioStopped() {
return {
type: 'PUSHER_RADIO_STOPPED',
};
}
export function debug(message = null){
return {
type: 'PUSHER_DEBUG',
message: message
}
export function debug(message = null) {
return {
type: 'PUSHER_DEBUG',
message,
};
}
export function getQueueMetadata(){
return {
type: 'PUSHER_GET_QUEUE_METADATA'
}
export function getQueueMetadata() {
return {
type: 'PUSHER_GET_QUEUE_METADATA',
};
}
export function queueMetadataChanged(queue_metadata){
return {
type: 'PUSHER_QUEUE_METADATA_CHANGED',
queue_metadata: queue_metadata
}
export function queueMetadataChanged(queue_metadata) {
return {
type: 'PUSHER_QUEUE_METADATA_CHANGED',
queue_metadata,
};
}
export function addQueueMetadata(tlids = [], from_uri = null){
return {
type: 'PUSHER_ADD_QUEUE_METADATA',
tlids: tlids,
from_uri: from_uri
}
export function addQueueMetadata(tlids = [], from_uri = null) {
return {
type: 'PUSHER_ADD_QUEUE_METADATA',
tlids,
from_uri,
};
}
/**
* Commands (buttons)
**/
* */
export function getCommands(){
return {
type: 'PUSHER_GET_COMMANDS'
}
export function getCommands() {
return {
type: 'PUSHER_GET_COMMANDS',
};
}
export function setCommand(command){
return {
type: 'PUSHER_SET_COMMAND',
command: command
}
export function setCommand(command) {
return {
type: 'PUSHER_SET_COMMAND',
command,
};
}
export function setCommands(commands){
return {
type: 'PUSHER_SET_COMMANDS',
commands: commands
}
export function setCommands(commands) {
return {
type: 'PUSHER_SET_COMMANDS',
commands,
};
}
export function removeCommand(id){
return {
type: 'PUSHER_REMOVE_COMMAND',
id: id
}
export function removeCommand(id) {
return {
type: 'PUSHER_REMOVE_COMMAND',
id,
};
}
export function runCommand(id, notify = false){
return {
type: 'PUSHER_RUN_COMMAND',
id: id,
notify: notify
}
export function runCommand(id, notify = false) {
return {
type: 'PUSHER_RUN_COMMAND',
id,
notify,
};
}
export function commandsUpdated(commands){
return {
type: 'PUSHER_COMMANDS_UPDATED',
commands: commands
}
}
export function commandsUpdated(commands) {
return {
type: 'PUSHER_COMMANDS_UPDATED',
commands,
};
}

1340
src/js/services/pusher/middleware.js
View File

File diff suppressed because it is too large Load Diff

115
src/js/services/pusher/reducer.js
View File

@ -1,73 +1,72 @@
export default function reducer(pusher = {}, action){
switch (action.type){
export default function reducer(pusher = {}, action) {
switch (action.type) {
case 'PUSHER_CONNECT':
case 'PUSHER_CONNECTING':
return { ...pusher, connected: false, connecting: true };
case 'PUSHER_CONNECT':
case 'PUSHER_CONNECTING':
return Object.assign({}, pusher, { connected: false, connecting: true });
case 'PUSHER_CONNECTED':
return {
...pusher,
connected: true,
connecting: false,
connection_id: action.connection_id,
client_id: action.client_id,
username: action.username,
};
case 'PUSHER_CONNECTED':
return Object.assign({}, pusher, {
connected: true,
connecting: false,
connection_id: action.connection_id,
client_id: action.client_id,
username: action.username
});
case 'PUSHER_DISCONNECTED':
return { ...pusher, connected: false, connecting: false };
case 'PUSHER_DISCONNECTED':
return Object.assign({}, pusher, { connected: false, connecting: false });
case 'PUSHER_SET_PORT':
return { ...pusher, port: action.port };
case 'PUSHER_SET_PORT':
return Object.assign({}, pusher, { port: action.port });
case 'PUSHER_SET_USERNAME':
return { ...pusher, username: action.username };
case 'PUSHER_SET_USERNAME':
return Object.assign({}, pusher, { username: action.username });
case 'PUSHER_CONNECTIONS':
var connections = {};
for (let i = 0; i < action.connections.length; i++) {
connections[action.connections[i].connection_id] = action.connections[i];
}
return { ...pusher, connections };
case 'PUSHER_CONNECTIONS':
var connections = {}
for (var i = 0; i < action.connections.length; i++){
connections[action.connections[i].connection_id] = action.connections[i]
}
return Object.assign({}, pusher, { connections: connections });
case 'PUSHER_CONNECTION_ADDED':
case 'PUSHER_CONNECTION_CHANGED':
var connections = { ...pusher.connections };
connections[action.connection.connection_id] = action.connection;
return { ...pusher, connections };
case 'PUSHER_CONNECTION_ADDED':
case 'PUSHER_CONNECTION_CHANGED':
var connections = Object.assign({}, pusher.connections)
connections[action.connection.connection_id] = action.connection;
return Object.assign({}, pusher, { connections: connections });
case 'PUSHER_CONNECTION_UPDATED':
return {
...pusher,
username: action.connection.username,
client_id: action.connection.client_id,
connection_id: action.connection.connection_id,
};
case 'PUSHER_CONNECTION_UPDATED':
return Object.assign({}, pusher, {
username: action.connection.username,
client_id: action.connection.client_id,
connection_id: action.connection.connection_id
});
case 'PUSHER_CONNECTION_REMOVED':
var connections = { ...pusher.connections };
delete connections[action.connection.connection_id];
return { ...pusher, connections };
case 'PUSHER_CONNECTION_REMOVED':
var connections = Object.assign({}, pusher.connections)
delete connections[action.connection.connection_id]
return Object.assign({}, pusher, { connections: connections });
case 'PUSHER_VERSION':
return {
...pusher,
version: action.version,
upgrading: false,
};
case 'PUSHER_VERSION':
return Object.assign({}, pusher, {
version: action.version,
upgrading: false
});
case 'PUSHER_START_UPGRADE':
return { ...pusher, upgrading: true };
case 'PUSHER_START_UPGRADE':
return Object.assign({}, pusher, { upgrading: true });
case 'PUSHER_CONFIG':
return { ...pusher, config: action.config };
case 'PUSHER_CONFIG':
return Object.assign({}, pusher, { config: action.config });
case 'PUSHER_COMMANDS_UPDATED':
return { ...pusher, commands: action.commands };
case 'PUSHER_COMMANDS_UPDATED':
return Object.assign({}, pusher, { commands: action.commands });
default:
return pusher
}
default:
return pusher;
}
}

192
src/js/services/snapcast/actions.js
View File

@ -1,135 +1,133 @@
export function getServer(){
return {
type: 'SNAPCAST_GET_SERVER'
}
export function getServer() {
return {
type: 'SNAPCAST_GET_SERVER',
};
}
export function setClientName(id, name){
return {
type: 'SNAPCAST_SET_CLIENT_NAME',
id: id,
name: name
}
export function setClientName(id, name) {
return {
type: 'SNAPCAST_SET_CLIENT_NAME',
id,
name,
};
}
export function setClientMute(id, mute){
return {
type: 'SNAPCAST_SET_CLIENT_MUTE',
id: id,
mute: mute
}
export function setClientMute(id, mute) {
return {
type: 'SNAPCAST_SET_CLIENT_MUTE',
id,
mute,
};
}
export function setClientVolume(id, volume){
return {
type: 'SNAPCAST_SET_CLIENT_VOLUME',
id: id,
volume: volume
}
export function setClientVolume(id, volume) {
return {
type: 'SNAPCAST_SET_CLIENT_VOLUME',
id,
volume,
};
}
export function setClientLatency(id, latency){
return {
type: 'SNAPCAST_SET_CLIENT_LATENCY',
id: id,
latency: latency
}
export function setClientLatency(id, latency) {
return {
type: 'SNAPCAST_SET_CLIENT_LATENCY',
id,
latency,
};
}
export function setClientGroup(id, group_id){
return {
type: 'SNAPCAST_SET_CLIENT_GROUP',
id: id,
group_id: group_id
}
export function setClientGroup(id, group_id) {
return {
type: 'SNAPCAST_SET_CLIENT_GROUP',
id,
group_id,
};
}
export function deleteClient(id){
return {
type: 'SNAPCAST_DELETE_CLIENT',
id: id
}
export function deleteClient(id) {
return {
type: 'SNAPCAST_DELETE_CLIENT',
id,
};
}
export function setGroupStream(id, stream_id){
return {
type: 'SNAPCAST_SET_GROUP_STREAM',
id: id,
stream_id: stream_id
}
export function setGroupStream(id, stream_id) {
return {
type: 'SNAPCAST_SET_GROUP_STREAM',
id,
stream_id,
};
}
export function setGroupMute(id, mute){
return {
type: 'SNAPCAST_SET_GROUP_MUTE',
id: id,
mute: mute
}
export function setGroupMute(id, mute) {
return {
type: 'SNAPCAST_SET_GROUP_MUTE',
id,
mute,
};
}
export function setGroupVolume(id, percent, old_percent = 0){
return {
type: 'SNAPCAST_SET_GROUP_VOLUME',
id: id,
percent: percent,
old_percent: old_percent
}
export function setGroupVolume(id, percent, old_percent = 0) {
return {
type: 'SNAPCAST_SET_GROUP_VOLUME',
id,
percent,
old_percent,
};
}
export function eventReceived(message){
return {
type: 'SNAPCAST_EVENT_RECEIVED',
method: message.method,
params: message.params
}
export function eventReceived(message) {
return {
type: 'SNAPCAST_EVENT_RECEIVED',
method: message.method,
params: message.params,
};
}
/**
* Record loaders
*
* We've got a loaded record, now we just need to plug it in to our state and stores.
**/
* */
export function serverLoaded(server){
return {
type: 'SNAPCAST_SERVER_LOADED',
server: server
}
export function serverLoaded(server) {
return {
type: 'SNAPCAST_SERVER_LOADED',
server,
};
}
export function clientLoaded(client){
return clientsLoaded([client]);
export function clientLoaded(client) {
return clientsLoaded([client]);
}
export function clientsLoaded(clients, flush = false){
return {
type: 'SNAPCAST_CLIENTS_LOADED',
clients: clients,
flush: flush
}
export function clientsLoaded(clients, flush = false) {
return {
type: 'SNAPCAST_CLIENTS_LOADED',
clients,
flush,
};
}
export function groupLoaded(group){
return groupsLoaded([group]);
export function groupLoaded(group) {
return groupsLoaded([group]);
}
export function groupsLoaded(groups, flush = false){
return {
type: 'SNAPCAST_GROUPS_LOADED',
groups: groups,
flush: flush
}
export function groupsLoaded(groups, flush = false) {
return {
type: 'SNAPCAST_GROUPS_LOADED',
groups,
flush,
};
}
export function streamLoaded(stream){
return streamsLoaded([stream]);
export function streamLoaded(stream) {
return streamsLoaded([stream]);
}
export function streamsLoaded(streams, flush = false){
return {
type: 'SNAPCAST_STREAMS_LOADED',
streams: streams,
flush: flush
}
}
export function streamsLoaded(streams, flush = false) {
return {
type: 'SNAPCAST_STREAMS_LOADED',
streams,
flush,
};
}

894
src/js/services/snapcast/middleware.js
View File

@ -1,474 +1,468 @@
import ReactGA from 'react-ga'
import ReactGA from 'react-ga';
var helpers = require('../../helpers');
var coreActions = require('../core/actions');
var uiActions = require('../ui/actions');
var pusherActions = require('../pusher/actions');
var snapcastActions = require('./actions');
const helpers = require('../../helpers');
const coreActions = require('../core/actions');
const uiActions = require('../ui/actions');
const pusherActions = require('../pusher/actions');
const snapcastActions = require('./actions');
const SnapcastMiddleware = (function(){
// A snapcast request is an alias of the Pusher request
const request = (store, params = null, response_callback = null, error_callback = null) => {
store.dispatch(
const SnapcastMiddleware = (function () {
// A snapcast request is an alias of the Pusher request
const request = (store, params = null, response_callback = null, error_callback = null) => {
store.dispatch(
pusherActions.request(
'snapcast',
params,
response_callback,
error_callback
)
);
return;
}
error_callback,
),
);
};
return store => next => action => {
var snapcast = store.getState().snapcast;
return (store) => (next) => (action) => {
const { snapcast } = store.getState();
switch(action.type){
case 'SNAPCAST_GET_SERVER':
request(
store,
switch (action.type) {
case 'SNAPCAST_GET_SERVER':
request(
store,
{
method: 'Server.GetStatus'
method: 'Server.GetStatus',
},
response => {
store.dispatch(snapcastActions.serverLoaded(response.server));
(response) => {
store.dispatch(snapcastActions.serverLoaded(response.server));
},
(error) => {
store.dispatch(coreActions.handleException(
'Could not get server',
error,
));
},
error => {
store.dispatch(coreActions.handleException(
'Could not get server',
error
));
}
);
break
break;
case 'SNAPCAST_SERVER_LOADED':
store.dispatch(snapcastActions.groupsLoaded(action.server.groups, true));
store.dispatch(snapcastActions.streamsLoaded(action.server.streams, true));
case 'SNAPCAST_SERVER_LOADED':
store.dispatch(snapcastActions.groupsLoaded(action.server.groups, true));
store.dispatch(snapcastActions.streamsLoaded(action.server.streams, true));
// Snapcast double-nests the server object
action.server = action.server.server;
// Snapcast double-nests the server object
action.server = action.server.server;
next(action);
break
next(action);
break;
case 'SNAPCAST_GROUPS_LOADED':
var groups_index = Object.assign({}, snapcast.groups);
var groups_loaded = [];
var clients_loaded = [];
case 'SNAPCAST_GROUPS_LOADED':
var groups_index = { ...snapcast.groups };
var groups_loaded = [];
var clients_loaded = [];
for (var raw_group of action.groups){
var group = helpers.formatGroup(raw_group);
for (const raw_group of action.groups) {
var group = helpers.formatGroup(raw_group);
if (groups_index[group.id]){
group = Object.assign({}, groups_index[group.id], group);
}
if (groups_index[group.id]) {
group = { ...groups_index[group.id], ...group };
}
if (raw_group.clients){
group.clients_ids = helpers.arrayOf('id', raw_group.clients);
clients_loaded = [...clients_loaded, ...raw_group.clients];
}
if (raw_group.clients) {
group.clients_ids = helpers.arrayOf('id', raw_group.clients);
clients_loaded = [...clients_loaded, ...raw_group.clients];
}
groups_loaded.push(group);
};
action.groups = groups_loaded;
if (clients_loaded.length > 0){
store.dispatch(snapcastActions.clientsLoaded(clients_loaded, action.flush));
}
next(action);
break
case 'SNAPCAST_CLIENTS_LOADED':
var clients_index = Object.assign({}, snapcast.clients);
var clients_loaded = [];
for (var raw_client of action.clients){
var client = helpers.formatClient(raw_client);
if (clients_index[client.id]){
client = Object.assign({}, clients_index[client.id], client);
}
clients_loaded.push(client);
}
action.clients = clients_loaded;
next(action);
break;
case 'SNAPCAST_SET_CLIENT_NAME':
var client = snapcast.clients[action.id];
var data = {
method: 'Client.SetName',
params: {
id: action.id,
name: action.name
}
}
request(
store,
data,
response => {
store.dispatch(snapcastActions.clientLoaded(
{
id: action.id,
name: response.name
}
));
}
);
break
case 'SNAPCAST_SET_CLIENT_MUTE':
var client = store.getState().snapcast.clients[action.id];
var data = {
method: 'Client.SetVolume',
params: {
id: action.id,
volume: {
muted: action.mute,
percent: client.volume,
}
}
}
request(
store,
data,
response => {
store.dispatch(snapcastActions.clientLoaded(
{
id: action.id,
volume: response.volume.percent,
mute: response.volume.muted
}
));
},
error => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message
));
}
);
break
case 'SNAPCAST_SET_CLIENT_VOLUME':
var client = snapcast.clients[action.id];
var data = {
method: 'Client.SetVolume',
params: {
id: action.id,
volume: {
muted: client.mute,
percent: action.volume
}
}
}
request(
store,
data,
response => {
store.dispatch(snapcastActions.clientLoaded(
{
id: action.id,
volume: response.volume.percent
}
));
},
error => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message
));
}
);
break
case 'SNAPCAST_SET_CLIENT_LATENCY':
var client = store.getState().snapcast.clients[action.id];
var data = {
method: 'Client.SetLatency',
params: {
id: action.id,
latency: action.latency
}
}
request(
store,
data,
response => {
store.dispatch(snapcastActions.clientLoaded(
{
id: action.id,
latency: response.latency
}
));
},
error => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message
));
}
);
break
case 'SNAPCAST_SET_CLIENT_GROUP':
var group = snapcast.groups[action.group_id];
var clients_ids = group.clients_ids;
var clients_ids_index = clients_ids.indexOf(action.id);
// Not in group (yet), so add it
if (clients_ids_index <= -1){
clients_ids.push(action.id);
// Already there, so remove it
} else {
clients_ids.splice(clients_ids_index, 1);
}
var data = {
method: 'Group.SetClients',
params: {
id: action.group_id,
clients: clients_ids
}
}
request(
store,
data,
response => {
store.dispatch(snapcastActions.serverLoaded(response.server));
},
error => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message
));
}
);
break
case 'SNAPCAST_DELETE_CLIENT':
var data = {
method: 'Server.DeleteClient',
params: {
id: action.id
}
}
request(
store,
data,
response => {
store.dispatch({
type: 'SNAPCAST_CLIENT_REMOVED',
key: action.data.params.id
})
},
error => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message
));
}
);
break
case 'SNAPCAST_SET_GROUP_STREAM':
var group = store.getState().snapcast.groups[action.id];
var data = {
method: 'Group.SetStream',
params: {
id: action.id,
stream_id: action.stream_id
}
}
request(
store,
data,
response => {
store.dispatch(snapcastActions.groupLoaded(
{
id: action.id,
stream_id: action.stream_id
}
));
},
error => {
store.dispatch(coreActions.handleException(
'Could not change stream',
error,
error.message
));
}
);
break
case 'SNAPCAST_SET_GROUP_MUTE':
var group = store.getState().snapcast.groups[action.id];
var data = {
method: 'Group.SetMute',
params: {
id: action.id,
mute: action.mute
}
}
request(
store,
data,
response => {
store.dispatch(snapcastActions.groupLoaded(
{
id: action.id,
muted: response.mute
}
));
},
error => {
store.dispatch(coreActions.handleException(
'Could not toggle mute',
error,
error.message
));
}
);
break;
case 'SNAPCAST_SET_GROUP_VOLUME':
var clients_to_update = [];
var group = snapcast.groups[action.id];
var change = action.percent - action.old_percent;
for (var client_id of group.clients_ids){
// Apply the change proportionately to each client
var client = snapcast.clients[client_id];
var current_volume = client.volume;
var new_volume = current_volume + change;
// Only change if the client is within min/max limits
if ((change > 0 && current_volume < 100) || (change < 0 && current_volume > 0)){
clients_to_update.push({
id: client.id,
volume: new_volume
});
}
}
// Loop our required changes, and post each to Snapcast
for (var client_to_update of clients_to_update){
var volume = client_to_update.volume + ((group.clients_ids.length - clients_to_update.length) * change);
// Make sure we're not creating an impossible percent
if (volume < 0){
volume = 0;
} else if (volume > 100){
volume = 100;
}
store.dispatch(snapcastActions.setClientVolume(client_to_update.id, volume));
}
break;
case 'SNAPCAST_EVENT_RECEIVED':
// Drop the prefix
action.method = action.method.replace('snapcast_','');
switch (action.method){
case 'Client.OnConnect':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.client.id,
name: action.params.client.name,
volume: action.params.client.volume.percent,
mute: action.params.client.volume.muted,
connected: action.params.client.connected
}
));
break;
case 'Client.OnDisconnect':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.client.id,
connected: action.params.client.connected
}
));
break;
case 'Client.OnVolumeChanged':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.id,
mute: action.params.volume.muted,
volume: action.params.volume.percent
}
));
break;
case 'Client.OnLatencyChanged':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.id,
latency: action.params.latency
}
));
break;
case 'Client.OnNameChanged':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.id,
name: action.params.name
}
));
break;
case 'Group.OnMute':
store.dispatch(snapcastActions.groupLoaded(
{
id: action.params.id,
mute: action.params.mute
}
));
break;
case 'Server.OnUpdate':
store.dispatch(snapcastActions.serverLoaded(action.params));
break;
}
break;
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
groups_loaded.push(group);
}
action.groups = groups_loaded;
if (clients_loaded.length > 0) {
store.dispatch(snapcastActions.clientsLoaded(clients_loaded, action.flush));
}
next(action);
break;
case 'SNAPCAST_CLIENTS_LOADED':
var clients_index = { ...snapcast.clients };
var clients_loaded = [];
for (const raw_client of action.clients) {
var client = helpers.formatClient(raw_client);
if (clients_index[client.id]) {
client = { ...clients_index[client.id], ...client };
}
clients_loaded.push(client);
}
action.clients = clients_loaded;
next(action);
break;
case 'SNAPCAST_SET_CLIENT_NAME':
var client = snapcast.clients[action.id];
var data = {
method: 'Client.SetName',
params: {
id: action.id,
name: action.name,
},
};
request(
store,
data,
(response) => {
store.dispatch(snapcastActions.clientLoaded(
{
id: action.id,
name: response.name,
},
));
},
);
break;
case 'SNAPCAST_SET_CLIENT_MUTE':
var client = store.getState().snapcast.clients[action.id];
var data = {
method: 'Client.SetVolume',
params: {
id: action.id,
volume: {
muted: action.mute,
percent: client.volume,
},
},
};
request(
store,
data,
(response) => {
store.dispatch(snapcastActions.clientLoaded(
{
id: action.id,
volume: response.volume.percent,
mute: response.volume.muted,
},
));
},
(error) => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message,
));
},
);
break;
case 'SNAPCAST_SET_CLIENT_VOLUME':
var client = snapcast.clients[action.id];
var data = {
method: 'Client.SetVolume',
params: {
id: action.id,
volume: {
muted: client.mute,
percent: action.volume,
},
},
};
request(
store,
data,
(response) => {
store.dispatch(snapcastActions.clientLoaded(
{
id: action.id,
volume: response.volume.percent,
},
));
},
(error) => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message,
));
},
);
break;
case 'SNAPCAST_SET_CLIENT_LATENCY':
var client = store.getState().snapcast.clients[action.id];
var data = {
method: 'Client.SetLatency',
params: {
id: action.id,
latency: action.latency,
},
};
request(
store,
data,
(response) => {
store.dispatch(snapcastActions.clientLoaded(
{
id: action.id,
latency: response.latency,
},
));
},
(error) => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message,
));
},
);
break;
case 'SNAPCAST_SET_CLIENT_GROUP':
var group = snapcast.groups[action.group_id];
var { clients_ids } = group;
var clients_ids_index = clients_ids.indexOf(action.id);
// Not in group (yet), so add it
if (clients_ids_index <= -1) {
clients_ids.push(action.id);
// Already there, so remove it
} else {
clients_ids.splice(clients_ids_index, 1);
}
var data = {
method: 'Group.SetClients',
params: {
id: action.group_id,
clients: clients_ids,
},
};
request(
store,
data,
(response) => {
store.dispatch(snapcastActions.serverLoaded(response.server));
},
(error) => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message,
));
},
);
break;
case 'SNAPCAST_DELETE_CLIENT':
var data = {
method: 'Server.DeleteClient',
params: {
id: action.id,
},
};
request(
store,
data,
(response) => {
store.dispatch({
type: 'SNAPCAST_CLIENT_REMOVED',
key: action.data.params.id,
});
},
(error) => {
store.dispatch(coreActions.handleException(
'Error',
error,
error.message,
));
},
);
break;
case 'SNAPCAST_SET_GROUP_STREAM':
var group = store.getState().snapcast.groups[action.id];
var data = {
method: 'Group.SetStream',
params: {
id: action.id,
stream_id: action.stream_id,
},
};
request(
store,
data,
(response) => {
store.dispatch(snapcastActions.groupLoaded(
{
id: action.id,
stream_id: action.stream_id,
},
));
},
(error) => {
store.dispatch(coreActions.handleException(
'Could not change stream',
error,
error.message,
));
},
);
break;
case 'SNAPCAST_SET_GROUP_MUTE':
var group = store.getState().snapcast.groups[action.id];
var data = {
method: 'Group.SetMute',
params: {
id: action.id,
mute: action.mute,
},
};
request(
store,
data,
(response) => {
store.dispatch(snapcastActions.groupLoaded(
{
id: action.id,
muted: response.mute,
},
));
},
(error) => {
store.dispatch(coreActions.handleException(
'Could not toggle mute',
error,
error.message,
));
},
);
break;
case 'SNAPCAST_SET_GROUP_VOLUME':
var clients_to_update = [];
var group = snapcast.groups[action.id];
var change = action.percent - action.old_percent;
for (const client_id of group.clients_ids) {
// Apply the change proportionately to each client
var client = snapcast.clients[client_id];
const current_volume = client.volume;
const new_volume = current_volume + change;
// Only change if the client is within min/max limits
if ((change > 0 && current_volume < 100) || (change < 0 && current_volume > 0)) {
clients_to_update.push({
id: client.id,
volume: new_volume,
});
}
}
// Loop our required changes, and post each to Snapcast
for (const client_to_update of clients_to_update) {
let volume = client_to_update.volume + ((group.clients_ids.length - clients_to_update.length) * change);
// Make sure we're not creating an impossible percent
if (volume < 0) {
volume = 0;
} else if (volume > 100) {
volume = 100;
}
store.dispatch(snapcastActions.setClientVolume(client_to_update.id, volume));
}
break;
case 'SNAPCAST_EVENT_RECEIVED':
// Drop the prefix
action.method = action.method.replace('snapcast_', '');
switch (action.method) {
case 'Client.OnConnect':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.client.id,
name: action.params.client.name,
volume: action.params.client.volume.percent,
mute: action.params.client.volume.muted,
connected: action.params.client.connected,
},
));
break;
case 'Client.OnDisconnect':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.client.id,
connected: action.params.client.connected,
},
));
break;
case 'Client.OnVolumeChanged':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.id,
mute: action.params.volume.muted,
volume: action.params.volume.percent,
},
));
break;
case 'Client.OnLatencyChanged':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.id,
latency: action.params.latency,
},
));
break;
case 'Client.OnNameChanged':
store.dispatch(snapcastActions.clientLoaded(
{
id: action.params.id,
name: action.params.name,
},
));
break;
case 'Group.OnMute':
store.dispatch(snapcastActions.groupLoaded(
{
id: action.params.id,
mute: action.params.mute,
},
));
break;
case 'Server.OnUpdate':
store.dispatch(snapcastActions.serverLoaded(action.params));
break;
}
break;
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
}
};
}());
})();
export default SnapcastMiddleware
export default SnapcastMiddleware;

80
src/js/services/snapcast/reducer.js
View File

@ -1,51 +1,47 @@
export default function reducer(snapcast = {}, action){
switch (action.type){
export default function reducer(snapcast = {}, action) {
switch (action.type) {
case 'SNAPCAST_SERVER_LOADED':
var server = { ...action.server };
return { ...snapcast, server };
case 'SNAPCAST_SERVER_LOADED':
var server = Object.assign({}, action.server);
return Object.assign({}, snapcast, { server: server });
case 'SNAPCAST_CLIENTS_LOADED':
if (action.flush) {
var clients = {};
} else {
var clients = { ...snapcast.clients };
}
case 'SNAPCAST_CLIENTS_LOADED':
if (action.flush){
var clients = {};
} else {
var clients = Object.assign({}, snapcast.clients);
}
for (const client of action.clients) {
clients[client.id] = client;
}
return { ...snapcast, clients };
for (var client of action.clients){
clients[client.id] = client;
}
return Object.assign({}, snapcast, { clients: clients });
case 'SNAPCAST_GROUPS_LOADED':
if (action.flush) {
var groups = {};
} else {
var groups = { ...snapcast.groups };
}
case 'SNAPCAST_GROUPS_LOADED':
if (action.flush){
var groups = {};
} else {
var groups = Object.assign({}, snapcast.groups);
}
for (const group of action.groups) {
groups[group.id] = group;
}
return { ...snapcast, groups };
for (var group of action.groups){
groups[group.id] = group;
}
return Object.assign({}, snapcast, { groups: groups });
case 'SNAPCAST_STREAMS_LOADED':
if (action.flush) {
var streams = {};
} else {
var streams = { ...snapcast.streams };
}
case 'SNAPCAST_STREAMS_LOADED':
if (action.flush){
var streams = {};
} else {
var streams = Object.assign({}, snapcast.streams);
}
for (const stream of action.streams) {
streams[stream.id] = stream;
}
return { ...snapcast, streams };
for (var stream of action.streams){
streams[stream.id] = stream;
}
return Object.assign({}, snapcast, { streams: streams });
default:
return snapcast
}
default:
return snapcast;
}
}

3444
src/js/services/spotify/actions.js
View File

File diff suppressed because it is too large Load Diff

709
src/js/services/spotify/middleware.js
View File

@ -2,150 +2,147 @@
import ReactGA from 'react-ga';
import { sha256 } from 'js-sha256';
var helpers = require('./../../helpers');
var coreActions = require('../core/actions');
var spotifyActions = require('./actions');
var uiActions = require('../ui/actions');
var pusherActions = require('../pusher/actions');
const helpers = require('./../../helpers');
const coreActions = require('../core/actions');
const spotifyActions = require('./actions');
const uiActions = require('../ui/actions');
const pusherActions = require('../pusher/actions');
const SpotifyMiddleware = (function(){
return store => next => action => {
var spotify = store.getState().spotify;
const SpotifyMiddleware = (function () {
return (store) => (next) => (action) => {
const { spotify } = store.getState();
switch(action.type){
case 'SPOTIFY_AUTHORIZATION_GRANTED':
if (store.getState().ui.allow_reporting){
ReactGA.event({category: 'Spotify', action: 'Authorization granted'});
switch (action.type) {
case 'SPOTIFY_AUTHORIZATION_GRANTED':
if (store.getState().ui.allow_reporting) {
ReactGA.event({ category: 'Spotify', action: 'Authorization granted' });
}
// Flush out the previous user's library
store.dispatch(spotifyActions.flushLibrary());
// Flush out the previous user's library
store.dispatch(spotifyActions.flushLibrary());
next(action);
break;
next(action);
break;
case 'SPOTIFY_AUTHORIZATION_REVOKED':
if (store.getState().ui.allow_reporting){
ReactGA.event({ category: 'Spotify', action: 'Authorization revoked'});
case 'SPOTIFY_AUTHORIZATION_REVOKED':
if (store.getState().ui.allow_reporting) {
ReactGA.event({ category: 'Spotify', action: 'Authorization revoked' });
}
next(action);
next(action);
// Now dispatch a getMe to get the backend-provided user
store.dispatch(spotifyActions.getMe());
// Now dispatch a getMe to get the backend-provided user
store.dispatch(spotifyActions.getMe());
// Flush out the previous user's library
store.dispatch(spotifyActions.flushLibrary());
// Flush out the previous user's library
store.dispatch(spotifyActions.flushLibrary());
break;
break;
case 'SPOTIFY_IMPORT_AUTHORIZATION':
case 'SPOTIFY_IMPORT_AUTHORIZATION':
// Flush out the previous user's library
store.dispatch(spotifyActions.flushLibrary());
// Flush out the previous user's library
store.dispatch(spotifyActions.flushLibrary());
// Wait a few moments before we fetch, allowing the import to complete first
// TODO: Use callbacks for better code accuracy
setTimeout(() => {store.dispatch(spotifyActions.getMe())}, 100);
// Wait a few moments before we fetch, allowing the import to complete first
// TODO: Use callbacks for better code accuracy
setTimeout(() => { store.dispatch(spotifyActions.getMe()); }, 100);
next(action);
break;
next(action);
break;
case 'SPOTIFY_RECOMMENDATIONS_LOADED':
if (store.getState().ui.allow_reporting && action.seeds_uris){
ReactGA.event({ category: 'Spotify', action: 'Recommendations', label: action.seeds_uris.join(',') })
}
next(action)
break;
case 'SPOTIFY_RECOMMENDATIONS_LOADED':
if (store.getState().ui.allow_reporting && action.seeds_uris) {
ReactGA.event({ category: 'Spotify', action: 'Recommendations', label: action.seeds_uris.join(',') });
}
next(action);
break;
case 'SPOTIFY_USER_LOADED':
if (store.getState().ui.allow_reporting && action.data){
case 'SPOTIFY_USER_LOADED':
if (store.getState().ui.allow_reporting && action.data) {
ReactGA.event({ category: 'User', action: 'Load', label: action.data.uri });
}
next(action)
break;
}
next(action);
break;
case 'SPOTIFY_CREATE_PLAYLIST':
store.dispatch(spotifyActions.createPlaylist(action.name, action.description, action.is_private, action.is_collaborative ))
break;
case 'SPOTIFY_CREATE_PLAYLIST':
store.dispatch(spotifyActions.createPlaylist(action.name, action.description, action.is_private, action.is_collaborative));
break;
case 'SPOTIFY_REMOVE_PLAYLIST_TRACKS':
var playlist = Object.assign({}, store.getState().core.playlists[action.key]);
store.dispatch(spotifyActions.deleteTracksFromPlaylist(playlist.uri, playlist.snapshot_id, action.tracks_indexes ))
break;
case 'SPOTIFY_REMOVE_PLAYLIST_TRACKS':
var playlist = { ...store.getState().core.playlists[action.key] };
store.dispatch(spotifyActions.deleteTracksFromPlaylist(playlist.uri, playlist.snapshot_id, action.tracks_indexes));
break;
case 'SPOTIFY_ADD_PLAYLIST_TRACKS':
store.dispatch(spotifyActions.addTracksToPlaylist(action.key, action.tracks_uris ))
break;
case 'SPOTIFY_ADD_PLAYLIST_TRACKS':
store.dispatch(spotifyActions.addTracksToPlaylist(action.key, action.tracks_uris));
break;
case 'SPOTIFY_REORDER_PLAYLIST_TRACKS':
store.dispatch(spotifyActions.reorderPlaylistTracks(action.key, action.range_start, action.range_length, action.insert_before, action.snapshot_id ))
break;
case 'SPOTIFY_REORDER_PLAYLIST_TRACKS':
store.dispatch(spotifyActions.reorderPlaylistTracks(action.key, action.range_start, action.range_length, action.insert_before, action.snapshot_id));
break;
case 'SPOTIFY_SAVE_PLAYLIST':
store.dispatch(spotifyActions.savePlaylist(action.key, action.name, action.description, action.is_public, action.is_collaborative, action.image))
break;
case 'SPOTIFY_SAVE_PLAYLIST':
store.dispatch(spotifyActions.savePlaylist(action.key, action.name, action.description, action.is_public, action.is_collaborative, action.image));
break;
case 'SPOTIFY_NEW_RELEASES_LOADED':
store.dispatch({
type: 'ALBUMS_LOADED',
albums: action.data.albums.items
});
case 'SPOTIFY_NEW_RELEASES_LOADED':
store.dispatch({
type: 'ALBUMS_LOADED',
albums: action.data.albums.items,
});
// Collate result into the three key values we want
action.uris = helpers.arrayOf('uri', action.data.albums.items);
action.more = action.data.albums.next;
action.total = action.data.albums.total;
// Collate result into the three key values we want
action.uris = helpers.arrayOf('uri', action.data.albums.items);
action.more = action.data.albums.next;
action.total = action.data.albums.total;
// And pass on to our reducer
next(action);
break
// And pass on to our reducer
next(action);
break;
case 'SPOTIFY_ARTIST_ALBUMS_LOADED':
store.dispatch(coreActions.albumsLoaded(action.data.items));
store.dispatch({
type: 'ARTIST_ALBUMS_LOADED',
artist_uri: action.artist_uri,
albums_uris: helpers.arrayOf('uri',action.data.items),
more: action.data.next,
total: action.data.total
});
break
case 'SPOTIFY_ARTIST_ALBUMS_LOADED':
store.dispatch(coreActions.albumsLoaded(action.data.items));
store.dispatch({
type: 'ARTIST_ALBUMS_LOADED',
artist_uri: action.artist_uri,
albums_uris: helpers.arrayOf('uri', action.data.items),
more: action.data.next,
total: action.data.total,
});
break;
case 'SPOTIFY_USER_PLAYLISTS_LOADED':
var playlists = []
for(var i = 0; i < action.data.items.length; i++){
var playlist = Object.assign(
{},
action.data.items[i],
{
tracks_total: action.data.items[i].tracks.total
}
)
case 'SPOTIFY_USER_PLAYLISTS_LOADED':
var playlists = [];
for (var i = 0; i < action.data.items.length; i++) {
var playlist = {
// remove our tracklist. It'll overwrite any full records otherwise
delete playlist.tracks
...action.data.items[i],
tracks_total: action.data.items[i].tracks.total,
};
playlists.push(playlist)
}
// remove our tracklist. It'll overwrite any full records otherwise
delete playlist.tracks;
store.dispatch({
type: 'PLAYLISTS_LOADED',
playlists: playlists
});
playlists.push(playlist);
}
store.dispatch({
type: 'USER_PLAYLISTS_LOADED',
key: action.key,
uris: helpers.arrayOf('uri',playlists),
more: action.data.next,
total: action.data.total
});
break
store.dispatch({
type: 'PLAYLISTS_LOADED',
playlists,
});
/*
store.dispatch({
type: 'USER_PLAYLISTS_LOADED',
key: action.key,
uris: helpers.arrayOf('uri', playlists),
more: action.data.next,
total: action.data.total,
});
break;
/*
case 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED':
var playlists = []
@ -179,305 +176,299 @@ const SpotifyMiddleware = (function(){
break
*/
case 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED':
store.dispatch(coreActions.playlistsLoaded(action.playlists.items));
action.uris = helpers.arrayOf('uri', action.playlists.items);
action.more = action.playlists.next;
action.total = action.playlists.total;
delete action.playlists;
case 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED':
store.dispatch(coreActions.playlistsLoaded(action.playlists.items));
// Upgrade our URIs
action.uris = helpers.upgradeSpotifyPlaylistUris(action.uris);
action.uris = helpers.arrayOf('uri', action.playlists.items);
action.more = action.playlists.next;
action.total = action.playlists.total;
delete action.playlists;
next(action);
break;
// Upgrade our URIs
action.uris = helpers.upgradeSpotifyPlaylistUris(action.uris);
case 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED_MORE':
store.dispatch({
type: 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED',
uri: action.uri,
playlists: action.data.playlists
});
break;
next(action);
break;
case 'SPOTIFY_CATEGORY_LOADED':
store.dispatch({
type: 'SPOTIFY_CATEGORIES_LOADED',
categories: [action.category]
});
break;
case 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED_MORE':
store.dispatch({
type: 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED',
uri: action.uri,
playlists: action.data.playlists,
});
break;
case 'SPOTIFY_CATEGORIES_LOADED':
var categories_index = Object.assign({}, spotify.categories);
var categories_loaded = [];
case 'SPOTIFY_CATEGORY_LOADED':
store.dispatch({
type: 'SPOTIFY_CATEGORIES_LOADED',
categories: [action.category],
});
break;
for (var raw_category of action.categories){
var category = Object.assign({}, raw_category);
case 'SPOTIFY_CATEGORIES_LOADED':
var categories_index = { ...spotify.categories };
var categories_loaded = [];
if (!category.uri){
category.uri = "category:"+category.id;
}
for (const raw_category of action.categories) {
let category = { ...raw_category };
if (categories_index[category.uri] !== undefined){
category = Object.assign({}, categories_index[category.uri], category);
}
if (!category.uri) {
category.uri = `category:${category.id}`;
}
if (category.icons){
category.icons = helpers.formatImages(category.icons);
}
if (categories_index[category.uri] !== undefined) {
category = { ...categories_index[category.uri], ...category };
}
categories_loaded.push(category);
}
if (category.icons) {
category.icons = helpers.formatImages(category.icons);
}
action.categories = categories_loaded;
next(action);
break;
categories_loaded.push(category);
}
case 'SPOTIFY_GET_LIBRARY_PLAYLISTS_PROCESSOR':
store.dispatch(spotifyActions.getLibraryPlaylistsProcessor(action.data))
break
action.categories = categories_loaded;
next(action);
break;
case 'SPOTIFY_LIBRARY_PLAYLISTS_LOADED':
var playlists = []
for (var playlist of action.playlists){
Object.assign(
playlist,
{
uri: playlist.uri.replace(/spotify:user:([^:]*?):/i, "spotify:"),
can_edit: (store.getState().spotify.me && store.getState().spotify.me.id == playlist.owner.id),
source: 'spotify',
in_library: true, // assumed because we asked for library items
tracks_total: playlist.tracks.total
}
);
case 'SPOTIFY_GET_LIBRARY_PLAYLISTS_PROCESSOR':
store.dispatch(spotifyActions.getLibraryPlaylistsProcessor(action.data));
break;
// remove our tracklist. It'll overwrite any full records otherwise
delete playlist.tracks
case 'SPOTIFY_LIBRARY_PLAYLISTS_LOADED':
var playlists = [];
for (var playlist of action.playlists) {
Object.assign(
playlist,
{
uri: playlist.uri.replace(/spotify:user:([^:]*?):/i, 'spotify:'),
can_edit: (store.getState().spotify.me && store.getState().spotify.me.id == playlist.owner.id),
source: 'spotify',
in_library: true, // assumed because we asked for library items
tracks_total: playlist.tracks.total,
},
);
playlists.push(playlist)
}
// remove our tracklist. It'll overwrite any full records otherwise
delete playlist.tracks;
store.dispatch({
type: 'PLAYLISTS_LOADED',
playlists: playlists
});
playlists.push(playlist);
}
// Append our action with the uris. This gets handed down to subsequent middleware and our reducer.
action.uris = helpers.arrayOf('uri',playlists)
next(action)
break
store.dispatch({
type: 'PLAYLISTS_LOADED',
playlists,
});
case 'SPOTIFY_GET_LIBRARY_ARTISTS_PROCESSOR':
store.dispatch(spotifyActions.getLibraryArtistsProcessor(action.data))
break
// Append our action with the uris. This gets handed down to subsequent middleware and our reducer.
action.uris = helpers.arrayOf('uri', playlists);
next(action);
break;
case 'SPOTIFY_LIBRARY_ARTISTS_LOADED':
var artists = []
for (var i = 0; i < action.artists.length; i++){
artists.push(
Object.assign(
{},
action.artists[i],
{
source: 'spotify',
in_library: true // assumed because we asked for library items
}
)
)
}
store.dispatch({
type: 'ARTISTS_LOADED',
artists: artists
});
case 'SPOTIFY_GET_LIBRARY_ARTISTS_PROCESSOR':
store.dispatch(spotifyActions.getLibraryArtistsProcessor(action.data));
break;
// Append our action with the uris. This gets handed down to subsequent middleware and our reducer.
action.uris = helpers.arrayOf('uri',artists)
next(action)
break
case 'SPOTIFY_LIBRARY_ARTISTS_LOADED':
var artists = [];
for (var i = 0; i < action.artists.length; i++) {
artists.push(
{
case 'SPOTIFY_GET_LIBRARY_ALBUMS_PROCESSOR':
store.dispatch(spotifyActions.getLibraryAlbumsProcessor(action.data))
break
...action.artists[i],
source: 'spotify',
in_library: true, // assumed because we asked for library items
case 'SPOTIFY_GET_LIBRARY_TRACKS_AND_PLAY_PROCESSOR':
store.dispatch(spotifyActions.getLibraryTracksAndPlayProcessor(action.data))
break
},
);
}
store.dispatch({
type: 'ARTISTS_LOADED',
artists,
});
case 'SPOTIFY_GET_ALL_PLAYLIST_TRACKS_PROCESSOR':
store.dispatch(spotifyActions.getAllPlaylistTracksProcessor(action.data))
break
// Append our action with the uris. This gets handed down to subsequent middleware and our reducer.
action.uris = helpers.arrayOf('uri', artists);
next(action);
break;
case 'SPOTIFY_LIBRARY_ALBUMS_LOADED':
var albums = []
for (var i = 0; i < action.albums.length; i++){
albums.push(
Object.assign(
{},
action.albums[i].album,
{
in_library: true, // assumed because we asked for library items
source: 'spotify',
added_at: action.albums[i].added_at,
tracks: action.albums[i].album.tracks.items,
tracks_more: action.albums[i].album.tracks.next,
tracks_total: action.albums[i].album.tracks.total
}
)
)
}
case 'SPOTIFY_GET_LIBRARY_ALBUMS_PROCESSOR':
store.dispatch(spotifyActions.getLibraryAlbumsProcessor(action.data));
break;
store.dispatch({
type: 'ALBUMS_LOADED',
albums: albums
});
case 'SPOTIFY_GET_LIBRARY_TRACKS_AND_PLAY_PROCESSOR':
store.dispatch(spotifyActions.getLibraryTracksAndPlayProcessor(action.data));
break;
// Append our action with the uris. This gets handed down to subsequent middleware and our reducer.
action.uris = helpers.arrayOf('uri',albums)
next(action)
break
case 'SPOTIFY_GET_ALL_PLAYLIST_TRACKS_PROCESSOR':
store.dispatch(spotifyActions.getAllPlaylistTracksProcessor(action.data));
break;
case 'SPOTIFY_FAVORITES_LOADED':
if (action.artists.length > 0){
store.dispatch({
type: 'ARTISTS_LOADED',
artists: action.artists
})
action.artists_uris = helpers.arrayOf('uri',action.artists)
}
if (action.tracks.length > 0){
store.dispatch({
type: 'TRACKS_LOADED',
tracks: action.tracks
})
action.tracks_uris = helpers.arrayOf('uri',action.tracks)
}
next(action)
break
case 'SPOTIFY_LIBRARY_ALBUMS_LOADED':
var albums = [];
for (var i = 0; i < action.albums.length; i++) {
albums.push(
{
case 'SPOTIFY_LIBRARY_TRACKS_LOADED':
case 'SPOTIFY_LIBRARY_TRACKS_LOADED_MORE':
if (action.data){
store.dispatch({
type: 'TRACKS_LOADED',
tracks: action.data.items
});
}
next(action);
break;
...action.albums[i].album,
in_library: true, // assumed because we asked for library items
source: 'spotify',
added_at: action.albums[i].added_at,
tracks: action.albums[i].album.tracks.items,
tracks_more: action.albums[i].album.tracks.next,
tracks_total: action.albums[i].album.tracks.total,
},
);
}
case 'SPOTIFY_TRACK_LOADED':
store.dispatch({
type: 'TRACKS_LOADED',
tracks: [action.data]
});
next(action);
break
store.dispatch({
type: 'ALBUMS_LOADED',
albums,
});
// Append our action with the uris. This gets handed down to subsequent middleware and our reducer.
action.uris = helpers.arrayOf('uri', albums);
next(action);
break;
case 'SPOTIFY_FAVORITES_LOADED':
if (action.artists.length > 0) {
store.dispatch({
type: 'ARTISTS_LOADED',
artists: action.artists,
});
action.artists_uris = helpers.arrayOf('uri', action.artists);
}
if (action.tracks.length > 0) {
store.dispatch({
type: 'TRACKS_LOADED',
tracks: action.tracks,
});
action.tracks_uris = helpers.arrayOf('uri', action.tracks);
}
next(action);
break;
case 'SPOTIFY_LIBRARY_TRACKS_LOADED':
case 'SPOTIFY_LIBRARY_TRACKS_LOADED_MORE':
if (action.data) {
store.dispatch({
type: 'TRACKS_LOADED',
tracks: action.data.items,
});
}
next(action);
break;
case 'SPOTIFY_TRACK_LOADED':
store.dispatch({
type: 'TRACKS_LOADED',
tracks: [action.data],
});
next(action);
break;
/**
/**
* Searching
* More results are lazy-loaded on demand, based on the _more URL
**/
* */
case 'SEARCH_STARTED':
store.dispatch({
type: 'SPOTIFY_CLEAR_SEARCH_RESULTS'
});
next(action);
break
case 'SEARCH_STARTED':
store.dispatch({
type: 'SPOTIFY_CLEAR_SEARCH_RESULTS',
});
next(action);
break;
case 'SPOTIFY_SEARCH_RESULTS_LOADED_MORE_TRACKS':
store.dispatch({
type: 'SPOTIFY_SEARCH_RESULTS_LOADED',
context: 'tracks',
results: helpers.formatTracks(action.data.tracks.items),
more: action.data.tracks.next
});
break
case 'SPOTIFY_SEARCH_RESULTS_LOADED_MORE_TRACKS':
store.dispatch({
type: 'SPOTIFY_SEARCH_RESULTS_LOADED',
context: 'tracks',
results: helpers.formatTracks(action.data.tracks.items),
more: action.data.tracks.next,
});
break;
case 'SPOTIFY_SEARCH_RESULTS_LOADED_MORE_ARTISTS':
store.dispatch({
type: 'ARTISTS_LOADED',
artists: action.data.artists.items
});
case 'SPOTIFY_SEARCH_RESULTS_LOADED_MORE_ARTISTS':
store.dispatch({
type: 'SPOTIFY_SEARCH_RESULTS_LOADED',
context: 'artists',
results: helpers.arrayOf('uri',action.data.playlists.items),
more: action.data.playlists.next
});
break
store.dispatch({
type: 'ARTISTS_LOADED',
artists: action.data.artists.items,
});
case 'SPOTIFY_SEARCH_RESULTS_LOADED_MORE_ALBUMS':
store.dispatch({
type: 'SPOTIFY_SEARCH_RESULTS_LOADED',
context: 'artists',
results: helpers.arrayOf('uri', action.data.playlists.items),
more: action.data.playlists.next,
});
break;
store.dispatch({
type: 'ALBUMS_LOADED',
albums: action.data.albums.items
});
case 'SPOTIFY_SEARCH_RESULTS_LOADED_MORE_ALBUMS':
store.dispatch({
type: 'SPOTIFY_SEARCH_RESULTS_LOADED',
context: 'playlists',
results: helpers.arrayOf('uri',action.data.albums.items),
more: action.data.albums.next
});
break
store.dispatch({
type: 'ALBUMS_LOADED',
albums: action.data.albums.items,
});
case 'SPOTIFY_SEARCH_RESULTS_LOADED_MORE_PLAYLISTS':
store.dispatch({
type: 'SPOTIFY_SEARCH_RESULTS_LOADED',
context: 'playlists',
results: helpers.arrayOf('uri', action.data.albums.items),
more: action.data.albums.next,
});
break;
var playlists = []
for (var i = 0; i < action.data.playlists.items.length; i++){
playlists.push(Object.assign(
{},
action.data.playlists.items[i],
{
tracks_total: action.data.playlists.items[i].tracks.total
}
))
}
case 'SPOTIFY_SEARCH_RESULTS_LOADED_MORE_PLAYLISTS':
store.dispatch({
type: 'PLAYLISTS_LOADED',
playlists: playlists
});
var playlists = [];
for (var i = 0; i < action.data.playlists.items.length; i++) {
playlists.push({
store.dispatch({
type: 'SPOTIFY_SEARCH_RESULTS_LOADED',
context: 'playlists',
results: helpers.arrayOf('uri',action.data.playlists.items),
more: action.data.playlists.next
});
break
...action.data.playlists.items[i],
tracks_total: action.data.playlists.items[i].tracks.total,
});
}
store.dispatch({
type: 'PLAYLISTS_LOADED',
playlists,
});
store.dispatch({
type: 'SPOTIFY_SEARCH_RESULTS_LOADED',
context: 'playlists',
results: helpers.arrayOf('uri', action.data.playlists.items),
more: action.data.playlists.next,
});
break;
case 'SPOTIFY_ME_LOADED':
var me = Object.assign({}, helpers.formatUser(action.me));
case 'SPOTIFY_ME_LOADED':
var me = { ...helpers.formatUser(action.me) };
// We are Anonymous currently so use 'me' name as my Pusher username
if (store.getState().pusher.username == 'Anonymous'){
store.dispatch(pusherActions.setUsername(me.name));
}
// We are Anonymous currently so use 'me' name as my Pusher username
if (store.getState().pusher.username == 'Anonymous') {
store.dispatch(pusherActions.setUsername(me.name));
}
if (store.getState().ui.allow_reporting){
var hashed_username = sha256(me.id);
ReactGA.set({userId: hashed_username});
ReactGA.event({category: 'Spotify', action: 'Authorization verified', label: hashed_username});
if (store.getState().ui.allow_reporting) {
const hashed_username = sha256(me.id);
ReactGA.set({ userId: hashed_username });
ReactGA.event({ category: 'Spotify', action: 'Authorization verified', label: hashed_username });
}
store.dispatch(coreActions.userLoaded(me));
action.me = me;
next(action);
break;
store.dispatch(coreActions.userLoaded(me));
action.me = me;
next(action);
break;
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
}
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
}
};
}());
})();
export default SpotifyMiddleware
export default SpotifyMiddleware;

585
src/js/services/spotify/reducer.js
View File

@ -1,358 +1,347 @@
import * as helpers from '../../helpers'
import * as helpers from '../../helpers';
export default function reducer(spotify = {}, action){
switch (action.type){
export default function reducer(spotify = {}, action) {
switch (action.type) {
case 'SPOTIFY_SET':
return { ...spotify, ...action.data };
case 'SPOTIFY_SET':
return Object.assign({},spotify,action.data)
case 'PUSHER_SPOTIFY_TOKEN':
if (spotify.authorization) return spotify;
return {
...spotify,
authorizing: false,
authorization: false,
access_token: action.data.access_token,
token_expiry: action.data.token_expiry,
};
case 'PUSHER_SPOTIFY_TOKEN':
if (spotify.authorization) return spotify;
return Object.assign({}, spotify, {
authorizing: false,
authorization: false,
access_token: action.data.access_token,
token_expiry: action.data.token_expiry
})
case 'SPOTIFY_AUTHORIZATION_GRANTED':
return {
...spotify,
enabled: true,
authorizing: false,
authorization: action.data,
access_token: action.data.access_token,
refresh_token: action.data.refresh_token,
token_expiry: action.data.token_expiry,
};
case 'SPOTIFY_AUTHORIZATION_GRANTED':
return Object.assign({}, spotify, {
enabled: true,
authorizing: false,
authorization: action.data,
access_token: action.data.access_token,
refresh_token: action.data.refresh_token,
token_expiry: action.data.token_expiry
})
case 'SPOTIFY_AUTHORIZATION_REVOKED':
return {
...spotify,
authorizing: false,
authorization: false,
access_token: false,
refresh_token: false,
token_expiry: 0,
me: false,
};
case 'SPOTIFY_AUTHORIZATION_REVOKED':
return Object.assign({}, spotify, {
authorizing: false,
authorization: false,
access_token: false,
refresh_token: false,
token_expiry: 0,
me: false
})
case 'SPOTIFY_IMPORT_AUTHORIZATION':
return {
...spotify,
authorizing: false,
authorization: action.authorization,
access_token: action.authorization.access_token,
refresh_token: action.authorization.refresh_token,
token_expiry: action.authorization.token_expiry,
me: action.me,
};
case 'SPOTIFY_IMPORT_AUTHORIZATION':
return Object.assign({}, spotify, {
authorizing: false,
authorization: action.authorization,
access_token: action.authorization.access_token,
refresh_token: action.authorization.refresh_token,
token_expiry: action.authorization.token_expiry,
me: action.me
});
case 'SPOTIFY_TOKEN_REFRESHING':
return { ...spotify, refreshing_token: true };
case 'SPOTIFY_TOKEN_REFRESHING':
return Object.assign({}, spotify, { refreshing_token: true })
case 'SPOTIFY_TOKEN_REFRESHED':
return {
...spotify,
refreshing_token: false,
access_token: action.data.access_token,
token_expiry: action.data.token_expiry,
};
case 'SPOTIFY_TOKEN_REFRESHED':
return Object.assign({}, spotify, {
refreshing_token: false,
access_token: action.data.access_token,
token_expiry: action.data.token_expiry
});
case 'SPOTIFY_TOKEN_CHANGED':
return {
...spotify,
access_token: action.spotify_token.access_token,
token_expiry: action.spotify_token.token_expiry,
};
case 'SPOTIFY_TOKEN_CHANGED':
return Object.assign({}, spotify, {
access_token: action.spotify_token.access_token,
token_expiry: action.spotify_token.token_expiry
});
case 'SPOTIFY_ME_LOADED':
return { ...spotify, me: action.me };
case 'SPOTIFY_ME_LOADED':
return Object.assign({}, spotify, { me: action.me })
case 'SPOTIFY_FEATURED_PLAYLISTS_LOADED':
return Object.assign({}, spotify, { featured_playlists: action.data })
case 'SPOTIFY_FEATURED_PLAYLISTS_LOADED':
return { ...spotify, featured_playlists: action.data };
case 'SPOTIFY_NEW_RELEASES_LOADED':
var new_releases = [];
if (spotify.new_releases){
case 'SPOTIFY_NEW_RELEASES_LOADED':
var new_releases = [];
if (spotify.new_releases) {
new_releases = Object.assign([], spotify.new_releases);
}
return Object.assign({}, spotify, {
new_releases: helpers.removeDuplicates([...new_releases, ...action.uris]),
new_releases_more: action.more,
new_releases_total: action.total
});
}
return {
...spotify,
new_releases: helpers.removeDuplicates([...new_releases, ...action.uris]),
new_releases_more: action.more,
new_releases_total: action.total,
};
case 'SPOTIFY_DISCOVER_LOADED':
if (!action.data ){
return Object.assign(
{},
spotify,
{
discover: []
}
);
}
return Object.assign(
{},
spotify,
{
discover: [...spotify.discover, ...[action.data]]
}
);
case 'SPOTIFY_DISCOVER_LOADED':
if (!action.data) {
return {
case 'CLEAR_SPOTIFY_RECOMMENDATIONS':
return Object.assign({}, spotify, {recommendations: {artists_uris: [], albums_uris: [], tracks_uris: []}});
...spotify,
discover: [],
};
}
return {
case 'SPOTIFY_RECOMMENDATIONS_LOADED':
return Object.assign(
{},
spotify,
{
recommendations: {
artists_uris: action.artists_uris,
albums_uris: action.albums_uris,
tracks_uris: action.tracks_uris
}
});
...spotify,
discover: [...spotify.discover, ...[action.data]],
};
case 'SPOTIFY_FAVORITES_LOADED':
return Object.assign(
{},
spotify,
{
favorite_artists: action.artists_uris,
favorite_tracks: action.tracks_uris
})
case 'CLEAR_SPOTIFY_RECOMMENDATIONS':
return { ...spotify, recommendations: { artists_uris: [], albums_uris: [], tracks_uris: [] } };
case 'SPOTIFY_AUTOCOMPLETE_LOADING':
var autocomplete_results = spotify.autocomplete_results
autocomplete_results[action.field_id] = {loading: true}
return Object.assign(
{},
spotify,
{
autocomplete_results: autocomplete_results
})
case 'SPOTIFY_RECOMMENDATIONS_LOADED':
return {
case 'SPOTIFY_AUTOCOMPLETE_LOADED':
var autocomplete_results = spotify.autocomplete_results
autocomplete_results[action.field_id] = action.results
autocomplete_results[action.field_id].loading = false
return Object.assign(
{},
spotify,
{
autocomplete_results: autocomplete_results
})
...spotify,
recommendations: {
artists_uris: action.artists_uris,
albums_uris: action.albums_uris,
tracks_uris: action.tracks_uris,
},
};
case 'SPOTIFY_AUTOCOMPLETE_CLEAR':
var autocomplete_results = spotify.autocomplete_results
if (typeof(autocomplete_results[action.field_id]) !== 'undefined'){
delete autocomplete_results[action.field_id]
}
return Object.assign(
{},
spotify,
{
autocomplete_results: autocomplete_results
})
case 'SPOTIFY_FAVORITES_LOADED':
return {
case 'SPOTIFY_GENRES_LOADED':
return Object.assign(
{},
spotify,
{
genres: action.genres
})
...spotify,
favorite_artists: action.artists_uris,
favorite_tracks: action.tracks_uris,
};
case 'SPOTIFY_AUTOCOMPLETE_LOADING':
var { autocomplete_results } = spotify;
autocomplete_results[action.field_id] = { loading: true };
return {
...spotify,
autocomplete_results,
};
case 'SPOTIFY_AUTOCOMPLETE_LOADED':
var { autocomplete_results } = spotify;
autocomplete_results[action.field_id] = action.results;
autocomplete_results[action.field_id].loading = false;
return {
...spotify,
autocomplete_results,
};
case 'SPOTIFY_AUTOCOMPLETE_CLEAR':
var { autocomplete_results } = spotify;
if (typeof (autocomplete_results[action.field_id]) !== 'undefined') {
delete autocomplete_results[action.field_id];
}
return {
...spotify,
autocomplete_results,
};
case 'SPOTIFY_GENRES_LOADED':
return {
...spotify,
genres: action.genres,
};
/**
/**
* Categories
**/
* */
case 'SPOTIFY_CATEGORIES_LOADED':
var categories = Object.assign({}, spotify.categories);
for (var category of action.categories){
categories[category.uri] = category
}
return Object.assign({}, spotify, { categories: categories });
case 'SPOTIFY_CATEGORIES_LOADED':
var categories = { ...spotify.categories };
for (var category of action.categories) {
categories[category.uri] = category;
}
return { ...spotify, categories };
case 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED':
var categories = Object.assign({}, spotify.categories)
var playlists_uris = [];
case 'SPOTIFY_CATEGORY_PLAYLISTS_LOADED':
var categories = { ...spotify.categories };
var playlists_uris = [];
if (categories[action.uri].playlists_uris){
playlists_uris = categories[action.uri].playlists_uris;
}
if (categories[action.uri].playlists_uris) {
playlists_uris = categories[action.uri].playlists_uris;
}
var category = Object.assign(
{},
categories[action.uri],
{
playlists_uris: [...playlists_uris, ...action.uris],
playlists_more: action.more,
playlists_total: action.total
}
)
categories[action.uri] = category
return Object.assign({}, spotify, { categories: categories });
var category = {
...categories[action.uri],
playlists_uris: [...playlists_uris, ...action.uris],
playlists_more: action.more,
playlists_total: action.total,
};
categories[action.uri] = category;
return { ...spotify, categories };
/**
/**
* Library
**/
* */
case 'SPOTIFY_FLUSH_LIBRARY':
return Object.assign(
{},
spotify,
{
library_playlists: null,
library_playlists_loaded_all: null,
library_playlists_status: null,
library_albums: null,
library_albums_status: null,
library_albums_loaded_all: null,
library_artists: null,
library_artists_status: null,
library_artists_loaded_all: null,
library_tracks: null,
library_tracks_status: null,
library_tracks_loaded_all: null
}
)
case 'SPOTIFY_FLUSH_LIBRARY':
return {
case 'SPOTIFY_LIBRARY_PLAYLISTS_LOADED':
if (spotify.library_playlists){
var uris = [...spotify.library_playlists,...action.uris]
} else {
var uris = action.uris
}
return Object.assign({}, spotify, { library_playlists: helpers.removeDuplicates(uris) })
...spotify,
library_playlists: null,
library_playlists_loaded_all: null,
library_playlists_status: null,
library_albums: null,
library_albums_status: null,
library_albums_loaded_all: null,
library_artists: null,
library_artists_status: null,
library_artists_loaded_all: null,
library_tracks: null,
library_tracks_status: null,
library_tracks_loaded_all: null,
};
case 'SPOTIFY_LIBRARY_ARTISTS_LOADED':
if (spotify.library_artists){
var uris = [...spotify.library_artists,...action.uris]
} else {
var uris = action.uris
}
return Object.assign({}, spotify, { library_artists: helpers.removeDuplicates(uris) })
case 'SPOTIFY_LIBRARY_PLAYLISTS_LOADED':
if (spotify.library_playlists) {
var uris = [...spotify.library_playlists, ...action.uris];
} else {
var { uris } = action;
}
return { ...spotify, library_playlists: helpers.removeDuplicates(uris) };
case 'SPOTIFY_LIBRARY_ALBUMS_LOADED':
if (spotify.library_albums){
var uris = [...spotify.library_albums,...action.uris]
} else {
var uris = action.uris
}
return Object.assign({}, spotify, { library_albums: helpers.removeDuplicates(uris) })
case 'SPOTIFY_LIBRARY_ARTISTS_LOADED':
if (spotify.library_artists) {
var uris = [...spotify.library_artists, ...action.uris];
} else {
var { uris } = action;
}
return { ...spotify, library_artists: helpers.removeDuplicates(uris) };
case 'SPOTIFY_LIBRARY_TRACKS_LOADED':
case 'SPOTIFY_LIBRARY_TRACKS_LOADED_MORE':
var tracks = action.data.items;
var uris = [];
case 'SPOTIFY_LIBRARY_ALBUMS_LOADED':
if (spotify.library_albums) {
var uris = [...spotify.library_albums, ...action.uris];
} else {
var { uris } = action;
}
return { ...spotify, library_albums: helpers.removeDuplicates(uris) };
if (tracks){
tracks = helpers.formatTracks(tracks);
uris = helpers.arrayOf('uri', tracks);
if (spotify.library_tracks){
uris = [...spotify.library_tracks, ...uris]
}
}
case 'SPOTIFY_LIBRARY_TRACKS_LOADED':
case 'SPOTIFY_LIBRARY_TRACKS_LOADED_MORE':
var tracks = action.data.items;
var uris = [];
return Object.assign({}, spotify, {
library_tracks: helpers.removeDuplicates(uris),
library_tracks_more: action.data.next
})
if (tracks) {
tracks = helpers.formatTracks(tracks);
uris = helpers.arrayOf('uri', tracks);
if (spotify.library_tracks) {
uris = [...spotify.library_tracks, ...uris];
}
}
return {
...spotify,
library_tracks: helpers.removeDuplicates(uris),
library_tracks_more: action.data.next,
};
case 'SPOTIFY_LIBRARY_PLAYLISTS_LOADED_ALL':
return Object.assign({}, spotify, { library_playlists_loaded_all: true })
case 'SPOTIFY_LIBRARY_PLAYLISTS_LOADED_ALL':
return { ...spotify, library_playlists_loaded_all: true };
case 'SPOTIFY_LIBRARY_PLAYLISTS_CLEAR':
return Object.assign({}, spotify, { library_playlists: [] })
case 'SPOTIFY_LIBRARY_PLAYLISTS_CLEAR':
return { ...spotify, library_playlists: [] };
case 'SPOTIFY_LIBRARY_ARTISTS_CLEAR':
return Object.assign({}, spotify, { library_artists: [] })
case 'SPOTIFY_LIBRARY_ARTISTS_CLEAR':
return { ...spotify, library_artists: [] };
case 'SPOTIFY_LIBRARY_ALBUMS_CLEAR':
return Object.assign({}, spotify, { library_albums: [] })
case 'SPOTIFY_LIBRARY_ALBUMS_CLEAR':
return { ...spotify, library_albums: [] };
case 'SPOTIFY_LIBRARY_ALBUM_CHECK':
var items = Object.assign([], spotify.library_albums)
var index = items.indexOf(action.key)
if (index > -1 && !action.in_library){
items.splice(index, 1)
} else if (index < 0 && action.in_library){
items.push(action.key)
}
return Object.assign({}, spotify, { library_albums: items });
case 'SPOTIFY_LIBRARY_ALBUM_CHECK':
var items = Object.assign([], spotify.library_albums);
var index = items.indexOf(action.key);
if (index > -1 && !action.in_library) {
items.splice(index, 1);
} else if (index < 0 && action.in_library) {
items.push(action.key);
}
return { ...spotify, library_albums: items };
case 'SPOTIFY_LIBRARY_ARTIST_CHECK':
var items = Object.assign([], spotify.library_artists)
var index = items.indexOf(action.key)
if (index > -1 && !action.in_library){
items.splice(index, 1)
} else if (index < 0 && action.in_library){
items.push(action.key)
}
return Object.assign({}, spotify, { library_artists: items });
case 'SPOTIFY_LIBRARY_ARTIST_CHECK':
var items = Object.assign([], spotify.library_artists);
var index = items.indexOf(action.key);
if (index > -1 && !action.in_library) {
items.splice(index, 1);
} else if (index < 0 && action.in_library) {
items.push(action.key);
}
return { ...spotify, library_artists: items };
case 'SPOTIFY_LIBRARY_PLAYLIST_CHECK':
var items = Object.assign([], spotify.library_playlists)
var index = items.indexOf(action.key)
if (index > -1 && !action.in_library){
items.splice(index, 1)
} else if (index < 0 && action.in_library){
items.push(action.key)
}
return Object.assign({}, spotify, { library_playlists: items });
case 'SPOTIFY_LIBRARY_PLAYLIST_CHECK':
var items = Object.assign([], spotify.library_playlists);
var index = items.indexOf(action.key);
if (index > -1 && !action.in_library) {
items.splice(index, 1);
} else if (index < 0 && action.in_library) {
items.push(action.key);
}
return { ...spotify, library_playlists: items };
case 'SPOTIFY_LIBRARY_TRACK_CHECK':
var items = Object.assign([], spotify.library_tracks)
var index = items.indexOf(action.key)
if (index > -1 && !action.in_library) {
items.splice(index, 1)
} else if (index < 0 && action.in_library){
items.push(action.key)
}
return Object.assign({}, spotify, { library_tracks: items });
case 'SPOTIFY_LIBRARY_TRACK_CHECK':
var items = Object.assign([], spotify.library_tracks);
var index = items.indexOf(action.key);
if (index > -1 && !action.in_library) {
items.splice(index, 1);
} else if (index < 0 && action.in_library) {
items.push(action.key);
}
return { ...spotify, library_tracks: items };
/**
/**
* Searching
**/
* */
case 'SPOTIFY_CLEAR_SEARCH_RESULTS':
return Object.assign({}, spotify, { search_results: {} });
case 'SPOTIFY_CLEAR_SEARCH_RESULTS':
return { ...spotify, search_results: {} };
case 'SPOTIFY_SEARCH_RESULTS_LOADED':
case 'SPOTIFY_SEARCH_RESULTS_LOADED':
// Fetch or create our container
if (spotify.search_results){
var search_results = Object.assign({}, spotify.search_results)
} else {
var search_results = {}
}
// Fetch or create our container
if (spotify.search_results) {
var search_results = { ...spotify.search_results };
} else {
var search_results = {};
}
search_results.query = action.query;
search_results.query = action.query;
if (search_results.results){
search_results[action.context] = [...search_results[action.context], ...action.results]
} else {
search_results[action.context] = action.results
}
if (search_results.results) {
search_results[action.context] = [...search_results[action.context], ...action.results];
} else {
search_results[action.context] = action.results;
}
if (action.more){
search_results[action.context+'_more'] = action.more
} else {
search_results[action.context+'_more'] = null
}
return Object.assign({}, spotify, { search_results: search_results });
if (action.more) {
search_results[`${action.context}_more`] = action.more;
} else {
search_results[`${action.context}_more`] = null;
}
return { ...spotify, search_results };
default:
return spotify
}
default:
return spotify;
}
}

410
src/js/services/ui/actions.js
View File

@ -1,12 +1,12 @@
import * as helpers from '../../helpers'
import * as helpers from '../../helpers';
export function setWindowTitle(title = null, play_state = null){
return {
type: 'SET_WINDOW_TITLE',
title: title,
play_state: play_state
}
export function setWindowTitle(title = null, play_state = null) {
return {
type: 'SET_WINDOW_TITLE',
title,
play_state,
};
}
/**
@ -14,282 +14,276 @@ export function setWindowTitle(title = null, play_state = null){
* we're pending transition to a new/next track
*
* @param transitioning Boolean
**/
export function setCurrentTrackTransition(current_track_transition){
return {
type: 'SET_CURRENT_TRACK_TRANSITION',
current_track_transition: current_track_transition
}
* */
export function setCurrentTrackTransition(current_track_transition) {
return {
type: 'SET_CURRENT_TRACK_TRANSITION',
current_track_transition,
};
}
export function setSelectedTracks(keys = []){
if (typeof(keys) === 'string'){
keys = [keys]
}
return {
type: 'SET_SELECTED_TRACKS',
keys: keys
}
export function setSelectedTracks(keys = []) {
if (typeof (keys) === 'string') {
keys = [keys];
}
return {
type: 'SET_SELECTED_TRACKS',
keys,
};
}
export function showContextMenu(data){
// Touchend
if (data.e.changedTouches){
data.position_x = data.e.changedTouches[0].clientX;
data.position_y = data.e.changedTouches[0].clientY;
export function showContextMenu(data) {
// Touchend
if (data.e.changedTouches) {
data.position_x = data.e.changedTouches[0].clientX;
data.position_y = data.e.changedTouches[0].clientY;
// Touchstart
} else if (data.e.touches){
data.position_x = data.e.touches[0].clientX;
data.position_y = data.e.touches[0].clientY;
} else if (data.e.touches) {
data.position_x = data.e.touches[0].clientX;
data.position_y = data.e.touches[0].clientY;
// Click/mousedown/mouseup/etc
} else {
data.position_x = data.e.clientX;
data.position_y = data.e.clientY;
}
} else {
data.position_x = data.e.clientX;
data.position_y = data.e.clientY;
}
return {
type: 'SHOW_CONTEXT_MENU',
data: data
}
return {
type: 'SHOW_CONTEXT_MENU',
data,
};
}
export function setSlimMode(slim_mode){
return {
type: 'SET_SLIM_MODE',
slim_mode: slim_mode
}
export function setSlimMode(slim_mode) {
return {
type: 'SET_SLIM_MODE',
slim_mode,
};
}
export function setWindowFocus(window_focus){
return {
type: 'SET_WINDOW_FOCUS',
window_focus: window_focus
}
export function setWindowFocus(window_focus) {
return {
type: 'SET_WINDOW_FOCUS',
window_focus,
};
}
export function hideContextMenu(){
return {
type: 'HIDE_CONTEXT_MENU'
}
export function hideContextMenu() {
return {
type: 'HIDE_CONTEXT_MENU',
};
}
export function removeContextMenu(){
return {
type: 'REMOVE_CONTEXT_MENU'
}
export function removeContextMenu() {
return {
type: 'REMOVE_CONTEXT_MENU',
};
}
export function showTouchContextMenu(data){
return {
type: 'SHOW_TOUCH_CONTEXT_MENU',
data: data
}
export function showTouchContextMenu(data) {
return {
type: 'SHOW_TOUCH_CONTEXT_MENU',
data,
};
}
export function hideTouchContextMenu(){
return {
type: 'HIDE_TOUCH_CONTEXT_MENU'
}
export function hideTouchContextMenu() {
return {
type: 'HIDE_TOUCH_CONTEXT_MENU',
};
}
export function removeTouchContextMenu(){
return {
type: 'REMOVE_TOUCH_CONTEXT_MENU'
}
export function removeTouchContextMenu() {
return {
type: 'REMOVE_TOUCH_CONTEXT_MENU',
};
}
export function lazyLoading(start){
return {
type: 'LAZY_LOADING',
start: start
}
export function lazyLoading(start) {
return {
type: 'LAZY_LOADING',
start,
};
}
export function toggleSidebar(new_state = 'toggle'){
var action = {
type: 'TOGGLE_SIDEBAR'
}
if (new_state != 'toggle'){
action.new_state = new_state
}
return action
export function toggleSidebar(new_state = 'toggle') {
const action = {
type: 'TOGGLE_SIDEBAR',
};
if (new_state != 'toggle') {
action.new_state = new_state;
}
return action;
}
export function dragStart(e, context, from_uri = null, victims, victims_indexes = null){
return {
type: 'DRAG_START',
context: context,
from_uri: from_uri,
victims: victims,
victims_indexes: victims_indexes,
start_x: e.clientX,
start_y: e.clientY
}
export function dragStart(e, context, from_uri = null, victims, victims_indexes = null) {
return {
type: 'DRAG_START',
context,
from_uri,
victims,
victims_indexes,
start_x: e.clientX,
start_y: e.clientY,
};
}
export function dragActive(){
return { type: 'DRAG_ACTIVE' }
export function dragActive() {
return { type: 'DRAG_ACTIVE' };
}
export function dragEnd(){
return { type: 'DRAG_END' }
export function dragEnd() {
return { type: 'DRAG_END' };
}
export function set(data){
return {
type: 'UI_SET',
data: data
}
export function set(data) {
return {
type: 'UI_SET',
data,
};
}
export function installPrompt(event){
return {
type: 'INSTALL_PROMPT',
event: event
}
export function installPrompt(event) {
return {
type: 'INSTALL_PROMPT',
event,
};
}
/**
* Notifications
*
* Subtle info/tooltip messages
**/
* */
export function createBrowserNotification(data){
return {
type: 'BROWSER_NOTIFICATION',
data: data
}
export function createBrowserNotification(data) {
return {
type: 'BROWSER_NOTIFICATION',
data,
};
}
export function createNotification(data){
export function createNotification(data) {
// Allow 'message' as an alias of our content
if (data.message) {
data.content = data.message;
}
// Allow 'message' as an alias of our content
if (data.message){
data.content = data.message;
}
// Shortcut notifications are short and sweet
if (data.type == 'shortcut'){
data.duration = 0.4;
}
// Shortcut notifications are short and sweet
if (data.type == 'shortcut') {
data.duration = 0.4;
}
return {
type: 'CREATE_NOTIFICATION',
notification: Object.assign(
{
key: helpers.generateGuid(),
duration: 5,
type: 'default',
title: null,
content: null,
description: null,
sticky: false,
closing: false,
render_content: false
},
data
)
}
return {
type: 'CREATE_NOTIFICATION',
notification: {
key: helpers.generateGuid(),
duration: 5,
type: 'default',
title: null,
content: null,
description: null,
sticky: false,
closing: false,
render_content: false,
...data,
},
};
}
export function closeNotification(key){
return {
type: 'CLOSE_NOTIFICATION',
key: key
}
export function closeNotification(key) {
return {
type: 'CLOSE_NOTIFICATION',
key,
};
}
export function removeNotification(key, manual = false){
return {
type: 'REMOVE_NOTIFICATION',
key: key,
manual: manual
}
export function removeNotification(key, manual = false) {
return {
type: 'REMOVE_NOTIFICATION',
key,
manual,
};
}
/**
* Loaders
**/
* */
export function startLoading(key,source){
return {
type: 'START_LOADING',
source: source,
key: key
}
export function startLoading(key, source) {
return {
type: 'START_LOADING',
source,
key,
};
}
export function stopLoading(key){
return {
type: 'STOP_LOADING',
key: key
}
export function stopLoading(key) {
return {
type: 'STOP_LOADING',
key,
};
}
export function startProcess(key,message,data = {}){
return {
type: 'START_PROCESS',
key: key,
message: message,
data: data
}
export function startProcess(key, message, data = {}) {
return {
type: 'START_PROCESS',
key,
message,
data,
};
}
export function resumeProcess(key,message,data = {}){
return {
type: 'RESUME_PROCESS',
key: key
}
export function resumeProcess(key, message, data = {}) {
return {
type: 'RESUME_PROCESS',
key,
};
}
export function updateProcess(key,message,data = {}){
return {
type: 'UPDATE_PROCESS',
key: key,
message: message,
data: data
}
export function updateProcess(key, message, data = {}) {
return {
type: 'UPDATE_PROCESS',
key,
message,
data,
};
}
export function runProcess(key,data = {}){
return {
type: key,
data: data
}
export function runProcess(key, data = {}) {
return {
type: key,
data,
};
}
export function cancelProcess(key){
return {
type: 'CANCEL_PROCESS',
key: key
}
export function cancelProcess(key) {
return {
type: 'CANCEL_PROCESS',
key,
};
}
export function processCancelled(key){
return {
type: 'PROCESS_CANCELLED',
key: key
}
export function processCancelled(key) {
return {
type: 'PROCESS_CANCELLED',
key,
};
}
export function processFinishing(key){
return {
type: 'PROCESS_FINISHING',
key: key
}
export function processFinishing(key) {
return {
type: 'PROCESS_FINISHING',
key,
};
}
export function processFinished(key){
return {
type: 'PROCESS_FINISHED',
key: key
}
export function processFinished(key) {
return {
type: 'PROCESS_FINISHED',
key,
};
}

453
src/js/services/ui/middleware.js
View File

@ -2,247 +2,244 @@
import ReactGA from 'react-ga';
import * as helpers from '../../helpers';
var uiActions = require('./actions.js')
var mopidyActions = require('../mopidy/actions.js')
const uiActions = require('./actions.js');
const mopidyActions = require('../mopidy/actions.js');
const UIMiddleware = (function(){
/**
const UIMiddleware = (function () {
/**
* The actual middleware inteceptor
**/
return store => next => action => {
switch(action.type){
* */
return (store) => (next) => (action) => {
switch (action.type) {
case 'MOPIDY_STATE':
case 'MOPIDY_STATE':
// Get the current track from our index
var { tracks } = store.getState().core;
var current_track_uri = store.getState().core.current_track;
var current_track = null;
if (tracks[current_track_uri] !== undefined) {
current_track = tracks[current_track_uri];
}
next(action);
break;
// Get the current track from our index
var tracks = store.getState().core.tracks;
var current_track_uri = store.getState().core.current_track;
var current_track = null;
if (tracks[current_track_uri] !== undefined){
current_track = tracks[current_track_uri];
}
next(action);
break
case 'SET_WINDOW_TITLE':
case 'SET_WINDOW_TITLE':
var window_title = '';
var window_title = "";
if (action.play_state) {
var { play_state } = action;
} else {
var { play_state } = store.getState().mopidy;
}
if (action.play_state){
var play_state = action.play_state;
} else {
var play_state = store.getState().mopidy.play_state;
}
if (action.title) {
var { title } = action;
} else {
var title = store.getState().ui.window_title;
}
if (action.title){
var title = action.title;
} else {
var title = store.getState().ui.window_title;
}
document.title = window_title+' '+title;
document.title = `${window_title} ${title}`;
next(action);
break;
next(action);
break;
case 'OPEN_MODAL':
if (store.getState().ui.allow_reporting){
case 'OPEN_MODAL':
if (store.getState().ui.allow_reporting) {
ReactGA.event({ category: 'Modal', action: 'Opened', label: action.modal.name });
}
$('body').addClass('modal-open')
store.dispatch(uiActions.hideContextMenu())
store.dispatch(uiActions.hideTouchContextMenu())
next(action)
break
$('body').addClass('modal-open');
store.dispatch(uiActions.hideContextMenu());
store.dispatch(uiActions.hideTouchContextMenu());
next(action);
break;
case 'CLOSE_MODAL':
if (store.getState().ui.allow_reporting){
ReactGA.event({ category: 'Modal', action: 'Closed', label: null });
}
$('body').removeClass('modal-open')
next(action)
break
case 'HIDE_CONTEXT_MENU':
if (store.getState().ui.context_menu){
setTimeout(
() => {
store.dispatch(uiActions.removeContextMenu())
},
200
);
next(action);
}
break;
case 'HIDE_TOUCH_CONTEXT_MENU':
if (store.getState().ui.context_menu){
setTimeout(
() => {
store.dispatch(uiActions.removeTouchContextMenu())
},
200
);
next(action);
}
break;
case 'BROWSER_NOTIFICATION':
var notification = window.Notification || window.mozNotification || window.webkitNotification;
if ('undefined' === typeof notification) return false;
if ('undefined' !== typeof notification) notification.requestPermission(function(permission){});
// handle nested data objects
var data = {}
if (typeof(action.data) ) data = action.data
if (typeof(data.data) ) data = Object.assign({}, data, data.data)
// construct our browser notification
var title = '';
var options = {
body: '',
dir: 'auto',
lang: 'EN',
tag: 'iris'
};
if (data.title ) title = data.title;
if (data.body ) options.body = data.body;
if (data.icon ) options.icon = data.icon;
// make it so
var notification = new notification(title, options );
break
case 'CREATE_NOTIFICATION':
// start a timeout to close this notification
if (!action.notification.sticky){
var timeout = setTimeout(
function(){
store.dispatch(uiActions.closeNotification(action.notification.key))
},
action.notification.duration * 1000
)
}
next(action);
break;
case 'CLOSE_NOTIFICATION':
var notifications = Object.assign({}, store.getState().ui.notifications);
// start a timeout to remove this notification
// This gives us time to animate out the notification before we remove the data
var timeout = setTimeout(
function(){
store.dispatch(uiActions.removeNotification(action.key))
},
200
)
next(action);
break;
case 'REMOVE_NOTIFICATION':
// Manual removal
if (action.manual){
var notifications = Object.assign({}, store.getState().ui.notifications);
// If a broadcast, add to suppressed_broadcasts
if (notifications[action.key] && notifications[action.key].type == 'broadcast'){
store.dispatch({
type: 'SUPPRESS_BROADCAST',
key: action.key
})
}
}
next(action);
break;
case 'BROADCASTS_LOADED':
var suppressed_broadcasts = []
if (store.getState().ui.suppressed_broadcasts !== undefined){
suppressed_broadcasts = store.getState().ui.suppressed_broadcasts
}
for (var i = 0; i < action.broadcasts.length; i++){
var broadcast = action.broadcasts[i]
if (!suppressed_broadcasts.includes(broadcast.key)){
if (broadcast.message){
var data = {
key: (broadcast.key ? broadcast.key : null),
title: (broadcast.title ? broadcast.title : null),
content: (broadcast.message ? broadcast.message : null),
links: (broadcast.links ? broadcast.links : null),
type: 'broadcast',
sticky: true
}
store.dispatch(uiActions.createNotification(data));
}
}
}
next(action)
break
case 'START_PROCESS':
store.dispatch({
type: action.key,
data: action.data
})
store.dispatch({
type: action.key+'_STARTED'
})
next(action)
break
case 'RESUME_PROCESS':
store.dispatch({
type: action.key,
data: store.getState().ui.processes[action.key].data
})
next(action)
break
case 'PROCESS_CANCELLED':
store.dispatch({
type: action.key+'_CANCELLED'
})
next(action)
break
case 'PROCESS_FINISHING':
// start a timeout to remove this notification
// This gives us time to animate out the notification before we remove the data
var timeout = setTimeout(
function(){
store.dispatch(uiActions.processFinished(action.key))
},
200
)
next(action);
break;
case 'PROCESS_FINISHED':
store.dispatch({
type: action.key+'_FINISHED'
});
next(action);
break;
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action)
case 'CLOSE_MODAL':
if (store.getState().ui.allow_reporting) {
ReactGA.event({ category: 'Modal', action: 'Closed', label: null });
}
$('body').removeClass('modal-open');
next(action);
break;
case 'HIDE_CONTEXT_MENU':
if (store.getState().ui.context_menu) {
setTimeout(
() => {
store.dispatch(uiActions.removeContextMenu());
},
200,
);
next(action);
}
break;
case 'HIDE_TOUCH_CONTEXT_MENU':
if (store.getState().ui.context_menu) {
setTimeout(
() => {
store.dispatch(uiActions.removeTouchContextMenu());
},
200,
);
next(action);
}
break;
case 'BROWSER_NOTIFICATION':
var notification = window.Notification || window.mozNotification || window.webkitNotification;
if (typeof notification === 'undefined') return false;
if (typeof notification !== 'undefined') notification.requestPermission((permission) => {});
// handle nested data objects
var data = {};
if (typeof (action.data)) data = action.data;
if (typeof (data.data)) data = { ...data, ...data.data };
// construct our browser notification
var title = '';
var options = {
body: '',
dir: 'auto',
lang: 'EN',
tag: 'iris',
};
if (data.title) title = data.title;
if (data.body) options.body = data.body;
if (data.icon) options.icon = data.icon;
// make it so
var notification = new notification(title, options);
break;
case 'CREATE_NOTIFICATION':
// start a timeout to close this notification
if (!action.notification.sticky) {
var timeout = setTimeout(
() => {
store.dispatch(uiActions.closeNotification(action.notification.key));
},
action.notification.duration * 1000,
);
}
next(action);
break;
case 'CLOSE_NOTIFICATION':
var notifications = { ...store.getState().ui.notifications };
// start a timeout to remove this notification
// This gives us time to animate out the notification before we remove the data
var timeout = setTimeout(
() => {
store.dispatch(uiActions.removeNotification(action.key));
},
200,
);
next(action);
break;
case 'REMOVE_NOTIFICATION':
// Manual removal
if (action.manual) {
var notifications = { ...store.getState().ui.notifications };
// If a broadcast, add to suppressed_broadcasts
if (notifications[action.key] && notifications[action.key].type == 'broadcast') {
store.dispatch({
type: 'SUPPRESS_BROADCAST',
key: action.key,
});
}
}
next(action);
break;
case 'BROADCASTS_LOADED':
var suppressed_broadcasts = [];
if (store.getState().ui.suppressed_broadcasts !== undefined) {
suppressed_broadcasts = store.getState().ui.suppressed_broadcasts;
}
for (let i = 0; i < action.broadcasts.length; i++) {
const broadcast = action.broadcasts[i];
if (!suppressed_broadcasts.includes(broadcast.key)) {
if (broadcast.message) {
var data = {
key: (broadcast.key ? broadcast.key : null),
title: (broadcast.title ? broadcast.title : null),
content: (broadcast.message ? broadcast.message : null),
links: (broadcast.links ? broadcast.links : null),
type: 'broadcast',
sticky: true,
};
store.dispatch(uiActions.createNotification(data));
}
}
}
next(action);
break;
case 'START_PROCESS':
store.dispatch({
type: action.key,
data: action.data,
});
store.dispatch({
type: `${action.key}_STARTED`,
});
next(action);
break;
case 'RESUME_PROCESS':
store.dispatch({
type: action.key,
data: store.getState().ui.processes[action.key].data,
});
next(action);
break;
case 'PROCESS_CANCELLED':
store.dispatch({
type: `${action.key}_CANCELLED`,
});
next(action);
break;
case 'PROCESS_FINISHING':
// start a timeout to remove this notification
// This gives us time to animate out the notification before we remove the data
var timeout = setTimeout(
() => {
store.dispatch(uiActions.processFinished(action.key));
},
200,
);
next(action);
break;
case 'PROCESS_FINISHED':
store.dispatch({
type: `${action.key}_FINISHED`,
});
next(action);
break;
// This action is irrelevant to us, pass it on to the next middleware
default:
return next(action);
}
};
}());
})();
export default UIMiddleware
export default UIMiddleware;

344
src/js/services/ui/reducer.js
View File

@ -1,228 +1,210 @@
import * as helpers from '../../helpers'
import * as helpers from '../../helpers';
export default function reducer(ui = {}, action){
switch (action.type){
export default function reducer(ui = {}, action) {
switch (action.type) {
case 'LAZY_LOADING':
return { ...ui, lazy_loading: action.start };
case 'LAZY_LOADING':
return Object.assign({}, ui, { lazy_loading: action.start });
case 'SET_SLIM_MODE':
return { ...ui, slim_mode: action.slim_mode };
case 'SET_SLIM_MODE':
return Object.assign({}, ui, { slim_mode: action.slim_mode });
case 'SET_WINDOW_FOCUS':
return { ...ui, window_focus: action.window_focus };
case 'SET_WINDOW_FOCUS':
return Object.assign({}, ui, { window_focus: action.window_focus });
case 'DEBUG':
return { ...ui, debug_response: action.response };
case 'DEBUG':
return Object.assign({}, ui, { debug_response: action.response })
case 'UI_SET':
return { ...ui, ...action.data };
case 'UI_SET':
return Object.assign({}, ui, action.data);
case 'SET_WINDOW_TITLE':
if (action.title){
return Object.assign({}, ui, { window_title: action.title });
} else {
return ui;
}
case 'TOGGLE_SIDEBAR':
var new_state = !ui.sidebar_open
if (typeof(action.new_state) !== 'undefined' ) new_state = action.new_state
return Object.assign({}, ui, { sidebar_open : new_state })
case 'SET_CURRENT_TRACK_TRANSITION':
return Object.assign({}, ui, { current_track_transition : action.current_track_transition })
case 'SET_SELECTED_TRACKS':
return Object.assign({}, ui, { selected_tracks : Object.assign([],action.keys) })
case 'ICON_LOADED':
var icons = Object.assign({}, ui.icons);
icons[action.key] = action.icon;
return Object.assign({}, ui, {icons : icons});
case 'INSTALL_PROMPT':
return Object.assign({}, ui, {install_prompt : action.event});
case 'SET_WINDOW_TITLE':
if (action.title) {
return { ...ui, window_title: action.title };
}
return ui;
/**
case 'TOGGLE_SIDEBAR':
var new_state = !ui.sidebar_open;
if (typeof (action.new_state) !== 'undefined') new_state = action.new_state;
return { ...ui, sidebar_open: new_state };
case 'SET_CURRENT_TRACK_TRANSITION':
return { ...ui, current_track_transition: action.current_track_transition };
case 'SET_SELECTED_TRACKS':
return { ...ui, selected_tracks: Object.assign([], action.keys) };
case 'ICON_LOADED':
var icons = { ...ui.icons };
icons[action.key] = action.icon;
return { ...ui, icons };
case 'INSTALL_PROMPT':
return { ...ui, install_prompt: action.event };
/**
* Context menu
**/
* */
case 'SHOW_CONTEXT_MENU':
return Object.assign({}, ui, {
context_menu: action.data
});
case 'SHOW_CONTEXT_MENU':
return { ...ui, context_menu: action.data };
case 'HIDE_CONTEXT_MENU':
return Object.assign(
{},
ui,
{
context_menu: Object.assign({}, ui.context_menu, {closing: true})
}
);
case 'HIDE_CONTEXT_MENU':
return {
case 'REMOVE_CONTEXT_MENU':
return Object.assign({}, ui, {context_menu: null});
...ui,
context_menu: { ...ui.context_menu, closing: true },
};
case 'SHOW_TOUCH_CONTEXT_MENU':
return Object.assign({}, ui, {
touch_context_menu: action.data
});
case 'REMOVE_CONTEXT_MENU':
return { ...ui, context_menu: null };
case 'HIDE_TOUCH_CONTEXT_MENU':
return Object.assign(
{},
ui,
{
touch_context_menu: Object.assign({}, ui.touch_context_menu, {closing: true})
}
);
case 'SHOW_TOUCH_CONTEXT_MENU':
return { ...ui, touch_context_menu: action.data };
case 'REMOVE_TOUCH_CONTEXT_MENU':
return Object.assign({}, ui, {touch_context_menu: null});
case 'HIDE_TOUCH_CONTEXT_MENU':
return {
...ui,
touch_context_menu: { ...ui.touch_context_menu, closing: true },
};
case 'REMOVE_TOUCH_CONTEXT_MENU':
return { ...ui, touch_context_menu: null };
/**
/**
* Dragging
**/
* */
case 'DRAG_START':
return Object.assign({}, ui, {
dragger: {
dragging: true,
active: false,
context: action.context,
from_uri: action.from_uri,
victims: action.victims,
victims_indexes: action.victims_indexes,
start_x: action.start_x,
start_y: action.start_y
}
});
case 'DRAG_START':
return {
...ui,
dragger: {
dragging: true,
active: false,
context: action.context,
from_uri: action.from_uri,
victims: action.victims,
victims_indexes: action.victims_indexes,
start_x: action.start_x,
start_y: action.start_y,
},
};
case 'DRAG_ACTIVE':
var dragger = Object.assign({}, ui.dragger, { active: true })
return Object.assign({}, ui, { dragger: dragger });
case 'DRAG_ACTIVE':
var dragger = { ...ui.dragger, active: true };
return { ...ui, dragger };
case 'DRAG_END':
return Object.assign({}, ui, {
dragger: false
});
case 'DRAG_END':
return { ...ui, dragger: false };
/**
/**
* Modals
**/
* */
case 'OPEN_MODAL':
return Object.assign({}, ui, { modal: action.modal })
case 'OPEN_MODAL':
return { ...ui, modal: action.modal };
case 'CLOSE_MODAL':
return Object.assign({}, ui, { modal: false })
case 'CLOSE_MODAL':
return { ...ui, modal: false };
/**
/**
* Notifications
**/
* */
case 'CREATE_NOTIFICATION':
var notifications = Object.assign({}, ui.notifications);
notifications[action.notification.key] = action.notification;
return Object.assign({}, ui, { notifications: notifications });
case 'CREATE_NOTIFICATION':
var notifications = { ...ui.notifications };
notifications[action.notification.key] = action.notification;
return { ...ui, notifications };
case 'CLOSE_NOTIFICATION':
var notifications = Object.assign({}, ui.notifications);
if (notifications[action.key]){
notifications[action.key].closing = true;
}
return Object.assign({}, ui, { notifications: notifications });
case 'CLOSE_NOTIFICATION':
var notifications = { ...ui.notifications };
if (notifications[action.key]) {
notifications[action.key].closing = true;
}
return { ...ui, notifications };
case 'REMOVE_NOTIFICATION':
var notifications = Object.assign({}, ui.notifications);
delete notifications[action.key];
return Object.assign({}, ui, {notifications: notifications});
case 'REMOVE_NOTIFICATION':
var notifications = { ...ui.notifications };
delete notifications[action.key];
return { ...ui, notifications };
/**
/**
* Loading and processes
**/
* */
case 'START_LOADING':
var load_queue = Object.assign({}, (ui.load_queue ? ui.load_queue : {}))
load_queue[action.key] = action.source
return Object.assign({}, ui, {load_queue: load_queue})
case 'START_LOADING':
var load_queue = { ...(ui.load_queue ? ui.load_queue : {}) };
load_queue[action.key] = action.source;
return { ...ui, load_queue };
case 'STOP_LOADING':
var load_queue = Object.assign({}, (ui.load_queue ? ui.load_queue : {}))
if (load_queue[action.key]){
delete load_queue[action.key]
}
return Object.assign({}, ui, {load_queue: load_queue})
case 'STOP_LOADING':
var load_queue = { ...(ui.load_queue ? ui.load_queue : {}) };
if (load_queue[action.key]) {
delete load_queue[action.key];
}
return { ...ui, load_queue };
case 'START_PROCESS':
case 'UPDATE_PROCESS':
var processes = Object.assign({}, (ui.processes ? ui.processes : []))
if (processes[action.key]){
var data = Object.assign({}, processes[action.key].data, action.data)
} else {
var data = action.data
}
processes[action.key] = {
key: action.key,
message: action.message,
status: 'running',
data: data
}
return Object.assign({}, ui, {processes: processes})
case 'START_PROCESS':
case 'UPDATE_PROCESS':
var processes = { ...(ui.processes ? ui.processes : []) };
if (processes[action.key]) {
var data = { ...processes[action.key].data, ...action.data };
} else {
var { data } = action;
}
processes[action.key] = {
key: action.key,
message: action.message,
status: 'running',
data,
};
return { ...ui, processes };
case 'RESUME_PROCESS':
var processes = Object.assign({}, (ui.processes ? ui.processes : {}))
if (processes[action.key]){
processes[action.key] = Object.assign({}, processes[action.key], {status: 'running'})
}
return Object.assign({}, ui, {processes: processes})
case 'RESUME_PROCESS':
var processes = { ...(ui.processes ? ui.processes : {}) };
if (processes[action.key]) {
processes[action.key] = { ...processes[action.key], status: 'running' };
}
return { ...ui, processes };
case 'CANCEL_PROCESS':
var processes = Object.assign({}, (ui.processes ? ui.processes : {}))
if (processes[action.key]){
processes[action.key] = Object.assign({}, processes[action.key], {status: 'cancelling'})
}
return Object.assign({}, ui, {processes: processes})
case 'CANCEL_PROCESS':
var processes = { ...(ui.processes ? ui.processes : {}) };
if (processes[action.key]) {
processes[action.key] = { ...processes[action.key], status: 'cancelling' };
}
return { ...ui, processes };
case 'PROCESS_CANCELLED':
var processes = Object.assign({}, (ui.processes ? ui.processes : {}))
if (processes[action.key]){
processes[action.key] = Object.assign({}, processes[action.key], {status: 'cancelled'})
}
return Object.assign({}, ui, {processes: processes})
case 'PROCESS_CANCELLED':
var processes = { ...(ui.processes ? ui.processes : {}) };
if (processes[action.key]) {
processes[action.key] = { ...processes[action.key], status: 'cancelled' };
}
return { ...ui, processes };
case 'PROCESS_FINISHING':
var processes = Object.assign({}, (ui.processes ? ui.processes : {}))
if (processes[action.key]){
processes[action.key] = Object.assign({}, processes[action.key], {closing: true})
}
return Object.assign({}, ui, {processes: processes})
case 'PROCESS_FINISHING':
var processes = { ...(ui.processes ? ui.processes : {}) };
if (processes[action.key]) {
processes[action.key] = { ...processes[action.key], closing: true };
}
return { ...ui, processes };
case 'PROCESS_FINISHED':
var processes = Object.assign({}, (ui.processes ? ui.processes : {}))
if (processes[action.key]){
processes[action.key] = Object.assign({}, processes[action.key], {status: 'finished', closing: false})
}
return Object.assign({}, ui, {processes: processes})
case 'PROCESS_FINISHED':
var processes = { ...(ui.processes ? ui.processes : {}) };
if (processes[action.key]) {
processes[action.key] = { ...processes[action.key], status: 'finished', closing: false };
}
return { ...ui, processes };
default:
return ui
}
default:
return ui;
}
}