Sign upLogin

IHTSDO/component-identifier-service

View on GitHub
Star

Showing 1,102 of 1,102 total issues

Function processJob has 406 lines of code (exceeds 25 allowed). Consider refactoring.
Open

function processJob(record){

    var request=JSON.parse(record.request);
    if (!request || !request.type || request.type==null){
        var lightJob={
Severity: Major
Found in blogic/BackEndJobService.js - About 2 days to fix

    Function insertRecords has a Cognitive Complexity of 88 (exceeds 5 allowed). Consider refactoring.
    Open

    var insertRecords=function(records, operation, callback) {
    Sync(function () {
        var err;
        try {
            sctid.bulkInsert.sync(null, records);
    Severity: Minor
    Found in blogic/SCTIdBulkDataManager.js - About 1 day to fix

    Cognitive Complexity

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

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

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

    Further reading

    File SCTIdBulkDataManager.js has 738 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /**
 * Created by ar on 7/16/15.
 */
var dbInit=require("../config/dbInit");
var stateMachine=require("../model/StateMachine");
    Severity: Major
    Found in blogic/SCTIdBulkDataManager.js - About 1 day to fix

      Function checkSctid has a Cognitive Complexity of 73 (exceeds 5 allowed). Consider refactoring.
      Open

      var checkSctid = function (sctid, callback) {
    var err = "";

    var partitionId = "";
    var checkDigit = null;
      Severity: Minor
      Found in blogic/SCTIdDataManager.js - About 1 day to fix

      Cognitive Complexity

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

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

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

      Further reading

      File SchemeIdBulkDataManager.js has 626 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      /**
 * Created by ar on 7/16/15.
 */
var dbInit=require("../config/dbInit");
var stateMachine=require("../model/StateMachine");
      Severity: Major
      Found in blogic/SchemeIdBulkDataManager.js - About 1 day to fix

        File SCTIdDataManager.js has 622 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        /**
 * Created by ar on 7/16/15.
 */
var dbInit=require("../config/dbInit");
var stateMachine=require("../model/StateMachine");
        Severity: Major
        Found in blogic/SCTIdDataManager.js - About 1 day to fix

          Function processJob has a Cognitive Complexity of 61 (exceeds 5 allowed). Consider refactoring.
          Open

          function processJob(record){

    var request=JSON.parse(record.request);
    if (!request || !request.type || request.type==null){
        var lightJob={
          Severity: Minor
          Found in blogic/BackEndJobService.js - About 1 day to fix

          Cognitive Complexity

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

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

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

          Further reading

          Function insertRecords has a Cognitive Complexity of 53 (exceeds 5 allowed). Consider refactoring.
          Open

          var insertRecords=function(records, scheme, key, autoSysId, callback) {
    Sync(function () {
        var err;
        try {
            schemeid.bulkInsert.sync(null, records);
          Severity: Minor
          Found in blogic/SchemeIdBulkDataManager.js - About 1 day to fix

          Cognitive Complexity

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

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

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

          Further reading

          Function has too many statements (81). Maximum allowed is 30.
          Open

          var checkSctid = function (sctid, callback) {
          Severity: Minor
          Found in blogic/SCTIdDataManager.js by eslint

          enforce a maximum number of statements allowed in function blocks (max-statements)

          The max-statements rule allows you to specify the maximum number of statements allowed in a function.

          function foo() {
  var bar = 1; // one statement
  var baz = 2; // two statements
  var qux = 3; // three statements
}

          Rule Details

          This rule enforces a maximum number of statements allowed in function blocks.

          Options

          This rule has a number or object option:

          • "max" (default 10) enforces a maximum number of statements allows in function blocks

          Deprecated: The object property maximum is deprecated; please use the object property max instead.

          This rule has an object option:

          • "ignoreTopLevelFunctions": true ignores top-level functions

          max

          Examples of incorrect code for this rule with the default { "max": 10 } option:

          /*eslint max-statements: ["error", 10]*/
/*eslint-env es6*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;

  var foo11 = 11; // Too many.
}

let foo = () => {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;

  var foo11 = 11; // Too many.
};

          Examples of correct code for this rule with the default { "max": 10 } option:

          /*eslint max-statements: ["error", 10]*/
/*eslint-env es6*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  return function () {

    // The number of statements in the inner function does not count toward the
    // statement maximum.

    return 42;
  };
}

let foo = () => {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  return function () {

    // The number of statements in the inner function does not count toward the
    // statement maximum.

    return 42;
  };
}

          ignoreTopLevelFunctions

          Examples of additional correct code for this rule with the { "max": 10 }, { "ignoreTopLevelFunctions": true } options:

          /*eslint max-statements: ["error", 10, { "ignoreTopLevelFunctions": true }]*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  var foo11 = 11;
}

          Related Rules

          • [complexity](complexity.md)
          • [max-depth](max-depth.md)
          • [max-len](max-len.md)
          • [max-nested-callbacks](max-nested-callbacks.md)
          • [max-params](max-params.md) Source: http://eslint.org/docs/rules/

          File SchemeIdDataManager.js has 461 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          /**
 * Created by ar on 7/16/15.
 */
var dbInit=require("../config/dbInit");
var stateMachine=require("../model/StateMachine");
          Severity: Minor
          Found in blogic/SchemeIdDataManager.js - About 7 hrs to fix

            Function findFieldSelect has a Cognitive Complexity of 45 (exceeds 5 allowed). Consider refactoring.
            Open

            job.findFieldSelect=function(query, fields,limit, skip,orderBy, callback){
    db.getDB(function (err,connection)
    {
        if (err) throw err;
        if (!query){
            Severity: Minor
            Found in model/job.js - About 6 hrs to fix

            Cognitive Complexity

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

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

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

            Further reading

            Function checkSctid has 172 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            var checkSctid = function (sctid, callback) {
    var err = "";

    var partitionId = "";
    var checkDigit = null;
            Severity: Major
            Found in blogic/SCTIdDataManager.js - About 6 hrs to fix

              File BackEndJobService.js has 450 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              /**
 * Created by ar on 7/31/15.
 */

var job=require("../model/JobType");
              Severity: Minor
              Found in blogic/BackEndJobService.js - About 6 hrs to fix

                File SctidBulk.js has 433 lines of code (exceeds 250 allowed). Consider refactoring.
                Open

                /**
 * Created by alo on 7/13/15.
 */
'use strict';
                Severity: Minor
                Found in controllers/SctidBulk.js - About 6 hrs to fix

                  File Sctid.js has 432 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  /**
 * Created by alo on 7/13/15.
 */
'use strict';
                  Severity: Minor
                  Found in controllers/Sctid.js - About 6 hrs to fix

                    Function has a complexity of 37.
                    Open

                    var checkSctid = function (sctid, callback) {
                    Severity: Minor
                    Found in blogic/SCTIdDataManager.js by eslint

                    Limit Cyclomatic Complexity (complexity)

                    Cyclomatic complexity measures the number of linearly independent paths through a program's source code. This rule allows setting a cyclomatic complexity threshold.

                    function a(x) {
    if (true) {
        return x; // 1st path
    } else if (false) {
        return x+1; // 2nd path
    } else {
        return 4; // 3rd path
    }
}

                    Rule Details

                    This rule is aimed at reducing code complexity by capping the amount of cyclomatic complexity allowed in a program. As such, it will warn when the cyclomatic complexity crosses the configured threshold (default is 20).

                    Examples of incorrect code for a maximum of 2:

                    /*eslint complexity: ["error", 2]*/

function a(x) {
    if (true) {
        return x;
    } else if (false) {
        return x+1;
    } else {
        return 4; // 3rd path
    }
}

                    Examples of correct code for a maximum of 2:

                    /*eslint complexity: ["error", 2]*/

function a(x) {
    if (true) {
        return x;
    } else {
        return 4;
    }
}

                    Options

                    Optionally, you may specify a max object property:

                    "complexity": ["error", 2]

                    is equivalent to

                    "complexity": ["error", { "max": 2 }]

                    Deprecated: the object property maximum is deprecated. Please use the property max instead.

                    When Not To Use It

                    If you can't determine an appropriate complexity limit for your code, then it's best to disable this rule.

                    Further Reading

                    Related Rules

                    • [max-depth](max-depth.md)
                    • [max-len](max-len.md)
                    • [max-nested-callbacks](max-nested-callbacks.md)
                    • [max-params](max-params.md)
                    • [max-statements](max-statements.md) Source: http://eslint.org/docs/rules/

                    Function 'processJob' has too many statements (60). Maximum allowed is 30.
                    Open

                    function processJob(record){
                    Severity: Minor
                    Found in blogic/BackEndJobService.js by eslint

                    enforce a maximum number of statements allowed in function blocks (max-statements)

                    The max-statements rule allows you to specify the maximum number of statements allowed in a function.

                    function foo() {
  var bar = 1; // one statement
  var baz = 2; // two statements
  var qux = 3; // three statements
}

                    Rule Details

                    This rule enforces a maximum number of statements allowed in function blocks.

                    Options

                    This rule has a number or object option:

                    • "max" (default 10) enforces a maximum number of statements allows in function blocks

                    Deprecated: The object property maximum is deprecated; please use the object property max instead.

                    This rule has an object option:

                    • "ignoreTopLevelFunctions": true ignores top-level functions

                    max

                    Examples of incorrect code for this rule with the default { "max": 10 } option:

                    /*eslint max-statements: ["error", 10]*/
/*eslint-env es6*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;

  var foo11 = 11; // Too many.
}

let foo = () => {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;

  var foo11 = 11; // Too many.
};

                    Examples of correct code for this rule with the default { "max": 10 } option:

                    /*eslint max-statements: ["error", 10]*/
/*eslint-env es6*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  return function () {

    // The number of statements in the inner function does not count toward the
    // statement maximum.

    return 42;
  };
}

let foo = () => {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  return function () {

    // The number of statements in the inner function does not count toward the
    // statement maximum.

    return 42;
  };
}

                    ignoreTopLevelFunctions

                    Examples of additional correct code for this rule with the { "max": 10 }, { "ignoreTopLevelFunctions": true } options:

                    /*eslint max-statements: ["error", 10, { "ignoreTopLevelFunctions": true }]*/

function foo() {
  var foo1 = 1;
  var foo2 = 2;
  var foo3 = 3;
  var foo4 = 4;
  var foo5 = 5;
  var foo6 = 6;
  var foo7 = 7;
  var foo8 = 8;
  var foo9 = 9;
  var foo10 = 10;
  var foo11 = 11;
}

                    Related Rules

                    • [complexity](complexity.md)
                    • [max-depth](max-depth.md)
                    • [max-len](max-len.md)
                    • [max-nested-callbacks](max-nested-callbacks.md)
                    • [max-params](max-params.md) Source: http://eslint.org/docs/rules/

                    Function registerSctid has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.
                    Open

                    var registerSctid=function (operation, callback) {

    if (!operation.autoSysId) {
        getSctidBySystemId(operation.namespace, operation.systemId, function (err, sctid) {
            if (err) {
                    Severity: Minor
                    Found in blogic/SCTIdDataManager.js - About 4 hrs to fix

                    Cognitive Complexity

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

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

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

                    Further reading

                    Function registerSchemeId has a Cognitive Complexity of 33 (exceeds 5 allowed). Consider refactoring.
                    Open

                    var registerSchemeId=function (scheme, operation, callback){

    if (!operation.autoSysId) {
        getSchemeIdBySystemId(scheme, operation.systemId, function (err, schemeId) {
            if (err) {
                    Severity: Minor
                    Found in blogic/SchemeIdDataManager.js - About 4 hrs to fix

                    Cognitive Complexity

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

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

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

                    Further reading

                    Method run has a Cognitive Complexity of 32 (exceeds 5 allowed). Consider refactoring.
                    Open

                        @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("\nThis process will synchronise the sequence of every partition within every namespace\n" +
                "from the source CIS instance to the target CIS instance\n" +
                "where the partition is available on both sides.\n");
                    Severity: Minor
                    Found in java-client/src/main/java/org/snomed/cis/maintenance/MaintenanceApplication.java - About 4 hrs to fix

                    Cognitive Complexity

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

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

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

                    Further reading

                    Severity
                    Category
                    Status
                    Source
                    Language