bencripps / react-redux-grid

import { fromJS } from 'immutable';

import {

    EDIT_ROW,

    DISMISS_EDITOR,

    ROW_VALUE_CHANGE,

    CANCEL_ROW,

    REMOVE_ROW,

    REPOSITION_EDITOR

} from '../../../constants/ActionTypes';

import {

    getData,

    setDataAtDataIndex,

} from './../../../util/getData';

import { generateLastUpdate } from './../../../util/lastUpdate';

    lastUpdate: generateLastUpdate()

});

export const isCellValid = ({ validator }, value, values) => {

    if (!validator || !typeof validator === 'function') {

        return true;

    }

    return validator({ value, values });

};

export const isRowValid = (columns, rowValues) => {

    for (let i = 0; i < columns.length; i++) {

        const col = columns[i];

        const val = isCellValid(col, getData(rowValues, columns, i), rowValues);

        if (!val) {

            return false;

        }

    }

    return true;

};

export const setDisabled = (col = {}, value, values) => {

    if (col.disabled === true || col.disabled === 'false') {

        return col.disabled;

    }

    if (typeof col.disabled === 'function') {

        return col.disabled({ column: col, value, values });

    }

    return false;

};

export const handleChangeFunc = (col, rowValues) => {

    if (!col.change || !typeof col.change === 'function') {

        return rowValues;

    }

    const overrideValue = col.change({ values: rowValues }) || {};

    Object.keys(overrideValue).forEach(k => {

        rowValues[k] = overrideValue[k];

    });

    return rowValues;

};

export default function editor(state = initialState, action) {

    switch (action.type) {

    case EDIT_ROW:

        const { values } = action;

        const isValid = isRowValid(action.columns, values);

        const iOverrides = state.getIn([stateKey, 'row', 'overrides'])

            ? state.getIn([stateKey, 'row', 'overrides']).toJS()

            : {};

        action.columns.forEach((col, i) => {

            const val = getData(values, action.columns, i);

            const dataIndex = col.dataIndex;

            // setting disabled

            iOverrides[dataIndex] = iOverrides[dataIndex] || {};

            iOverrides[dataIndex].disabled = setDisabled(col, val, values);

        });

        return state.setIn([action.stateKey], fromJS({

            row: {

                key: action.rowId,

                values: action.values,

                rowIndex: action.rowIndex,

                top: action.top,

                valid: isValid,

                isCreate: action.isCreate || false,

                overrides: iOverrides

            },

            lastUpdate: generateLastUpdate()

        }));

    case ROW_VALUE_CHANGE:

        const { column, columns, value, stateKey } = action;

        const previousValues = state.getIn([stateKey, 'row', 'values'])

            ? state.getIn([stateKey, 'row', 'values']).toJS()

            : {};

        const overrides = state.getIn([stateKey, 'row', 'overrides'])

            ? state.getIn([stateKey, 'row', 'overrides']).toJS()

            : {};

        let rowValues = setDataAtDataIndex(

            previousValues, column.dataIndex, value

        );

        columns.forEach((col, i) => {

            const val = getData(rowValues, columns, i);

            const dataIndex = col.dataIndex;

            // interpreting `change func` to set final values

            // happens first, due to other validation

            rowValues = handleChangeFunc(col, rowValues);

            // setting default value

            if (col.defaultValue !== undefined

                && val === undefined || val === null) {

                setDataAtDataIndex(rowValues, dataIndex, col.defaultValue);

            }

            // setting disabled

            overrides[dataIndex] = overrides[dataIndex] || {};

            overrides[dataIndex].disabled = setDisabled(col, val, rowValues);

        });

        const valid = isRowValid(columns, rowValues);

        state = state.mergeIn([action.stateKey, 'row'], {

            values: rowValues,

            previousValues: state.getIn([stateKey, 'row', 'values']),

            valid,

            overrides

        });

        return state.setIn(

            [action.stateKey, 'lastUpdate'],

            generateLastUpdate()

        );

    case REPOSITION_EDITOR:

        const row = state.mergeIn([action.stateKey, 'row'], {

            top: action.top

        }).getIn([action.stateKey, 'row']);

        return state.mergeIn(

            [action.stateKey],

            fromJS({

                row: row,

                lastUpdate: generateLastUpdate()

            })

        );

    case REMOVE_ROW:

    case DISMISS_EDITOR:

    case CANCEL_ROW:

        return state.setIn(

            [action.stateKey],

            fromJS({ lastUpdate: generateLastUpdate() })

        );

    default:

        return state;

    }

}