The following document contains the results of PMD 5.5.1.
| Violation | Line |
|---|---|
| Overriding method merely calls super | 51–54 |
| Violation | Line |
|---|---|
| Avoid variables with short names like id | 81 |
| Violation | Line |
|---|---|
| Avoid variables with short names like id | 69 |
| Violation | Line |
|---|---|
| Abstract classes should be named AbstractXXX | 45–49 |
| This abstract class does not have any abstract methods | 45–49 |
| No abstract method which means that the keyword is most likely used to prevent instantiation. Use a private or protected constructor instead. | 45–49 |
| Use of modifier volatile is not recommended. | 47 |
| Use of modifier volatile is not recommended. | 48 |
| Violation | Line |
|---|---|
| Avoid variables with short names like p | 76 |
| Violation | Line |
|---|---|
| Use of modifier volatile is not recommended. | 50 |
| Avoid using redundant field initializer for '_singleton' | 50 |
| It is a good practice to call super() in a constructor | 55–61 |
| Avoid unnecessary constructors - the compiler will generate these for you | 55–61 |
| Singleton is not thread safe | 91–94 |
| Violation | Line |
|---|---|
| Avoid modifiers which are implied by the context | 48 |
| Avoid modifiers which are implied by the context | 54 |
| Avoid modifiers which are implied by the context | 60 |
| Avoid modifiers which are implied by the context | 66 |
| Violation | Line |
|---|---|
| Private field '_showService' could be made final; it is only initialized in the declaration or constructor. | 88 |
| It is a good practice to call super() in a constructor | 93–96 |
| Assigning an Object to null is a code smell. Consider refactoring. | 162 |
| Position literals first in String comparisons | 167 |
| Position literals first in String comparisons | 187 |
| Position literals first in String comparisons | 191 |
| Position literals first in String comparisons | 191 |
| Violation | Line |
|---|---|
| Avoid variables with short names like em | 82 |
| Avoid variables with short names like cb | 83 |
| Avoid variables with short names like cq | 85 |
| Document empty method | 143–144 |
| Violation | Line |
|---|---|
| When instantiating a SimpleDateFormat object, specify a Locale | 79 |
| When instantiating a SimpleDateFormat object, specify a Locale | 119 |
| Use equals() to compare strings instead of '==' or '!=' | 119 |
| Avoid variables with short names like e | 119 |
| Static DateFormatter objects should be accessed in a synchronized manner | 137 |
| Avoid printStackTrace(); use a logger call instead. | 141 |
| Avoid using if statements without curly braces | 180–181 |
| Violation | Line |
|---|---|
| Avoid unused private fields such as 'BEAN_STOCK_TICKETS_SHOW_SERVICE'. | 61 |
| Violation | Line |
|---|---|
| Private field '_purchaseSessionManager' could be made final; it is only initialized in the declaration or constructor. | 50 |
| Use block level rather than method level synchronization | 56–67 |
| Violation | Line |
|---|---|
| Avoid variables with short names like id | 63 |
| Violation | Line |
|---|---|
| Avoid variables with short names like ID | 47 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–472 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 118 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 158 |
| Avoid variables with short names like ve | 160 |
| Avoid variables with short names like fe | 206 |
| Avoid variables with short names like e | 223 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 225 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 225 |
| Avoid variables with short names like e | 295 |
| Assigning an Object to null is a code smell. Consider refactoring. | 327 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 418 |
| These nested if statements could be combined | 463–469 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–337 |
| This abstract class does not have any abstract methods | 75–337 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 129 |
| Avoid variables with short names like ve | 131 |
| Avoid variables with short names like e | 213 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 215 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 215 |
| Avoid variables with short names like e | 263 |
| Avoid variables with short names like fe | 279 |
| Prefer StringBuffer over += for concatenating strings | 331 |
| Violation | Line |
|---|---|
| Avoid unused private fields such as 'BEAN_STOCK_TICKETS_SHOW_SERVICE'. | 68 |
| Private field '_ratingProductService' could be made final; it is only initialized in the declaration or constructor. | 81 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 116 |
| Violation | Line |
|---|---|
| StringBuffer constructor is initialized with size 16, but has at least 43 characters appended. | 84 |
| Avoid concatenating nonliterals in a StringBuffer/StringBuilder constructor or append(). | 96 |
| StringBuffer (or StringBuilder).append is called consecutively without reusing the target variable. | 123 |
| debug logging that involves string concatenation should be guarded with isDebugEnabled() checks | 131 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–464 |
| Private field '_serviceCategory' could be made final; it is only initialized in the declaration or constructor. | 147 |
| Private field '_serviceShow' could be made final; it is only initialized in the declaration or constructor. | 155 |
| It is a good practice to call super() in a constructor | 160–166 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 199 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 234 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 268 |
| Avoid variables with short names like fe | 270 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 410 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–458 |
| Possible God class (WMC=47, ATFD=98, TCC=0.0) | 34–458 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.attribute.product.ProductAttributeNum' | 37 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.attribute.product.ProductAttributeNum' | 37 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.attribute.purchase.PurchaseAttribute' | 38 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.attribute.purchase.PurchaseAttribute' | 38 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.offer.Offer' | 39 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.offer.Offer' | 39 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.product.ProductFilter' | 41 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.product.ProductFilter' | 41 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.provider.Provider' | 42 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.provider.Provider' | 42 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.provider.ProviderFilter' | 43 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.provider.ProviderFilter' | 43 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.purchase.Purchase' | 44 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.purchase.Purchase' | 44 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.commons.ResultList' | 46 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.commons.ResultList' | 46 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.modules.tickets.business' | 49 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.modules.tickets.service' | 50 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.service.IProductService' | 53 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.service.IProductService' | 53 |
| Avoid unused imports such as 'javax.inject.Inject' | 69 |
| Avoid unused imports such as 'javax.inject.Inject' | 69 |
| Avoid unused imports such as 'javax.inject.Named' | 70 |
| Avoid unused imports such as 'javax.inject.Named' | 70 |
| Avoid unused imports such as 'java.util.stream.Collectors.mapping' | 75 |
| Avoid unused imports such as 'java.util.stream.Collectors.mapping' | 75 |
| The class 'NotificationJspBean' has a Modified Cyclomatic Complexity of 9 (Highest = 26). | 80–458 |
| The class 'NotificationJspBean' has a Cyclomatic Complexity of 12 (Highest = 38). | 80–458 |
| The class 'NotificationJspBean' has a Standard Cyclomatic Complexity of 9 (Highest = 26). | 80–458 |
| Private field '_serviceOffer' could be made final; it is only initialized in the declaration or constructor. | 126 |
| Private field '_servicePurchase' could be made final; it is only initialized in the declaration or constructor. | 127 |
| Private field '_serviceNotification' could be made final; it is only initialized in the declaration or constructor. | 128 |
| Private field '_serviceProvider' could be made final; it is only initialized in the declaration or constructor. | 129 |
| Private field '_serviceShow' could be made final; it is only initialized in the declaration or constructor. | 130 |
| Avoid unused private fields such as '_daoPurchase'. | 133 |
| Perhaps '_daoPurchase' could be replaced by a local variable. | 133 |
| Private field '_daoPurchase' could be made final; it is only initialized in the declaration or constructor. | 133 |
| The method 'getSendNotification' has a Cyclomatic Complexity of 38. | 156–393 |
| Avoid really long methods. | 156–393 |
| The method getSendNotification() has an NCSS line count of 116 | 156–393 |
| The method getSendNotification() has an NPath complexity of 11242 | 156–393 |
| The method 'getSendNotification' has a Modified Cyclomatic Complexity of 26. | 156–393 |
| The method 'getSendNotification' has a Standard Cyclomatic Complexity of 26. | 156–393 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 159 |
| Avoid variables with short names like ve | 162 |
| Avoid variables with short names like e | 183 |
| Avoid variables with short names like e | 184 |
| Avoid variables with short names like e | 185 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 245 |
| Deeply nested if..then statements are hard to read | 277–289 |
| Avoid appending characters as strings in StringBuffer.append. | 285 |
| Deeply nested if..then statements are hard to read | 294–301 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 314 |
| Avoid variables with short names like e | 371 |
| Violation | Line |
|---|---|
| Possible God class (WMC=94, ATFD=197, TCC=0.19117647058823528) | 34–1080 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–1080 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.product.ProductFilter' | 39 |
| Avoid unused imports such as 'fr.paris.lutece.plugins.stock.business.product.ProductFilter' | 39 |
| Avoid unused imports such as 'java.util.Optional' | 90 |
| Avoid unused imports such as 'java.util.Optional' | 90 |
| The class 'OfferJspBean' has a Modified Cyclomatic Complexity of 5 (Highest = 25). | 100–1080 |
| The class 'OfferJspBean' has a Standard Cyclomatic Complexity of 5 (Highest = 25). | 100–1080 |
| The class 'OfferJspBean' has a Cyclomatic Complexity of 5 (Highest = 26). | 100–1080 |
| Private field '_serviceOffer' could be made final; it is only initialized in the declaration or constructor. | 207 |
| Private field '_serviceProduct' could be made final; it is only initialized in the declaration or constructor. | 211 |
| Private field '_servicePartner' could be made final; it is only initialized in the declaration or constructor. | 212 |
| Private field '_servicePurchase' could be made final; it is only initialized in the declaration or constructor. | 213 |
| Private field '_serviceNotification' could be made final; it is only initialized in the declaration or constructor. | 214 |
| Private field '_subscriptionProductService' could be made final; it is only initialized in the declaration or constructor. | 215 |
| Private field '_purchaseSessionManager' could be made final; it is only initialized in the declaration or constructor. | 216 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 317 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 388 |
| The method 'getSaveOffer' has a Cyclomatic Complexity of 17. | 423–566 |
| The method 'getSaveOffer' has a Modified Cyclomatic Complexity of 13. | 423–566 |
| The method 'getSaveOffer' has a Standard Cyclomatic Complexity of 13. | 423–566 |
| Avoid really long methods. | 423–566 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 426 |
| Avoid variables with short names like ve | 430 |
| Avoid unused local variables such as 'idProvider'. | 453 |
| Position literals first in String comparisons | 498 |
| Avoid variables with short names like e | 571 |
| Avoid variables with short names like e | 572 |
| Avoid variables with short names like e | 573 |
| Avoid variables with short names like e | 576 |
| Avoid unused private methods such as 'getContactComboList(int)'. | 600 |
| The method doSaveOffer() has an NPath complexity of 13824 | 615–747 |
| Avoid really long methods. | 615–747 |
| The method 'doSaveOffer' has a Cyclomatic Complexity of 26. | 615–747 |
| The method 'doSaveOffer' has a Modified Cyclomatic Complexity of 25. | 615–747 |
| The method 'doSaveOffer' has a Standard Cyclomatic Complexity of 25. | 615–747 |
| These nested if statements could be combined | 718–721 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 765 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 809 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 876 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 878 |
| The method getMasseDeleteOffer() has an NPath complexity of 300 | 930–970 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 932 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 955 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 957 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 959 |
| Avoid using implementation types like 'ArrayList'; use the interface instead | 1017 |
| Avoid using implementation types like 'ArrayList'; use the interface instead | 1017 |
| Avoid variables with short names like i | 1021 |
| These nested if statements could be combined | 1036–1040 |
| Avoid variables with short names like os | 1063 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–501 |
| Private field '_serviceProvider' could be made final; it is only initialized in the declaration or constructor. | 131 |
| Private field '_serviceShow' could be made final; it is only initialized in the declaration or constructor. | 133 |
| Private field '_serviceDistrict' could be made final; it is only initialized in the declaration or constructor. | 134 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 211 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 246 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 276 |
| Avoid variables with short names like ve | 279 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 387 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 431 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 433 |
| Violation | Line |
|---|---|
| Private field '_productService' could be made final; it is only initialized in the declaration or constructor. | 73 |
| Avoid variables with short names like os | 117 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–997 |
| Avoid unused imports such as 'fr.paris.lutece.portal.service.util.AppPropertiesService' | 66 |
| Avoid unused imports such as 'fr.paris.lutece.portal.service.util.AppPropertiesService' | 66 |
| The class 'PurchaseJspBean' has a Standard Cyclomatic Complexity of 4 (Highest = 13). | 95–997 |
| The class 'PurchaseJspBean' has a Modified Cyclomatic Complexity of 4 (Highest = 13). | 95–997 |
| The class 'PurchaseJspBean' has a Cyclomatic Complexity of 4 (Highest = 15). | 95–997 |
| Private field '_servicePurchase' could be made final; it is only initialized in the declaration or constructor. | 260 |
| Private field '_serviceOffer' could be made final; it is only initialized in the declaration or constructor. | 264 |
| Private field '_purchaseSessionManager' could be made final; it is only initialized in the declaration or constructor. | 267 |
| Private field '_serviceNotification' could be made final; it is only initialized in the declaration or constructor. | 269 |
| The method 'getManagePurchases' has a Cyclomatic Complexity of 10. | 341–416 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 345 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 438 |
| The method 'getSavePurchase' has a Modified Cyclomatic Complexity of 13. | 473–608 |
| The method getSavePurchase() has an NPath complexity of 1356 | 473–608 |
| The method 'getSavePurchase' has a Cyclomatic Complexity of 15. | 473–608 |
| Avoid really long methods. | 473–608 |
| The method 'getSavePurchase' has a Standard Cyclomatic Complexity of 13. | 473–608 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 476 |
| Avoid variables with short names like ve | 484 |
| Avoid reassigning parameters such as 'actualQuantity' | 619 |
| New exception is thrown in catch block, original stack trace may be lost | 684 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 719 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 759 |
| Avoid unused local variables such as 'strJspBack'. | 759 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 803 |
| These nested if statements could be combined | 845–859 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 898 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 934 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 973 |
| Violation | Line |
|---|---|
| Possible God class (WMC=47, ATFD=127, TCC=0.14545454545454545) | 34–824 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–824 |
| The class 'ShowJspBean' has a Cyclomatic Complexity of 4 (Highest = 14). | 98–824 |
| The class 'ShowJspBean' has a Standard Cyclomatic Complexity of 4 (Highest = 11). | 98–824 |
| The class 'ShowJspBean' has a Modified Cyclomatic Complexity of 4 (Highest = 11). | 98–824 |
| Avoid unused private fields such as 'PROPERTY_POSTER_PATH'. | 171 |
| Private field '_serviceProduct' could be made final; it is only initialized in the declaration or constructor. | 232 |
| Private field '_serviceOffer' could be made final; it is only initialized in the declaration or constructor. | 237 |
| Private field '_serviceProvider' could be made final; it is only initialized in the declaration or constructor. | 241 |
| Private field '_serviceCategory' could be made final; it is only initialized in the declaration or constructor. | 245 |
| Private field '_serviceStatistic' could be made final; it is only initialized in the declaration or constructor. | 249 |
| Private field '_subscriptionProductService' could be made final; it is only initialized in the declaration or constructor. | 250 |
| It is a good practice to call super() in a constructor | 258–267 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 301 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 352 |
| The method 'getSaveProduct' has a Cyclomatic Complexity of 14. | 395–527 |
| The method 'getSaveProduct' has a Standard Cyclomatic Complexity of 11. | 395–527 |
| The method 'getSaveProduct' has a Modified Cyclomatic Complexity of 11. | 395–527 |
| Avoid really long methods. | 395–527 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 398 |
| Avoid variables with short names like fe | 400 |
| New exception is thrown in catch block, original stack trace may be lost | 640 |
| These nested if statements could be combined | 662–665 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 749 |
| Unnecessary use of fully qualified name 'java.text.SimpleDateFormat' due to existing import 'java.text.SimpleDateFormat' | 820 |
| Unnecessary use of fully qualified name 'java.util.Date' due to existing import 'java.util.Date' | 821 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–492 |
| The class 'StatisticJspBean' has a Standard Cyclomatic Complexity of 6 (Highest = 10). | 87–492 |
| The class 'StatisticJspBean' has a Cyclomatic Complexity of 7 (Highest = 11). | 87–492 |
| The class 'StatisticJspBean' has a Modified Cyclomatic Complexity of 6 (Highest = 10). | 87–492 |
| Private field '_serviceStatistic' could be made final; it is only initialized in the declaration or constructor. | 144 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 166 |
| Avoid variables with short names like t | 167 |
| The method getManageProducts() has an NPath complexity of 1200 | 179–231 |
| The method 'getManageProducts' has a Cyclomatic Complexity of 11. | 179–231 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 184 |
| These nested if statements could be combined | 193–197 |
| Avoid variables with short names like fe | 195 |
| Assigning an Object to null is a code smell. Consider refactoring. | 222 |
| Assigning an Object to null is a code smell. Consider refactoring. | 223 |
| The method getManagePurchases() has an NPath complexity of 1200 | 240–291 |
| The method 'getManagePurchases' has a Cyclomatic Complexity of 11. | 240–291 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 245 |
| These nested if statements could be combined | 254–258 |
| Avoid variables with short names like fe | 256 |
| Assigning an Object to null is a code smell. Consider refactoring. | 283 |
| Assigning an Object to null is a code smell. Consider refactoring. | 284 |
| The method 'doGenerateGraph' has a Modified Cyclomatic Complexity of 10. | 301–387 |
| The method 'doGenerateGraph' has a Standard Cyclomatic Complexity of 10. | 301–387 |
| The method 'doGenerateGraph' has a Cyclomatic Complexity of 10. | 301–387 |
| Substitute calls to size() == 0 (or size() != 0, size() > 0, size() < 1) with calls to isEmpty() | 335 |
| Avoid catching generic exceptions such as NullPointerException, RuntimeException, Exception in try-catch block | 383 |
| Avoid variables with short names like os | 456 |
| Violation | Line |
|---|---|
| Possible God class (WMC=51, ATFD=93, TCC=0.2857142857142857) | 34–655 |
| A high number of imports can indicate a high degree of coupling within an object. | 34–655 |
| The class 'StockBilletterieApp' has a Standard Cyclomatic Complexity of 7 (Highest = 27). | 95–655 |
| The class 'StockBilletterieApp' has a Cyclomatic Complexity of 7 (Highest = 32). | 95–655 |
| The class 'StockBilletterieApp' has a Modified Cyclomatic Complexity of 6 (Highest = 25). | 95–655 |
| Private field '_showService' could be made final; it is only initialized in the declaration or constructor. | 168 |
| Private field '_providerService' could be made final; it is only initialized in the declaration or constructor. | 169 |
| Private field '_offerService' could be made final; it is only initialized in the declaration or constructor. | 173 |
| Private field '_districtService' could be made final; it is only initialized in the declaration or constructor. | 175 |
| The method getShowPage() has an NPath complexity of 6850008 | 220–465 |
| The method getShowPage() has an NCSS line count of 131 | 220–465 |
| The method 'getShowPage' has a Modified Cyclomatic Complexity of 25. | 220–465 |
| Avoid really long methods. | 220–465 |
| The method 'getShowPage' has a Standard Cyclomatic Complexity of 27. | 220–465 |
| The method 'getShowPage' has a Cyclomatic Complexity of 32. | 220–465 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 241 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 243 |
| Deeply nested if..then statements are hard to read | 265–273 |
| Avoid variables with short names like fe | 307 |
| Avoid variables with short names like e | 318 |
| Position literals first in String comparisons | 402 |
| Position literals first in String comparisons | 424 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 538 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 586 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 619 |
| Violation | Line |
|---|---|
| A high number of imports can indicate a high degree of coupling within an object. | 34–878 |
| The class 'StockBilletterieReservationApp' has a Standard Cyclomatic Complexity of 5 (Highest = 18). | 96–878 |
| The class 'StockBilletterieReservationApp' has a Cyclomatic Complexity of 6 (Highest = 21). | 96–878 |
| The class 'StockBilletterieReservationApp' has a Modified Cyclomatic Complexity of 5 (Highest = 18). | 96–878 |
| Avoid unused private fields such as 'TEMPLATE_MODIFY_BOOK'. | 168 |
| Avoid empty if statements | 236–238 |
| Avoid really long methods. | 256–431 |
| The method 'getConfirmBooking' has a Cyclomatic Complexity of 21. | 256–431 |
| The method 'getConfirmBooking' has a Standard Cyclomatic Complexity of 18. | 256–431 |
| The method getConfirmBooking() has an NPath complexity of 6000 | 256–431 |
| The method 'getConfirmBooking' has a Modified Cyclomatic Complexity of 18. | 256–431 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 263 |
| Avoid variables with short names like fe | 266 |
| Avoid variables with short names like i | 296 |
| New exception is thrown in catch block, original stack trace may be lost | 340 |
| Avoid using exceptions as flow control. | 361 |
| The method 'doSaveReservation' has a Modified Cyclomatic Complexity of 10. | 444–546 |
| The method 'doSaveReservation' has a Standard Cyclomatic Complexity of 10. | 444–546 |
| The method 'doSaveReservation' has a Cyclomatic Complexity of 11. | 444–546 |
| Avoid really long methods. | 444–546 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 562 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 601 |
| Avoid declaring a variable if it is unreferenced before a possible exit point. | 602 |
| The method getMyBookings() has an NPath complexity of 375 | 650–718 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 690 |
| Prefer StringBuffer over += for concatenating strings | 701 |
| Prefer StringBuffer over += for concatenating strings | 705 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 742 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 790 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 823 |
| Position literals first in String comparisons | 871 |
| These nested if statements could be combined | 871–874 |
| Violation | Line |
|---|---|
| Avoid unused private fields such as 'JSP_PORTAL'. | 60 |
| Avoid unused private fields such as 'BEAN_STOCK_TICKETS_SHOW_SERVICE'. | 63 |
| Private field '_subscriptionProductService' could be made final; it is only initialized in the declaration or constructor. | 66 |
| Position literals first in String comparisons | 95 |
| Position literals first in String comparisons | 119 |
| Position literals first in String comparisons | 141 |
| Position literals first in String comparisons | 161 |
| Avoid appending characters as strings in StringBuffer.append. | 166 |
| Avoid appending characters as strings in StringBuffer.append. | 168 |
| Position literals first in String comparisons | 189 |
| Violation | Line |
|---|---|
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 81 |
| If you run in Java5 or newer and have concurrent access, you should use the ConcurrentHashMap implementation | 131 |
