Sign upLogin

Bnei-Baruch/mdb

View on GitHub
Star
importer/kmedia/congresses.go

Summary

Maintainability
F
3 days
Test Coverage

Function importNewCongresses has a Cognitive Complexity of 37 (exceeds 20 allowed). Consider refactoring.
Open

func importNewCongresses(congresses map[int]*Congress) error {
    tx, err := mdb.Begin()
    if err != nil {
        return errors.Wrap(err, "Start transaction")
    }
Severity: Minor
Found in importer/kmedia/congresses.go - About 3 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 congresses.go has 518 lines of code (exceeds 500 allowed). Consider refactoring.
Open

package kmedia

import (
    "database/sql"
    "fmt"
Severity: Minor
Found in importer/kmedia/congresses.go - About 2 hrs to fix

    Function analyzeExisting has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.
    Open

    func analyzeExisting(congresses map[int]*Congress) error {
    fExists, err := ioutil.TempFile("/tmp", "congress_units_exists")
    if err != nil {
        return errors.Wrap(err, "Create temp file: fExists")
    }
    Severity: Minor
    Found in importer/kmedia/congresses.go - 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 doNewUnit has 81 lines of code (exceeds 50 allowed). Consider refactoring.
    Open

    func doNewUnit(exec boil.Executor, h map[string]int, x []string) error {
    // input validation
    ct := x[h["content_type"]]
    if ct == "" {
        log.Infof("Empty content_type, skipping %s", x)
    Severity: Major
    Found in importer/kmedia/congresses.go - About 2 hrs to fix

      Function importNewCongresses has 66 lines of code (exceeds 50 allowed). Consider refactoring.
      Open

      func importNewCongresses(congresses map[int]*Congress) error {
    tx, err := mdb.Begin()
    if err != nil {
        return errors.Wrap(err, "Start transaction")
    }
      Severity: Minor
      Found in importer/kmedia/congresses.go - About 1 hr to fix

        Function doExistingUnit has 61 lines of code (exceeds 50 allowed). Consider refactoring.
        Open

        func doExistingUnit(exec boil.Executor, h map[string]int, x []string) error {
    unitID := x[h["unit.id"]]
    cuID, err := strconv.Atoi(unitID)
    if err != nil {
        return errors.Wrapf(err, "bad unit.id %s", unitID)
        Severity: Minor
        Found in importer/kmedia/congresses.go - About 1 hr to fix

          Function doNewUnit has 13 return statements (exceeds 4 allowed).
          Open

          func doNewUnit(exec boil.Executor, h map[string]int, x []string) error {
    // input validation
    ct := x[h["content_type"]]
    if ct == "" {
        log.Infof("Empty content_type, skipping %s", x)
          Severity: Major
          Found in importer/kmedia/congresses.go - About 1 hr to fix

            Function doExistingUnit has 12 return statements (exceeds 4 allowed).
            Open

            func doExistingUnit(exec boil.Executor, h map[string]int, x []string) error {
    unitID := x[h["unit.id"]]
    cuID, err := strconv.Atoi(unitID)
    if err != nil {
        return errors.Wrapf(err, "bad unit.id %s", unitID)
            Severity: Major
            Found in importer/kmedia/congresses.go - About 1 hr to fix

              Function initCongresses has 51 lines of code (exceeds 50 allowed). Consider refactoring.
              Open

              func initCongresses() (map[int]*Congress, error) {
    // Read mappings file
    records, err := utils.ReadCSV(CONGRESSES_FILE)
    if err != nil {
        return nil, errors.Wrap(err, "Read congresses")
              Severity: Minor
              Found in importer/kmedia/congresses.go - About 1 hr to fix

                Function analyzeExisting has 51 lines of code (exceeds 50 allowed). Consider refactoring.
                Open

                func analyzeExisting(congresses map[int]*Congress) error {
    fExists, err := ioutil.TempFile("/tmp", "congress_units_exists")
    if err != nil {
        return errors.Wrap(err, "Create temp file: fExists")
    }
                Severity: Minor
                Found in importer/kmedia/congresses.go - About 1 hr to fix

                  Function initCongresses has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
                  Open

                  func initCongresses() (map[int]*Congress, error) {
    // Read mappings file
    records, err := utils.ReadCSV(CONGRESSES_FILE)
    if err != nil {
        return nil, errors.Wrap(err, "Read congresses")
                  Severity: Minor
                  Found in importer/kmedia/congresses.go - About 55 mins 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 importNewCongresses has 7 return statements (exceeds 4 allowed).
                  Open

                  func importNewCongresses(congresses map[int]*Congress) error {
    tx, err := mdb.Begin()
    if err != nil {
        return errors.Wrap(err, "Start transaction")
    }
                  Severity: Major
                  Found in importer/kmedia/congresses.go - About 45 mins to fix

                    Function initCongresses has 7 return statements (exceeds 4 allowed).
                    Open

                    func initCongresses() (map[int]*Congress, error) {
    // Read mappings file
    records, err := utils.ReadCSV(CONGRESSES_FILE)
    if err != nil {
        return nil, errors.Wrap(err, "Read congresses")
                    Severity: Major
                    Found in importer/kmedia/congresses.go - About 45 mins to fix

                      Function doNewUnit has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.
                      Open

                      func doNewUnit(exec boil.Executor, h map[string]int, x []string) error {
    // input validation
    ct := x[h["content_type"]]
    if ct == "" {
        log.Infof("Empty content_type, skipping %s", x)
                      Severity: Minor
                      Found in importer/kmedia/congresses.go - About 45 mins 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 analyzeExisting has 6 return statements (exceeds 4 allowed).
                      Open

                      func analyzeExisting(congresses map[int]*Congress) error {
    fExists, err := ioutil.TempFile("/tmp", "congress_units_exists")
    if err != nil {
        return errors.Wrap(err, "Create temp file: fExists")
    }
                      Severity: Major
                      Found in importer/kmedia/congresses.go - About 40 mins to fix

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

                        func importNewUnits() error {
    // Read mappings file
    records, err := utils.ReadCSV(NEW_UNITS_FILE)
    if err != nil {
        return errors.Wrap(err, "Read NEW_UNITS_FILE")
                        Severity: Major
                        Found in importer/kmedia/congresses.go and 1 other location - About 3 hrs to fix
                        importer/kmedia/congresses.go on lines 554..586

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 269.

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

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

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

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

                        Refactorings

                        Further Reading

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

                        func importExistingUnits() error {
    // Read mappings file
    records, err := utils.ReadCSV(EXISTING_UNITS_FILE)
    if err != nil {
        return errors.Wrap(err, "Read EXISTING_UNITS_FILE")
                        Severity: Major
                        Found in importer/kmedia/congresses.go and 1 other location - About 3 hrs to fix
                        importer/kmedia/congresses.go on lines 419..451

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 269.

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

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

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

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

                        Refactorings

                        Further Reading

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

                            for _, fileAsset := range container.R.FileAssets {
        log.Infof("Processing file_asset %d", fileAsset.ID)
        stats.FileAssetsProcessed.Inc(1)

        // Create or update MDB file
                        Severity: Major
                        Found in importer/kmedia/congresses.go and 3 other locations - About 50 mins to fix
                        importer/kmedia/common.go on lines 196..210
                        importer/kmedia/programs.go on lines 153..167
                        importer/kmedia/virtual_lessons.go on lines 134..148

                        Duplicated Code

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

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

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

                        Tuning

                        This issue has a mass of 120.

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

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

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

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

                        Refactorings

                        Further Reading

                        There are no issues that match your filters.

                        Category
                        Status