orb-ui-firebase/es/store/lists/actions.js

Firebase with redux

import * as types from './types';
import * as selectors from './selectors';
import * as initSelectors from '../initialization/selectors';
import { logError } from '../errors/actions';
import { logLoading } from '../loadings/actions';

export var initialize = function initialize(list, location, path, append) {
  return {
    type: types.INIIALIZE,
    payload: list,
    path: path,
    location: location,
    append: append,
    locationValue: true
  };
};

export var childAdded = function childAdded(child, location) {
  return {
    type: types.CHILD_ADDED,
    payload: child,
    location: location
  };
};

export var childChanged = function childChanged(child, location) {
  return {
    type: types.CHILD_CHANGED,
    payload: child,
    location: location
  };
};

export var childRemoved = function childRemoved(child, location) {
  return {
    type: types.CHILD_REMOVED,
    payload: child,
    location: location
  };
};

export var destroy = function destroy(location) {
  return {
    type: types.DESTROY,
    location: location
  };
};

export var unWatch = function unWatch(path) {
  return {
    type: types.UNWATCH,
    path: path
  };
};

var getPayload = function getPayload(snapshot) {
  return { key: snapshot.key, val: snapshot.val() };
};

export var getRef = function getRef(firebaseApp, path) {
  if (typeof path === 'string' || path instanceof String) {
    return firebaseApp.database().ref(path);
  } else {
    return path;
  }
};

export var getLocation = function getLocation(firebaseApp, path) {
  if (typeof path === 'string' || path instanceof String) {
    return path;
  } else {
    return path.toString().substring(firebaseApp.database().ref().root.toString().length);
  }
};

export function watchList(firebaseApp, firebasePath) {
  var reduxPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  var append = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;

  var ref = getRef(firebaseApp, firebasePath);
  var path = ref.toString();
  var location = reduxPath || getLocation(firebaseApp, firebasePath);

  return function (dispatch, getState) {
    var initialized = false;
    var isInitialized = initSelectors.isInitialised(getState(), path, location);
    var persistetList = getState().lists ? getState().lists[location] : [];

    if (!isInitialized) {
      dispatch(initialize(persistetList, location, path, append));
      dispatch(logLoading(location));
      ref.once('value', function (snapshot) {
        initialized = true;

        var list = [];

        snapshot.forEach(function (childSnapshot) {
          var childKey = childSnapshot.key;
          var childData = childSnapshot.val();

          list.push({ key: childKey, val: childData });
        });

        dispatch(initialize(list, location, path, append));
      }, function (err) {
        console.error(err);
        dispatch(logError(location, err));
      });

      ref.on('child_added', function (snapshot) {
        if (initialized) {
          dispatch(childAdded(getPayload(snapshot), location));
        }
      }, function (err) {
        console.error(err);
        dispatch(logError(location, err));
      });

      ref.on('child_changed', function (snapshot) {
        dispatch(childChanged(getPayload(snapshot), location));
      }, function (err) {
        console.error(err);
        dispatch(logError(location, err));
      });

      ref.on('child_removed', function (snapshot) {
        dispatch(childRemoved(getPayload(snapshot), location));
      }, function (err) {
        console.error(err);
        dispatch(logError(location, err));
      });
    }
  };
}

export function unwatchList(firebaseApp, firebasePath) {
  return function (dispatch) {
    var ref = getRef(firebaseApp, firebasePath);
    ref.off();
    dispatch(unWatch(ref.toString()));
  };
}

export function destroyList(firebaseApp, firebasePath) {
  var reduxPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  return function (dispatch, getState) {
    var ref = getRef(firebaseApp, firebasePath);
    var locations = getState().initialization[ref.toString()];

    ref.off();
    dispatch(unWatch(ref.toString()));

    if (reduxPath) {
      dispatch(destroy(reduxPath));
    } else if (locations) {
      Object.keys(locations).forEach(function (location) {
        dispatch(destroy(location));
      });
    }
  };
}

export function unwatchAllLists(firebaseApp, path) {
  return function (dispatch, getState) {
    var allLists = selectors.getAllLists(getState());

    Object.keys(allLists).forEach(function (key, index) {
      var ref = firebaseApp.database().ref(key);
      ref.off();
      dispatch(unWatch(ref.toString()));
    });
  };
}

export function destroyAllLists(firebaseApp, path) {
  return function (dispatch, getState) {
    var allLists = selectors.getAllLists(getState());

    Object.keys(allLists).forEach(function (key, index) {
      var ref = firebaseApp.database().ref(key);
      ref.off();
      dispatch(destroyList(firebaseApp, ref.toString()));
    });
  };
}