The following document contains the results of PMD 6.13.0.
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strLabel' doesn't match '[a-z][a-zA-Z0-9]*' | 45 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strLabel' doesn't match '[a-z][a-zA-Z0-9]*' | 46 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_formQuestionEntryResponseDAO' doesn't match '[A-Z][A-Z_0-9]*' | 73 |
| Rule | Violation | Line |
|---|---|---|
| FormalParameterNamingConventions | The method parameter name '_plugin' doesn't match '[a-z][a-zA-Z0-9]*' | 106 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strLabel' doesn't match '[a-z][a-zA-Z0-9]*' | 41 |
| Rule | Violation | Line |
|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 39–173 |
| Rule | Violation | Line |
|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 42–108 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_nColumnToSortPosition' doesn't match '[a-z][a-zA-Z0-9]*' | 42 |
| FieldNamingConventions | The final field name '_strSortAttributeName' doesn't match '[a-z][a-zA-Z0-9]*' | 43 |
| FieldNamingConventions | The final field name '_bAscSort' doesn't match '[a-z][a-zA-Z0-9]*' | 44 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listFormColumnCell' doesn't match '[a-z][a-zA-Z0-9]*' | 48 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'LuceneQueryBuilder' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 49–96 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strSortKey' doesn't match '[a-z][a-zA-Z0-9]*' | 53 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_nPosition' doesn't match '[a-z][a-zA-Z0-9]*' | 48 |
| FieldNamingConventions | The final field name '_strFormFilterLabel' doesn't match '[a-z][a-zA-Z0-9]*' | 49 |
| FieldNamingConventions | The final field name '_strFormFilterName' doesn't match '[a-z][a-zA-Z0-9]*' | 50 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_formColumn' doesn't match '[a-z][a-zA-Z0-9]*' | 48 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_formListDAO' doesn't match '[a-z][a-zA-Z0-9]*' | 55 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listFormPanelConfiguration' doesn't match '[a-z][a-zA-Z0-9]*' | 50 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_nPosition' doesn't match '[a-z][a-zA-Z0-9]*' | 48 |
| FieldNamingConventions | The final field name '_strTechnicalCode' doesn't match '[a-z][a-zA-Z0-9]*' | 49 |
| FieldNamingConventions | The final field name '_strTitle' doesn't match '[a-z][a-zA-Z0-9]*' | 50 |
| FieldNamingConventions | The final field name '_listFormPanelInitializerName' doesn't match '[a-z][a-zA-Z0-9]*' | 51 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'FormPanelInitializerQueryBuilder' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 47–83 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The field name 'strIdComponent' doesn't match '_[a-z][a-zA-Z0-9]*' | 54 |
| FormalParameterNamingConventions | The method parameter name 'user_id' doesn't match '[a-z][a-zA-Z0-9]*' | 75 |
| FormalParameterNamingConventions | The method parameter name 'published_questions_only' doesn't match '[a-z][a-zA-Z0-9]*' | 89 |
| FormalParameterNamingConventions | The method parameter name 'published_formresponse_only' doesn't match '[a-z][a-zA-Z0-9]*' | 89 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_formPanel' doesn't match '[a-z][a-zA-Z0-9]*' | 67 |
| FieldNamingConventions | The final field name '_listFormColumn' doesn't match '[a-z][a-zA-Z0-9]*' | 68 |
| FieldNamingConventions | The final field name '_listFormFilter' doesn't match '[a-z][a-zA-Z0-9]*' | 69 |
| FieldNamingConventions | The final field name '_sortConfig' doesn't match '[a-z][a-zA-Z0-9]*' | 70 |
| FieldNamingConventions | The final field name '_fileName' doesn't match '[a-z][a-zA-Z0-9]*' | 71 |
| FieldNamingConventions | The final field name '_fileDescription' doesn't match '[a-z][a-zA-Z0-9]*' | 72 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listFormatExport' doesn't match '[a-z][a-zA-Z0-9]*' | 66 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_mapDataToExport' doesn't match '[a-z][a-zA-Z0-9]*' | 67 |
| FieldNamingConventions | The final field name '_commonDataToExport' doesn't match '[a-z][a-zA-Z0-9]*' | 68 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strFormatExportName' doesn't match '[a-z][a-zA-Z0-9]*' | 54 |
| FieldNamingConventions | The final field name '_strFormatExportDisplayName' doesn't match '[a-z][a-zA-Z0-9]*' | 55 |
| FieldNamingConventions | The final field name '_strFormatExportDescription' doesn't match '[a-z][a-zA-Z0-9]*' | 56 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listQuestionColumns' doesn't match '[a-z][a-zA-Z0-9]*' | 53 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_csvHeader' doesn't match '[a-z][a-zA-Z0-9]*' | 61 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_formTitle' doesn't match '[a-z][a-zA-Z0-9]*' | 109 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strFormatExportName' doesn't match '[a-z][a-zA-Z0-9]*' | 54 |
| FieldNamingConventions | The final field name '_strFormatExportDisplayName' doesn't match '[a-z][a-zA-Z0-9]*' | 55 |
| FieldNamingConventions | The final field name '_strFormatExportDescription' doesn't match '[a-z][a-zA-Z0-9]*' | 56 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strFormatExportName' doesn't match '[a-z][a-zA-Z0-9]*' | 49 |
| FieldNamingConventions | The final field name '_strFormatExportDisplayName' doesn't match '[a-z][a-zA-Z0-9]*' | 50 |
| FieldNamingConventions | The final field name '_strFormatExportDescription' doesn't match '[a-z][a-zA-Z0-9]*' | 51 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listEntryDisplayService' doesn't match '[a-z][a-zA-Z0-9]*' | 51 |
| FieldNamingConventions | The final field name '_listEntryDataService' doesn't match '[a-z][a-zA-Z0-9]*' | 53 |
| FieldNamingConventions | The final field name '_listValidator' doesn't match '[a-z][a-zA-Z0-9]*' | 55 |
| Rule | Violation | Line |
|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 56–130 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_formListFacade' doesn't match '[a-z][a-zA-Z0-9]*' | 73 |
| FieldNamingConventions | The final field name '_formColumnFactory' doesn't match '[a-z][a-zA-Z0-9]*' | 74 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_singleton' doesn't match '[A-Z][A-Z_0-9]*' | 163 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_formDatabaseService' doesn't match '[a-z][a-zA-Z0-9]*' | 84 |
| Rule | Violation | Line |
|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 81–245 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_lockDao' doesn't match '[a-z][a-zA-Z0-9]*' | 51 |
| FieldNamingConventions | The constant name '_plugin' doesn't match '[A-Z][A-Z_0-9]*' | 52 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'FormEntryNameConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 39–62 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'FormMultiviewFormResponseDateCreationNameConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 39–52 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'FormMultiviewFormsNameConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 39–58 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'FormMultiviewWorkflowStateNameConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 39–54 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'FormsConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 44–267 |
| Rule | Violation | Line |
|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 95–578 |
| Rule | Violation | Line |
|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 42–65 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_collectionItem' doesn't match '[a-z][a-zA-Z0-9]*' | 55 |
| FieldNamingConventions | The final field name '_strCodeAttr' doesn't match '[a-z][a-zA-Z0-9]*' | 56 |
| FieldNamingConventions | The final field name '_strNameAttribute' doesn't match '[a-z][a-zA-Z0-9]*' | 57 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strValidatorName' doesn't match '[a-z][a-zA-Z0-9]*' | 49 |
| FieldNamingConventions | The final field name '_strDisplayName' doesn't match '[a-z][a-zA-Z0-9]*' | 50 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'ControlListenerManager' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 44–96 |
| LocalVariableNamingConventions | The local variable name 'ControlRemovalListener' doesn't match '[a-z][a-zA-Z0-9]*' | 62 |
| LocalVariableNamingConventions | The local variable name 'ControlListener' doesn't match '[a-z][a-zA-Z0-9]*' | 76 |
| LocalVariableNamingConventions | The local variable name 'ControlListener' doesn't match '[a-z][a-zA-Z0-9]*' | 90 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listChildren' doesn't match '[a-z][a-zA-Z0-9]*' | 97 |
| FieldNamingConventions | The final field name '_formDisplay' doesn't match '[a-z][a-zA-Z0-9]*' | 99 |
| FieldNamingConventions | The final field name '_model' doesn't match '[a-z][a-zA-Z0-9]*' | 101 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_formDisplay' doesn't match '[a-z][a-zA-Z0-9]*' | 112 |
| FieldNamingConventions | The final field name '_model' doesn't match '[a-z][a-zA-Z0-9]*' | 114 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listValidatedStep' doesn't match '[a-z][a-zA-Z0-9]*' | 56 |
| FieldNamingConventions | The final field name '_formResponse' doesn't match '[a-z][a-zA-Z0-9]*' | 57 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The field name 'IsRequestComingFromAction' doesn't match '_[a-z][a-zA-Z0-9]*' | 161 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listChildren' doesn't match '[a-z][a-zA-Z0-9]*' | 92 |
| FieldNamingConventions | The final field name '_listICompositeDisplay' doesn't match '[a-z][a-zA-Z0-9]*' | 93 |
| FieldNamingConventions | The final field name '_formResponse' doesn't match '[a-z][a-zA-Z0-9]*' | 96 |
| FieldNamingConventions | The final field name '_mapStepResponses' doesn't match '[a-z][a-zA-Z0-9]*' | 97 |
| FieldNamingConventions | The final field name '_model' doesn't match '[a-z][a-zA-Z0-9]*' | 99 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_nDefaultItemsPerPage' doesn't match '[a-z][a-zA-Z0-9]*' | 151 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_nDefaultItemsPerPage' doesn't match '[a-z][a-zA-Z0-9]*' | 206 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_formService' doesn't match '[A-Z][A-Z_0-9]*' | 133 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_stepService' doesn't match '[A-Z][A-Z_0-9]*' | 155 |
| FieldNamingConventions | The final field name '_nDefaultItemsPerPage' doesn't match '[a-z][a-zA-Z0-9]*' | 161 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_formsMultiviewAuthorizationService' doesn't match '[a-z][a-zA-Z0-9]*' | 155 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_mapValueNames' doesn't match '[A-Z][A-Z_0-9]*' | 49 |
| Rule | Violation | Line |
|---|---|---|
| ClassNamingConventions | The utility class name 'BreadcrumbManager' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 42–67 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strBreadcrumbBeanName' doesn't match '[a-z][a-zA-Z0-9]*' | 53 |
| FieldNamingConventions | The final field name '_strBreadcrumbDisplayBeanName' doesn't match '[a-z][a-zA-Z0-9]*' | 54 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strBreadcrumbBeanName' doesn't match '[a-z][a-zA-Z0-9]*' | 56 |
| FieldNamingConventions | The final field name '_strBreadcrumbDisplayBeanName' doesn't match '[a-z][a-zA-Z0-9]*' | 57 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_mode' doesn't match '[a-z][a-zA-Z0-9]*' | 63 |
| FieldNamingConventions | The final field name '_bIsFront' doesn't match '[a-z][a-zA-Z0-9]*' | 64 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_strCode' doesn't match '[a-z][a-zA-Z0-9]*' | 42 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The constant name '_singleton' doesn't match '[A-Z][A-Z_0-9]*' | 172 |
| Rule | Violation | Line |
|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 65–302 |
| Rule | Violation | Line |
|---|---|---|
| ReturnEmptyArrayRatherThanNull | Return an empty array rather than null. | 170–191 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_nIdFormResponse' doesn't match '[a-z][a-zA-Z0-9]*' | 45 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_listFormResponseViewModelProcessor' doesn't match '[a-z][a-zA-Z0-9]*' | 46 |
| Rule | Violation | Line |
|---|---|---|
| FieldNamingConventions | The final field name '_modifiableParameters' doesn't match '[a-z][a-zA-Z0-9]*' | 45 |
| Rule | Violation | Line |
|---|---|---|
| ProperCloneImplementation | Object clone() should be implemented with super.clone() | 201 |
| Rule | Violation | Line |
|---|---|---|
| AvoidReassigningParameters | Avoid reassigning parameters such as 'strSqlQuery' | 243 |
| Rule | Violation | Line |
|---|---|---|
| ProperCloneImplementation | Object clone() should be implemented with super.clone() | 331 |
| Rule | Violation | Line |
|---|---|---|
| AvoidReassigningParameters | Avoid reassigning parameters such as 'strValue' | 103 |
| Rule | Violation | Line |
|---|---|---|
| AvoidReassigningParameters | Avoid reassigning parameters such as 'nIdForm' | 172 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'nIdForm' | 228 |
| Rule | Violation | Line |
|---|---|---|
| AvoidReassigningParameters | Avoid reassigning parameters such as 'additionnalData' | 68 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'additionnalData' | 86 |
| Rule | Violation | Line |
|---|---|---|
| AvoidReassigningParameters | Avoid reassigning parameters such as 'nIterationNumber' | 55 |
| Rule | Violation | Line |
|---|---|---|
| AvoidReassigningParameters | Avoid reassigning parameters such as 'controlGroup' | 339 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'controlGroup' | 339 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'controlGroup' | 339 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 36–78 |
| UncommentedEmptyConstructor | Document empty constructor | 44–45 |
| CommentRequired | Public method and constructor comments are required | 44–45 |
| CommentRequired | Public method and constructor comments are required | 47–52 |
| CommentRequired | Public method and constructor comments are required | 54–56 |
| CommentRequired | Public method and constructor comments are required | 58–60 |
| CommentRequired | Public method and constructor comments are required | 62–64 |
| CommentRequired | Public method and constructor comments are required | 66–68 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 187–189 |
| CommentRequired | Public method and constructor comments are required | 191–193 |
| CloneThrowsCloneNotSupportedException | clone() method should throw CloneNotSupportedException | 201–224 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 50–431 |
| Rule | Violation | Line |
|---|---|---|
| UseLocaleWithCaseConversions | When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 100 |
| UseLocaleWithCaseConversions | When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 155 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 223–225 |
| UseLocaleWithCaseConversions | When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 245 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 80–85 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 36–93 |
| DataClass | The class 'ControlMapping' is suspected to be a Data Class (WOC=0.000%, NOPA=0, NOAM=6, WMC=6) | 36–93 |
| Rule | Violation | Line |
|---|---|---|
| ExcessivePublicCount | This class has a bunch of public methods and attributes | 34–813 |
| GodClass | Possible God Class (WMC=79, ATFD=10, TCC=1.798%) | 55–813 |
| TooManyFields | Too many fields | 55–813 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the Form constructor if you want a default access modifier | 149–178 |
| SimplifyBooleanReturns | Avoid unnecessary if..then..else statements when returning booleans | 808–810 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 55–393 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 98–105 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 182–189 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 48–320 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 55–724 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 428–431 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 47–300 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 143–147 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 50–402 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 50–367 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 46–227 |
| Rule | Violation | Line |
|---|---|---|
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 222 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 223 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 46–241 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 40–68 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 44–197 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 43–185 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 44–201 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 44–171 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 44–175 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Enum comments are required | 36–51 |
| CommentRequired | Public method and constructor comments are required | 47–49 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 39–173 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _bDisplayFormsTitleColumn field if you want a default access modifier | 43 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 43 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 44 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _bDisplayFormsAssigneeColumn field if you want a default access modifier | 44 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 45 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _strCsvSeparator field if you want a default access modifier | 45 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 46 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _intNumberOfFormResponsesPerPdf field if you want a default access modifier | 46 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _nIdFileTemplatePdf field if you want a default access modifier | 47 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 47 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 66 |
| NonThreadSafeSingleton | Singleton is not thread safe | 76–79 |
| CommentRequired | Public method and constructor comments are required | 138–141 |
| CommentRequired | Public method and constructor comments are required | 143–146 |
| CommentRequired | Public method and constructor comments are required | 148–150 |
| CommentRequired | Public method and constructor comments are required | 152–154 |
| Rule | Violation | Line |
|---|---|---|
| TooManyFields | Too many fields | 48–532 |
| CommentRequired | Public method and constructor comments are required | 507–509 |
| CommentRequired | Public method and constructor comments are required | 511–513 |
| ShortVariable | Avoid variables with short names like o | 516 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 53–474 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 48–315 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 48–313 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 47–92 |
| ShortVariable | Avoid variables with short names like rt | 56 |
| ShortVariable | Avoid variables with short names like p | 62 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 89 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 36–129 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 43–144 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 42–108 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 40–91 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 48 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 47 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 39–53 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 103–106 |
| Rule | Violation | Line |
|---|---|---|
| FieldDeclarationsShouldBeAtStartOfClass | Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 58 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 84 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 107 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 63 |
| TooFewBranchesForASwitchStatement | A switch with less than three branches is inefficient, use a if statement instead. | 76–83 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 65 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 57 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 41–61 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 49 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 41–61 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 49 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 42–62 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 50 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 53 |
| Rule | Violation | Line |
|---|---|---|
| DataClass | The class 'FormFilter' is suspected to be a Data Class (WOC=0.000%, NOPA=0, NOAM=4, WMC=4) | 42–79 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 46–62 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 49 |
| Rule | Violation | Line |
|---|---|---|
| MissingOverride | The method 'getPosition()' is missing an @Override annotation. | 72–75 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 47–50 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 50–54 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 45–68 |
| CommentRequired | Public method and constructor comments are required | 48–51 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 48–51 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 48–51 |
| Rule | Violation | Line |
|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 61–75 |
| Rule | Violation | Line |
|---|---|---|
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _formSearchEngine field if you want a default access modifier | 69 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 69 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 74 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 126–133 |
| Rule | Violation | Line |
|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 56–90 |
| SimpleDateFormatNeedsLocale | When instantiating a SimpleDateFormat object, specify a Locale | 69 |
| Rule | Violation | Line |
|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 57–74 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 61 |
| Rule | Violation | Line |
|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 59–72 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 38–71 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'acquire': the method is declared in an interface type | 47 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'release': the method is declared in an interface type | 55 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'refresh': the method is declared in an interface type | 63 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'closeAll': the method is declared in an interface type | 69 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 39–164 |
| MissingSerialVersionUID | Classes implementing Serializable should set a serialVersionUID | 39–164 |
| DataClass | The class 'Lock' is suspected to be a Data Class (WOC=8.333%, NOPA=0, NOAM=11, WMC=12) | 39–164 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 45–129 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryModifier | Unnecessary modifiers 'public static final' on field 'RESOURCE_TYPE': the field is declared in an interface type | 48 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 44–58 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 347 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'selectList': the method is declared in an interface type | 121 |
| Rule | Violation | Line |
|---|---|---|
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 63–78 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 51–179 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 68–71 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 85 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 44–120 |
| Rule | Violation | Line |
|---|---|---|
| RedundantFieldInitializer | Avoid using redundant field initializer for '_instance' | 47 |
| NonThreadSafeSingleton | Singleton is not thread safe | 56–59 |
| MissingOverride | The method 'getPortletTypeId()' is missing an @Override annotation. | 69–73 |
| MissingOverride | The method 'getDAO()' is missing an @Override annotation. | 80–83 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 38–41 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 49–123 |
| ImmutableField | Private field 'strIdComponent' could be made final; it is only initialized in the declaration or constructor. | 54 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 77 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 77 |
| EmptyStatementNotInLoop | An empty statement (semicolon) not part of a loop | 117 |
| Rule | Violation | Line |
|---|---|---|
| MissingSerialVersionUID | Classes implementing Serializable should set a serialVersionUID | 3–13 |
| CommentRequired | Header comments are required | 3–13 |
| UnnecessaryConstructor | Avoid unnecessary constructors - the compiler will generate these for you | 8–11 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 36–74 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 57–122 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_configList' | 74 |
| CommentRequired | Protected method constructor comments are required | 99–113 |
| CommentRequired | Protected method constructor comments are required | 115–120 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 117 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 118 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 132–152 |
| CommentRequired | Public method and constructor comments are required | 154–178 |
| CommentRequired | Public method and constructor comments are required | 180–213 |
| Rule | Violation | Line |
|---|---|---|
| UnusedPrivateField | Avoid unused private fields such as 'RESPONSE_SEPARATOR'. | 63 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 84 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 85 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 86 |
| CommentRequired | Public method and constructor comments are required | 93–118 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 97 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 110–113 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 127 |
| Rule | Violation | Line |
|---|---|---|
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 133 |
| Rule | Violation | Line |
|---|---|---|
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _mapQuestionAndIterationColumn field if you want a default access modifier | 52 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 52 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 52 |
| SingularField | Perhaps '_numberOfQuestionColumns' could be replaced by a local variable. | 54 |
| ImmutableField | Private field '_numberOfQuestionColumns' could be made final; it is only initialized in the declaration or constructor. | 54 |
| UnusedPrivateField | Avoid unused private fields such as '_numberOfQuestionColumns'. | 54 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 118–133 |
| Rule | Violation | Line |
|---|---|---|
| DefaultPackage | Use explicit scoping instead of the default package private level | 103–109 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the safeString method if you want a default access modifier | 103–109 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_csvSeparator' could be made final; it is only initialized in the declaration or constructor. | 62 |
| CommentRequired | Public method and constructor comments are required | 64–67 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 76 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 77 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 78 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 79 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 80 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 81 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 82 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 85–90 |
| CommentRequired | Public method and constructor comments are required | 99–111 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 122 |
| LooseCoupling | Avoid using implementation types like 'ArrayList'; use the interface instead | 152 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 185 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–439 |
| CommentRequired | Header comments are required | 95–439 |
| GodClass | Possible God Class (WMC=51, ATFD=47, TCC=1.515%) | 95–439 |
| CommentRequired | Protected method constructor comments are required | 111–115 |
| CommentRequired | Protected method constructor comments are required | 117–125 |
| SignatureDeclareThrowsException | A method/constructor should not explicitly throw java.lang.Exception | 117 |
| CommentRequired | Protected method constructor comments are required | 127–138 |
| SignatureDeclareThrowsException | A method/constructor should not explicitly throw java.lang.Exception | 127 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 272–281 |
| NPathComplexity | The method 'getResponseValue(FormQuestionResponse, int)' has an NPath complexity of 2166 | 343–419 |
| CyclomaticComplexity | The method 'getResponseValue(FormQuestionResponse, int)' has a cyclomatic complexity of 19. | 343–419 |
| CollapsibleIfStatements | These nested if statements could be combined | 382–398 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 409 |
| CommentRequired | Protected method constructor comments are required | 421–437 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–251 |
| CommentRequired | Header comments are required | 73–251 |
| CommentRequired | Public method and constructor comments are required | 78–104 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 191 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 191–195 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 194 |
| Rule | Violation | Line |
|---|---|---|
| DataClass | The class 'PdfCell' is suspected to be a Data Class (WOC=7.692%, NOPA=0, NOAM=12, WMC=13) | 38–127 |
| CommentRequired | Header comments are required | 38–127 |
| CommentRequired | Public method and constructor comments are required | 123–126 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 61–187 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_hasMultipleFiles' | 65 |
| CommentRequired | Protected method constructor comments are required | 67–71 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 127 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 152 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 160 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 171 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 181 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 47–163 |
| ShortVariable | Avoid variables with short names like y | 64 |
| CommentRequired | Public method and constructor comments are required | 150–162 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 47–95 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 67–228 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_hasMultipleFiles' | 69 |
| CommentRequired | Protected method constructor comments are required | 71–75 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 137 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 152 |
| SignatureDeclareThrowsException | A method/constructor should not explicitly throw java.lang.Exception | 160 |
| SignatureDeclareThrowsException | A method/constructor should not explicitly throw java.lang.Exception | 184 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 50–251 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_formDatabaseService' | 55 |
| CommentRequired | Protected method constructor comments are required | 250 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 48–58 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 57–234 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 58–234 |
| Rule | Violation | Line |
|---|---|---|
| MissingOverride | The method 'deleteDisplayAndDescendants(int)' is missing an @Override annotation. | 66–119 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 92–94 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 49–116 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_formService' could be made final; it is only initialized in the declaration or constructor. | 58 |
| CommentRequired | Public method and constructor comments are required | 67–75 |
| NonThreadSafeSingleton | Singleton is not thread safe | 69–72 |
| CommentRequired | Public method and constructor comments are required | 77–81 |
| CommentRequired | Public method and constructor comments are required | 83–87 |
| CommentRequired | Public method and constructor comments are required | 101–129 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 122 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–681 |
| GodClass | Possible God Class (WMC=64, ATFD=84, TCC=0.308%) | 100–681 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 101–681 |
| CyclomaticComplexity | The method 'saveForm(Form, FormResponse)' has a cyclomatic complexity of 12. | 118–158 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 151 |
| DoNotUseThreads | To be compliant to J2EE, a webapp should not use any thread. | 515 |
| DoNotUseThreads | To be compliant to J2EE, a webapp should not use any thread. | 549 |
| DoNotUseThreads | To be compliant to J2EE, a webapp should not use any thread. | 584 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 622 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 142 |
| Rule | Violation | Line |
|---|---|---|
| DataClass | The class 'FormsResourceIdService' is suspected to be a Data Class (WOC=0.000%, NOPA=13, NOAM=0, WMC=1) | 52–183 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 48–273 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 49–273 |
| CommentRequired | Public method and constructor comments are required | 272 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 42–128 |
| CommentRequired | Public method and constructor comments are required | 93 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–384 |
| CommentRequired | Public method and constructor comments are required | 124–129 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 174 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 188 |
| CyclomaticComplexity | The method 'getFormFiltersList(Integer, List, Locale, User)' has a cyclomatic complexity of 10. | 228–273 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 230 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 254 |
| AvoidReassigningLoopVariables | Avoid reassigning the loop control variable 'question' | 289 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 291–305 |
| Rule | Violation | Line |
|---|---|---|
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 114 |
| CommentRequired | Public method and constructor comments are required | 174–177 |
| CommentRequired | Public method and constructor comments are required | 179–186 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 43–162 |
| CommentRequired | Public method and constructor comments are required | 61–64 |
| CommentRequired | Public method and constructor comments are required | 66–69 |
| CommentRequired | Public method and constructor comments are required | 71–74 |
| CommentRequired | Public method and constructor comments are required | 76–79 |
| CommentRequired | Public method and constructor comments are required | 81–84 |
| CommentRequired | Public method and constructor comments are required | 86–90 |
| CommentRequired | Public method and constructor comments are required | 92–96 |
| CommentRequired | Public method and constructor comments are required | 98–101 |
| CommentRequired | Public method and constructor comments are required | 103–106 |
| CommentRequired | Public method and constructor comments are required | 108–112 |
| CommentRequired | Public method and constructor comments are required | 114–117 |
| CommentRequired | Public method and constructor comments are required | 119–122 |
| CommentRequired | Public method and constructor comments are required | 124–127 |
| CommentRequired | Public method and constructor comments are required | 129–132 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 46–131 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 72 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 90 |
| ShortVariable | Avoid variables with short names like sb | 111 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 112 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 113 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 114 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 115 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 49–81 |
| ShortVariable | Avoid variables with short names like bo | 57 |
| Rule | Violation | Line |
|---|---|---|
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 312 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 41–99 |
| Rule | Violation | Line |
|---|---|---|
| CyclomaticComplexity | The method 'isResponseChanged(List, List)' has a cyclomatic complexity of 11. | 107–151 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 114 |
| Rule | Violation | Line |
|---|---|---|
| CyclomaticComplexity | The method 'getResponseValueForExport(Entry, HttpServletRequest, Response, Locale)' has a cyclomatic complexity of 10. | 136–171 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 153–162 |
| Rule | Violation | Line |
|---|---|---|
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 211 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 42–117 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–451 |
| GodClass | Possible God Class (WMC=53, ATFD=65, TCC=10.458%) | 80–451 |
| CommentRequired | Header comments are required | 80–451 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 81–451 |
| CommentRequired | Protected method constructor comments are required | 87–95 |
| CommentRequired | Public method and constructor comments are required | 170–195 |
| CommentRequired | Protected method constructor comments are required | 197–219 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 200 |
| CommentRequired | Protected method constructor comments are required | 221–260 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 225 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 227 |
| CommentRequired | Protected method constructor comments are required | 262–276 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 264 |
| CommentRequired | Protected method constructor comments are required | 278–301 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 280 |
| CommentRequired | Protected method constructor comments are required | 303–336 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 306 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 316 |
| CommentRequired | Protected method constructor comments are required | 450 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 51–253 |
| DataClass | The class 'FormJsonData' is suspected to be a Data Class (WOC=0.000%, NOPA=0, NOAM=22, WMC=22) | 51–253 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–245 |
| CommentRequired | Public method and constructor comments are required | 92–95 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 216 |
| Rule | Violation | Line |
|---|---|---|
| DataClass | The class 'StepJsonData' is suspected to be a Data Class (WOC=0.000%, NOPA=0, NOAM=14, WMC=14) | 47–176 |
| CommentRequired | Header comments are required | 47–176 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 46–58 |
| ImmutableField | Private field '_fmt' could be made final; it is only initialized in the declaration or constructor. | 48 |
| ShortVariable | Avoid variables with short names like dt | 54 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 46–59 |
| ImmutableField | Private field '_fmt' could be made final; it is only initialized in the declaration or constructor. | 48 |
| ShortVariable | Avoid variables with short names like z | 54 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 47–143 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 38–98 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 5–39 |
| Rule | Violation | Line |
|---|---|---|
| MissingStaticMethodInNonInstantiatableClass | Class cannot be instantiated and does not provide any static methods or fields | 49–131 |
| CommentRequired | Header comments are required | 49–131 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–358 |
| AbstractClassWithoutAbstractMethod | This abstract class does not have any abstract methods | 84–358 |
| CommentRequired | Header comments are required | 84–358 |
| CyclomaticComplexity | The method 'getValuesModel(FormResponse, HttpServletRequest)' has a cyclomatic complexity of 20. | 128–233 |
| NcssCount | The method 'getValuesModel(FormResponse, HttpServletRequest)' has a NCSS line count of 62. | 128–233 |
| ExcessiveMethodLength | Avoid really long methods. | 128–233 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 130 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 142–175 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 150–156 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 157–172 |
| CollapsibleIfStatements | These nested if statements could be combined | 159–171 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 245 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 46–86 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 36–61 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_formSearchIndexer' could be made final; it is only initialized in the declaration or constructor. | 55 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 44–78 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 40–51 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'provideFields': the method is declared in an interface type | 50 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–254 |
| CommentRequired | Header comments are required | 72–254 |
| ShortVariable | Avoid variables with short names like ir | 88 |
| OptimizableToArrayCall | This call to Collection.toArray() may be optimizable | 128 |
| OptimizableToArrayCall | This call to Collection.toArray() may be optimizable | 128 |
| OptimizableToArrayCall | This call to Collection.toArray() may be optimizable | 129 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 135–140 |
| ShortVariable | Avoid variables with short names like si | 138 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 142 |
| ShortVariable | Avoid variables with short names like ir | 188 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 194–201 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 70 |
| CyclomaticComplexity | The method 'getIndexWriter(Boolean, boolean)' has a cyclomatic complexity of 11. | 94–140 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 163–169 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–889 |
| GodClass | Possible God Class (WMC=95, ATFD=149, TCC=8.696%) | 97–889 |
| CyclomaticComplexity | The class 'LuceneFormSearchIndexer' has a total cyclomatic complexity of 95 (highest 17). | 97–889 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 98–889 |
| UseUnderscoresInNumericLiterals | Number 3600000L should separate every third digit with an underscore | 104 |
| ImmutableField | Private field '_lockManager' could be made final; it is only initialized in the declaration or constructor. | 111 |
| MissingOverride | The method 'fullIndexing()' is missing an @Override annotation. | 147–187 |
| InsufficientStringBufferDeclaration | StringBuffer constructor is initialized with size 16, but has at least 71 characters appended. | 150 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 170 |
| MissingOverride | The method 'incrementalIndexing()' is missing an @Override annotation. | 192–216 |
| InsufficientStringBufferDeclaration | StringBuffer constructor is initialized with size 16, but has at least 116 characters appended. | 194 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 203 |
| CyclomaticComplexity | The method 'removeConcurrentAction(List, List, List, Plugin)' has a cyclomatic complexity of 10. | 259–313 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 318–395 |
| CyclomaticComplexity | The method 'processIndexing()' has a cyclomatic complexity of 12. | 318–395 |
| MissingOverride | The method 'isIndexerInitialized()' is missing an @Override annotation. | 400–411 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 406 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 426–435 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 441 |
| OptimizableToArrayCall | This call to Collection.toArray() may be optimizable | 484 |
| CyclomaticComplexity | The method 'getDocument(FormResponse, Form, State)' has a cyclomatic complexity of 17. | 667–810 |
| NcssCount | The method 'getDocument(FormResponse, Form, State)' has a NCSS line count of 76. | 667–810 |
| ExcessiveMethodLength | Avoid really long methods. | 667–810 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 747–802 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 759 |
| ShortVariable | Avoid variables with short names like sb | 822 |
| AppendCharacterWithChar | Avoid appending characters as strings in StringBuffer.append. | 840 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 60–63 |
| Rule | Violation | Line |
|---|---|---|
| AvoidDuplicateLiterals | The String literal "id_parent" appears 4 times in this file; the first occurrence is on line 57 | 57 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–578 |
| CommentRequired | Header comments are required | 95–578 |
| GodClass | Possible God Class (WMC=68, ATFD=106, TCC=0.526%) | 95–578 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 96–578 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 98 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 132 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 210 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 242–245 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 265 |
| NPathComplexity | The method 'fillResponseManagerWithResponses(HttpServletRequest, boolean, FormResponseManager, List, boolean)' has an NPath complexity of 1098 | 326–413 |
| CyclomaticComplexity | The method 'fillResponseManagerWithResponses(HttpServletRequest, boolean, FormResponseManager, List, boolean)' has a cyclomatic complexity of 17. | 326–413 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 335–348 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 415–419 |
| CommentRequired | Public method and constructor comments are required | 415–419 |
| CommentRequired | Public method and constructor comments are required | 503–506 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 572 |
| Rule | Violation | Line |
|---|---|---|
| InsufficientStringBufferDeclaration | StringBuffer constructor is initialized with size 16, but has at least 18 characters appended. | 60 |
| Rule | Violation | Line |
|---|---|---|
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 58 |
| Rule | Violation | Line |
|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 61–85 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 63–73 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 77–84 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 53–130 |
| CommentRequired | Public method and constructor comments are required | 62–65 |
| SimpleDateFormatNeedsLocale | When instantiating a SimpleDateFormat object, specify a Locale | 70 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 97 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 107 |
| CommentRequired | Protected method constructor comments are required | 123 |
| CommentRequired | Protected method constructor comments are required | 125 |
| CommentRequired | Protected method constructor comments are required | 127 |
| CommentRequired | Protected method constructor comments are required | 129 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 48–110 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 74 |
| CommentRequired | Public method and constructor comments are required | 106 |
| CommentRequired | Protected method constructor comments are required | 108 |
| CommentRequired | Protected method constructor comments are required | 109 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 85 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 117 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 48–110 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 74 |
| CommentRequired | Public method and constructor comments are required | 106 |
| CommentRequired | Protected method constructor comments are required | 108 |
| CommentRequired | Protected method constructor comments are required | 109 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 56–128 |
| ImmutableField | Private field '_plugin' could be made final; it is only initialized in the declaration or constructor. | 63 |
| CommentRequired | Public method and constructor comments are required | 65–68 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 73 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 94 |
| CommentRequired | Protected method constructor comments are required | 127 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 46–170 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 39–70 |
| CommentRequired | Public method and constructor comments are required | 42–45 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 39–70 |
| CommentRequired | Public method and constructor comments are required | 42–45 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 41–77 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 7–20 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 76 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 88 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 75 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 43–94 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 71–74 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 94 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 105–108 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 144 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 39–71 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 40–74 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 80 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 105 |
| Rule | Violation | Line |
|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 71–597 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 101 |
| UnusedFormalParameter | Avoid unused constructor parameters such as 'nIterationNumber'. | 113 |
| NPathComplexity | The method 'findTemplateFor(DisplayType)' has an NPath complexity of 384 | 274–312 |
| CyclomaticComplexity | The method 'findTemplateFor(DisplayType)' has a cyclomatic complexity of 10. | 274–312 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 481 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–723 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 88–723 |
| NPathComplexity | The method 'getCompositeHtml(HttpServletRequest, List, Locale, DisplayType)' has an NPath complexity of 2148 | 200–299 |
| NcssCount | The method 'getCompositeHtml(HttpServletRequest, List, Locale, DisplayType)' has a NCSS line count of 64. | 200–299 |
| CyclomaticComplexity | The method 'getCompositeHtml(HttpServletRequest, List, Locale, DisplayType)' has a cyclomatic complexity of 19. | 200–299 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 203 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 203 |
| ControlStatementBraces | This statement should have braces | 234 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 253–255 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 262–273 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 284 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 295 |
| CyclomaticComplexity | The method 'findTemplateFor(DisplayType)' has a cyclomatic complexity of 10. | 457–497 |
| NPathComplexity | The method 'findTemplateFor(DisplayType)' has an NPath complexity of 384 | 457–497 |
| NPathComplexity | The method 'setQuestionVisibility(List, DisplayType)' has an NPath complexity of 576 | 532–576 |
| CyclomaticComplexity | The method 'setQuestionVisibility(List, DisplayType)' has a cyclomatic complexity of 11. | 532–576 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 637 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 38–112 |
| Rule | Violation | Line |
|---|---|---|
| GodClass | Possible God Class (WMC=49, ATFD=34, TCC=26.667%) | 54–429 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 55–429 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_bIsResponseLoadedFromBackup' | 58 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_isBackupResponseAlreadyInitiated' | 59 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 152 |
| CommentRequired | Public method and constructor comments are required | 157–161 |
| CommentRequired | Public method and constructor comments are required | 171–173 |
| CommentRequired | Public method and constructor comments are required | 182–184 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–377 |
| CommentRequired | Public method and constructor comments are required | 132–152 |
| CommentRequired | Public method and constructor comments are required | 155–196 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 159 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 198 |
| CommentRequired | Public method and constructor comments are required | 199–250 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 208 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 227 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 260 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 264 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 342–349 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–1470 |
| ExcessiveClassLength | Avoid really long classes. | 98–1470 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 99–1470 |
| ImmutableField | Private field '_captchaSecurityService' could be made final; it is only initialized in the declaration or constructor. | 154 |
| RedundantFieldInitializer | Avoid using redundant field initializer for 'IsRequestComingFromAction' | 161 |
| PreserveStackTrace | New exception is thrown in catch block, original stack trace may be lost | 215 |
| CyclomaticComplexity | The method 'checkMyLuteceAuthentification(Form, HttpServletRequest)' has a cyclomatic complexity of 11. | 229–258 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 271 |
| NPathComplexity | The method 'getStepView(HttpServletRequest)' has an NPath complexity of 184608 | 272–395 |
| NcssCount | The method 'getStepView(HttpServletRequest)' has a NCSS line count of 63. | 272–395 |
| ExcessiveMethodLength | Avoid really long methods. | 272–395 |
| CyclomaticComplexity | The method 'getStepView(HttpServletRequest)' has a cyclomatic complexity of 29. | 272–395 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 272–395 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 308–310 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 311 |
| AvoidDuplicateLiterals | The String literal "action_" appears 4 times in this file; the first occurrence is on line 326 | 326 |
| LinguisticNaming | Linguistics Antipattern - The getter 'getFormStepModel' should not return void linguistically | 448–466 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 478 |
| CyclomaticComplexity | The method 'doReturnStep(HttpServletRequest)' has a cyclomatic complexity of 10. | 479–524 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 479–524 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 482 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 519 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 536 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 537–578 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 541 |
| EmptyCatchBlock | Avoid empty catch blocks | 566–569 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 590 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 591–623 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 690 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 691–728 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 742 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 743–780 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 854–868 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 944 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 945–1000 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 953 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 960 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 990 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 1023 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 1024–1083 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 1098 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 1099–1135 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1130 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 1148 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 1149–1183 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 1196 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 1197–1232 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 1245 |
| CyclomaticComplexity | The method 'doSynchronousUploadDocument(HttpServletRequest)' has a cyclomatic complexity of 10. | 1246–1334 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 1246–1334 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1265 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 1300–1330 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 1345–1352 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1403 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1404 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1405 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1406 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1420 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1421 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1422 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1423 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1437 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1438 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 1439 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 67–127 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 99 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 116 |
| ShortVariable | Avoid variables with short names like t | 122 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Public method and constructor comments are required | 153 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 97 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 99 |
| ImmutableField | Private field '_captchaSecurityService' could be made final; it is only initialized in the declaration or constructor. | 100 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 270 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 298–311 |
| CyclomaticComplexity | The method 'findTemplateFor(DisplayType)' has a cyclomatic complexity of 10. | 331–375 |
| NPathComplexity | The method 'findTemplateFor(DisplayType)' has an NPath complexity of 512 | 331–375 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 191 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–922 |
| CyclomaticComplexity | The class 'AbstractFormQuestionJspBean' has a total cyclomatic complexity of 111 (highest 21). | 82–922 |
| CommentRequired | Header comments are required | 82–922 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 83–922 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_nIdParentSelected' | 171 |
| NPathComplexity | The method 'processQuestionCreation(HttpServletRequest, String)' has an NPath complexity of 576 | 182–260 |
| CyclomaticComplexity | The method 'processQuestionCreation(HttpServletRequest, String)' has a cyclomatic complexity of 12. | 182–260 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 185 |
| CyclomaticComplexity | The method 'processQuestionUpdate(HttpServletRequest)' has a cyclomatic complexity of 12. | 269–332 |
| NPathComplexity | The method 'processQuestionUpdate(HttpServletRequest)' has an NPath complexity of 288 | 269–332 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 310–319 |
| CommentRequired | Protected method constructor comments are required | 334–379 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 344 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 356–375 |
| CommentRequired | Protected method constructor comments are required | 381–410 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 390 |
| CommentRequired | Protected method constructor comments are required | 412–437 |
| CommentRequired | Protected method constructor comments are required | 439–464 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 442 |
| CommentRequired | Protected method constructor comments are required | 466–517 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 469 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 492 |
| CommentRequired | Protected method constructor comments are required | 519–599 |
| CyclomaticComplexity | The method 'initModifyQuestionModel(HttpServletRequest)' has a cyclomatic complexity of 10. | 519–599 |
| AvoidReassigningLoopVariables | Avoid reassigning the loop control variable 'field' | 549 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 557 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 583 |
| ExcessiveMethodLength | Avoid really long methods. | 601–714 |
| CyclomaticComplexity | The method 'initMoveCompositeModel(HttpServletRequest)' has a cyclomatic complexity of 21. | 601–714 |
| NcssCount | The method 'initMoveCompositeModel(HttpServletRequest)' has a NCSS line count of 62. | 601–714 |
| CommentRequired | Protected method constructor comments are required | 601–714 |
| NPathComplexity | The method 'initMoveCompositeModel(HttpServletRequest)' has an NPath complexity of 103680 | 601–714 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 603 |
| CommentRequired | Protected method constructor comments are required | 910 |
| CommentRequired | Protected method constructor comments are required | 921 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Protected method constructor comments are required | 89–95 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 233 |
| CommentRequired | Protected method constructor comments are required | 247–255 |
| CommentRequired | Protected method constructor comments are required | 257–263 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_uploadHandler' could be made final; it is only initialized in the declaration or constructor. | 109 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–828 |
| UseLocaleWithCaseConversions | When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 326 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 329 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 330 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 342–349 |
| CommentRequired | Public method and constructor comments are required | 362–394 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 383–390 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 424–431 |
| CyclomaticComplexity | The method 'buildControlModel(HttpServletRequest, Map)' has a cyclomatic complexity of 31. | 444–573 |
| NPathComplexity | The method 'buildControlModel(HttpServletRequest, Map)' has an NPath complexity of 645120 | 444–573 |
| NcssCount | The method 'buildControlModel(HttpServletRequest, Map)' has a NCSS line count of 77. | 444–573 |
| ExcessiveMethodLength | Avoid really long methods. | 444–573 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 496–503 |
| ShortVariable | Avoid variables with short names like q | 520 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 558 |
| UseEqualsToCompareStrings | Use equals() to compare strings instead of '==' or '!=' | 558 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 660–674 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 728 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 767 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 768 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 769 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 771 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 772 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 773 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 64–439 |
| CommentRequired | Public method and constructor comments are required | 107–148 |
| CommentRequired | Public method and constructor comments are required | 151–185 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 152 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 153 |
| LinguisticNaming | Linguistics Antipattern - The variable 'isOrderExportDecrementing' indicates linguistically it is a boolean, but it is 'int' | 167 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 180 |
| CommentRequired | Public method and constructor comments are required | 188–228 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 189 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 223 |
| CommentRequired | Public method and constructor comments are required | 231–263 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 241 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 259 |
| CommentRequired | Public method and constructor comments are required | 266–296 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 268 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 280 |
| CommentRequired | Public method and constructor comments are required | 299–334 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 301 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 312 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 330 |
| CommentRequired | Public method and constructor comments are required | 337–372 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 344 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 368 |
| CommentRequired | Public method and constructor comments are required | 375–410 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 382 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 406 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 418 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 428–430 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 433 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–889 |
| ImmutableField | Private field '_captchaSecurityService' could be made final; it is only initialized in the declaration or constructor. | 212 |
| ImmutableField | Private field '_uploadHandler' could be made final; it is only initialized in the declaration or constructor. | 213 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 293 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 294 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 546–554 |
| CommentRequired | Public method and constructor comments are required | 588–617 |
| CommentRequired | Public method and constructor comments are required | 848–869 |
| CommentRequired | Public method and constructor comments are required | 872–888 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 69–250 |
| CommentRequired | Public method and constructor comments are required | 110–153 |
| CommentRequired | Public method and constructor comments are required | 156–190 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 186 |
| CommentRequired | Public method and constructor comments are required | 193–225 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 221 |
| CommentRequired | Public method and constructor comments are required | 228–249 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 230 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 240–242 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 245 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–790 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 96–790 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 184 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 214 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 258 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 315–322 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 352–354 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 372 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 376 |
| ControlStatementBraces | This statement should have braces | 393 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 423–430 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 483 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 493–500 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 504 |
| CommentRequired | Public method and constructor comments are required | 505–526 |
| ShortVariable | Avoid variables with short names like id | 508 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 522 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 535 |
| NPathComplexity | The method 'getConfirmRemoveComposite(HttpServletRequest)' has an NPath complexity of 972 | 536–595 |
| CyclomaticComplexity | The method 'getConfirmRemoveComposite(HttpServletRequest)' has a cyclomatic complexity of 15. | 536–595 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 569–583 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 691 |
| NPathComplexity | The method 'doMoveComposite(HttpServletRequest)' has an NPath complexity of 864 | 716–777 |
| CyclomaticComplexity | The method 'doMoveComposite(HttpServletRequest)' has a cyclomatic complexity of 12. | 716–777 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 748 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–755 |
| CommentRequired | Header comments are required | 74–755 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 75–755 |
| ImmutableField | Private field '_controller' could be made final; it is only initialized in the declaration or constructor. | 113 |
| ImmutableField | Private field '_formService' could be made final; it is only initialized in the declaration or constructor. | 114 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 128 |
| CyclomaticComplexity | The method 'getStepView(HttpServletRequest)' has a cyclomatic complexity of 17. | 129–224 |
| NPathComplexity | The method 'getStepView(HttpServletRequest)' has an NPath complexity of 1216 | 129–224 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 233 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 247 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 264 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 275 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 298 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 325 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 353 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 381 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 407 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 442 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 443–457 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 466 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 467–487 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 496 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 497–529 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 514–522 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 524 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 539 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 540 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 541 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 542 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 555 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 556 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 557 |
| LinguisticNaming | Linguistics Antipattern - The getter 'getFormStepModel' should not return void linguistically | 652–662 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 699–713 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–675 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 252 |
| CyclomaticComplexity | The method 'doCreateStep(HttpServletRequest)' has a cyclomatic complexity of 10. | 290–335 |
| CyclomaticComplexity | The method 'doModifyStep(HttpServletRequest)' has a cyclomatic complexity of 11. | 524–589 |
| NPathComplexity | The method 'doModifyStep(HttpServletRequest)' has an NPath complexity of 432 | 524–589 |
| CommentRequired | Public method and constructor comments are required | 606–634 |
| CommentRequired | Public method and constructor comments are required | 637–657 |
| CommentRequired | Public method and constructor comments are required | 660–674 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–629 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 75–629 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 138 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 208 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 212–219 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 248–255 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 456–470 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 60–148 |
| CommentRequired | Public method and constructor comments are required | 85–111 |
| CommentRequired | Public method and constructor comments are required | 114–147 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 143 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–686 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 157 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 178 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 199 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 276 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 307 |
| CyclomaticComplexity | The method 'doModifyField(HttpServletRequest)' has a cyclomatic complexity of 11. | 327–390 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 329 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 331 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 333 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 334 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 353–387 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 374 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 399 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 434 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 435 |
| CyclomaticComplexity | The method 'doMoveField(HttpServletRequest, boolean)' has a cyclomatic complexity of 10. | 504–549 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 506 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 507 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 508 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 509 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 565 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 566 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 567 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–685 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 103–685 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 154 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 231 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 268 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 326 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 412 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 445 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 461 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 472–482 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 501 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 513 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 548 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 551 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 637–651 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 640 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 49 |
| Rule | Violation | Line |
|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 34–687 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 107–687 |
| ImmutableField | Private field '_uploadHandler' could be made final; it is only initialized in the declaration or constructor. | 161 |
| CyclomaticComplexity | The method 'getMultiviewFormsView(HttpServletRequest)' has a cyclomatic complexity of 10. | 171–250 |
| NPathComplexity | The method 'getMultiviewFormsView(HttpServletRequest)' has an NPath complexity of 216 | 171–250 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 311 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 354 |
| EmptyCatchBlock | Avoid empty catch blocks | 437–440 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 514 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 612–619 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 633–637 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 94 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 97 |
| UnusedPrivateMethod | Avoid unused private methods such as 'getCurrentStepIndex(List,int)'. | 120 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 49–79 |
| CommentRequired | Public method and constructor comments are required | 55–58 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 68 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 62 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 86–92 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 66 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 57 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 79–84 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 71 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 95–101 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 57 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 79–84 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 61 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 87–98 |
| EmptyCatchBlock | Avoid empty catch blocks | 117–120 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 58 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 82–88 |
| Rule | Violation | Line |
|---|---|---|
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 44–47 |
| CommentRequired | Public method and constructor comments are required | 44–47 |
| Rule | Violation | Line |
|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 122 |
| Rule | Violation | Line |
|---|---|---|
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 191–195 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 278–297 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 284–296 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 79 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 96 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 100 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 140 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 153 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 73 |
| UnusedLocalVariable | Avoid unused local variables such as 'strEntryGeoJSON'. | 92 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 104 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'objEntryGeoJSON' | 139 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 75 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 121 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 66 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 95 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 66 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 95 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 67 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 94 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 67 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 94 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 204 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 91 |
| Rule | Violation | Line |
|---|---|---|
| ShortVariable | Avoid variables with short names like TO | 58 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 97 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 122 |
| ShortVariable | Avoid variables with short names like m | 175 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 185 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 99 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 112 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 138 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 140 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 149 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 152 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_formSearchEngine' could be made final; it is only initialized in the declaration or constructor. | 69 |
| CommentRequired | Public method and constructor comments are required | 71–74 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 71–74 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 100 |
| UselessStringValueOf | No need to call String.valueOf to append to a string. | 110 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 129 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 92 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 101 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 128–144 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 139 |
| Rule | Violation | Line |
|---|---|---|
| GodClass | Possible God Class (WMC=53, ATFD=42, TCC=0.735%) | 69–522 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 70–522 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 132 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 231 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 235 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 236 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 241 |
| UnusedFormalParameter | Avoid unused method parameters such as 'strRedirectionDetailsBaseUrl'. | 264 |
| UnusedFormalParameter | Avoid unused method parameters such as 'formColumnlineTemplate'. | 264 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 270–277 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 282 |
| Rule | Violation | Line |
|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 219 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 43–55 |
| CommentRequired | Protected method constructor comments are required | 54 |
| Rule | Violation | Line |
|---|---|---|
| ImmutableField | Private field '_strIterationParameterName' could be made final; it is only initialized in the declaration or constructor. | 52 |
| MissingOverride | The method 'getParameterValues(String)' is missing an @Override annotation. | 72–75 |
| MethodReturnsInternalArray | Returning '_strIterationParameterName' may expose an internal array. | 74 |
| MissingOverride | The method 'getParameter(String)' is missing an @Override annotation. | 80–83 |
| Rule | Violation | Line |
|---|---|---|
| CommentRequired | Header comments are required | 43–98 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_allParameters' | 46 |
| Rule | Violation | Line |
|---|---|---|
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 118 |
| Rule | Violation | Line |
|---|---|---|
| MissingSerialVersionUID | Classes implementing Serializable should set a serialVersionUID | 52–130 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 98–107 |
| LooseCoupling | Avoid using implementation types like 'HashMap'; use the interface instead | 121 |
| Rule | Violation | Line |
|---|---|---|
| ShortClassName | Avoid short class names like Form | 55–813 |
| Rule | Violation | Line |
|---|---|---|
| BooleanGetMethodName | A getX() method which returns a boolean should be named isX() | 92–95 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.plugin.Plugin' due to existing import 'fr.paris.lutece.portal.service.plugin.Plugin' | 196 |
| Rule | Violation | Line |
|---|---|---|
| ShortClassName | Avoid short class names like Step | 43–184 |
| Rule | Violation | Line |
|---|---|---|
| ShortClassName | Avoid short class names like Lock | 39–164 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.forms.service.lock.LockResult' | 36 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'fr.paris.lutece.portal.business.file.File' due to existing import 'fr.paris.lutece.portal.business.file.File' | 385 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'java.io.OutputStream' | 38 |
| UnusedImports | Avoid unused imports such as 'java.nio.file.Files' | 39 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.genericattributes.service.entrytype.AbstractEntryTypeGeolocation' | 41 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.file.FileService' | 41 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.file.IFileStoreServiceProvider' | 42 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'fr.paris.lutece.plugins.genericattributes.business.Response' due to existing import 'fr.paris.lutece.plugins.genericattributes.business.Response' | 141 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.genericattributes.service.entrytype.EntryTypeServiceManager' | 78 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.i18n.I18nService' | 47 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.i18n.I18nService' | 43 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.i18n.I18nService' | 43 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'java.time.LocalDateTime' | 37 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.genericattributes.business.ResponseHome' | 44 |
| UnusedImports | Avoid unused imports such as 'org.apache.james.mime4j.dom.datetime.DateTime' | 90 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.api.user.User' | 46 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.admin.AdminUserService' | 61 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.image.ImageResourceManager' | 77 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.business.user.AdminUser' | 80 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.admin.AdminUserService' | 83 |
| Rule | Violation | Line |
|---|---|---|
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'FormsConstants.PARAMETER_ID_FORM' due to existing static import 'fr.paris.lutece.plugins.forms.util.FormsConstants.PARAMETER_ID_FORM' | 435 |
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'FormsConstants.PARAMETER_ID_FORM' due to existing static import 'fr.paris.lutece.plugins.forms.util.FormsConstants.PARAMETER_ID_FORM' | 493 |
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'FormsConstants.PARAMETER_ID_FORM' due to existing static import 'fr.paris.lutece.plugins.forms.util.FormsConstants.PARAMETER_ID_FORM' | 652 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.forms.business.StepHome' | 43 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.business.file.FileHome' | 56 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.business.physicalfile.PhysicalFileHome' | 58 |
| Rule | Violation | Line |
|---|---|---|
| UnusedImports | Avoid unused imports such as 'java.util.Arrays' | 36 |
| UnusedImports | Avoid unused imports such as 'java.util.List' | 38 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_strLabel' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 45 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 36–78 |
| UncommentedEmptyConstructor | Document empty constructor | 3 | 44–45 |
| CommentRequired | Public method and constructor comments are required | 3 | 44–45 |
| CommentRequired | Public method and constructor comments are required | 3 | 47–52 |
| CommentRequired | Public method and constructor comments are required | 3 | 54–56 |
| CommentRequired | Public method and constructor comments are required | 3 | 58–60 |
| CommentRequired | Public method and constructor comments are required | 3 | 62–64 |
| CommentRequired | Public method and constructor comments are required | 3 | 66–68 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 187–189 |
| CommentRequired | Public method and constructor comments are required | 3 | 191–193 |
| CloneThrowsCloneNotSupportedException | clone() method should throw CloneNotSupportedException | 3 | 201–224 |
| ProperCloneImplementation | Object clone() should be implemented with super.clone() | 2 | 201 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 50–431 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseLocaleWithCaseConversions | When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 3 | 100 |
| UseLocaleWithCaseConversions | When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 3 | 155 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 223–225 |
| UseLocaleWithCaseConversions | When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 3 | 245 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 80–85 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 36–93 |
| DataClass | The class 'ControlMapping' is suspected to be a Data Class (WOC=0.000%, NOPA=0, NOAM=6, WMC=6) | 3 | 36–93 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_strLabel' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 46 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessivePublicCount | This class has a bunch of public methods and attributes | 3 | 34–813 |
| ShortClassName | Avoid short class names like Form | 4 | 55–813 |
| GodClass | Possible God Class (WMC=79, ATFD=10, TCC=1.798%) | 3 | 55–813 |
| TooManyFields | Too many fields | 3 | 55–813 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the Form constructor if you want a default access modifier | 3 | 149–178 |
| SimplifyBooleanReturns | Avoid unnecessary if..then..else statements when returning booleans | 3 | 808–810 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 55–393 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 98–105 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 182–189 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'strSqlQuery' | 2 | 243 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 48–320 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| BooleanGetMethodName | A getX() method which returns a boolean should be named isX() | 4 | 92–95 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 55–724 |
| FieldNamingConventions | The constant name '_formQuestionEntryResponseDAO' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 73 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 428–431 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 47–300 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 143–147 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 50–402 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 50–367 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 46–227 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 3 | 222 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 3 | 223 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 46–241 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FormalParameterNamingConventions | The method parameter name '_plugin' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 106 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 40–68 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 44–197 |
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'fr.paris.lutece.portal.service.plugin.Plugin' due to existing import 'fr.paris.lutece.portal.service.plugin.Plugin' | 4 | 196 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 43–185 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 44–201 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 44–171 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 44–175 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Enum comments are required | 3 | 36–51 |
| FieldNamingConventions | The final field name '_strLabel' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 41 |
| CommentRequired | Public method and constructor comments are required | 3 | 47–49 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 39–173 |
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 1 | 39–173 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _bDisplayFormsTitleColumn field if you want a default access modifier | 3 | 43 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 3 | 43 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 3 | 44 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _bDisplayFormsAssigneeColumn field if you want a default access modifier | 3 | 44 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 3 | 45 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _strCsvSeparator field if you want a default access modifier | 3 | 45 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 3 | 46 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _intNumberOfFormResponsesPerPdf field if you want a default access modifier | 3 | 46 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _nIdFileTemplatePdf field if you want a default access modifier | 3 | 47 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 3 | 47 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 66 |
| NonThreadSafeSingleton | Singleton is not thread safe | 3 | 76–79 |
| CommentRequired | Public method and constructor comments are required | 3 | 138–141 |
| CommentRequired | Public method and constructor comments are required | 3 | 143–146 |
| CommentRequired | Public method and constructor comments are required | 3 | 148–150 |
| CommentRequired | Public method and constructor comments are required | 3 | 152–154 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyFields | Too many fields | 3 | 48–532 |
| ProperCloneImplementation | Object clone() should be implemented with super.clone() | 2 | 331 |
| CommentRequired | Public method and constructor comments are required | 3 | 507–509 |
| CommentRequired | Public method and constructor comments are required | 3 | 511–513 |
| ShortVariable | Avoid variables with short names like o | 3 | 516 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 53–474 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ShortClassName | Avoid short class names like Step | 4 | 43–184 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 48–315 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 48–313 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 47–92 |
| ShortVariable | Avoid variables with short names like rt | 3 | 56 |
| ShortVariable | Avoid variables with short names like p | 3 | 62 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 89 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 36–129 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 43–144 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 42–108 |
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 1 | 42–108 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 40–91 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_nColumnToSortPosition' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 42 |
| FieldNamingConventions | The final field name '_strSortAttributeName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 43 |
| FieldNamingConventions | The final field name '_bAscSort' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 44 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 48 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_listFormColumnCell' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 48 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'LuceneQueryBuilder' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 49–96 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 47 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_strSortKey' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 53 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 39–53 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 103–106 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldDeclarationsShouldBeAtStartOfClass | Fields should be declared at the top of the class, before any method declarations, constructors, initializers or inner classes. | 3 | 58 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 84 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 107 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 63 |
| TooFewBranchesForASwitchStatement | A switch with less than three branches is inefficient, use a if statement instead. | 3 | 76–83 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 65 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 57 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 41–61 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 49 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 41–61 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 49 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 42–62 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 50 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 53 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| DataClass | The class 'FormFilter' is suspected to be a Data Class (WOC=0.000%, NOPA=0, NOAM=4, WMC=4) | 3 | 42–79 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 46–62 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 49 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_nPosition' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 48 |
| FieldNamingConventions | The final field name '_strFormFilterLabel' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 49 |
| FieldNamingConventions | The final field name '_strFormFilterName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 50 |
| MissingOverride | The method 'getPosition()' is missing an @Override annotation. | 3 | 72–75 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 47–50 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_formColumn' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 48 |
| CommentRequired | Public method and constructor comments are required | 3 | 50–54 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 45–68 |
| CommentRequired | Public method and constructor comments are required | 3 | 48–51 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 48–51 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 48–51 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 61–75 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _formSearchEngine field if you want a default access modifier | 3 | 69 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 3 | 69 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 74 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 126–133 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 56–90 |
| SimpleDateFormatNeedsLocale | When instantiating a SimpleDateFormat object, specify a Locale | 3 | 69 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 57–74 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 61 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 59–72 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_formListDAO' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 55 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 38–71 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'acquire': the method is declared in an interface type | 3 | 47 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'release': the method is declared in an interface type | 3 | 55 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'refresh': the method is declared in an interface type | 3 | 63 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'closeAll': the method is declared in an interface type | 3 | 69 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ShortClassName | Avoid short class names like Lock | 4 | 39–164 |
| CommentRequired | Header comments are required | 3 | 39–164 |
| MissingSerialVersionUID | Classes implementing Serializable should set a serialVersionUID | 3 | 39–164 |
| DataClass | The class 'Lock' is suspected to be a Data Class (WOC=8.333%, NOPA=0, NOAM=11, WMC=12) | 3 | 39–164 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.forms.service.lock.LockResult' | 4 | 36 |
| CommentRequired | Header comments are required | 3 | 45–129 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_listFormPanelConfiguration' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 50 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_nPosition' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 48 |
| FieldNamingConventions | The final field name '_strTechnicalCode' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 49 |
| FieldNamingConventions | The final field name '_strTitle' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 50 |
| FieldNamingConventions | The final field name '_listFormPanelInitializerName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 51 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnnecessaryModifier | Unnecessary modifiers 'public static final' on field 'RESOURCE_TYPE': the field is declared in an interface type | 3 | 48 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'FormPanelInitializerQueryBuilder' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 47–83 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 44–58 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 347 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'selectList': the method is declared in an interface type | 3 | 121 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 63–78 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 51–179 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 3 | 68–71 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 85 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 44–120 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| RedundantFieldInitializer | Avoid using redundant field initializer for '_instance' | 3 | 47 |
| NonThreadSafeSingleton | Singleton is not thread safe | 3 | 56–59 |
| MissingOverride | The method 'getPortletTypeId()' is missing an @Override annotation. | 3 | 69–73 |
| MissingOverride | The method 'getDAO()' is missing an @Override annotation. | 3 | 80–83 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 38–41 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 49–123 |
| ImmutableField | Private field 'strIdComponent' could be made final; it is only initialized in the declaration or constructor. | 3 | 54 |
| FieldNamingConventions | The field name 'strIdComponent' doesn't match '_[a-z][a-zA-Z0-9]*' | 1 | 54 |
| FormalParameterNamingConventions | The method parameter name 'user_id' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 75 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 77 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 77 |
| FormalParameterNamingConventions | The method parameter name 'published_questions_only' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 89 |
| FormalParameterNamingConventions | The method parameter name 'published_formresponse_only' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 89 |
| EmptyStatementNotInLoop | An empty statement (semicolon) not part of a loop | 3 | 117 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| MissingSerialVersionUID | Classes implementing Serializable should set a serialVersionUID | 3 | 3–13 |
| CommentRequired | Header comments are required | 3 | 3–13 |
| UnnecessaryConstructor | Avoid unnecessary constructors - the compiler will generate these for you | 3 | 8–11 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 36–74 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 57–122 |
| FieldNamingConventions | The final field name '_formPanel' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 67 |
| FieldNamingConventions | The final field name '_listFormColumn' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 68 |
| FieldNamingConventions | The final field name '_listFormFilter' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 69 |
| FieldNamingConventions | The final field name '_sortConfig' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 70 |
| FieldNamingConventions | The final field name '_fileName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 71 |
| FieldNamingConventions | The final field name '_fileDescription' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 72 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_configList' | 3 | 74 |
| CommentRequired | Protected method constructor comments are required | 3 | 99–113 |
| CommentRequired | Protected method constructor comments are required | 3 | 115–120 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 117 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 118 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_listFormatExport' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 66 |
| CommentRequired | Public method and constructor comments are required | 3 | 132–152 |
| CommentRequired | Public method and constructor comments are required | 3 | 154–178 |
| CommentRequired | Public method and constructor comments are required | 3 | 180–213 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedPrivateField | Avoid unused private fields such as 'RESPONSE_SEPARATOR'. | 3 | 63 |
| FieldNamingConventions | The final field name '_mapDataToExport' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 67 |
| FieldNamingConventions | The final field name '_commonDataToExport' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 68 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 84 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 85 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 86 |
| CommentRequired | Public method and constructor comments are required | 3 | 93–118 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 97 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 110–113 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 127 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_strFormatExportName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 54 |
| FieldNamingConventions | The final field name '_strFormatExportDisplayName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 55 |
| FieldNamingConventions | The final field name '_strFormatExportDescription' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 56 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 133 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the _mapQuestionAndIterationColumn field if you want a default access modifier | 3 | 52 |
| DefaultPackage | Use explicit scoping instead of the default package private level | 3 | 52 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 52 |
| FieldNamingConventions | The final field name '_listQuestionColumns' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 53 |
| SingularField | Perhaps '_numberOfQuestionColumns' could be replaced by a local variable. | 3 | 54 |
| ImmutableField | Private field '_numberOfQuestionColumns' could be made final; it is only initialized in the declaration or constructor. | 3 | 54 |
| UnusedPrivateField | Avoid unused private fields such as '_numberOfQuestionColumns'. | 3 | 54 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 118–133 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| DefaultPackage | Use explicit scoping instead of the default package private level | 3 | 103–109 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'strValue' | 2 | 103 |
| CommentDefaultAccessModifier | To avoid mistakes add a comment at the beginning of the safeString method if you want a default access modifier | 3 | 103–109 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_csvHeader' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 61 |
| ImmutableField | Private field '_csvSeparator' could be made final; it is only initialized in the declaration or constructor. | 3 | 62 |
| CommentRequired | Public method and constructor comments are required | 3 | 64–67 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 76 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 77 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 78 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 79 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 80 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 81 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 82 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 85–90 |
| CommentRequired | Public method and constructor comments are required | 3 | 99–111 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 122 |
| LooseCoupling | Avoid using implementation types like 'ArrayList'; use the interface instead | 3 | 152 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 185 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–439 |
| CommentRequired | Header comments are required | 3 | 95–439 |
| GodClass | Possible God Class (WMC=51, ATFD=47, TCC=1.515%) | 3 | 95–439 |
| FieldNamingConventions | The final field name '_formTitle' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 109 |
| CommentRequired | Protected method constructor comments are required | 3 | 111–115 |
| CommentRequired | Protected method constructor comments are required | 3 | 117–125 |
| SignatureDeclareThrowsException | A method/constructor should not explicitly throw java.lang.Exception | 3 | 117 |
| CommentRequired | Protected method constructor comments are required | 3 | 127–138 |
| SignatureDeclareThrowsException | A method/constructor should not explicitly throw java.lang.Exception | 3 | 127 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 272–281 |
| NPathComplexity | The method 'getResponseValue(FormQuestionResponse, int)' has an NPath complexity of 2166 | 3 | 343–419 |
| CyclomaticComplexity | The method 'getResponseValue(FormQuestionResponse, int)' has a cyclomatic complexity of 19. | 3 | 343–419 |
| CollapsibleIfStatements | These nested if statements could be combined | 3 | 382–398 |
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'fr.paris.lutece.portal.business.file.File' due to existing import 'fr.paris.lutece.portal.business.file.File' | 4 | 385 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 409 |
| CommentRequired | Protected method constructor comments are required | 3 | 421–437 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–251 |
| CommentRequired | Header comments are required | 3 | 73–251 |
| CommentRequired | Public method and constructor comments are required | 3 | 78–104 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 191 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 191–195 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 3 | 194 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_strFormatExportName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 54 |
| FieldNamingConventions | The final field name '_strFormatExportDisplayName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 55 |
| FieldNamingConventions | The final field name '_strFormatExportDescription' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 56 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| DataClass | The class 'PdfCell' is suspected to be a Data Class (WOC=7.692%, NOPA=0, NOAM=12, WMC=13) | 3 | 38–127 |
| CommentRequired | Header comments are required | 3 | 38–127 |
| CommentRequired | Public method and constructor comments are required | 3 | 123–126 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'java.io.OutputStream' | 4 | 38 |
| UnusedImports | Avoid unused imports such as 'java.nio.file.Files' | 4 | 39 |
| CommentRequired | Header comments are required | 3 | 61–187 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_hasMultipleFiles' | 3 | 65 |
| CommentRequired | Protected method constructor comments are required | 3 | 67–71 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 127 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 152 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 160 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 171 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 181 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 47–163 |
| ShortVariable | Avoid variables with short names like y | 3 | 64 |
| CommentRequired | Public method and constructor comments are required | 3 | 150–162 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 47–95 |
| FieldNamingConventions | The final field name '_strFormatExportName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 49 |
| FieldNamingConventions | The final field name '_strFormatExportDisplayName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 50 |
| FieldNamingConventions | The final field name '_strFormatExportDescription' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 51 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 67–228 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_hasMultipleFiles' | 3 | 69 |
| CommentRequired | Protected method constructor comments are required | 3 | 71–75 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 137 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 152 |
| SignatureDeclareThrowsException | A method/constructor should not explicitly throw java.lang.Exception | 3 | 160 |
| SignatureDeclareThrowsException | A method/constructor should not explicitly throw java.lang.Exception | 3 | 184 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 50–251 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_formDatabaseService' | 3 | 55 |
| CommentRequired | Protected method constructor comments are required | 3 | 250 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_listEntryDisplayService' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 51 |
| FieldNamingConventions | The final field name '_listEntryDataService' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 53 |
| FieldNamingConventions | The final field name '_listValidator' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 55 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 48–58 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 57–234 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 58–234 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| MissingOverride | The method 'deleteDisplayAndDescendants(int)' is missing an @Override annotation. | 3 | 66–119 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 92–94 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 49–116 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 1 | 56–130 |
| ImmutableField | Private field '_formService' could be made final; it is only initialized in the declaration or constructor. | 3 | 58 |
| CommentRequired | Public method and constructor comments are required | 3 | 67–75 |
| NonThreadSafeSingleton | Singleton is not thread safe | 3 | 69–72 |
| CommentRequired | Public method and constructor comments are required | 3 | 77–81 |
| CommentRequired | Public method and constructor comments are required | 3 | 83–87 |
| CommentRequired | Public method and constructor comments are required | 3 | 101–129 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 122 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–681 |
| GodClass | Possible God Class (WMC=64, ATFD=84, TCC=0.308%) | 3 | 100–681 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 101–681 |
| CyclomaticComplexity | The method 'saveForm(Form, FormResponse)' has a cyclomatic complexity of 12. | 3 | 118–158 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 151 |
| DoNotUseThreads | To be compliant to J2EE, a webapp should not use any thread. | 3 | 515 |
| DoNotUseThreads | To be compliant to J2EE, a webapp should not use any thread. | 3 | 549 |
| DoNotUseThreads | To be compliant to J2EE, a webapp should not use any thread. | 3 | 584 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 622 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_formListFacade' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 73 |
| FieldNamingConventions | The final field name '_formColumnFactory' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 74 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 142 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| DataClass | The class 'FormsResourceIdService' is suspected to be a Data Class (WOC=0.000%, NOPA=13, NOAM=0, WMC=1) | 3 | 52–183 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 48–273 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 49–273 |
| CommentRequired | Public method and constructor comments are required | 3 | 272 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 42–128 |
| CommentRequired | Public method and constructor comments are required | 3 | 93 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–384 |
| CommentRequired | Public method and constructor comments are required | 3 | 124–129 |
| FieldNamingConventions | The constant name '_singleton' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 163 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'nIdForm' | 2 | 172 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 174 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 188 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'nIdForm' | 2 | 228 |
| CyclomaticComplexity | The method 'getFormFiltersList(Integer, List, Locale, User)' has a cyclomatic complexity of 10. | 3 | 228–273 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 230 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 254 |
| AvoidReassigningLoopVariables | Avoid reassigning the loop control variable 'question' | 3 | 289 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 291–305 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 114 |
| CommentRequired | Public method and constructor comments are required | 3 | 174–177 |
| CommentRequired | Public method and constructor comments are required | 3 | 179–186 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 43–162 |
| CommentRequired | Public method and constructor comments are required | 3 | 61–64 |
| CommentRequired | Public method and constructor comments are required | 3 | 66–69 |
| CommentRequired | Public method and constructor comments are required | 3 | 71–74 |
| CommentRequired | Public method and constructor comments are required | 3 | 76–79 |
| CommentRequired | Public method and constructor comments are required | 3 | 81–84 |
| CommentRequired | Public method and constructor comments are required | 3 | 86–90 |
| CommentRequired | Public method and constructor comments are required | 3 | 92–96 |
| CommentRequired | Public method and constructor comments are required | 3 | 98–101 |
| CommentRequired | Public method and constructor comments are required | 3 | 103–106 |
| CommentRequired | Public method and constructor comments are required | 3 | 108–112 |
| CommentRequired | Public method and constructor comments are required | 3 | 114–117 |
| CommentRequired | Public method and constructor comments are required | 3 | 119–122 |
| CommentRequired | Public method and constructor comments are required | 3 | 124–127 |
| CommentRequired | Public method and constructor comments are required | 3 | 129–132 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 46–131 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'additionnalData' | 2 | 68 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 72 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'additionnalData' | 2 | 86 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 90 |
| ShortVariable | Avoid variables with short names like sb | 3 | 111 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 112 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 113 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 114 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 115 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 49–81 |
| ShortVariable | Avoid variables with short names like bo | 3 | 57 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 312 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 41–99 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.genericattributes.service.entrytype.AbstractEntryTypeGeolocation' | 4 | 41 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CyclomaticComplexity | The method 'isResponseChanged(List, List)' has a cyclomatic complexity of 11. | 3 | 107–151 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 114 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.file.FileService' | 4 | 41 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.file.IFileStoreServiceProvider' | 4 | 42 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CyclomaticComplexity | The method 'getResponseValueForExport(Entry, HttpServletRequest, Response, Locale)' has a cyclomatic complexity of 10. | 3 | 136–171 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 153–162 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 211 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 42–117 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–451 |
| GodClass | Possible God Class (WMC=53, ATFD=65, TCC=10.458%) | 3 | 80–451 |
| CommentRequired | Header comments are required | 3 | 80–451 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 81–451 |
| FieldNamingConventions | The final field name '_formDatabaseService' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 84 |
| CommentRequired | Protected method constructor comments are required | 3 | 87–95 |
| CommentRequired | Public method and constructor comments are required | 3 | 170–195 |
| CommentRequired | Protected method constructor comments are required | 3 | 197–219 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 200 |
| CommentRequired | Protected method constructor comments are required | 3 | 221–260 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 225 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 227 |
| CommentRequired | Protected method constructor comments are required | 3 | 262–276 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 264 |
| CommentRequired | Protected method constructor comments are required | 3 | 278–301 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 280 |
| CommentRequired | Protected method constructor comments are required | 3 | 303–336 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 306 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 316 |
| CommentRequired | Protected method constructor comments are required | 3 | 450 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 51–253 |
| DataClass | The class 'FormJsonData' is suspected to be a Data Class (WOC=0.000%, NOPA=0, NOAM=22, WMC=22) | 3 | 51–253 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–245 |
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 1 | 81–245 |
| CommentRequired | Public method and constructor comments are required | 3 | 92–95 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 216 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| DataClass | The class 'StepJsonData' is suspected to be a Data Class (WOC=0.000%, NOPA=0, NOAM=14, WMC=14) | 3 | 47–176 |
| CommentRequired | Header comments are required | 3 | 47–176 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 46–58 |
| ImmutableField | Private field '_fmt' could be made final; it is only initialized in the declaration or constructor. | 3 | 48 |
| ShortVariable | Avoid variables with short names like dt | 3 | 54 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 46–59 |
| ImmutableField | Private field '_fmt' could be made final; it is only initialized in the declaration or constructor. | 3 | 48 |
| ShortVariable | Avoid variables with short names like z | 3 | 54 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 47–143 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 38–98 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 5–39 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| MissingStaticMethodInNonInstantiatableClass | Class cannot be instantiated and does not provide any static methods or fields | 3 | 49–131 |
| CommentRequired | Header comments are required | 3 | 49–131 |
| FieldNamingConventions | The final field name '_lockDao' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 51 |
| FieldNamingConventions | The constant name '_plugin' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 52 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–358 |
| AbstractClassWithoutAbstractMethod | This abstract class does not have any abstract methods | 3 | 84–358 |
| CommentRequired | Header comments are required | 3 | 84–358 |
| CyclomaticComplexity | The method 'getValuesModel(FormResponse, HttpServletRequest)' has a cyclomatic complexity of 20. | 3 | 128–233 |
| NcssCount | The method 'getValuesModel(FormResponse, HttpServletRequest)' has a NCSS line count of 62. | 3 | 128–233 |
| ExcessiveMethodLength | Avoid really long methods. | 3 | 128–233 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 130 |
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'fr.paris.lutece.plugins.genericattributes.business.Response' due to existing import 'fr.paris.lutece.plugins.genericattributes.business.Response' | 4 | 141 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 142–175 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 150–156 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 157–172 |
| CollapsibleIfStatements | These nested if statements could be combined | 3 | 159–171 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 245 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 46–86 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 36–61 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_formSearchIndexer' could be made final; it is only initialized in the declaration or constructor. | 3 | 55 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 44–78 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 40–51 |
| UnnecessaryModifier | Unnecessary modifier 'public' on method 'provideFields': the method is declared in an interface type | 3 | 50 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–254 |
| CommentRequired | Header comments are required | 3 | 72–254 |
| ShortVariable | Avoid variables with short names like ir | 3 | 88 |
| OptimizableToArrayCall | This call to Collection.toArray() may be optimizable | 3 | 128 |
| OptimizableToArrayCall | This call to Collection.toArray() may be optimizable | 3 | 128 |
| OptimizableToArrayCall | This call to Collection.toArray() may be optimizable | 3 | 129 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 135–140 |
| ShortVariable | Avoid variables with short names like si | 3 | 138 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 142 |
| ShortVariable | Avoid variables with short names like ir | 3 | 188 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 194–201 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 70 |
| CyclomaticComplexity | The method 'getIndexWriter(Boolean, boolean)' has a cyclomatic complexity of 11. | 3 | 94–140 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 163–169 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–889 |
| GodClass | Possible God Class (WMC=95, ATFD=149, TCC=8.696%) | 3 | 97–889 |
| CyclomaticComplexity | The class 'LuceneFormSearchIndexer' has a total cyclomatic complexity of 95 (highest 17). | 3 | 97–889 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 98–889 |
| UseUnderscoresInNumericLiterals | Number 3600000L should separate every third digit with an underscore | 3 | 104 |
| ImmutableField | Private field '_lockManager' could be made final; it is only initialized in the declaration or constructor. | 3 | 111 |
| MissingOverride | The method 'fullIndexing()' is missing an @Override annotation. | 3 | 147–187 |
| InsufficientStringBufferDeclaration | StringBuffer constructor is initialized with size 16, but has at least 71 characters appended. | 3 | 150 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 170 |
| MissingOverride | The method 'incrementalIndexing()' is missing an @Override annotation. | 3 | 192–216 |
| InsufficientStringBufferDeclaration | StringBuffer constructor is initialized with size 16, but has at least 116 characters appended. | 3 | 194 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 203 |
| CyclomaticComplexity | The method 'removeConcurrentAction(List, List, List, Plugin)' has a cyclomatic complexity of 10. | 3 | 259–313 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 318–395 |
| CyclomaticComplexity | The method 'processIndexing()' has a cyclomatic complexity of 12. | 3 | 318–395 |
| MissingOverride | The method 'isIndexerInitialized()' is missing an @Override annotation. | 3 | 400–411 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 406 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 426–435 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 441 |
| OptimizableToArrayCall | This call to Collection.toArray() may be optimizable | 3 | 484 |
| CyclomaticComplexity | The method 'getDocument(FormResponse, Form, State)' has a cyclomatic complexity of 17. | 3 | 667–810 |
| NcssCount | The method 'getDocument(FormResponse, Form, State)' has a NCSS line count of 76. | 3 | 667–810 |
| ExcessiveMethodLength | Avoid really long methods. | 3 | 667–810 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 747–802 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 759 |
| ShortVariable | Avoid variables with short names like sb | 3 | 822 |
| AppendCharacterWithChar | Avoid appending characters as strings in StringBuffer.append. | 3 | 840 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 60–63 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'FormEntryNameConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 39–62 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'FormMultiviewFormResponseDateCreationNameConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 39–52 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'FormMultiviewFormsNameConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 39–58 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'FormMultiviewWorkflowStateNameConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 39–54 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'FormsConstants' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 44–267 |
| AvoidDuplicateLiterals | The String literal "id_parent" appears 4 times in this file; the first occurrence is on line 57 | 3 | 57 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–578 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.genericattributes.service.entrytype.EntryTypeServiceManager' | 4 | 78 |
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 1 | 95–578 |
| CommentRequired | Header comments are required | 3 | 95–578 |
| GodClass | Possible God Class (WMC=68, ATFD=106, TCC=0.526%) | 3 | 95–578 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 96–578 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 98 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 132 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 210 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 242–245 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 265 |
| NPathComplexity | The method 'fillResponseManagerWithResponses(HttpServletRequest, boolean, FormResponseManager, List, boolean)' has an NPath complexity of 1098 | 3 | 326–413 |
| CyclomaticComplexity | The method 'fillResponseManagerWithResponses(HttpServletRequest, boolean, FormResponseManager, List, boolean)' has a cyclomatic complexity of 17. | 3 | 326–413 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 335–348 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 415–419 |
| CommentRequired | Public method and constructor comments are required | 3 | 415–419 |
| CommentRequired | Public method and constructor comments are required | 3 | 503–506 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 3 | 572 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 1 | 42–65 |
| InsufficientStringBufferDeclaration | StringBuffer constructor is initialized with size 16, but has at least 18 characters appended. | 3 | 60 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| AvoidReassigningParameters | Avoid reassigning parameters such as 'nIterationNumber' | 2 | 55 |
| ConsecutiveAppendsShouldReuse | StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 3 | 58 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 61–85 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 63–73 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 77–84 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_collectionItem' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 55 |
| FieldNamingConventions | The final field name '_strCodeAttr' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 56 |
| FieldNamingConventions | The final field name '_strNameAttribute' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 57 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 53–130 |
| CommentRequired | Public method and constructor comments are required | 3 | 62–65 |
| SimpleDateFormatNeedsLocale | When instantiating a SimpleDateFormat object, specify a Locale | 3 | 70 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 97 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 107 |
| CommentRequired | Protected method constructor comments are required | 3 | 123 |
| CommentRequired | Protected method constructor comments are required | 3 | 125 |
| CommentRequired | Protected method constructor comments are required | 3 | 127 |
| CommentRequired | Protected method constructor comments are required | 3 | 129 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 48–110 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 74 |
| CommentRequired | Public method and constructor comments are required | 3 | 106 |
| CommentRequired | Protected method constructor comments are required | 3 | 108 |
| CommentRequired | Protected method constructor comments are required | 3 | 109 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.i18n.I18nService' | 4 | 47 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 85 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 117 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 48–110 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 74 |
| CommentRequired | Public method and constructor comments are required | 3 | 106 |
| CommentRequired | Protected method constructor comments are required | 3 | 108 |
| CommentRequired | Protected method constructor comments are required | 3 | 109 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 56–128 |
| ImmutableField | Private field '_plugin' could be made final; it is only initialized in the declaration or constructor. | 3 | 63 |
| CommentRequired | Public method and constructor comments are required | 3 | 65–68 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 73 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 94 |
| CommentRequired | Protected method constructor comments are required | 3 | 127 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 46–170 |
| FieldNamingConventions | The final field name '_strValidatorName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 49 |
| FieldNamingConventions | The final field name '_strDisplayName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 50 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'ControlListenerManager' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 44–96 |
| LocalVariableNamingConventions | The local variable name 'ControlRemovalListener' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 62 |
| LocalVariableNamingConventions | The local variable name 'ControlListener' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 76 |
| LocalVariableNamingConventions | The local variable name 'ControlListener' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 90 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 39–70 |
| CommentRequired | Public method and constructor comments are required | 3 | 42–45 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 39–70 |
| CommentRequired | Public method and constructor comments are required | 3 | 42–45 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 41–77 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 7–20 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.i18n.I18nService' | 4 | 43 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 76 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 88 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.i18n.I18nService' | 4 | 43 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 75 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 43–94 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 71–74 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 94 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 105–108 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 144 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 39–71 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 40–74 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 80 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 105 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 71–597 |
| FieldNamingConventions | The final field name '_listChildren' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 97 |
| FieldNamingConventions | The final field name '_formDisplay' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 99 |
| FieldNamingConventions | The final field name '_model' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 101 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 101 |
| UnusedFormalParameter | Avoid unused constructor parameters such as 'nIterationNumber'. | 3 | 113 |
| NPathComplexity | The method 'findTemplateFor(DisplayType)' has an NPath complexity of 384 | 3 | 274–312 |
| CyclomaticComplexity | The method 'findTemplateFor(DisplayType)' has a cyclomatic complexity of 10. | 3 | 274–312 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 481 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–723 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 88–723 |
| FieldNamingConventions | The final field name '_formDisplay' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 112 |
| FieldNamingConventions | The final field name '_model' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 114 |
| NPathComplexity | The method 'getCompositeHtml(HttpServletRequest, List, Locale, DisplayType)' has an NPath complexity of 2148 | 3 | 200–299 |
| NcssCount | The method 'getCompositeHtml(HttpServletRequest, List, Locale, DisplayType)' has a NCSS line count of 64. | 3 | 200–299 |
| CyclomaticComplexity | The method 'getCompositeHtml(HttpServletRequest, List, Locale, DisplayType)' has a cyclomatic complexity of 19. | 3 | 200–299 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 203 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 203 |
| ControlStatementBraces | This statement should have braces | 3 | 234 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 253–255 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 262–273 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 284 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 295 |
| CyclomaticComplexity | The method 'findTemplateFor(DisplayType)' has a cyclomatic complexity of 10. | 3 | 457–497 |
| NPathComplexity | The method 'findTemplateFor(DisplayType)' has an NPath complexity of 384 | 3 | 457–497 |
| NPathComplexity | The method 'setQuestionVisibility(List, DisplayType)' has an NPath complexity of 576 | 3 | 532–576 |
| CyclomaticComplexity | The method 'setQuestionVisibility(List, DisplayType)' has a cyclomatic complexity of 11. | 3 | 532–576 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 637 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 38–112 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'java.time.LocalDateTime' | 4 | 37 |
| GodClass | Possible God Class (WMC=49, ATFD=34, TCC=26.667%) | 3 | 54–429 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 55–429 |
| FieldNamingConventions | The final field name '_listValidatedStep' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 56 |
| FieldNamingConventions | The final field name '_formResponse' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 57 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_bIsResponseLoadedFromBackup' | 3 | 58 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_isBackupResponseAlreadyInitiated' | 3 | 59 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 152 |
| CommentRequired | Public method and constructor comments are required | 3 | 157–161 |
| CommentRequired | Public method and constructor comments are required | 3 | 171–173 |
| CommentRequired | Public method and constructor comments are required | 3 | 182–184 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–377 |
| CommentRequired | Public method and constructor comments are required | 3 | 132–152 |
| CommentRequired | Public method and constructor comments are required | 3 | 155–196 |
| UseDiamondOperator | Explicit type arguments can be replaced by Diamond Operator | 3 | 159 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 198 |
| CommentRequired | Public method and constructor comments are required | 3 | 199–250 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 208 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 227 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 260 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 264 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 342–349 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–1470 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.genericattributes.business.ResponseHome' | 4 | 44 |
| UnusedImports | Avoid unused imports such as 'org.apache.james.mime4j.dom.datetime.DateTime' | 4 | 90 |
| ExcessiveClassLength | Avoid really long classes. | 3 | 98–1470 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 99–1470 |
| ImmutableField | Private field '_captchaSecurityService' could be made final; it is only initialized in the declaration or constructor. | 3 | 154 |
| RedundantFieldInitializer | Avoid using redundant field initializer for 'IsRequestComingFromAction' | 3 | 161 |
| FieldNamingConventions | The field name 'IsRequestComingFromAction' doesn't match '_[a-z][a-zA-Z0-9]*' | 1 | 161 |
| PreserveStackTrace | New exception is thrown in catch block, original stack trace may be lost | 3 | 215 |
| CyclomaticComplexity | The method 'checkMyLuteceAuthentification(Form, HttpServletRequest)' has a cyclomatic complexity of 11. | 3 | 229–258 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 271 |
| NPathComplexity | The method 'getStepView(HttpServletRequest)' has an NPath complexity of 184608 | 3 | 272–395 |
| NcssCount | The method 'getStepView(HttpServletRequest)' has a NCSS line count of 63. | 3 | 272–395 |
| ExcessiveMethodLength | Avoid really long methods. | 3 | 272–395 |
| CyclomaticComplexity | The method 'getStepView(HttpServletRequest)' has a cyclomatic complexity of 29. | 3 | 272–395 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 272–395 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 308–310 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 311 |
| AvoidDuplicateLiterals | The String literal "action_" appears 4 times in this file; the first occurrence is on line 326 | 3 | 326 |
| LinguisticNaming | Linguistics Antipattern - The getter 'getFormStepModel' should not return void linguistically | 3 | 448–466 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 478 |
| CyclomaticComplexity | The method 'doReturnStep(HttpServletRequest)' has a cyclomatic complexity of 10. | 3 | 479–524 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 479–524 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 482 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 519 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 536 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 537–578 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 541 |
| EmptyCatchBlock | Avoid empty catch blocks | 3 | 566–569 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 590 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 591–623 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 690 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 691–728 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 742 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 743–780 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 854–868 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 944 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 945–1000 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 953 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 960 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 990 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 1023 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 1024–1083 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 1098 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 1099–1135 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1130 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 1148 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 1149–1183 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 1196 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 1197–1232 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 1245 |
| CyclomaticComplexity | The method 'doSynchronousUploadDocument(HttpServletRequest)' has a cyclomatic complexity of 10. | 3 | 1246–1334 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 1246–1334 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 1265 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 1300–1330 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 1345–1352 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1403 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1404 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1405 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1406 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1420 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1421 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1422 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1423 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1437 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1438 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 1439 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 67–127 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 99 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 116 |
| ShortVariable | Avoid variables with short names like t | 3 | 122 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Public method and constructor comments are required | 3 | 153 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.api.user.User' | 4 | 46 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.admin.AdminUserService' | 4 | 61 |
| FieldNamingConventions | The final field name '_listChildren' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 92 |
| FieldNamingConventions | The final field name '_listICompositeDisplay' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 93 |
| FieldNamingConventions | The final field name '_formResponse' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 96 |
| FieldNamingConventions | The final field name '_mapStepResponses' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 97 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 97 |
| FieldNamingConventions | The final field name '_model' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 99 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 99 |
| ImmutableField | Private field '_captchaSecurityService' could be made final; it is only initialized in the declaration or constructor. | 3 | 100 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 270 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 298–311 |
| CyclomaticComplexity | The method 'findTemplateFor(DisplayType)' has a cyclomatic complexity of 10. | 3 | 331–375 |
| NPathComplexity | The method 'findTemplateFor(DisplayType)' has an NPath complexity of 512 | 3 | 331–375 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 191 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–922 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.image.ImageResourceManager' | 4 | 77 |
| CyclomaticComplexity | The class 'AbstractFormQuestionJspBean' has a total cyclomatic complexity of 111 (highest 21). | 3 | 82–922 |
| CommentRequired | Header comments are required | 3 | 82–922 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 83–922 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_nIdParentSelected' | 3 | 171 |
| NPathComplexity | The method 'processQuestionCreation(HttpServletRequest, String)' has an NPath complexity of 576 | 3 | 182–260 |
| CyclomaticComplexity | The method 'processQuestionCreation(HttpServletRequest, String)' has a cyclomatic complexity of 12. | 3 | 182–260 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 185 |
| CyclomaticComplexity | The method 'processQuestionUpdate(HttpServletRequest)' has a cyclomatic complexity of 12. | 3 | 269–332 |
| NPathComplexity | The method 'processQuestionUpdate(HttpServletRequest)' has an NPath complexity of 288 | 3 | 269–332 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 310–319 |
| CommentRequired | Protected method constructor comments are required | 3 | 334–379 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 344 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 356–375 |
| CommentRequired | Protected method constructor comments are required | 3 | 381–410 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 390 |
| CommentRequired | Protected method constructor comments are required | 3 | 412–437 |
| CommentRequired | Protected method constructor comments are required | 3 | 439–464 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 442 |
| CommentRequired | Protected method constructor comments are required | 3 | 466–517 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 469 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 492 |
| CommentRequired | Protected method constructor comments are required | 3 | 519–599 |
| CyclomaticComplexity | The method 'initModifyQuestionModel(HttpServletRequest)' has a cyclomatic complexity of 10. | 3 | 519–599 |
| AvoidReassigningLoopVariables | Avoid reassigning the loop control variable 'field' | 3 | 549 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 557 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 583 |
| ExcessiveMethodLength | Avoid really long methods. | 3 | 601–714 |
| CyclomaticComplexity | The method 'initMoveCompositeModel(HttpServletRequest)' has a cyclomatic complexity of 21. | 3 | 601–714 |
| NcssCount | The method 'initMoveCompositeModel(HttpServletRequest)' has a NCSS line count of 62. | 3 | 601–714 |
| CommentRequired | Protected method constructor comments are required | 3 | 601–714 |
| NPathComplexity | The method 'initMoveCompositeModel(HttpServletRequest)' has an NPath complexity of 103680 | 3 | 601–714 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 603 |
| CommentRequired | Protected method constructor comments are required | 3 | 910 |
| CommentRequired | Protected method constructor comments are required | 3 | 921 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Protected method constructor comments are required | 3 | 89–95 |
| UseObjectForClearerAPI | Rather than using a lot of String arguments, consider using a container object for those values. | 3 | 233 |
| CommentRequired | Protected method constructor comments are required | 3 | 247–255 |
| CommentRequired | Protected method constructor comments are required | 3 | 257–263 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_uploadHandler' could be made final; it is only initialized in the declaration or constructor. | 3 | 109 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–828 |
| FieldNamingConventions | The final field name '_nDefaultItemsPerPage' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 151 |
| UseLocaleWithCaseConversions | When doing a String.toLowerCase()/toUpperCase() call, use a Locale | 3 | 326 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 329 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 330 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'controlGroup' | 2 | 339 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'controlGroup' | 2 | 339 |
| AvoidReassigningParameters | Avoid reassigning parameters such as 'controlGroup' | 2 | 339 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 342–349 |
| CommentRequired | Public method and constructor comments are required | 3 | 362–394 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 383–390 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 424–431 |
| CyclomaticComplexity | The method 'buildControlModel(HttpServletRequest, Map)' has a cyclomatic complexity of 31. | 3 | 444–573 |
| NPathComplexity | The method 'buildControlModel(HttpServletRequest, Map)' has an NPath complexity of 645120 | 3 | 444–573 |
| NcssCount | The method 'buildControlModel(HttpServletRequest, Map)' has a NCSS line count of 77. | 3 | 444–573 |
| ExcessiveMethodLength | Avoid really long methods. | 3 | 444–573 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 496–503 |
| ShortVariable | Avoid variables with short names like q | 3 | 520 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 558 |
| UseEqualsToCompareStrings | Use equals() to compare strings instead of '==' or '!=' | 3 | 558 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 660–674 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 728 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 767 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 768 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 769 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 771 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 772 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 773 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 64–439 |
| CommentRequired | Public method and constructor comments are required | 3 | 107–148 |
| CommentRequired | Public method and constructor comments are required | 3 | 151–185 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 152 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 153 |
| LinguisticNaming | Linguistics Antipattern - The variable 'isOrderExportDecrementing' indicates linguistically it is a boolean, but it is 'int' | 3 | 167 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 180 |
| CommentRequired | Public method and constructor comments are required | 3 | 188–228 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 189 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 223 |
| CommentRequired | Public method and constructor comments are required | 3 | 231–263 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 241 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 259 |
| CommentRequired | Public method and constructor comments are required | 3 | 266–296 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 268 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 280 |
| CommentRequired | Public method and constructor comments are required | 3 | 299–334 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 301 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 312 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 330 |
| CommentRequired | Public method and constructor comments are required | 3 | 337–372 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 344 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 368 |
| CommentRequired | Public method and constructor comments are required | 3 | 375–410 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 382 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 406 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 418 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 428–430 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 433 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–889 |
| FieldNamingConventions | The final field name '_nDefaultItemsPerPage' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 206 |
| ImmutableField | Private field '_captchaSecurityService' could be made final; it is only initialized in the declaration or constructor. | 3 | 212 |
| ImmutableField | Private field '_uploadHandler' could be made final; it is only initialized in the declaration or constructor. | 3 | 213 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 293 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 294 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 546–554 |
| CommentRequired | Public method and constructor comments are required | 3 | 588–617 |
| CommentRequired | Public method and constructor comments are required | 3 | 848–869 |
| CommentRequired | Public method and constructor comments are required | 3 | 872–888 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 69–250 |
| CommentRequired | Public method and constructor comments are required | 3 | 110–153 |
| CommentRequired | Public method and constructor comments are required | 3 | 156–190 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 186 |
| CommentRequired | Public method and constructor comments are required | 3 | 193–225 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 221 |
| CommentRequired | Public method and constructor comments are required | 3 | 228–249 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 230 |
| ForLoopCanBeForeach | This for loop can be replaced by a foreach loop | 3 | 240–242 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 245 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–790 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 96–790 |
| FieldNamingConventions | The constant name '_formService' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 133 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 184 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 214 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 258 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 315–322 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 352–354 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 372 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 376 |
| ControlStatementBraces | This statement should have braces | 3 | 393 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 423–430 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 483 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 493–500 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 504 |
| CommentRequired | Public method and constructor comments are required | 3 | 505–526 |
| ShortVariable | Avoid variables with short names like id | 3 | 508 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 522 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 535 |
| NPathComplexity | The method 'getConfirmRemoveComposite(HttpServletRequest)' has an NPath complexity of 972 | 3 | 536–595 |
| CyclomaticComplexity | The method 'getConfirmRemoveComposite(HttpServletRequest)' has a cyclomatic complexity of 15. | 3 | 536–595 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 569–583 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 691 |
| NPathComplexity | The method 'doMoveComposite(HttpServletRequest)' has an NPath complexity of 864 | 3 | 716–777 |
| CyclomaticComplexity | The method 'doMoveComposite(HttpServletRequest)' has a cyclomatic complexity of 12. | 3 | 716–777 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 748 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–755 |
| CommentRequired | Header comments are required | 3 | 74–755 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 75–755 |
| ImmutableField | Private field '_controller' could be made final; it is only initialized in the declaration or constructor. | 3 | 113 |
| ImmutableField | Private field '_formService' could be made final; it is only initialized in the declaration or constructor. | 3 | 114 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 128 |
| CyclomaticComplexity | The method 'getStepView(HttpServletRequest)' has a cyclomatic complexity of 17. | 3 | 129–224 |
| NPathComplexity | The method 'getStepView(HttpServletRequest)' has an NPath complexity of 1216 | 3 | 129–224 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 233 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 247 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 264 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 275 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 298 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 325 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 353 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 381 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 407 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 442 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 443–457 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 466 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 467–487 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 496 |
| AvoidSynchronizedAtMethodLevel | Use block level rather than method level synchronization | 3 | 497–529 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 514–522 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 524 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 539 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 540 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 541 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 542 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 555 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 556 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 557 |
| LinguisticNaming | Linguistics Antipattern - The getter 'getFormStepModel' should not return void linguistically | 3 | 652–662 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 699–713 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–675 |
| FieldNamingConventions | The constant name '_stepService' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 155 |
| FieldNamingConventions | The final field name '_nDefaultItemsPerPage' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 161 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 252 |
| CyclomaticComplexity | The method 'doCreateStep(HttpServletRequest)' has a cyclomatic complexity of 10. | 3 | 290–335 |
| CyclomaticComplexity | The method 'doModifyStep(HttpServletRequest)' has a cyclomatic complexity of 11. | 3 | 524–589 |
| NPathComplexity | The method 'doModifyStep(HttpServletRequest)' has an NPath complexity of 432 | 3 | 524–589 |
| CommentRequired | Public method and constructor comments are required | 3 | 606–634 |
| CommentRequired | Public method and constructor comments are required | 3 | 637–657 |
| CommentRequired | Public method and constructor comments are required | 3 | 660–674 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–629 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 75–629 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 138 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 208 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 212–219 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 248–255 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 456–470 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 60–148 |
| CommentRequired | Public method and constructor comments are required | 3 | 85–111 |
| CommentRequired | Public method and constructor comments are required | 3 | 114–147 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 143 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–686 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 157 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 178 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 199 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 276 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 307 |
| CyclomaticComplexity | The method 'doModifyField(HttpServletRequest)' has a cyclomatic complexity of 11. | 3 | 327–390 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 329 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 331 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 333 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 334 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 353–387 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 374 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 399 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 434 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 435 |
| CyclomaticComplexity | The method 'doMoveField(HttpServletRequest, boolean)' has a cyclomatic complexity of 10. | 3 | 504–549 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 506 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 507 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 508 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 509 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 565 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 566 |
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 567 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–685 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.business.user.AdminUser' | 4 | 80 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.service.admin.AdminUserService' | 4 | 83 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 103–685 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 154 |
| FieldNamingConventions | The final field name '_formsMultiviewAuthorizationService' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 155 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 231 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 268 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 326 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 412 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 445 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 461 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 472–482 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 501 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 513 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 548 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 551 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 637–651 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 640 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 49 |
| FieldNamingConventions | The constant name '_mapValueNames' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 49 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ExcessiveImports | A high number of imports can indicate a high degree of coupling within an object. | 3 | 34–687 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 107–687 |
| ImmutableField | Private field '_uploadHandler' could be made final; it is only initialized in the declaration or constructor. | 3 | 161 |
| CyclomaticComplexity | The method 'getMultiviewFormsView(HttpServletRequest)' has a cyclomatic complexity of 10. | 3 | 171–250 |
| NPathComplexity | The method 'getMultiviewFormsView(HttpServletRequest)' has an NPath complexity of 216 | 3 | 171–250 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 311 |
| UnnecessaryAnnotationValueElement | Avoid the use of value in annotations when its the only element | 3 | 354 |
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'FormsConstants.PARAMETER_ID_FORM' due to existing static import 'fr.paris.lutece.plugins.forms.util.FormsConstants.PARAMETER_ID_FORM' | 4 | 435 |
| EmptyCatchBlock | Avoid empty catch blocks | 3 | 437–440 |
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'FormsConstants.PARAMETER_ID_FORM' due to existing static import 'fr.paris.lutece.plugins.forms.util.FormsConstants.PARAMETER_ID_FORM' | 4 | 493 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 514 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 612–619 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 633–637 |
| UnnecessaryFullyQualifiedName | Unnecessary use of fully qualified name 'FormsConstants.PARAMETER_ID_FORM' due to existing static import 'fr.paris.lutece.plugins.forms.util.FormsConstants.PARAMETER_ID_FORM' | 4 | 652 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassNamingConventions | The utility class name 'BreadcrumbManager' doesn't match '[A-Z][a-zA-Z0-9]+(Utils?|Helper|Home|Service)' | 1 | 42–67 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_strBreadcrumbBeanName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 53 |
| FieldNamingConventions | The final field name '_strBreadcrumbDisplayBeanName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 54 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 94 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.plugins.forms.business.StepHome' | 4 | 43 |
| FieldNamingConventions | The final field name '_strBreadcrumbBeanName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 56 |
| FieldNamingConventions | The final field name '_strBreadcrumbDisplayBeanName' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 57 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 97 |
| UnusedPrivateMethod | Avoid unused private methods such as 'getCurrentStepIndex(List,int)'. | 3 | 120 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_mode' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 63 |
| FieldNamingConventions | The final field name '_bIsFront' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 64 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 49–79 |
| CommentRequired | Public method and constructor comments are required | 3 | 55–58 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 68 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 3 | 62 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 3 | 86–92 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 3 | 66 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 3 | 57 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 3 | 79–84 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.business.file.FileHome' | 4 | 56 |
| UnusedImports | Avoid unused imports such as 'fr.paris.lutece.portal.business.physicalfile.PhysicalFileHome' | 4 | 58 |
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 3 | 71 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 3 | 95–101 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 3 | 57 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 3 | 79–84 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 3 | 61 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 3 | 87–98 |
| EmptyCatchBlock | Avoid empty catch blocks | 3 | 117–120 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_strEntryServiceName' could be made final; it is only initialized in the declaration or constructor. | 3 | 58 |
| LinguisticNaming | Linguistics Antipattern - The setter 'setModel' should not return any type except void linguistically | 3 | 82–88 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_strCode' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 42 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 3 | 44–47 |
| CommentRequired | Public method and constructor comments are required | 3 | 44–47 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 122 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The constant name '_singleton' doesn't match '[A-Z][A-Z_0-9]*' | 1 | 172 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ClassWithOnlyPrivateConstructorsShouldBeFinal | A class which only has private constructors should be final | 1 | 65–302 |
| AvoidDeeplyNestedIfStmts | Deeply nested if..then statements are hard to read | 3 | 191–195 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 278–297 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 284–296 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 79 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 3 | 96 |
| UseStringBufferForStringAppends | Prefer StringBuilder (non-synchronized) or StringBuffer (synchronized) over += for concatenating strings | 3 | 100 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 140 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 153 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UnusedImports | Avoid unused imports such as 'java.util.Arrays' | 4 | 36 |
| UnusedImports | Avoid unused imports such as 'java.util.List' | 4 | 38 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 73 |
| UnusedLocalVariable | Avoid unused local variables such as 'strEntryGeoJSON'. | 3 | 92 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 104 |
| UnnecessaryLocalBeforeReturn | Consider simply returning the value vs storing it in local variable 'objEntryGeoJSON' | 3 | 139 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 75 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 121 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 66 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 95 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 66 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 95 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 67 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 94 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 67 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 94 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 204 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 91 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ShortVariable | Avoid variables with short names like TO | 3 | 58 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 97 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 122 |
| ReturnEmptyArrayRatherThanNull | Return an empty array rather than null. | 1 | 170–191 |
| ShortVariable | Avoid variables with short names like m | 3 | 175 |
| AvoidCatchingGenericException | Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 3 | 185 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 99 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 112 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 138 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 140 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 149 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 152 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_formSearchEngine' could be made final; it is only initialized in the declaration or constructor. | 3 | 69 |
| CommentRequired | Public method and constructor comments are required | 3 | 71–74 |
| CallSuperInConstructor | It is a good practice to call super() in a constructor | 3 | 71–74 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 100 |
| UselessStringValueOf | No need to call String.valueOf to append to a string. | 3 | 110 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 129 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 92 |
| NullAssignment | Assigning an Object to null is a code smell. Consider refactoring. | 3 | 101 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 128–144 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 139 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_nIdFormResponse' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 45 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| GodClass | Possible God Class (WMC=53, ATFD=42, TCC=0.735%) | 3 | 69–522 |
| TooManyMethods | This class has too many methods, consider refactoring it. | 3 | 70–522 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 132 |
| AvoidLiteralsInIfCondition | Avoid using Literals in Conditional Statements | 3 | 231 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 235 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 236 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 241 |
| UnusedFormalParameter | Avoid unused method parameters such as 'strRedirectionDetailsBaseUrl'. | 3 | 264 |
| UnusedFormalParameter | Avoid unused method parameters such as 'formColumnlineTemplate'. | 3 | 264 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 270–277 |
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 282 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| UseConcurrentHashMap | If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 3 | 219 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 43–55 |
| CommentRequired | Protected method constructor comments are required | 3 | 54 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| FieldNamingConventions | The final field name '_listFormResponseViewModelProcessor' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 46 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| ImmutableField | Private field '_strIterationParameterName' could be made final; it is only initialized in the declaration or constructor. | 3 | 52 |
| MissingOverride | The method 'getParameterValues(String)' is missing an @Override annotation. | 3 | 72–75 |
| MethodReturnsInternalArray | Returning '_strIterationParameterName' may expose an internal array. | 3 | 74 |
| MissingOverride | The method 'getParameter(String)' is missing an @Override annotation. | 3 | 80–83 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| CommentRequired | Header comments are required | 3 | 43–98 |
| FieldNamingConventions | The final field name '_modifiableParameters' doesn't match '[a-z][a-zA-Z0-9]*' | 1 | 45 |
| RedundantFieldInitializer | Avoid using redundant field initializer for '_allParameters' | 3 | 46 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| PrematureDeclaration | Avoid declaring a variable if it is unreferenced before a possible exit point. | 3 | 118 |
| Rule | Violation | Priority | Line |
|---|---|---|---|
| MissingSerialVersionUID | Classes implementing Serializable should set a serialVersionUID | 3 | 52–130 |
| ConfusingTernary | Avoid if (x != y) ..; else ..; | 3 | 98–107 |
| LooseCoupling | Avoid using implementation types like 'HashMap'; use the interface instead | 3 | 121 |
