Sign upLogin

SiLeBAT/FSK-Lab

View on GitHub
Star

Showing 6,856 of 14,752 total issues

File app.table.js has 437 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*

version: 1.0.0
author: sascha obermüller
date: 07.12.2020
Severity: Minor
Found in de.bund.bfr.knime.js/src/js/app/app.table.js - About 6 hrs to fix

Function 4 has 162 lines of code (exceeds 25 allowed). Consider refactoring.
Open

},{"./fractions":4,"./helper":5}],4:[function(require,module,exports){
var isInt = require('./helper').isInt;
var gcd = require('./helper').gcd;
var lcm = require('./helper').lcm;
Severity: Major
Found in de.bund.bfr.knime.pmm.nodes/js-src/de/bund/bfr/knime/pmm/js/modelplotter/algebra-0.2.6.min.js - About 6 hrs to fix

Function generate_dependencies has 162 lines of code (exceeds 25 allowed). Consider refactoring.
Open

module.exports = function generate_dependencies(it, $keyword, $ruleType) {
  var out = ' ';
  var $lvl = it.level;
  var $dataLvl = it.dataLevel;
  var $schema = it.schema[$keyword];
Severity: Major
Found in de.bund.bfr.knime.fsklab.deprecatednodes/js-src/de/bund/bfr/knime/fsklab/nodes/joiner/emfbundle/ajv.min.js - About 6 hrs to fix

Method stepNew has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.
Open

    private PmmTimeSeries stepNew(BufferedReader reader) throws IOException {
        // initialize next time series
        PmmTimeSeries next = new PmmTimeSeries();

        while (true) {
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/combaseio/lib/CombaseReader.java - 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

Method loadDBNew has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.
Open

    private MainFrame loadDBNew(MyDBI myDBi, String dbPath, Boolean autoUpdate, boolean openTheGui, boolean beInteractive) {
        MainFrame mf = null;
        MyDBTable myDB = null;
        boolean doUpdates = false;
        try {
Severity: Minor
Found in org.hsh.bfr.db/src/org/hsh/bfr/db/gui/Login.java - 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

File SettingsHelperTest.java has 434 lines of code (exceeds 250 allowed). Consider refactoring.
Open

package de.bund.bfr.knime.pmm.predictorview;

import static org.junit.Assert.*;

import java.awt.Color;
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes.tests/src/de/bund/bfr/knime/pmm/predictorview/SettingsHelperTest.java - About 6 hrs to fix

Method doImportNewFormat has 160 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    private int[] doImportNewFormat(HSSFWorkbook wb, JProgressBar progress) {
        int numSuccess = 0;
        int numFails = 0;
        HSSFSheet transactionSheet = wb.getSheet("NewTransactions");
        HSSFSheet businessSheet = wb.getSheet("Business_List");
Severity: Major
Found in org.hsh.bfr.db/src/org/hsh/bfr/db/imports/custom/LieferkettenImporterEFSA.java - About 6 hrs to fix

Hazard has 46 methods (exceeds 20 allowed). Consider refactoring.
Open

@javax.annotation.Generated(value = "io.swagger.codegen.languages.JavaClientCodegen", date = "2019-07-02T16:22:48.194+02:00")
public class Hazard {
  @SerializedName("type")
  private String type = null;
Severity: Minor
Found in de.bund.bfr.knime.fsklab.metadata.model/gen/de/bund/bfr/metadata/swagger/Hazard.java - About 6 hrs to fix

Method setValueAt has 157 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

      String stringValue = (String) aValue;
Severity: Major
Found in de.bund.bfr.knime.fsklab.nodes.common/src/de/bund/bfr/knime/fsklab/nodes/common/ui/MetaDataPane.java - About 6 hrs to fix

Method getEditor has 157 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    public static JEditorPane getEditor(PCMLPortObjectSpec spec) {
        JEditorPane editor = new JEditorPane("text/html", "");
        editor.setEditable(false);
        
        StringBuilder buffer = new StringBuilder();
Severity: Major
Found in de.bund.bfr.knime.foodprocess.pcml/src/de/bund/bfr/knime/pcml/port/PCMLPortObjectSpecView.java - About 6 hrs to fix

Function _createFormField has 157 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    _createFormField ( param ) {
        let O = this;
        _log( 'PANEL SIM / _createFormField' );
        _log( param );
Severity: Major
Found in de.bund.bfr.knime.js/src/js/app/app.simulation.js - About 6 hrs to fix

Function initRow has 157 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    BootstrapTable.prototype.initRow = function(item, i, data, parentDom) {
        var that=this,
            key,
            html = [],
            style = {},
Severity: Major
Found in de.bund.bfr.knime.pmm.nodes/js-lib/bootstrap-table/1_11_1/debug/js/bootstrap-table.js - About 6 hrs to fix

File SettingsHelper.java has 428 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*******************************************************************************
 * Copyright (c) 2015 Federal Institute for Risk Assessment (BfR), Germany
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/secondarymodelanddataview/SettingsHelper.java - About 6 hrs to fix

Method getNumDBSuccesses has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
Open

    private int getNumDBSuccesses(boolean conform, int level, String dbuuid, DataRow row, DataTableSpec outSpec,
            Connection conn) {
        int numDBSuccesses = 0;
        if (conform && (nodeSettings.deletePrimaryModels && level == 1
                || nodeSettings.deleteSecondaryModels && level == 2)) {
Severity: Minor
Found in de.bund.bfr.knime.pmm.nodes/src/de/bund/bfr/knime/pmm/dbdelete/DatabaseDeleteNodeModel.java - 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

Method dbBackup has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
Open

    private static void dbBackup(final JFrame frame, final File backupFile, final boolean silent) {
        if (backupFile != null && backupFile.getParentFile().exists() && DBKernel.DBFilesDa(DBKernel.HSHDB_PATH, DBKernel.dbKennung)) {
            try {
                if (backupFile.exists()) {
                    backupFile.delete();
Severity: Minor
Found in org.hsh.bfr.db/src/org/hsh/bfr/db/Backup.java - 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

Method getFunctionSamplePoints has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
Open

    public double[][] getFunctionSamplePoints(String paramX, String paramY,
            String unitX, String unitY, String transformX, String transformY,
            double minX, double maxX, double minY, double maxY,
            Map<String, Integer> choice, List<String> warnings)
            throws ConvertException {
Severity: Minor
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/chart/Plotable.java - 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

Method convertArrays2MiscXmlDoc has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
Open

    public static PmmXmlDoc convertArrays2MiscXmlDoc(Array id, Array param, Array desc, Array value, Array unit, String dbuuid) {
        PmmXmlDoc miscDoc = new PmmXmlDoc();
        if (id != null) {
            try {
                Object[] sid = (Object[])id.getArray();
Severity: Minor
Found in de.bund.bfr.knime.pmm.common/src/de/bund/bfr/knime/pmm/common/DbIo.java - 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 _validateSimField has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
Open

    _validateSimField ( field ) {
        let O = this;
        _log( 'PANEL SIM / _validateSimField' );
        _log( field );
Severity: Minor
Found in de.bund.bfr.knime.js/src/js/app/app.simulation.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

Method setUp has 156 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    @BeforeClass
    public static void setUp() {
        MAPPER = EMFModule.setupDefaultMapper().registerModule(new ThreeTenModule())
                .registerModule(new EmfMetadataModule());
Severity: Major
Found in de.bund.bfr.knime.fsklab.metadata.model.tests/src/metadata/EmfMetadataModuleTest.java - About 6 hrs to fix

Function size has 156 lines of code (exceeds 25 allowed). Consider refactoring.
Open

var effectSize = $.effects.effect.size = function( o, done ) {

    // Create element
    var original, baseline, factor,
        el = $( this ),
Severity: Major
Found in de.bund.bfr.knime.pmm.nodes/js-src/de/bund/bfr/knime/pmm/js/modelplotter/jquery-ui.js - About 6 hrs to fix
Severity
Category
Status
Source
Language