src/actions/GridActions.js - Code Metrics - Inspection of "Merge pull request #54 from taco/feature/tree-dnd" - bencripps/react-redux-grid - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6efc01...f24beb )

by Benjamin

created 2016-09-26 18:21 UTC

src/actions/GridActions.js B

↳ Parent: Project

Complexity

Total Complexity	49
Complexity/F	2.13

Size

Lines of Code	429
Function Count	23

Duplication

Duplicated Lines	46
Ratio	10.72 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
cc	0
wmc	49
c	2
b	0
f	1
nc	1
mnd	4
bc	49
fnc	23
dl	46
loc	429
rs	8.5454
bpm	2.1304
cpm	2.1304
noi	3

12 Functions

Rating	Name	Duplication	Size	Complexity
A	GridActions.js ➔ setTreeNodeVisibility	0	11	1
A	GridActions.js ➔ setData	0	3	1
A	GridActions.js ➔ doLocalSort	0	3	1
A	GridActions.js ➔ moveNode	0	11	1
A	GridActions.js ➔ setColumnVisibility	0	15	1
A	GridActions.js ➔ setColumns	0	13	2
A	GridActions.js ➔ setSortDirection	0	23	1
B	GridActions.js ➔ getAsyncData	0	161	1
B	GridActions.js ➔ doRemoteSort	46	94	1
A	GridActions.js ➔ setHeaderVisibility	0	3	1
B	GridActions.js ➔ resizeColumns	0	26	1
B	GridActions.js ➔ setTreeData	0	32	3

How to fix Duplicated Code Complexity

import {
    ERROR_OCCURRED,
    HIDE_HEADER,
    MOVE_NODE,
    RESIZE_COLUMNS,
    SET_COLUMNS,
    SET_DATA,
    SET_SORT_DIRECTION,
    SET_TREE_DATA_PARTIAL,
    SET_TREE_NODE_VISIBILITY,
    SORT_DATA
} from '../constants/ActionTypes';

import { setLoaderState } from '../actions/plugins/loader/LoaderActions';

import { dismissEditor } from '../actions/plugins/editor/EditorActions';

import { keyGenerator } from '../util/keyGenerator';

import { treeToFlatList } from '../util/treeToFlatList';

import Request from '../components/plugins/ajax/Request';

export function getAsyncData({
    stateKey, dataSource, type, showTreeRootNode, extraParams = {}
}) {

    return (dispatch) => {

        dispatch(dismissEditor({ stateKey }));

        dispatch(
            setLoaderState({state: true, stateKey })
        );

        if (typeof dataSource === 'function') {

            // passing extraParams.parentId
            // to custom func so they can do partial
            // loading
            dataSource(extraParams).then((response) => {

                if (response && response.data) {

                    dispatch(
                        setLoaderState({ state: false, stateKey })
                    );

                    if (type !== 'tree') {

                        dispatch({
                            type: SET_DATA,
                            data: response.data,
                            total: response.total,
                            currentRecords: response.data,
                            success: true,
                            stateKey
                        });
                    }

                    else {
                        // upon the return of read
                        // response needs to clarify
                        // whether this is a partial update
                        dispatch(setTreeData({
                            data: response.data,
                            stateKey,
                            showTreeRootNode,
                            parentId: extraParams.parentId,
                            partial: response.partial
                        }));
                    }

                    return;
                }

                if (response && !response.data) {
                    /* eslint-disable no-console */
                    console.warn(
                        `A response was recieved
                         but no data entry was found`
                    );
                    console.warn(
                        `Please see
                         https://github.com/bencripps/react-redux-grid
                         for documentation`
                    );
                    /* eslint-enable no-console */
                }

                dispatch(
                    setLoaderState({ state: false, stateKey })
                );

                dispatch({
                    type: ERROR_OCCURRED,
                    error: 'Unable to Retrieve Grid Data',
                    errorOccurred: true,
                    stateKey
                });

            });

        }

        else if (typeof dataSource === 'string') {
function isBig(a) {
    if (a > 5000) {
        return "yes";
    }
}

console.log(isBig(5001)); //returns yes
console.log(isBig(42)); //returns undefined

            if (type !== 'tree') {

                return Request.api({
                    route: dataSource,
                    method: 'GET'
                }).then((response) => {

                    if (response && response.data) {

                        dispatch({
                            type: SET_DATA,
                            data: response.data,
                            total: response.total,
                            currentRecords: response.data,
                            success: true,
                            stateKey
                        });

                    }

                    else {
                        dispatch({
                            type: ERROR_OCCURRED,
                            error: 'Unable to Retrieve Grid Data',
                            errorOccurred: true,
                            stateKey
                        });
                    }

                    dispatch(
                        setLoaderState({state: false, stateKey })
                    );
                });

            }

            else {

                return Request.api({
                    route: dataSource,
                    method: 'GET',
                    queryStringParams: {
                        parentId: extraParams.parentId
                    }
                }).then((response) => {

                    if (response && response.data) {

                        // response needs to specify
                        // whether this is full or partial update
                        dispatch(setTreeData({
                            data: response.data,
                            stateKey,
                            showTreeRootNode,
                            partial: response.partial,
                            parentId: extraParams.parentId
                        }));

                    }

                    else {
                        dispatch({
                            type: ERROR_OCCURRED,
                            error: 'Unable to Retrieve Grid Data',
                            errorOccurred: true,
                            stateKey
                        });
                    }

                    dispatch(
                        setLoaderState({state: false, stateKey })
                    );
                });
            }
        }

    };
}

