The following document contains the results of PMD 5.3.5.
| Violation | Line |
|---|---|
| Possible God class (WMC=54, ATFD=59, TCC=0.0) | 34–475 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–475 |
| The class 'BaseAuthentication' has a Cyclomatic Complexity of 2 (Highest = 21). | 92–475 |
| The class 'BaseAuthentication' has a Standard Cyclomatic Complexity of 2 (Highest = 14). | 92–475 |
| The class 'BaseAuthentication' has a Modified Cyclomatic Complexity of 2 (Highest = 14). | 92–475 |
| Avoid really long methods. | 147–251 |
| The method 'login' has a Modified Cyclomatic Complexity of 14. | 147–251 |
| The method login() has an NPath complexity of 5346 | 147–251 |
| The method 'login' has a Cyclomatic Complexity of 21. | 147–251 |
| The method 'login' has a Standard Cyclomatic Complexity of 14. | 147–251 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 155 |
| Unnecessary use of fully qualified name 'java.sql.Timestamp' due to existing import 'java.sql.Timestamp' | 155 |
| Deeply nested if..then statements are hard to read | 179–186 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 243 |
| Document empty method | 258–259 |
| Singleton is not thread safe | 429–432 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 460 |
| Violation | Line |
|---|---|
| Avoid unused imports such as 'fr.paris.lutece.util.sql.DAOUtil' | 37 |
| Avoid unused imports such as 'fr.paris.lutece.util.sql.DAOUtil' | 37 |
| Violation | Line |
|---|---|
| These nested if statements could be combined | 109–113 |
| Violation | Line |
|---|---|
| Avoid unused imports such as 'java.util.Date' | 56 |
| Avoid unused imports such as 'java.util.Date' | 56 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 86 |
| Avoid using Literals in Conditional Statements | 91 |
| Violation | Line |
|---|---|
| Possible God class (WMC=61, ATFD=81, TCC=0.008547008547008548) | 34–647 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 519 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 547 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 574 |
| Violation | Line |
|---|---|
| Possible God class (WMC=47, ATFD=18, TCC=0.004301075268817204) | 34–553 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 193 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 207 |
| Avoid using Literals in Conditional Statements | 297 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 333 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 351 |
| Unnecessary use of fully qualified name 'java.sql.Timestamp' due to existing import 'java.sql.Timestamp' | 550 |
| Violation | Line |
|---|---|
| Avoid unnecessary if..then..else statements when returning booleans | 67–70 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 67 |
| Violation | Line |
|---|---|
| Avoid modifiers which are implied by the context | 81 |
| Violation | Line |
|---|---|
| Consider simply returning the value vs storing it in local variable 'nValue' | 111 |
| Violation | Line |
|---|---|
| Avoid modifiers which are implied by the context | 84 |
| The String literal "mylutece-directory.transactionManager" appears 8 times in this file; the first occurrence is on line 251 | 251 |
| Violation | Line |
|---|---|
| Use explicit scoping instead of the default package private level | 50–51 |
| Violation | Line |
|---|---|
| Private field 'listMailEntryId' could be made final; it is only initialized in the declaration or constructor. | 89 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 232 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 233 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 234 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 235 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 236 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 237 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 238 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 239 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 240 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 257 |
| Avoid variables with short names like i | 266 |
| Violation | Line |
|---|---|
| Use explicit scoping instead of the default package private level | 49–50 |
| Violation | Line |
|---|---|
| The class 'MyluteceDirectoryAnonymizationService' has a Cyclomatic Complexity of 4 (Highest = 10). | 65–165 |
| The class 'MyluteceDirectoryAnonymizationService' has a Modified Cyclomatic Complexity of 4 (Highest = 10). | 65–165 |
| The class 'MyluteceDirectoryAnonymizationService' has a Standard Cyclomatic Complexity of 4 (Highest = 10). | 65–165 |
| The method 'anonymizeUser' has a Cyclomatic Complexity of 10. | 92–155 |
| The method 'anonymizeUser' has a Modified Cyclomatic Complexity of 10. | 92–155 |
| The method 'anonymizeUser' has a Standard Cyclomatic Complexity of 10. | 92–155 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 145 |
| Violation | Line |
|---|---|
| Avoid variables with short names like rt | 62 |
| Avoid variables with short names like p | 67 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–920 |
| Possible God class (WMC=93, ATFD=128, TCC=0.01282051282051282) | 34–920 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 467 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 530 |
| The String literal "mylutece-directory.transactionManager" appears 10 times in this file; the first occurrence is on line 561 | 561 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 801 |
| Avoid reassigning parameters such as 'strPassword' | 832 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 865 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 896 |
| Violation | Line |
|---|---|
| A class which only has private constructors should be final | 45–64 |
| Violation | Line |
|---|---|
| Avoid modifiers which are implied by the context | 67 |
| Violation | Line |
|---|---|
| Private field '_myluteceDirectoryService' could be made final; it is only initialized in the declaration or constructor. | 66 |
| Document empty method | 98–99 |
| Violation | Line |
|---|---|
| Private field '_myluteceDirectoryService' could be made final; it is only initialized in the declaration or constructor. | 66 |
| Document empty method | 98–99 |
| Violation | Line |
|---|---|
| Private field '_mapErrors' could be made final; it is only initialized in the declaration or constructor. | 49 |
| Private field '_mapLastValues' could be made final; it is only initialized in the declaration or constructor. | 50 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–1434 |
| Possible God class (WMC=150, ATFD=295, TCC=0.2045977011494253) | 34–1434 |
| Avoid unused imports such as 'java.util.regex.Matcher' | 44 |
| Avoid unused imports such as 'java.util.regex.Matcher' | 44 |
| Avoid unused imports such as 'java.util.regex.Pattern' | 45 |
| Avoid unused imports such as 'java.util.regex.Pattern' | 45 |
| No need to import a type that lives in the same package | 75 |
| The class 'MyLuteceDirectoryApp' has a Standard Cyclomatic Complexity of 4 (Highest = 19). | 110–1434 |
| The class 'MyLuteceDirectoryApp' has a Cyclomatic Complexity of 5 (Highest = 21). | 110–1434 |
| Avoid really long classes. | 110–1434 |
| The class 'MyLuteceDirectoryApp' has a Modified Cyclomatic Complexity of 4 (Highest = 19). | 110–1434 |
| Avoid unused private fields such as 'PARAMETER_ACTION_MODIFY_ACCOUNT'. | 158 |
| Avoid unused private fields such as 'ERROR_LOGIN_ACCENTS_OR_BLANK'. | 183 |
| Avoid unused private fields such as 'PROPERTY_ERROR_LOGIN_ACCENTS'. | 241 |
| Private field '_myluteceDirectoryService' could be made final; it is only initialized in the declaration or constructor. | 271 |
| Private field '_securityService' could be made final; it is only initialized in the declaration or constructor. | 272 |
| Private field '_attributeMappingService' could be made final; it is only initialized in the declaration or constructor. | 273 |
| Private field '_userKeyService' could be made final; it is only initialized in the declaration or constructor. | 274 |
| Private field '_parameterService' could be made final; it is only initialized in the declaration or constructor. | 275 |
| Private field '_recordService' could be made final; it is only initialized in the declaration or constructor. | 276 |
| The method 'getPage' has a Modified Cyclomatic Complexity of 12. | 301–361 |
| The method 'getPage' has a Standard Cyclomatic Complexity of 12. | 301–361 |
| The method 'getPage' has a Cyclomatic Complexity of 16. | 301–361 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 469 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 469 |
| Avoid variables with short names like t | 489 |
| Avoid reassigning parameters such as 'formErrors' | 513 |
| The method 'getCreateAccountPage' has a Cyclomatic Complexity of 11. | 513–592 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 516 |
| Avoid variables with short names like t | 586 |
| The method 'doCreateAccount' has a Modified Cyclomatic Complexity of 19. | 599–771 |
| The method doCreateAccount() has an NPath complexity of 419328 | 599–771 |
| Avoid really long methods. | 599–771 |
| The method 'doCreateAccount' has a Cyclomatic Complexity of 21. | 599–771 |
| The method 'doCreateAccount' has a Standard Cyclomatic Complexity of 19. | 599–771 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 716 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 754 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 781 |
| Avoid variables with short names like t | 791 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 807 |
| Avoid variables with short names like t | 817 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 852 |
| Avoid variables with short names like t | 866 |
| The method 'doModifyAccount' has a Cyclomatic Complexity of 18. | 879–999 |
| Avoid really long methods. | 879–999 |
| The method 'doModifyAccount' has a Modified Cyclomatic Complexity of 14. | 879–999 |
| The method 'doModifyAccount' has a Standard Cyclomatic Complexity of 14. | 879–999 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 883 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 889 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 891 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 892 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 893 |
| The method 'doSendPassword' has a Modified Cyclomatic Complexity of 12. | 1026–1129 |
| The method 'doSendPassword' has a Standard Cyclomatic Complexity of 12. | 1026–1129 |
| Avoid really long methods. | 1026–1129 |
| The method 'doSendPassword' has a Cyclomatic Complexity of 18. | 1026–1129 |
| The method doSendPassword() has an NPath complexity of 4140 | 1026–1129 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1031 |
| The method 'doSendLogin' has a Cyclomatic Complexity of 13. | 1137–1210 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1142 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1273 |
| Avoid variables with short names like t | 1285 |
| The method 'updateAccount' has a Cyclomatic Complexity of 12. | 1380–1428 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–641 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.workflowcore.business.action.ActionFilter' | 62 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.workflowcore.business.action.ActionFilter' | 62 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.workflowcore.service.action.ActionService' | 63 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.workflowcore.service.action.ActionService' | 63 |
| Avoid unused imports such as 'fr.paris.lutece.util.ReferenceItem' | 80 |
| Avoid unused imports such as 'fr.paris.lutece.util.ReferenceItem' | 80 |
| The class 'MyluteceDirectoryJspBean' has a Standard Cyclomatic Complexity of 4 (Highest = 10). | 90–641 |
| The class 'MyluteceDirectoryJspBean' has a Modified Cyclomatic Complexity of 4 (Highest = 10). | 90–641 |
| The class 'MyluteceDirectoryJspBean' has a Cyclomatic Complexity of 4 (Highest = 12). | 90–641 |
| Private field '_nDefaultItemsPerPage' could be made final; it is only initialized in the declaration or constructor. | 152 |
| Private field '_myluteceDirectoryService' could be made final; it is only initialized in the declaration or constructor. | 156 |
| Private field '_attributeMappingService' could be made final; it is only initialized in the declaration or constructor. | 157 |
| It is a good practice to call super() in a constructor | 162–164 |
| Avoid unnecessary constructors - the compiler will generate these for you | 162–164 |
| Document empty constructor | 162–164 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 194 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 201 |
| The method 'getManageMappings' has a Cyclomatic Complexity of 12. | 225–313 |
| The method 'getManageMappings' has a Standard Cyclomatic Complexity of 10. | 225–313 |
| The method getManageMappings() has an NPath complexity of 390 | 225–313 |
| The method 'getManageMappings' has a Modified Cyclomatic Complexity of 10. | 225–313 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 245 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 285 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 334 |
| These nested if statements could be combined | 350–353 |
| Avoid empty catch blocks | 404–406 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 429 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 504 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 520 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 557 |
| Violation | Line |
|---|---|
| Possible God class (WMC=146, ATFD=279, TCC=0.2962962962962963) | 34–1547 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–1547 |
| The class 'MyluteceDirectoryUserJspBean' has a Modified Cyclomatic Complexity of 4 (Highest = 14). | 104–1547 |
| The class 'MyluteceDirectoryUserJspBean' has a Standard Cyclomatic Complexity of 4 (Highest = 14). | 104–1547 |
| Avoid really long classes. | 104–1547 |
| The class 'MyluteceDirectoryUserJspBean' has a Cyclomatic Complexity of 5 (Highest = 21). | 104–1547 |
| Avoid excessively long variable names like PROPERTY_MESSAGE_CONFIRM_MODIFY_PASSWORD_ENCRYPTION | 142 |
| Private field '_nDefaultItemsPerPage' could be made final; it is only initialized in the declaration or constructor. | 266 |
| Avoid using implementation types like 'HashMap'; use the interface instead | 269 |
| Avoid using implementation types like 'HashMap'; use the interface instead | 269 |
| Private field '_myluteceDirectoryService' could be made final; it is only initialized in the declaration or constructor. | 270 |
| Private field '_parameterService' could be made final; it is only initialized in the declaration or constructor. | 271 |
| Private field '_anonymizationService' could be made final; it is only initialized in the declaration or constructor. | 272 |
| Document empty constructor | 278–280 |
| It is a good practice to call super() in a constructor | 278–280 |
| Avoid unnecessary constructors - the compiler will generate these for you | 278–280 |
| Avoid really long methods. | 289–440 |
| The method getManageRecords() has an NPath complexity of 676 | 289–440 |
| The method 'getManageRecords' has a Standard Cyclomatic Complexity of 13. | 289–440 |
| The method 'getManageRecords' has a Modified Cyclomatic Complexity of 13. | 289–440 |
| The method 'getManageRecords' has a Cyclomatic Complexity of 14. | 289–440 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 294 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 302 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 317 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 401 |
| The method getModifyUser() has an NPath complexity of 225 | 449–503 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 463 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 470 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 481 |
| The method 'doCreateUser' has a Cyclomatic Complexity of 11. | 559–617 |
| The method doCreateUser() has an NPath complexity of 600 | 559–617 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 564 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 580 |
| Avoid really long methods. | 625–747 |
| The method 'doModifyUser' has a Modified Cyclomatic Complexity of 14. | 625–747 |
| The method 'doModifyUser' has a Cyclomatic Complexity of 21. | 625–747 |
| The method doModifyUser() has an NPath complexity of 11880 | 625–747 |
| The method 'doModifyUser' has a Standard Cyclomatic Complexity of 14. | 625–747 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 630 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 633 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 642–643 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 833 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 887 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 916 |
| Assigning an Object to null is a code smell. Consider refactoring. | 975 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1210 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 1294 |
| The method 'getModifyAccountLifeTimeEmails' has a Cyclomatic Complexity of 14. | 1333–1440 |
| The method 'getModifyAccountLifeTimeEmails' has a Standard Cyclomatic Complexity of 14. | 1333–1440 |
| The method getModifyAccountLifeTimeEmails() has an NPath complexity of 300 | 1333–1440 |
| Avoid really long methods. | 1333–1440 |
| The method 'getModifyAccountLifeTimeEmails' has a Modified Cyclomatic Complexity of 14. | 1333–1440 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 1337 |
| The method 'doModifyAccountLifeTimeEmails' has a Modified Cyclomatic Complexity of 12. | 1447–1532 |
| The method 'doModifyAccountLifeTimeEmails' has a Standard Cyclomatic Complexity of 12. | 1447–1532 |
| The method 'doModifyAccountLifeTimeEmails' has a Cyclomatic Complexity of 12. | 1447–1532 |
