Sign upLogin

IHTSDO/component-identifier-service

View on GitHub
Star

Showing 1,102 of 1,102 total issues

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

var relationshipIdBulkCreation = function (namespace, partitionId, idsTotal, request, callback) {


    //console.log("step relationshipIdBulkCreation");
Severity: Major
Found in blogic/BulkIdCreation.js - About 2 hrs to fix

    Method run has 53 lines of code (exceeds 25 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: Major
    Found in java-client/src/main/java/org/snomed/cis/maintenance/MaintenanceApplication.java - About 2 hrs to fix

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

      module.exports.getSctid = function getSctid (req, res, next) {
    var token = req.swagger.params.token.value;
    var sctid = req.swagger.params.sctid.value;
    var includeAdditionalIds = req.swagger.params.includeAdditionalIds.value;
    security.authenticate(token, function(err, data) {
      Severity: Major
      Found in controllers/Sctid.js - About 2 hrs to fix

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

        var conceptIdBulkCreation = function (namespace, partitionId, idsTotal, request, callback) {


    //console.log("step conceptIdBulkCreation");
        Severity: Major
        Found in blogic/BulkIdCreation.js - About 2 hrs to fix

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

          var descriptionIdBulkCreation = function (namespace, partitionId, idsTotal, request, callback) {


    //console.log("step descriptionIdBulkCreation");
          Severity: Major
          Found in blogic/BulkIdCreation.js - About 2 hrs to fix

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

            module.exports.createNamespace = function createNamespace(objNamespace, callback){
    dbInit.getDB(function (err, pdb, model) {
        if (err)
            throw err;
        else{
            Severity: Major
            Found in blogic/NamespaceDataManager.js - About 2 hrs to fix

              Function find has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
              Open

              job.find=function(query, limit, skip, callback){
    db.getDB(function (err,connection)
    {
        if (err) throw err;
        if (!query){
              Severity: Minor
              Found in model/job.js - About 2 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 getNamespaces has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
              Open

              module.exports.getNamespaces = function getNamespaces (req, res, next) {
    namespace.getNamespaces(function(err, namespaces) {
        if (err)
            return next(err.message);
        else{
              Severity: Minor
              Found in controllers/Namespace.js - About 2 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 updateSchemeIds has 52 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              var updateSchemeIds=function ( operation, callback){
    var cont=0;
    var records=[];
    var error=false;
    var scheme=operation.scheme;
              Severity: Major
              Found in blogic/SchemeIdBulkDataManager.js - About 2 hrs to fix

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

                var generateSchemeIdSmallRequest=function ( operation, callback) {
    getModel(function (err) {
        if (err) {
            console.log("error model:" + err);
            callback(err);
                Severity: Major
                Found in blogic/SchemeIdBulkDataManager.js - About 2 hrs to fix

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

                  var updateSctids=function (operation, callback){
    var cont=0;
    var records=[];
    var error=false;
    for (var i=0;i<operation.sctids.length;i++) {
                  Severity: Major
                  Found in blogic/SCTIdBulkDataManager.js - About 2 hrs to fix

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

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

                      Function save has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                      Open

                       schemeid.save=function(schemeIdRecord,callback){

    db.getDB(function (err,connection)
    {
        if (err) throw err;
                      Severity: Minor
                      Found in model/schemeid.js - About 1 hr to fix

                      Cognitive Complexity

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

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

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

                      Further reading

                      Function idsRetrieve has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                      Open

                      var idsRetrieve = function (request, callback) {

    if (request.partitionId.substr(1,1)=="0") {
        conceptIdBulkCreation( request.namespace, request.partitionId, request.quantity, request, function(err, result){
                      Severity: Minor
                      Found in blogic/BulkIdCreation.js - About 1 hr to fix

                      Cognitive Complexity

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

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

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

                      Further reading

                      Function has a complexity of 8.
                      Open

                          db.getDB(function (err,connection)
                      Severity: Minor
                      Found in model/job.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 has too many statements (32). Maximum allowed is 30.
                      Open

                          db.getDB(function (err,connection)
                      Severity: Minor
                      Found in model/job.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 has a complexity of 8.
                      Open

                              isAbleUser(generationData.namespace, data.user.name, function(able){
                      Severity: Minor
                      Found in controllers/SctidBulk.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 has a complexity of 8.
                      Open

                              function (err, data) {
                      Severity: Minor
                      Found in blogic/CleanService.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 has a complexity of 8.
                      Open

                              function (err, data) {
                      Severity: Minor
                      Found in blogic/CleanService.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 find has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      schemeid.find=function(query, limit, skip, callback){
    db.getDB(function (err,connection)
    {
        if (err) throw err;
        var swhere="";
                      Severity: Minor
                      Found in model/schemeid.js - About 1 hr to fix
                        Severity
                        Category
                        Status
                        Source
                        Language