export function setColumns({ columns, stateKey, stateful }) {

    let cols = columns;

    if (!cols[0].id) {
        cols = columns.map((col) => {
            col.id = keyGenerator(col.name, 'grid-column');
            return col;
        });
    }

    return { type: SET_COLUMNS, columns: cols, stateKey, stateful };
}

export function setSortDirection({
    columns, id, sortDirection, stateKey
}) {

    let cols = columns;


    cols = columns.map((col) => {

        if (col.id === id) {
            col.sortDirection = sortDirection;
        }

        else {
            // to do: remove this if we want to build
            // up the sorts
            col.sortDirection = null;
        }

        return col;
    });

    return { type: SET_SORT_DIRECTION, columns: cols, stateKey };
}

export function doLocalSort({ data, stateKey }) {
    return { type: SORT_DATA, data, stateKey };
}

export function doRemoteSort(
    { dataSource, pageIndex, pageSize, sortParams, stateKey }
) {

    return (dispatch) => {

        dispatch(
            setLoaderState({state: true, stateKey })
        );


        if (typeof dataSource === 'function') {
            return dataSource({}, {}, sortParams).then((response) => {

                if (response && response.data) {

                    dispatch({
                        type: SET_DATA,
                        data: response.data,
                        total: response.total,
                        currentRecords: response.data,
                        success: true,
                        stateKey
                    });

                }

                else {

                    if (response && !response.data) {
                        /* eslint-disable no-console */
                        console.warn(
                            `A response was recieved but no data
                             entry was found`
                        );
                        console.warn(
                            `Please see
                             https://github.com/bencripps/react-redux-grid
                             for documentation`
                        );
                        /* eslint-enable no-console */
                    }

                    dispatch({
                        type: ERROR_OCCURRED,
                        error: 'Unable to Retrieve Grid Data',
                        errorOccurred: true,
                        stateKey
                    });
                }

                dispatch(
                    setLoaderState({state: false, stateKey })
                );
            });

        }

        return Request.api({
            route: dataSource,
            method: 'POST',
            data: {
                pageIndex: pageIndex,
                pageSize: pageSize,
                sort: sortParams.sort
            }
        }).then((response) => {

            if (response && response.data) {

                dispatch({
                    type: SET_DATA,
                    data: response.data,
                    total: response.total,
                    currentRecords: response.data,
                    success: true
                });

            }

            else {
                dispatch({
                    type: ERROR_OCCURRED,
                    error: 'Unable to Retrieve Grid Data',
                    errorOccurred: true
                });
            }

            dispatch(
                setLoaderState({state: false, stateKey })
            );
        });

    };
}

export function setColumnVisibility({
 columns, column, isHidden, stateKey, stateful
}) {
    const hidden = !isHidden;

    const columnsArr = columns.map((col) => {
        if (col.name === column.name) {
            col.hidden = hidden;
        }

        return col;
    });

    return { type: SET_COLUMNS, columns: columnsArr, stateKey, stateful };
}

