maestrano/mno-enterprise

View on GitHub
frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js

Summary

Maintainability
F
1 mo
Test Coverage

File ui-bootstrap-tpls-0.13.4.js has 4537 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*
 * angular-ui-bootstrap
 * http://angular-ui.github.io/bootstrap/

 * Version: 0.13.4 - 2015-09-03

    Function link has 275 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

          link: function(originalScope, element, attrs, ctrls) {
            var modelCtrl = ctrls[0];
            var ngModelOptions = ctrls[1];
            //SUPPORTED ATTRIBUTES (OPTIONS)
    
    

      Function $get has 270 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        this.$get = ['$window', '$compile', '$timeout', '$document', '$position', '$interpolate', '$rootScope', '$parse', function($window, $compile, $timeout, $document, $position, $interpolate, $rootScope, $parse) {
          return function $tooltip(type, prefix, defaultTriggerShow, options) {
            options = angular.extend({}, defaultOptions, globalOptions, options);
      
            /**

        Function $tooltip has 268 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            return function $tooltip(type, prefix, defaultTriggerShow, options) {
              options = angular.extend({}, defaultOptions, globalOptions, options);
        
              /**
               * Returns an object of show and hide triggers.

          Function link has 248 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              link: function(scope, element, attrs, ngModel) {
                var dateFormat,
                    closeOnDateSelection = angular.isDefined(attrs.closeOnDateSelection) ? scope.$parent.$eval(attrs.closeOnDateSelection) : datepickerPopupConfig.closeOnDateSelection,
                    appendToBody = angular.isDefined(attrs.datepickerAppendToBody) ? scope.$parent.$eval(attrs.datepickerAppendToBody) : datepickerPopupConfig.appendToBody,
                    onOpenFocus = angular.isDefined(attrs.onOpenFocus) ? scope.$parent.$eval(attrs.onOpenFocus) : datepickerPopupConfig.onOpenFocus,

            Function compile has 236 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                    compile: function(tElem, tAttrs) {
                      var tooltipLinker = $compile( template );
            
                      return function link(scope, element, attrs, tooltipCtrl) {
                        var tooltip;

              Function link has 233 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                        return function link(scope, element, attrs, tooltipCtrl) {
                          var tooltip;
                          var tooltipLinkedScope;
                          var transitionTimeout;
                          var popupTimeout;

                Function $get has 99 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                        function ($injector, $rootScope, $q, $templateRequest, $controller, $modalStack) {
                          var $modal = {};
                
                          function getTemplatePromise(options) {
                            return options.template ? $q.when(options.template) :

                  Function link has 86 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      link: function(scope, element, attrs, ctrl) {
                        scope.showWeeks = ctrl.showWeeks;
                  
                        ctrl.step = { months: 1 };
                        ctrl.element = element;

                    Function open has 74 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                              $modal.open = function (modalOptions) {
                    
                                var modalResultDeferred = $q.defer();
                                var modalOpenedDeferred = $q.defer();
                                var modalRenderDeferred = $q.defer();

                      Function link has 62 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          link: function(scope, element, attrs, ctrls) {
                            var paginationCtrl = ctrls[0], ngModelCtrl = ctrls[1];
                      
                            if (!ngModelCtrl) {
                               return; // do nothing if no ng-model

                        Function positionElements has 58 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                              positionElements: function(hostEl, targetEl, positionStr, appendToBody) {
                                var positionStrParts = positionStr.split('-');
                                var pos0 = positionStrParts[0], pos1 = positionStrParts[1] || 'center';
                        
                                var hostElPos,

                          Function setupInputEvents has 57 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                            this.setupInputEvents = function(hoursInputEl, minutesInputEl) {
                              if ($scope.readonlyInput) {
                                $scope.updateHours = angular.noop;
                                $scope.updateMinutes = angular.noop;
                                return;

                            Function TabsetCtrl has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                            Open

                            .controller('TabsetController', ['$scope', function TabsetCtrl($scope) {
                              var ctrl = this,
                                  tabs = ctrl.tabs = $scope.tabs = [];
                            
                              ctrl.select = function(selectedTab) {

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function link has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                  link: function(scope, element, attrs) {
                                    element.addClass(attrs.windowClass || '');
                                    scope.size = attrs.size;
                            
                                    scope.close = function(evt) {

                              Function link has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  link: function(scope, elem, attrs) {
                                    var origScope = scope.$eval(attrs.tooltipTemplateTranscludeScope);
                              
                                    var changeCounter = 0,
                                      currentScope,

                                Function parse has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                  this.parse = function(input, format, baseDate) {
                                    if (!angular.isString(input) || !format) {
                                      return input;
                                    }
                                
                                

                                  Function createNew has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                        createNew: function() {
                                          var stack = [];
                                  
                                          return {
                                            add: function(key, value) {

                                    Function open has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                          $modalStack.open = function(modalInstance, modal) {
                                            var modalOpener = $document[0].activeElement,
                                              modalBodyClass = modal.openedClass || OPENED_MODAL_CLASS;
                                    
                                            openedWindows.add(modalInstance, {

                                      Function link has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                          link: function(scope, element, attrs, ctrl) {
                                            var range = ctrl.yearRange;
                                      
                                            ctrl.step = { years: range };
                                            ctrl.element = element;

                                        Function link has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            link: function(scope, element, attrs, ctrl) {
                                              ctrl.step = { years: 1 };
                                              ctrl.element = element;
                                        
                                              ctrl._refreshView = function() {

                                          Function link has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                                link: function(scope, element, attrs) {
                                                  function expand() {
                                                    element.removeClass('collapse')
                                                      .addClass('collapsing')
                                                      .attr('aria-expanded', true)

                                            Function createNew has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                                  createNew: function() {
                                                    var map = {};
                                            
                                                    return {
                                                      entries: function() {

                                              Function resolveSuccess has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                                            .then(function resolveSuccess(tplAndVars) {
                                              
                                                              var modalScope = (modalOptions.scope || $rootScope).$new();
                                                              modalScope.$close = modalInstance.close;
                                                              modalScope.$dismiss = modalInstance.dismiss;

                                                Function TabsetCtrl has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                .controller('TabsetController', ['$scope', function TabsetCtrl($scope) {
                                                  var ctrl = this,
                                                      tabs = ctrl.tabs = $scope.tabs = [];
                                                
                                                  ctrl.select = function(selectedTab) {

                                                  Function getMatchesAsync has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                          var getMatchesAsync = function(inputValue) {
                                                            var locals = {$viewValue: inputValue};
                                                            isLoadingSetter(originalScope, true);
                                                            isNoResultsSetter(originalScope, false);
                                                            $q.when(parserResult.source(originalScope, locals)).then(function(matches) {

                                                    Function _refreshView has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                    Open

                                                          ctrl._refreshView = function() {
                                                            var year = ctrl.activeDate.getFullYear(),
                                                              month = ctrl.activeDate.getMonth(),
                                                              firstDayOfMonth = new Date(year, month, 1),
                                                              difference = ctrl.startingDay - firstDayOfMonth.getDay(),

                                                      Function link has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                          link: function(scope, element, attrs, ctrls) {
                                                            var buttonsCtrl = ctrls[0], ngModelCtrl = ctrls[1];
                                                      
                                                            element.find('input').css({display: 'none'});
                                                      
                                                      

                                                        Function removeAfterAnimate has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                              function removeAfterAnimate(domEl, scope, done) {
                                                                var asyncDeferred;
                                                                var asyncPromise = null;
                                                                var setIsAsync = function() {
                                                                  if (!asyncDeferred) {

                                                          Function $transition has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                            var $transition = function(element, trigger, options) {
                                                              options = options || {};
                                                              var deferred = $q.defer();
                                                              var endEventName = $transition[options.animation ? 'animationEndEventName' : 'transitionEndEventName'];
                                                          
                                                          

                                                            Function getPages has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                                  function getPages(currentPage, totalPages) {
                                                                    var pages = [];
                                                            
                                                                    // Default page limits
                                                                    var startPage = 1, endPage = totalPages;

                                                              Function createTooltip has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                              Open

                                                                          function createTooltip() {
                                                                            // There can only be one tooltip element per directive shown at once.
                                                                            if (tooltip) {
                                                                              removeTooltip();
                                                                            }

                                                                Function link has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                Open

                                                                    link: function (scope, element, attrs, dropdownCtrl) {
                                                                
                                                                      element.bind('keydown', function(e) {
                                                                        if ([38, 40].indexOf(e.which) !== -1) {
                                                                          e.preventDefault();

                                                                  Function link has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                  Open

                                                                      link: function(scope, elm, attrs, tabsetCtrl, transclude) {
                                                                        scope.$watch('active', function(active) {
                                                                          if (active) {
                                                                            tabsetCtrl.select(scope);
                                                                          }

                                                                    Function goNext has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                    Open

                                                                      function goNext(slide, index, direction) {
                                                                        // Scope has been destroyed, stop here.
                                                                        if (destroyed) { return; }
                                                                    
                                                                        angular.extend(slide, {direction: direction, active: true});

                                                                      Function $get has 8 arguments (exceeds 4 allowed). Consider refactoring.
                                                                      Open

                                                                        this.$get = ['$window', '$compile', '$timeout', '$document', '$position', '$interpolate', '$rootScope', '$parse', function($window, $compile, $timeout, $document, $position, $interpolate, $rootScope, $parse) {

                                                                        Function $get has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                        Open

                                                                                function ($injector, $rootScope, $q, $templateRequest, $controller, $modalStack) {

                                                                          Function link has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                          Open

                                                                              link: function(scope, element, attr, accordionGroupCtrl, transclude) {

                                                                            Function link has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                            Open

                                                                                  link: function($scope, $element, $attrs, controller, $transclude) {

                                                                              Function link has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                              Open

                                                                                  link: function(scope, elm, attrs, tabsetCtrl, transclude) {

                                                                                Avoid too many return statements within this function.
                                                                                Open

                                                                                          return false;

                                                                                  Avoid too many return statements within this function.
                                                                                  Open

                                                                                            return undefined;

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        hoursInputEl.bind('keydown', function(e) {
                                                                                          if (e.which === 38) { // up
                                                                                            e.preventDefault();
                                                                                            $scope.incrementHours();
                                                                                            $scope.$apply();
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4638..4648

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 113.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        minutesInputEl.bind('keydown', function(e) {
                                                                                          if (e.which === 38) { // up
                                                                                            e.preventDefault();
                                                                                            $scope.incrementMinutes();
                                                                                            $scope.$apply();
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4626..4636

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 113.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                          $modalStack.close = function(modalInstance, result) {
                                                                                            var modalWindow = openedWindows.get(modalInstance);
                                                                                            if (modalWindow && broadcastClosing(modalWindow, result, true)) {
                                                                                              modalWindow.value.modalScope.$$uibDestructionScheduled = true;
                                                                                              modalWindow.value.deferred.resolve(result);
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 2810..2819

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 112.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                          $modalStack.dismiss = function(modalInstance, reason) {
                                                                                            var modalWindow = openedWindows.get(modalInstance);
                                                                                            if (modalWindow && broadcastClosing(modalWindow, reason, false)) {
                                                                                              modalWindow.value.modalScope.$$uibDestructionScheduled = true;
                                                                                              modalWindow.value.deferred.reject(reason);
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 2799..2808

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 112.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/datepicker/month.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/datepicker/month.html",
                                                                                        "<table role=\"grid\" aria-labelledby=\"{{::uniqueId}}-title\" aria-activedescendant=\"{{activeDateId}}\">\n" +
                                                                                        "  <thead>\n" +
                                                                                        "    <tr>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5576..5595

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 106.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/datepicker/year.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/datepicker/year.html",
                                                                                        "<table role=\"grid\" aria-labelledby=\"{{::uniqueId}}-title\" aria-activedescendant=\"{{activeDateId}}\">\n" +
                                                                                        "  <thead>\n" +
                                                                                        "    <tr>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5540..5559

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 106.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                scope.$on($modalStack.NOW_CLOSING_EVENT, function(e, setIsAsync) {
                                                                                                  var done = setIsAsync();
                                                                                                  if ($animateCss) {
                                                                                                    $animateCss(element, {
                                                                                                      removeClass: attrs.modalInClass
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 2445..2454

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 101.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            scope.$on($modalStack.NOW_CLOSING_EVENT, function(e, setIsAsync) {
                                                                                              var done = setIsAsync();
                                                                                              if ($animateCss) {
                                                                                                $animateCss(element, {
                                                                                                  removeClass: attrs.modalInClass
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 2518..2527

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 101.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            var shiftWidth = {
                                                                                              center: function() {
                                                                                                return hostElPos.left + hostElPos.width / 2 - targetElWidth / 2;
                                                                                              },
                                                                                              left: function() {
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1090..1100

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 87.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            var shiftHeight = {
                                                                                              center: function() {
                                                                                                return hostElPos.top + hostElPos.height / 2 - targetElHeight / 2;
                                                                                              },
                                                                                              top: function() {
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1078..1088

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 87.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/popover/popover.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/popover/popover.html",
                                                                                        "<div class=\"popover\"\n" +
                                                                                        "  tooltip-animation-class=\"fade\"\n" +
                                                                                        "  tooltip-classes\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5689..5703

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 86.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            if ($animateCss) {
                                                                                              $animateCss(element, {addClass: directionClass})
                                                                                                .start()
                                                                                                .done(removeClassFn);
                                                                                            } else {
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 730..741

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 86.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            if ($animateCss) {
                                                                                              $animateCss(element, {addClass: directionClass})
                                                                                                .start()
                                                                                                .done(removeClassFn);
                                                                                            } else {
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 758..769

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 86.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/popover/popover-html.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/popover/popover-html.html",
                                                                                        "<div class=\"popover\"\n" +
                                                                                        "  tooltip-animation-class=\"fade\"\n" +
                                                                                        "  tooltip-classes\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5723..5737

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 86.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        "<table>\n" +
                                                                                        "  <tbody>\n" +
                                                                                        "    <tr class=\"text-center\" ng-show=\"::showSpinners\">\n" +
                                                                                        "      <td><a ng-click=\"incrementHours()\" ng-class=\"{disabled: noIncrementHours()}\" class=\"btn btn-link\"><span class=\"glyphicon glyphicon-chevron-up\"></span></a></td>\n" +
                                                                                        "      <td>&nbsp;</td>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5516..5537

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 85.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        "<table role=\"grid\" aria-labelledby=\"{{::uniqueId}}-title\" aria-activedescendant=\"{{activeDateId}}\">\n" +
                                                                                        "  <thead>\n" +
                                                                                        "    <tr>\n" +
                                                                                        "      <th><button type=\"button\" class=\"btn btn-default btn-sm pull-left\" ng-click=\"move(-1)\" tabindex=\"-1\"><i class=\"glyphicon glyphicon-chevron-left\"></i></button></th>\n" +
                                                                                        "      <th colspan=\"{{::5 + showWeeks}}\"><button id=\"{{::uniqueId}}-title\" role=\"heading\" aria-live=\"assertive\" aria-atomic=\"true\" type=\"button\" class=\"btn btn-default btn-sm\" ng-click=\"toggleMode()\" ng-disabled=\"datepickerMode === maxMode\" tabindex=\"-1\" style=\"width:100%;\"><strong>{{title}}</strong></button></th>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5792..5813

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 85.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/datepicker/popup.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/datepicker/popup.html",
                                                                                        "<ul class=\"dropdown-menu\" ng-if=\"isOpen\" style=\"display: block\" ng-style=\"{top: position.top+'px', left: position.left+'px'}\" ng-keydown=\"keydown($event)\" ng-click=\"$event.stopPropagation()\">\n" +
                                                                                        " <li ng-transclude></li>\n" +
                                                                                        " <li ng-if=\"showButtonBar\" style=\"padding:10px 9px 2px\">\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5452..5465
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5775..5788

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 82.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/tabs/tabset.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/tabs/tabset.html",
                                                                                        "<div>\n" +
                                                                                        "  <ul class=\"nav nav-{{type || 'tabs'}}\" ng-class=\"{'nav-stacked': vertical, 'nav-justified': justified}\" ng-transclude></ul>\n" +
                                                                                        "  <div class=\"tab-content\">\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5452..5465
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5561..5574

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 82.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/accordion/accordion-group.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/accordion/accordion-group.html",
                                                                                        "<div class=\"panel {{panelClass || 'panel-default'}}\">\n" +
                                                                                        "  <div class=\"panel-heading\" ng-keypress=\"toggleOpen($event)\">\n" +
                                                                                        "    <h4 class=\"panel-title\">\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5561..5574
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5775..5788

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 82.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                          scope.compare = function(date1, date2) {
                                                                                            return (new Date(date1.getFullYear(), date1.getMonth(), date1.getDate()) - new Date(date2.getFullYear(), date2.getMonth(), date2.getDate()));
                                                                                          };
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1452..1454

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 79.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                          ctrl.compare = function(date1, date2) {
                                                                                            return (new Date(date1.getFullYear(), date1.getMonth(), date1.getDate()) - new Date(date2.getFullYear(), date2.getMonth(), date2.getDate()));
                                                                                          };
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1667..1669

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 79.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        minutesInputEl.bind('blur', function(e) {
                                                                                          if (!$scope.invalidMinutes && $scope.minutes < 10) {
                                                                                            $scope.$apply(function() {
                                                                                              $scope.minutes = pad($scope.minutes);
                                                                                            });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4685..4691

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 78.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        hoursInputEl.bind('blur', function(e) {
                                                                                          if (!$scope.invalidHours && $scope.hours < 10) {
                                                                                            $scope.$apply(function() {
                                                                                              $scope.hours = pad($scope.hours);
                                                                                            });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4709..4715

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 78.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/pagination/pagination.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/pagination/pagination.html",
                                                                                        "<ul class=\"pagination\">\n" +
                                                                                        "  <li ng-if=\"::boundaryLinks\" ng-class=\"{disabled: noPrevious()||ngDisabled}\" class=\"pagination-first\"><a href ng-click=\"selectPage(1, $event)\">{{::getText('first')}}</a></li>\n" +
                                                                                        "  <li ng-if=\"::directionLinks\" ng-class=\"{disabled: noPrevious()||ngDisabled}\" class=\"pagination-prev\"><a href ng-click=\"selectPage(page - 1, $event)\">{{::getText('previous')}}</a></li>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5472..5482
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5639..5649
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5651..5661
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5663..5673

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 70.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/tooltip/tooltip-popup.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/tooltip/tooltip-popup.html",
                                                                                        "<div class=\"tooltip\"\n" +
                                                                                        "  tooltip-animation-class=\"fade\"\n" +
                                                                                        "  tooltip-classes\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5472..5482
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5627..5637
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5639..5649
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5651..5661

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 70.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/tooltip/tooltip-html-popup.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/tooltip/tooltip-html-popup.html",
                                                                                        "<div class=\"tooltip\"\n" +
                                                                                        "  tooltip-animation-class=\"fade\"\n" +
                                                                                        "  tooltip-classes\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5472..5482
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5627..5637
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5651..5661
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5663..5673

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 70.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/tooltip/tooltip-html-unsafe-popup.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/tooltip/tooltip-html-unsafe-popup.html",
                                                                                        "<div class=\"tooltip\"\n" +
                                                                                        "  tooltip-animation-class=\"fade\"\n" +
                                                                                        "  tooltip-classes\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5472..5482
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5627..5637
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5639..5649
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5663..5673

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 70.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/alert/alert.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/alert/alert.html",
                                                                                        "<div class=\"alert\" ng-class=\"['alert-' + (type || 'warning'), closeable ? 'alert-dismissible' : null]\" role=\"alert\">\n" +
                                                                                        "    <button ng-show=\"closeable\" type=\"button\" class=\"close\" ng-click=\"close($event)\">\n" +
                                                                                        "        <span aria-hidden=\"true\">&times;</span>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5627..5637
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5639..5649
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5651..5661
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5663..5673

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 70.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        'MMM': {
                                                                                          regex: $locale.DATETIME_FORMATS.SHORTMONTH.join('|'),
                                                                                          apply: function(value) { this.month = $locale.DATETIME_FORMATS.SHORTMONTH.indexOf(value); }
                                                                                        },
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 804..807

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 65.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        'MMMM': {
                                                                                          regex: $locale.DATETIME_FORMATS.MONTH.join('|'),
                                                                                          apply: function(value) { this.month = $locale.DATETIME_FORMATS.MONTH.indexOf(value); }
                                                                                        },
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 808..811

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 65.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        minutesInputEl.bind('mousewheel wheel', function(e) {
                                                                                          $scope.$apply(isScrollingUp(e) ? $scope.incrementMinutes() : $scope.decrementMinutes());
                                                                                          e.preventDefault();
                                                                                        });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4612..4615

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 63.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module( 'ui.bootstrap.popover', ['ui.bootstrap.tooltip'])
                                                                                    
                                                                                    .directive('popoverTemplatePopup', function() {
                                                                                      return {
                                                                                        restrict: 'EA',
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3266..3812
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3862..3902

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 63.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module('ui.bootstrap.tooltip', ['ui.bootstrap.position', 'ui.bootstrap.bindHtml'])
                                                                                    
                                                                                    /**
                                                                                     * The $tooltip service creates tooltip- and popover-like directives as well as
                                                                                     * houses global options for them.
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3862..3887
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3862..3902

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 63.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        hoursInputEl.bind('mousewheel wheel', function(e) {
                                                                                          $scope.$apply(isScrollingUp(e) ? $scope.incrementHours() : $scope.decrementHours());
                                                                                          e.preventDefault();
                                                                                        });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4617..4620

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 63.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/modal/backdrop.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/modal/backdrop.html",
                                                                                        "<div class=\"modal-backdrop\"\n" +
                                                                                        "     modal-animation-class=\"fade\"\n" +
                                                                                        "     modal-in-class=\"in\"\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5827..5835

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 62.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/typeahead/typeahead-popup.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/typeahead/typeahead-popup.html",
                                                                                        "<ul class=\"dropdown-menu\" ng-show=\"isOpen() && !moveInProgress\" ng-style=\"{top: position().top+'px', left: position().left+'px'}\" style=\"display: block;\" role=\"listbox\" aria-hidden=\"{{!isOpen()}}\">\n" +
                                                                                        "    <li ng-repeat=\"match in matches track by $index\" ng-class=\"{active: isActive($index) }\" ng-mouseenter=\"selectActive($index)\" ng-click=\"selectMatch($index)\" role=\"option\" id=\"{{::match.id}}\">\n" +
                                                                                        "        <div typeahead-match index=\"$index\" match=\"match\" query=\"query\" template-url=\"templateUrl\"></div>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5597..5605

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 62.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            scope.$apply(function() {
                                                                                              ngModelCtrl.$setViewValue(element.hasClass(buttonsCtrl.activeClass) ? getFalseValue() : getTrueValue());
                                                                                              ngModelCtrl.$render();
                                                                                            });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 354..357

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 61.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            scope.$apply(function() {
                                                                                              ngModelCtrl.$setViewValue(element.hasClass(buttonsCtrl.activeClass) ? getFalseValue() : getTrueValue());
                                                                                              ngModelCtrl.$render();
                                                                                            });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 342..345

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 61.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/datepicker/datepicker.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/datepicker/datepicker.html",
                                                                                        "<div ng-switch=\"datepickerMode\" role=\"application\" ng-keydown=\"keydown($event)\">\n" +
                                                                                        "  <daypicker ng-switch-when=\"day\" tabindex=\"0\"></daypicker>\n" +
                                                                                        "  <monthpicker ng-switch-when=\"month\" tabindex=\"0\"></monthpicker>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5618..5625
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5758..5765

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 58.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/rating/rating.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/rating/rating.html",
                                                                                        "<span ng-mouseleave=\"reset()\" ng-keydown=\"onKeydown($event)\" tabindex=\"0\" role=\"slider\" aria-valuemin=\"0\" aria-valuemax=\"{{range.length}}\" aria-valuenow=\"{{value}}\">\n" +
                                                                                        "    <span ng-repeat-start=\"r in range track by $index\" class=\"sr-only\">({{ $index < value ? '*' : ' ' }})</span>\n" +
                                                                                        "    <i ng-repeat-end ng-mouseenter=\"enter($index + 1)\" ng-click=\"rate($index + 1)\" class=\"glyphicon\" ng-class=\"$index < value && (r.stateOn || 'glyphicon-star') || (r.stateOff || 'glyphicon-star-empty')\" ng-attr-title=\"{{r.title}}\" ></i>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5505..5512
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5618..5625

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 58.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                      $scope.$parent.$watch($parse($attrs.max), function(value) {
                                                                                        var dt = new Date(value);
                                                                                        max = isNaN(dt) ? undefined : dt;
                                                                                      });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4511..4514

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 58.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                      $scope.$parent.$watch($parse($attrs.min), function(value) {
                                                                                        var dt = new Date(value);
                                                                                        min = isNaN(dt) ? undefined : dt;
                                                                                      });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4517..4520

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 58.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/pagination/pager.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/pagination/pager.html",
                                                                                        "<ul class=\"pager\">\n" +
                                                                                        "  <li ng-class=\"{disabled: noPrevious()||ngDisabled, previous: align}\"><a href ng-click=\"selectPage(page - 1, $event)\">{{::getText('previous')}}</a></li>\n" +
                                                                                        "  <li ng-class=\"{disabled: noNext()||ngDisabled, next: align}\"><a href ng-click=\"selectPage(page + 1, $event)\">{{::getText('next')}}</a></li>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5505..5512
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5758..5765

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 58.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/carousel/slide.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/carousel/slide.html",
                                                                                        "<div ng-class=\"{\n" +
                                                                                        "    'active': active\n" +
                                                                                        "  }\" class=\"item text-center\" ng-transclude></div>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5750..5756
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5767..5773

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 54.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/progressbar/progressbar.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/progressbar/progressbar.html",
                                                                                        "<div class=\"progress\">\n" +
                                                                                        "  <div class=\"progress-bar\" ng-class=\"type && 'progress-bar-' + type\" role=\"progressbar\" aria-valuenow=\"{{value}}\" aria-valuemin=\"0\" aria-valuemax=\"{{max}}\" ng-style=\"{width: (percent < 100 ? percent : 100) + '%'}\" aria-valuetext=\"{{percent | number:0}}%\" style=\"min-width: 0;\" ng-transclude></div>\n" +
                                                                                        "</div>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5497..5503
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5767..5773

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 54.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/tabs/tab.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/tabs/tab.html",
                                                                                        "<li ng-class=\"{active: active, disabled: disabled}\">\n" +
                                                                                        "  <a href ng-click=\"select()\" tab-heading-transclude>{{heading}}</a>\n" +
                                                                                        "</li>\n" +
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5497..5503
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5750..5756

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 54.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                      if ($attrs.minuteStep) {
                                                                                        $scope.$parent.$watch($parse($attrs.minuteStep), function(value) {
                                                                                          minuteStep = parseInt(value, 10);
                                                                                        });
                                                                                      }
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4497..4501

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 53.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                      if ($attrs.hourStep) {
                                                                                        $scope.$parent.$watch($parse($attrs.hourStep), function(value) {
                                                                                          hourStep = parseInt(value, 10);
                                                                                        });
                                                                                      }
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4504..4508

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 53.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                              months[i] = angular.extend(ctrl.createDateObject(date, ctrl.formatMonth), {
                                                                                                uid: scope.uniqueId + '-' + i
                                                                                              });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1573..1575

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 51.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                              years[i] = angular.extend(ctrl.createDateObject(date, ctrl.formatYear), {
                                                                                                uid: scope.uniqueId + '-' + i
                                                                                              });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1511..1513

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 51.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                                  if (!angular.isNumber(dropdownCtrl.selectedOption)) {
                                                                                                    dropdownCtrl.selectedOption = 0;
                                                                                                  } else {
                                                                                                    dropdownCtrl.selectedOption = dropdownCtrl.selectedOption === elems.length -1 ?
                                                                                                      dropdownCtrl.selectedOption : dropdownCtrl.selectedOption + 1;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 2091..2097

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        this.stateOn = angular.isDefined($attrs.stateOn) ? $scope.$parent.$eval($attrs.stateOn) : ratingConfig.stateOn;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4079..4079

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        this.stateOff = angular.isDefined($attrs.stateOff) ? $scope.$parent.$eval($attrs.stateOff) : ratingConfig.stateOff;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4078..4078

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                    Open

                                                                                          scope.align = angular.isDefined(attrs.align) ? scope.$parent.$eval(attrs.align) : pagerConfig.align;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1652..1652
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3143..3143
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3144..3144
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4492..4492
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4780..4781

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            if (!angular.isNumber(self.selectedOption)) {
                                                                                              self.selectedOption = 0;
                                                                                            } else {
                                                                                              self.selectedOption = (self.selectedOption === elems.length -1 ?
                                                                                                self.selectedOption :
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 2240..2245

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                    Open

                                                                                        $scope.readonlyInput = angular.isDefined($attrs.readonlyInput) ? $scope.$parent.$eval($attrs.readonlyInput) : timepickerConfig.readonlyInput;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1652..1652
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3143..3143
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3144..3144
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3255..3255
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4780..4781

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                    Open

                                                                                      $scope.showSpinners = angular.isDefined($attrs.showSpinners) ?
                                                                                        $scope.$parent.$eval($attrs.showSpinners) : timepickerConfig.showSpinners;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1652..1652
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3143..3143
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3144..3144
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3255..3255
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4492..4492

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                    Open

                                                                                          scope.directionLinks = angular.isDefined(attrs.directionLinks) ? scope.$parent.$eval(attrs.directionLinks) : paginationConfig.directionLinks;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1652..1652
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3143..3143
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3255..3255
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4492..4492
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4780..4781

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                    Open

                                                                                          scope.boundaryLinks = angular.isDefined(attrs.boundaryLinks) ? scope.$parent.$eval(attrs.boundaryLinks) : paginationConfig.boundaryLinks;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1652..1652
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3144..3144
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3255..3255
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4492..4492
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4780..4781

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 6 locations. Consider refactoring.
                                                                                    Open

                                                                                          scope.showButtonBar = angular.isDefined(attrs.showButtonBar) ? scope.$parent.$eval(attrs.showButtonBar) : datepickerPopupConfig.showButtonBar;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3143..3143
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3144..3144
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 3255..3255
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4492..4492
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4780..4781

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 49.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/typeahead/typeahead-match.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/typeahead/typeahead-match.html",
                                                                                        "<a href tabindex=\"-1\" ng-bind-html=\"match.label | typeaheadHighlight:query\"></a>\n" +
                                                                                        "");
                                                                                    }]);
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5739..5743

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 46.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                    angular.module("template/progressbar/bar.html", []).run(["$templateCache", function($templateCache) {
                                                                                      $templateCache.put("template/progressbar/bar.html",
                                                                                        "<div class=\"progress-bar\" ng-class=\"type && 'progress-bar-' + type\" role=\"progressbar\" aria-valuenow=\"{{value}}\" aria-valuemin=\"0\" aria-valuemax=\"{{max}}\" ng-style=\"{width: (percent < 100 ? percent : 100) + '%'}\" aria-valuetext=\"{{percent | number:0}}%\" style=\"min-width: 0;\" ng-transclude></div>\n" +
                                                                                        "");
                                                                                    }]);
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 5821..5825

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 46.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            scope.$parent.$watch($parse(attrs.disabled), function(value) {
                                                                                              scope.disabled = !! value;
                                                                                            });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4370..4372

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        link: function(scope, element, attrs, ctrls) {
                                                                                          var datepickerCtrl = ctrls[0], ngModelCtrl = ctrls[1];
                                                                                    
                                                                                          datepickerCtrl.init(ngModelCtrl);
                                                                                        }
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4149..4152

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                        link: function(scope, element, attrs, ctrls) {
                                                                                          var ratingCtrl = ctrls[0], ngModelCtrl = ctrls[1];
                                                                                          ratingCtrl.init( ngModelCtrl );
                                                                                        }
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1373..1377

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                        var mousewheel = angular.isDefined($attrs.mousewheel) ? $scope.$parent.$eval($attrs.mousewheel) : timepickerConfig.mousewheel;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4080..4080
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4487..4487

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                          scope.vertical = angular.isDefined(attrs.vertical) ? scope.$parent.$eval(attrs.vertical) : false;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4259..4259

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            if ((key == 'minMode' && self.modes.indexOf($scope.datepickerMode) < self.modes.indexOf(self[key])) || (key == 'maxMode' && self.modes.indexOf($scope.datepickerMode) > self.modes.indexOf(self[key]))) {
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 1186..1186

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                          scope.justified = angular.isDefined(attrs.justified) ? scope.$parent.$eval(attrs.justified) : false;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4258..4258

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                        var tmpTitles = angular.isDefined($attrs.titles)  ? $scope.$parent.$eval($attrs.titles) : ratingConfig.titles ;    
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4482..4482
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4487..4487

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                    Open

                                                                                        var arrowkeys = angular.isDefined($attrs.arrowkeys) ? $scope.$parent.$eval($attrs.arrowkeys) : timepickerConfig.arrowkeys;
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4080..4080
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4482..4482

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                    Open

                                                                                            scope.$parent.$watch($parse(attrs.disable), function(value) {
                                                                                              scope.disabled = !! value;
                                                                                            });
                                                                                    frontend/app/assets/javascripts/mno_enterprise/lib/ui-bootstrap-tpls-0.13.4.js on lines 4381..4383

                                                                                    Duplicated Code

                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                    Tuning

                                                                                    This issue has a mass of 45.

                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                    Refactorings

                                                                                    Further Reading

                                                                                    There are no issues that match your filters.

                                                                                    Category
                                                                                    Status