webcol/Calima

View on GitHub
public_/js/bootstrap.js

Summary

Maintainability
F
2 mos
Test Coverage

File bootstrap.js has 1550 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
 * Bootstrap v3.3.1 (http://getbootstrap.com)
 * Copyright 2011-2014 Twitter, Inc.
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
 */
Severity: Major
Found in public_/js/bootstrap.js - About 4 days to fix

    Function show has 54 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

      Tooltip.prototype.show = function () {
        var e = $.Event('show.bs.' + this.type)
    
        if (this.hasContent() && this.enabled) {
          this.$element.trigger(e)
    Severity: Major
    Found in public_/js/bootstrap.js - About 2 hrs to fix

      Function slide has 49 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        Carousel.prototype.slide = function (type, next) {
          var $active   = this.$element.find('.item.active')
          var $next     = next || this.getItemForDirection(type, $active)
          var isCycling = this.interval
          var direction = type == 'next' ? 'left' : 'right'
      Severity: Minor
      Found in public_/js/bootstrap.js - About 1 hr to fix

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

          Tab.prototype.activate = function (element, container, callback) {
            var $active    = container.find('> .active')
            var transition = callback
              && $.support.transition
              && (($active.length && $active.hasClass('fade')) || !!container.find('> .fade').length)
        Severity: Minor
        Found in public_/js/bootstrap.js - About 1 hr to fix

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

            Modal.prototype.show = function (_relatedTarget) {
              var that = this
              var e    = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
          
              this.$element.trigger(e)
          Severity: Minor
          Found in public_/js/bootstrap.js - About 1 hr to fix

            Function show has 36 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              Collapse.prototype.show = function () {
                if (this.transitioning || this.$element.hasClass('in')) return
            
                var activesData
                var actives = this.$parent && this.$parent.find('> .panel').children('.in, .collapsing')
            Severity: Minor
            Found in public_/js/bootstrap.js - About 1 hr to fix

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

                Modal.prototype.backdrop = function (callback) {
                  var that = this
                  var animate = this.$element.hasClass('fade') ? 'fade' : ''
              
                  if (this.isShown && this.options.backdrop) {
              Severity: Minor
              Found in public_/js/bootstrap.js - About 1 hr to fix

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

                  Tooltip.prototype.applyPlacement = function (offset, placement) {
                    var $tip   = this.tip()
                    var width  = $tip[0].offsetWidth
                    var height = $tip[0].offsetHeight
                
                
                Severity: Minor
                Found in public_/js/bootstrap.js - About 1 hr to fix

                  Function show has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    Tab.prototype.show = function () {
                      var $this    = this.element
                      var $ul      = $this.closest('ul:not(.dropdown-menu)')
                      var selector = $this.data('target')
                  
                  
                  Severity: Minor
                  Found in public_/js/bootstrap.js - About 1 hr to fix

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

                      Affix.prototype.checkPosition = function () {
                        if (!this.$element.is(':visible')) return
                    
                        var height       = this.$element.height()
                        var offset       = this.options.offset
                    Severity: Minor
                    Found in public_/js/bootstrap.js - About 1 hr to fix

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

                        ScrollSpy.prototype.refresh = function () {
                          var offsetMethod = 'offset'
                          var offsetBase   = 0
                      
                          if (!$.isWindow(this.$scrollElement[0])) {
                      Severity: Minor
                      Found in public_/js/bootstrap.js - About 1 hr to fix

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

                          Collapse.prototype.hide = function () {
                            if (this.transitioning || !this.$element.hasClass('in')) return
                        
                            var startEvent = $.Event('hide.bs.collapse')
                            this.$element.trigger(startEvent)
                        Severity: Minor
                        Found in public_/js/bootstrap.js - About 1 hr to fix

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

                              function next() {
                                $active
                                  .removeClass('active')
                                  .find('> .dropdown-menu > .active')
                                    .removeClass('active')
                          Severity: Minor
                          Found in public_/js/bootstrap.js - About 1 hr to fix

                            Avoid too many return statements within this function.
                            Open

                                if (offsetBottom != null && (colliderTop + colliderHeight >= scrollHeight - offsetBottom)) return 'bottom'
                            Severity: Major
                            Found in public_/js/bootstrap.js - About 30 mins to fix

                              Avoid too many return statements within this function.
                              Open

                                  return false
                              Severity: Major
                              Found in public_/js/bootstrap.js - About 30 mins to fix

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

                                  Collapse.prototype.show = function () {
                                    if (this.transitioning || this.$element.hasClass('in')) return
                                
                                    var activesData
                                    var actives = this.$parent && this.$parent.find('> .panel').children('.in, .collapsing')
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 days to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 583..632

                                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 479.

                                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

                                +function ($) {
                                  'use strict';
                                
                                  // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
                                  // ============================================================
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 days to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 28..77

                                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 402.

                                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

                                  Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {
                                    var delta = { top: 0, left: 0 }
                                    if (!this.$viewport) return delta
                                
                                    var viewportPadding = this.options.viewport && this.options.viewport.padding || 0
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 days to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1641..1667

                                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 385.

                                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

                                  Tab.prototype.show = function () {
                                    var $this    = this.element
                                    var $ul      = $this.closest('ul:not(.dropdown-menu)')
                                    var selector = $this.data('target')
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2085..2123

                                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 348.

                                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

                                  Collapse.prototype.hide = function () {
                                    if (this.transitioning || !this.$element.hasClass('in')) return
                                
                                    var startEvent = $.Event('hide.bs.collapse')
                                    this.$element.trigger(startEvent)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 634..670

                                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 328.

                                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

                                  Affix.prototype.getState = function (scrollHeight, height, offsetTop, offsetBottom) {
                                    var scrollTop    = this.$target.scrollTop()
                                    var position     = this.$element.offset()
                                    var targetHeight = this.$target.height()
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2255..2275

                                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 274.

                                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

                                  $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
                                    var $this   = $(this)
                                    var href    = $this.attr('href')
                                    var $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) // strip for ie7
                                    var option  = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1238..1253

                                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 266.

                                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 ($.support.transition && this.$element.hasClass('slide')) {
                                      $next.addClass(type)
                                      $next[0].offsetWidth // force reflow
                                      $active.addClass(direction)
                                      $next.addClass(direction)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 444..464

                                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 253.

                                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

                                  Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
                                    return placement == 'bottom' ? { top: pos.top + pos.height,   left: pos.left + pos.width / 2 - actualWidth / 2  } :
                                           placement == 'top'    ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2  } :
                                           placement == 'left'   ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
                                        /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width   }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1633..1639

                                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 239.

                                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

                                    for (var i = triggers.length; i--;) {
                                      var trigger = triggers[i]
                                
                                      if (trigger == 'click') {
                                        this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1319..1331

                                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 235.

                                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.$body
                                      .find(this.selector)
                                      .map(function () {
                                        var $el   = $(this)
                                        var href  = $el.data('target') || $el.attr('href')
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1941..1957

                                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 225.

                                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

                                  Popover.prototype.setContent = function () {
                                    var $tip    = this.tip()
                                    var title   = this.getTitle()
                                    var content = this.getContent()
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1820..1835

                                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 219.

                                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 clickHandler = function (e) {
                                    var href
                                    var $this   = $(this)
                                    var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7
                                    if (!$target.hasClass('carousel')) return
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 507..523

                                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 209.

                                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

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this    = $(this)
                                      var data     = $this.data('bs.tooltip')
                                      var options  = typeof option == 'object' && option
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/js/bootstrap.js on lines 1795..1811

                                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 208.

                                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

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this    = $(this)
                                      var data     = $this.data('bs.popover')
                                      var options  = typeof option == 'object' && option
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/js/bootstrap.js on lines 1675..1691

                                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 208.

                                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

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this   = $(this)
                                      var data    = $this.data('bs.carousel')
                                      var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 475..487

                                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 206.

                                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 (this.affixed != affix) {
                                      if (this.unpin != null) this.$element.css('top', '')
                                
                                      var affixType = 'affix' + (affix ? '-' + affix : '')
                                      var e         = $.Event(affixType + '.bs.affix')
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2304..2321

                                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 197.

                                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

                                  Carousel.prototype.to = function (pos) {
                                    var that        = this
                                    var activeIndex = this.getItemIndex(this.$active = this.$element.find('.item.active'))
                                
                                    if (pos > (this.$items.length - 1) || pos < 0) return
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 day to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 381..391

                                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 195.

                                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

                                  ScrollSpy.prototype.activate = function (target) {
                                    this.activeTarget = target
                                
                                    this.clear()
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 6 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1990..2010

                                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 165.

                                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

                                  $(window).on('load', function () {
                                    $('[data-spy="affix"]').each(function () {
                                      var $spy = $(this)
                                      var data = $spy.data()
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 6 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2363..2375

                                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 163.

                                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

                                  function Plugin(option, _relatedTarget) {
                                    return this.each(function () {
                                      var $this   = $(this)
                                      var data    = $this.data('bs.modal')
                                      var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 6 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1208..1218

                                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 163.

                                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 (this.isShown && this.options.backdrop) {
                                      var doAnimate = $.support.transition && animate
                                
                                      this.$backdrop = $('<div class="modal-backdrop ' + animate + '" />')
                                        .prependTo(this.$element)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 5 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1105..1150

                                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 144.

                                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

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this   = $(this)
                                      var data    = $this.data('bs.button')
                                      var options = typeof option == 'object' && option
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 251..262

                                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 132.

                                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

                                  Carousel.prototype.pause = function (e) {
                                    e || (this.paused = true)
                                
                                    if (this.$element.find('.next, .prev').length && $.support.transition) {
                                      this.$element.trigger($.support.transition.end)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 393..404

                                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 131.

                                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

                                        placement = placement == 'bottom' && pos.bottom + actualHeight > containerDim.bottom ? 'top'    :
                                                    placement == 'top'    && pos.top    - actualHeight < containerDim.top    ? 'bottom' :
                                                    placement == 'right'  && pos.right  + actualWidth  > containerDim.width  ? 'left'   :
                                                    placement == 'left'   && pos.left   - actualWidth  < containerDim.left   ? 'right'  :
                                                    placement
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1474..1478

                                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 127.

                                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

                                  Modal.prototype.escape = function () {
                                    if (this.isShown && this.options.keyboard) {
                                      this.$element.on('keydown.dismiss.bs.modal', $.proxy(function (e) {
                                        e.which == 27 && this.hide()
                                      }, this))
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1067..1075

                                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 125.

                                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 4 locations. Consider refactoring.
                                Open

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this   = $(this)
                                      var data    = $this.data('bs.affix')
                                      var options = typeof option == 'object' && option
                                Severity: Major
                                Found in public_/js/bootstrap.js and 3 other locations - About 4 hrs to fix
                                public_/js/bootstrap.js on lines 1967..1976
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2022..2031
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2334..2343

                                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 118.

                                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 4 locations. Consider refactoring.
                                Open

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this   = $(this)
                                      var data    = $this.data('bs.scrollspy')
                                      var options = typeof option == 'object' && option
                                Severity: Major
                                Found in public_/js/bootstrap.js and 3 other locations - About 4 hrs to fix
                                public_/js/bootstrap.js on lines 2277..2286
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2022..2031
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2334..2343

                                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 118.

                                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

                                  Modal.prototype.adjustDialog = function () {
                                    var modalIsOverflowing = this.$element[0].scrollHeight > document.documentElement.clientHeight
                                
                                    this.$element.css({
                                      paddingLeft:  !this.bodyIsOverflowing && modalIsOverflowing ? this.scrollbarWidth : '',
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1159..1166

                                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 117.

                                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

                                  Collapse.prototype.getParent = function () {
                                    return $(this.options.parent)
                                      .find('[data-toggle="collapse"][data-parent="' + this.options.parent + '"]')
                                      .each($.proxy(function (i, element) {
                                        var $element = $(element)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 676..684

                                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 117.

                                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

                                  Affix.prototype.getPinnedOffset = function () {
                                    if (this.pinnedOffset) return this.pinnedOffset
                                    this.$element.removeClass(Affix.RESET).addClass('affix')
                                    var scrollTop = this.$target.scrollTop()
                                    var position  = this.$element.offset()
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2277..2283

                                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 117.

                                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

                                  Carousel.prototype.cycle = function (e) {
                                    e || (this.paused = false)
                                
                                    this.interval && clearInterval(this.interval)
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 354..364

                                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 117.

                                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

                                  Tooltip.prototype.getOptions = function (options) {
                                    options = $.extend({}, this.getDefaults(), this.$element.data(), options)
                                
                                    if (options.delay && typeof options.delay == 'number') {
                                      options.delay = {
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1342..1353

                                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 116.

                                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

                                  function getParent($this) {
                                    var selector = $this.attr('data-target')
                                
                                    if (!selector) {
                                      selector = $this.attr('href')
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 4 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 774..785

                                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 116.

                                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

                                  Modal.prototype.measureScrollbar = function () { // thx walsh
                                    var scrollDiv = document.createElement('div')
                                    scrollDiv.className = 'modal-scrollbar-measure'
                                    this.$body.append(scrollDiv)
                                    var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1195..1202

                                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 107.

                                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

                                  Modal.prototype.hideModal = function () {
                                    var that = this
                                    this.$element.hide()
                                    this.backdrop(function () {
                                      that.$body.removeClass('modal-open')
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1085..1094

                                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 107.

                                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 4 locations. Consider refactoring.
                                Open

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this = $(this)
                                      var data  = $this.data('bs.alert')
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 3 other locations - About 3 hrs to fix
                                public_/js/bootstrap.js on lines 867..875
                                public_/plantillas/inspinia/js/bootstrap.js on lines 142..150
                                public_/plantillas/inspinia/js/bootstrap.js on lines 880..888

                                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 105.

                                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 4 locations. Consider refactoring.
                                Open

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this = $(this)
                                      var data  = $this.data('bs.dropdown')
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 3 other locations - About 3 hrs to fix
                                public_/js/bootstrap.js on lines 141..149
                                public_/plantillas/inspinia/js/bootstrap.js on lines 142..150
                                public_/plantillas/inspinia/js/bootstrap.js on lines 880..888

                                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 105.

                                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

                                  Tooltip.prototype.getTitle = function () {
                                    var title
                                    var $e = this.$element
                                    var o  = this.options
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1669..1678

                                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 105.

                                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 (e) {
                                      self = $(e.currentTarget).data('bs.' + this.type)
                                      if (!self) {
                                        self = new this.constructor(e.currentTarget, this.getDelegateOptions())
                                        $(e.currentTarget).data('bs.' + this.type, self)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1714..1720

                                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 102.

                                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

                                  function Plugin(option) {
                                    return this.each(function () {
                                      var $this = $(this)
                                      var data  = $this.data('bs.tab')
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2177..2185

                                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 100.

                                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

                                  Tooltip.prototype.getDelegateOptions = function () {
                                    var options  = {}
                                    var defaults = this.getDefaults()
                                
                                    this._options && $.each(this._options, function (key, value) {
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1355..1364

                                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 99.

                                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

                                  Tooltip.prototype.fixTitle = function () {
                                    var $e = this.$element
                                    if ($e.attr('title') || typeof ($e.attr('data-original-title')) != 'string') {
                                      $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
                                    }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 3 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1601..1606

                                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 97.

                                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

                                  $(document)
                                    .on('click.bs.dropdown.data-api', clearMenus)
                                    .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
                                    .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)
                                    .on('keydown.bs.dropdown.data-api', toggle, Dropdown.prototype.keydown)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 908..913

                                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 94.

                                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

                                  Carousel.prototype.keydown = function (e) {
                                    if (/input|textarea/i.test(e.target.tagName)) return
                                    switch (e.which) {
                                      case 37: this.prev(); break
                                      case 39: this.next(); break
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 343..352

                                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 93.

                                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 10 locations. Consider refactoring.
                                Open

                                  Popover.prototype.getContent = function () {
                                    var $e = this.$element
                                    var o  = this.options
                                
                                    return $e.attr('data-content')
                                Severity: Major
                                Found in public_/js/bootstrap.js and 9 other locations - About 2 hrs to fix
                                public_/js/bootstrap-confirmation.js on lines 140..145
                                public_/js/bootstrap-confirmation.js on lines 147..152
                                public_/js/bootstrap-confirmation.js on lines 154..159
                                public_/js/bootstrap-confirmation.js on lines 161..166
                                public_/js/bootstrap-confirmation.js on lines 168..173
                                public_/js/bootstrap-confirmation.js on lines 175..180
                                public_/js/bootstrap-confirmation.js on lines 182..187
                                public_/js/bootstrap-confirmation.js on lines 189..194
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1841..1849

                                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 93.

                                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

                                  Tooltip.prototype.setContent = function () {
                                    var $tip  = this.tip()
                                    var title = this.getTitle()
                                
                                    $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1561..1567

                                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 92.

                                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

                                    $.offset.setOffset($tip[0], $.extend({
                                      using: function (props) {
                                        $tip.css({
                                          top: Math.round(props.top),
                                          left: Math.round(props.left)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1523..1530

                                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 91.

                                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 (this.$indicators.length) {
                                      this.$indicators.find('.active').removeClass('active')
                                      var $nextIndicator = $(this.$indicators.children()[this.getItemIndex($next)])
                                      $nextIndicator && $nextIndicator.addClass('active')
                                    }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 437..441

                                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

                                    this.options.pause == 'hover' && !('ontouchstart' in document.documentElement) && this.$element
                                      .on('mouseenter.bs.carousel', $.proxy(this.pause, this))
                                      .on('mouseleave.bs.carousel', $.proxy(this.cycle, this))
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 327..329

                                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 81.

                                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

                                  Modal.prototype.resize = function () {
                                    if (this.isShown) {
                                      $(window).on('resize.bs.modal', $.proxy(this.handleUpdate, this))
                                    } else {
                                      $(window).off('resize.bs.modal')
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1077..1083

                                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

                                  Tooltip.prototype.replaceArrow = function (delta, dimension, isHorizontal) {
                                    this.arrow()
                                      .css(isHorizontal ? 'left' : 'top', 50 * (1 - delta / dimension) + '%')
                                      .css(isHorizontal ? 'top' : 'left', '')
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1555..1559

                                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

                                    if ((!isActive && e.which != 27) || (isActive && e.which == 27)) {
                                      if (e.which == 27) $parent.find(toggle).trigger('focus')
                                      return $this.trigger('click')
                                    }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 857..860

                                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

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

                                    $.support.transition && this.$element.hasClass('fade') ?
                                      this.$element
                                        .one('bsTransitionEnd', $.proxy(this.hideModal, this))
                                        .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
                                      this.hideModal()
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1048..1052

                                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

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

                                      var complete = function () {
                                        var prevHoverState = that.hoverState
                                        that.$element.trigger('shown.bs.' + that.type)
                                        that.hoverState = null
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1489..1495

                                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 76.

                                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 (this.options.remote) {
                                      this.$element
                                        .find('.modal-content')
                                        .load(this.options.remote, $.proxy(function () {
                                          this.$element.trigger('loaded.bs.modal')
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 2 hrs to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 943..949

                                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 76.

                                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

                                  $(window).on('load.bs.scrollspy.data-api', function () {
                                    $('[data-spy="scroll"]').each(function () {
                                      var $spy = $(this)
                                      Plugin.call($spy, $spy.data())
                                    })
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2051..2056

                                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 74.

                                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

                                  Tooltip.DEFAULTS = {
                                    animation: true,
                                    placement: 'top',
                                    selector: false,
                                    template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1289..1303

                                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 73.

                                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

                                  Collapse.prototype.addAriaAndCollapsedClass = function ($element, $trigger) {
                                    var isOpen = $element.hasClass('in')
                                
                                    $element.attr('aria-expanded', isOpen)
                                    $trigger
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 686..693

                                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 72.

                                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

                                  function getTargetFromTrigger($trigger) {
                                    var href
                                    var target = $trigger.attr('data-target')
                                      || (href = $trigger.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7
                                
                                
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 695..701

                                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 72.

                                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

                                  $(window).on('load', function () {
                                    $('[data-ride="carousel"]').each(function () {
                                      var $carousel = $(this)
                                      Plugin.call($carousel, $carousel.data())
                                    })
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 529..534

                                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 71.

                                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 (elRect.width == null) {
                                      // width and height are missing in IE8, so compute them manually; see https://github.com/twbs/bootstrap/issues/14093
                                      elRect = $.extend({}, elRect, { width: elRect.right - elRect.left, height: elRect.bottom - elRect.top })
                                    }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1619..1622

                                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

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

                                  Carousel.prototype.getItemIndex = function (item) {
                                    this.$items = item.parent().children('.item')
                                    return this.$items.index(item || this.$active)
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 366..369

                                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

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

                                  var Button = function (element, options) {
                                    this.$element  = $(element)
                                    this.options   = $.extend({}, Button.DEFAULTS, options)
                                    this.isLoading = false
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 189..193

                                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 69.

                                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

                                  ScrollSpy.prototype.getScrollHeight = function () {
                                    return this.$scrollElement[0].scrollHeight || Math.max(this.$body[0].scrollHeight, document.documentElement.scrollHeight)
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1923..1925

                                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 68.

                                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

                                    this.$target = $(this.options.target)
                                      .on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))
                                      .on('click.bs.affix.data-api',  $.proxy(this.checkPositionWithEventLoop, this))
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2234..2236

                                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 67.

                                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

                                      var placement = typeof this.options.placement == 'function' ?
                                        this.options.placement.call(this, $tip[0], this.$element[0]) :
                                        this.options.placement
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1449..1451

                                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

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

                                  Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
                                    placement: 'right',
                                    trigger: 'click',
                                    content: '',
                                    template: '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1801..1806

                                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

                                  ScrollSpy.prototype.clear = function () {
                                    $(this.selector)
                                      .parentsUntil(this.options.target, '.active')
                                      .removeClass('active')
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2012..2016

                                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 59.

                                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

                                      $tip
                                        .detach()
                                        .css({ top: 0, left: 0, display: 'block' })
                                        .addClass(placement)
                                        .data('bs.' + this.type, this)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1457..1461

                                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 59.

                                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 transition = callback
                                      && $.support.transition
                                      && (($active.length && $active.hasClass('fade')) || !!container.find('> .fade').length)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2127..2129

                                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 59.

                                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

                                  Tooltip.prototype.getUID = function (prefix) {
                                    do prefix += ~~(Math.random() * 1000000)
                                    while (document.getElementById(prefix))
                                    return prefix
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1680..1684

                                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

                                    this.options.selector ?
                                      (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
                                      this.fixTitle()
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1333..1335

                                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

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

                                      $.support.transition && this.$tip.hasClass('fade') ?
                                        $tip
                                          .one('bsTransitionEnd', complete)
                                          .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
                                        complete()
                                Severity: Major
                                Found in public_/js/bootstrap.js and 2 other locations - About 1 hr to fix
                                public_/js/bootstrap.js on lines 1537..1541
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1497..1501

                                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 57.

                                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 3 locations. Consider refactoring.
                                Open

                                    $.support.transition && this.$tip.hasClass('fade') ?
                                      $tip
                                        .one('bsTransitionEnd', complete)
                                        .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
                                      complete()
                                Severity: Major
                                Found in public_/js/bootstrap.js and 2 other locations - About 1 hr to fix
                                public_/js/bootstrap.js on lines 1446..1450
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1497..1501

                                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 57.

                                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 (this.options.parent) {
                                      this.$parent = this.getParent()
                                    } else {
                                      this.addAriaAndCollapsedClass(this.$element, this.$trigger)
                                    }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 561..565

                                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 57.

                                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 ((version[0] < 2 && version[1] < 9) || (version[0] == 1 && version[1] == 9 && version[2] < 1)) {
                                Severity: Major
                                Found in public_/js/bootstrap.js and 1 other location - About 1 hr to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 14..14

                                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 57.

                                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 4 locations. Consider refactoring.
                                Open

                                    self.timeout = setTimeout(function () {
                                      if (self.hoverState == 'out') self.hide()
                                    }, self.options.delay.hide)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 3 other locations - About 1 hr to fix
                                public_/js/bootstrap.js on lines 1353..1355
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1390..1392
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1424..1426

                                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 55.

                                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 4 locations. Consider refactoring.
                                Open

                                    self.timeout = setTimeout(function () {
                                      if (self.hoverState == 'in') self.show()
                                    }, self.options.delay.show)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 3 other locations - About 1 hr to fix
                                public_/js/bootstrap.js on lines 1373..1375
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1390..1392
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1424..1426

                                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 55.

                                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

                                  Tooltip.prototype.arrow = function () {
                                    return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 2 other locations - About 55 mins to fix
                                public_/js/bootstrap.js on lines 1782..1784
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1696..1698

                                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

                                  Popover.prototype.arrow = function () {
                                    return (this.$arrow = this.$arrow || this.tip().find('.arrow'))
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 2 other locations - About 55 mins to fix
                                public_/js/bootstrap.js on lines 1634..1636
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1696..1698

                                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

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

                                  Modal.prototype.removeBackdrop = function () {
                                    this.$backdrop && this.$backdrop.remove()
                                    this.$backdrop = null
                                  }
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 55 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1096..1099

                                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 3 locations. Consider refactoring.
                                Open

                                    $.support.transition && $parent.hasClass('fade') ?
                                      $parent
                                        .one('bsTransitionEnd', removeElement)
                                        .emulateTransitionEnd(Alert.TRANSITION_DURATION) :
                                      removeElement()
                                Severity: Major
                                Found in public_/js/bootstrap.js and 2 other locations - About 55 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 131..135
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1590..1594

                                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

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

                                      $active
                                        .removeClass('active')
                                        .find('> .dropdown-menu > .active')
                                          .removeClass('active')
                                        .end()
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 50 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2132..2138

                                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

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

                                    if (!$.isWindow(this.$scrollElement[0])) {
                                      offsetMethod = 'position'
                                      offsetBase   = this.$scrollElement.scrollTop()
                                    }
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 45 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1936..1939

                                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 50.

                                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

                                  $(document)
                                    .on('click.bs.button.data-api', '[data-toggle^="button"]', function (e) {
                                      var $btn = $(e.target)
                                      if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')
                                      Plugin.call($btn, 'toggle')
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 45 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 282..296

                                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 50.

                                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

                                  Modal.prototype.toggle = function (_relatedTarget) {
                                    return this.isShown ? this.hide() : this.show(_relatedTarget)
                                  }
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 40 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 963..965

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.alert.noConflict = function () {
                                    $.fn.alert = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 268..271
                                public_/js/bootstrap.js on lines 491..494
                                public_/js/bootstrap.js on lines 720..723
                                public_/js/bootstrap.js on lines 886..889
                                public_/js/bootstrap.js on lines 1202..1205
                                public_/js/bootstrap.js on lines 1987..1990
                                public_/js/bootstrap.js on lines 2139..2142
                                public_/js/bootstrap.js on lines 2297..2300
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.button.noConflict = function () {
                                    $.fn.button = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 160..163
                                public_/js/bootstrap.js on lines 491..494
                                public_/js/bootstrap.js on lines 720..723
                                public_/js/bootstrap.js on lines 886..889
                                public_/js/bootstrap.js on lines 1202..1205
                                public_/js/bootstrap.js on lines 1987..1990
                                public_/js/bootstrap.js on lines 2139..2142
                                public_/js/bootstrap.js on lines 2297..2300
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.tab.noConflict = function () {
                                    $.fn.tab = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 160..163
                                public_/js/bootstrap.js on lines 268..271
                                public_/js/bootstrap.js on lines 491..494
                                public_/js/bootstrap.js on lines 720..723
                                public_/js/bootstrap.js on lines 886..889
                                public_/js/bootstrap.js on lines 1202..1205
                                public_/js/bootstrap.js on lines 1987..1990
                                public_/js/bootstrap.js on lines 2297..2300
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.modal.noConflict = function () {
                                    $.fn.modal = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 160..163
                                public_/js/bootstrap.js on lines 268..271
                                public_/js/bootstrap.js on lines 491..494
                                public_/js/bootstrap.js on lines 720..723
                                public_/js/bootstrap.js on lines 886..889
                                public_/js/bootstrap.js on lines 1987..1990
                                public_/js/bootstrap.js on lines 2139..2142
                                public_/js/bootstrap.js on lines 2297..2300
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.dropdown.noConflict = function () {
                                    $.fn.dropdown = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 160..163
                                public_/js/bootstrap.js on lines 268..271
                                public_/js/bootstrap.js on lines 491..494
                                public_/js/bootstrap.js on lines 720..723
                                public_/js/bootstrap.js on lines 1202..1205
                                public_/js/bootstrap.js on lines 1987..1990
                                public_/js/bootstrap.js on lines 2139..2142
                                public_/js/bootstrap.js on lines 2297..2300
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.scrollspy.noConflict = function () {
                                    $.fn.scrollspy = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 160..163
                                public_/js/bootstrap.js on lines 268..271
                                public_/js/bootstrap.js on lines 491..494
                                public_/js/bootstrap.js on lines 720..723
                                public_/js/bootstrap.js on lines 886..889
                                public_/js/bootstrap.js on lines 1202..1205
                                public_/js/bootstrap.js on lines 2139..2142
                                public_/js/bootstrap.js on lines 2297..2300
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.affix.noConflict = function () {
                                    $.fn.affix = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 160..163
                                public_/js/bootstrap.js on lines 268..271
                                public_/js/bootstrap.js on lines 491..494
                                public_/js/bootstrap.js on lines 720..723
                                public_/js/bootstrap.js on lines 886..889
                                public_/js/bootstrap.js on lines 1202..1205
                                public_/js/bootstrap.js on lines 1987..1990
                                public_/js/bootstrap.js on lines 2139..2142
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.carousel.noConflict = function () {
                                    $.fn.carousel = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 160..163
                                public_/js/bootstrap.js on lines 268..271
                                public_/js/bootstrap.js on lines 720..723
                                public_/js/bootstrap.js on lines 886..889
                                public_/js/bootstrap.js on lines 1202..1205
                                public_/js/bootstrap.js on lines 1987..1990
                                public_/js/bootstrap.js on lines 2139..2142
                                public_/js/bootstrap.js on lines 2297..2300
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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 18 locations. Consider refactoring.
                                Open

                                  $.fn.collapse.noConflict = function () {
                                    $.fn.collapse = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 17 other locations - About 40 mins to fix
                                public_/js/bootstrap.js on lines 160..163
                                public_/js/bootstrap.js on lines 268..271
                                public_/js/bootstrap.js on lines 491..494
                                public_/js/bootstrap.js on lines 886..889
                                public_/js/bootstrap.js on lines 1202..1205
                                public_/js/bootstrap.js on lines 1987..1990
                                public_/js/bootstrap.js on lines 2139..2142
                                public_/js/bootstrap.js on lines 2297..2300
                                public_/plantillas/inspinia/js/bootstrap.js on lines 161..164
                                public_/plantillas/inspinia/js/bootstrap.js on lines 273..276
                                public_/plantillas/inspinia/js/bootstrap.js on lines 498..501
                                public_/plantillas/inspinia/js/bootstrap.js on lines 728..731
                                public_/plantillas/inspinia/js/bootstrap.js on lines 899..902
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1229..1232
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2042..2045
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2196..2199
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2354..2357

                                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 48.

                                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

                                  Collapse.prototype.dimension = function () {
                                    var hasWidth = this.$element.hasClass('width')
                                    return hasWidth ? 'width' : 'height'
                                  }
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 40 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 578..581

                                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 48.

                                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

                                  Collapse.prototype.toggle = function () {
                                    this[this.$element.hasClass('in') ? 'hide' : 'show']()
                                  }
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 40 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 672..674

                                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 48.

                                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 (transition) {
                                        element[0].offsetWidth // reflow for transition
                                        element.addClass('in')
                                      } else {
                                        element.removeClass('fade')
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 40 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2145..2150

                                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 48.

                                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 (element.parent('.dropdown-menu')) {
                                        element
                                          .closest('li.dropdown')
                                            .addClass('active')
                                          .end()
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 35 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 2152..2159

                                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 47.

                                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

                                  Modal.prototype.resetAdjustments = function () {
                                    this.$element.css({
                                      paddingLeft: '',
                                      paddingRight: ''
                                    })
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 35 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1168..1173

                                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

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

                                    var scroll    = { scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop() }
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 35 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1627..1627

                                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

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

                                    var outerDims = isBody ? { width: $(window).width(), height: $(window).height() } : null
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 35 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1628..1628

                                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

                                    if (scrollTop >= maxScroll) {
                                      return activeTarget != (i = targets[targets.length - 1]) && this.activate(i)
                                    }
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 35 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1973..1975

                                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

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

                                    var self = obj instanceof this.constructor ?
                                      obj : $(obj.currentTarget).data('bs.' + this.type)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 3 other locations - About 30 mins to fix
                                public_/js/bootstrap.js on lines 1334..1335
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1367..1368
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1404..1405

                                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

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

                                    var self = obj instanceof this.constructor ?
                                      obj : $(obj.currentTarget).data('bs.' + this.type)
                                Severity: Major
                                Found in public_/js/bootstrap.js and 3 other locations - About 30 mins to fix
                                public_/js/bootstrap.js on lines 1359..1360
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1367..1368
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1404..1405

                                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

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

                                      if (!that.$element.parent().length) {
                                        that.$element.appendTo(that.$body) // don't move modals dom position
                                      }
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 30 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 995..997

                                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

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

                                    var arrowDelta          = isVertical ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 30 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1548..1548

                                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 5 locations. Consider refactoring.
                                Open

                                  $.fn.tooltip.noConflict = function () {
                                    $.fn.tooltip = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 4 other locations - About 30 mins to fix
                                public_/js/bootstrap-confirmation.js on lines 235..239
                                public_/js/bootstrap.js on lines 1822..1825
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1771..1774
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1880..1883

                                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 5 locations. Consider refactoring.
                                Open

                                  $.fn.popover.noConflict = function () {
                                    $.fn.popover = old
                                    return this
                                  }
                                Severity: Major
                                Found in public_/js/bootstrap.js and 4 other locations - About 30 mins to fix
                                public_/js/bootstrap-confirmation.js on lines 235..239
                                public_/js/bootstrap.js on lines 1702..1705
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1771..1774
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1880..1883

                                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

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

                                      this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
                                Severity: Minor
                                Found in public_/js/bootstrap.js and 1 other location - About 30 mins to fix
                                public_/plantillas/inspinia/js/bootstrap.js on lines 1463..1463

                                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