export function resizeColumns({
    width, id, nextColumn, columns, stateKey, stateful
}) {

    const cols = columns.map((col) => {

        if (col.id === id) {
            col.width = `${width}%`;
        }

        else if (col.id === nextColumn.id) {
            col.width = `${nextColumn.width}%`;
        }

        return col;

    });

    return {
        type: RESIZE_COLUMNS,
        stateKey,
        columns: cols,
        stateful
    };

}

export function setData({ data, stateKey }) {
    return { type: SET_DATA, data, stateKey };
}

export function setTreeData({
    data, stateKey, showTreeRootNode, partial, parentId
}) {

    // if this is a partial update to
    // a tree grid, dispatch separate action;
    if (partial) {
        return {
            type: SET_TREE_DATA_PARTIAL,
            data: data,
            stateKey,
            gridType: 'tree',
            showTreeRootNode,
            parentId
        };
    }

    const flat = treeToFlatList(data);

    // remove root node
    if (!showTreeRootNode) {
        flat.shift();
    }

    return {
        type: SET_DATA,
        data: flat,
        stateKey,
        gridType: 'tree',
        treeData: data
    };
}

export function setTreeNodeVisibility({
    id, visible, stateKey, showTreeRootNode
}) {
    return {
        type: SET_TREE_NODE_VISIBILITY,
        id,
        visible,
        stateKey,
        showTreeRootNode
    };
}

export function moveNode({
    stateKey, current, next, showTreeRootNode
}) {
    return {
        type: MOVE_NODE,
        stateKey,
        current,
        next,
        showTreeRootNode
    };
}

export function setHeaderVisibility({ hidden, stateKey }) {
    return { type: HIDE_HEADER, headerHidden: hidden, stateKey };
}


