React in functional style

dashboard.js

import React, { PropTypes } from "react";
import IPropTypes from "react-immutable-proptypes";

import composeEnhances from "recompose/compose";
import setDisplayName from "recompose/setDisplayName";
import setPropTypes from "recompose/setPropTypes";
import onlyUpdateForPropTypes from "recompose/onlyUpdateForPropTypes";

import { connect } from "react-redux";

import pipe from "ramda/src/pipe";
import __ from "ramda/src/__";
import always from "ramda/src/always";
import cond from "ramda/src/cond";
import equals from "ramda/src/equals";
import identity from "ramda/src/identity";
import T from "ramda/src/T";
import isNil from "ramda/src/isNil";
import ReworkNavigation from "../components/rework-navigation/rework-navigation";

import {
	get,
	set,
	deleteField,
	toString,
	getIn,
	update,
	reduce,
} from "../../../../util/functional-immutable";
import { List, Map } from "immutable";
import {
	applyFilter,
	setStep,
	setFilter
} from "../rework-actions";
import DateRangeFilter from "../components/date-range-filter/date-range-filter";
import ReworkList from "../components/rework-list/rework-list";
import LoadDataSpinner from "../components/load-data-spinner/load-data-spinner";
import FilterStepper from "../components/filter-stepper/filter-stepper";
import AuthorsFilter from "../components/authors-filter/authors-filter";
import AreasFilter from "../components/areas-filter/areas-filter";
import ReasonsFilter from "../components/reasons-filter/reasons-filter";

const mapStateToProps = (state, props) => ({
	rework: state.get("rework"),
});



const mapDispatchToProps = dispatch => ({
	updateFilterField: (rework, fieldName) => pipe(
		toString,
		set(fieldName, __, get("filter", rework)),
		applyFilter,
		dispatch,
	),
	removeFilterField: (rework, fieldName) => pipe(
		always(rework),
		get("filter"),
		deleteField(fieldName),
		applyFilter,
		dispatch,
	),
	onSelectAll: (rework, fieldName) => pipe(
		always(rework),
		get("filter"),
		deleteField(fieldName),
		setFilter,
		dispatch
	),
	onSetStep: rework => step => pipe(
		setStep,
		dispatch,
		always(get("filter", rework)),
		cond([
			[always(step === 0) , pipe(deleteField("areas"), deleteField("authors"))],
			[always(step === 1), deleteField("areas")],
			[filter => step === 2 && !isNil(get("areas", filter)),
				update("areas", reduce((acc, _, areaName) => set(areaName, new Map(), acc) , new Map()))],
			[T, identity]
		]),
		applyFilter,
		dispatch
	)(step),
	onSetFilter: pipe(
		setFilter,
		dispatch,
	),
	onSetFilterField: (rework, fieldName) => pipe(
		set(fieldName, __, get("filter", rework)),
		setFilter,
		dispatch,
	),
	onApplyFilter: pipe(
		applyFilter,
		dispatch
	)
});

const enhance = composeEnhances(
	setDisplayName("ReworkDashboardPage"),
	onlyUpdateForPropTypes,
	setPropTypes({
		rework: IPropTypes.map,

		updateFilterField: PropTypes.func,
		removeFilterField: PropTypes.func,
		onSetStep: PropTypes.func,
		onSetFilter: PropTypes.func,
		onSetFilterField: PropTypes.func,
		onSelectAll: PropTypes.func,
		onApplyFilter: PropTypes.func,
	}),
	connect(mapStateToProps, mapDispatchToProps)
);

const ReworkDashboardPage = enhance(({
	rework,

	updateFilterField,
	removeFilterField,
	onSetStep,
	onSetFilter,
	onSetFilterField,
	onSelectAll,
	onApplyFilter
}) => (
		<div className="rework-dashboard-page">
			<div className="row">
				<LoadDataSpinner loading={ get("loading", rework) }/>

				<DateRangeFilter
					fromDate={ getIn(["filter", "fromDate"], rework) }
					toDate={ getIn(["filter", "toDate"], rework) }
					onChangeFromDate={ updateFilterField(rework, "fromDate") }
					onChangeToDate={ updateFilterField(rework, "toDate") }
					removeFromDate={ removeFilterField(rework, "fromDate") }
					removeToDate={ removeFilterField(rework, "toDate") } />
				<FilterStepper step={ get("step", rework) } onSetStep={ onSetStep(rework) }/>


				{ cond([
					[equals(1), always(
						<AreasFilter
							areas={ getIn(["statistic", "areas"], rework) }
							selectedAreas={ getIn(["filter", "areas"], rework)}
							onSelectAll={ onSelectAll(rework, "areas") }
							onUnselectAll={ _ => onSetFilterField(rework, "areas")(new Map()) }
							onSelectAreas={
								areas => pipe(
									get("filter"),
									set("areas", areas),
									onSetFilter
								)(rework)
							} />
					)],
					[equals(2), always(
						<ReasonsFilter
							areas={ getIn(["statistic", "areas"], rework) }
							selectedAreas={ getIn(["filter", "areas"], rework)}
							onSelectAreas={
								areas => pipe(
									get("filter"),
									set("areas", areas),
									onSetFilter
								)(rework)
							} />
					)],
					[equals(3), always(
						<ReworkList
							reworkList={ get("reworkList", rework) } />
					)],
					[T, always(
						<AuthorsFilter
							authors={ getIn(["statistic", "authors"], rework) }
							selectedAuthors={ getIn(["filter", "authors"], rework) }
							onSelectAll={ onSelectAll(rework, "authors") }
							onUnselectAll={ _ => onSetFilterField(rework, "authors")(new List()) }
							onSelectAuthors={
								authors => pipe(
									get("filter"),
									set("authors", authors),
									onSetFilter
								)(rework)
							} />
					)],
				])(get("step", rework) || 0) }

				<ReworkNavigation
					className="left"
					step={ get("step", rework) }
					setStep={ onSetStep(rework) }/>
			</div>
		</div>
	)
);

export default ReworkDashboardPage;