src/Oro/Bundle/FilterBundle/Resources/public/js/filter/number-filter.js - Code Metrics - Inspection of "Merge remote-tracking branch 'remotes/dev/master'" - oroinc/platform - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — master ( ae6bbc...554531 )

unknown

created 2018-03-20 17:00 UTC

src/Oro/Bundle/FilterBundle/Resources/public/js/filter/number-filter.js B

↳ Parent: Project

Complexity

Total Complexity	36
Complexity/F	1.8

Size

Lines of Code	237
Function Count	20

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	0
wmc	36
nc	128
mnd	3
bc	33
fnc	20
dl	0
loc	237
rs	8.8
bpm	1.65
cpm	1.8
noi	2
c	0
b	0
f	0

define(function(require) {
    'use strict';

    var NumberFilter;

    var _ = require('underscore');
    var ChoiceFilter = require('./choice-filter');
    var NumberFormatter = require('orofilter/js/formatter/number-formatter');
    var __ = require('orotranslation/js/translator');
    var mediator = require('oroui/js/mediator');

    /**
     * Number filter: formats value as a number
     */
    NumberFilter = ChoiceFilter.extend({
        /**
         * @property {Boolean}
         */
        wrapHintValue: false,

        /**
         * @inheritDoc
         */
        constructor: function NumberFilter() {
            NumberFilter.__super__.constructor.apply(this, arguments);
        },

        /**
         * Initialize.
         *
         * @param {Object} options
         * @param {*} [options.formatter] Object with methods fromRaw and toRaw or
         *      a string name of formatter (e.g. "integer", "decimal")
         */
        initialize: function(options) {

            _.defaults(this, {
                formatterOptions: {},
                arraySeparator: ',',
                arrayOperators: [],
                dataType: 'data_integer'
            });

            this._filterArrayChoices();
            this.formatter = new NumberFormatter(this.formatterOptions);
            NumberFilter.__super__.initialize.apply(this, arguments);
        },

        /**
         * @inheritDoc
         */
        dispose: function() {
            if (this.disposed) {
                return;
            }
            delete this.formatter;
            NumberFilter.__super__.dispose.call(this);
        },

        _filterArrayChoices: function() {
            this.choices = _.filter(
                this.choices,
                _.bind(function(item) {
                    return this.dataType === 'data_integer' || !this._isArrayType(item.data);
                }, this)
            );
        },

        /**
         * @inheritDoc
         */
        _formatRawValue: function(value) {
            var formatted = _.clone(value);

            formatted.value = this._toRawValue(value.value);

            return formatted;
        },

        /**
         * @inheritDoc
         */
        _formatDisplayValue: function(value) {
            var formatted = _.clone(value);

            formatted.value = this._toDisplayValue(value.value);

            return formatted;
        },

        /**
         * @param {*} value
         * @return {*}
         */
        _toRawValue: function(value) {
            if (value === '') {
                value = undefined;
            }

            if (value !== undefined && this._isArrayTypeSelected()) {
                return this._formatArray(value);
            }

            if (value !== undefined) {
                value = this.formatter.toRaw(value);
            }

            return value;
        },

        /**
         * @param {*} value
         * @return {*}
         */
        _toDisplayValue: function(value) {
            if (value) {
                if (this._isArrayTypeSelected()) {
                    return this._formatArray(value);
                } else if (_.isString(value)) {
                    value = parseFloat(value);
                }
            }

            if (_.isNumber(value)) {
                value = this.formatter.fromRaw(value);
            }
            return value;
        },

        /**
         * @param {*} value
         * @return {String}
         */
        _formatArray: function(value) {
            return _.filter(
                _.map(
                    value.toString().split(this.arraySeparator),
                    function(number) {
                        return parseInt(number);
                    }
                ),
                function(number) {
                    return !isNaN(number);
                }
            ).join(this.arraySeparator);
        },

        /**
         * @return {Boolean}
         */
        _isArrayTypeSelected: function() {
            return this._isArrayType(this._readDOMValue().type);
        },

        /**
         * @return {Boolean}
         */
        _isArrayType: function(type) {
            return _.contains(this.arrayOperators, parseInt(type) || 0);
        },

        /**
         * @inheritDoc
         */
        _writeDOMValue: function(data) {
            var value = _.isString(data.value) ? this.formatter.toRaw(data.value) : data.value;
            this._setInputValue(this.criteriaValueSelectors.value, value);
            this._setInputValue(this.criteriaValueSelectors.type, data.type);
            return this;
        },

        /**
         * @inheritDoc
         * @returns {boolean}
         * @private
         */
        _isValid: function() {
            var rawValue = this.formatter.toRaw(this._readDOMValue().value);
            var validValue = rawValue === void 0 || this._checkNumberRules(rawValue);


            if (!validValue) {
                return false;
            } else {
                return NumberFilter.__super__._isValid.apply(this, arguments);
            }
        },

        /**
         *
         * @param value
         * @returns {boolean}
         * @private
         */
        _checkNumberRules: function(value) {
            if (_.isUndefined(value)) {
                return true;
            }

            var result = true;

            if (!_.isNumber(value) || _.isNaN(value)) {
                this._showNumberWarning();
                result = false;
            }

            if (this.formatter.percent && value > 100) {
                this._showMaxPercentWarning();
                result = false;
            }

            return result;
        },

        /**
         * @private
         */
        _showNumberWarning: function() {
            mediator.execute(
                'showFlashMessage',
                'warning',
                __('oro.form.number.nan')
            );
        },

        /**
         * @private
         */
        _showMaxPercentWarning: function() {
            mediator.execute(
                'showFlashMessage',
                'warning',
                __('This value should be {{ limit }} or less.', {limit: 100})
            );
        }
    });

    return NumberFilter;
});


