Sign upLogin

IHTSDO/component-identifier-service

View on GitHub
Star
controllers/SchemeIdBulk.js

Summary

Maintainability
C
1 day
Test Coverage

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

function isAbleUser(schemeName, user, callback){
    var able = false;
    security.admins.forEach(function(admin){
        if (admin == user)
            able = true;
Severity: Minor
Found in controllers/SchemeIdBulk.js - About 1 hr to fix

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

    module.exports.generateSchemeIds = function generateSchemeIds (req, res, next) {
    var token = req.swagger.params.token.value;
    var schemeName = req.swagger.params.schemeName.value;
    var generationMetadata = req.swagger.params.generationMetadata.value;
    security.authenticate(token, function(err, data) {
    Severity: Minor
    Found in controllers/SchemeIdBulk.js - About 1 hr to fix

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

      module.exports.registerSchemeIds = function registerSchemeIds (req, res, next) {
    var token = req.swagger.params.token.value;
    var schemeName = req.swagger.params.schemeName.value;
    var registrationMetadata = req.swagger.params.registrationMetadata.value;
    security.authenticate(token, function(err, data) {
      Severity: Minor
      Found in controllers/SchemeIdBulk.js - About 1 hr to fix

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

        module.exports.publishSchemeIds = function publishSchemeIds (req, res, next) {
    var token = req.swagger.params.token.value;
    var schemeName = req.swagger.params.schemeName.value;
    var publicationMetadata = req.swagger.params.publicationMetadata.value;
    security.authenticate(token, function(err, data) {
        Severity: Minor
        Found in controllers/SchemeIdBulk.js - About 1 hr to fix

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

          module.exports.reserveSchemeIds = function reserveSchemeIds (req, res, next) {
    var token = req.swagger.params.token.value;
    var schemeName = req.swagger.params.schemeName.value;
    var reservationMetadata = req.swagger.params.reservationMetadata.value;
    security.authenticate(token, function(err, data) {
          Severity: Minor
          Found in controllers/SchemeIdBulk.js - About 1 hr to fix

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

            module.exports.releaseSchemeIds = function releaseSchemeIds (req, res, next) {
    var token = req.swagger.params.token.value;
    var schemeName = req.swagger.params.schemeName.value;
    var releaseMetadata = req.swagger.params.releaseMetadata.value;
    security.authenticate(token, function(err, data) {
            Severity: Minor
            Found in controllers/SchemeIdBulk.js - About 1 hr to fix

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

              module.exports.deprecateSchemeIds = function deprecateSchemeIds (req, res, next) {
    var token = req.swagger.params.token.value;
    var schemeName = req.swagger.params.schemeName.value;
    var deprecationMetadata = req.swagger.params.deprecationMetadata.value;
    security.authenticate(token, function(err, data) {
              Severity: Minor
              Found in controllers/SchemeIdBulk.js - About 1 hr to fix

                Avoid deeply nested control flow statements.
                Open

                                            if (err) {
                                console.log("Error accessing groups", err);
                                callback(able);
                            } else {
                                result.forEach(function(loopGroup){
                Severity: Major
                Found in controllers/SchemeIdBulk.js - About 45 mins to fix

                  Expected '===' and instead saw '=='.
                  Open

                                          if (permission.role == "group"){
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  Expected '!==' and instead saw '!='.
                  Open

                                                      if (possibleGroups.indexOf(loopGroup) != -1)
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  Expected return with your callback function.
                  Open

                              callback(able);
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Enforce Return After Callback (callback-return)

                  The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

                  function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

                  Rule Details

                  This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

                  Options

                  The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

                  Default callback names

                  Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

                  Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  Supplied callback names

                  Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

                  Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

                  Known Limitations

                  Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

                  • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
                  • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

                  Passing the callback by reference

                  The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

                  Triggering the callback within a nested function

                  The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

                  If/else statements

                  The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

                  Example of a false positive when this rule reports incorrect code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

                  When Not To Use It

                  There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

                  Further Reading

                  Related Rules

                  Expected '===' and instead saw '=='.
                  Open

                                  if (!registrationMetadata.records || registrationMetadata.records.length==0){
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  Expected return with your callback function.
                  Open

                                                  callback(able);
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Enforce Return After Callback (callback-return)

                  The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

                  function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

                  Rule Details

                  This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

                  Options

                  The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

                  Default callback names

                  Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

                  Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  Supplied callback names

                  Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

                  Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

                  Known Limitations

                  Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

                  • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
                  • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

                  Passing the callback by reference

                  The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

                  Triggering the callback within a nested function

                  The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

                  If/else statements

                  The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

                  Example of a false positive when this rule reports incorrect code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

                  When Not To Use It

                  There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

                  Further Reading

                  Related Rules

                  Expected '===' and instead saw '=='.
                  Open

                          if (admin == user)
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  Expected '!==' and instead saw '!='.
                  Open

                                  if (generationMetadata.systemIds && generationMetadata.systemIds.length!=0 && generationMetadata.systemIds.length!=generationMetadata.quantity){
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  Expected return with your callback function.
                  Open

                          callback(able);
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Enforce Return After Callback (callback-return)

                  The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

                  function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

                  Rule Details

                  This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

                  Options

                  The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

                  Default callback names

                  Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

                  Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  Supplied callback names

                  Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

                  Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

                  Known Limitations

                  Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

                  • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
                  • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

                  Passing the callback by reference

                  The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

                  Triggering the callback within a nested function

                  The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

                  If/else statements

                  The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

                  Example of a false positive when this rule reports incorrect code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

                  When Not To Use It

                  There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

                  Further Reading

                  Related Rules

                  Expected '===' and instead saw '=='.
                  Open

                                          }else if (permission.username == user)
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  Expected return with your callback function.
                  Open

                                                  callback(able);
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Enforce Return After Callback (callback-return)

                  The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

                  function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

                  Rule Details

                  This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

                  Options

                  The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

                  Default callback names

                  Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

                  Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  Supplied callback names

                  Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

                  Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

                  Known Limitations

                  Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

                  • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
                  • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

                  Passing the callback by reference

                  The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

                  Triggering the callback within a nested function

                  The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

                  If/else statements

                  The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

                  Example of a false positive when this rule reports incorrect code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

                  When Not To Use It

                  There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

                  Further Reading

                  Related Rules

                  Expected '===' and instead saw '=='.
                  Open

                                  if (!generationMetadata.systemIds || generationMetadata.systemIds.length==0){
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  Expected return with your callback function.
                  Open

                                          callback(able);
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Enforce Return After Callback (callback-return)

                  The callback pattern is at the heart of most I/O and event-driven programming in JavaScript.

                  function doSomething(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  To prevent calling the callback multiple times it is important to return anytime the callback is triggered outside of the main function body. Neglecting this technique often leads to issues where you do something more than once. For example, in the case of an HTTP request, you may try to send HTTP headers more than once leading Node.js to throw a Can't render headers after they are sent to the client. error.

                  Rule Details

                  This rule is aimed at ensuring that callbacks used outside of the main function block are always part-of or immediately preceding a return statement. This rule decides what is a callback based on the name of the function being called.

                  Options

                  The rule takes a single option - an array of possible callback names - which may include object methods. The default callback names are callback, cb, next.

                  Default callback names

                  Examples of incorrect code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err);
    }
    callback();
}

                  Examples of correct code for this rule with the default ["callback", "cb", "next"] option:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        return callback(err);
    }
    callback();
}

                  Supplied callback names

                  Examples of incorrect code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        send.error(err);
    }
    send.success();
}

                  Examples of correct code for this rule with the option ["done", "send.error", "send.success"]:

                  /*eslint callback-return: ["error", ["done", "send.error", "send.success"]]*/

function foo(err, done) {
    if (err) {
        return done(err);
    }
    done();
}

function bar(err, send) {
    if (err) {
        return send.error(err);
    }
    send.success();
}

                  Known Limitations

                  Because it is difficult to understand the meaning of a program through static analysis, this rule has limitations:

                  • false negatives when this rule reports correct code, but the program calls the callback more than one time (which is incorrect behavior)
                  • false positives when this rule reports incorrect code, but the program calls the callback only one time (which is correct behavior)

                  Passing the callback by reference

                  The static analysis of this rule does not detect that the program calls the callback if it is an argument of a function (for example, setTimeout).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        setTimeout(callback, 0); // this is bad, but WILL NOT warn
    }
    callback();
}

                  Triggering the callback within a nested function

                  The static analysis of this rule does not detect that the program calls the callback from within a nested function or an immediately-invoked function expression (IIFE).

                  Example of a false negative when this rule reports correct code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        process.nextTick(function() {
            return callback(); // this is bad, but WILL NOT warn
        });
    }
    callback();
}

                  If/else statements

                  The static analysis of this rule does not detect that the program calls the callback only one time in each branch of an if statement.

                  Example of a false positive when this rule reports incorrect code:

                  /*eslint callback-return: "error"*/

function foo(err, callback) {
    if (err) {
        callback(err); // this is fine, but WILL warn
    } else {
        callback();    // this is fine, but WILL warn
    }
}

                  When Not To Use It

                  There are some cases where you might want to call a callback function more than once. In those cases this rule may lead to incorrect behavior. In those cases you may want to reserve a special name for those callbacks and not include that in the list of callbacks that trigger warnings.

                  Further Reading

                  Related Rules

                  Expected '!==' and instead saw '!='.
                  Open

                                  if (generationMetadata.systemIds && generationMetadata.systemIds.length!=0 && generationMetadata.systemIds.length!=generationMetadata.quantity){
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  Expected '!==' and instead saw '!='.
                  Open

                          if (schemeName != "false"){
                  Severity: Minor
                  Found in controllers/SchemeIdBulk.js by eslint

                  Require === and !== (eqeqeq)

                  It is considered good practice to use the type-safe equality operators === and !== instead of their regular counterparts == and !=.

                  The reason for this is that == and != do type coercion which follows the rather obscure Abstract Equality Comparison Algorithm. For instance, the following statements are all considered true:

                  • [] == false
                  • [] == ![]
                  • 3 == "03"

                  If one of those occurs in an innocent-looking statement such as a == b the actual problem is very difficult to spot.

                  Rule Details

                  This rule is aimed at eliminating the type-unsafe equality operators.

                  Examples of incorrect code for this rule:

                  /*eslint eqeqeq: "error"*/

if (x == 42) { }

if ("" == text) { }

if (obj.getStuff() != undefined) { }

                  The --fix option on the command line automatically fixes some problems reported by this rule. A problem is only fixed if one of the operands is a typeof expression, or if both operands are literals with the same type.

                  Options

                  always

                  The "always" option (default) enforces the use of === and !== in every situation (except when you opt-in to more specific handling of null [see below]).

                  Examples of incorrect code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a == b
foo == true
bananas != 1
value == undefined
typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  Examples of correct code for the "always" option:

                  /*eslint eqeqeq: ["error", "always"]*/

a === b
foo === true
bananas !== 1
value === undefined
typeof foo === 'undefined'
'hello' !== 'world'
0 === 0
true === true
foo === null

                  This rule optionally takes a second argument, which should be an object with the following supported properties:

                  • "null": Customize how this rule treats null literals. Possible values:
                    • always (default) - Always use === or !==.
                    • never - Never use === or !== with null.
                    • ignore - Do not apply this rule to null.

                  smart

                  The "smart" option enforces the use of === and !== except for these cases:

                  • Comparing two literal values
                  • Evaluating the value of typeof
                  • Comparing against null

                  Examples of incorrect code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

// comparing two variables requires ===
a == b

// only one side is a literal
foo == true
bananas != 1

// comparing to undefined requires ===
value == undefined

                  Examples of correct code for the "smart" option:

                  /*eslint eqeqeq: ["error", "smart"]*/

typeof foo == 'undefined'
'hello' != 'world'
0 == 0
true == true
foo == null

                  allow-null

                  Deprecated: Instead of using this option use "always" and pass a "null" option property with value "ignore". This will tell eslint to always enforce strict equality except when comparing with the null literal.

                  ["error", "always", {"null": "ignore"}]

                  When Not To Use It

                  If you don't want to enforce a style for using equality operators, then it's safe to disable this rule. Source: http://eslint.org/docs/rules/

                  There are no issues that match your filters.

                  Category
                  Status