divio/django-cms

View on GitHub
cms/static/cms/js/modules/cms.plugins.js

Summary

Maintainability
F
1 wk
Test Coverage

File cms.plugins.js has 1473 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*
 * Copyright https://github.com/divio/django-cms
 */
import Modal from './cms.modal';
import StructureBoard from './cms.structureboard';
Severity: Major
Found in cms/static/cms/js/modules/cms.plugins.js - About 3 days to fix

    Plugin has 41 functions (exceeds 20 allowed). Consider refactoring.
    Open

    var Plugin = new Class({
        implement: [Helpers],
    
        options: {
            type: '', // bar, plugin or generic
    Severity: Minor
    Found in cms/static/cms/js/modules/cms.plugins.js - About 5 hrs to fix

      Function _initializeGlobalHandlers has 94 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      Plugin._initializeGlobalHandlers = function _initializeGlobalHandlers() {
          var timer;
          var clickCounter = 0;
      
          Plugin._updateClipboard();
      Severity: Major
      Found in cms/static/cms/js/modules/cms.plugins.js - About 3 hrs to fix

        Function _setAddPluginModal has 85 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            _setAddPluginModal: function _setAddPluginModal(nav) {
                if (nav.hasClass('cms-btn-disabled')) {
                    return false;
                }
                var that = this;
        Severity: Major
        Found in cms/static/cms/js/modules/cms.plugins.js - About 3 hrs to fix

          Function _delegate has 69 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              _delegate: function _delegate(e) {
                  e.preventDefault();
                  e.stopPropagation();
          
                  var nav;
          Severity: Major
          Found in cms/static/cms/js/modules/cms.plugins.js - About 2 hrs to fix

            Function _setPluginStructureEvents has 55 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                _setPluginStructureEvents: function _setPluginStructureEvents() {
                    var that = this;
            
                    // filling up ui object
                    this.ui.draggable = $('.cms-draggable-' + this.options.plugin_id);
            Severity: Major
            Found in cms/static/cms/js/modules/cms.plugins.js - About 2 hrs to fix

              Function movePlugin has 53 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  movePlugin: function(opts) {
                      // cancel request if already in progress
                      if (CMS.API.locked) {
                          return false;
                      }
              Severity: Major
              Found in cms/static/cms/js/modules/cms.plugins.js - About 2 hrs to fix

                Function setupUI has 53 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    _setupUI: function setupUI(container) {
                        var wrapper = $(`.${container}`);
                        var contents;
                
                        // have to check for cms-plugin, there can be a case when there are multiple
                Severity: Major
                Found in cms/static/cms/js/modules/cms.plugins.js - About 2 hrs to fix

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

                      _toggleCollapsable: function toggleCollapsable(el) {
                          var that = this;
                          var id = that._getId(el.parent());
                          var draggable = el.closest('.cms-draggable');
                          var items;
                  Severity: Major
                  Found in cms/static/cms/js/modules/cms.plugins.js - About 2 hrs to fix

                    Function copyPlugin has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        copyPlugin: function(opts, source_language) {
                            // cancel request if already in progress
                            if (CMS.API.locked) {
                                return false;
                            }
                    Severity: Minor
                    Found in cms/static/cms/js/modules/cms.plugins.js - About 2 hrs to fix

                      Function initModal has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                              var initModal = once(function initModal() {
                                  var placeholder = $(
                                      '<div class="cms-add-plugin-placeholder">' + CMS.config.lang.addPluginPlaceholder + '</div>'
                                  );
                                  var dragItem = nav.closest('.cms-dragitem');
                      Severity: Minor
                      Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

                        Function toggleCollapsable has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
                        Open

                            _toggleCollapsable: function toggleCollapsable(el) {
                                var that = this;
                                var id = that._getId(el.parent());
                                var draggable = el.closest('.cms-draggable');
                                var items;
                        Severity: Minor
                        Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

                        Cognitive Complexity

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

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

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

                        Further reading

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

                            _setSettingsMenu: function _setSettingsMenu(nav) {
                                var that = this;
                        
                                this.ui.dropdown = nav.siblings('.cms-submenu-dropdown-settings');
                                var dropdown = this.ui.dropdown;
                        Severity: Minor
                        Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

                          Function setupUI has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
                          Open

                              _setupUI: function setupUI(container) {
                                  var wrapper = $(`.${container}`);
                                  var contents;
                          
                                  // have to check for cms-plugin, there can be a case when there are multiple
                          Severity: Minor
                          Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

                          Cognitive Complexity

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

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

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

                          Further reading

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

                              _checkIfPasteAllowed: function _checkIfPasteAllowed() {
                                  var pasteButton = this.ui.dropdown.find('[data-rel=paste]');
                                  var pasteItem = pasteButton.parent();
                          
                                  if (!clipboardDraggable.length) {
                          Severity: Minor
                          Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

                            Function cutPlugin has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                cutPlugin: function() {
                                    // if cut is once triggered, prevent additional actions
                                    if (CMS.API.locked) {
                                        return false;
                                    }
                            Severity: Minor
                            Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

                              Function _setPluginContentEvents has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  _setPluginContentEvents: function _setPluginContentEvents() {
                                      const pluginDoubleClickEvent = this._getNamepacedEvent(Plugin.doubleClick);
                              
                                      this.ui.container
                                          .off('mouseover.cms.plugins')
                              Severity: Minor
                              Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

                                Function refreshPlugins has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                Plugin._refreshPlugins = function refreshPlugins() {
                                    Plugin.aliasPluginDuplicatesMap = {};
                                    Plugin.staticPlaceholderDuplicatesMap = {};
                                    CMS._plugins = uniqWith(CMS._plugins, isEqual);
                                
                                
                                Severity: Minor
                                Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

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

                                      _filterPluginsList: function _filterPluginsList(list, input) {
                                          var items = list.find('.cms-submenu-item');
                                          var titles = list.find('.cms-submenu-item-title');
                                          var query = input.val();
                                  
                                  
                                  Severity: Minor
                                  Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

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

                                        initialize: function initialize(container, options) {
                                            this.options = $.extend(true, {}, this.options, options);
                                    
                                            // create an unique for this component to use it internally
                                            this.uid = uid();
                                    Severity: Minor
                                    Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

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

                                          _updateWithMostUsedPlugins: function _updateWithMostUsedPlugins(plugins) {
                                              const items = plugins.find('.cms-submenu-item');
                                              // eslint-disable-next-line no-unused-vars
                                              const mostUsedPlugins = toPairs(pluginUsageMap).sort(([x, a], [y, b]) => a - b).reverse();
                                              const MAX_MOST_USED_PLUGINS = 5;
                                      Severity: Minor
                                      Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

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

                                            _setupQuickSearch: function _setupQuickSearch(plugins) {
                                                var that = this;
                                                var FILTER_DEBOUNCE_TIMER = 100;
                                                var FILTER_PICK_DEBOUNCE_TIMER = 110;
                                        
                                        
                                        Severity: Minor
                                        Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

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

                                              _setupKeyboardTraversing: function _setupKeyboardTraversing() {
                                                  var dropdown = $('.cms-modal-markup .cms-plugin-picker');
                                                  const keyDownTraverseEvent = this._getNamepacedEvent(Plugin.keyDown, 'traverse');
                                          
                                                  if (!dropdown.length) {
                                          Severity: Minor
                                          Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

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

                                                addPlugin: function(type, name, parent) {
                                                    var params = {
                                                        placeholder_id: this.options.placeholder_id,
                                                        plugin_type: type,
                                                        cms_path: path,
                                            Severity: Minor
                                            Found in cms/static/cms/js/modules/cms.plugins.js - About 1 hr to fix

                                              Function _checkIfPasteAllowed has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                              Open

                                                  _checkIfPasteAllowed: function _checkIfPasteAllowed() {
                                                      var pasteButton = this.ui.dropdown.find('[data-rel=paste]');
                                                      var pasteItem = pasteButton.parent();
                                              
                                                      if (!clipboardDraggable.length) {
                                              Severity: Minor
                                              Found in cms/static/cms/js/modules/cms.plugins.js - About 55 mins to fix

                                              Cognitive Complexity

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

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

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

                                              Further reading

                                              Function initialize has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                                              Open

                                                  initialize: function initialize(container, options) {
                                                      this.options = $.extend(true, {}, this.options, options);
                                              
                                                      // create an unique for this component to use it internally
                                                      this.uid = uid();
                                              Severity: Minor
                                              Found in cms/static/cms/js/modules/cms.plugins.js - About 45 mins to fix

                                              Cognitive Complexity

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

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

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

                                              Further reading

                                              Consider simplifying this complex logical expression.
                                              Open

                                                      if (childRestrictions && childRestrictions.length) {
                                                          resultElements = resultElements.filter(function() {
                                                              var item = $(this);
                                              
                                                              return (
                                              Severity: Major
                                              Found in cms/static/cms/js/modules/cms.plugins.js - About 40 mins to fix

                                                Function _delegate has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                                Open

                                                    _delegate: function _delegate(e) {
                                                        e.preventDefault();
                                                        e.stopPropagation();
                                                
                                                        var nav;
                                                Severity: Minor
                                                Found in cms/static/cms/js/modules/cms.plugins.js - About 35 mins to fix

                                                Cognitive Complexity

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

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

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

                                                Further reading

                                                Avoid too many return statements within this function.
                                                Open

                                                        return true;
                                                Severity: Major
                                                Found in cms/static/cms/js/modules/cms.plugins.js - About 30 mins to fix

                                                  Function copyPlugin has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                  Open

                                                      copyPlugin: function(opts, source_language) {
                                                          // cancel request if already in progress
                                                          if (CMS.API.locked) {
                                                              return false;
                                                          }
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js - About 25 mins to fix

                                                  Cognitive Complexity

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

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

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

                                                  Further reading

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

                                                              error: function(jqXHR) {
                                                                  CMS.API.locked = false;
                                                                  var msg = CMS.config.lang.error;
                                                  
                                                                  // trigger error
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 3 hrs to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 804..814

                                                  Duplicated Code

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

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

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

                                                  Tuning

                                                  This issue has a mass of 113.

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

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

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

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

                                                  Refactorings

                                                  Further Reading

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

                                                              error: function(jqXHR) {
                                                                  CMS.API.locked = false;
                                                                  var msg = CMS.config.lang.error;
                                                  
                                                                  // trigger error
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 3 hrs to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 690..700

                                                  Duplicated Code

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

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

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

                                                  Tuning

                                                  This issue has a mass of 113.

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

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

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

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

                                                  Refactorings

                                                  Further Reading

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

                                                          if (this.ui.draggable && this.ui.draggable.hasClass('cms-draggable-disabled')) {
                                                              pasteItem.addClass('cms-submenu-item-disabled');
                                                              pasteItem.find('a').attr('tabindex', '-1').attr('aria-disabled', 'true');
                                                              pasteItem.find('.cms-submenu-item-paste-tooltip-disabled').css('display', 'block');
                                                              return false;
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 2 other locations - About 1 hr to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 462..467
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 487..495

                                                  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

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

                                                              if (
                                                                  (bounds.length && $.inArray(type, bounds) === -1) ||
                                                                  (parent_bounds.length && $.inArray(currentPluginType, parent_bounds) === -1)
                                                              ) {
                                                                  pasteItem.addClass('cms-submenu-item-disabled');
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 2 other locations - About 1 hr to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 462..467
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 469..474

                                                  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

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

                                                          if (!clipboardDraggable.length) {
                                                              pasteItem.addClass('cms-submenu-item-disabled');
                                                              pasteItem.find('a').attr('tabindex', '-1').attr('aria-disabled', 'true');
                                                              pasteItem.find('.cms-submenu-item-paste-tooltip-empty').css('display', 'block');
                                                              return false;
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 2 other locations - About 1 hr to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 469..474
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 487..495

                                                  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

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

                                                  const isContentReady = () =>
                                                      CMS.config.settings.mode !== 'structure' ||
                                                      CMS.config.settings.legacy_mode ||
                                                      CMS.API.StructureBoard._loadedContent;
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 1 hr to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 34..37

                                                  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

                                                  const isStructureReady = () =>
                                                      CMS.config.settings.mode === 'structure' ||
                                                      CMS.config.settings.legacy_mode ||
                                                      CMS.API.StructureBoard._loadedStructure;
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 1 hr to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 38..41

                                                  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

                                                                  items.each(function() {
                                                                      var item = $(this);
                                                  
                                                                      if (!item.hasClass('cms-dragitem-expanded')) {
                                                                          that._toggleCollapsable(item);
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 1 hr to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 1702..1708

                                                  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

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

                                                          items.each(function() {
                                                              var item = $(this);
                                                  
                                                              if (!item.hasClass('cms-dragitem-expanded')) {
                                                                  that._toggleCollapsable(item);
                                                  Severity: Major
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 1 hr to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 1592..1598

                                                  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

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

                                                          items.each(function() {
                                                              var item = $(this);
                                                  
                                                              if (item.hasClass('cms-dragitem-expanded')) {
                                                                  that._toggleCollapsable(item);
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 55 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 1571..1577

                                                  Duplicated Code

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

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

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

                                                  Tuning

                                                  This issue has a mass of 53.

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

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

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

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

                                                  Refactorings

                                                  Further Reading

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

                                                              case 'edit':
                                                                  that.editPlugin(
                                                                      Helpers.updateUrlWithPath(that.options.urls.edit_plugin),
                                                                      that.options.plugin_name,
                                                                      that._getPluginBreadcrumbs()
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 55 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 1382..1388

                                                  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

                                                                  items.each(function() {
                                                                      var item = $(this);
                                                  
                                                                      if (item.hasClass('cms-dragitem-expanded')) {
                                                                          that._toggleCollapsable(item);
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 55 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 1730..1736

                                                  Duplicated Code

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

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

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

                                                  Tuning

                                                  This issue has a mass of 53.

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

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

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

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

                                                  Refactorings

                                                  Further Reading

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

                                                              case 'delete':
                                                                  that.deletePlugin(
                                                                      Helpers.updateUrlWithPath(that.options.urls.delete_plugin),
                                                                      that.options.plugin_name,
                                                                      that._getPluginBreadcrumbs()
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 55 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 1356..1362

                                                  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

                                                          nav
                                                              .on([Plugin.pointerUp, Plugin.pointerDown, Plugin.click, Plugin.doubleClick].join(' '))
                                                              .on([Plugin.pointerUp, Plugin.pointerDown, Plugin.click, Plugin.doubleClick].join(' '), function(e) {
                                                                  e.stopPropagation();
                                                              });
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 40 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 1135..1137

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

                                                                          if (includes(['OBJECT', 'EMBED', 'APPLET'], el.nodeName)) {
                                                                              const element = $(el);
                                                  
                                                                              element.wrap('<cms-plugin class="cms-plugin-object-node"></cms-plugin>');
                                                                              itemContents[index] = element.parent()[0];
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 40 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 187..192

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

                                                                          if (el.nodeType === Node.TEXT_NODE && !el.textContent.match(/^\s*$/)) {
                                                                              const element = $(el);
                                                  
                                                                              element.wrap('<cms-plugin class="cms-plugin-text-node"></cms-plugin>');
                                                                              itemContents[index] = element.parent()[0];
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 40 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 179..184

                                                  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

                                                          var modal = new Modal({
                                                              onClose: this.options.onClose || false,
                                                              redirectOnClose: this.options.redirectOnClose || false
                                                          });
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 40 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 558..561

                                                  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

                                                          nav.on([Plugin.pointerUp, Plugin.pointerDown, Plugin.click, Plugin.doubleClick].join(' '), function(e) {
                                                              e.stopPropagation();
                                                          });
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 40 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 977..981

                                                  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

                                                          var modal = new Modal({
                                                              onClose: this.options.onClose || false,
                                                              redirectOnClose: this.options.redirectOnClose || false
                                                          });
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 40 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 858..861

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

                                                              Helpers.addEventListener('modal-closed', (e, { instance }) => {
                                                                  if (instance !== modal) {
                                                                      return;
                                                                  }
                                                                  Plugin._removeAddPluginPlaceholder();
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 35 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 539..544

                                                  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

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

                                                          Helpers.addEventListener('modal-closed.add-plugin', (e, { instance }) => {
                                                              if (instance !== modal) {
                                                                  return;
                                                              }
                                                              Plugin._removeAddPluginPlaceholder();
                                                  Severity: Minor
                                                  Found in cms/static/cms/js/modules/cms.plugins.js and 1 other location - About 35 mins to fix
                                                  cms/static/cms/js/modules/cms.plugins.js on lines 1075..1080

                                                  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

                                                  There are no issues that match your filters.

                                                  Category
                                                  Status