Convert connectivity and dashboard (nukeop#1034)

* Convert connectivity and dashboard

* Fix types

packages/app/app/actions/actionTypes.ts

@@ -75,3 +75,22 @@ export enum Mastodon {
 
   MASTODON_LOG_OUT = 'MASTODON_LOG_OUT'
 }
+
+export enum Connectivity {
+  CHANGE_CONNECTIVITY = 'CHANGE_CONNECTIVITY'
+}
+
+export enum Dashboard {
+  LOAD_BEST_NEW_ALBUMS_START = 'LOAD_BEST_NEW_ALBUMS_START',
+  LOAD_BEST_NEW_ALBUMS_SUCCESS = 'LOAD_BEST_NEW_ALBUMS_SUCCESS',
+  LOAD_BEST_NEW_ALBUMS_ERROR = 'LOAD_BEST_NEW_ALBUMS_ERROR',
+  LOAD_BEST_NEW_TRACKS_START = 'LOAD_BEST_NEW_TRACKS_START',
+  LOAD_BEST_NEW_TRACKS_SUCCESS = 'LOAD_BEST_NEW_TRACKS_SUCCESS',
+  LOAD_BEST_NEW_TRACKS_ERROR = 'LOAD_BEST_NEW_TRACKS_ERROR',
+  LOAD_TOP_TAGS_START = 'LOAD_TOP_TAGS_START',
+  LOAD_TOP_TAGS_SUCCESS = 'LOAD_TOP_TAGS_SUCCESS',
+  LOAD_TOP_TAGS_ERROR = 'LOAD_TOP_TAGS_ERROR',
+  LOAD_TOP_TRACKS_START = 'LOAD_TOP_TRACKS_START',
+  LOAD_TOP_TRACKS_SUCCESS = 'LOAD_TOP_TRACKS_SUCCESS',
+  LOAD_TOP_TRACKS_ERROR = 'LOAD_TOP_TRACKS_ERROR',
+}

packages/app/app/actions/connectivity.ts

@@ -0,0 +1,4 @@
+import { createStandardAction } from 'typesafe-actions';
+import { Connectivity } from './actionTypes';
+
+export const changeConnectivity = createStandardAction(Connectivity.CHANGE_CONNECTIVITY)();

packages/app/app/actions/dashboard.ts

@@ -0,0 +1,93 @@
+import logger from 'electron-timber';
+import { rest } from '@nuclear/core';
+import { getBestNewAlbums, getBestNewTracks } from 'pitchfork-bnm';
+import { Deezer } from '@nuclear/core/src/rest';
+
+import globals from '../globals';
+import { Dashboard } from './actionTypes';
+import { createAsyncAction } from 'typesafe-actions';
+
+const lastfm = new rest.LastFmApi(
+  globals.lastfmApiKey,
+  globals.lastfmApiSecret
+);
+
+export const loadTopTagsAction = createAsyncAction(
+  Dashboard.LOAD_TOP_TAGS_START,
+  Dashboard.LOAD_TOP_TAGS_SUCCESS,
+  Dashboard.LOAD_TOP_TAGS_ERROR
+)<undefined, unknown, undefined>();
+
+export function loadTopTags() {
+  return dispatch => {
+    dispatch(loadTopTagsAction.request());
+    lastfm
+      .getTopTags()
+      .then(response => response.json())
+      .then(results => {
+        dispatch(loadTopTagsAction.success(results.toptags.tag));
+      })
+      .catch(error => {
+        dispatch(loadTopTagsAction.failure());
+        logger.error(error);
+      });
+  };
+}
+
+export const loadBestNewAlbumsAction = createAsyncAction(
+  Dashboard.LOAD_BEST_NEW_ALBUMS_START,
+  Dashboard.LOAD_BEST_NEW_ALBUMS_SUCCESS,
+  Dashboard.LOAD_BEST_NEW_ALBUMS_ERROR
+)<undefined, unknown, undefined>();
+
+export function loadBestNewAlbums() {
+  return dispatch => {
+    dispatch(loadBestNewAlbumsAction.request());
+    getBestNewAlbums()
+      .then(albums => {
+        dispatch(loadBestNewAlbumsAction.success(albums));
+      })
+      .catch(error => {
+        dispatch(loadBestNewAlbumsAction.failure());
+        logger.error(error);
+      });
+  };
+}
+
+export const loadBestNewTracksAction = createAsyncAction(
+  Dashboard.LOAD_BEST_NEW_TRACKS_START,
+  Dashboard.LOAD_BEST_NEW_TRACKS_SUCCESS,
+  Dashboard.LOAD_BEST_NEW_TRACKS_ERROR
+)<undefined, unknown, undefined>();
+
+export function loadBestNewTracks() {
+  return dispatch => {
+    dispatch(loadBestNewTracksAction.request());
+    getBestNewTracks()
+      .then(tracks => {
+        dispatch(loadBestNewTracksAction.success(tracks));
+      })
+      .catch(error => {
+        dispatch(loadBestNewTracksAction.failure());
+        logger.error(error);
+      });
+  };
+}
+
+export const loadTopTracksAction = createAsyncAction(
+  Dashboard.LOAD_TOP_TRACKS_START,
+  Dashboard.LOAD_TOP_TRACKS_SUCCESS,
+  Dashboard.LOAD_TOP_TRACKS_ERROR
+)<undefined, unknown, undefined>();
+
+export const loadTopTracks = () => async (dispatch) => {
+  dispatch(loadTopTracksAction.request());
+
+  try {
+    const tracks = await Deezer.getTopTracks();
+    dispatch(loadTopTracksAction.success(tracks.data.map(Deezer.mapDeezerTrackToInternal)));
+  } catch (error) {
+    dispatch(loadTopTracksAction.failure());
+    logger.error(error);
+  }
+};

packages/app/app/reducers/connectivity.js → packages/app/app/reducers/connectivity.ts

@@ -1,8 +1,9 @@
-import { CHANGE_CONNECTIVITY } from '../actions/connectivity';
+import { getType } from 'typesafe-actions';
+import { changeConnectivity } from '../actions/connectivity';
 
 function ConnectivityReducer(state = navigator.onLine, action) {
   switch (action.type) {
-  case CHANGE_CONNECTIVITY:
+  case getType(changeConnectivity):
     return action.payload;
   default:
     return state;

packages/app/app/reducers/dashboard.js → packages/app/app/reducers/dashboard.ts

@@ -1,9 +1,5 @@
-import {
-  LOAD_BEST_NEW_ALBUMS_SUCCESS,
-  LOAD_BEST_NEW_TRACKS_SUCCESS,
-  LOAD_TOP_TAGS_SUCCESS,
-  LOAD_TOP_TRACKS_SUCCESS
-} from '../actions/dashboard';
+import { getType } from 'typesafe-actions';
+import {loadBestNewAlbumsAction, loadBestNewTracksAction, loadTopTagsAction, loadTopTracksAction} from '../actions/dashboard';
 
 const initialState = {
   bestNewAlbums: [],
@@ -13,19 +9,19 @@ const initialState = {
 
 export default function DashboardReducer(state = initialState, action) {
   switch (action.type) {
-  case LOAD_BEST_NEW_ALBUMS_SUCCESS:
+  case getType(loadBestNewAlbumsAction.success):
     return Object.assign({}, state, {
       bestNewAlbums: action.payload
     });
-  case LOAD_BEST_NEW_TRACKS_SUCCESS:
+  case getType(loadBestNewTracksAction.success):
     return Object.assign({}, state, {
       bestNewTracks: action.payload
     });
-  case LOAD_TOP_TAGS_SUCCESS:
+  case getType(loadTopTagsAction.success):
     return Object.assign({}, state, {
       topTags: action.payload
     });
-  case LOAD_TOP_TRACKS_SUCCESS:
+  case getType(loadTopTracksAction.success):
     return Object.assign({}, state, {
       topTracks: action.payload
     });

packages/app/app/store/middlewares/ipc.js → packages/app/app/store/middlewares/ipc.ts

@@ -5,10 +5,19 @@ import _ from 'lodash';
 import { PAUSE_PLAYBACK, START_PLAYBACK, UPDATE_VOLUME } from '../../actions/player';
 import { LocalLibrary } from '../../actions/actionTypes';
 import { ADD_QUEUE_ITEM, CLEAR_QUEUE, REMOVE_QUEUE_ITEM, QUEUE_DROP } from '../../actions/queue';
-import { SET_BOOLEAN_OPTION, SET_NUMBER_OPTION } from '../../actions/settings';
-import { CHANGE_CONNECTIVITY } from '../../actions/connectivity';
+import { Settings } from '../../actions/actionTypes';
+import { changeConnectivity } from '../../actions/connectivity';
 import { ADD_TO_DOWNLOADS, DOWNLOAD_RESUMED, DOWNLOAD_PAUSED, DOWNLOAD_FINISHED, DOWNLOAD_ERROR } from '../../actions/downloads';
 import { CLOSE_WINDOW, MINIMIZE_WINDOW, MAXIMIZE_WINDOW, OPEN_DEVTOOLS } from '../../actions/window';
+import { getType } from 'typesafe-actions';
+
+type IpcActionType = {
+  type: string;
+  payload: any;
+  meta: {
+    fromMain?: boolean;
+  };
+}
 
 const ipcConnect = () => next => {
   next({
@@ -21,7 +30,7 @@ const ipcConnect = () => next => {
     payload: ipcRenderer.sendSync(IpcEvents.LOCAL_METAS)
   });
 
-  return ({ meta = {}, payload, type }) => {
+  return ({ meta = {}, payload, type }: IpcActionType) => {
     if (meta.fromMain) {
       next({ type, payload });
       return;
@@ -60,7 +69,7 @@ const ipcConnect = () => next => {
     case QUEUE_DROP:
       return ipcRenderer.send(IpcEvents.QUEUE_DROP, payload);
 
-    case SET_BOOLEAN_OPTION:
+    case Settings.SET_BOOLEAN_OPTION:
       switch (payload.option) {
       case 'api.enabled':
         ipcRenderer.send(payload.state ? IpcEvents.API_RESTART : IpcEvents.API_STOP);
@@ -73,13 +82,13 @@ const ipcConnect = () => next => {
         break;
       }
       break;
-    case SET_NUMBER_OPTION:
+    case Settings.SET_NUMBER_OPTION:
       if (payload.option === 'api.port' && isValidPort(payload.state) && getOption('api.enabled')) {
         ipcRenderer.send(IpcEvents.API_RESTART);
       }
       break;
 
-    case CHANGE_CONNECTIVITY:
+    case getType(changeConnectivity):
       ipcRenderer.send(IpcEvents.CONNECTIVITY, payload);
       break;