cloudfoundry/stratos

View on GitHub

Showing 1,155 of 1,370 total issues

File helm-release-helper.service.ts has 270 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import { Injectable } from '@angular/core';
import { combineLatest, Observable } from 'rxjs';
import { filter, map } from 'rxjs/operators';

import { helmEntityCatalog } from '../../../../helm/helm-entity-catalog';

    File form.po.ts has 269 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    import { browser, by, element, promise } from 'protractor';
    import { ElementArrayFinder, ElementFinder, protractor } from 'protractor/built';
    import { Key } from 'selenium-webdriver';
    
    import { Component } from './component.po';
    Severity: Minor
    Found in src/test-e2e/po/form.po.ts - About 2 hrs to fix

      Function authReducer has 61 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      export function authReducer(state: AuthState = defaultState, action): AuthState {
        switch (action.type) {
          case LOGIN:
            return { ...state, loggingIn: true, loggedIn: false, error: false };
          case LOGIN_SUCCESS:
      Severity: Major
      Found in src/frontend/packages/store/src/reducers/auth.reducer.ts - About 2 hrs to fix

        Function parseAuth has 61 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          public parseAuth(cluster: KubeConfigFileCluster, user: KubeConfigFileUser): RowState {
        
            // Default subtype is generic Kubernetes ('') or previously determined/selected sub type
            cluster._subType = cluster._subType || '';
        
        

          Function extractArchiveFiles has a Cognitive Complexity of 21 (exceeds 8 allowed). Consider refactoring.
          Open

          func extractArchiveFiles(archivePath, chartName, downloadFolder string, filenames []string) error {
              // Map the filenames array into a map of path to destination file
              requiredFiles := make(map[string]string)
              requiredCount := len(filenames)
              for _, name := range filenames {
          Severity: Minor
          Found in src/jetstream/plugins/monocular/cache.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

          Method PgsqlTokenRepository.SaveCNSIToken has a Cognitive Complexity of 21 (exceeds 8 allowed). Consider refactoring.
          Open

          func (p *PgsqlTokenRepository) SaveCNSIToken(cnsiGUID string, userGUID string, tr interfaces.TokenRecord, encryptionKey []byte) error {
              log.Debug("SaveCNSIToken")
              if cnsiGUID == "" {
                  msg := "Unable to save CNSI Token without a valid CNSI GUID."
                  log.Debug(msg)
          Severity: Minor
          Found in src/jetstream/repository/tokens/pgsql_tokens.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

          Method CloudFoundrySpecification.cfLoginHook has a Cognitive Complexity of 21 (exceeds 8 allowed). Consider refactoring.
          Open

          func (c *CloudFoundrySpecification) cfLoginHook(context echo.Context) error {
          
              cfAPI, cfCnsi, err := c.fetchAutoRegisterEndpoint()
              // CF auto reg url missing, continue as normal
              if cfAPI == "" {
          Severity: Minor
          Found in src/jetstream/plugins/cloudfoundry/main.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 validate has a Cognitive Complexity of 21 (exceeds 8 allowed). Consider refactoring.
          Open

            private validate(endpoints: EndpointModel[], cluster: KubeConfigFileCluster, clusters: KubeConfigFileCluster[]) {
              cluster._invalid = false;
              let reset = true;
          
              const found = endpoints.find(item => item.name === cluster.name);

          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 setActive has a Cognitive Complexity of 21 (exceeds 8 allowed). Consider refactoring.
          Open

            setActive(index: number) {
              if (this.basePreviousRedirect && index < 0) {
                this.dispatchRedirect(this.basePreviousRedirect);
              }
              if (!this.canGoto(index)) {

          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 getColors has a Cognitive Complexity of 21 (exceeds 8 allowed). Consider refactoring.
          Open

            private getColors(total: number, used: number) {
              const percentage = (used / total) * 100;
              // I'm sure this can be tidies up - NJ
              if (this.thresholds) {
                if (this.thresholds.hasOwnProperty('danger')) {

          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 ngOnInit has 60 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            ngOnInit() {
              if (this.setUsernames) {
                this.blocked.next(false);
              } else {
                this.cfRolesService.loading$.subscribe(loading => this.blocked.next(loading));

            Function ngOnInit has 60 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              ngOnInit() {
                this.sourceType$ = this.store.select(selectSourceType);
            
                // Set previously supplied docker values
                this.subs.push(this.store.select(selectDeployAppState).pipe(

              Method CFHosting.Init has 84 lines of code (exceeds 50 allowed). Consider refactoring.
              Open

              func (ch *CFHosting) Init() error {
              
                  // Determine if we are running CF by presence of env var "VCAP_APPLICATION" and configure appropriately
                  if ch.portalProxy.Env().IsSet(VCapApplication) {
                      log.Info("Detected that Console is deployed as a Cloud Foundry Application")
              Severity: Major
              Found in src/jetstream/plugins/cloudfoundryhosting/main.go - About 2 hrs to fix

                Method PgsqlTokenRepository.findCNSIToken has 84 lines of code (exceeds 50 allowed). Consider refactoring.
                Open

                func (p *PgsqlTokenRepository) findCNSIToken(cnsiGUID string, userGUID string, encryptionKey []byte, includeDisconnected bool) (interfaces.TokenRecord, error) {
                    log.Debug("findCNSIToken")
                    if cnsiGUID == "" {
                        msg := "Unable to find CNSI Token without a valid CNSI GUID."
                        log.Debug(msg)
                Severity: Major
                Found in src/jetstream/repository/tokens/pgsql_tokens.go - About 2 hrs to fix

                  File edit-autoscaler-policy-step4.component.ts has 264 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  import { Component, OnInit } from '@angular/core';
                  import { AbstractControl, FormBuilder, FormGroup, ValidatorFn, Validators } from '@angular/forms';
                  import { ErrorStateMatcher, ShowOnDirtyErrorStateMatcher } from '@angular/material/core';
                  import { ActivatedRoute } from '@angular/router';
                  import { Store } from '@ngrx/store';

                    CfUserService has 22 functions (exceeds 20 allowed). Consider refactoring.
                    Open

                    @Injectable()
                    export class CfUserService {
                      private allUsers$: Observable<PaginationObservables<APIResource<CfUser>>>;
                    
                      users: { [guid: string]: Observable<APIResource<CfUser>>; } = {};

                      Method portalProxy.getInfo has 83 lines of code (exceeds 50 allowed). Consider refactoring.
                      Open

                      func (p *portalProxy) getInfo(c echo.Context) (*interfaces.Info, error) {
                          // get the version
                          versions, err := p.getVersionsData()
                          if err != nil {
                              return nil, errors.New("Could not find database version")
                      Severity: Major
                      Found in src/jetstream/info.go - About 2 hrs to fix

                        File application-tabs-base.component.ts has 262 lines of code (exceeds 250 allowed). Consider refactoring.
                        Open

                        import { Component, NgZone, OnDestroy, OnInit } from '@angular/core';
                        import { Store } from '@ngrx/store';
                        import { GitSCMService, GitSCMType } from '@stratosui/git';
                        import { combineLatest as observableCombineLatest, Observable, Subscription } from 'rxjs';
                        import { filter, first, map, startWith, switchMap, withLatestFrom } from 'rxjs/operators';

                          Method Analyzer.doRun has 82 lines of code (exceeds 50 allowed). Consider refactoring.
                          Open

                          func (a *Analyzer) doRun(ec echo.Context) error {
                          
                              log.Debug("Run analyzer!")
                          
                              engine := ec.Param("analyzer")
                          Severity: Major
                          Found in src/jetstream/plugins/analysis/container/run.go - About 2 hrs to fix

                            Function constructor has 57 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                              constructor(
                                public endpointsService: EndpointsService,
                                private store: Store<AppState>,
                                public userFavoriteManager: UserFavoriteManager,
                                private scrollDispatcher: ScrollDispatcher,
                              Severity
                              Category
                              Status
                              Source
                              Language