1			define(function(require) {
2			'use strict';
3
4			var NumberFilter;
5
6			var _ = require('underscore');
7			var ChoiceFilter = require('./choice-filter');
8			var NumberFormatter = require('orofilter/js/formatter/number-formatter');
9			var __ = require('orotranslation/js/translator');
10			var mediator = require('oroui/js/mediator');
11
12			/**
13			* Number filter: formats value as a number
14			*/
15			NumberFilter = ChoiceFilter.extend({
16			/**
17			* @property {Boolean}
18			*/
19			wrapHintValue: false,
20
21			/**
22			* @inheritDoc
23			*/
24			constructor: function NumberFilter() {
25			NumberFilter.__super__.constructor.apply(this, arguments);
26			},
27
28			/**
29			* Initialize.
30			*
31			* @param {Object} options
32			* @param {*} [options.formatter] Object with methods fromRaw and toRaw or
33			* a string name of formatter (e.g. "integer", "decimal")
34			*/
35			initialize: function(options) {
			0 ignored issues – show Unused Code introduced 2018-03-20 17:04 UTC by Report Bug Copy Issue Report The parameter `options` is not used and could be removed. This check looks for parameters in functions that are not used in the function body and are not followed by other parameters which are used inside the function. Loading history...
36			_.defaults(this, {
37			formatterOptions: {},
38			arraySeparator: ',',
39			arrayOperators: [],
40			dataType: 'data_integer'
41			});
42
43			this._filterArrayChoices();
44			this.formatter = new NumberFormatter(this.formatterOptions);
45			NumberFilter.__super__.initialize.apply(this, arguments);
46			},
47
48			/**
49			* @inheritDoc
50			*/
51			dispose: function() {
52			if (this.disposed) {
53			return;
54			}
55			delete this.formatter;
56			NumberFilter.__super__.dispose.call(this);
57			},
58
59			_filterArrayChoices: function() {
60			this.choices = _.filter(
61			this.choices,
62			_.bind(function(item) {
63			return this.dataType === 'data_integer' \|\| !this._isArrayType(item.data);
64			}, this)
65			);
66			},
67
68			/**
69			* @inheritDoc
70			*/
71			_formatRawValue: function(value) {
72			var formatted = _.clone(value);
73
74			formatted.value = this._toRawValue(value.value);
75
76			return formatted;
77			},
78
79			/**
80			* @inheritDoc
81			*/
82			_formatDisplayValue: function(value) {
83			var formatted = _.clone(value);
84
85			formatted.value = this._toDisplayValue(value.value);
86
87			return formatted;
88			},
89
90			/**
91			* @param {*} value
92			* @return {*}
93			*/
94			_toRawValue: function(value) {
95			if (value === '') {
96			value = undefined;
97			}
98
99			if (value !== undefined && this._isArrayTypeSelected()) {
100			return this._formatArray(value);
101			}
102
103			if (value !== undefined) {
104			value = this.formatter.toRaw(value);
105			}
106
107			return value;
108			},
109
110			/**
111			* @param {*} value
112			* @return {*}
113			*/
114			_toDisplayValue: function(value) {
115			if (value) {
116			if (this._isArrayTypeSelected()) {
117			return this._formatArray(value);
118			} else if (_.isString(value)) {
119			value = parseFloat(value);
120			}
121			}
122
123			if (_.isNumber(value)) {
124			value = this.formatter.fromRaw(value);
125			}
126			return value;
127			},
128
129			/**
130			* @param {*} value
131			* @return {String}
132			*/
133			_formatArray: function(value) {
134			return _.filter(
135			_.map(
136			value.toString().split(this.arraySeparator),
137			function(number) {
138			return parseInt(number);
139			}
140			),
141			function(number) {
142			return !isNaN(number);
143			}
144			).join(this.arraySeparator);
145			},
146
147			/**
148			* @return {Boolean}
149			*/
150			_isArrayTypeSelected: function() {
151			return this._isArrayType(this._readDOMValue().type);
152			},
153
154			/**
155			* @return {Boolean}
156			*/
157			_isArrayType: function(type) {
158			return _.contains(this.arrayOperators, parseInt(type) \|\| 0);
159			},
160
161			/**
162			* @inheritDoc
163			*/
164			_writeDOMValue: function(data) {
165			var value = _.isString(data.value) ? this.formatter.toRaw(data.value) : data.value;
166			this._setInputValue(this.criteriaValueSelectors.value, value);
167			this._setInputValue(this.criteriaValueSelectors.type, data.type);
168			return this;
169			},
170
171			/**
172			* @inheritDoc
173			* @returns {boolean}
174			* @private
175			*/
176			_isValid: function() {
177			var rawValue = this.formatter.toRaw(this._readDOMValue().value);
178			var validValue = rawValue === void 0 \|\| this._checkNumberRules(rawValue);
			0 ignored issues – show Coding Style introduced 2018-03-20 17:04 UTC by Report Bug Copy Issue Report Consider using `undefined` instead of `void(0)`. It is equivalent and more straightforward to read. Loading history...
179
180			if (!validValue) {
181			return false;
182			} else {
183			return NumberFilter.__super__._isValid.apply(this, arguments);
184			}
185			},
186
187			/**
188			*
189			* @param value
190			* @returns {boolean}
191			* @private
192			*/
193			_checkNumberRules: function(value) {
194			if (_.isUndefined(value)) {
195			return true;
196			}
197
198			var result = true;
199
200			if (!_.isNumber(value) \|\| _.isNaN(value)) {
201			this._showNumberWarning();
202			result = false;
203			}
204
205			if (this.formatter.percent && value > 100) {
206			this._showMaxPercentWarning();
207			result = false;
208			}
209
210			return result;
211			},
212
213			/**
214			* @private
215			*/
216			_showNumberWarning: function() {
217			mediator.execute(
218			'showFlashMessage',
219			'warning',
220			__('oro.form.number.nan')
221			);
222			},
223
224			/**
225			* @private
226			*/
227			_showMaxPercentWarning: function() {
228			mediator.execute(
229			'showFlashMessage',
230			'warning',
231			__('This value should be {{ limit }} or less.', {limit: 100})
232			);
233			}
234			});
235
236			return NumberFilter;
237			});
238

oroinc / platform

Push — master ( ae6bbc...554531 )

src/Oro/Bundle/FilterBundle/Resources/public/js/filter/number-filter.js B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like