Noosfero/noosfero

View on GitHub
plugins/orders/public/javascripts/moment-with-locales.js

Summary

Maintainability
F
3 mos
Test Coverage

File moment-with-locales.js has 8154 lines of code (exceeds 250 allowed). Consider refactoring.
Open

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
    typeof define === 'function' && define.amd ? define(factory) :
    global.moment = factory()
}(this, function () { 'use strict';
Severity: Major
Found in plugins/orders/public/javascripts/moment-with-locales.js - About 3 wks to fix

    Consider simplifying this complex logical expression.
    Open

            if (a && m._pf.overflow === -2) {
                overflow =
                    a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
                    a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
                    a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
    Severity: Critical
    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 2 hrs to fix

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

          function sl__translate(number, withoutSuffix, key) {
              var result = number + ' ';
              switch (key) {
              case 'm':
                  return withoutSuffix ? 'ena minuta' : 'eno minuto';
      Severity: Major
      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 2 hrs to fix

        Function is__translate has 56 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            function is__translate(number, withoutSuffix, key, isFuture) {
                var result = number + ' ';
                switch (key) {
                case 's':
                    return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum';
        Severity: Major
        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 2 hrs to fix

          Function create__createDuration has 52 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              function create__createDuration (input, key) {
                  var duration = input,
                      // matching against regexp is expensive, do it on demand
                      match = null,
                      sign,
          Severity: Major
          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 2 hrs to fix

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

                function hr__translate(number, withoutSuffix, key) {
                    var result = number + ' ';
                    switch (key) {
                    case 'm':
                        return withoutSuffix ? 'jedna minuta' : 'jedne minute';
            Severity: Minor
            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 2 hrs to fix

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

                  function sk__translate(number, withoutSuffix, key, isFuture) {
                      var result = number + ' ';
                      switch (key) {
                      case 's':  // a few seconds / in a few seconds / a few seconds ago
                          return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
              Severity: Minor
              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 2 hrs to fix

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

                    function bs__translate(number, withoutSuffix, key) {
                        var result = number + ' ';
                        switch (key) {
                        case 'm':
                            return withoutSuffix ? 'jedna minuta' : 'jedne minute';
                Severity: Minor
                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 2 hrs to fix

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

                      function cs__translate(number, withoutSuffix, key, isFuture) {
                          var result = number + ' ';
                          switch (key) {
                          case 's':  // a few seconds / in a few seconds / a few seconds ago
                              return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
                  Severity: Minor
                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 2 hrs to fix

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

                        function configFromStringAndFormat(config) {
                            // TODO: Move this to another part of the creation flow to prevent circular deps
                            if (config._f === utils_hooks__hooks.ISO_8601) {
                                configFromISO(config);
                                return;
                    Severity: Minor
                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                          function copyConfig(to, from) {
                              var i, prop, val;
                      
                              if (typeof from._isAMomentObject !== 'undefined') {
                                  to._isAMomentObject = from._isAMomentObject;
                      Severity: Minor
                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                            function configFromArray (config) {
                                var i, date, input = [], currentDate, yearToUse;
                        
                                if (config._d) {
                                    return;
                        Severity: Minor
                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                              function fi__translate(number, withoutSuffix, key, isFuture) {
                                  var result = '';
                                  switch (key) {
                                  case 's':
                                      return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
                          Severity: Minor
                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                                function configFromStringAndArray(config) {
                                    var tempConfig,
                                        bestMoment,
                            
                                        scoreToBeat,
                            Severity: Minor
                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                                  function getSetOffset (input, keepLocalTime) {
                                      var offset = this._offset || 0,
                                          localAdjust;
                                      if (input != null) {
                                          if (typeof input === 'string') {
                              Severity: Minor
                              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                                    function startOf (units) {
                                        units = normalizeUnits(units);
                                        // the following switch intentionally omits break keywords
                                        // to utilize falling through the cases.
                                        switch (units) {
                                Severity: Minor
                                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                                      function hu__translate(number, withoutSuffix, key, isFuture) {
                                          var num = number,
                                              suffix;
                                          switch (key) {
                                          case 's':
                                  Severity: Minor
                                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                                        function dayOfYearFromWeekInfo(config) {
                                            var w, weekYear, week, weekday, dow, doy, temp;
                                    
                                            w = config._w;
                                            if (w.GG != null || w.W != null || w.E != null) {
                                    Severity: Minor
                                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

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

                                          function eifelerRegelAppliesToNumber(number) {
                                              number = parseInt(number, 10);
                                              if (isNaN(number)) {
                                                  return false;
                                              }
                                      Severity: Minor
                                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

                                        Consider simplifying this complex logical expression.
                                        Open

                                                if (m._isValid == null) {
                                                    m._isValid = !isNaN(m._d.getTime()) &&
                                                        m._pf.overflow < 0 &&
                                                        !m._pf.empty &&
                                                        !m._pf.invalidMonth &&
                                        Severity: Major
                                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 1 hr to fix

                                          Function createDate has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                          Open

                                              function createDate (y, m, d, h, M, s, ms) {
                                          Severity: Major
                                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 50 mins to fix

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

                                                function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
                                            Severity: Minor
                                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 35 mins to fix

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

                                                  function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
                                              Severity: Minor
                                              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 35 mins to fix

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

                                                    function list (format, index, field, count, setter) {
                                                Severity: Minor
                                                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 35 mins to fix

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

                                                      function createLocalOrUTC (input, format, locale, strict, isUTC) {
                                                  Severity: Minor
                                                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 35 mins to fix

                                                    Avoid too many return statements within this function.
                                                    Open

                                                                    return 'रात';
                                                    Severity: Major
                                                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                      Avoid too many return statements within this function.
                                                      Open

                                                                  return result + 'klukkustund';
                                                      Severity: Major
                                                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                        Avoid too many return statements within this function.
                                                        Open

                                                                        return 'dagur';
                                                        Severity: Major
                                                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                          Avoid too many return statements within this function.
                                                          Open

                                                                              return result + 'dagar';
                                                          Severity: Major
                                                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                            Avoid too many return statements within this function.
                                                            Open

                                                                            return result + (isFuture ? 'daga' : 'dögum');
                                                            Severity: Major
                                                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                              Avoid too many return statements within this function.
                                                              Open

                                                                              return result + 'mesiacmi';
                                                              Severity: Major
                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                Avoid too many return statements within this function.
                                                                Open

                                                                                return result + (cs__plural(number) ? 'měsíce' : 'měsíců');
                                                                Severity: Major
                                                                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                  Avoid too many return statements within this function.
                                                                  Open

                                                                                  return number + '-ри';
                                                                  Severity: Major
                                                                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                    Avoid too many return statements within this function.
                                                                    Open

                                                                                return isFuture ? 'dag' : 'degi';
                                                                    Severity: Major
                                                                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                      Avoid too many return statements within this function.
                                                                      Open

                                                                                      return number + '-ми';
                                                                      Severity: Major
                                                                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                        Avoid too many return statements within this function.
                                                                        Open

                                                                                        return ' எற்பாடு'; // எற்பாடு
                                                                        Severity: Major
                                                                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                          Avoid too many return statements within this function.
                                                                          Open

                                                                                          return result + 'měsíci';
                                                                          Severity: Major
                                                                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                            Avoid too many return statements within this function.
                                                                            Open

                                                                                        return result + (isFuture ? 'dag' : 'degi');
                                                                            Severity: Major
                                                                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                              Avoid too many return statements within this function.
                                                                              Open

                                                                                              return '下午';
                                                                              Severity: Major
                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                Avoid too many return statements within this function.
                                                                                Open

                                                                                                return number + '-ти';
                                                                                Severity: Major
                                                                                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                  Avoid too many return statements within this function.
                                                                                  Open

                                                                                                  return 'रात्री';
                                                                                  Severity: Major
                                                                                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                    Avoid too many return statements within this function.
                                                                                    Open

                                                                                                return result;
                                                                                    Severity: Major
                                                                                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                      Avoid too many return statements within this function.
                                                                                      Open

                                                                                                      return ' மாலை'; // மாலை
                                                                                      Severity: Major
                                                                                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                        Avoid too many return statements within this function.
                                                                                        Open

                                                                                                        return result + 'dagur';
                                                                                        Severity: Major
                                                                                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                          Avoid too many return statements within this function.
                                                                                          Open

                                                                                                          return result + (isFuture ? 'mánuði' : 'mánuðum');
                                                                                          Severity: Major
                                                                                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                            Avoid too many return statements within this function.
                                                                                            Open

                                                                                                        return eifelerRegelAppliesToNumber(lastDigit);
                                                                                            Severity: Major
                                                                                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                              Avoid too many return statements within this function.
                                                                                              Open

                                                                                                              return number + '-ри';
                                                                                              Severity: Major
                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                Avoid too many return statements within this function.
                                                                                                Open

                                                                                                                return result + 'rokmi';
                                                                                                Severity: Major
                                                                                                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                  Avoid too many return statements within this function.
                                                                                                  Open

                                                                                                                  return result + 'lety';
                                                                                                  Severity: Major
                                                                                                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                    Avoid too many return statements within this function.
                                                                                                    Open

                                                                                                                return result;
                                                                                                    Severity: Major
                                                                                                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                      Avoid too many return statements within this function.
                                                                                                      Open

                                                                                                                  return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
                                                                                                      Severity: Major
                                                                                                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                        Avoid too many return statements within this function.
                                                                                                        Open

                                                                                                                        return number + '-ми';
                                                                                                        Severity: Major
                                                                                                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                          Avoid too many return statements within this function.
                                                                                                          Open

                                                                                                                          return 'രാത്രി';
                                                                                                          Severity: Major
                                                                                                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                            Avoid too many return statements within this function.
                                                                                                            Open

                                                                                                                            return number + '-ти';
                                                                                                            Severity: Major
                                                                                                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                              Avoid too many return statements within this function.
                                                                                                              Open

                                                                                                                              return result + (cs__plural(number) ? 'roky' : 'let');
                                                                                                              Severity: Major
                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                Avoid too many return statements within this function.
                                                                                                                Open

                                                                                                                            return eifelerRegelAppliesToNumber(number);
                                                                                                                Severity: Major
                                                                                                                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                  Avoid too many return statements within this function.
                                                                                                                  Open

                                                                                                                                  return result + (sk__plural(number) ? 'mesiace' : 'mesiacov');
                                                                                                                  Severity: Major
                                                                                                                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                    Avoid too many return statements within this function.
                                                                                                                    Open

                                                                                                                                    return '晚上';
                                                                                                                    Severity: Major
                                                                                                                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                      Avoid too many return statements within this function.
                                                                                                                      Open

                                                                                                                                  return eifelerRegelAppliesToNumber(number);
                                                                                                                      Severity: Major
                                                                                                                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                        Avoid too many return statements within this function.
                                                                                                                        Open

                                                                                                                                        return 'রাত';
                                                                                                                        Severity: Major
                                                                                                                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                          Avoid too many return statements within this function.
                                                                                                                          Open

                                                                                                                                          return result + 'dny';
                                                                                                                          Severity: Major
                                                                                                                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                            Avoid too many return statements within this function.
                                                                                                                            Open

                                                                                                                                        return result + (isFuture ? 'mánuð' : 'mánuði');
                                                                                                                            Severity: Major
                                                                                                                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                              Avoid too many return statements within this function.
                                                                                                                              Open

                                                                                                                                              return 'མཚན་མོ';
                                                                                                                              Severity: Major
                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                Open

                                                                                                                                                return 'mánuður';
                                                                                                                                Severity: Major
                                                                                                                                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                  Open

                                                                                                                                                  return result + 'mánuður';
                                                                                                                                  Severity: Major
                                                                                                                                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                    Open

                                                                                                                                                        return result + 'mánuðir';
                                                                                                                                    Severity: Major
                                                                                                                                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                      Open

                                                                                                                                                      return ' யாமம்';
                                                                                                                                      Severity: Major
                                                                                                                                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                        Open

                                                                                                                                                        return result + (cs__plural(number) ? 'dny' : 'dní');
                                                                                                                                        Severity: Major
                                                                                                                                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                          Open

                                                                                                                                                          return 'साँझ';
                                                                                                                                          Severity: Major
                                                                                                                                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                            Open

                                                                                                                                                            return result + (sk__plural(number) ? 'roky' : 'rokov');
                                                                                                                                            Severity: Major
                                                                                                                                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                              Open

                                                                                                                                                              return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
                                                                                                                                              Severity: Major
                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                Open

                                                                                                                                                            return isFuture ? 'mánuð' : 'mánuði';
                                                                                                                                                Severity: Major
                                                                                                                                                Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                  Open

                                                                                                                                                                  return eifelerRegelAppliesToNumber(firstDigit);
                                                                                                                                                  Severity: Major
                                                                                                                                                  Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                    Open

                                                                                                                                                                    return 'राती';
                                                                                                                                                    Severity: Major
                                                                                                                                                    Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                      Open

                                                                                                                                                                      return result + 'dňami';
                                                                                                                                                      Severity: Major
                                                                                                                                                      Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                        Open

                                                                                                                                                                    return result;
                                                                                                                                                        Severity: Major
                                                                                                                                                        Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                          Open

                                                                                                                                                                          return '晚上';
                                                                                                                                                          Severity: Major
                                                                                                                                                          Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                            Open

                                                                                                                                                                            return result + (sk__plural(number) ? 'dni' : 'dní');
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in plugins/orders/public/javascripts/moment-with-locales.js - About 30 mins to fix

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

                                                                                                                                                                  var bg = _moment__default.defineLocale('bg', {
                                                                                                                                                                      months : 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
                                                                                                                                                                      monthsShort : 'янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
                                                                                                                                                                      weekdays : 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split('_'),
                                                                                                                                                                      weekdaysShort : 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6967..7040

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 479.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var mk = _moment__default.defineLocale('mk', {
                                                                                                                                                                      months : 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
                                                                                                                                                                      monthsShort : 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
                                                                                                                                                                      weekdays : 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
                                                                                                                                                                      weekdaysShort : 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3688..3761

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 479.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var cs = _moment__default.defineLocale('cs', {
                                                                                                                                                                      months : cs__months,
                                                                                                                                                                      monthsShort : cs__monthsShort,
                                                                                                                                                                      monthsParse : (function (months, monthsShort) {
                                                                                                                                                                          var i, _monthsParse = [];
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8105..8187

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 458.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var sk = _moment__default.defineLocale('sk', {
                                                                                                                                                                      months : sk__months,
                                                                                                                                                                      monthsShort : sk__monthsShort,
                                                                                                                                                                      monthsParse : (function (months, monthsShort) {
                                                                                                                                                                          var i, _monthsParse = [];
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4320..4402

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 458.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var id = _moment__default.defineLocale('id', {
                                                                                                                                                                      months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
                                                                                                                                                                      monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nov_Des'.split('_'),
                                                                                                                                                                      weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
                                                                                                                                                                      weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7216..7281

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 413.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var ms_my = _moment__default.defineLocale('ms-my', {
                                                                                                                                                                      months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
                                                                                                                                                                      monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
                                                                                                                                                                      weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
                                                                                                                                                                      weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6176..6241

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 413.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var sr_cyrl = _moment__default.defineLocale('sr-cyrl', {
                                                                                                                                                                      months: ['јануар', 'фебруар', 'март', 'април', 'мај', 'јун', 'јул', 'август', 'септембар', 'октобар', 'новембар', 'децембар'],
                                                                                                                                                                      monthsShort: ['јан.', 'феб.', 'мар.', 'апр.', 'мај', 'јун', 'јул', 'авг.', 'сеп.', 'окт.', 'нов.', 'дец.'],
                                                                                                                                                                      weekdays: ['недеља', 'понедељак', 'уторак', 'среда', 'четвртак', 'петак', 'субота'],
                                                                                                                                                                      weekdaysShort: ['нед.', 'пон.', 'уто.', 'сре.', 'чет.', 'пет.', 'суб.'],
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8507..8575

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 387.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var sr = _moment__default.defineLocale('sr', {
                                                                                                                                                                      months: ['januar', 'februar', 'mart', 'april', 'maj', 'jun', 'jul', 'avgust', 'septembar', 'oktobar', 'novembar', 'decembar'],
                                                                                                                                                                      monthsShort: ['jan.', 'feb.', 'mar.', 'apr.', 'maj', 'jun', 'jul', 'avg.', 'sep.', 'okt.', 'nov.', 'dec.'],
                                                                                                                                                                      weekdays: ['nedelja', 'ponedeljak', 'utorak', 'sreda', 'četvrtak', 'petak', 'subota'],
                                                                                                                                                                      weekdaysShort: ['ned.', 'pon.', 'uto.', 'sre.', 'čet.', 'pet.', 'sub.'],
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8410..8478

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 387.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 sk__translate(number, withoutSuffix, key, isFuture) {
                                                                                                                                                                      var result = number + ' ';
                                                                                                                                                                      switch (key) {
                                                                                                                                                                      case 's':  // a few seconds / in a few seconds / a few seconds ago
                                                                                                                                                                          return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4267..4318

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 375.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 cs__translate(number, withoutSuffix, key, isFuture) {
                                                                                                                                                                      var result = number + ' ';
                                                                                                                                                                      switch (key) {
                                                                                                                                                                      case 's':  // a few seconds / in a few seconds / a few seconds ago
                                                                                                                                                                          return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8052..8103

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 375.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var bs = _moment__default.defineLocale('bs', {
                                                                                                                                                                      months : 'januar_februar_mart_april_maj_juni_juli_august_septembar_oktobar_novembar_decembar'.split('_'),
                                                                                                                                                                      monthsShort : 'jan._feb._mar._apr._maj._jun._jul._aug._sep._okt._nov._dec.'.split('_'),
                                                                                                                                                                      weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
                                                                                                                                                                      weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5901..5971

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 368.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var hr = _moment__default.defineLocale('hr', {
                                                                                                                                                                      months : 'sječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_'),
                                                                                                                                                                      monthsShort : 'sje._vel._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
                                                                                                                                                                      weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
                                                                                                                                                                      weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4118..4188

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 368.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function hr__translate(number, withoutSuffix, key) {
                                                                                                                                                                      var result = number + ' ';
                                                                                                                                                                      switch (key) {
                                                                                                                                                                      case 'm':
                                                                                                                                                                          return withoutSuffix ? 'jedna minuta' : 'jedne minute';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4065..4116

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 365.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function bs__translate(number, withoutSuffix, key) {
                                                                                                                                                                      var result = number + ' ';
                                                                                                                                                                      switch (key) {
                                                                                                                                                                      case 'm':
                                                                                                                                                                          return withoutSuffix ? 'jedna minuta' : 'jedne minute';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 days to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5848..5899

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 365.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var nl = _moment__default.defineLocale('nl', {
                                                                                                                                                                      months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
                                                                                                                                                                      monthsShort : function (m, format) {
                                                                                                                                                                          if (/-MMM-/.test(format)) {
                                                                                                                                                                              return nl__monthsShortWithoutDots[m.month()];
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5544..5595

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 344.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var fy = _moment__default.defineLocale('fy', {
                                                                                                                                                                      months : 'jannewaris_febrewaris_maart_april_maaie_juny_july_augustus_septimber_oktober_novimber_desimber'.split('_'),
                                                                                                                                                                      monthsShort : function (m, format) {
                                                                                                                                                                          if (/-MMM-/.test(format)) {
                                                                                                                                                                              return fy__monthsShortWithoutDots[m.month()];
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7533..7584

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 344.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var en_gb = _moment__default.defineLocale('en-gb', {
                                                                                                                                                                      months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
                                                                                                                                                                      monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
                                                                                                                                                                      weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
                                                                                                                                                                      weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4788..4838
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8581..8631

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 335.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var en_au = _moment__default.defineLocale('en-au', {
                                                                                                                                                                      months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
                                                                                                                                                                      monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
                                                                                                                                                                      weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
                                                                                                                                                                      weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4896..4946
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8581..8631

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 335.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var sv = _moment__default.defineLocale('sv', {
                                                                                                                                                                      months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
                                                                                                                                                                      monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
                                                                                                                                                                      weekdays : 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
                                                                                                                                                                      weekdaysShort : 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4788..4838
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4896..4946

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 335.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var fo = _moment__default.defineLocale('fo', {
                                                                                                                                                                      months : 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
                                                                                                                                                                      monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
                                                                                                                                                                      weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split('_'),
                                                                                                                                                                      weekdaysShort : 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7590..7633

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 263.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var nn = _moment__default.defineLocale('nn', {
                                                                                                                                                                      months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
                                                                                                                                                                      monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
                                                                                                                                                                      weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
                                                                                                                                                                      weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5394..5437

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 263.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var de = _moment__default.defineLocale('de', {
                                                                                                                                                                      months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
                                                                                                                                                                      monthsShort : 'Jan._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
                                                                                                                                                                      weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
                                                                                                                                                                      weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4593..4636

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 254.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var de_at = _moment__default.defineLocale('de-at', {
                                                                                                                                                                      months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
                                                                                                                                                                      monthsShort : 'Jän._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
                                                                                                                                                                      weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
                                                                                                                                                                      weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4657..4700

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 254.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var uz = _moment__default.defineLocale('uz', {
                                                                                                                                                                      months : 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
                                                                                                                                                                      monthsShort : 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
                                                                                                                                                                      weekdays : 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
                                                                                                                                                                      weekdaysShort : 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8905..8946

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 253.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var tzm_latn = _moment__default.defineLocale('tzm-latn', {
                                                                                                                                                                      months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
                                                                                                                                                                      monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
                                                                                                                                                                      weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
                                                                                                                                                                      weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9141..9182

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 253.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var sr__translator = {
                                                                                                                                                                      words: { //Different grammatical cases
                                                                                                                                                                          m: ['jedan minut', 'jedne minute'],
                                                                                                                                                                          mm: ['minut', 'minute', 'minuta'],
                                                                                                                                                                          h: ['jedan sat', 'jednog sata'],
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8387..8408

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 220.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var sr_cyrl__translator = {
                                                                                                                                                                      words: { //Different grammatical cases
                                                                                                                                                                          m: ['један минут', 'једне минуте'],
                                                                                                                                                                          mm: ['минут', 'минуте', 'минута'],
                                                                                                                                                                          h: ['један сат', 'једног сата'],
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8484..8505

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 220.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      calendar : {
                                                                                                                                                                          sameDay : function () {
                                                                                                                                                                              return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
                                                                                                                                                                          },
                                                                                                                                                                          nextDay : function () {
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5037..5054
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5615..5632

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 201.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      calendar : {
                                                                                                                                                                          sameDay : function () {
                                                                                                                                                                              return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
                                                                                                                                                                          },
                                                                                                                                                                          nextDay : function () {
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4208..4225
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5615..5632

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 201.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      calendar : {
                                                                                                                                                                          sameDay : function () {
                                                                                                                                                                              return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
                                                                                                                                                                          },
                                                                                                                                                                          nextDay : function () {
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 day to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4208..4225
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5037..5054

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 201.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function de_at__processRelativeTime(number, withoutSuffix, key, isFuture) {
                                                                                                                                                                      var format = {
                                                                                                                                                                          'm': ['eine Minute', 'einer Minute'],
                                                                                                                                                                          'h': ['eine Stunde', 'einer Stunde'],
                                                                                                                                                                          'd': ['ein Tag', 'einem Tag'],
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4643..4655

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 125.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function de__processRelativeTime(number, withoutSuffix, key, isFuture) {
                                                                                                                                                                      var format = {
                                                                                                                                                                          'm': ['eine Minute', 'einer Minute'],
                                                                                                                                                                          'h': ['eine Stunde', 'einer Stunde'],
                                                                                                                                                                          'd': ['ein Tag', 'einem Tag'],
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4579..4591

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 125.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      meridiemHour : function (hour, meridiem) {
                                                                                                                                                                          if (hour === 12) {
                                                                                                                                                                              hour = 0;
                                                                                                                                                                          }
                                                                                                                                                                          if (meridiem === 'रात') {
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7179..7192

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 121.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 uk__plural(word, num) {
                                                                                                                                                                      var forms = word.split('_');
                                                                                                                                                                      return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
                                                                                                                                                                  }
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7894..7897

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 121.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 ru__plural(word, num) {
                                                                                                                                                                      var forms = word.split('_');
                                                                                                                                                                      return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
                                                                                                                                                                  }
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9000..9003

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 121.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      meridiemHour : function (hour, meridiem) {
                                                                                                                                                                          if (hour === 12) {
                                                                                                                                                                              hour = 0;
                                                                                                                                                                          }
                                                                                                                                                                          if (meridiem === 'रात्री') {
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5811..5824

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 121.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 8 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  var ar_sa__symbolMap = {
                                                                                                                                                                      '1': '١',
                                                                                                                                                                      '2': '٢',
                                                                                                                                                                      '3': '٣',
                                                                                                                                                                      '4': '٤',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 7 other locations - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3767..3790
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3869..3892
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5204..5226
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5736..5759
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7106..7129
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7287..7309
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7418..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 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 8 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  var my__symbolMap = {
                                                                                                                                                                      '1': '၁',
                                                                                                                                                                      '2': '၂',
                                                                                                                                                                      '3': '၃',
                                                                                                                                                                      '4': '၄',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 7 other locations - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3196..3218
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3767..3790
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3869..3892
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5204..5226
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5736..5759
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7106..7129
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7418..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 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 8 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  var bn__symbolMap = {
                                                                                                                                                                      '1': '১',
                                                                                                                                                                      '2': '২',
                                                                                                                                                                      '3': '৩',
                                                                                                                                                                      '4': '৪',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 7 other locations - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3196..3218
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3869..3892
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5204..5226
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5736..5759
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7106..7129
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7287..7309
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7418..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 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 8 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  var hi__symbolMap = {
                                                                                                                                                                      '1': '१',
                                                                                                                                                                      '2': '२',
                                                                                                                                                                      '3': '३',
                                                                                                                                                                      '4': '४',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 7 other locations - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3196..3218
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3767..3790
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3869..3892
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5204..5226
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7106..7129
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7287..7309
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7418..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 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 8 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  var bo__symbolMap = {
                                                                                                                                                                      '1': '༡',
                                                                                                                                                                      '2': '༢',
                                                                                                                                                                      '3': '༣',
                                                                                                                                                                      '4': '༤',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 7 other locations - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3196..3218
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3767..3790
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5204..5226
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5736..5759
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7106..7129
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7287..7309
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7418..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 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 8 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  var ne__symbolMap = {
                                                                                                                                                                      '1': '१',
                                                                                                                                                                      '2': '२',
                                                                                                                                                                      '3': '३',
                                                                                                                                                                      '4': '४',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 7 other locations - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3196..3218
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3767..3790
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3869..3892
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5204..5226
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5736..5759
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7106..7129
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7287..7309

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 8 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  var fa__symbolMap = {
                                                                                                                                                                      '1': '۱',
                                                                                                                                                                      '2': '۲',
                                                                                                                                                                      '3': '۳',
                                                                                                                                                                      '4': '۴',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 7 other locations - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3196..3218
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3767..3790
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3869..3892
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5736..5759
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7106..7129
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7287..7309
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7418..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 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 8 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  var mr__symbolMap = {
                                                                                                                                                                      '1': '१',
                                                                                                                                                                      '2': '२',
                                                                                                                                                                      '3': '३',
                                                                                                                                                                      '4': '४',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 7 other locations - About 4 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3196..3218
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3767..3790
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3869..3892
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5204..5226
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5736..5759
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7287..7309
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7418..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 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

                                                                                                                                                                  var az__suffixes = {
                                                                                                                                                                      1: '-inci',
                                                                                                                                                                      5: '-inci',
                                                                                                                                                                      8: '-inci',
                                                                                                                                                                      70: '-inci',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 3 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8827..8846

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 97.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  var tr__suffixes = {
                                                                                                                                                                      1: '\'inci',
                                                                                                                                                                      5: '\'inci',
                                                                                                                                                                      8: '\'inci',
                                                                                                                                                                      70: '\'inci',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 3 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3459..3478

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 97.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      ordinal : function (number) {
                                                                                                                                                                          if (number === 0) {  // special case for zero
                                                                                                                                                                              return number + '\'ıncı';
                                                                                                                                                                          }
                                                                                                                                                                          var a = number % 10,
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 3 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3533..3541

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 97.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      ordinal : function (number) {
                                                                                                                                                                          if (number === 0) {  // special case for zero
                                                                                                                                                                              return number + '-ıncı';
                                                                                                                                                                          }
                                                                                                                                                                          var a = number % 10,
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 3 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8886..8894

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 97.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function ka__monthsCaseReplace(m, format) {
                                                                                                                                                                      var months = {
                                                                                                                                                                          'nominative': 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split('_'),
                                                                                                                                                                          'accusative': 'იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6075..6084

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 85.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function hy_am__monthsCaseReplace(m, format) {
                                                                                                                                                                      var months = {
                                                                                                                                                                          'nominative': 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_'),
                                                                                                                                                                          'accusative': 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6476..6485

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 85.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      case 'yy':
                                                                                                                                                                          if (number === 1) {
                                                                                                                                                                              result += 'leto';
                                                                                                                                                                          } else if (number === 2) {
                                                                                                                                                                              result += 'leti';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8198..8208
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8211..8221
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8229..8239

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 82.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      case 'mm':
                                                                                                                                                                          if (number === 1) {
                                                                                                                                                                              result += 'minuta';
                                                                                                                                                                          } else if (number === 2) {
                                                                                                                                                                              result += 'minuti';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8211..8221
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8229..8239
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8240..8250

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 82.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      case 'MM':
                                                                                                                                                                          if (number === 1) {
                                                                                                                                                                              result += 'mesec';
                                                                                                                                                                          } else if (number === 2) {
                                                                                                                                                                              result += 'meseca';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8198..8208
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8211..8221
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8240..8250

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 82.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      case 'hh':
                                                                                                                                                                          if (number === 1) {
                                                                                                                                                                              result += 'ura';
                                                                                                                                                                          } else if (number === 2) {
                                                                                                                                                                              result += 'uri';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8198..8208
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8229..8239
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8240..8250

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 82.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                          if (hour < 3) {
                                                                                                                                                                              return 'राती';
                                                                                                                                                                          } else if (hour < 10) {
                                                                                                                                                                              return 'बिहान';
                                                                                                                                                                          } else if (hour < 15) {
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9279..9291

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function ru__weekdaysCaseReplace(m, format) {
                                                                                                                                                                      var weekdays = {
                                                                                                                                                                          'nominative': 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),
                                                                                                                                                                          'accusative': 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3576..3585
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3586..3595
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6486..6495
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7913..7922
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7923..7932
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9022..9031

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                          if (hm < 600) {
                                                                                                                                                                              return '凌晨';
                                                                                                                                                                          } else if (hm < 900) {
                                                                                                                                                                              return '早上';
                                                                                                                                                                          } else if (hm < 1130) {
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7483..7495

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function be__monthsCaseReplace(m, format) {
                                                                                                                                                                      var months = {
                                                                                                                                                                          'nominative': 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_'),
                                                                                                                                                                          'accusative': 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3586..3595
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6486..6495
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7913..7922
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7923..7932
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7933..7942
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9022..9031

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function uk__monthsCaseReplace(m, format) {
                                                                                                                                                                      var months = {
                                                                                                                                                                          'nominative': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_'),
                                                                                                                                                                          'accusative': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3576..3585
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3586..3595
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6486..6495
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7913..7922
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7923..7932
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7933..7942

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function ru__monthsCaseReplace(m, format) {
                                                                                                                                                                      var months = {
                                                                                                                                                                          'nominative': 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
                                                                                                                                                                          'accusative': 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3576..3585
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3586..3595
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6486..6495
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7923..7932
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7933..7942
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9022..9031

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function be__weekdaysCaseReplace(m, format) {
                                                                                                                                                                      var weekdays = {
                                                                                                                                                                          'nominative': 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split('_'),
                                                                                                                                                                          'accusative': 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3576..3585
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6486..6495
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7913..7922
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7923..7932
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7933..7942
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9022..9031

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function ka__weekdaysCaseReplace(m, format) {
                                                                                                                                                                      var weekdays = {
                                                                                                                                                                          'nominative': 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split('_'),
                                                                                                                                                                          'accusative': 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3576..3585
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3586..3595
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7913..7922
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7923..7932
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7933..7942
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9022..9031

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function ru__monthsShortCaseReplace(m, format) {
                                                                                                                                                                      var monthsShort = {
                                                                                                                                                                          'nominative': 'янв_фев_март_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
                                                                                                                                                                          'accusative': 'янв_фев_мар_апр_мая_июня_июля_авг_сен_окт_ноя_дек'.split('_')
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3576..3585
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3586..3595
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6486..6495
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7913..7922
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7933..7942
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9022..9031

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 81.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      calendar : {
                                                                                                                                                                          sameDay: '[Hoje às] LT',
                                                                                                                                                                          nextDay: '[Amanhã às] LT',
                                                                                                                                                                          nextWeek: 'dddd [às] LT',
                                                                                                                                                                          lastDay: '[Ontem às] LT',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7742..7753

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 80.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      calendar : {
                                                                                                                                                                          sameDay: '[Hoje às] LT',
                                                                                                                                                                          nextDay: '[Amanhã às] LT',
                                                                                                                                                                          nextWeek: 'dddd [às] LT',
                                                                                                                                                                          lastDay: '[Ontem às] LT',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7791..7802

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 80.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      meridiem : function (hour, minute, isLower) {
                                                                                                                                                                          if (hour < 4) {
                                                                                                                                                                              return 'रात';
                                                                                                                                                                          } else if (hour < 10) {
                                                                                                                                                                              return 'सुबह';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3945..3957
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7087..7099
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7193..7205

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 79.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      meridiem: function (hour, minute, isLower) {
                                                                                                                                                                          if (hour < 4) {
                                                                                                                                                                              return 'रात्री';
                                                                                                                                                                          } else if (hour < 10) {
                                                                                                                                                                              return 'सकाळी';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3945..3957
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5825..5837
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7087..7099

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 79.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      meridiem : function (hour, minute, isLower) {
                                                                                                                                                                          if (hour < 4) {
                                                                                                                                                                              return 'രാത്രി';
                                                                                                                                                                          } else if (hour < 12) {
                                                                                                                                                                              return 'രാവിലെ';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3945..3957
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5825..5837
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7193..7205

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 79.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      meridiem : function (hour, minute, isLower) {
                                                                                                                                                                          if (hour < 4) {
                                                                                                                                                                              return 'མཚན་མོ';
                                                                                                                                                                          } else if (hour < 10) {
                                                                                                                                                                              return 'ཞོགས་ཀས';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 3 other locations - About 2 hrs to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5825..5837
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7087..7099
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7193..7205

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 79.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      relativeTime : {
                                                                                                                                                                          future : 'за %s',
                                                                                                                                                                          past : '%s тому',
                                                                                                                                                                          s : 'декілька секунд',
                                                                                                                                                                          m : uk__relativeTimeWithPlural,
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7990..8004

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 71.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      relativeTime : {
                                                                                                                                                                          future : '%s vēlāk',
                                                                                                                                                                          past : '%s agrāk',
                                                                                                                                                                          s : 'dažas sekundes',
                                                                                                                                                                          m : 'minūti',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 7868..7882

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 71.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      relativeTime : {
                                                                                                                                                                          future : 'peste %s',
                                                                                                                                                                          past : '%s în urmă',
                                                                                                                                                                          s : 'câteva secunde',
                                                                                                                                                                          m : 'un minut',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6940..6954

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 71.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      relativeTime : {
                                                                                                                                                                          future : 'через %s',
                                                                                                                                                                          past : '%s назад',
                                                                                                                                                                          s : 'несколько секунд',
                                                                                                                                                                          m : ru__relativeTimeWithPlural,
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9085..9099

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 71.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      case 'MM':
                                                                                                                                                                          if (is__plural(number)) {
                                                                                                                                                                              if (withoutSuffix) {
                                                                                                                                                                                  return result + 'mánuðir';
                                                                                                                                                                              }
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6279..6288

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 70.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      case 'dd':
                                                                                                                                                                          if (is__plural(number)) {
                                                                                                                                                                              if (withoutSuffix) {
                                                                                                                                                                                  return result + 'dagar';
                                                                                                                                                                              }
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6294..6303

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 70.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      if (key === 'm') {
                                                                                                                                                                          return withoutSuffix ? 'хвіліна' : 'хвіліну';
                                                                                                                                                                      }
                                                                                                                                                                      else if (key === 'h') {
                                                                                                                                                                          return withoutSuffix ? 'гадзіна' : 'гадзіну';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9012..9020

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                      if (key === 'm') {
                                                                                                                                                                          return withoutSuffix ? 'хвилина' : 'хвилину';
                                                                                                                                                                      }
                                                                                                                                                                      else if (key === 'h') {
                                                                                                                                                                          return withoutSuffix ? 'година' : 'годину';
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3566..3574

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 67.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      ordinal: function (number, period) {
                                                                                                                                                                          switch (period) {
                                                                                                                                                                          case 'M':
                                                                                                                                                                          case 'd':
                                                                                                                                                                          case 'DDD':
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9318..9332
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9413..9427

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 66.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      ordinal : function (number, period) {
                                                                                                                                                                          switch (period) {
                                                                                                                                                                          case 'd':
                                                                                                                                                                          case 'D':
                                                                                                                                                                          case 'DDD':
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8021..8035
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9413..9427

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 66.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      ordinal : function (number, period) {
                                                                                                                                                                          switch (period) {
                                                                                                                                                                          case 'd' :
                                                                                                                                                                          case 'D' :
                                                                                                                                                                          case 'DDD' :
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 8021..8035
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9318..9332

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 66.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      calendar : {
                                                                                                                                                                          sameDay: '[Oggi alle] LT',
                                                                                                                                                                          nextDay: '[Domani alle] LT',
                                                                                                                                                                          nextWeek: 'dddd [alle] LT',
                                                                                                                                                                          lastDay: '[Ieri alle] LT',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4739..4753

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 64.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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

                                                                                                                                                                      calendarEl : {
                                                                                                                                                                          sameDay : '[Σήμερα {}] LT',
                                                                                                                                                                          nextDay : '[Αύριο {}] LT',
                                                                                                                                                                          nextWeek : 'dddd [{}] LT',
                                                                                                                                                                          lastDay : '[Χθες {}] LT',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6378..6392

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 64.

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

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

                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ 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 7 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      longDateFormat : {
                                                                                                                                                                          LT : 'Ah点mm',
                                                                                                                                                                          LTS : 'Ah点m分s秒',
                                                                                                                                                                          L : 'YYYY-MM-DD',
                                                                                                                                                                          LL : 'YYYY年MMMD日',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5157..5168
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5347..5358
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5673..5684
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6850..6861
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9194..9205
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9365..9376

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 7 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      longDateFormat : {
                                                                                                                                                                          LT : 'HH.mm',
                                                                                                                                                                          LTS : 'HH.mm.ss',
                                                                                                                                                                          L : 'DD.MM.YYYY',
                                                                                                                                                                          LL : 'Do MMMM[ta] YYYY',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5157..5168
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5673..5684
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6850..6861
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9194..9205
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9250..9261
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9365..9376

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 7 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      longDateFormat : {
                                                                                                                                                                          LT : 'HH:mm',
                                                                                                                                                                          LTS : 'LT:ss',
                                                                                                                                                                          L : 'YYYY-MM-DD',
                                                                                                                                                                          LL : 'YYYY [m.] MMMM D [d.]',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5157..5168
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5347..5358
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5673..5684
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9194..9205
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9250..9261
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9365..9376

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 7 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      longDateFormat : {
                                                                                                                                                                          LT : 'HH:mm',
                                                                                                                                                                          LTS : 'LT:ss',
                                                                                                                                                                          L : 'YYYY-MM-DD',
                                                                                                                                                                          LL : 'YYYY[ko] MMMM[ren] D[a]',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5347..5358
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5673..5684
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6850..6861
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9194..9205
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9250..9261
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9365..9376

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 7 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      longDateFormat : {
                                                                                                                                                                          LT : 'HH:mm',
                                                                                                                                                                          LTS : 'LT:ss',
                                                                                                                                                                          L : 'DD/MM/YYYY',
                                                                                                                                                                          LL : 'D MMMM [năm] YYYY',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5157..5168
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5347..5358
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5673..5684
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6850..6861
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9250..9261
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9365..9376

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 7 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      longDateFormat : {
                                                                                                                                                                          LT : 'HH:mm',
                                                                                                                                                                          LTS : 'LT:ss',
                                                                                                                                                                          L : 'DD/MM/YYYY',
                                                                                                                                                                          LL : 'D [ב]MMMM YYYY',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5157..5168
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5347..5358
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6850..6861
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9194..9205
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9250..9261
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9365..9376

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 7 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      longDateFormat : {
                                                                                                                                                                          LT : 'Ah點mm',
                                                                                                                                                                          LTS : 'Ah點m分s秒',
                                                                                                                                                                          L : 'YYYY年MMMD日',
                                                                                                                                                                          LL : 'YYYY年MMMD日',
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 6 other locations - About 1 hr to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5157..5168
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5347..5358
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5673..5684
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6850..6861
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9194..9205
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 9250..9261

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                      } else {
                                                                                                                                                                          anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
                                                                                                                                                                          // linear across the month
                                                                                                                                                                          adjust = (b - anchor) / (anchor2 - anchor);
                                                                                                                                                                      }
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 55 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 1890..1894

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 53.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function processPastTime(string) {
                                                                                                                                                                      var number = string.substr(0, string.indexOf(' '));
                                                                                                                                                                      if (eifelerRegelAppliesToNumber(number)) {
                                                                                                                                                                          return 'viru ' + string;
                                                                                                                                                                      }
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 55 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6682..6688

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 53.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                  function processFutureTime(string) {
                                                                                                                                                                      var number = string.substr(0, string.indexOf(' '));
                                                                                                                                                                      if (eifelerRegelAppliesToNumber(number)) {
                                                                                                                                                                          return 'a ' + string;
                                                                                                                                                                      }
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 55 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 6689..6695

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 53.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      if (b - anchor < 0) {
                                                                                                                                                                          anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
                                                                                                                                                                          // linear across the month
                                                                                                                                                                          adjust = (b - anchor) / (anchor - anchor2);
                                                                                                                                                                      } else {
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 55 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 1894..1898

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 53.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      meridiem : function (hours, minutes, isLower) {
                                                                                                                                                                          if (hours > 11) {
                                                                                                                                                                              return isLower ? 'μμ' : 'ΜΜ';
                                                                                                                                                                          } else {
                                                                                                                                                                              return isLower ? 'πμ' : 'ΠΜ';
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 35 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3096..3102
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4972..4978

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      meridiem : function (hours, minutes, isLower) {
                                                                                                                                                                          if (hours < 12) {
                                                                                                                                                                              return isLower ? 'vm' : 'VM';
                                                                                                                                                                          } else {
                                                                                                                                                                              return isLower ? 'nm' : 'NM';
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 35 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4720..4726
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4972..4978

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      meridiem : function (hours, minutes, isLower) {
                                                                                                                                                                          if (hours > 11) {
                                                                                                                                                                              return isLower ? 'p.t.m.' : 'P.T.M.';
                                                                                                                                                                          } else {
                                                                                                                                                                              return isLower ? 'a.t.m.' : 'A.T.M.';
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 2 other locations - About 35 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3096..3102
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 4720..4726

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                              this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 35 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 641..641

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                              this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 35 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 642..642

                                                                                                                                                              Duplicated Code

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

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

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

                                                                                                                                                              Tuning

                                                                                                                                                              This issue has a mass of 46.

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

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

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

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

                                                                                                                                                              Refactorings

                                                                                                                                                              Further Reading

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

                                                                                                                                                                      postformat: function (string) {
                                                                                                                                                                          return string.replace(/\d/g, function (match) {
                                                                                                                                                                              return ar_sa__symbolMap[match];
                                                                                                                                                                          }).replace(/,/g, '،');
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 5 other locations - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3268..3272
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3439..3443
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3444..3448
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5276..5280
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5281..5285

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 6 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      postformat: function (string) {
                                                                                                                                                                          return string.replace(/\d/g, function (match) {
                                                                                                                                                                              return fa__symbolMap[match];
                                                                                                                                                                          }).replace(/,/g, '،');
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 5 other locations - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3268..3272
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3273..3277
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3439..3443
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3444..3448
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5276..5280

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 6 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      preparse: function (string) {
                                                                                                                                                                          return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
                                                                                                                                                                              return ar_sa__numberMap[match];
                                                                                                                                                                          }).replace(/،/g, ',');
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 5 other locations - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3273..3277
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3439..3443
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3444..3448
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5276..5280
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5281..5285

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 6 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      preparse: function (string) {
                                                                                                                                                                          return string.replace(/[١٢٣٤٥٦٧٨٩٠]/g, function (match) {
                                                                                                                                                                              return ar__numberMap[match];
                                                                                                                                                                          }).replace(/،/g, ',');
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 5 other locations - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3268..3272
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3273..3277
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3444..3448
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5276..5280
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5281..5285

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 6 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      preparse: function (string) {
                                                                                                                                                                          return string.replace(/[۰-۹]/g, function (match) {
                                                                                                                                                                              return fa__numberMap[match];
                                                                                                                                                                          }).replace(/،/g, ',');
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 5 other locations - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3268..3272
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3273..3277
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3439..3443
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3444..3448
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5281..5285

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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 6 locations. Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                      postformat: function (string) {
                                                                                                                                                                          return string.replace(/\d/g, function (match) {
                                                                                                                                                                              return ar__symbolMap[match];
                                                                                                                                                                          }).replace(/,/g, '،');
                                                                                                                                                                      },
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 5 other locations - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3268..3272
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3273..3277
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 3439..3443
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5276..5280
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 5281..5285

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                  var prototypeMax = deprecate(
                                                                                                                                                                      'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
                                                                                                                                                                      function () {
                                                                                                                                                                          var other = local__createLocal.apply(null, arguments);
                                                                                                                                                                          return other > this ? this : other;
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 1364..1370

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                  addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
                                                                                                                                                                      week[token.substr(0, 1)] = toInt(input);
                                                                                                                                                                  });
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 2078..2080

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                  var prototypeMin = deprecate(
                                                                                                                                                                       'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
                                                                                                                                                                       function () {
                                                                                                                                                                           var other = local__createLocal.apply(null, arguments);
                                                                                                                                                                           return other < this ? this : other;
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 1372..1378

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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

                                                                                                                                                                  addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
                                                                                                                                                                      week[token.substr(0, 2)] = toInt(input);
                                                                                                                                                                  });
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in plugins/orders/public/javascripts/moment-with-locales.js and 1 other location - About 30 mins to fix
                                                                                                                                                              plugins/orders/public/javascripts/moment-with-locales.js on lines 904..906

                                                                                                                                                              Duplicated Code

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

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

                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both 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