gopheracademy/gcon

View on GitHub
assets/admin/global/plugins/fullcalendar/fullcalendar.js

Summary

Maintainability
F
1 mo
Test Coverage

File fullcalendar.js has 7088 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*!
 * FullCalendar v2.4.0
 * Docs & License: http://fullcalendar.io/
 * (c) 2015 Adam Shaw
 */
Severity: Major
Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 wks to fix

    Function EventManager has 736 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    function EventManager(options) { // assumed to be a calendar
        var t = this;
        
        
        // exports
    Severity: Major
    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 3 days to fix

      Function Calendar_constructor has 404 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      function Calendar_constructor(element, overrides) {
          var t = this;
      
      
          t.initOptions(overrides || {});
      Severity: Major
      Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 days to fix

        Function Header has 188 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        function Header(calendar, options) {
            var t = this;
            
            // exports
            t.render = render;
        Severity: Major
        Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 7 hrs to fix

          Function renderSection has 134 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              function renderSection(position) {
                  var sectionEl = $('<div class="fc-' + position + '"/>');
                  var buttonStr = options.header[position];
          
                  if (buttonStr) {
          Severity: Major
          Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 5 hrs to fix

            Function _fetchEventSource has 91 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                function _fetchEventSource(source, callback) {
                    var i;
                    var fetchers = fc.sourceFetchers;
                    var res;
            
            
            Severity: Major
            Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 3 hrs to fix

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

                  limitRow: function(row, levelLimit) {
                      var _this = this;
                      var rowStruct = this.rowStructs[row];
                      var moreNodes = []; // array of "more" <a> links and <td> DOM nodes
                      var col = 0; // col #, left-to-right (not chronologically)
              Severity: Major
              Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

                Function segDragMousedown has 68 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    segDragMousedown: function(seg, ev) {
                        var _this = this;
                        var view = this.view;
                        var calendar = view.calendar;
                        var el = seg.el;
                Severity: Major
                Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

                  Function renderSegRow has 68 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      renderSegRow: function(row, rowSegs) {
                          var colCnt = this.colCnt;
                          var segLevels = this.buildSegLevels(rowSegs); // group into sub-arrays of levels
                          var levelCnt = Math.max(1, segLevels.length); // ensure at least one level
                          var tbody = $('<tbody/>');
                  Severity: Major
                  Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

                    Function mutateEvent has 64 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        function mutateEvent(event, newProps, largeUnit) {
                            var miscProps = {};
                            var oldProps;
                            var clearEnd;
                            var startDelta;
                    Severity: Major
                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

                      Function buildEventFromInput has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          function buildEventFromInput(input, source) {
                              var out = {};
                              var start, end;
                              var allDay;
                      
                      
                      Severity: Major
                      Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

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

                            function mutateEvents(events, clearEnd, allDay, dateDelta, durationDelta, miscProps) {
                                var isAmbigTimezone = t.getIsAmbigTimezone();
                                var undoFunctions = [];
                        
                                // normalize zero-length deltas to be null
                        Severity: Major
                        Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

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

                          function makeMoment(args, parseAsUTC, parseZone) {
                              var input = args[0];
                              var isSingleString = args.length == 1 && typeof input === 'string';
                              var isAmbigTime;
                              var isAmbigZone;
                          Severity: Major
                          Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

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

                                fgSegHtml: function(seg, disableResizing) {
                                    var view = this.view;
                                    var event = seg.event;
                                    var isDraggable = view.isEventDraggable(event);
                                    var isResizableFromStart = !disableResizing && seg.isStart && view.isEventResizableFromStart(event);
                            Severity: Major
                            Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

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

                                  segResizeMousedown: function(seg, ev, isStart) {
                                      var _this = this;
                                      var view = this.view;
                                      var calendar = view.calendar;
                                      var el = seg.el;
                              Severity: Minor
                              Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 2 hrs to fix

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

                                    buildViewSpec: function(requestedViewType) {
                                        var viewOverrides = this.overrides.views || {};
                                        var specChain = []; // for the view. lowest to highest priority
                                        var defaultsChain = []; // for the view. lowest to highest priority
                                        var overridesChain = []; // for the view. lowest to highest priority
                                Severity: Minor
                                Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                      fgSegHtml: function(seg, disableResizing) {
                                          var view = this.view;
                                          var event = seg.event;
                                          var isDraggable = view.isEventDraggable(event);
                                          var isResizableFromStart = !disableResizing && event.allDay &&
                                  Severity: Minor
                                  Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                        function expandEvent(abstractEvent, _rangeStart, _rangeEnd) {
                                            var events = [];
                                            var dowHash;
                                            var dow;
                                            var i;
                                    Severity: Minor
                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                          function isRangeAllowed(range, constraint, overlap, event) {
                                              var constraintEvents;
                                              var anyContainment;
                                              var peerEvents;
                                              var i, peerEvent;
                                      Severity: Minor
                                      Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                            position: function() {
                                                var options = this.options;
                                                var origin = this.el.offsetParent().offset();
                                                var width = this.el.outerWidth();
                                                var height = this.el.outerHeight();
                                        Severity: Minor
                                        Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                              dayMousedown: function(ev) {
                                                  var _this = this;
                                                  var view = this.view;
                                                  var isSelectable = view.opt('selectable');
                                                  var dayClickCell; // null if invalid dayClick
                                          Severity: Minor
                                          Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                renderFill: function(type, segs, className) {
                                                    var segCols;
                                                    var skeletonEl;
                                                    var trEl;
                                                    var col, colSegs;
                                            Severity: Minor
                                            Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                  rangeToSegs: function(range) {
                                                      var isRTL = this.isRTL;
                                                      var rowCnt = this.rowCnt;
                                                      var colCnt = this.colCnt;
                                                      var segs = [];
                                              Severity: Minor
                                              Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                function formatRangeWithChunks(date1, date2, chunks, separator, isRTL) {
                                                    var chunkStr; // the rendering of the chunk
                                                    var leftI;
                                                    var leftStr = '';
                                                    var rightI;
                                                Severity: Minor
                                                Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                      computeEventDrop: function(startCell, endCell, event) {
                                                          var calendar = this.view.calendar;
                                                          var dragStart = startCell.start;
                                                          var dragEnd = endCell.start;
                                                          var delta;
                                                  Severity: Minor
                                                  Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                    function massageOverrides(input) {
                                                        var overrides = { views: input.views || {} }; // the output. ensure a `views` hash
                                                        var subObj;
                                                    
                                                        // iterate through all option override properties (except `views`)
                                                    Severity: Minor
                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                          listenToExternalDrag: function(el, ev, ui) {
                                                              var _this = this;
                                                              var meta = getDraggedElMeta(el); // extra data about event drop, including possible event to create
                                                              var dragListener;
                                                              var dropLocation; // a null value signals an unsuccessful drag
                                                      Severity: Minor
                                                      Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                            function renderView(viewType) {
                                                                ignoreWindowResize++;
                                                        
                                                                // if viewType is changing, remove the old view's rendering
                                                                if (currentView && viewType && currentView.type !== viewType) {
                                                        Severity: Minor
                                                        Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                          function mergeProps(propObjs, complexProps) {
                                                              var dest = {};
                                                              var i, name;
                                                              var complexObjs;
                                                              var j, val;
                                                          Severity: Minor
                                                          Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                            function distributeHeight(els, availableHeight, shouldRedistribute) {
                                                            
                                                                // *FLOORING NOTE*: we floor in certain places because zoom can give inaccurate floating-point dimensions,
                                                                // and it is better to be shorter than taller, to avoid creating unnecessary scrollbars.
                                                            
                                                            
                                                            Severity: Minor
                                                            Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                  showSegPopover: function(cell, moreLink, segs) {
                                                                      var _this = this;
                                                                      var view = this.view;
                                                                      var moreWrap = moreLink.parent(); // the <div> wrapper around the <a>
                                                                      var topEl; // the element we want to match the top coordinate of
                                                              Severity: Minor
                                                              Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                    function buildEventSource(sourceInput) { // will return undefined if invalid source
                                                                        var normalizers = fc.sourceNormalizers;
                                                                        var source;
                                                                        var i;
                                                                
                                                                
                                                                Severity: Minor
                                                                Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                      getCell: function(x, y) {
                                                                          var rowCoords = this.rowCoords;
                                                                          var rowCnt = rowCoords.length;
                                                                          var colCoords = this.colCoords;
                                                                          var colCnt = colCoords.length;
                                                                  Severity: Minor
                                                                  Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                    function getDraggedElMeta(el) {
                                                                        var prefix = fc.dataAttrPrefix;
                                                                        var eventProps; // properties for creating the event, not related to date/time
                                                                        var startTime; // a Duration
                                                                        var duration;
                                                                    Severity: Minor
                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                          bindSegHandlers: function() {
                                                                              var _this = this;
                                                                              var view = this.view;
                                                                      
                                                                              $.each(
                                                                      Severity: Minor
                                                                      Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                            setHeight: function(totalHeight, isAuto) {
                                                                                var eventLimit;
                                                                                var scrollerHeight;
                                                                        
                                                                                if (this.bottomRuleHeight === null) {
                                                                        Severity: Minor
                                                                        Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                              renderMoreLink: function(cell, hiddenSegs) {
                                                                                  var _this = this;
                                                                                  var view = this.view;
                                                                          
                                                                                  return $('<a class="fc-more"/>')
                                                                          Severity: Minor
                                                                          Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                            function intersectionToSeg(subjectRange, constraintRange) {
                                                                                var subjectStart = subjectRange.start;
                                                                                var subjectEnd = subjectRange.end;
                                                                                var constraintStart = constraintRange.start;
                                                                                var constraintEnd = constraintRange.end;
                                                                            Severity: Minor
                                                                            Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                  getHtmlRenderer: function(rendererName, rowType) {
                                                                                      var view = this.view;
                                                                                      var generalName; // like "cellHtml"
                                                                                      var specificName; // like "dayCellHtml". based on rowType
                                                                                      var provider; // either the View or the RowRenderer subclass, whichever provided the method
                                                                              Severity: Minor
                                                                              Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                    computeEventResize: function(type, startCell, endCell, event) {
                                                                                        var calendar = this.view.calendar;
                                                                                        var delta = this.diffDates(endCell[type], startCell[type]);
                                                                                        var range;
                                                                                        var defaultDuration;
                                                                                Severity: Minor
                                                                                Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                      function getBusinessHoursEvents(wholeDay) {
                                                                                          var optionVal = options.businessHours;
                                                                                          var defaultVal = {
                                                                                              className: 'fc-nonbusiness',
                                                                                              start: '09:00',
                                                                                  Severity: Minor
                                                                                  Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                        eventsToInverseRanges: function(events) {
                                                                                            var view = this.view;
                                                                                            var viewStart = view.start.clone().stripZone(); // normalize timezone
                                                                                            var viewEnd = view.end.clone().stripZone(); // normalize timezone
                                                                                            var normalRanges = this.eventsToNormalRanges(events); // will give us normalized dates we can use w/o copies
                                                                                    Severity: Minor
                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                          slatRowHtml: function() {
                                                                                              var view = this.view;
                                                                                              var isRTL = this.isRTL;
                                                                                              var html = '';
                                                                                              var slotTime = moment.duration(+this.minTime); // wish there was .clone() for durations
                                                                                      Severity: Minor
                                                                                      Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                            function fetchEventSource(source, fetchID) {
                                                                                                _fetchEventSource(source, function(eventInputs) {
                                                                                                    var isArraySource = $.isArray(source.events);
                                                                                                    var i, eventInput;
                                                                                                    var abstractEvent;
                                                                                        Severity: Minor
                                                                                        Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                              stop: function(shouldRevert, callback) {
                                                                                                  var _this = this;
                                                                                                  var revertDuration = this.options.revertDuration;
                                                                                          
                                                                                                  function complete() {
                                                                                          Severity: Minor
                                                                                          Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                                listenStart: function(ev) {
                                                                                                    var subjectEl = this.subjectEl;
                                                                                                    var subjectRect;
                                                                                                    var origPoint;
                                                                                                    var point;
                                                                                            Severity: Minor
                                                                                            Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                                  computeRange: function(date) {
                                                                                                      var intervalUnit = computeIntervalUnit(this.intervalDuration);
                                                                                                      var intervalStart = date.clone().startOf(intervalUnit);
                                                                                                      var intervalEnd = intervalStart.clone().add(this.intervalDuration);
                                                                                                      var start, end;
                                                                                              Severity: Minor
                                                                                              Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                                    renderSegPopoverContent: function(cell, segs) {
                                                                                                        var view = this.view;
                                                                                                        var isTheme = view.opt('theme');
                                                                                                        var title = cell.start.format(view.opt('dayPopoverFormat'));
                                                                                                        var content = $(
                                                                                                Severity: Minor
                                                                                                Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                                      initOptions: function(overrides) {
                                                                                                          var lang, langDefaults;
                                                                                                          var isRTL, dirDefaults;
                                                                                                  
                                                                                                          // converts legacy options into non-legacy ones.
                                                                                                  Severity: Minor
                                                                                                  Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 1 hr to fix

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

                                                                                                        function mutateEvents(events, clearEnd, allDay, dateDelta, durationDelta, miscProps) {
                                                                                                    Severity: Minor
                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 45 mins to fix

                                                                                                      Avoid deeply nested control flow statements.
                                                                                                      Open

                                                                                                                              if (startTime) {
                                                                                                                                  start = start.time(startTime);
                                                                                                                              }
                                                                                                      Severity: Major
                                                                                                      Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 45 mins to fix

                                                                                                        Avoid deeply nested control flow statements.
                                                                                                        Open

                                                                                                                                if (endTime) {
                                                                                                                                    end = date.clone().time(endTime);
                                                                                                                                }
                                                                                                        Severity: Major
                                                                                                        Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 45 mins to fix

                                                                                                          Avoid deeply nested control flow statements.
                                                                                                          Open

                                                                                                                                                  if (
                                                                                                                                                      button.hasClass(tm + '-state-active') ||
                                                                                                                                                      button.hasClass(tm + '-state-disabled')
                                                                                                                                                  ) {
                                                                                                                                                      button.removeClass(tm + '-state-hover');
                                                                                                          Severity: Major
                                                                                                          Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 45 mins to fix

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

                                                                                                            function formatRange(date1, date2, formatStr, separator, isRTL) {
                                                                                                            Severity: Minor
                                                                                                            Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 35 mins to fix

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

                                                                                                                  triggerEventResize: function(event, durationDelta, undoFunc, el, ev) {
                                                                                                              Severity: Minor
                                                                                                              Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 35 mins to fix

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

                                                                                                                    reportEventDrop: function(event, dropLocation, largeUnit, el, ev) {
                                                                                                                Severity: Minor
                                                                                                                Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 35 mins to fix

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

                                                                                                                      triggerEventDrop: function(event, dateDelta, undoFunc, el, ev) {
                                                                                                                  Severity: Minor
                                                                                                                  Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 35 mins to fix

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

                                                                                                                        reportExternalDrop: function(meta, dropLocation, el, ev, ui) {
                                                                                                                    Severity: Minor
                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 35 mins to fix

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

                                                                                                                          triggerExternalDrop: function(event, dropLocation, el, ev, ui) {
                                                                                                                      Severity: Minor
                                                                                                                      Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 35 mins to fix

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

                                                                                                                            reportEventResize: function(event, resizeLocation, largeUnit, el, ev) {
                                                                                                                        Severity: Minor
                                                                                                                        Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 35 mins to fix

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

                                                                                                                          function formatRangeWithChunks(date1, date2, chunks, separator, isRTL) {
                                                                                                                          Severity: Minor
                                                                                                                          Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 35 mins to fix

                                                                                                                            Avoid too many return statements within this function.
                                                                                                                            Open

                                                                                                                                return a - b;
                                                                                                                            Severity: Major
                                                                                                                            Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 30 mins to fix

                                                                                                                              Avoid too many return statements within this function.
                                                                                                                              Open

                                                                                                                                  return '';
                                                                                                                              Severity: Major
                                                                                                                              Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 30 mins to fix

                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                Open

                                                                                                                                                        return false;
                                                                                                                                Severity: Major
                                                                                                                                Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 30 mins to fix

                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                  Open

                                                                                                                                          return true;
                                                                                                                                  Severity: Major
                                                                                                                                  Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js - About 30 mins to fix

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                if (typeof spec === 'function') { // TODO: deprecate

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    // TODO: week maybe?

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                // TODO: repeat code, same code for event classNames

                                                                                                                                    HACK found
                                                                                                                                    Open

                                                                                                                                        // HACK: can override the recurring window by providing custom rangeStart/rangeEnd (for businessHours).

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    // TODO: make it work with timezone offset

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                // TODO: use getClientRect in future. but prevents auto scrolling when on top of scrollbars

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                    [ this ] // always make the last argument a reference to the view. TODO: deprecate

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                    this.destroySelection(); // TODO: deprecate

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                            this.dayNumbersVisible = this.dayGrid.rowCnt > 1; // TODO: make grid responsible

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: move to another class. not applicable to all Grids

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        copyOwnProps(members.prototype || members, this.prototype); // TODO: copyNativeMethods?

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: better code reuse for this. Repeat code

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                this.render(); // TODO: deprecate

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: move to another class. not applicable to all Grids

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    // TODO: rename everything "lang" to "locale", like what the moment project did

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: make this a part of the event -> eventRange system

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        t.getDefaultEventEnd = function(allDay, start) { // TODO: rename to computeDefaultEventEnd

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: move this into the view

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    // TODO: look into Moment's keepLocalTime functionality

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    // TODO: document the structure and ordering of a FullCalendar lang file

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                            // TODO: use keepLocalTime in the future

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        var chunker = /\[([^\]]*)\]|\(([^\)]*)\)|(LTS|LT|(\w)\4*o?)|([^\w\[\(]+)/g; // TODO: more descrimination

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: move to DayGrid.event, similar to what we did with Grid's drag methods

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                            year: 'year', // TODO: locale files need to specify this

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    var instanceComputableOptions = { // TODO: best place for this? related to lang?

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        colHeadFormat: null, // TODO: move to another class. not applicable to all Grids

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // Responsible for populating this.elsByFill. TODO: better API for expressing this requirement

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: move to another class. not applicable to all Grids

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                        // no change? (TODO: how does this work with timezones?)

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    // TODO: rename all header-related things to "toolbar"

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                // TODO: use ranges in the future

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    // TODO: move to date section?

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                this.destroy(); // TODO: deprecate

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                    // TODO: consider nextDayThreshold here? If so, will require a lot of testing and adjustment

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: don't use so many closures. possible memory issues when lots of events with same ID.

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                            var rowHeight = rowEl.height(); // TODO: cache somehow?

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                    this.destroyEvents(); // TODO: deprecate

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: going forward, most of this stuff should be directly handled by the view

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        header: { // TODO: smarter solution (first/center/last ?)

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                    // TODO: look into moment.momentProperties for this.

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: consolidate with getEventSkinCss?

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        numbersVisible: false, // should render a row for day/week numbers? set by outside view. TODO: make internal

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                                    /* TODO: write CSS for this

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                            // Try to build an event object and render it. TODO: decouple the two

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                            // TODO: look into Moment's keepLocalTime functionality

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        // TODO: should probably move this to Grid.events, like we did event dragging / resizing

                                                                                                                                    TODO found
                                                                                                                                    Open

                                                                                                                                        documentMousedownProxy: null, // TODO: doesn't work with touch

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

                                                                                                                                        computeRowCoords: function() {
                                                                                                                                            var items = [];
                                                                                                                                            var i, el;
                                                                                                                                            var top;
                                                                                                                                    
                                                                                                                                    
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 4 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 3267..3282

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

                                                                                                                                    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

                                                                                                                                        computeColCoords: function() {
                                                                                                                                            var items = [];
                                                                                                                                            var i, el;
                                                                                                                                            var left;
                                                                                                                                    
                                                                                                                                    
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 4 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 3247..3262

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

                                                                                                                                    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

                                                                                                                                        groupSegRows: function(segs) {
                                                                                                                                            var segRows = [];
                                                                                                                                            var i;
                                                                                                                                    
                                                                                                                                            for (i = 0; i < this.rowCnt; i++) {
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 4 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 6705..6718

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 118.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        groupSegCols: function(segs) {
                                                                                                                                            var segCols = [];
                                                                                                                                            var i;
                                                                                                                                    
                                                                                                                                            for (i = 0; i < this.colCnt; i++) {
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 4 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 5467..5480

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 118.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                            if (this.scrollTopVel < 0) { // scrolling up?
                                                                                                                                                if (el.scrollTop() <= 0) { // already scrolled all the way up?
                                                                                                                                                    this.scrollTopVel = 0;
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 4 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2466..2475

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 117.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                            if (this.scrollLeftVel < 0) { // scrolling left?
                                                                                                                                                if (el.scrollLeft() <= 0) { // already scrolled all the left?
                                                                                                                                                    this.scrollLeftVel = 0;
                                                                                                                                                }
                                                                                                                                            }
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 4 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2455..2464

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 117.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        reportEventResize: function(event, resizeLocation, largeUnit, el, ev) {
                                                                                                                                            var calendar = this.calendar;
                                                                                                                                            var mutateResult = calendar.mutateEvent(event, resizeLocation, largeUnit);
                                                                                                                                            var undoFunc = function() {
                                                                                                                                                mutateResult.undo();
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 3 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 7489..7499

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

                                                                                                                                    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

                                                                                                                                        reportEventDrop: function(event, dropLocation, largeUnit, el, ev) {
                                                                                                                                            var calendar = this.calendar;
                                                                                                                                            var mutateResult = calendar.mutateEvent(event, dropLocation, largeUnit);
                                                                                                                                            var undoFunc = function() {
                                                                                                                                                mutateResult.undo();
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 3 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 7591..7601

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

                                                                                                                                    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

                                                                                                                                            return '' +
                                                                                                                                                '<table>' +
                                                                                                                                                    '<thead class="fc-head">' +
                                                                                                                                                        '<tr>' +
                                                                                                                                                            '<td class="' + this.widgetHeaderClass + '">' +
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 2 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 10454..10466

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

                                                                                                                                    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

                                                                                                                                            return '' +
                                                                                                                                                '<table>' +
                                                                                                                                                    '<thead class="fc-head">' +
                                                                                                                                                        '<tr>' +
                                                                                                                                                            '<td class="' + this.widgetHeaderClass + '">' +
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 2 hrs to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 10858..10874

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

                                                                                                                                    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 eventContainsRange(event, range) {
                                                                                                                                            var eventStart = event.start.clone().stripZone();
                                                                                                                                            var eventEnd = t.getEventEnd(event).stripZone();
                                                                                                                                    
                                                                                                                                            return range.start >= eventStart && range.end <= eventEnd;
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 10322..10327

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 74.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        function eventIntersectsRange(event, range) {
                                                                                                                                            var eventStart = event.start.clone().stripZone();
                                                                                                                                            var eventEnd = t.getEventEnd(event).stripZone();
                                                                                                                                    
                                                                                                                                            return range.start < eventEnd && range.end > eventStart;
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 10312..10317

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 74.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                            return '<a class="' + classes.join(' ') + '"' +
                                                                                                                                                (event.url ?
                                                                                                                                                    ' href="' + htmlEscape(event.url) + '"' :
                                                                                                                                                    ''
                                                                                                                                                    ) +
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 5312..5326

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 74.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                            return '<a class="' + classes.join(' ') + '"' +
                                                                                                                                                    (event.url ?
                                                                                                                                                        ' href="' + htmlEscape(event.url) + '"' :
                                                                                                                                                        ''
                                                                                                                                                        ) +
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 6616..6635

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 74.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        isEventDraggable: function(event) {
                                                                                                                                            var source = event.source || {};
                                                                                                                                    
                                                                                                                                            return firstDefined(
                                                                                                                                                event.startEditable,
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 7576..7587

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 68.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        isEventResizable: function(event) {
                                                                                                                                            var source = event.source || {};
                                                                                                                                    
                                                                                                                                            return firstDefined(
                                                                                                                                                event.durationEditable,
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 7473..7484

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 68.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                                for (i = 0; i < rowCnt; i++) {
                                                                                                                                                    coords = rowCoords[i];
                                                                                                                                                    if (y >= coords.top && y < coords.bottom) {
                                                                                                                                                        hitRow = i;
                                                                                                                                                        break;
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2044..2050

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 67.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        clear: function() {
                                                                                                                                            var coordMaps = this.coordMaps;
                                                                                                                                            var i;
                                                                                                                                    
                                                                                                                                            for (i = 0; i < coordMaps.length; i++) {
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2104..2111

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 67.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                                for (i = 0; i < colCnt; i++) {
                                                                                                                                                    coords = colCoords[i];
                                                                                                                                                    if (x >= coords.left && x < coords.right) {
                                                                                                                                                        hitCol = i;
                                                                                                                                                        break;
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2036..2042

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 67.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        build: function() {
                                                                                                                                            var coordMaps = this.coordMaps;
                                                                                                                                            var i;
                                                                                                                                    
                                                                                                                                            for (i = 0; i < coordMaps.length; i++) {
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2129..2136

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 67.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        trigger: function(name) {
                                                                                                                                            if (this.options[name]) {
                                                                                                                                                this.options[name].apply(this, Array.prototype.slice.call(arguments, 1));
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2368..2372

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

                                                                                                                                    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

                                                                                                                                        trigger: function(name) {
                                                                                                                                            if (this.options[name]) {
                                                                                                                                                this.options[name].apply(this, Array.prototype.slice.call(arguments, 1));
                                                                                                                                            }
                                                                                                                                        },
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 1967..1971

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

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        segDragStop: function(seg, ev) {
                                                                                                                                            this.isDraggingSeg = false;
                                                                                                                                            this.view.trigger('eventDragStop', seg.el[0], seg.event, ev, {}); // last argument is jqui dummy
                                                                                                                                        },
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 3 other locations - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4032..4035
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4291..4294
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4298..4301

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 59.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        segResizeStop: function(seg, ev) {
                                                                                                                                            this.isResizingSeg = false;
                                                                                                                                            this.view.trigger('eventResizeStop', seg.el[0], seg.event, ev, {}); // last argument is jqui dummy
                                                                                                                                        },
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 3 other locations - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4032..4035
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4039..4042
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4291..4294

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 59.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        segDragStart: function(seg, ev) {
                                                                                                                                            this.isDraggingSeg = true;
                                                                                                                                            this.view.trigger('eventDragStart', seg.el[0], seg.event, ev, {}); // last argument is jqui dummy
                                                                                                                                        },
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 3 other locations - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4039..4042
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4291..4294
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4298..4301

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 59.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        segResizeStart: function(seg, ev) {
                                                                                                                                            this.isResizingSeg = true;
                                                                                                                                            this.view.trigger('eventResizeStart', seg.el[0], seg.event, ev, {}); // last argument is jqui dummy
                                                                                                                                        },
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 3 other locations - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4032..4035
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4039..4042
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4298..4301

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 59.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        extraSmallTimeFormat: function(momOptions) {
                                                                                                                                            return momOptions.longDateFormat('LT')
                                                                                                                                                .replace(':mm', '(:mm)')
                                                                                                                                                .replace(/(\Wmm)$/, '($1)') // like above, but for foreign langs
                                                                                                                                                .replace(/\s*a$/i, 't'); // convert to AM/PM/am/pm to lowercase one-letter. remove any spaces beforehand
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8927..8932
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8943..8948

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 57.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        hourFormat: function(momOptions) {
                                                                                                                                            return momOptions.longDateFormat('LT')
                                                                                                                                                .replace(':mm', '')
                                                                                                                                                .replace(/(\Wmm)$/, '') // like above, but for foreign langs
                                                                                                                                                .replace(/\s*a$/i, 'a'); // convert AM/PM/am/pm to lowercase. remove any spaces beforehand
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8927..8932
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8935..8940

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 57.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        smallTimeFormat: function(momOptions) {
                                                                                                                                            return momOptions.longDateFormat('LT')
                                                                                                                                                .replace(':mm', '(:mm)')
                                                                                                                                                .replace(/(\Wmm)$/, '($1)') // like above, but for foreign langs
                                                                                                                                                .replace(/\s*a$/i, 'a'); // convert AM/PM/am/pm to lowercase. remove any spaces beforehand
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8935..8940
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8943..8948

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 57.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                                                    .mousedown(function() {
                                                                                                                                                                        // the *down* effect (mouse pressed in).
                                                                                                                                                                        // only on buttons that are not the "active" tab, or disabled
                                                                                                                                                                        button
                                                                                                                                                                            .not('.' + tm + '-state-active')
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 9172..9179

                                                                                                                                    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

                                                                                                                                                                        function() {
                                                                                                                                                                            // the *hover* effect.
                                                                                                                                                                            // only on buttons that are not the "active" tab, or disabled
                                                                                                                                                                            button
                                                                                                                                                                                .not('.' + tm + '-state-active')
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 1 hr to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 9159..9166

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

                                                                                                                                        monthYearFormat: function(dpOptions) {
                                                                                                                                            return dpOptions.showMonthAfterYear ?
                                                                                                                                                'YYYY[' + dpOptions.yearSuffix + '] MMMM' :
                                                                                                                                                'MMMM YYYY[' + dpOptions.yearSuffix + ']';
                                                                                                                                        }
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 45 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8970..8974
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8977..8981

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 50.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        smallWeekFormat: function(options) {
                                                                                                                                            return options.isRTL ?
                                                                                                                                                'w[' + options.weekNumberTitle + ']' :
                                                                                                                                                '[' + options.weekNumberTitle + ']w';
                                                                                                                                        }
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 45 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8894..8898
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8970..8974

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 50.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        weekFormat: function(options) {
                                                                                                                                            return options.isRTL ?
                                                                                                                                                'w[ ' + options.weekNumberTitle + ']' :
                                                                                                                                                '[' + options.weekNumberTitle + ' ]w';
                                                                                                                                        },
                                                                                                                                    Severity: Major
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 45 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8894..8898
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8977..8981

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 50.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                            return moment.duration({
                                                                                                                                                hours: this.hours(),
                                                                                                                                                minutes: this.minutes(),
                                                                                                                                                seconds: this.seconds(),
                                                                                                                                                milliseconds: this.milliseconds()
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 45 mins to fix
                                                                                                                                    assets/admin/global/plugins/plupload/js/moxie.js on lines 1129..1134

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 50.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        for (var i=0; i<arguments.length; i++) {
                                                                                                                                            if (arguments[i] !== undefined) {
                                                                                                                                                return arguments[i];
                                                                                                                                            }
                                                                                                                                        }
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 40 mins to fix
                                                                                                                                    assets/admin/global/plugins/jquery-validation/js/jquery.validate.js on lines 694..698

                                                                                                                                    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

                                                                                                                                        renderBusinessHours: function() {
                                                                                                                                            this.timeGrid.renderBusinessHours();
                                                                                                                                    
                                                                                                                                            if (this.dayGrid) {
                                                                                                                                                this.dayGrid.renderBusinessHours();
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 40 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 11099..11104

                                                                                                                                    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

                                                                                                                                        unrenderDrag: function() {
                                                                                                                                            this.timeGrid.unrenderDrag();
                                                                                                                                            if (this.dayGrid) {
                                                                                                                                                this.dayGrid.unrenderDrag();
                                                                                                                                            }
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 40 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 10846..10852

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

                                                                                                                                        removeElement: function() {
                                                                                                                                            if (this.el) {
                                                                                                                                                this.el.remove();
                                                                                                                                                this.el = null;
                                                                                                                                            }
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 40 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 5118..5123
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 6325..6330

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 48.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        unrenderHelper: function() {
                                                                                                                                            if (this.helperEl) {
                                                                                                                                                this.helperEl.remove();
                                                                                                                                                this.helperEl = null;
                                                                                                                                            }
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 40 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2843..2848
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 5118..5123

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 48.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        unrenderHelper: function() {
                                                                                                                                            if (this.helperEls) {
                                                                                                                                                this.helperEls.remove();
                                                                                                                                                this.helperEls = null;
                                                                                                                                            }
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 2 other locations - About 40 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 2843..2848
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 6325..6330

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 48.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        hideEvent: function(event) {
                                                                                                                                            this.renderedEventSegEach(function(seg) {
                                                                                                                                                seg.el.css('visibility', 'hidden');
                                                                                                                                            }, event);
                                                                                                                                        },
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 35 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 7429..7433

                                                                                                                                    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

                                                                                                                                        showEvent: function(event) {
                                                                                                                                            this.renderedEventSegEach(function(seg) {
                                                                                                                                                seg.el.css('visibility', '');
                                                                                                                                            }, event);
                                                                                                                                        },
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 35 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 7437..7441

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 47.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                            if (this.colCnt > 1) { // multiple days, so full single date string WON'T be in title text
                                                                                                                                                return this.view.opt('dayOfMonthFormat'); // "Sat 12/10"
                                                                                                                                            }
                                                                                                                                            else { // single day, so full single date string will probably be in title text
                                                                                                                                                return 'dddd'; // "Saturday"
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 30 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 4832..4837

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 45.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                            else if (this.colCnt > 1) { // multiple days, so full single date string WON'T be in title text
                                                                                                                                                return this.view.opt('dayOfMonthFormat'); // "Sat 12/10"
                                                                                                                                            }
                                                                                                                                            else { // single day, so full single date string will probably be in title text
                                                                                                                                                return 'dddd'; // "Saturday"
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 30 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 6049..6054

                                                                                                                                    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

                                                                                                                                        weekNumberStyleAttr: function() {
                                                                                                                                            if (this.weekNumberWidth !== null) {
                                                                                                                                                return 'style="width:' + this.weekNumberWidth + 'px"';
                                                                                                                                            }
                                                                                                                                            return '';
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 30 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 10935..10940

                                                                                                                                    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

                                                                                                                                        pushLoading: function() {
                                                                                                                                            if (!(this.loadingLevel++)) {
                                                                                                                                                this.trigger('loading', null, true, this.view);
                                                                                                                                            }
                                                                                                                                        },
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 30 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8012..8016

                                                                                                                                    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

                                                                                                                                        popLoading: function() {
                                                                                                                                            if (!(--this.loadingLevel)) {
                                                                                                                                                this.trigger('loading', null, false, this.view);
                                                                                                                                            }
                                                                                                                                        },
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 30 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 8004..8008

                                                                                                                                    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

                                                                                                                                        axisStyleAttr: function() {
                                                                                                                                            if (this.axisWidth !== null) {
                                                                                                                                                 return 'style="width:' + this.axisWidth + 'px"';
                                                                                                                                            }
                                                                                                                                            return '';
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 30 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 10544..10549

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 45.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        if (src._ambigTime) {
                                                                                                                                            dest._ambigTime = true;
                                                                                                                                        }
                                                                                                                                        else if (dest._ambigTime) {
                                                                                                                                            dest._ambigTime = false;
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 30 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 1433..1438

                                                                                                                                    Duplicated Code

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

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

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

                                                                                                                                    Tuning

                                                                                                                                    This issue has a mass of 45.

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

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

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

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

                                                                                                                                    Refactorings

                                                                                                                                    Further Reading

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

                                                                                                                                        if (src._ambigZone) {
                                                                                                                                            dest._ambigZone = true;
                                                                                                                                        }
                                                                                                                                        else if (dest._ambigZone) {
                                                                                                                                            dest._ambigZone = false;
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in assets/admin/global/plugins/fullcalendar/fullcalendar.js and 1 other location - About 30 mins to fix
                                                                                                                                    assets/admin/global/plugins/fullcalendar/fullcalendar.js on lines 1426..1431

                                                                                                                                    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