--- a/client/src/reducers/sessionsReducer.js	Tue Oct 09 19:07:47 2018 +0200
+++ b/client/src/reducers/sessionsReducer.js	Mon Oct 08 18:35:47 2018 +0200
@@ -1,82 +1,49 @@
-import Immutable from 'immutable';
+import * as R from 'ramda';
 import * as types from '../constants/actionTypes';
 import SessionRecord from '../store/sessionRecord';
 import { ActionEnum } from '../constants';
+import { getId, idEq, getNewAction, setAction } from './utils';
 
-export const sessions = (state = Immutable.List([]), action) => {
+export const sessions = (state = [], action) => {
 
   switch (action.type) {
 
     case types.CREATE_SESSION: {
-      return state.push(new SessionRecord(action.session));
+      return R.append(SessionRecord(action.session), state);
     }
     case types.UPDATE_SESSION: {
-      const sessionToUpdate = state.find(session => session === action.session);
-      const sessionIndex = state.indexOf(action.session);
-      if (sessionIndex === -1) {
-        return state;
-      }
-      let newAction;
-      switch (sessionToUpdate.get('action')) {
-        case ActionEnum.CREATED:
-          newAction = ActionEnum.CREATED;
-          break;
-        case ActionEnum.DELETED: // should not happen, but...
-          newAction = ActionEnum.DELETED;
-          break;
-        default:
-          newAction = ActionEnum.UPDATED;
-      }
-
-      const updatedSession = sessionToUpdate.merge(action.values, {action: newAction});
-      return state.set(sessionIndex, updatedSession);
+      return R.map(R.when(idEq(action.sessionId), session => {
+        return R.mergeAll([session, action.values, {action: getNewAction(R.prop('action', session))}])
+      }), state);
     }
     case types.DO_DELETE_SESSION: {
-      return state.filter((session) => action.sessionId !== session._id)
+      return R.reject(idEq(action.sessionId) , state);
     }
+    // TODO: Change the session argument. This should not be the complete session object
     case types.DELETE_SESSION: {
-      const sessionIndex = state.indexOf(action.session);
-      if (sessionIndex === -1) {
-        return state;
-      }
-      const deletedSession = state.get(sessionIndex);
-      if(deletedSession.get('action') === ActionEnum.CREATED) {
-        // The session was previously created, we can delete it
-        return state.delete(sessionIndex);
-      } else {
-        return state.set(sessionIndex, deletedSession.merge({action: ActionEnum.DELETED}));
-      }
+      return R.map(R.when(idEq(action.sessionId), setAction(ActionEnum.DELETED) ), state);
     }
     case types.LOAD_SESSIONS: {
       return action.sessions;
     }
     case types.LOAD_SESSION: {
       const sessionRec = action.session;
-      const sessionId = sessionRec.get('_id');
-      const index = state.findIndex((session) => session.get('_id') === sessionId);
+      const sessionId = getId(sessionRec);
+      const index = R.findIndex(idEq(sessionId), state);
       if(index >= 0) {
-        return state.set(index, sessionRec);
+        return  R.update(index, sessionRec, state);
       } else {
-        return state.push(sessionRec);
+        return R.append(sessionRec, state);
       }
     }
     case types.SYNC_RESET_ALL: {
-      return state.map((session) => {
-        if(session.action !== ActionEnum.NONE) {
-          return session.merge({action: ActionEnum.None});
-        } else {
-          return session;
-        }
-      });
+      return R.map(setAction(ActionEnum.NONE), state);
     }
     case types.RESET_ACTION_SESSION: {
-      const sessionId = action.session.get('_id');
-      const index = state.findIndex((session) => session.get('_id') === sessionId);
-      const session = state.get(index);
-      return state.set(index, session.merge({action: ActionEnum.NONE}));
+      return R.map(R.when(idEq(action.sessionId), setAction(ActionEnum.NONE)), state);
     }
     case types.AUTH_LOGOUT: {
-      return Immutable.List(); // empty session list on logout
+      return []; // empty session list on logout
     }
     default:
       return state;