webcol/Calima

View on GitHub
public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js

Summary

Maintainability
F
1 mo
Test Coverage

File jquery.dataTables.js has 6052 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*! DataTables 1.10.4
 * ©2008-2014 SpryMedia Ltd - datatables.net/license
 */

/**

    Function _fnScrollDraw has 174 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        function _fnScrollDraw ( settings )
        {
            // Given that this is such a monster function, a lot of variables are use
            // to try and keep the minimised size as small as possible
            var

      Function _fnAddOptionsHtml has 108 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          function _fnAddOptionsHtml ( oSettings )
          {
              var classes = oSettings.oClasses;
              var table = $(oSettings.nTable);
              var holding = $('<div/>').insertBefore( table ); // Holding element for speed

        Function _fnCalculateColumnWidths has 106 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            function _fnCalculateColumnWidths ( oSettings )
            {
                var
                    table = oSettings.nTable,
                    columns = oSettings.aoColumns,

          Function _fnFeatureHtmlTable has 102 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              function _fnFeatureHtmlTable ( settings )
              {
                  var table = $(settings.nTable);
              
                  // Add the ARIA grid role to the table

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

                function _fnDraw( oSettings )
                {
                    /* Provide a pre-callback function which can be used to cancel the draw is false is returned */
                    var aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );
                    if ( $.inArray( false, aPreDraw ) !== -1 )

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

                  function _fnBuildAjax( oSettings, data, fn )
                  {
                      // Compatibility with 1.9-, allow fnServerData and event to manipulate
                      _fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );
                  

                Function _fnColumnOptions has 82 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    function _fnColumnOptions( oSettings, iCol, oOptions )
                    {
                        var oCol = oSettings.aoColumns[ iCol ];
                        var oClasses = oSettings.oClasses;
                        var th = $(oCol.nTh);

                  Function _fnGetObjectDataFn has 80 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      function _fnGetObjectDataFn( mSource )
                      {
                          if ( $.isPlainObject( mSource ) )
                          {
                              /* Build an object of get functions, and wrap them in a single call */

                    Function _ has 76 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                                _: function ( settings, host, idx, buttons, page, pages ) {
                                    var classes = settings.oClasses;
                                    var lang = settings.oLanguage.oPaginate;
                                    var btnDisplay, btnClass, counter=0;
                        

                      Function _fnAjaxParameters has 72 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          function _fnAjaxParameters( settings )
                          {
                              var
                                  columns = settings.aoColumns,
                                  columnCount = columns.length,

                        Function _fnSort has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            function _fnSort ( oSettings )
                            {
                                var
                                    i, ien, iLen, j, jLen, k, kLen,
                                    sDataType, nTh,

                          Function _fnSetObjectDataFn has 70 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              function _fnSetObjectDataFn( mSource )
                              {
                                  if ( $.isPlainObject( mSource ) )
                                  {
                                      /* Unlike get, only the underscore (global) option is used for for

                            Function _fnDrawHead has 65 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                function _fnDrawHead( oSettings, aoSource, bIncludeHidden )
                                {
                                    var i, iLen, j, jLen, k, kLen, n, nLocalTr;
                                    var aoLocal = [];
                                    var aApplied = [];

                              Function attach has 63 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                              var attach = function( container, buttons ) {
                                                  var i, ien, node, button;
                                                  var clickHandler = function ( e ) {
                                                      _fnPageChange( settings, e.data.action, true );
                                                  };

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

                                    function _fnGetRowElements( settings, row, colIdx, d )
                                    {
                                        var
                                            tds = [],
                                            td = row.firstChild,

                                  Function _fnFeatureHtmlFilter has 60 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      function _fnFeatureHtmlFilter ( settings )
                                      {
                                          var classes = settings.oClasses;
                                          var tableId = settings.sTableId;
                                          var language = settings.oLanguage;

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

                                        var __column_selector = function ( settings, selector, opts )
                                        {
                                            var
                                                columns = settings.aoColumns,
                                                names = _pluck( columns, 'sName' ),

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

                                          function _fnPageChange ( settings, action, redraw )
                                          {
                                              var
                                                  start     = settings._iDisplayStart,
                                                  len       = settings._iDisplayLength,

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

                                                iterator: function ( flatten, type, fn, alwaysNew ) {
                                                    var
                                                        a = [], ret,
                                                        i, ien, j, jen,
                                                        context = this.context,

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

                                              function _fnSortListener ( settings, colIdx, append, callback )
                                              {
                                                  var col = settings.aoColumns[ colIdx ];
                                                  var sorting = settings.aaSorting;
                                                  var asSorting = col.asSorting;

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

                                                function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )
                                                {
                                                    var i, iLen, j, jLen, k, kLen, def;
                                                    var columns = oSettings.aoColumns;
                                                

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

                                                  function _fnSortFlatten ( settings )
                                                  {
                                                      var
                                                          i, iLen, k, kLen,
                                                          aSort = [],

                                                Function _fnBuildHead has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                    function _fnBuildHead( oSettings )
                                                    {
                                                        var i, ien, cell, row, column;
                                                        var thead = oSettings.nTHead;
                                                        var tfoot = oSettings.nTFoot;

                                                  Function _fnDetectHeader has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                      function _fnDetectHeader ( aLayout, nThead )
                                                      {
                                                          var nTrs = $(nThead).children('tr');
                                                          var nTr, nCell;
                                                          var i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;

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

                                                        var __cell_selector = function ( settings, selector, opts )
                                                        {
                                                            var data = settings.aoData;
                                                            var rows = _selector_row_indexes( settings, opts );
                                                            var cells = _removeEmpty( _pluck_order( data, rows, 'anCells' ) );

                                                      Function _fnCreateTr has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                          function _fnCreateTr ( oSettings, iRow, nTrIn, anTds )
                                                          {
                                                              var
                                                                  row = oSettings.aoData[iRow],
                                                                  rowData = row._aData,

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

                                                            function _fnFilterData ( settings )
                                                            {
                                                                var columns = settings.aoColumns;
                                                                var column;
                                                                var i, j, ien, jen, filterData, cellData, row;

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

                                                              var _selector_row_indexes = function ( settings, opts )
                                                              {
                                                                  var
                                                                      i, ien, tmp, a=[],
                                                                      displayFiltered = settings.aiDisplay,

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

                                                                var __details_events = function ( settings )
                                                                {
                                                                    var api = new _Api( settings );
                                                                    var namespace = '.dt.DT_details';
                                                                    var drawEvent = 'draw'+namespace;

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

                                                                          var setData = function (data, val, src) {
                                                                              var a = _fnSplitObjNotation( src ), b;
                                                                              var aLast = a[a.length-1];
                                                                              var arrayNotation, funcNotation, o, innerSrc;
                                                                  

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

                                                                    function _fnFeatureHtmlPaginate ( settings )
                                                                    {
                                                                        var
                                                                            type   = settings.sPaginationType,
                                                                            plugin = DataTable.ext.pager[ type ],

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

                                                                      function _fnInitialise ( settings )
                                                                      {
                                                                          var i, iLen, iAjaxStart=settings.iInitDisplayStart;
                                                                          var columns = settings.aoColumns, column;
                                                                          var features = settings.oFeatures;

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

                                                                        function _fnInvalidate( settings, rowIdx, src, colIdx )
                                                                        {
                                                                            var row = settings.aoData[ rowIdx ];
                                                                            var i, ien;
                                                                            var cellWrite = function ( cell, col ) {

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

                                                                                  var fetchData = function (data, type, src) {
                                                                                      var arrayNotation, funcNotation, out, innerSrc;
                                                                          
                                                                                      if ( src !== "" )
                                                                                      {

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

                                                                            function _fnLoadState ( settings, oInit )
                                                                            {
                                                                                var i, ien;
                                                                                var columns = settings.aoColumns;
                                                                            

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

                                                                              function _fnColumnTypes ( settings )
                                                                              {
                                                                                  var columns = settings.aoColumns;
                                                                                  var data = settings.aoData;
                                                                                  var types = DataTable.ext.type.detect;

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

                                                                                var __setColumnVis = function ( settings, column, vis, recalc ) {
                                                                                    var
                                                                                        cols = settings.aoColumns,
                                                                                        col  = cols[ column ],
                                                                                        data = settings.aoData,

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

                                                                                  function _fnFeatureHtmlLength ( settings )
                                                                                  {
                                                                                      var
                                                                                          classes  = settings.oClasses,
                                                                                          tableId  = settings.sTableId,

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

                                                                                    var __row_selector = function ( settings, selector, opts )
                                                                                    {
                                                                                        return _selector_run( selector, function ( sel ) {
                                                                                            var selInt = _intVal( sel );
                                                                                            var i, ien;

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

                                                                                              jqueryui: function ( settings, cell, column, classes ) {
                                                                                                  $('<div/>')
                                                                                                      .addClass( classes.sSortJUIWrapper )
                                                                                                      .append( cell.contents() )
                                                                                                      .append( $('<span/>')

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

                                                                                        function _fnBrowserDetect( settings )
                                                                                        {
                                                                                            var browser = settings.oBrowser;
                                                                                        
                                                                                            // Scrolling feature / quirks detection

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

                                                                                          function _fnSortAria ( settings )
                                                                                          {
                                                                                              var label;
                                                                                              var nextSort;
                                                                                              var columns = settings.aoColumns;

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

                                                                                            var _toSettings = function ( mixed )
                                                                                            {
                                                                                                var idx, jq;
                                                                                                var settings = DataTable.settings;
                                                                                                var tables = $.map( settings, function (el, i) {

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

                                                                                              var __details_add = function ( ctx, row, data, klass )
                                                                                              {
                                                                                                  // Convert to array of TR elements
                                                                                                  var rows = [];
                                                                                                  var addRow = function ( r, k ) {

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

                                                                                                function _fnFilterComplete ( oSettings, oInput, iForce )
                                                                                                {
                                                                                                    var oPrevSearch = oSettings.oPreviousSearch;
                                                                                                    var aoPrevSearch = oSettings.aoPreSearchCols;
                                                                                                    var fnSaveFilter = function ( oFilter ) {

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

                                                                                                  function _fnScrollBarWidth ()
                                                                                                  {
                                                                                                      // On first run a static variable is set, since this is only needed once.
                                                                                                      // Subsequent runs will just use the previously calculated value
                                                                                                      if ( ! DataTable.__scrollbarWidth ) {

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

                                                                                                    function _fnGetCellData( settings, rowIdx, colIdx, type )
                                                                                                    {
                                                                                                        var draw           = settings.iDraw;
                                                                                                        var col            = settings.aoColumns[colIdx];
                                                                                                        var rowData        = settings.aoData[rowIdx]._aData;

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

                                                                                                      function _numbers ( page, pages ) {
                                                                                                          var
                                                                                                              numbers = [],
                                                                                                              buttons = extPagination.numbers_length,
                                                                                                              half = Math.floor( buttons / 2 ),

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

                                                                                                        function _fnAjaxUpdateDraw ( settings, json )
                                                                                                        {
                                                                                                            // v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.
                                                                                                            // Support both
                                                                                                            var compat = function ( old, modern ) {

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

                                                                                                          function _fnFilter( settings, input, force, regex, smart, caseInsensitive )
                                                                                                          {
                                                                                                              var rpSearch = _fnFilterCreateSearch( input, regex, smart, caseInsensitive );
                                                                                                              var prevSearch = settings.oPreviousSearch.sSearch;
                                                                                                              var displayMaster = settings.aiDisplayMaster;

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

                                                                                                                this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )
                                                                                                        Severity: Minor
                                                                                                        Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

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

                                                                                                              function _fnFilterColumn ( settings, searchStr, colIdx, regex, smart, caseInsensitive )
                                                                                                          Severity: Minor
                                                                                                          Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

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

                                                                                                                function _fnReduce ( that, fn, init, start, end, inc )
                                                                                                            Severity: Minor
                                                                                                            Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

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

                                                                                                                          _: function ( settings, host, idx, buttons, page, pages ) {
                                                                                                              Severity: Minor
                                                                                                              Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

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

                                                                                                                    function _fnFilter( settings, input, force, regex, smart, caseInsensitive )
                                                                                                                Severity: Minor
                                                                                                                Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                  Open

                                                                                                                                          if ( cache[k] === undefined ) {
                                                                                                                                              cache[k] = _fnGetCellData( settings, k, i, 'type' );
                                                                                                                                          }
                                                                                                                  Severity: Major
                                                                                                                  Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                    Open

                                                                                                                                            while( columns.length <= aTargets[j] )
                                                                                                                                            {
                                                                                                                                                _fnAddColumn( oSettings );
                                                                                                                                            }
                                                                                                                    Severity: Major
                                                                                                                    Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                      Open

                                                                                                                                          if ((tmp === -1 && search == 'removed') ||
                                                                                                                                              (tmp >= 0   && search == 'applied') )
                                                                                                                                          {
                                                                                                                                              a.push( i );
                                                                                                                                          }
                                                                                                                      Severity: Major
                                                                                                                      Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                        Open

                                                                                                                                                if ( ! detectedType && j !== types.length-1 ) {
                                                                                                                                                    break;
                                                                                                                                                }
                                                                                                                        Severity: Major
                                                                                                                        Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                          Open

                                                                                                                                              else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )
                                                                                                                                              {
                                                                                                                                                  /* Negative integer, right to left column counting */
                                                                                                                                                  fn( columns.length+aTargets[j], def );
                                                                                                                                              }
                                                                                                                          Severity: Major
                                                                                                                          Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                            Open

                                                                                                                                                        if ( s( o, _fnGetCellData(settings, row, j), host.anCells[j] ) ) {
                                                                                                                                                            a.push( o );
                                                                                                                                                        }
                                                                                                                            Severity: Major
                                                                                                                            Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                              Open

                                                                                                                                                      if ( arrayNotation )
                                                                                                                                                      {
                                                                                                                                                          // Array notation
                                                                                                                                                          a[i] = a[i].replace(__reArray, '');
                                                                                                                                  
                                                                                                                              Severity: Major
                                                                                                                              Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                Open

                                                                                                                                                        if ( fomatters[ column.sType ] ) {
                                                                                                                                                            cellData = fomatters[ column.sType ]( cellData );
                                                                                                                                                        }
                                                                                                                                Severity: Major
                                                                                                                                Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                  Open

                                                                                                                                                      for ( j=0, jen=items.length ; j<jen ; j++ ) {
                                                                                                                                                          item = items[j];
                                                                                                                                      
                                                                                                                                                          if ( type === 'cell' ) {
                                                                                                                                                              ret = fn.call( apiInst, context[i], item.row, item.column, i, j );
                                                                                                                                  Severity: Major
                                                                                                                                  Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                    Open

                                                                                                                                                            for ( k=0 ; k<iRowspan ; k++ )
                                                                                                                                                            {
                                                                                                                                                                aLayout[i+k][iColShifted+l] = {
                                                                                                                                                                    "cell": nCell,
                                                                                                                                                                    "unique": bUnique
                                                                                                                                    Severity: Major
                                                                                                                                    Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                      Open

                                                                                                                                                              if ( typeof cellData !== 'string' && cellData.toString ) {
                                                                                                                                                                  cellData = cellData.toString();
                                                                                                                                                              }
                                                                                                                                      Severity: Major
                                                                                                                                      Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                        Open

                                                                                                                                                            if ( type === 'column-rows' ) {
                                                                                                                                                                rows = _selector_row_indexes( context[i], selector.opts );
                                                                                                                                                            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                          Open

                                                                                                                                                                  if ( detectedType === 'html' ) {
                                                                                                                                                                      break;
                                                                                                                                                                  }
                                                                                                                                          Severity: Major
                                                                                                                                          Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                            Open

                                                                                                                                                                    if ( data === null || data[ a[i] ] === undefined )
                                                                                                                                                                    {
                                                                                                                                                                        return undefined;
                                                                                                                                                                    }
                                                                                                                                            Severity: Major
                                                                                                                                            Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                              Open

                                                                                                                                                                  if ( cOption == aoFeatures[k].cFeature )
                                                                                                                                                                  {
                                                                                                                                                                      featureNode = aoFeatures[k].fnInit( oSettings );
                                                                                                                                                                      break;
                                                                                                                                                                  }
                                                                                                                                              Severity: Major
                                                                                                                                              Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                Open

                                                                                                                                                                        for ( k=0 ; k<iRowspan ; k++ )
                                                                                                                                                                        {
                                                                                                                                                                            aApplied[i+k][j+iColspan] = 1;
                                                                                                                                                                        }
                                                                                                                                                Severity: Major
                                                                                                                                                Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                  Open

                                                                                                                                                                          if ( cellData === null ) {
                                                                                                                                                                              cellData = '';
                                                                                                                                                                          }
                                                                                                                                                  Severity: Major
                                                                                                                                                  Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 45 mins to fix

                                                                                                                                                    Consider simplifying this complex logical expression.
                                                                                                                                                    Open

                                                                                                                                                                    if ( nCell.nodeName.toUpperCase() == "TD" ||
                                                                                                                                                                         nCell.nodeName.toUpperCase() == "TH" )
                                                                                                                                                                    {
                                                                                                                                                                        /* Get the col and rowspan attributes from the DOM and sanitise them */
                                                                                                                                                                        iColspan = nCell.getAttribute('colspan') * 1;
                                                                                                                                                    Severity: Major
                                                                                                                                                    Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 40 mins to fix

                                                                                                                                                      Consider simplifying this complex logical expression.
                                                                                                                                                      Open

                                                                                                                                                              if ( ! userInputs && ! scrollX && ! scrollY &&
                                                                                                                                                                  columnCount == _fnVisbleColumns( oSettings ) &&
                                                                                                                                                                  columnCount == headerCells.length
                                                                                                                                                              ) {
                                                                                                                                                                  for ( i=0 ; i<columnCount ; i++ ) {
                                                                                                                                                      Severity: Major
                                                                                                                                                      Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 40 mins to fix

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

                                                                                                                                                            var __columnData = function ( settings, column, r1, r2, rows ) {
                                                                                                                                                        Severity: Minor
                                                                                                                                                        Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 35 mins to fix

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

                                                                                                                                                                  this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )
                                                                                                                                                          Severity: Minor
                                                                                                                                                          Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 35 mins to fix

                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                            Open

                                                                                                                                                                        return function (data, type) { // row and meta also passed, but not used
                                                                                                                                                                            return data[mSource];
                                                                                                                                                                        };
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 30 mins to fix

                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                              Open

                                                                                                                                                                              return $( nodes )
                                                                                                                                                                                  .filter( s )
                                                                                                                                                                                  .map( function () {
                                                                                                                                                                                      return $.inArray( this, nodes ); // `nodes` is column index complete and in order
                                                                                                                                                                                  } )
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 30 mins to fix

                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                Open

                                                                                                                                                                            return function (data, val) { // meta is also passed in, but not used
                                                                                                                                                                                data[mSource] = val;
                                                                                                                                                                            };
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 30 mins to fix

                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                  Open

                                                                                                                                                                              return;
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 30 mins to fix

                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                    Open

                                                                                                                                                                                        return [ sel._DT_RowIndex ]; // sel is a TR node that is in the table
                                                                                                                                                                    Severity: Major
                                                                                                                                                                    Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 30 mins to fix

                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                      Open

                                                                                                                                                                                  return $(nodes)
                                                                                                                                                                                      .filter( sel )
                                                                                                                                                                                      .map( function () {
                                                                                                                                                                                          return this._DT_RowIndex;
                                                                                                                                                                                      } )
                                                                                                                                                                      Severity: Major
                                                                                                                                                                      Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 30 mins to fix

                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                        Open

                                                                                                                                                                                    return jq.map( function(i) {
                                                                                                                                                                                        idx = $.inArray( this, tables );
                                                                                                                                                                                        return idx !== -1 ? settings[idx] : null;
                                                                                                                                                                                    } ).toArray();
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 30 mins to fix

                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                          Open

                                                                                                                                                                                                  return [ _fnVisibleToColumnIndex( settings, idx ) ];
                                                                                                                                                                          Severity: Major
                                                                                                                                                                          Found in public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js - About 30 mins to fix

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

                                                                                                                                                                                _api_register( 'rows()', function ( selector, opts ) {
                                                                                                                                                                                    // argument shifting
                                                                                                                                                                                    if ( selector === undefined ) {
                                                                                                                                                                                        selector = '';
                                                                                                                                                                                    }
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 8252..8273

                                                                                                                                                                            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

                                                                                                                                                                                _api_register( 'columns()', function ( selector, opts ) {
                                                                                                                                                                                    // argument shifting
                                                                                                                                                                                    if ( selector === undefined ) {
                                                                                                                                                                                        selector = '';
                                                                                                                                                                                    }
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 7694..7715

                                                                                                                                                                            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

                                                                                                                                                                                    else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||
                                                                                                                                                                                              mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )
                                                                                                                                                                                    {
                                                                                                                                                                                        /* If there is a . in the source string then the data source is in a
                                                                                                                                                                                         * nested object so we loop over the data for each level to get the next
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 1314..1391

                                                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                                                            Tuning

                                                                                                                                                                            This issue has a mass of 62.

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

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

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

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

                                                                                                                                                                            Refactorings

                                                                                                                                                                            Further Reading

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

                                                                                                                                                                                    else if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||
                                                                                                                                                                                              mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )
                                                                                                                                                                                    {
                                                                                                                                                                                        /* Like the get, we need to get data from a nested object */
                                                                                                                                                                                        var setData = function (data, val, src) {
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 1201..1281

                                                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                                                            Tuning

                                                                                                                                                                            This issue has a mass of 62.

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

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

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

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

                                                                                                                                                                            Refactorings

                                                                                                                                                                            Further Reading

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

                                                                                                                                                                                        for ( var i=0, ien=src.length ; i<ien ; i++ ) {
                                                                                                                                                                                            if ( src[i].name === name ) {
                                                                                                                                                                                                return src[i];
                                                                                                                                                                                            }
                                                                                                                                                                                        }
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/dataTables.responsive.js on lines 520..524

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

                                                                                                                                                                                            $.extend( preSearch[ column ], {
                                                                                                                                                                                                "sSearch": input+"",
                                                                                                                                                                                                "bRegex":  regex === null ? false : regex,
                                                                                                                                                                                                "bSmart":  smart === null ? true  : smart,
                                                                                                                                                                                                "bCaseInsensitive": caseInsen === null ? true : caseInsen
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 8697..8702

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

                                                                                                                                                                            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

                                                                                                                                                                                        _fnFilterComplete( settings, $.extend( {}, settings.oPreviousSearch, {
                                                                                                                                                                                            "sSearch": input+"",
                                                                                                                                                                                            "bRegex":  regex === null ? false : regex,
                                                                                                                                                                                            "bSmart":  smart === null ? true  : smart,
                                                                                                                                                                                            "bCaseInsensitive": caseInsen === null ? true : caseInsen
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 8724..8729

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

                                                                                                                                                                            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

                                                                                                                                                                                _api_register( 'ajax.json()', function () {
                                                                                                                                                                                    var ctx = this.context;
                                                                                                                                                                                
                                                                                                                                                                                    if ( ctx.length > 0 ) {
                                                                                                                                                                                        return ctx[0].json;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 7399..7407

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

                                                                                                                                                                            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

                                                                                                                                                                                _api_register( 'ajax.params()', function () {
                                                                                                                                                                                    var ctx = this.context;
                                                                                                                                                                                
                                                                                                                                                                                    if ( ctx.length > 0 ) {
                                                                                                                                                                                        return ctx[0].oAjaxData;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 7385..7393

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

                                                                                                                                                                            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

                                                                                                                                                                                _api_registerPlural( 'columns().header()', 'column().header()', function ( selector, opts ) {
                                                                                                                                                                                    return this.iterator( 'column', function ( settings, column ) {
                                                                                                                                                                                        return settings.aoColumns[column].nTh;
                                                                                                                                                                                    }, 1 );
                                                                                                                                                                                } );
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 8289..8293

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

                                                                                                                                                                                _api_registerPlural( 'columns().footer()', 'column().footer()', function ( selector, opts ) {
                                                                                                                                                                                    return this.iterator( 'column', function ( settings, column ) {
                                                                                                                                                                                        return settings.aoColumns[column].nTf;
                                                                                                                                                                                    }, 1 );
                                                                                                                                                                                } );
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 8279..8283

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

                                                                                                                                                                                                    $(_div, { 'class': classes.sScrollFootInner } )
                                                                                                                                                                                                        .append(
                                                                                                                                                                                                            footerClone
                                                                                                                                                                                                                .removeAttr('id')
                                                                                                                                                                                                                .css( 'margin-left', 0 )
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 3644..3657

                                                                                                                                                                            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

                                                                                                                                                                                function _fnSearchToCamel ( obj )
                                                                                                                                                                                {
                                                                                                                                                                                    return {
                                                                                                                                                                                        search:          obj.sSearch,
                                                                                                                                                                                        smart:           obj.bSmart,
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 3121..3129

                                                                                                                                                                            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

                                                                                                                                                                                function _fnSearchToHung ( obj )
                                                                                                                                                                                {
                                                                                                                                                                                    return {
                                                                                                                                                                                        sSearch:          obj.search,
                                                                                                                                                                                        bSmart:           obj.smart,
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 3102..3110

                                                                                                                                                                            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

                                                                                                                                                                                                    $(_div, { 'class': classes.sScrollHeadInner } )
                                                                                                                                                                                                        .css( {
                                                                                                                                                                                                            'box-sizing': 'content-box',
                                                                                                                                                                                                            width: scroll.sXInner || '100%'
                                                                                                                                                                                                        } )
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 3679..3688

                                                                                                                                                                            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 'next':
                                                                                                                                                                                                                btnDisplay = lang.sNext;
                                                                                                                                                                                                                btnClass = button + (page < pages-1 ?
                                                                                                                                                                                                                    '' : ' '+classes.sPageButtonDisabled);
                                                                                                                                                                                                                break;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 14147..14151

                                                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                                                            Tuning

                                                                                                                                                                            This issue has a mass of 49.

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

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

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

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

                                                                                                                                                                            Refactorings

                                                                                                                                                                            Further Reading

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

                                                                                                                                                                                                            case 'last':
                                                                                                                                                                                                                btnDisplay = lang.sLast;
                                                                                                                                                                                                                btnClass = button + (page < pages-1 ?
                                                                                                                                                                                                                    '' : ' '+classes.sPageButtonDisabled);
                                                                                                                                                                                                                break;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 14141..14145

                                                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                                                            Tuning

                                                                                                                                                                            This issue has a mass of 49.

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

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

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

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

                                                                                                                                                                            Refactorings

                                                                                                                                                                            Further Reading

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

                                                                                                                                                                                    if ( data === undefined ) {
                                                                                                                                                                                        // get
                                                                                                                                                                                        return ctx.length && this.length ?
                                                                                                                                                                                            ctx[0].aoData[ this[0] ]._details :
                                                                                                                                                                                            undefined;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 7820..7825

                                                                                                                                                                            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

                                                                                                                                                                                    if ( data === undefined ) {
                                                                                                                                                                                        // Get
                                                                                                                                                                                        return ctx.length && this.length ?
                                                                                                                                                                                            ctx[0].aoData[ this[0] ]._aData :
                                                                                                                                                                                            undefined;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 8023..8040

                                                                                                                                                                            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

                                                                                                                                                                                                            case 'first':
                                                                                                                                                                                                                btnDisplay = lang.sFirst;
                                                                                                                                                                                                                btnClass = button + (page > 0 ?
                                                                                                                                                                                                                    '' : ' '+classes.sPageButtonDisabled);
                                                                                                                                                                                                                break;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 14135..14139

                                                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                                                            Tuning

                                                                                                                                                                            This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                            Refactorings

                                                                                                                                                                            Further Reading

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

                                                                                                                                                                                    "fnRecordsTotal": function ()
                                                                                                                                                                                    {
                                                                                                                                                                                        return _fnDataSource( this ) == 'ssp' ?
                                                                                                                                                                                            this._iRecordsTotal * 1 :
                                                                                                                                                                                            this.aiDisplayMaster.length;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 13343..13348

                                                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                                                            Tuning

                                                                                                                                                                            This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                            Refactorings

                                                                                                                                                                            Further Reading

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

                                                                                                                                                                                    "fnRecordsDisplay": function ()
                                                                                                                                                                                    {
                                                                                                                                                                                        return _fnDataSource( this ) == 'ssp' ?
                                                                                                                                                                                            this._iRecordsDisplay * 1 :
                                                                                                                                                                                            this.aiDisplay.length;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 13332..13337

                                                                                                                                                                            Duplicated Code

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

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

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

                                                                                                                                                                            Tuning

                                                                                                                                                                            This issue has a mass of 45.

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

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

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

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

                                                                                                                                                                            Refactorings

                                                                                                                                                                            Further Reading

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

                                                                                                                                                                                                            case 'previous':
                                                                                                                                                                                                                btnDisplay = lang.sPrevious;
                                                                                                                                                                                                                btnClass = button + (page > 0 ?
                                                                                                                                                                                                                    '' : ' '+classes.sPageButtonDisabled);
                                                                                                                                                                                                                break;
                                                                                                                                                                            public_/plantillas/inspinia/js/plugins/dataTables/jquery.dataTables.js on lines 14129..14133

                                                                                                                                                                            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