CloudSlang/cs-actions

View on GitHub

Showing 2,058 of 4,022 total issues

File ScpCopier.java has 441 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*
 * Copyright 2021-2024 Open Text
 * This program and the accompanying materials
 * are made available under the terms of the Apache License v2.0 which accompany this distribution.
 *

    File OCICreateInstanceInputs.java has 439 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    
    
    package io.cloudslang.content.oracle.oci.entities.inputs;
    
    import org.jetbrains.annotations.NotNull;

      File DBConnectionManager.java has 438 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      /*
       * Copyright 2019-2024 Open Text
       * This program and the accompanying materials
       * are made available under the terms of the Apache License v2.0 which accompany this distribution.
       *

        File CreateVMRequestBody.java has 438 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        /*
         * Copyright 2024 Open Text
         * This program and the accompanying materials
         * are made available under the terms of the Apache License v2.0 which accompany this distribution.
         *

          Method execute has 52 arguments (exceeds 4 allowed). Consider refactoring.
          Open

              public Map<String, String> execute(@Param(value = ENDPOINT) String endpoint,
                                                 @Param(value = IDENTITY, required = true) String identity,
                                                 @Param(value = CREDENTIAL, required = true, encrypted = true) String credential,
                                                 @Param(value = PROXY_HOST) String proxyHost,
                                                 @Param(value = PROXY_PORT) String proxyPort,

            Method execute has 52 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                public Map<String, String> execute(@Param(value = TENANCY_OCID, required = true, description = TENANCY_OCID_DESC) String tenancyOcid,
                                                   @Param(value = USER_OCID, required = true, description = USER_OCID_DESC) String userOcid,
                                                   @Param(value = FINGER_PRINT, encrypted = true, required = true, description = FINGER_PRINT_DESC) String fingerPrint,
                                                   @Param(value = PRIVATE_KEY_DATA, encrypted = true, description = PRIVATE_KEY_DATA_DESC) String privateKeyData,
                                                   @Param(value = PRIVATE_KEY_FILE, description = PRIVATE_KEY_FILE_DESC) String privateKeyFile,

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

                            @Param(value = PRETTY_PRINT, description = PRETTY_PRINT_DESC) prettyPrintInp: String): util.Map[String, String] = {
              
                  val asyncStr = defaultIfEmpty(asyncInp, TRUE)
                  val timeoutStr = defaultIfEmpty(timeoutInp, DEFAULT_SYNC_TIMEOUT)
                  val pollingIntervalStr = defaultIfEmpty(pollingIntervalInp, DEFAULT_POLLING_INTERVAL)

                File InstanceUtils.java has 435 lines of code (exceeds 250 allowed). Consider refactoring.
                Open

                /*
                 * Copyright 2019-2024 Open Text
                 * This program and the accompanying materials
                 * are made available under the terms of the Apache License v2.0 which accompany this distribution.
                 *

                  File SendMailInput.java has 432 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  /*
                   * Copyright 2021-2024 Open Text
                   * This program and the accompanying materials
                   * are made available under the terms of the Apache License v2.0 which accompany this distribution.
                   *

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

                    public class HttpClientInputs {
                        private final String host;
                        private final String authType;
                        private final String preemptiveAuth;
                        private final String username;

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

                          public static class HttpClientInputsBuilder {
                              private String host = EMPTY;
                              private String authType = EMPTY;
                              private String preemptiveAuth = EMPTY;
                              private String username = EMPTY;

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

                            public void cleanDataSources() {
                        
                                Hashtable<String, List<String>> removedDsKeyTable = null;
                        
                                //gather all the empty ds's key, can't remove item while iterate

                        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 execute has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
                        Open

                            public Map<String, String> execute(SendMailInput sendMailInput) throws Exception {
                                Map<String, String> result = new HashMap<>();
                                Transport transport = null;
                                try {
                                    this.input = sendMailInput;

                        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 wait has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
                        Open

                            public Object[] wait(ManagedObjectReference objMor, String[] filterProps, String[] endWaitProps, Object[][] expectedValues)
                                    throws InvalidPropertyFaultMsg, RuntimeFaultFaultMsg, InvalidCollectorVersionFaultMsg {
                        
                                String version = Constants.EMPTY;
                                String stateVal = null;

                        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

                        Builder has 45 methods (exceeds 20 allowed). Consider refactoring.
                        Open

                            public static class Builder {
                                private String instanceId;
                                private String imageId;
                                private String identityId;
                                private String volumeId;

                          FSUtil has 45 methods (exceeds 20 allowed). Consider refactoring.
                          Open

                          public class FSUtil {
                              static final String CLASS_FILE_SUFFIX = ".class";
                              static final int BUFFER_SIZE = 16384; // 16 * 1024
                          
                              /**

                            Method execute has 49 arguments (exceeds 4 allowed). Consider refactoring.
                            Open

                                        @Param(value = HttpClientInputs.URL, required = true) String url,
                                        @Param(HttpClientInputs.TLS_VERSION) String tlsVersion,
                                        @Param(HttpClientInputs.ALLOWED_CYPHERS) String allowedCyphers,
                                        @Param(HttpClientInputs.AUTH_TYPE) String authType,
                                        @Param(HttpClientInputs.PREEMPTIVE_AUTH) String preemptiveAuth,

                              Method getWorkspaceVariablesOperationOutput has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.
                              Open

                                  @NotNull
                                  public static Map<String, String> getWorkspaceVariablesOperationOutput(String workspaceVariablesJson, String sensitiveWorkspaceVariablesJson, Map<String, Map<String, String>> result) {
                                      try {
                                          final Map<String, String> results = new HashMap<>();
                                          JSONParser parser = new JSONParser();

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

                                  @NotNull
                                  public static Map<String, Map<String, String>> updateWorkspaceVariables(@NotNull TerraformWorkspaceVariableInputs terraformWorkspaceVariableInputs) throws Exception {
                                      String workspaceVariableName;
                                      String workspaceVariableValue;
                                      String sensitiveWorkspaceVariableValue;

                                Method execute has 48 arguments (exceeds 4 allowed). Consider refactoring.
                                Open

                                    public Map<String, String> execute(@Param(value = ENDPOINT) String endpoint,
                                                                       @Param(value = IDENTITY, required = true) String identity,
                                                                       @Param(value = CREDENTIAL, required = true, encrypted = true) String credential,
                                                                       @Param(value = PROXY_HOST) String proxyHost,
                                                                       @Param(value = PROXY_PORT) String proxyPort,
                                  Severity
                                  Category
                                  Status
                                  Source
                                  Language