1		import {
2		ERROR_OCCURRED,
3		HIDE_HEADER,
4		MOVE_NODE,
5		RESIZE_COLUMNS,
6		SET_COLUMNS,
7		SET_DATA,
8		SET_SORT_DIRECTION,
9		SET_TREE_DATA_PARTIAL,
10		SET_TREE_NODE_VISIBILITY,
11		SORT_DATA
12		} from '../constants/ActionTypes';
13
14		import { setLoaderState } from '../actions/plugins/loader/LoaderActions';
15
16		import { dismissEditor } from '../actions/plugins/editor/EditorActions';
17
18		import { keyGenerator } from '../util/keyGenerator';
19
20		import { treeToFlatList } from '../util/treeToFlatList';
21
22		import Request from '../components/plugins/ajax/Request';
23
24		export function getAsyncData({
25		stateKey, dataSource, type, showTreeRootNode, extraParams = {}
26		}) {
27
28		return (dispatch) => {
29
30		dispatch(dismissEditor({ stateKey }));
31
32		dispatch(
33		setLoaderState({state: true, stateKey })
34		);
35
36		if (typeof dataSource === 'function') {
37
38		// passing extraParams.parentId
39		// to custom func so they can do partial
40		// loading
41		dataSource(extraParams).then((response) => {
42
43		if (response && response.data) {
44
45		dispatch(
46		setLoaderState({ state: false, stateKey })
47		);
48
49		if (type !== 'tree') {
50
51		dispatch({
52		type: SET_DATA,
53		data: response.data,
54		total: response.total,
55		currentRecords: response.data,
56		success: true,
57		stateKey
58		});
59		}
60
61		else {
62		// upon the return of read
63		// response needs to clarify
64		// whether this is a partial update
65		dispatch(setTreeData({
66		data: response.data,
67		stateKey,
68		showTreeRootNode,
69		parentId: extraParams.parentId,
70		partial: response.partial
71		}));
72		}
73
74		return;
75		}
76
77		if (response && !response.data) {
78		/* eslint-disable no-console */
79		console.warn(
80		`A response was recieved
81		but no data entry was found`
82		);
83		console.warn(
84		`Please see
85		https://github.com/bencripps/react-redux-grid
86		for documentation`
87		);
88		/* eslint-enable no-console */
89		}
90
91		dispatch(
92		setLoaderState({ state: false, stateKey })
93		);
94
95		dispatch({
96		type: ERROR_OCCURRED,
97		error: 'Unable to Retrieve Grid Data',
98		errorOccurred: true,
99		stateKey
100		});
101
102		});
		0 ignored issues – show Best Practice introduced 2016-08-21 15:46 UTC by Report Bug Copy Issue Report There is no `return` statement in this branch, but you do return something in other branches. Did you maybe miss it? If you do not want to return anything, consider adding `return undefined;` explicitly. Loading history...
103		}
104
105		else if (typeof dataSource === 'string') {
		0 ignored issues – show Complexity Best Practice introduced 2016-08-21 15:46 UTC by Report Bug Copy Issue Report There is no return statement if `typeof dataSource === "string"` is `false`. Are you sure this is correct? If so, consider adding `return;` explicitly. This check looks for functions where a `return` statement is found in some execution paths, but not in all. Consider this little piece of code function isBig(a) { if (a > 5000) { return "yes"; } } console.log(isBig(5001)); //returns yes console.log(isBig(42)); //returns undefined The function `isBig` will only return a specific value when its parameter is bigger than 5000. In any other case, it will implicitly return `undefined`. This behaviour may not be what you had intended. In any case, you can add a `return undefined` to the other execution path to make the return value explicit. Loading history...
106
107		if (type !== 'tree') {
108
109		return Request.api({
110		route: dataSource,
111		method: 'GET'
112		}).then((response) => {
113
114		if (response && response.data) {
115
116		dispatch({
117		type: SET_DATA,
118		data: response.data,
119		total: response.total,
120		currentRecords: response.data,
121		success: true,
122		stateKey
123		});
124
125		}
126
127		else {
128		dispatch({
129		type: ERROR_OCCURRED,
130		error: 'Unable to Retrieve Grid Data',
131		errorOccurred: true,
132		stateKey
133		});
134		}
135
136		dispatch(
137		setLoaderState({state: false, stateKey })
138		);
139		});
140
141		}
142
143		else {
144
145		return Request.api({
146		route: dataSource,
147		method: 'GET',
148		queryStringParams: {
149		parentId: extraParams.parentId
150		}
151		}).then((response) => {
152
153		if (response && response.data) {
154
155		// response needs to specify
156		// whether this is full or partial update
157		dispatch(setTreeData({
158		data: response.data,
159		stateKey,
160		showTreeRootNode,
161		partial: response.partial,
162		parentId: extraParams.parentId
163		}));
164
165		}
166
167		else {
168		dispatch({
169		type: ERROR_OCCURRED,
170		error: 'Unable to Retrieve Grid Data',
171		errorOccurred: true,
172		stateKey
173		});
174		}
175
176		dispatch(
177		setLoaderState({state: false, stateKey })
178		);
179		});
180		}
181		}
182
183		};
184		}
185
186		export function setColumns({ columns, stateKey, stateful }) {
187
188		let cols = columns;
189
190		if (!cols[0].id) {
191		cols = columns.map((col) => {
192		col.id = keyGenerator(col.name, 'grid-column');
193		return col;
194		});
195		}
196
197		return { type: SET_COLUMNS, columns: cols, stateKey, stateful };
198		}
199
200		export function setSortDirection({
201		columns, id, sortDirection, stateKey
202		}) {
203
204		let cols = columns;
		0 ignored issues – show Unused Code introduced 2016-09-08 18:04 UTC by Report Bug Copy Issue Report The assignment to variable `cols` seems to be never used. Consider removing it. Loading history...
205
206		cols = columns.map((col) => {
207
208		if (col.id === id) {
209		col.sortDirection = sortDirection;
210		}
211
212		else {
213		// to do: remove this if we want to build
214		// up the sorts
215		col.sortDirection = null;
216		}
217
218		return col;
219		});
220
221		return { type: SET_SORT_DIRECTION, columns: cols, stateKey };
222		}
223
224		export function doLocalSort({ data, stateKey }) {
225		return { type: SORT_DATA, data, stateKey };
226		}
227
228		export function doRemoteSort(
229		{ dataSource, pageIndex, pageSize, sortParams, stateKey }
230		) {
231
232		return (dispatch) => {
233
234		dispatch(
235		setLoaderState({state: true, stateKey })
236		);
237	View Code Duplication
		0 ignored issues – show Duplication introduced 2016-08-21 15:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
238		if (typeof dataSource === 'function') {
239		return dataSource({}, {}, sortParams).then((response) => {
240
241		if (response && response.data) {
242
243		dispatch({
244		type: SET_DATA,
245		data: response.data,
246		total: response.total,
247		currentRecords: response.data,
248		success: true,
249		stateKey
250		});
251
252		}
253
254		else {
255
256		if (response && !response.data) {
257		/* eslint-disable no-console */
258		console.warn(
259		`A response was recieved but no data
260		entry was found`
261		);
262		console.warn(
263		`Please see
264		https://github.com/bencripps/react-redux-grid
265		for documentation`
266		);
267		/* eslint-enable no-console */
268		}
269
270		dispatch({
271		type: ERROR_OCCURRED,
272		error: 'Unable to Retrieve Grid Data',
273		errorOccurred: true,
274		stateKey
275		});
276		}
277
278		dispatch(
279		setLoaderState({state: false, stateKey })
280		);
281		});
282
283		}
284
285		return Request.api({
286		route: dataSource,
287		method: 'POST',
288		data: {
289		pageIndex: pageIndex,
290		pageSize: pageSize,
291		sort: sortParams.sort
292		}
293		}).then((response) => {
294
295		if (response && response.data) {
296
297		dispatch({
298		type: SET_DATA,
299		data: response.data,
300		total: response.total,
301		currentRecords: response.data,
302		success: true
303		});
304
305		}
306
307		else {
308		dispatch({
309		type: ERROR_OCCURRED,
310		error: 'Unable to Retrieve Grid Data',
311		errorOccurred: true
312		});
313		}
314
315		dispatch(
316		setLoaderState({state: false, stateKey })
317		);
318		});
319
320		};
321		}
322
323		export function setColumnVisibility({
324		columns, column, isHidden, stateKey, stateful
325		}) {
326		const hidden = !isHidden;
327
328		const columnsArr = columns.map((col) => {
329		if (col.name === column.name) {
330		col.hidden = hidden;
331		}
332
333		return col;
334		});
335
336		return { type: SET_COLUMNS, columns: columnsArr, stateKey, stateful };
337		}
338
339		export function resizeColumns({
340		width, id, nextColumn, columns, stateKey, stateful
341		}) {
342
343		const cols = columns.map((col) => {
344
345		if (col.id === id) {
346		col.width = `${width}%`;
347		}
348
349		else if (col.id === nextColumn.id) {
350		col.width = `${nextColumn.width}%`;
351		}
352
353		return col;
354
355		});
356
357		return {
358		type: RESIZE_COLUMNS,
359		stateKey,
360		columns: cols,
361		stateful
362		};
363
364		}
365
366		export function setData({ data, stateKey }) {
367		return { type: SET_DATA, data, stateKey };
368		}
369
370		export function setTreeData({
371		data, stateKey, showTreeRootNode, partial, parentId
372		}) {
373
374		// if this is a partial update to
375		// a tree grid, dispatch separate action;
376		if (partial) {
377		return {
378		type: SET_TREE_DATA_PARTIAL,
379		data: data,
380		stateKey,
381		gridType: 'tree',
382		showTreeRootNode,
383		parentId
384		};
385		}
386
387		const flat = treeToFlatList(data);
388
389		// remove root node
390		if (!showTreeRootNode) {
391		flat.shift();
392		}
393
394		return {
395		type: SET_DATA,
396		data: flat,
397		stateKey,
398		gridType: 'tree',
399		treeData: data
400		};
401		}
402
403		export function setTreeNodeVisibility({
404		id, visible, stateKey, showTreeRootNode
405		}) {
406		return {
407		type: SET_TREE_NODE_VISIBILITY,
408		id,
409		visible,
410		stateKey,
411		showTreeRootNode
412		};
413		}
414
415		export function moveNode({
416		stateKey, current, next, showTreeRootNode
417		}) {
418		return {
419		type: MOVE_NODE,
420		stateKey,
421		current,
422		next,
423		showTreeRootNode
424		};
425		}
426
427		export function setHeaderVisibility({ hidden, stateKey }) {
428		return { type: HIDE_HEADER, headerHidden: hidden, stateKey };
429		}
430

bencripps / react-redux-grid

GitHub Access Token became invalid

Push — master ( 6efc01...f24beb )

src/actions/GridActions.js B

Complexity

Size

Duplication

Importance

12 Functions

How to fix Duplicated Code Complexity

Duplicated Code

Complexity

Duplication Side-by-Side

Filter issues like