Showing 3,994 of 4,023 total issues
Method setConnectionParameters
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
public static void setConnectionParameters(HttpClientInputs httpClientInputs,
@NotNull final String connectTimeout,
@NotNull final String socketTimeout,
@NotNull final String keepAlive,
@NotNull final String connectionsMaxPerRoot,
Method verifyAuthorizationInputs
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
public static List<String> verifyAuthorizationInputs(@Nullable final String loginType,
@Nullable final String clientId,
@Nullable final String clientSecret,
@Nullable final String username,
@Nullable final String password,
Method execute
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
@Action(name = GET_VNIC_DETAILS_OPERATION_NAME,
description = GET_VNIC_DETAILS_OPERATION_DESC,
outputs = {
@Output(value = RETURN_RESULT, description = RETURN_RESULT_DESC),
@Output(value = EXCEPTION, description = EXCEPTION_DESC),
- Read upRead up
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 processHostDeleteFolder
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
public static String processHostDeleteFolder(List<String> ids, String folderName) throws Utils.HostException {
boolean found = false;
for(String id:ids){
if(!id.isEmpty()){
- Read upRead up
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 8 (exceeds 5 allowed). Consider refactoring. Open
@Action(name = "Get site name by id",
outputs = {
@Output(value = RETURN_RESULT, description = RETURN_RESULT_DESC),
@Output(value = RETURN_CODE, description = RETURN_CODE_DESC),
@Output(value = SITE_NAME, description = SITE_NAME_DESC),
- Read upRead up
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 6 arguments (exceeds 4 allowed). Consider refactoring. Open
public Map<String, String> execute(@Param(value = Constants.InputNames.JSON_OBJECT, required = true) String jsonObject,
@Param(value = Constants.InputNames.JSON_PATH, required = true) String jsonPath,
@Param(value = Constants.InputNames.ACTION, required = true) String action,
@Param(value = Constants.InputNames.NAME) String name,
@Param(value = Constants.InputNames.VALUE) String value,
Method verifyAuthorizationInputs
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
public static List<String> verifyAuthorizationInputs(@Nullable final String loginType, @Nullable final String clientId, @Nullable final String clientSecret, @Nullable final String username, @Nullable final String password, @NotNull final String proxyPort) {
Method execute
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
@Action(name = "Get site id by name",
outputs = {
@Output(value = RETURN_RESULT, description = RETURN_RESULT_DESC),
@Output(value = RETURN_CODE, description = RETURN_CODE_DESC),
@Output(value = SITE_ID, description = SITE_ID_DESC),
- Read upRead up
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 validateKey
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
public static void validateKey(String key, String pairDelimiter, String entryDelimiter, String elementWrapper, String mapStart, String mapEnd) throws ValidationException {
Avoid deeply nested control flow statements. Open
if (result != 0) {
return result;
}
Method iterateList
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
private static String iterateList(String value, String list, String delimiter, String method) {
String[] listString;
if (!StringUtils.isEmpty(delimiter)) {
listString = list.split(delimiter);
} else {
- Read upRead up
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 6 arguments (exceeds 4 allowed). Consider refactoring. Open
@Param(value = XML_DOCUMENT, required = true) String xmlDocument,
@Param(value = XML_DOCUMENT_SOURCE) String xmlDocumentSource,
@Param(value = XPATH_ELEMENT_QUERY, required = true) String xPathElementQuery,
@Param(value = ATTRIBUTE_NAME, required = true) String attributeName,
@Param(value = VALUE, required = true) String value,
Method execute
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
@Param(value = XML, required = true) String xml,
@Param(value = TEXT_ELEMENTS_NAME) String textElementsName,
@Param(value = INCLUDE_ROOT) String includeRootElement,
@Param(value = INCLUDE_ATTRIBUTES) String includeAttributes,
@Param(value = PRETTY_PRINT) String prettyPrint,
Method execute
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
@Param(value = Constants.Inputs.XML_DOCUMENT, required = true) String xmlDocument,
@Param(Constants.Inputs.XML_DOCUMENT_SOURCE) String xmlDocumentSource,
@Param(value = Constants.Inputs.XPATH_QUERY, required = true) String xPathQuery,
@Param(value = Constants.Inputs.QUERY_TYPE, required = true) String queryType,
@Param(Constants.Inputs.DELIMITER) String delimiter,
Method validateInputs
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
public static void validateInputs(EditXmlInputs inputs) throws Exception {
validateXmlAndFilePathInputs(inputs.getXml(), inputs.getFilePath());
if (Constants.Inputs.MOVE_ACTION.equals(inputs.getAction())) {
validateIsNotEmpty(inputs.getXpath2(), "xpath2 input is required for action 'move' ");
- Read upRead up
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 getUncontainedArray
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
public static String[] getUncontainedArray(String[] subArray, String[] containerArray, boolean ignoreCase) {
String[] uncontainedArray = new String[subArray.length];
int index = 0;
boolean found = false;
for (String subStr : subArray) {
- Read upRead up
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 getIndex
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
public static int getIndex(String index, int listLength) throws Exception {
index = index.toLowerCase().trim();
try {
return Integer.parseInt(index);
} catch (NumberFormatException e) {
- Read upRead up
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 validateValue
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
public static void validateValue(String value, String pairDelimiter, String entryDelimiter, String elementWrapper, String mapStart, String mapEnd) throws ValidationException {
Method execute
has 6 arguments (exceeds 4 allowed). Consider refactoring. Open
@Param(value = XML_DOCUMENT, required = true) String xmlDocument,
@Param(value = XML_DOCUMENT_SOURCE, required = true) String xmlDocumentSource,
@Param(value = XPATH_ELEMENT_QUERY, required = true) String xPathQuery,
@Param(value = ATTRIBUTE_NAME) String attributeName,
@Param(value = VALUE, required = true) String value,
Method execute
has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring. Open
@Override
public String execute(EditXmlInputs inputs) throws Exception {
Document doc = XmlUtils.createDocument(inputs.getXml(), inputs.getFilePath(), inputs.getParsingFeatures());
NodeList nodeList = XmlUtils.readNode(doc, inputs.getXpath1(), XmlUtils.getNamespaceContext(inputs.getXml(), inputs.getFilePath()));
Node node;
- Read upRead up
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"