CloudSlang/cs-actions

View on GitHub

Showing 3,994 of 4,023 total issues

Method verifyCommonUserInputs has 8 arguments (exceeds 4 allowed). Consider refactoring.
Open

    public static List<String> verifyCommonUserInputs(@Nullable final String proxyPort,
                                                      @Nullable final String trustAllRoots,
                                                      @Nullable final String x509HostnameVerifier,
                                                      @Nullable final String connectTimeout,
                                                      @Nullable final String socketTimeout,

    Method verifyCommonInputs has 8 arguments (exceeds 4 allowed). Consider refactoring.
    Open

        public static List<String> verifyCommonInputs(@Nullable final String privateKeyData,
                                                      @Nullable final String privateKeyFile,
                                                      @Nullable final String proxyPort,
                                                      @Nullable final String connectTimeout,
                                                      @Nullable final String socketTimeout,

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

        def execute(@Param(value = ACCESS_TOKEN, required = true, encrypted = true, description = ACCESS_TOKEN_DESC) accessToken: String,
                    @Param(value = BUCKET_NAME, required = true, description = BUCKET_NAME_DESC) bucketName: String,
                    @Param(value = METAGENERATION_MATCH, description = METAGENERATION_MATCH_DESC) metagenerationMatch: String,
                    @Param(value = METAGENERATION_NOT_MATCH, description = METAGENERATION_NOT_MATCH_DESC) metagenerationNotMatch: String,
                    @Param(value = PROXY_HOST, description = PROXY_HOST_DESC) proxyHost: String,

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

          def execute(@Param(value = PROJECT_ID, required = true, encrypted = true, description = PROJECT_ID_DESC) projectId: String,
                      @Param(value = ACCESS_TOKEN, required = true, encrypted = true, description = ACCESS_TOKEN_DESC) accessToken: String,
                      @Param(value = FILTER, description = FILTER_DESC) filter: String,
                      @Param(value = PROXY_HOST, description = PROXY_HOST_DESC) proxyHost: String,
                      @Param(value = PROXY_PORT, description = PROXY_PORT_DESC) proxyPort: String,

          Method createAttachedDisk has 8 arguments (exceeds 4 allowed). Consider refactoring.
          Open

            def createAttachedDisk(boot: Boolean,
                                   autoDelete: Boolean,
                                   mountMode: String,
                                   sourceOpt: Option[String] = None,
                                   deviceNameOpt: Option[String] = None,

            Method getSerialPortOutput has 8 arguments (exceeds 4 allowed). Consider refactoring.
            Open

              def getSerialPortOutput(httpTransport: HttpTransport, jsonFactory: JsonFactory, credential: Credential, project: String,
                                      zone: String, instanceName: String, port: Int, start: Long): SerialPortOutput =

              Method delete has 8 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                def delete(httpTransport: HttpTransport, jsonFactory: JsonFactory, credential: Credential, project: String, networkName: String,
                           async: Boolean, timeout: Long, pollingInterval: Long): Operation = {

                Method list has 8 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                  def list(httpTransport: HttpTransport, jsonFactory: JsonFactory, credential: Credential, projectId: String, maxResults: String, prefix: String, pageToken: String, projection: String): Buckets = {

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

                    def execute(@Param(value = PROJECT_ID, required = true, encrypted = true, description = PROJECT_ID_DESC) projectId: String,
                                @Param(value = ACCESS_TOKEN, required = true, encrypted = true, description = ACCESS_TOKEN_DESC) accessToken: String,
                                @Param(value = INSTANCE_ID, required = true, description = INSTANCE_ID_DESC) instanceId: String,
                                @Param(value = PROXY_HOST) proxyHost: String,
                                @Param(value = PROXY_PORT) proxyPort: String,

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

                      def execute(@Param(value = JSON_TOKEN, required = true, encrypted = true) jsonToken: String,
                                  @Param(value = SCOPES, required = true) scopes: String,
                                  @Param(value = SCOPES_DELIMITER) scopesDelInp: String,
                                  @Param(value = TIMEOUT) timeoutInp: String,
                                  @Param(value = PROXY_HOST) proxyHost: String,

                      Method insert has 8 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                        def insert(httpTransport: HttpTransport, jsonFactory: JsonFactory, credential: Credential, project: String, network: Network,
                                   async: Boolean, timeout: Long, pollingInterval: Long): Operation = {

                        Method updateBucket has 8 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                          def updateBucket(storageClass: String, defaultEventBasedHold: String, versioningEnabled: String,
                                           accessControl: String, retentionPeriodType: String, retentionPeriod: String,
                                           removeRetentionPolicy: String, labels: java.util.Map[String, String]): Bucket = {

                          Method delete has 8 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                            def delete(httpTransport: HttpTransport, jsonFactory: JsonFactory, credential: Credential,
                                       projectId: String, databaseInstanceId: String, async: Boolean, timeout: Long,
                                       pollingInterval: Long): Operation = {

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

                              def execute(@Param(value = PROJECT_ID, required = true) projectId: String,
                                          @Param(value = NETWORK_NAME, required = true) networkName: String,
                                          @Param(value = ACCESS_TOKEN, required = true, encrypted = true) accessToken: String,
                                          @Param(value = PROXY_HOST) proxyHost: String,
                                          @Param(value = PROXY_PORT) proxyPortInp: String,

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

                                def execute(@Param(value = PROJECT_ID, required = true) projectId: String,
                                            @Param(value = GLOBAL_OPERATION_NAME, required = true) globalOperationName: String,
                                            @Param(value = ACCESS_TOKEN, required = true, encrypted = true) accessToken: String,
                                            @Param(value = PROXY_HOST) proxyHost: String,
                                            @Param(value = PROXY_PORT) proxyPortInp: String,

                                Identical blocks of code found in 3 locations. Consider refactoring.
                                Open

                                        if (StringUtils.isEmpty(statusCode) || Integer.parseInt(statusCode) < 200 || Integer.parseInt(statusCode) >= 300) {
                                            if (StringUtils.isEmpty(httpResults.get(EXCEPTION)))
                                                httpResults.put(EXCEPTION, httpResults.get(RETURN_RESULT));
                                            httpResults.put(RETURN_CODE, NEGATIVE_RETURN_CODE);
                                        }
                                cs-openshift/src/main/java/io/cloudslang/content/redhat/services/OpenshiftService.java on lines 46..50
                                cs-openshift/src/main/java/io/cloudslang/content/redhat/services/OpenshiftService.java on lines 91..95

                                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 70.

                                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

                                Identical blocks of code found in 3 locations. Consider refactoring.
                                Open

                                            if (StringUtils.isEmpty(statusCode) || Integer.parseInt(statusCode) < 200 || Integer.parseInt(statusCode) >= 300) {
                                                if (StringUtils.isEmpty(httpResults.get(EXCEPTION)))
                                                    httpResults.put(EXCEPTION, httpResults.get(RETURN_RESULT));
                                                httpResults.put(RETURN_CODE, NEGATIVE_RETURN_CODE);
                                            }
                                cs-openshift/src/main/java/io/cloudslang/content/redhat/services/OpenshiftService.java on lines 46..50
                                cs-openshift/src/main/java/io/cloudslang/content/redhat/services/OpenshiftService.java on lines 108..112

                                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 70.

                                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

                                Identical blocks of code found in 3 locations. Consider refactoring.
                                Open

                                            if (StringUtils.isEmpty(statusCode) || Integer.parseInt(statusCode) < 200 || Integer.parseInt(statusCode) >= 300) {
                                                if (StringUtils.isEmpty(httpResults.get(EXCEPTION)))
                                                    httpResults.put(EXCEPTION, httpResults.get(RETURN_RESULT));
                                                httpResults.put(RETURN_CODE, NEGATIVE_RETURN_CODE);
                                            }
                                cs-openshift/src/main/java/io/cloudslang/content/redhat/services/OpenshiftService.java on lines 91..95
                                cs-openshift/src/main/java/io/cloudslang/content/redhat/services/OpenshiftService.java on lines 108..112

                                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 70.

                                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 5 locations. Consider refactoring.
                                Open

                                            .commonInputs(TerraformCommonInputs.builder()
                                                    .authToken("")
                                                    .requestBody("")
                                                    .proxyHost("")
                                                    .proxyPort("")
                                cs-hashicorp-terraform/src/test/java/io/cloudslang/content/hashicorp/terraform/services/ListOAuthClientImplTest.java on lines 19..36
                                cs-hashicorp-terraform/src/test/java/io/cloudslang/content/hashicorp/terraform/services/RunImplTest.java on lines 42..59
                                cs-hashicorp-terraform/src/test/java/io/cloudslang/content/hashicorp/terraform/services/RunImplTest.java on lines 63..80
                                cs-hashicorp-terraform/src/test/java/io/cloudslang/content/hashicorp/terraform/services/VariableImplTest.java on lines 38..55

                                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 70.

                                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 5 locations. Consider refactoring.
                                Open

                                    @NotNull
                                    public static List<String> verifySqlScript(@NotNull final String walletPath,
                                                                               @NotNull final String trustore,
                                                                               @NotNull final String keystore,
                                                                               @NotNull final String overwrite,
                                cs-excel/src/main/java/io/cloudslang/content/excel/utils/InputsValidation.java on lines 55..70
                                cs-excel/src/main/java/io/cloudslang/content/excel/utils/InputsValidation.java on lines 117..132
                                cs-oracle-cloud-databases/src/main/java/io/cloudslang/content/database/utils/InputsValidation.java on lines 46..63
                                cs-sharepoint/src/main/java/io/cloudslang/content/sharepoint/utils/InputsValidation.java on lines 61..74

                                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 70.

                                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

                                Severity
                                Category
                                Status
                                Source
                                Language